struct Artifact {
eye: vec4<f32>,
target_: vec4<f32>,
place: vec4<f32>,
screen: vec2<f32>,
lens: f32,
time: f32,
light: f32,
rays: u32,
columns: u32,
}

struct Uniforms_quad_artifact {
screen: vec2<f32>,
rect: vec4<f32>,
look: Artifact,
}

struct Vertex_io {
@builtin(position) v0_: vec4<f32>,
@location(0) v1_: vec2<f32>,
@location(1) v2_: vec2<f32>,
}

struct VertexIndex {
index: u32,
}

struct ClipPosition {
position: vec4<f32>,
}

struct Vertex {
position: ClipPosition,
uv: vec2<f32>,
pixel: vec2<f32>,
}

struct Hit {
at: f32,
normal: vec3<f32>,
depth: f32,
cover: f32,
strut: f32,
}

struct artifact_out {
@location(0) color0_: vec4<f32>,
}

struct FragCoord {
position: vec4<f32>,
}

struct f32_f32_f32_ {
a: f32,
b: f32,
c: f32,
}

@group(0) @binding(1) 
var<storage> struts: array<vec4<f32>>;
@group(0) @binding(2) 
var<storage> panes: array<vec4<f32>>;
@group(0) @binding(3) 
var<storage> tiles: array<vec4<u32>>;
@group(0) @binding(0) 
var<uniform> u: Uniforms_quad_artifact;

@vertex 
fn quad(@builtin(vertex_index) input0_: u32) -> Vertex_io {
var corners: array<vec2<f32>, 6>;

let v0_ = VertexIndex(input0_);
let _e5 = vec2<f32>(1f, 0f);
let _e6 = vec2<f32>(0f, 1f);
corners = array<vec2<f32>, 6>(vec2<f32>(0f, 0f), _e5, _e6, _e6, _e5, vec2<f32>(1f, 1f));
let v21_ = corners[v0_.index];
let v22_ = u.rect;
let v24_ = u.rect;
let _e23 = (v22_.xy + (v24_.zw * v21_));
let v30_ = u.screen.x;
let v37_ = u.screen.y;
let _e43 = Vertex(ClipPosition(vec4<f32>((((_e23.x / v30_) * 2f) - 1f), (1f - ((_e23.y / v37_) * 2f)), 0f, 1f)), v21_, _e23);
return Vertex_io(_e43.position.position, _e43.uv, _e43.pixel);
}

@fragment 
fn artifact(@builtin(position) input0_1: vec4<f32>) -> artifact_out {
var logic: bool;
var logic_1: bool;
var offsets: array<vec2<f32>, 4>;
var c: vec3<f32>;
var counter: u32;
var logic_2: bool;
var if_: u32;
var ro: vec3<f32>;
var metal: f32;
var gathered: vec3<f32>;
var through: vec3<f32>;
var skip: f32;
var past: f32;
var cone: vec2<f32>;
var counter_1: u32;
var n: vec3<f32>;
var mirrored: vec3<f32>;
var if_1: Hit;
var hit: Hit;
var left: u32;
var logic_3: bool;
var if_2: f32;
var if_3: vec4<f32>;
var logic_4: bool;
var normal: vec3<f32>;
var logic_5: bool;
var best: vec4<f32>;
var logic_6: bool;
var done: bool;
var result: vec4<f32>;
var best_1: f32;
var which: f32;
var left_1: u32;
var logic_7: bool;
var logic_8: bool;
var logic_9: bool;
var done_1: bool;
var result_1: f32;
var done_2: bool;
var result_2: f32;
var done_3: bool;
var result_3: f32;
var done_4: bool;
var result_4: f32;
var done_5: bool;
var result_5: f32;
var done_6: bool;
var result_6: f32;
var done_7: bool;
var result_7: f32;
var done_8: bool;
var result_8: f32;
var done_9: bool;
var result_9: f32;
var done_10: bool;
var result_10: f32;
var done_11: bool;
var result_11: f32;
var done_12: bool;
var result_12: f32;
var done_13: bool;
var result_13: f32;
var done_14: bool;
var result_14: f32;
var done_15: bool;
var result_15: f32;
var done_16: bool;
var result_16: f32;
var done_17: bool;
var result_17: f32;
var done_18: bool;
var result_18: f32;
var done_19: bool;
var result_19: f32;
var done_20: bool;
var result_20: f32;
var done_21: bool;
var result_21: f32;
var hit_1: Hit;
var left_2: u32;
var logic_10: bool;
var if_4: f32;
var if_5: vec4<f32>;
var logic_11: bool;
var normal_1: vec3<f32>;
var logic_12: bool;
var best_2: vec4<f32>;
var logic_13: bool;
var done_22: bool;
var result_22: vec4<f32>;
var done_23: bool;
var result_23: f32;
var done_24: bool;
var result_24: f32;
var done_25: bool;
var result_25: f32;
var done_26: bool;
var result_26: f32;
var done_27: bool;
var result_27: f32;
var result_28: vec4<f32>;
var left_3: bool;
var ro_1: vec3<f32>;
var metal_1: f32;
var gathered_1: vec3<f32>;
var through_1: vec3<f32>;
var skip_1: f32;
var past_1: f32;
var cone_1: vec2<f32>;
var counter_2: u32;
var n_1: vec3<f32>;
var mirrored_1: vec3<f32>;
var if_6: Hit;
var hit_2: Hit;
var left_4: u32;
var logic_14: bool;
var if_7: f32;
var if_8: vec4<f32>;
var logic_15: bool;
var normal_2: vec3<f32>;
var logic_16: bool;
var best_3: vec4<f32>;
var logic_17: bool;
var done_28: bool;
var result_29: vec4<f32>;
var best_4: f32;
var which_1: f32;
var left_5: u32;
var logic_18: bool;
var logic_19: bool;
var logic_20: bool;
var done_29: bool;
var result_30: f32;
var done_30: bool;
var result_31: f32;
var done_31: bool;
var result_32: f32;
var done_32: bool;
var result_33: f32;
var done_33: bool;
var result_34: f32;
var done_34: bool;
var result_35: f32;
var done_35: bool;
var result_36: f32;
var done_36: bool;
var result_37: f32;
var done_37: bool;
var result_38: f32;
var done_38: bool;
var result_39: f32;
var done_39: bool;
var result_40: f32;
var done_40: bool;
var result_41: f32;
var done_41: bool;
var result_42: f32;
var done_42: bool;
var result_43: f32;
var done_43: bool;
var result_44: f32;
var done_44: bool;
var result_45: f32;
var done_45: bool;
var result_46: f32;
var done_46: bool;
var result_47: f32;
var done_47: bool;
var result_48: f32;
var done_48: bool;
var result_49: f32;
var done_49: bool;
var result_50: f32;
var hit_3: Hit;
var left_6: u32;
var logic_21: bool;
var if_9: f32;
var if_10: vec4<f32>;
var logic_22: bool;
var normal_3: vec3<f32>;
var logic_23: bool;
var best_5: vec4<f32>;
var logic_24: bool;
var done_50: bool;
var result_51: vec4<f32>;
var done_51: bool;
var result_52: f32;
var done_52: bool;
var result_53: f32;
var done_53: bool;
var result_54: f32;
var done_54: bool;
var result_55: f32;
var done_55: bool;
var result_56: f32;
var result_57: vec4<f32>;
var left_7: bool;
var local: f32;
var local_1: vec2<u32>;
var local_2: f32;
var local_3: vec3<f32>;
var local_4: vec3<f32>;
var local_5: vec3<f32>;
var local_6: vec3<f32>;
var local_7: vec3<f32>;
var local_8: f32;
var local_9: vec3<f32>;
var local_10: vec3<f32>;
var local_11: vec3<f32>;
var local_12: vec3<f32>;
var local_13: vec3<f32>;
var local_14: f32;
var local_15: f32;
var local_16: f32;
var local_17: f32;
var local_18: f32;
var local_19: vec3<f32>;
var local_20: vec3<f32>;
var local_21: vec3<f32>;
var local_22: vec3<f32>;
var local_23: vec3<f32>;
var local_24: f32;
var local_25: vec3<f32>;
var local_26: vec3<f32>;
var local_27: vec3<f32>;
var local_28: vec3<f32>;
var local_29: vec3<f32>;
var local_30: f32;
var local_31: f32;
var local_32: f32;
var local_33: f32;

let v0_1 = FragCoord(input0_1);
let v1_ = u.look.eye;
let _e6 = v1_.xyz;
let v3_ = u.look.place.w;
local = 0.022f;
let _e15 = local;
let _e19 = (v3_ * (1.7f + (_e15 * 2.4f)));
let _e21 = v0_1.position.xy;
let v159_ = u.look.target_;
let v161_ = u.look.eye;
let _e33 = normalize((v159_.xyz - v161_.xyz));
let _e36 = vec3<f32>(0f, 1f, 0f);
let _e38 = normalize(cross(_e33, _e36));
let v176_ = u.look.screen;
let _e46 = vec2(2f);
let _e48 = vec2(1f);
let _e49 = (((_e21 / v176_) * _e46) - _e48);
let v189_ = u.look.screen.x;
let v190_ = u.look.screen.y;
let v199_ = u.look.lens;
let _e77 = normalize((_e33 + ((((_e38 * vec3(_e49.x)) * vec3((v189_ / v190_))) - (cross(_e38, _e33) * vec3(_e49.y))) * vec3(v199_))));
let v15_ = u.look.place;
let _e83 = (_e6 - v15_.xyz);
let _e84 = dot(_e83, _e77);
let v21_1 = u.look.place.w;
let _e91 = (v21_1 <= 0.001f);
logic = _e91;
let v7592_ = logic;
logic = select(v7592_, ((((_e84 * _e84) - dot(_e83, _e83)) + (_e19 * _e19)) <= 0f), !(_e91));
let v38_ = logic;
if v38_ {
let v41_ = u.look.light;
let _e129 = ((vec3<f32>(0.004f, 0.0042f, 0.0052f) + (vec3<f32>(0.012f, 0.012f, 0.013f) * vec3(exp((-(abs((_e77.y + 0.05f))) * 6f))))) * vec3(v41_));
return artifact_out(vec4<f32>(_e129.x, _e129.y, _e129.z, 1f));
}
let v49_ = u.look.lens;
let v52_ = u.look.screen.y;
let _e145 = ((2f * v49_) / v52_);
let v54_ = u.look.place.w;
let _e154 = ((0.022f * v54_) / (_e145 * length(_e83)));
let _e156 = (_e154 < 2.5f);
logic_2 = _e156;
let v226_ = u.look.rays;
let v7594_ = logic_2;
logic_2 = select(v7594_, (v226_ >= 4u), _e156);
let v229_ = logic_2;
if_ = select(1u, 4u, v229_);
let v232_ = if_;
let _e179 = saturate(((4f - _e154) / 1.5f));
local_1 = vec2(16u);
let _e184 = local_1;
let _e185 = (vec2<u32>(_e21) / _e184);
let v74_ = u.look.columns;
let _e193 = ((_e185.y * v74_) + _e185.x);
ro = _e6;
metal = 0f;
let _e196 = vec3(0f);
gathered = _e196;
let _e198 = vec3(1f);
through = _e198;
skip = -1f;
past = -1f;
cone = vec2<f32>(0f, _e145);
let v253_ = u.look.place.w;
counter_1 = 0u;
left_3 = false;
loop {
let v258_ = counter_1;
if (v258_ >= 4u) {
break;
}
let v262_ = ro;
let v264_ = cone;
let v265_ = past;
let _e225 = Hit(1000000000f, _e196, 0f, 0f, -1f);
hit = _e225;
let v274_ = tiles[_e193].x;
left = v274_;
loop {
let v275_ = left;
if !((v275_ != 0u)) {
break;
}
let v279_ = left;
let _e238 = countTrailingZeros(v279_);
let v281_ = left;
let v282_ = left;
left = (v281_ & (v282_ - 1u));
let _e246 = f32(_e238);
if (_e246 == v265_) {
continue;
}
let _e249 = (_e238 * 3u);
let _e250 = (_e249 + 1u);
let _e252 = (_e249 + 2u);
let v306_ = struts[_e249].w;
let v307_ = struts[_e250].w;
let v308_ = struts[_e252].z;
let _e265 = f32_f32_f32_(v306_, v307_, v308_);
let v313_ = struts[_e250];
let v315_ = struts[_e249];
let _e277 = (v313_.xyz - v315_.xyz);
let v318_ = struts[_e249];
let v320_ = struts[_e250];
let _e290 = (((v318_.xyz + v320_.xyz) * vec3(0.5f)) - v262_);
let _e291 = dot(_e290, _e77);
let _e300 = (((_e265.c + max(_e265.a, _e265.b)) + v264_.x) + (v264_.y * max((_e291 + _e265.c), 0f)));
let _e305 = ((dot(_e290, _e290) - (_e291 * _e291)) > (_e300 * _e300));
logic_3 = _e305;
let v7597_ = logic_3;
logic_3 = select(v7597_, (_e291 < -(_e300)), !(_e305));
let v362_ = logic_3;
if v362_ {
continue;
}
let v364_ = struts[_e249];
let _e320 = (v262_ - v364_.xyz);
let _e321 = dot(_e277, _e277);
let _e322 = dot(_e277, _e77);
let _e323 = dot(_e77, _e320);
let _e325 = (_e321 - (_e322 * _e322));
if_2 = select(0.5f, saturate(((dot(_e277, _e320) - (_e323 * _e322)) / _e325)), (_e325 > 0.000001f));
let v395_ = if_2;
let _e339 = max(((v395_ * _e322) - _e323), 0f);
let _e342 = (_e320 + (_e77 * vec3(_e339)));
let _e345 = saturate((dot(_e342, _e277) / _e321));
let _e348 = (_e342 - (_e277 * vec3(_e345)));
let _e349 = length(_e348);
let _e350 = mix(_e265.a, _e265.b, _e345);
let _e352 = (v264_.x + (v264_.y * _e339));
let _e356 = saturate((0.5f - ((_e349 - _e350) / _e352)));
if (_e356 <= 0f) {
continue;
}
if (_e349 < _e350) {
let v452_ = struts[_e249];
let _e362 = v452_.xyz;
let v454_ = struts[_e250];
let _e366 = v454_.xyz;
done = false;
let _e368 = (_e366 - _e362);
let _e369 = (v262_ - _e362);
let _e370 = (v262_ - _e366);
let _e371 = (_e265.a - _e265.b);
let _e372 = dot(_e368, _e368);
let _e373 = dot(_e368, _e369);
let _e374 = dot(_e368, _e77);
let _e375 = dot(_e77, _e369);
let _e376 = dot(_e369, _e369);
let _e377 = dot(_e370, _e77);
let _e380 = (_e372 - (_e371 * _e371));
let _e382 = (_e380 - (_e374 * _e374));
let _e388 = (((_e380 * _e375) - (_e373 * _e374)) + ((_e374 * _e371) * _e265.a));
let _e401 = ((_e388 * _e388) - (((((_e380 * _e376) - (_e373 * _e373)) + (((_e373 * _e371) * _e265.a) * 2f)) - ((_e372 * _e265.a) * _e265.a)) * _e382));
let _e402 = (_e401 < 0f);
let _e403 = vec4(-1f);
let v7600_ = result;
result = select(v7600_, _e403, _e402);
let v7602_ = done;
done = select(v7602_, true, _e402);
let v549_ = done;
if v549_ {
} else {
let _e418 = ((-(sqrt(_e401)) - _e388) / _e382);
let _e422 = ((_e373 - (_e265.a * _e371)) + (_e418 * _e374));
let _e423 = (_e422 > 0f);
logic_5 = _e423;
let v7604_ = logic_5;
logic_5 = select(v7604_, (_e422 < _e380), _e423);
let v572_ = logic_5;
let _e440 = normalize((((_e369 + (_e77 * vec3(_e418))) * vec3(_e380)) - (_e368 * vec3(_e422))));
let v7606_ = result;
result = select(v7606_, vec4<f32>(_e418, _e440.x, _e440.y, _e440.z), v572_);
let v7608_ = done;
done = select(v7608_, true, v572_);
let v594_ = done;
if v594_ {
} else {
let _e458 = (((_e375 * _e375) - _e376) + (_e265.a * _e265.a));
let _e462 = (((_e377 * _e377) - dot(_e370, _e370)) + (_e265.b * _e265.b));
best = _e403;
let _e467 = (-(_e375) - sqrt(_e458));
let _e472 = ((_e369 + (_e77 * vec3(_e467))) / vec3(_e265.a));
let v7610_ = best;
best = select(v7610_, vec4<f32>(_e467, _e472.x, _e472.y, _e472.z), (_e458 > 0f));
if (_e462 > 0f) {
let _e484 = (-(_e377) - sqrt(_e462));
let v645_ = best.x;
let _e488 = (v645_ < 0f);
logic_6 = _e488;
let v650_ = best.x;
let v7612_ = logic_6;
logic_6 = select(v7612_, (_e484 < v650_), !(_e488));
let v652_ = logic_6;
let _e505 = ((_e370 + (_e77 * vec3(_e484))) / vec3(_e265.b));
let v7614_ = best;
best = select(v7614_, vec4<f32>(_e484, _e505.x, _e505.y, _e505.z), v652_);
}
let v667_ = best;
result = v667_;
done = true;
}
}
let v669_ = result;
if_3 = v669_;
} else {
let _e523 = (_e348 / vec3(max(_e349, 0.000001f)));
if_3 = vec4<f32>(_e339, _e523.x, _e523.y, _e523.z);
}
let v681_ = if_3;
let _e533 = (v681_.x > 0.0001f);
logic_4 = _e533;
let v687_ = hit.at;
let v7616_ = logic_4;
logic_4 = select(v7616_, (v681_.x < v687_), _e533);
let v689_ = logic_4;
if v689_ {
let v697_ = struts[_e249];
normal = v681_.yzw;
let _e558 = (_e352 * 0.5f);
if ((_e349 + _e558) > _e350) {
let _e566 = clamp(((max((_e349 - _e558), -(_e350)) + _e350) * 0.5f), 0f, _e350);
let _e569 = (_e277 / vec3(sqrt(_e321)));
normal = normalize((((_e348 / vec3(max(_e349, 0.000001f))) * vec3(_e566)) + (normalize(((_e77 * vec3(-1f)) + (_e569 * vec3(dot(_e77, _e569))))) * vec3(sqrt(((_e350 * _e350) - (_e566 * _e566)))))));
}
let v769_ = normal;
let v770_ = struts[_e252].x;
let v771_ = struts[_e252].y;
hit = Hit(v681_.x, v769_, mix(v770_, v771_, saturate((dot(((v262_ + (_e77 * vec3(v681_.x))) - v697_.xyz), _e277) / _e321))), _e356, _e246);
}
}
let v778_ = hit;
local_2 = 1.2f;
let _e608 = local_2;
let _e612 = ((0.022f * v253_) * min((1.2f / (_e608 - -1f)), 2.4f));
let v791_ = ro;
let v793_ = skip;
best_1 = 1000000000f;
which = -1f;
let v797_ = tiles[_e193].y;
left_1 = v797_;
loop {
let v798_ = left_1;
if !((v798_ != 0u)) {
break;
}
let v802_ = left_1;
let _e630 = countTrailingZeros(v802_);
let v804_ = left_1;
let v805_ = left_1;
left_1 = (v804_ & (v805_ - 1u));
let _e638 = f32(_e630);
if (_e638 == v793_) {
continue;
}
let _e641 = (_e630 * 6u);
let _e643 = (_e641 + 5u);
let v819_ = panes[_e643];
let _e648 = (v819_.xyz - v791_);
let _e649 = dot(_e648, _e77);
let v833_ = panes[_e643].w;
let v834_ = panes[_e643].w;
let _e662 = ((dot(_e648, _e648) - (_e649 * _e649)) > (v833_ * v834_));
logic_7 = _e662;
if !(_e662) {
let v839_ = panes[_e643].w;
logic_7 = (_e649 < -(v839_));
}
let v842_ = logic_7;
if v842_ {
continue;
}
done_1 = false;
let v854_ = panes[_e641];
let _e679 = dot(_e77, v854_.xyz);
let _e682 = (abs(_e679) < 0.000001f);
let v7618_ = result_1;
result_1 = select(v7618_, -1f, _e682);
let v7620_ = done_1;
done_1 = select(v7620_, true, _e682);
let v863_ = done_1;
if v863_ {
} else {
let v864_ = panes[_e641].w;
let v866_ = panes[_e641];
let _e704 = ((v864_ - dot(v791_, v866_.xyz)) / _e679);
let _e705 = (_e704 <= 0f);
let v7622_ = result_1;
result_1 = select(v7622_, -1f, _e705);
let v7624_ = done_1;
done_1 = select(v7624_, true, _e705);
let v877_ = done_1;
if v877_ {
} else {
let _e718 = (v791_ + (_e77 * vec3(_e704)));
let _e719 = (_e641 + 1u);
let v888_ = panes[_e719];
let v894_ = panes[_e719].w;
let _e729 = (dot(_e718, v888_.xyz) - v894_);
let _e731 = (_e641 + 2u);
let v900_ = panes[_e731];
let v906_ = panes[_e731].w;
let _e741 = (dot(_e718, v900_.xyz) - v906_);
let _e743 = (_e641 + 3u);
let v912_ = panes[_e743];
let v918_ = panes[_e743].w;
let _e753 = (dot(_e718, v912_.xyz) - v918_);
let _e754 = (_e641 + 4u);
let v924_ = panes[_e754];
let v930_ = panes[_e754].w;
let _e764 = (dot(_e718, v924_.xyz) - v930_);
let _e768 = (min(min(_e729, _e741), min(_e753, _e764)) >= _e612);
logic_9 = _e768;
let v7626_ = logic_9;
logic_9 = select(v7626_, (max(max(_e729, _e741), max(_e753, _e764)) <= -(_e612)), !(_e768));
let v952_ = logic_9;
let v7628_ = result_1;
result_1 = select(v7628_, _e704, v952_);
let v7630_ = done_1;
done_1 = select(v7630_, true, v952_);
let v955_ = done_1;
let v7632_ = result_1;
result_1 = select(-1f, v7632_, v955_);
let v7634_ = done_1;
done_1 = select(true, v7634_, v955_);
}
}
let v958_ = result_1;
let _e803 = (v958_ > 0.0002f);
logic_8 = _e803;
let v963_ = best_1;
let v7636_ = logic_8;
logic_8 = select(v7636_, (v958_ < v963_), _e803);
let v965_ = logic_8;
let v7638_ = best_1;
best_1 = select(v7638_, v958_, v965_);
let v7640_ = which;
which = select(v7640_, _e638, v965_);
}
let v969_ = best_1;
let v970_ = which;
let _e826 = vec2<f32>(v969_, v970_);
if (v778_.at < _e826.x) {
metal = 1f;
let _e844 = mix(vec3<f32>(0.5f, 0.51f, 0.53f), vec3<f32>(0.08f, 0.082f, 0.088f), vec3(smoothstep(-0.5f, 0.5f, v778_.depth)));
let _e845 = dot(_e77, v778_.normal);
let _e855 = vec3(0.25f);
let _e861 = (_e77 - (v778_.normal * vec3((2f * _e845))));
local_3 = vec3<f32>(-0.35f, 0.9f, 0.35f);
let _e867 = local_3;
let _e868 = normalize(_e867);
done_2 = false;
let _e873 = dot(_e861, _e868);
let _e874 = (_e873 <= 0f);
let v7642_ = result_2;
result_2 = select(v7642_, 0f, _e874);
let v7644_ = done_2;
done_2 = select(v7644_, true, _e874);
let v1052_ = done_2;
if v1052_ {
} else {
let _e887 = normalize(cross(_e868, _e36));
let _e895 = (abs((vec2<f32>(dot(_e861, _e887), dot(_e861, cross(_e887, _e868))) / vec2(_e873))) - vec2<f32>(0.6f, 0.32f));
result_2 = saturate((1f - (max(_e895.x, _e895.y) / 0.35f)));
done_2 = true;
}
let v1086_ = result_2;
local_4 = vec3<f32>(-0.92f, 0.12f, -0.38f);
let _e911 = local_4;
let _e912 = normalize(_e911);
done_3 = false;
let _e918 = dot(_e861, _e912);
let _e919 = (_e918 <= 0f);
let v7646_ = result_3;
result_3 = select(v7646_, 0f, _e919);
let v7648_ = done_3;
done_3 = select(v7648_, true, _e919);
let v1106_ = done_3;
if v1106_ {
} else {
let _e931 = normalize(cross(_e912, _e36));
let _e939 = (abs((vec2<f32>(dot(_e861, _e931), dot(_e861, cross(_e931, _e912))) / vec2(_e918))) - vec2<f32>(0.16f, 0.95f));
result_3 = saturate((1f - (max(_e939.x, _e939.y) / 0.3f)));
done_3 = true;
}
let v1140_ = result_3;
local_5 = vec3<f32>(0.9f, 0.18f, -0.4f);
let _e954 = local_5;
let _e955 = normalize(_e954);
done_4 = false;
let _e959 = dot(_e861, _e955);
let _e960 = (_e959 <= 0f);
let v7650_ = result_4;
result_4 = select(v7650_, 0f, _e960);
let v7652_ = done_4;
done_4 = select(v7652_, true, _e960);
let v1160_ = done_4;
if v1160_ {
} else {
let _e972 = normalize(cross(_e955, _e36));
let _e980 = (abs((vec2<f32>(dot(_e861, _e972), dot(_e861, cross(_e972, _e955))) / vec2(_e959))) - vec2<f32>(0.14f, 0.95f));
result_4 = saturate((1f - (max(_e980.x, _e980.y) / 0.3f)));
done_4 = true;
}
let v1194_ = result_4;
local_6 = vec3<f32>(0.6f, -0.05f, 0.8f);
let _e995 = local_6;
let _e996 = normalize(_e995);
done_5 = false;
let _e1000 = dot(_e861, _e996);
let _e1001 = (_e1000 <= 0f);
let v7654_ = result_5;
result_5 = select(v7654_, 0f, _e1001);
let v7656_ = done_5;
done_5 = select(v7656_, true, _e1001);
let v1214_ = done_5;
if v1214_ {
} else {
let _e1013 = normalize(cross(_e996, _e36));
let _e1021 = (abs((vec2<f32>(dot(_e861, _e1013), dot(_e861, cross(_e1013, _e996))) / vec2(_e1000))) - vec2<f32>(0.6f, 0.22f));
result_5 = saturate((1f - (max(_e1021.x, _e1021.y) / 0.3f)));
done_5 = true;
}
let v1248_ = result_5;
local_7 = vec3<f32>(0f, 0.25f, -1f);
let _e1034 = local_7;
let _e1035 = normalize(_e1034);
done_6 = false;
let _e1038 = dot(_e861, _e1035);
let _e1039 = (_e1038 <= 0f);
let v7658_ = result_6;
result_6 = select(v7658_, 0f, _e1039);
let v7660_ = done_6;
done_6 = select(v7660_, true, _e1039);
let v1268_ = done_6;
if v1268_ {
} else {
let _e1051 = normalize(cross(_e1035, _e36));
let _e1059 = (abs((vec2<f32>(dot(_e861, _e1051), dot(_e861, cross(_e1051, _e1035))) / vec2(_e1038))) - vec2<f32>(0.9f, 0.12f));
result_6 = saturate((1f - (max(_e1059.x, _e1059.y) / 0.25f)));
done_6 = true;
}
let v1302_ = result_6;
let _e1072 = vec3<f32>(1f, 0.99f, 0.98f);
let _e1079 = vec3<f32>(0.9f, 0.94f, 1f);
let _e1088 = vec3<f32>(0.95f, 0.95f, 1f);
let _e1096 = vec3<f32>(0.95f, 0.96f, 1f);
let _e1110 = vec3(0.04f);
local_8 = -0.6f;
let _e1114 = local_8;
let _e1118 = ((vec3(0.095f) * vec3(smoothstep(-0.25f, 0.9f, _e861.y))) + (_e1110 * vec3(smoothstep(0.1f, _e1114, _e861.y))));
let _e1120 = saturate(_e873);
let v1525_ = u.look.time;
let v1542_ = through;
let v1548_ = gathered;
let _e1188 = (v1548_ + ((v1542_ * (((mix((((((((_e1072 * vec3(v1086_)) * vec3(1.8f)) + (_e1079 * vec3(((v1140_ * 1.3f) + (v1194_ * 1.1f))))) + ((_e1088 * vec3(v1248_)) * vec3(0.45f))) + ((_e1096 * vec3(v1302_)) * vec3(0.6f))) + _e1118) + vec3((pow(_e1120, 12f) * 0.5f))), ((((((_e1072 * vec3(pow(_e1120, 3f))) * _e198) + (_e1079 * vec3(((pow(saturate(_e918), 4f) * 0.45f) + (pow(saturate(_e959), 4f) * 0.4f))))) + ((_e1088 * vec3(pow(saturate(_e1000), 2f))) * _e855)) + ((_e1096 * vec3(pow(saturate(_e1038), 3f))) * _e855)) + _e1118), vec3(_e179)) * (_e844 + (((_e198 - _e844) * vec3(pow((1f - saturate(-(_e845))), 5f))) * _e855))) + (_e844 * _e1110)) + ((_e844 + vec3(0.1f)) * vec3((pow(saturate(((sin(((v778_.depth * 2.4f) + (v1525_ * 0.8f))) * 0.5f) + 0.5f)), 30f) * 0.55f))))) * vec3(v778_.cover)));
gathered = _e1188;
if (v778_.cover >= 1f) {
result_28 = vec4<f32>(_e1188.x, _e1188.y, _e1188.z, 1f);
left_3 = true;
break;
}
let v1563_ = through;
through = (v1563_ * vec3((1f - v778_.cover)));
past = v778_.strut;
continue;
}
past = -1f;
if (_e826.y >= 0f) {
let v1571_ = ro;
let _e1212 = (v1571_ + (_e77 * vec3(_e826.x)));
let v1581_ = panes[(u32(_e826.y) * 6u)];
let _e1219 = v1581_.xyz;
n = _e1219;
let v7662_ = n;
n = select(v7662_, -(_e1219), (dot(_e1219, _e77) > 0f));
let v1591_ = u.look.place;
let v1594_ = n;
let v1598_ = u.look.place.w;
let _e1242 = ((_e1212 - v1591_.xyz) / vec3(v1598_));
let v1607_ = u.look.time;
let v1618_ = u.look.time;
let v1629_ = u.look.time;
let _e1279 = vec3<f32>(sin((dot(_e1242, vec3<f32>(2.3f, 1.7f, -1.1f)) + (v1607_ * 0.6f))), sin((dot(_e1242, vec3<f32>(-1.5f, 2.6f, 1.9f)) + (v1618_ * 0.5f))), sin((dot(_e1242, vec3<f32>(2f, -1.3f, 2.4f)) - (v1629_ * 0.7f))));
let _e1288 = normalize((v1594_ + ((_e1279 - (v1594_ * vec3(dot(_e1279, v1594_)))) * vec3(0.16f))));
let _e1289 = dot(_e77, _e1288);
let v1662_ = cone.x;
let v1663_ = cone.y;
let v1667_ = cone.y;
let _e1310 = vec2<f32>((v1662_ + (v1663_ * _e826.x)), v1667_);
let _e1314 = (_e77 - (_e1288 * vec3((2f * _e1289))));
let v1680_ = n;
let _e1320 = ((_e1288 - v1680_) * vec3(0.05f));
let _e1322 = normalize((_e1314 - _e1320));
local_9 = vec3<f32>(-0.35f, 0.9f, 0.35f);
let _e1328 = local_9;
let _e1329 = normalize(_e1328);
let _e1331 = vec2<f32>(0.6f, 0.32f);
done_7 = false;
let _e1333 = dot(_e1322, _e1329);
let _e1334 = (_e1333 <= 0f);
let v7664_ = result_7;
result_7 = select(v7664_, 0f, _e1334);
let v7666_ = done_7;
done_7 = select(v7666_, true, _e1334);
let v1708_ = done_7;
if v1708_ {
} else {
let _e1347 = normalize(cross(_e1329, _e36));
let _e1355 = (abs((vec2<f32>(dot(_e1322, _e1347), dot(_e1322, cross(_e1347, _e1329))) / vec2(_e1333))) - _e1331);
result_7 = saturate((1f - (max(_e1355.x, _e1355.y) / 0.35f)));
done_7 = true;
}
let v1742_ = result_7;
local_10 = vec3<f32>(-0.92f, 0.12f, -0.38f);
let _e1371 = local_10;
let _e1372 = normalize(_e1371);
let _e1374 = vec2<f32>(0.16f, 0.95f);
done_8 = false;
let _e1377 = dot(_e1322, _e1372);
let _e1378 = (_e1377 <= 0f);
let v7668_ = result_8;
result_8 = select(v7668_, 0f, _e1378);
let v7670_ = done_8;
done_8 = select(v7670_, true, _e1378);
let v1762_ = done_8;
if v1762_ {
} else {
let _e1390 = normalize(cross(_e1372, _e36));
let _e1398 = (abs((vec2<f32>(dot(_e1322, _e1390), dot(_e1322, cross(_e1390, _e1372))) / vec2(_e1377))) - _e1374);
result_8 = saturate((1f - (max(_e1398.x, _e1398.y) / 0.3f)));
done_8 = true;
}
let v1796_ = result_8;
local_11 = vec3<f32>(0.9f, 0.18f, -0.4f);
let _e1413 = local_11;
let _e1414 = normalize(_e1413);
let _e1416 = vec2<f32>(0.14f, 0.95f);
done_9 = false;
let _e1418 = dot(_e1322, _e1414);
let _e1419 = (_e1418 <= 0f);
let v7672_ = result_9;
result_9 = select(v7672_, 0f, _e1419);
let v7674_ = done_9;
done_9 = select(v7674_, true, _e1419);
let v1816_ = done_9;
if v1816_ {
} else {
let _e1431 = normalize(cross(_e1414, _e36));
let _e1439 = (abs((vec2<f32>(dot(_e1322, _e1431), dot(_e1322, cross(_e1431, _e1414))) / vec2(_e1418))) - _e1416);
result_9 = saturate((1f - (max(_e1439.x, _e1439.y) / 0.3f)));
done_9 = true;
}
let v1850_ = result_9;
local_12 = vec3<f32>(0.6f, -0.05f, 0.8f);
let _e1454 = local_12;
let _e1455 = normalize(_e1454);
let _e1457 = vec2<f32>(0.6f, 0.22f);
done_10 = false;
let _e1459 = dot(_e1322, _e1455);
let _e1460 = (_e1459 <= 0f);
let v7676_ = result_10;
result_10 = select(v7676_, 0f, _e1460);
let v7678_ = done_10;
done_10 = select(v7678_, true, _e1460);
let v1870_ = done_10;
if v1870_ {
} else {
let _e1472 = normalize(cross(_e1455, _e36));
let _e1480 = (abs((vec2<f32>(dot(_e1322, _e1472), dot(_e1322, cross(_e1472, _e1455))) / vec2(_e1459))) - _e1457);
result_10 = saturate((1f - (max(_e1480.x, _e1480.y) / 0.3f)));
done_10 = true;
}
let v1904_ = result_10;
local_13 = vec3<f32>(0f, 0.25f, -1f);
let _e1494 = local_13;
let _e1495 = normalize(_e1494);
let _e1496 = vec2<f32>(0.9f, 0.12f);
done_11 = false;
let _e1498 = dot(_e1322, _e1495);
let _e1499 = (_e1498 <= 0f);
let v7680_ = result_11;
result_11 = select(v7680_, 0f, _e1499);
let v7682_ = done_11;
done_11 = select(v7682_, true, _e1499);
let v1924_ = done_11;
if v1924_ {
} else {
let _e1511 = normalize(cross(_e1495, _e36));
let _e1519 = (abs((vec2<f32>(dot(_e1322, _e1511), dot(_e1322, cross(_e1511, _e1495))) / vec2(_e1498))) - _e1496);
result_11 = saturate((1f - (max(_e1519.x, _e1519.y) / 0.25f)));
done_11 = true;
}
let v1958_ = result_11;
let _e1532 = vec3<f32>(1f, 0.99f, 0.98f);
let _e1536 = vec3(1.8f);
let _e1539 = vec3<f32>(0.9f, 0.94f, 1f);
let _e1548 = vec3<f32>(0.95f, 0.95f, 1f);
let _e1552 = vec3(0.45f);
let _e1555 = vec3<f32>(0.95f, 0.96f, 1f);
let _e1558 = vec3(0.6f);
let _e1562 = vec3(0.095f);
let _e1568 = vec3(0.04f);
local_14 = -0.6f;
let _e1572 = local_14;
done_12 = false;
let _e1580 = dot(_e1314, _e1329);
let _e1581 = (_e1580 <= 0f);
let v7684_ = result_12;
result_12 = select(v7684_, 0f, _e1581);
let v7686_ = done_12;
done_12 = select(v7686_, true, _e1581);
let v2045_ = done_12;
if v2045_ {
} else {
let _e1593 = normalize(cross(_e1329, _e36));
let _e1601 = (abs((vec2<f32>(dot(_e1314, _e1593), dot(_e1314, cross(_e1593, _e1329))) / vec2(_e1580))) - _e1331);
result_12 = saturate((1f - (max(_e1601.x, _e1601.y) / 0.35f)));
done_12 = true;
}
let v2079_ = result_12;
done_13 = false;
let _e1613 = dot(_e1314, _e1372);
let _e1614 = (_e1613 <= 0f);
let v7688_ = result_13;
result_13 = select(v7688_, 0f, _e1614);
let v7690_ = done_13;
done_13 = select(v7690_, true, _e1614);
let v2099_ = done_13;
if v2099_ {
} else {
let _e1626 = normalize(cross(_e1372, _e36));
let _e1634 = (abs((vec2<f32>(dot(_e1314, _e1626), dot(_e1314, cross(_e1626, _e1372))) / vec2(_e1613))) - _e1374);
result_13 = saturate((1f - (max(_e1634.x, _e1634.y) / 0.3f)));
done_13 = true;
}
let v2133_ = result_13;
done_14 = false;
let _e1646 = dot(_e1314, _e1414);
let _e1647 = (_e1646 <= 0f);
let v7692_ = result_14;
result_14 = select(v7692_, 0f, _e1647);
let v7694_ = done_14;
done_14 = select(v7694_, true, _e1647);
let v2153_ = done_14;
if v2153_ {
} else {
let _e1659 = normalize(cross(_e1414, _e36));
let _e1667 = (abs((vec2<f32>(dot(_e1314, _e1659), dot(_e1314, cross(_e1659, _e1414))) / vec2(_e1646))) - _e1416);
result_14 = saturate((1f - (max(_e1667.x, _e1667.y) / 0.3f)));
done_14 = true;
}
let v2187_ = result_14;
done_15 = false;
let _e1679 = dot(_e1314, _e1455);
let _e1680 = (_e1679 <= 0f);
let v7696_ = result_15;
result_15 = select(v7696_, 0f, _e1680);
let v7698_ = done_15;
done_15 = select(v7698_, true, _e1680);
let v2207_ = done_15;
if v2207_ {
} else {
let _e1692 = normalize(cross(_e1455, _e36));
let _e1700 = (abs((vec2<f32>(dot(_e1314, _e1692), dot(_e1314, cross(_e1692, _e1455))) / vec2(_e1679))) - _e1457);
result_15 = saturate((1f - (max(_e1700.x, _e1700.y) / 0.3f)));
done_15 = true;
}
let v2241_ = result_15;
done_16 = false;
let _e1712 = dot(_e1314, _e1495);
let _e1713 = (_e1712 <= 0f);
let v7700_ = result_16;
result_16 = select(v7700_, 0f, _e1713);
let v7702_ = done_16;
done_16 = select(v7702_, true, _e1713);
let v2261_ = done_16;
if v2261_ {
} else {
let _e1725 = normalize(cross(_e1495, _e36));
let _e1733 = (abs((vec2<f32>(dot(_e1314, _e1725), dot(_e1314, cross(_e1725, _e1495))) / vec2(_e1712))) - _e1496);
result_16 = saturate((1f - (max(_e1733.x, _e1733.y) / 0.25f)));
done_16 = true;
}
let v2295_ = result_16;
local_15 = -0.6f;
let _e1766 = local_15;
let _e1774 = normalize((_e1314 + _e1320));
done_17 = false;
let _e1776 = dot(_e1774, _e1329);
let _e1777 = (_e1776 <= 0f);
let v7704_ = result_17;
result_17 = select(v7704_, 0f, _e1777);
let v7706_ = done_17;
done_17 = select(v7706_, true, _e1777);
let v2388_ = done_17;
if v2388_ {
} else {
let _e1789 = normalize(cross(_e1329, _e36));
let _e1797 = (abs((vec2<f32>(dot(_e1774, _e1789), dot(_e1774, cross(_e1789, _e1329))) / vec2(_e1776))) - _e1331);
result_17 = saturate((1f - (max(_e1797.x, _e1797.y) / 0.35f)));
done_17 = true;
}
let v2422_ = result_17;
done_18 = false;
let _e1809 = dot(_e1774, _e1372);
let _e1810 = (_e1809 <= 0f);
let v7708_ = result_18;
result_18 = select(v7708_, 0f, _e1810);
let v7710_ = done_18;
done_18 = select(v7710_, true, _e1810);
let v2442_ = done_18;
if v2442_ {
} else {
let _e1822 = normalize(cross(_e1372, _e36));
let _e1830 = (abs((vec2<f32>(dot(_e1774, _e1822), dot(_e1774, cross(_e1822, _e1372))) / vec2(_e1809))) - _e1374);
result_18 = saturate((1f - (max(_e1830.x, _e1830.y) / 0.3f)));
done_18 = true;
}
let v2476_ = result_18;
done_19 = false;
let _e1842 = dot(_e1774, _e1414);
let _e1843 = (_e1842 <= 0f);
let v7712_ = result_19;
result_19 = select(v7712_, 0f, _e1843);
let v7714_ = done_19;
done_19 = select(v7714_, true, _e1843);
let v2496_ = done_19;
if v2496_ {
} else {
let _e1855 = normalize(cross(_e1414, _e36));
let _e1863 = (abs((vec2<f32>(dot(_e1774, _e1855), dot(_e1774, cross(_e1855, _e1414))) / vec2(_e1842))) - _e1416);
result_19 = saturate((1f - (max(_e1863.x, _e1863.y) / 0.3f)));
done_19 = true;
}
let v2530_ = result_19;
done_20 = false;
let _e1875 = dot(_e1774, _e1455);
let _e1876 = (_e1875 <= 0f);
let v7716_ = result_20;
result_20 = select(v7716_, 0f, _e1876);
let v7718_ = done_20;
done_20 = select(v7718_, true, _e1876);
let v2550_ = done_20;
if v2550_ {
} else {
let _e1888 = normalize(cross(_e1455, _e36));
let _e1896 = (abs((vec2<f32>(dot(_e1774, _e1888), dot(_e1774, cross(_e1888, _e1455))) / vec2(_e1875))) - _e1457);
result_20 = saturate((1f - (max(_e1896.x, _e1896.y) / 0.3f)));
done_20 = true;
}
let v2584_ = result_20;
done_21 = false;
let _e1908 = dot(_e1774, _e1495);
let _e1909 = (_e1908 <= 0f);
let v7720_ = result_21;
result_21 = select(v7720_, 0f, _e1909);
let v7722_ = done_21;
done_21 = select(v7722_, true, _e1909);
let v2604_ = done_21;
if v2604_ {
} else {
let _e1921 = normalize(cross(_e1495, _e36));
let _e1929 = (abs((vec2<f32>(dot(_e1774, _e1921), dot(_e1774, cross(_e1921, _e1495))) / vec2(_e1908))) - _e1496);
result_21 = saturate((1f - (max(_e1929.x, _e1929.y) / 0.25f)));
done_21 = true;
}
let v2638_ = result_21;
local_16 = -0.6f;
let _e1962 = local_16;
let _e1969 = vec3<f32>(((((((_e1532 * vec3(v1742_)) * _e1536) + (_e1539 * vec3(((v1796_ * 1.3f) + (v1850_ * 1.1f))))) + ((_e1548 * vec3(v1904_)) * _e1552)) + ((_e1555 * vec3(v1958_)) * _e1558)) + ((_e1562 * vec3(smoothstep(-0.25f, 0.9f, _e1322.y))) + (_e1568 * vec3(smoothstep(0.1f, _e1572, _e1322.y))))).x, ((((((_e1532 * vec3(v2079_)) * _e1536) + (_e1539 * vec3(((v2133_ * 1.3f) + (v2187_ * 1.1f))))) + ((_e1548 * vec3(v2241_)) * _e1552)) + ((_e1555 * vec3(v2295_)) * _e1558)) + ((_e1562 * vec3(smoothstep(-0.25f, 0.9f, _e1314.y))) + (_e1568 * vec3(smoothstep(0.1f, _e1766, _e1314.y))))).y, ((((((_e1532 * vec3(v2422_)) * _e1536) + (_e1539 * vec3(((v2476_ * 1.3f) + (v2530_ * 1.1f))))) + ((_e1548 * vec3(v2584_)) * _e1552)) + ((_e1555 * vec3(v2638_)) * _e1558)) + ((_e1562 * vec3(smoothstep(-0.25f, 0.9f, _e1774.y))) + (_e1568 * vec3(smoothstep(0.1f, _e1962, _e1774.y))))).z);
mirrored = _e1969;
let v2707_ = n;
let v2709_ = n;
let _e1979 = (_e77 - (v2707_ * vec3((2f * dot(_e77, v2709_)))));
let v2716_ = skip;
if (v2716_ < 0f) {
let _e1985 = (_e1212 + (_e1979 * vec3(0.001f)));
hit_1 = _e225;
let v2736_ = tiles[_e193].z;
left_2 = v2736_;
loop {
let v2737_ = left_2;
if !((v2737_ != 0u)) {
break;
}
let v2741_ = left_2;
let _e1998 = countTrailingZeros(v2741_);
let v2743_ = left_2;
let v2744_ = left_2;
left_2 = (v2743_ & (v2744_ - 1u));
let _e2006 = f32(_e1998);
if (_e2006 == -1f) {
continue;
}
let _e2009 = (_e1998 * 3u);
let _e2010 = (_e2009 + 1u);
let _e2012 = (_e2009 + 2u);
let v2768_ = struts[_e2009].w;
let v2769_ = struts[_e2010].w;
let v2770_ = struts[_e2012].z;
let _e2025 = f32_f32_f32_(v2768_, v2769_, v2770_);
let v2775_ = struts[_e2010];
let v2777_ = struts[_e2009];
let _e2037 = (v2775_.xyz - v2777_.xyz);
let v2780_ = struts[_e2009];
let v2782_ = struts[_e2010];
let _e2049 = (((v2780_.xyz + v2782_.xyz) * vec3(0.5f)) - _e1985);
let _e2050 = dot(_e2049, _e1979);
let _e2059 = (((_e2025.c + max(_e2025.a, _e2025.b)) + _e1310.x) + (_e1310.y * max((_e2050 + _e2025.c), 0f)));
let _e2064 = ((dot(_e2049, _e2049) - (_e2050 * _e2050)) > (_e2059 * _e2059));
logic_10 = _e2064;
let v7724_ = logic_10;
logic_10 = select(v7724_, (_e2050 < -(_e2059)), !(_e2064));
let v2824_ = logic_10;
if v2824_ {
continue;
}
let v2826_ = struts[_e2009];
let _e2079 = (_e1985 - v2826_.xyz);
let _e2080 = dot(_e2037, _e2037);
let _e2081 = dot(_e2037, _e1979);
let _e2082 = dot(_e1979, _e2079);
let _e2084 = (_e2080 - (_e2081 * _e2081));
if_4 = select(0.5f, saturate(((dot(_e2037, _e2079) - (_e2082 * _e2081)) / _e2084)), (_e2084 > 0.000001f));
let v2857_ = if_4;
let _e2098 = max(((v2857_ * _e2081) - _e2082), 0f);
let _e2101 = (_e2079 + (_e1979 * vec3(_e2098)));
let _e2104 = saturate((dot(_e2101, _e2037) / _e2080));
let _e2107 = (_e2101 - (_e2037 * vec3(_e2104)));
let _e2108 = length(_e2107);
let _e2109 = mix(_e2025.a, _e2025.b, _e2104);
let _e2111 = (_e1310.x + (_e1310.y * _e2098));
let _e2115 = saturate((0.5f - ((_e2108 - _e2109) / _e2111)));
if (_e2115 <= 0f) {
continue;
}
if (_e2108 < _e2109) {
let v2914_ = struts[_e2009];
let _e2121 = v2914_.xyz;
let v2916_ = struts[_e2010];
let _e2125 = v2916_.xyz;
done_22 = false;
let _e2127 = (_e2125 - _e2121);
let _e2128 = (_e1985 - _e2121);
let _e2129 = (_e1985 - _e2125);
let _e2130 = (_e2025.a - _e2025.b);
let _e2131 = dot(_e2127, _e2127);
let _e2132 = dot(_e2127, _e2128);
let _e2133 = dot(_e2127, _e1979);
let _e2134 = dot(_e1979, _e2128);
let _e2135 = dot(_e2128, _e2128);
let _e2136 = dot(_e2129, _e1979);
let _e2139 = (_e2131 - (_e2130 * _e2130));
let _e2141 = (_e2139 - (_e2133 * _e2133));
let _e2147 = (((_e2139 * _e2134) - (_e2132 * _e2133)) + ((_e2133 * _e2130) * _e2025.a));
let _e2160 = ((_e2147 * _e2147) - (((((_e2139 * _e2135) - (_e2132 * _e2132)) + (((_e2132 * _e2130) * _e2025.a) * 2f)) - ((_e2131 * _e2025.a) * _e2025.a)) * _e2141));
let _e2161 = (_e2160 < 0f);
let _e2162 = vec4(-1f);
let v7727_ = result_22;
result_22 = select(v7727_, _e2162, _e2161);
let v7729_ = done_22;
done_22 = select(v7729_, true, _e2161);
let v3011_ = done_22;
if v3011_ {
} else {
let _e2176 = ((-(sqrt(_e2160)) - _e2147) / _e2141);
let _e2180 = ((_e2132 - (_e2025.a * _e2130)) + (_e2176 * _e2133));
let _e2181 = (_e2180 > 0f);
logic_12 = _e2181;
let v7731_ = logic_12;
logic_12 = select(v7731_, (_e2180 < _e2139), _e2181);
let v3034_ = logic_12;
let _e2198 = normalize((((_e2128 + (_e1979 * vec3(_e2176))) * vec3(_e2139)) - (_e2127 * vec3(_e2180))));
let v7733_ = result_22;
result_22 = select(v7733_, vec4<f32>(_e2176, _e2198.x, _e2198.y, _e2198.z), v3034_);
let v7735_ = done_22;
done_22 = select(v7735_, true, v3034_);
let v3056_ = done_22;
if v3056_ {
} else {
let _e2216 = (((_e2134 * _e2134) - _e2135) + (_e2025.a * _e2025.a));
let _e2220 = (((_e2136 * _e2136) - dot(_e2129, _e2129)) + (_e2025.b * _e2025.b));
best_2 = _e2162;
let _e2225 = (-(_e2134) - sqrt(_e2216));
let _e2230 = ((_e2128 + (_e1979 * vec3(_e2225))) / vec3(_e2025.a));
let v7737_ = best_2;
best_2 = select(v7737_, vec4<f32>(_e2225, _e2230.x, _e2230.y, _e2230.z), (_e2216 > 0f));
if (_e2220 > 0f) {
let _e2242 = (-(_e2136) - sqrt(_e2220));
let v3107_ = best_2.x;
let _e2246 = (v3107_ < 0f);
logic_13 = _e2246;
let v3112_ = best_2.x;
let v7739_ = logic_13;
logic_13 = select(v7739_, (_e2242 < v3112_), !(_e2246));
let v3114_ = logic_13;
let _e2263 = ((_e2129 + (_e1979 * vec3(_e2242))) / vec3(_e2025.b));
let v7741_ = best_2;
best_2 = select(v7741_, vec4<f32>(_e2242, _e2263.x, _e2263.y, _e2263.z), v3114_);
}
let v3129_ = best_2;
result_22 = v3129_;
done_22 = true;
}
}
let v3131_ = result_22;
if_5 = v3131_;
} else {
let _e2281 = (_e2107 / vec3(max(_e2108, 0.000001f)));
if_5 = vec4<f32>(_e2098, _e2281.x, _e2281.y, _e2281.z);
}
let v3143_ = if_5;
let _e2291 = (v3143_.x > 0.0001f);
logic_11 = _e2291;
let v3149_ = hit_1.at;
let v7743_ = logic_11;
logic_11 = select(v7743_, (v3143_.x < v3149_), _e2291);
let v3151_ = logic_11;
if v3151_ {
let v3159_ = struts[_e2009];
normal_1 = v3143_.yzw;
let _e2316 = (_e2111 * 0.5f);
if ((_e2108 + _e2316) > _e2109) {
let _e2324 = clamp(((max((_e2108 - _e2316), -(_e2109)) + _e2109) * 0.5f), 0f, _e2109);
let _e2327 = (_e2037 / vec3(sqrt(_e2080)));
normal_1 = normalize((((_e2107 / vec3(max(_e2108, 0.000001f))) * vec3(_e2324)) + (normalize(((_e1979 * vec3(-1f)) + (_e2327 * vec3(dot(_e1979, _e2327))))) * vec3(sqrt(((_e2109 * _e2109) - (_e2324 * _e2324)))))));
}
let v3231_ = normal_1;
let v3232_ = struts[_e2012].x;
let v3233_ = struts[_e2012].y;
hit_1 = Hit(v3143_.x, v3231_, mix(v3232_, v3233_, saturate((dot(((_e1985 + (_e1979 * vec3(v3143_.x))) - v3159_.xyz), _e2037) / _e2080))), _e2115, _e2006);
}
}
let v3240_ = hit_1;
if_1 = v3240_;
} else {
if_1 = _e225;
}
let v3248_ = if_1;
if (v3248_.at < 100000000f) {
metal = 1f;
let _e2384 = mix(vec3<f32>(0.5f, 0.51f, 0.53f), vec3<f32>(0.08f, 0.082f, 0.088f), vec3(smoothstep(-0.5f, 0.5f, v3248_.depth)));
let _e2385 = dot(_e1979, v3248_.normal);
let _e2393 = vec3(0.25f);
let _e2399 = (_e1979 - (v3248_.normal * vec3((2f * _e2385))));
done_23 = false;
let _e2401 = dot(_e2399, _e1329);
let _e2402 = (_e2401 <= 0f);
let v7745_ = result_23;
result_23 = select(v7745_, 0f, _e2402);
let v7747_ = done_23;
done_23 = select(v7747_, true, _e2402);
let v3329_ = done_23;
if v3329_ {
} else {
let _e2414 = normalize(cross(_e1329, _e36));
let _e2422 = (abs((vec2<f32>(dot(_e2399, _e2414), dot(_e2399, cross(_e2414, _e1329))) / vec2(_e2401))) - _e1331);
result_23 = saturate((1f - (max(_e2422.x, _e2422.y) / 0.35f)));
done_23 = true;
}
let v3363_ = result_23;
done_24 = false;
let _e2434 = dot(_e2399, _e1372);
let _e2435 = (_e2434 <= 0f);
let v7749_ = result_24;
result_24 = select(v7749_, 0f, _e2435);
let v7751_ = done_24;
done_24 = select(v7751_, true, _e2435);
let v3383_ = done_24;
if v3383_ {
} else {
let _e2447 = normalize(cross(_e1372, _e36));
let _e2455 = (abs((vec2<f32>(dot(_e2399, _e2447), dot(_e2399, cross(_e2447, _e1372))) / vec2(_e2434))) - _e1374);
result_24 = saturate((1f - (max(_e2455.x, _e2455.y) / 0.3f)));
done_24 = true;
}
let v3417_ = result_24;
done_25 = false;
let _e2467 = dot(_e2399, _e1414);
let _e2468 = (_e2467 <= 0f);
let v7753_ = result_25;
result_25 = select(v7753_, 0f, _e2468);
let v7755_ = done_25;
done_25 = select(v7755_, true, _e2468);
let v3437_ = done_25;
if v3437_ {
} else {
let _e2480 = normalize(cross(_e1414, _e36));
let _e2488 = (abs((vec2<f32>(dot(_e2399, _e2480), dot(_e2399, cross(_e2480, _e1414))) / vec2(_e2467))) - _e1416);
result_25 = saturate((1f - (max(_e2488.x, _e2488.y) / 0.3f)));
done_25 = true;
}
let v3471_ = result_25;
done_26 = false;
let _e2500 = dot(_e2399, _e1455);
let _e2501 = (_e2500 <= 0f);
let v7757_ = result_26;
result_26 = select(v7757_, 0f, _e2501);
let v7759_ = done_26;
done_26 = select(v7759_, true, _e2501);
let v3491_ = done_26;
if v3491_ {
} else {
let _e2513 = normalize(cross(_e1455, _e36));
let _e2521 = (abs((vec2<f32>(dot(_e2399, _e2513), dot(_e2399, cross(_e2513, _e1455))) / vec2(_e2500))) - _e1457);
result_26 = saturate((1f - (max(_e2521.x, _e2521.y) / 0.3f)));
done_26 = true;
}
let v3525_ = result_26;
done_27 = false;
let _e2533 = dot(_e2399, _e1495);
let _e2534 = (_e2533 <= 0f);
let v7761_ = result_27;
result_27 = select(v7761_, 0f, _e2534);
let v7763_ = done_27;
done_27 = select(v7763_, true, _e2534);
let v3545_ = done_27;
if v3545_ {
} else {
let _e2546 = normalize(cross(_e1495, _e36));
let _e2554 = (abs((vec2<f32>(dot(_e2399, _e2546), dot(_e2399, cross(_e2546, _e1495))) / vec2(_e2533))) - _e1496);
result_27 = saturate((1f - (max(_e2554.x, _e2554.y) / 0.25f)));
done_27 = true;
}
let v3579_ = result_27;
local_17 = -0.6f;
let _e2587 = local_17;
let _e2591 = ((_e1562 * vec3(smoothstep(-0.25f, 0.9f, _e2399.y))) + (_e1568 * vec3(smoothstep(0.1f, _e2587, _e2399.y))));
let _e2593 = saturate(_e2401);
let v3802_ = u.look.time;
mirrored = mix(_e1969, (((mix((((((((_e1532 * vec3(v3363_)) * _e1536) + (_e1539 * vec3(((v3417_ * 1.3f) + (v3471_ * 1.1f))))) + ((_e1548 * vec3(v3525_)) * _e1552)) + ((_e1555 * vec3(v3579_)) * _e1558)) + _e2591) + vec3((pow(_e2593, 12f) * 0.5f))), ((((((_e1532 * vec3(pow(_e2593, 3f))) * _e198) + (_e1539 * vec3(((pow(saturate(_e2434), 4f) * 0.45f) + (pow(saturate(_e2467), 4f) * 0.4f))))) + ((_e1548 * vec3(pow(saturate(_e2500), 2f))) * _e2393)) + ((_e1555 * vec3(pow(saturate(_e2533), 3f))) * _e2393)) + _e2591), vec3(_e179)) * (_e2384 + (((_e198 - _e2384) * vec3(pow((1f - saturate(-(_e2385))), 5f))) * _e2393))) + (_e2384 * _e1568)) + ((_e2384 + vec3(0.1f)) * vec3((pow(saturate(((sin(((v3248_.depth * 2.4f) + (v3802_ * 0.8f))) * 0.5f) + 0.5f)), 30f) * 0.55f)))), vec3(v3248_.cover));
}
let _e2660 = (0.03f + (0.55f * (0.04f + (0.96f * pow((1f - saturate(-(_e1289))), 5f)))));
let v3829_ = through;
let v3830_ = mirrored;
let v3838_ = gathered;
gathered = (v3838_ + (((v3829_ * v3830_) * vec3(_e2660)) * vec3(0.7f)));
let v3845_ = through;
through = (v3845_ * vec3(((1f - _e2660) * 0.6f)));
cone = _e1310;
ro = _e1212;
skip = _e826.y;
continue;
}
let v3851_ = gathered;
let v3852_ = through;
let _e2707 = (v3851_ + (v3852_ * (vec3<f32>(0.004f, 0.0042f, 0.0052f) + (vec3<f32>(0.012f, 0.012f, 0.013f) * vec3(exp((-(abs((_e77.y + 0.05f))) * 6f)))))));
let v3875_ = metal;
result_28 = vec4<f32>(_e2707.x, _e2707.y, _e2707.z, v3875_);
left_3 = true;
break;
continuing {
let v3881_ = counter_1;
counter_1 = (v3881_ + 1u);
}
}
let v3884_ = left_3;
let v3885_ = gathered;
let v3886_ = metal;
let v7765_ = result_28;
result_28 = select(vec4<f32>(v3885_.x, v3885_.y, v3885_.z, v3886_), v7765_, v3884_);
let v3892_ = result_28;
let _e2737 = (v232_ == 1u);
logic_1 = _e2737;
let v7767_ = logic_1;
logic_1 = select(v7767_, (v3892_.w == 0f), !(_e2737));
let v93_ = logic_1;
if v93_ {
let v96_ = u.look.light;
let _e2754 = (v3892_.xyz * vec3(v96_));
return artifact_out(vec4<f32>(_e2754.x, _e2754.y, _e2754.z, 1f));
}
offsets = array<vec2<f32>, 4>(vec2<f32>(0.25f, -0.25f), vec2<f32>(-0.25f, 0.25f), vec2<f32>(0.25f, 0.25f), vec2<f32>(-0.25f, -0.25f));
c = _e196;
counter = 0u;
loop {
let v121_ = counter;
if (v121_ >= v232_) {
break;
}
let v123_ = counter;
let v127_ = offsets[v123_];
let v3893_ = u.look.target_;
let v3895_ = u.look.eye;
let _e2790 = normalize((v3893_.xyz - v3895_.xyz));
let _e2792 = normalize(cross(_e2790, _e36));
let v3910_ = u.look.screen;
let _e2800 = ((((_e21 + v127_) / v3910_) * _e46) - _e48);
let v3923_ = u.look.screen.x;
let v3924_ = u.look.screen.y;
let v3933_ = u.look.lens;
let _e2828 = normalize((_e2790 + ((((_e2792 * vec3(_e2800.x)) * vec3((v3923_ / v3924_))) - (cross(_e2792, _e2790) * vec3(_e2800.y))) * vec3(v3933_))));
ro_1 = _e6;
metal_1 = 0f;
gathered_1 = _e196;
through_1 = _e198;
skip_1 = -1f;
past_1 = -1f;
cone_1 = vec2<f32>(0f, (_e145 * 0.5f));
let v3952_ = u.look.place.w;
counter_2 = 0u;
left_7 = false;
loop {
let v3957_ = counter_2;
if (v3957_ >= 4u) {
break;
}
let v3961_ = ro_1;
let v3963_ = cone_1;
let v3964_ = past_1;
let _e2857 = Hit(1000000000f, _e196, 0f, 0f, -1f);
hit_2 = _e2857;
let v3973_ = tiles[_e193].x;
left_4 = v3973_;
loop {
let v3974_ = left_4;
if !((v3974_ != 0u)) {
break;
}
let v3978_ = left_4;
let _e2870 = countTrailingZeros(v3978_);
let v3980_ = left_4;
let v3981_ = left_4;
left_4 = (v3980_ & (v3981_ - 1u));
let _e2878 = f32(_e2870);
if (_e2878 == v3964_) {
continue;
}
let _e2881 = (_e2870 * 3u);
let _e2882 = (_e2881 + 1u);
let _e2884 = (_e2881 + 2u);
let v4005_ = struts[_e2881].w;
let v4006_ = struts[_e2882].w;
let v4007_ = struts[_e2884].z;
let _e2897 = f32_f32_f32_(v4005_, v4006_, v4007_);
let v4012_ = struts[_e2882];
let v4014_ = struts[_e2881];
let _e2909 = (v4012_.xyz - v4014_.xyz);
let v4017_ = struts[_e2881];
let v4019_ = struts[_e2882];
let _e2921 = (((v4017_.xyz + v4019_.xyz) * vec3(0.5f)) - v3961_);
let _e2922 = dot(_e2921, _e2828);
let _e2931 = (((_e2897.c + max(_e2897.a, _e2897.b)) + v3963_.x) + (v3963_.y * max((_e2922 + _e2897.c), 0f)));
let _e2936 = ((dot(_e2921, _e2921) - (_e2922 * _e2922)) > (_e2931 * _e2931));
logic_14 = _e2936;
let v7769_ = logic_14;
logic_14 = select(v7769_, (_e2922 < -(_e2931)), !(_e2936));
let v4061_ = logic_14;
if v4061_ {
continue;
}
let v4063_ = struts[_e2881];
let _e2951 = (v3961_ - v4063_.xyz);
let _e2952 = dot(_e2909, _e2909);
let _e2953 = dot(_e2909, _e2828);
let _e2954 = dot(_e2828, _e2951);
let _e2956 = (_e2952 - (_e2953 * _e2953));
if_7 = select(0.5f, saturate(((dot(_e2909, _e2951) - (_e2954 * _e2953)) / _e2956)), (_e2956 > 0.000001f));
let v4094_ = if_7;
let _e2970 = max(((v4094_ * _e2953) - _e2954), 0f);
let _e2973 = (_e2951 + (_e2828 * vec3(_e2970)));
let _e2976 = saturate((dot(_e2973, _e2909) / _e2952));
let _e2979 = (_e2973 - (_e2909 * vec3(_e2976)));
let _e2980 = length(_e2979);
let _e2981 = mix(_e2897.a, _e2897.b, _e2976);
let _e2983 = (v3963_.x + (v3963_.y * _e2970));
let _e2987 = saturate((0.5f - ((_e2980 - _e2981) / _e2983)));
if (_e2987 <= 0f) {
continue;
}
if (_e2980 < _e2981) {
let v4151_ = struts[_e2881];
let _e2993 = v4151_.xyz;
let v4153_ = struts[_e2882];
let _e2997 = v4153_.xyz;
done_28 = false;
let _e2999 = (_e2997 - _e2993);
let _e3000 = (v3961_ - _e2993);
let _e3001 = (v3961_ - _e2997);
let _e3002 = (_e2897.a - _e2897.b);
let _e3003 = dot(_e2999, _e2999);
let _e3004 = dot(_e2999, _e3000);
let _e3005 = dot(_e2999, _e2828);
let _e3006 = dot(_e2828, _e3000);
let _e3007 = dot(_e3000, _e3000);
let _e3008 = dot(_e3001, _e2828);
let _e3011 = (_e3003 - (_e3002 * _e3002));
let _e3013 = (_e3011 - (_e3005 * _e3005));
let _e3019 = (((_e3011 * _e3006) - (_e3004 * _e3005)) + ((_e3005 * _e3002) * _e2897.a));
let _e3032 = ((_e3019 * _e3019) - (((((_e3011 * _e3007) - (_e3004 * _e3004)) + (((_e3004 * _e3002) * _e2897.a) * 2f)) - ((_e3003 * _e2897.a) * _e2897.a)) * _e3013));
let _e3033 = (_e3032 < 0f);
let _e3034 = vec4(-1f);
let v7772_ = result_29;
result_29 = select(v7772_, _e3034, _e3033);
let v7774_ = done_28;
done_28 = select(v7774_, true, _e3033);
let v4248_ = done_28;
if v4248_ {
} else {
let _e3049 = ((-(sqrt(_e3032)) - _e3019) / _e3013);
let _e3053 = ((_e3004 - (_e2897.a * _e3002)) + (_e3049 * _e3005));
let _e3054 = (_e3053 > 0f);
logic_16 = _e3054;
let v7776_ = logic_16;
logic_16 = select(v7776_, (_e3053 < _e3011), _e3054);
let v4271_ = logic_16;
let _e3071 = normalize((((_e3000 + (_e2828 * vec3(_e3049))) * vec3(_e3011)) - (_e2999 * vec3(_e3053))));
let v7778_ = result_29;
result_29 = select(v7778_, vec4<f32>(_e3049, _e3071.x, _e3071.y, _e3071.z), v4271_);
let v7780_ = done_28;
done_28 = select(v7780_, true, v4271_);
let v4293_ = done_28;
if v4293_ {
} else {
let _e3089 = (((_e3006 * _e3006) - _e3007) + (_e2897.a * _e2897.a));
let _e3093 = (((_e3008 * _e3008) - dot(_e3001, _e3001)) + (_e2897.b * _e2897.b));
best_3 = _e3034;
let _e3098 = (-(_e3006) - sqrt(_e3089));
let _e3103 = ((_e3000 + (_e2828 * vec3(_e3098))) / vec3(_e2897.a));
let v7782_ = best_3;
best_3 = select(v7782_, vec4<f32>(_e3098, _e3103.x, _e3103.y, _e3103.z), (_e3089 > 0f));
if (_e3093 > 0f) {
let _e3115 = (-(_e3008) - sqrt(_e3093));
let v4344_ = best_3.x;
let _e3119 = (v4344_ < 0f);
logic_17 = _e3119;
let v4349_ = best_3.x;
let v7784_ = logic_17;
logic_17 = select(v7784_, (_e3115 < v4349_), !(_e3119));
let v4351_ = logic_17;
let _e3136 = ((_e3001 + (_e2828 * vec3(_e3115))) / vec3(_e2897.b));
let v7786_ = best_3;
best_3 = select(v7786_, vec4<f32>(_e3115, _e3136.x, _e3136.y, _e3136.z), v4351_);
}
let v4366_ = best_3;
result_29 = v4366_;
done_28 = true;
}
}
let v4368_ = result_29;
if_8 = v4368_;
} else {
let _e3154 = (_e2979 / vec3(max(_e2980, 0.000001f)));
if_8 = vec4<f32>(_e2970, _e3154.x, _e3154.y, _e3154.z);
}
let v4380_ = if_8;
let _e3164 = (v4380_.x > 0.0001f);
logic_15 = _e3164;
let v4386_ = hit_2.at;
let v7788_ = logic_15;
logic_15 = select(v7788_, (v4380_.x < v4386_), _e3164);
let v4388_ = logic_15;
if v4388_ {
let v4396_ = struts[_e2881];
normal_2 = v4380_.yzw;
let _e3189 = (_e2983 * 0.5f);
if ((_e2980 + _e3189) > _e2981) {
let _e3197 = clamp(((max((_e2980 - _e3189), -(_e2981)) + _e2981) * 0.5f), 0f, _e2981);
let _e3200 = (_e2909 / vec3(sqrt(_e2952)));
normal_2 = normalize((((_e2979 / vec3(max(_e2980, 0.000001f))) * vec3(_e3197)) + (normalize(((_e2828 * vec3(-1f)) + (_e3200 * vec3(dot(_e2828, _e3200))))) * vec3(sqrt(((_e2981 * _e2981) - (_e3197 * _e3197)))))));
}
let v4468_ = normal_2;
let v4469_ = struts[_e2884].x;
let v4470_ = struts[_e2884].y;
hit_2 = Hit(v4380_.x, v4468_, mix(v4469_, v4470_, saturate((dot(((v3961_ + (_e2828 * vec3(v4380_.x))) - v4396_.xyz), _e2909) / _e2952))), _e2987, _e2878);
}
}
let v4477_ = hit_2;
local_18 = 1.2f;
let _e3239 = local_18;
let _e3243 = ((0.022f * v3952_) * min((1.2f / (_e3239 - -1f)), 2.4f));
let v4490_ = ro_1;
let v4492_ = skip_1;
best_4 = 1000000000f;
which_1 = -1f;
let v4496_ = tiles[_e193].y;
left_5 = v4496_;
loop {
let v4497_ = left_5;
if !((v4497_ != 0u)) {
break;
}
let v4501_ = left_5;
let _e3261 = countTrailingZeros(v4501_);
let v4503_ = left_5;
let v4504_ = left_5;
left_5 = (v4503_ & (v4504_ - 1u));
let _e3269 = f32(_e3261);
if (_e3269 == v4492_) {
continue;
}
let _e3272 = (_e3261 * 6u);
let _e3274 = (_e3272 + 5u);
let v4518_ = panes[_e3274];
let _e3279 = (v4518_.xyz - v4490_);
let _e3280 = dot(_e3279, _e2828);
let v4532_ = panes[_e3274].w;
let v4533_ = panes[_e3274].w;
let _e3293 = ((dot(_e3279, _e3279) - (_e3280 * _e3280)) > (v4532_ * v4533_));
logic_18 = _e3293;
if !(_e3293) {
let v4538_ = panes[_e3274].w;
logic_18 = (_e3280 < -(v4538_));
}
let v4541_ = logic_18;
if v4541_ {
continue;
}
done_29 = false;
let v4553_ = panes[_e3272];
let _e3310 = dot(_e2828, v4553_.xyz);
let _e3313 = (abs(_e3310) < 0.000001f);
let v7790_ = result_30;
result_30 = select(v7790_, -1f, _e3313);
let v7792_ = done_29;
done_29 = select(v7792_, true, _e3313);
let v4562_ = done_29;
if v4562_ {
} else {
let v4563_ = panes[_e3272].w;
let v4565_ = panes[_e3272];
let _e3335 = ((v4563_ - dot(v4490_, v4565_.xyz)) / _e3310);
let _e3336 = (_e3335 <= 0f);
let v7794_ = result_30;
result_30 = select(v7794_, -1f, _e3336);
let v7796_ = done_29;
done_29 = select(v7796_, true, _e3336);
let v4576_ = done_29;
if v4576_ {
} else {
let _e3349 = (v4490_ + (_e2828 * vec3(_e3335)));
let _e3350 = (_e3272 + 1u);
let v4587_ = panes[_e3350];
let v4593_ = panes[_e3350].w;
let _e3360 = (dot(_e3349, v4587_.xyz) - v4593_);
let _e3362 = (_e3272 + 2u);
let v4599_ = panes[_e3362];
let v4605_ = panes[_e3362].w;
let _e3372 = (dot(_e3349, v4599_.xyz) - v4605_);
let _e3374 = (_e3272 + 3u);
let v4611_ = panes[_e3374];
let v4617_ = panes[_e3374].w;
let _e3384 = (dot(_e3349, v4611_.xyz) - v4617_);
let _e3385 = (_e3272 + 4u);
let v4623_ = panes[_e3385];
let v4629_ = panes[_e3385].w;
let _e3395 = (dot(_e3349, v4623_.xyz) - v4629_);
let _e3399 = (min(min(_e3360, _e3372), min(_e3384, _e3395)) >= _e3243);
logic_20 = _e3399;
let v7798_ = logic_20;
logic_20 = select(v7798_, (max(max(_e3360, _e3372), max(_e3384, _e3395)) <= -(_e3243)), !(_e3399));
let v4651_ = logic_20;
let v7800_ = result_30;
result_30 = select(v7800_, _e3335, v4651_);
let v7802_ = done_29;
done_29 = select(v7802_, true, v4651_);
let v4654_ = done_29;
let v7804_ = result_30;
result_30 = select(-1f, v7804_, v4654_);
let v7806_ = done_29;
done_29 = select(true, v7806_, v4654_);
}
}
let v4657_ = result_30;
let _e3434 = (v4657_ > 0.0002f);
logic_19 = _e3434;
let v4662_ = best_4;
let v7808_ = logic_19;
logic_19 = select(v7808_, (v4657_ < v4662_), _e3434);
let v4664_ = logic_19;
let v7810_ = best_4;
best_4 = select(v7810_, v4657_, v4664_);
let v7812_ = which_1;
which_1 = select(v7812_, _e3269, v4664_);
}
let v4668_ = best_4;
let v4669_ = which_1;
let _e3457 = vec2<f32>(v4668_, v4669_);
if (v4477_.at < _e3457.x) {
metal_1 = 1f;
let _e3474 = mix(vec3<f32>(0.5f, 0.51f, 0.53f), vec3<f32>(0.08f, 0.082f, 0.088f), vec3(smoothstep(-0.5f, 0.5f, v4477_.depth)));
let _e3475 = dot(_e2828, v4477_.normal);
let _e3484 = vec3(0.25f);
let _e3490 = (_e2828 - (v4477_.normal * vec3((2f * _e3475))));
local_19 = vec3<f32>(-0.35f, 0.9f, 0.35f);
let _e3496 = local_19;
let _e3497 = normalize(_e3496);
done_30 = false;
let _e3502 = dot(_e3490, _e3497);
let _e3503 = (_e3502 <= 0f);
let v7814_ = result_31;
result_31 = select(v7814_, 0f, _e3503);
let v7816_ = done_30;
done_30 = select(v7816_, true, _e3503);
let v4751_ = done_30;
if v4751_ {
} else {
let _e3516 = normalize(cross(_e3497, _e36));
let _e3524 = (abs((vec2<f32>(dot(_e3490, _e3516), dot(_e3490, cross(_e3516, _e3497))) / vec2(_e3502))) - vec2<f32>(0.6f, 0.32f));
result_31 = saturate((1f - (max(_e3524.x, _e3524.y) / 0.35f)));
done_30 = true;
}
let v4785_ = result_31;
local_20 = vec3<f32>(-0.92f, 0.12f, -0.38f);
let _e3540 = local_20;
let _e3541 = normalize(_e3540);
done_31 = false;
let _e3547 = dot(_e3490, _e3541);
let _e3548 = (_e3547 <= 0f);
let v7818_ = result_32;
result_32 = select(v7818_, 0f, _e3548);
let v7820_ = done_31;
done_31 = select(v7820_, true, _e3548);
let v4805_ = done_31;
if v4805_ {
} else {
let _e3560 = normalize(cross(_e3541, _e36));
let _e3568 = (abs((vec2<f32>(dot(_e3490, _e3560), dot(_e3490, cross(_e3560, _e3541))) / vec2(_e3547))) - vec2<f32>(0.16f, 0.95f));
result_32 = saturate((1f - (max(_e3568.x, _e3568.y) / 0.3f)));
done_31 = true;
}
let v4839_ = result_32;
local_21 = vec3<f32>(0.9f, 0.18f, -0.4f);
let _e3583 = local_21;
let _e3584 = normalize(_e3583);
done_32 = false;
let _e3588 = dot(_e3490, _e3584);
let _e3589 = (_e3588 <= 0f);
let v7822_ = result_33;
result_33 = select(v7822_, 0f, _e3589);
let v7824_ = done_32;
done_32 = select(v7824_, true, _e3589);
let v4859_ = done_32;
if v4859_ {
} else {
let _e3601 = normalize(cross(_e3584, _e36));
let _e3609 = (abs((vec2<f32>(dot(_e3490, _e3601), dot(_e3490, cross(_e3601, _e3584))) / vec2(_e3588))) - vec2<f32>(0.14f, 0.95f));
result_33 = saturate((1f - (max(_e3609.x, _e3609.y) / 0.3f)));
done_32 = true;
}
let v4893_ = result_33;
local_22 = vec3<f32>(0.6f, -0.05f, 0.8f);
let _e3624 = local_22;
let _e3625 = normalize(_e3624);
done_33 = false;
let _e3629 = dot(_e3490, _e3625);
let _e3630 = (_e3629 <= 0f);
let v7826_ = result_34;
result_34 = select(v7826_, 0f, _e3630);
let v7828_ = done_33;
done_33 = select(v7828_, true, _e3630);
let v4913_ = done_33;
if v4913_ {
} else {
let _e3642 = normalize(cross(_e3625, _e36));
let _e3650 = (abs((vec2<f32>(dot(_e3490, _e3642), dot(_e3490, cross(_e3642, _e3625))) / vec2(_e3629))) - vec2<f32>(0.6f, 0.22f));
result_34 = saturate((1f - (max(_e3650.x, _e3650.y) / 0.3f)));
done_33 = true;
}
let v4947_ = result_34;
local_23 = vec3<f32>(0f, 0.25f, -1f);
let _e3663 = local_23;
let _e3664 = normalize(_e3663);
done_34 = false;
let _e3667 = dot(_e3490, _e3664);
let _e3668 = (_e3667 <= 0f);
let v7830_ = result_35;
result_35 = select(v7830_, 0f, _e3668);
let v7832_ = done_34;
done_34 = select(v7832_, true, _e3668);
let v4967_ = done_34;
if v4967_ {
} else {
let _e3680 = normalize(cross(_e3664, _e36));
let _e3688 = (abs((vec2<f32>(dot(_e3490, _e3680), dot(_e3490, cross(_e3680, _e3664))) / vec2(_e3667))) - vec2<f32>(0.9f, 0.12f));
result_35 = saturate((1f - (max(_e3688.x, _e3688.y) / 0.25f)));
done_34 = true;
}
let v5001_ = result_35;
let _e3701 = vec3<f32>(1f, 0.99f, 0.98f);
let _e3708 = vec3<f32>(0.9f, 0.94f, 1f);
let _e3717 = vec3<f32>(0.95f, 0.95f, 1f);
let _e3725 = vec3<f32>(0.95f, 0.96f, 1f);
let _e3738 = vec3(0.04f);
local_24 = -0.6f;
let _e3742 = local_24;
let _e3746 = ((vec3(0.095f) * vec3(smoothstep(-0.25f, 0.9f, _e3490.y))) + (_e3738 * vec3(smoothstep(0.1f, _e3742, _e3490.y))));
let _e3748 = saturate(_e3502);
let v5224_ = u.look.time;
let v5241_ = through_1;
let v5247_ = gathered_1;
let _e3816 = (v5247_ + ((v5241_ * (((mix((((((((_e3701 * vec3(v4785_)) * vec3(1.8f)) + (_e3708 * vec3(((v4839_ * 1.3f) + (v4893_ * 1.1f))))) + ((_e3717 * vec3(v4947_)) * vec3(0.45f))) + ((_e3725 * vec3(v5001_)) * vec3(0.6f))) + _e3746) + vec3((pow(_e3748, 12f) * 0.5f))), ((((((_e3701 * vec3(pow(_e3748, 3f))) * _e198) + (_e3708 * vec3(((pow(saturate(_e3547), 4f) * 0.45f) + (pow(saturate(_e3588), 4f) * 0.4f))))) + ((_e3717 * vec3(pow(saturate(_e3629), 2f))) * _e3484)) + ((_e3725 * vec3(pow(saturate(_e3667), 3f))) * _e3484)) + _e3746), vec3(_e179)) * (_e3474 + (((_e198 - _e3474) * vec3(pow((1f - saturate(-(_e3475))), 5f))) * _e3484))) + (_e3474 * _e3738)) + ((_e3474 + vec3(0.1f)) * vec3((pow(saturate(((sin(((v4477_.depth * 2.4f) + (v5224_ * 0.8f))) * 0.5f) + 0.5f)), 30f) * 0.55f))))) * vec3(v4477_.cover)));
gathered_1 = _e3816;
if (v4477_.cover >= 1f) {
result_57 = vec4<f32>(_e3816.x, _e3816.y, _e3816.z, 1f);
left_7 = true;
break;
}
let v5262_ = through_1;
through_1 = (v5262_ * vec3((1f - v4477_.cover)));
past_1 = v4477_.strut;
continue;
}
past_1 = -1f;
if (_e3457.y >= 0f) {
let v5270_ = ro_1;
let _e3840 = (v5270_ + (_e2828 * vec3(_e3457.x)));
let v5280_ = panes[(u32(_e3457.y) * 6u)];
let _e3847 = v5280_.xyz;
n_1 = _e3847;
let v7834_ = n_1;
n_1 = select(v7834_, -(_e3847), (dot(_e3847, _e2828) > 0f));
let v5290_ = u.look.place;
let v5293_ = n_1;
let v5297_ = u.look.place.w;
let _e3870 = ((_e3840 - v5290_.xyz) / vec3(v5297_));
let v5306_ = u.look.time;
let v5317_ = u.look.time;
let v5328_ = u.look.time;
let _e3906 = vec3<f32>(sin((dot(_e3870, vec3<f32>(2.3f, 1.7f, -1.1f)) + (v5306_ * 0.6f))), sin((dot(_e3870, vec3<f32>(-1.5f, 2.6f, 1.9f)) + (v5317_ * 0.5f))), sin((dot(_e3870, vec3<f32>(2f, -1.3f, 2.4f)) - (v5328_ * 0.7f))));
let _e3915 = normalize((v5293_ + ((_e3906 - (v5293_ * vec3(dot(_e3906, v5293_)))) * vec3(0.16f))));
let _e3916 = dot(_e2828, _e3915);
let v5361_ = cone_1.x;
let v5362_ = cone_1.y;
let v5366_ = cone_1.y;
let _e3937 = vec2<f32>((v5361_ + (v5362_ * _e3457.x)), v5366_);
let _e3941 = (_e2828 - (_e3915 * vec3((2f * _e3916))));
let v5379_ = n_1;
let _e3947 = ((_e3915 - v5379_) * vec3(0.05f));
let _e3949 = normalize((_e3941 - _e3947));
local_25 = vec3<f32>(-0.35f, 0.9f, 0.35f);
let _e3955 = local_25;
let _e3956 = normalize(_e3955);
let _e3958 = vec2<f32>(0.6f, 0.32f);
done_35 = false;
let _e3960 = dot(_e3949, _e3956);
let _e3961 = (_e3960 <= 0f);
let v7836_ = result_36;
result_36 = select(v7836_, 0f, _e3961);
let v7838_ = done_35;
done_35 = select(v7838_, true, _e3961);
let v5407_ = done_35;
if v5407_ {
} else {
let _e3974 = normalize(cross(_e3956, _e36));
let _e3982 = (abs((vec2<f32>(dot(_e3949, _e3974), dot(_e3949, cross(_e3974, _e3956))) / vec2(_e3960))) - _e3958);
result_36 = saturate((1f - (max(_e3982.x, _e3982.y) / 0.35f)));
done_35 = true;
}
let v5441_ = result_36;
local_26 = vec3<f32>(-0.92f, 0.12f, -0.38f);
let _e3998 = local_26;
let _e3999 = normalize(_e3998);
let _e4001 = vec2<f32>(0.16f, 0.95f);
done_36 = false;
let _e4004 = dot(_e3949, _e3999);
let _e4005 = (_e4004 <= 0f);
let v7840_ = result_37;
result_37 = select(v7840_, 0f, _e4005);
let v7842_ = done_36;
done_36 = select(v7842_, true, _e4005);
let v5461_ = done_36;
if v5461_ {
} else {
let _e4017 = normalize(cross(_e3999, _e36));
let _e4025 = (abs((vec2<f32>(dot(_e3949, _e4017), dot(_e3949, cross(_e4017, _e3999))) / vec2(_e4004))) - _e4001);
result_37 = saturate((1f - (max(_e4025.x, _e4025.y) / 0.3f)));
done_36 = true;
}
let v5495_ = result_37;
local_27 = vec3<f32>(0.9f, 0.18f, -0.4f);
let _e4040 = local_27;
let _e4041 = normalize(_e4040);
let _e4043 = vec2<f32>(0.14f, 0.95f);
done_37 = false;
let _e4045 = dot(_e3949, _e4041);
let _e4046 = (_e4045 <= 0f);
let v7844_ = result_38;
result_38 = select(v7844_, 0f, _e4046);
let v7846_ = done_37;
done_37 = select(v7846_, true, _e4046);
let v5515_ = done_37;
if v5515_ {
} else {
let _e4058 = normalize(cross(_e4041, _e36));
let _e4066 = (abs((vec2<f32>(dot(_e3949, _e4058), dot(_e3949, cross(_e4058, _e4041))) / vec2(_e4045))) - _e4043);
result_38 = saturate((1f - (max(_e4066.x, _e4066.y) / 0.3f)));
done_37 = true;
}
let v5549_ = result_38;
local_28 = vec3<f32>(0.6f, -0.05f, 0.8f);
let _e4081 = local_28;
let _e4082 = normalize(_e4081);
let _e4084 = vec2<f32>(0.6f, 0.22f);
done_38 = false;
let _e4086 = dot(_e3949, _e4082);
let _e4087 = (_e4086 <= 0f);
let v7848_ = result_39;
result_39 = select(v7848_, 0f, _e4087);
let v7850_ = done_38;
done_38 = select(v7850_, true, _e4087);
let v5569_ = done_38;
if v5569_ {
} else {
let _e4099 = normalize(cross(_e4082, _e36));
let _e4107 = (abs((vec2<f32>(dot(_e3949, _e4099), dot(_e3949, cross(_e4099, _e4082))) / vec2(_e4086))) - _e4084);
result_39 = saturate((1f - (max(_e4107.x, _e4107.y) / 0.3f)));
done_38 = true;
}
let v5603_ = result_39;
local_29 = vec3<f32>(0f, 0.25f, -1f);
let _e4120 = local_29;
let _e4121 = normalize(_e4120);
let _e4122 = vec2<f32>(0.9f, 0.12f);
done_39 = false;
let _e4124 = dot(_e3949, _e4121);
let _e4125 = (_e4124 <= 0f);
let v7852_ = result_40;
result_40 = select(v7852_, 0f, _e4125);
let v7854_ = done_39;
done_39 = select(v7854_, true, _e4125);
let v5623_ = done_39;
if v5623_ {
} else {
let _e4137 = normalize(cross(_e4121, _e36));
let _e4145 = (abs((vec2<f32>(dot(_e3949, _e4137), dot(_e3949, cross(_e4137, _e4121))) / vec2(_e4124))) - _e4122);
result_40 = saturate((1f - (max(_e4145.x, _e4145.y) / 0.25f)));
done_39 = true;
}
let v5657_ = result_40;
let _e4158 = vec3<f32>(1f, 0.99f, 0.98f);
let _e4162 = vec3(1.8f);
let _e4165 = vec3<f32>(0.9f, 0.94f, 1f);
let _e4174 = vec3<f32>(0.95f, 0.95f, 1f);
let _e4178 = vec3(0.45f);
let _e4181 = vec3<f32>(0.95f, 0.96f, 1f);
let _e4184 = vec3(0.6f);
let _e4188 = vec3(0.095f);
let _e4193 = vec3(0.04f);
local_30 = -0.6f;
let _e4197 = local_30;
done_40 = false;
let _e4205 = dot(_e3941, _e3956);
let _e4206 = (_e4205 <= 0f);
let v7856_ = result_41;
result_41 = select(v7856_, 0f, _e4206);
let v7858_ = done_40;
done_40 = select(v7858_, true, _e4206);
let v5744_ = done_40;
if v5744_ {
} else {
let _e4218 = normalize(cross(_e3956, _e36));
let _e4226 = (abs((vec2<f32>(dot(_e3941, _e4218), dot(_e3941, cross(_e4218, _e3956))) / vec2(_e4205))) - _e3958);
result_41 = saturate((1f - (max(_e4226.x, _e4226.y) / 0.35f)));
done_40 = true;
}
let v5778_ = result_41;
done_41 = false;
let _e4238 = dot(_e3941, _e3999);
let _e4239 = (_e4238 <= 0f);
let v7860_ = result_42;
result_42 = select(v7860_, 0f, _e4239);
let v7862_ = done_41;
done_41 = select(v7862_, true, _e4239);
let v5798_ = done_41;
if v5798_ {
} else {
let _e4251 = normalize(cross(_e3999, _e36));
let _e4259 = (abs((vec2<f32>(dot(_e3941, _e4251), dot(_e3941, cross(_e4251, _e3999))) / vec2(_e4238))) - _e4001);
result_42 = saturate((1f - (max(_e4259.x, _e4259.y) / 0.3f)));
done_41 = true;
}
let v5832_ = result_42;
done_42 = false;
let _e4271 = dot(_e3941, _e4041);
let _e4272 = (_e4271 <= 0f);
let v7864_ = result_43;
result_43 = select(v7864_, 0f, _e4272);
let v7866_ = done_42;
done_42 = select(v7866_, true, _e4272);
let v5852_ = done_42;
if v5852_ {
} else {
let _e4284 = normalize(cross(_e4041, _e36));
let _e4292 = (abs((vec2<f32>(dot(_e3941, _e4284), dot(_e3941, cross(_e4284, _e4041))) / vec2(_e4271))) - _e4043);
result_43 = saturate((1f - (max(_e4292.x, _e4292.y) / 0.3f)));
done_42 = true;
}
let v5886_ = result_43;
done_43 = false;
let _e4304 = dot(_e3941, _e4082);
let _e4305 = (_e4304 <= 0f);
let v7868_ = result_44;
result_44 = select(v7868_, 0f, _e4305);
let v7870_ = done_43;
done_43 = select(v7870_, true, _e4305);
let v5906_ = done_43;
if v5906_ {
} else {
let _e4317 = normalize(cross(_e4082, _e36));
let _e4325 = (abs((vec2<f32>(dot(_e3941, _e4317), dot(_e3941, cross(_e4317, _e4082))) / vec2(_e4304))) - _e4084);
result_44 = saturate((1f - (max(_e4325.x, _e4325.y) / 0.3f)));
done_43 = true;
}
let v5940_ = result_44;
done_44 = false;
let _e4337 = dot(_e3941, _e4121);
let _e4338 = (_e4337 <= 0f);
let v7872_ = result_45;
result_45 = select(v7872_, 0f, _e4338);
let v7874_ = done_44;
done_44 = select(v7874_, true, _e4338);
let v5960_ = done_44;
if v5960_ {
} else {
let _e4350 = normalize(cross(_e4121, _e36));
let _e4358 = (abs((vec2<f32>(dot(_e3941, _e4350), dot(_e3941, cross(_e4350, _e4121))) / vec2(_e4337))) - _e4122);
result_45 = saturate((1f - (max(_e4358.x, _e4358.y) / 0.25f)));
done_44 = true;
}
let v5994_ = result_45;
local_31 = -0.6f;
let _e4391 = local_31;
let _e4399 = normalize((_e3941 + _e3947));
done_45 = false;
let _e4401 = dot(_e4399, _e3956);
let _e4402 = (_e4401 <= 0f);
let v7876_ = result_46;
result_46 = select(v7876_, 0f, _e4402);
let v7878_ = done_45;
done_45 = select(v7878_, true, _e4402);
let v6087_ = done_45;
if v6087_ {
} else {
let _e4414 = normalize(cross(_e3956, _e36));
let _e4422 = (abs((vec2<f32>(dot(_e4399, _e4414), dot(_e4399, cross(_e4414, _e3956))) / vec2(_e4401))) - _e3958);
result_46 = saturate((1f - (max(_e4422.x, _e4422.y) / 0.35f)));
done_45 = true;
}
let v6121_ = result_46;
done_46 = false;
let _e4434 = dot(_e4399, _e3999);
let _e4435 = (_e4434 <= 0f);
let v7880_ = result_47;
result_47 = select(v7880_, 0f, _e4435);
let v7882_ = done_46;
done_46 = select(v7882_, true, _e4435);
let v6141_ = done_46;
if v6141_ {
} else {
let _e4447 = normalize(cross(_e3999, _e36));
let _e4455 = (abs((vec2<f32>(dot(_e4399, _e4447), dot(_e4399, cross(_e4447, _e3999))) / vec2(_e4434))) - _e4001);
result_47 = saturate((1f - (max(_e4455.x, _e4455.y) / 0.3f)));
done_46 = true;
}
let v6175_ = result_47;
done_47 = false;
let _e4467 = dot(_e4399, _e4041);
let _e4468 = (_e4467 <= 0f);
let v7884_ = result_48;
result_48 = select(v7884_, 0f, _e4468);
let v7886_ = done_47;
done_47 = select(v7886_, true, _e4468);
let v6195_ = done_47;
if v6195_ {
} else {
let _e4480 = normalize(cross(_e4041, _e36));
let _e4488 = (abs((vec2<f32>(dot(_e4399, _e4480), dot(_e4399, cross(_e4480, _e4041))) / vec2(_e4467))) - _e4043);
result_48 = saturate((1f - (max(_e4488.x, _e4488.y) / 0.3f)));
done_47 = true;
}
let v6229_ = result_48;
done_48 = false;
let _e4500 = dot(_e4399, _e4082);
let _e4501 = (_e4500 <= 0f);
let v7888_ = result_49;
result_49 = select(v7888_, 0f, _e4501);
let v7890_ = done_48;
done_48 = select(v7890_, true, _e4501);
let v6249_ = done_48;
if v6249_ {
} else {
let _e4513 = normalize(cross(_e4082, _e36));
let _e4521 = (abs((vec2<f32>(dot(_e4399, _e4513), dot(_e4399, cross(_e4513, _e4082))) / vec2(_e4500))) - _e4084);
result_49 = saturate((1f - (max(_e4521.x, _e4521.y) / 0.3f)));
done_48 = true;
}
let v6283_ = result_49;
done_49 = false;
let _e4533 = dot(_e4399, _e4121);
let _e4534 = (_e4533 <= 0f);
let v7892_ = result_50;
result_50 = select(v7892_, 0f, _e4534);
let v7894_ = done_49;
done_49 = select(v7894_, true, _e4534);
let v6303_ = done_49;
if v6303_ {
} else {
let _e4546 = normalize(cross(_e4121, _e36));
let _e4554 = (abs((vec2<f32>(dot(_e4399, _e4546), dot(_e4399, cross(_e4546, _e4121))) / vec2(_e4533))) - _e4122);
result_50 = saturate((1f - (max(_e4554.x, _e4554.y) / 0.25f)));
done_49 = true;
}
let v6337_ = result_50;
local_32 = -0.6f;
let _e4587 = local_32;
let _e4594 = vec3<f32>(((((((_e4158 * vec3(v5441_)) * _e4162) + (_e4165 * vec3(((v5495_ * 1.3f) + (v5549_ * 1.1f))))) + ((_e4174 * vec3(v5603_)) * _e4178)) + ((_e4181 * vec3(v5657_)) * _e4184)) + ((_e4188 * vec3(smoothstep(-0.25f, 0.9f, _e3949.y))) + (_e4193 * vec3(smoothstep(0.1f, _e4197, _e3949.y))))).x, ((((((_e4158 * vec3(v5778_)) * _e4162) + (_e4165 * vec3(((v5832_ * 1.3f) + (v5886_ * 1.1f))))) + ((_e4174 * vec3(v5940_)) * _e4178)) + ((_e4181 * vec3(v5994_)) * _e4184)) + ((_e4188 * vec3(smoothstep(-0.25f, 0.9f, _e3941.y))) + (_e4193 * vec3(smoothstep(0.1f, _e4391, _e3941.y))))).y, ((((((_e4158 * vec3(v6121_)) * _e4162) + (_e4165 * vec3(((v6175_ * 1.3f) + (v6229_ * 1.1f))))) + ((_e4174 * vec3(v6283_)) * _e4178)) + ((_e4181 * vec3(v6337_)) * _e4184)) + ((_e4188 * vec3(smoothstep(-0.25f, 0.9f, _e4399.y))) + (_e4193 * vec3(smoothstep(0.1f, _e4587, _e4399.y))))).z);
mirrored_1 = _e4594;
let v6406_ = n_1;
let v6408_ = n_1;
let _e4604 = (_e2828 - (v6406_ * vec3((2f * dot(_e2828, v6408_)))));
let v6415_ = skip_1;
if (v6415_ < 0f) {
let _e4610 = (_e3840 + (_e4604 * vec3(0.001f)));
hit_3 = _e2857;
let v6435_ = tiles[_e193].z;
left_6 = v6435_;
loop {
let v6436_ = left_6;
if !((v6436_ != 0u)) {
break;
}
let v6440_ = left_6;
let _e4623 = countTrailingZeros(v6440_);
let v6442_ = left_6;
let v6443_ = left_6;
left_6 = (v6442_ & (v6443_ - 1u));
let _e4631 = f32(_e4623);
if (_e4631 == -1f) {
continue;
}
let _e4634 = (_e4623 * 3u);
let _e4635 = (_e4634 + 1u);
let _e4637 = (_e4634 + 2u);
let v6467_ = struts[_e4634].w;
let v6468_ = struts[_e4635].w;
let v6469_ = struts[_e4637].z;
let _e4650 = f32_f32_f32_(v6467_, v6468_, v6469_);
let v6474_ = struts[_e4635];
let v6476_ = struts[_e4634];
let _e4662 = (v6474_.xyz - v6476_.xyz);
let v6479_ = struts[_e4634];
let v6481_ = struts[_e4635];
let _e4674 = (((v6479_.xyz + v6481_.xyz) * vec3(0.5f)) - _e4610);
let _e4675 = dot(_e4674, _e4604);
let _e4684 = (((_e4650.c + max(_e4650.a, _e4650.b)) + _e3937.x) + (_e3937.y * max((_e4675 + _e4650.c), 0f)));
let _e4689 = ((dot(_e4674, _e4674) - (_e4675 * _e4675)) > (_e4684 * _e4684));
logic_21 = _e4689;
let v7896_ = logic_21;
logic_21 = select(v7896_, (_e4675 < -(_e4684)), !(_e4689));
let v6523_ = logic_21;
if v6523_ {
continue;
}
let v6525_ = struts[_e4634];
let _e4704 = (_e4610 - v6525_.xyz);
let _e4705 = dot(_e4662, _e4662);
let _e4706 = dot(_e4662, _e4604);
let _e4707 = dot(_e4604, _e4704);
let _e4709 = (_e4705 - (_e4706 * _e4706));
if_9 = select(0.5f, saturate(((dot(_e4662, _e4704) - (_e4707 * _e4706)) / _e4709)), (_e4709 > 0.000001f));
let v6556_ = if_9;
let _e4723 = max(((v6556_ * _e4706) - _e4707), 0f);
let _e4726 = (_e4704 + (_e4604 * vec3(_e4723)));
let _e4729 = saturate((dot(_e4726, _e4662) / _e4705));
let _e4732 = (_e4726 - (_e4662 * vec3(_e4729)));
let _e4733 = length(_e4732);
let _e4734 = mix(_e4650.a, _e4650.b, _e4729);
let _e4736 = (_e3937.x + (_e3937.y * _e4723));
let _e4740 = saturate((0.5f - ((_e4733 - _e4734) / _e4736)));
if (_e4740 <= 0f) {
continue;
}
if (_e4733 < _e4734) {
let v6613_ = struts[_e4634];
let _e4746 = v6613_.xyz;
let v6615_ = struts[_e4635];
let _e4750 = v6615_.xyz;
done_50 = false;
let _e4752 = (_e4750 - _e4746);
let _e4753 = (_e4610 - _e4746);
let _e4754 = (_e4610 - _e4750);
let _e4755 = (_e4650.a - _e4650.b);
let _e4756 = dot(_e4752, _e4752);
let _e4757 = dot(_e4752, _e4753);
let _e4758 = dot(_e4752, _e4604);
let _e4759 = dot(_e4604, _e4753);
let _e4760 = dot(_e4753, _e4753);
let _e4761 = dot(_e4754, _e4604);
let _e4764 = (_e4756 - (_e4755 * _e4755));
let _e4766 = (_e4764 - (_e4758 * _e4758));
let _e4772 = (((_e4764 * _e4759) - (_e4757 * _e4758)) + ((_e4758 * _e4755) * _e4650.a));
let _e4785 = ((_e4772 * _e4772) - (((((_e4764 * _e4760) - (_e4757 * _e4757)) + (((_e4757 * _e4755) * _e4650.a) * 2f)) - ((_e4756 * _e4650.a) * _e4650.a)) * _e4766));
let _e4786 = (_e4785 < 0f);
let _e4787 = vec4(-1f);
let v7899_ = result_51;
result_51 = select(v7899_, _e4787, _e4786);
let v7901_ = done_50;
done_50 = select(v7901_, true, _e4786);
let v6710_ = done_50;
if v6710_ {
} else {
let _e4801 = ((-(sqrt(_e4785)) - _e4772) / _e4766);
let _e4805 = ((_e4757 - (_e4650.a * _e4755)) + (_e4801 * _e4758));
let _e4806 = (_e4805 > 0f);
logic_23 = _e4806;
let v7903_ = logic_23;
logic_23 = select(v7903_, (_e4805 < _e4764), _e4806);
let v6733_ = logic_23;
let _e4823 = normalize((((_e4753 + (_e4604 * vec3(_e4801))) * vec3(_e4764)) - (_e4752 * vec3(_e4805))));
let v7905_ = result_51;
result_51 = select(v7905_, vec4<f32>(_e4801, _e4823.x, _e4823.y, _e4823.z), v6733_);
let v7907_ = done_50;
done_50 = select(v7907_, true, v6733_);
let v6755_ = done_50;
if v6755_ {
} else {
let _e4841 = (((_e4759 * _e4759) - _e4760) + (_e4650.a * _e4650.a));
let _e4845 = (((_e4761 * _e4761) - dot(_e4754, _e4754)) + (_e4650.b * _e4650.b));
best_5 = _e4787;
let _e4850 = (-(_e4759) - sqrt(_e4841));
let _e4855 = ((_e4753 + (_e4604 * vec3(_e4850))) / vec3(_e4650.a));
let v7909_ = best_5;
best_5 = select(v7909_, vec4<f32>(_e4850, _e4855.x, _e4855.y, _e4855.z), (_e4841 > 0f));
if (_e4845 > 0f) {
let _e4867 = (-(_e4761) - sqrt(_e4845));
let v6806_ = best_5.x;
let _e4871 = (v6806_ < 0f);
logic_24 = _e4871;
let v6811_ = best_5.x;
let v7911_ = logic_24;
logic_24 = select(v7911_, (_e4867 < v6811_), !(_e4871));
let v6813_ = logic_24;
let _e4888 = ((_e4754 + (_e4604 * vec3(_e4867))) / vec3(_e4650.b));
let v7913_ = best_5;
best_5 = select(v7913_, vec4<f32>(_e4867, _e4888.x, _e4888.y, _e4888.z), v6813_);
}
let v6828_ = best_5;
result_51 = v6828_;
done_50 = true;
}
}
let v6830_ = result_51;
if_10 = v6830_;
} else {
let _e4906 = (_e4732 / vec3(max(_e4733, 0.000001f)));
if_10 = vec4<f32>(_e4723, _e4906.x, _e4906.y, _e4906.z);
}
let v6842_ = if_10;
let _e4916 = (v6842_.x > 0.0001f);
logic_22 = _e4916;
let v6848_ = hit_3.at;
let v7915_ = logic_22;
logic_22 = select(v7915_, (v6842_.x < v6848_), _e4916);
let v6850_ = logic_22;
if v6850_ {
let v6858_ = struts[_e4634];
normal_3 = v6842_.yzw;
let _e4941 = (_e4736 * 0.5f);
if ((_e4733 + _e4941) > _e4734) {
let _e4949 = clamp(((max((_e4733 - _e4941), -(_e4734)) + _e4734) * 0.5f), 0f, _e4734);
let _e4952 = (_e4662 / vec3(sqrt(_e4705)));
normal_3 = normalize((((_e4732 / vec3(max(_e4733, 0.000001f))) * vec3(_e4949)) + (normalize(((_e4604 * vec3(-1f)) + (_e4952 * vec3(dot(_e4604, _e4952))))) * vec3(sqrt(((_e4734 * _e4734) - (_e4949 * _e4949)))))));
}
let v6930_ = normal_3;
let v6931_ = struts[_e4637].x;
let v6932_ = struts[_e4637].y;
hit_3 = Hit(v6842_.x, v6930_, mix(v6931_, v6932_, saturate((dot(((_e4610 + (_e4604 * vec3(v6842_.x))) - v6858_.xyz), _e4662) / _e4705))), _e4740, _e4631);
}
}
let v6939_ = hit_3;
if_6 = v6939_;
} else {
if_6 = _e2857;
}
let v6947_ = if_6;
if (v6947_.at < 100000000f) {
metal_1 = 1f;
let _e5009 = mix(vec3<f32>(0.5f, 0.51f, 0.53f), vec3<f32>(0.08f, 0.082f, 0.088f), vec3(smoothstep(-0.5f, 0.5f, v6947_.depth)));
let _e5010 = dot(_e4604, v6947_.normal);
let _e5018 = vec3(0.25f);
let _e5024 = (_e4604 - (v6947_.normal * vec3((2f * _e5010))));
done_51 = false;
let _e5026 = dot(_e5024, _e3956);
let _e5027 = (_e5026 <= 0f);
let v7917_ = result_52;
result_52 = select(v7917_, 0f, _e5027);
let v7919_ = done_51;
done_51 = select(v7919_, true, _e5027);
let v7028_ = done_51;
if v7028_ {
} else {
let _e5039 = normalize(cross(_e3956, _e36));
let _e5047 = (abs((vec2<f32>(dot(_e5024, _e5039), dot(_e5024, cross(_e5039, _e3956))) / vec2(_e5026))) - _e3958);
result_52 = saturate((1f - (max(_e5047.x, _e5047.y) / 0.35f)));
done_51 = true;
}
let v7062_ = result_52;
done_52 = false;
let _e5059 = dot(_e5024, _e3999);
let _e5060 = (_e5059 <= 0f);
let v7921_ = result_53;
result_53 = select(v7921_, 0f, _e5060);
let v7923_ = done_52;
done_52 = select(v7923_, true, _e5060);
let v7082_ = done_52;
if v7082_ {
} else {
let _e5072 = normalize(cross(_e3999, _e36));
let _e5080 = (abs((vec2<f32>(dot(_e5024, _e5072), dot(_e5024, cross(_e5072, _e3999))) / vec2(_e5059))) - _e4001);
result_53 = saturate((1f - (max(_e5080.x, _e5080.y) / 0.3f)));
done_52 = true;
}
let v7116_ = result_53;
done_53 = false;
let _e5092 = dot(_e5024, _e4041);
let _e5093 = (_e5092 <= 0f);
let v7925_ = result_54;
result_54 = select(v7925_, 0f, _e5093);
let v7927_ = done_53;
done_53 = select(v7927_, true, _e5093);
let v7136_ = done_53;
if v7136_ {
} else {
let _e5105 = normalize(cross(_e4041, _e36));
let _e5113 = (abs((vec2<f32>(dot(_e5024, _e5105), dot(_e5024, cross(_e5105, _e4041))) / vec2(_e5092))) - _e4043);
result_54 = saturate((1f - (max(_e5113.x, _e5113.y) / 0.3f)));
done_53 = true;
}
let v7170_ = result_54;
done_54 = false;
let _e5125 = dot(_e5024, _e4082);
let _e5126 = (_e5125 <= 0f);
let v7929_ = result_55;
result_55 = select(v7929_, 0f, _e5126);
let v7931_ = done_54;
done_54 = select(v7931_, true, _e5126);
let v7190_ = done_54;
if v7190_ {
} else {
let _e5138 = normalize(cross(_e4082, _e36));
let _e5146 = (abs((vec2<f32>(dot(_e5024, _e5138), dot(_e5024, cross(_e5138, _e4082))) / vec2(_e5125))) - _e4084);
result_55 = saturate((1f - (max(_e5146.x, _e5146.y) / 0.3f)));
done_54 = true;
}
let v7224_ = result_55;
done_55 = false;
let _e5158 = dot(_e5024, _e4121);
let _e5159 = (_e5158 <= 0f);
let v7933_ = result_56;
result_56 = select(v7933_, 0f, _e5159);
let v7935_ = done_55;
done_55 = select(v7935_, true, _e5159);
let v7244_ = done_55;
if v7244_ {
} else {
let _e5171 = normalize(cross(_e4121, _e36));
let _e5179 = (abs((vec2<f32>(dot(_e5024, _e5171), dot(_e5024, cross(_e5171, _e4121))) / vec2(_e5158))) - _e4122);
result_56 = saturate((1f - (max(_e5179.x, _e5179.y) / 0.25f)));
done_55 = true;
}
let v7278_ = result_56;
local_33 = -0.6f;
let _e5212 = local_33;
let _e5216 = ((_e4188 * vec3(smoothstep(-0.25f, 0.9f, _e5024.y))) + (_e4193 * vec3(smoothstep(0.1f, _e5212, _e5024.y))));
let _e5218 = saturate(_e5026);
let v7501_ = u.look.time;
mirrored_1 = mix(_e4594, (((mix((((((((_e4158 * vec3(v7062_)) * _e4162) + (_e4165 * vec3(((v7116_ * 1.3f) + (v7170_ * 1.1f))))) + ((_e4174 * vec3(v7224_)) * _e4178)) + ((_e4181 * vec3(v7278_)) * _e4184)) + _e5216) + vec3((pow(_e5218, 12f) * 0.5f))), ((((((_e4158 * vec3(pow(_e5218, 3f))) * _e198) + (_e4165 * vec3(((pow(saturate(_e5059), 4f) * 0.45f) + (pow(saturate(_e5092), 4f) * 0.4f))))) + ((_e4174 * vec3(pow(saturate(_e5125), 2f))) * _e5018)) + ((_e4181 * vec3(pow(saturate(_e5158), 3f))) * _e5018)) + _e5216), vec3(_e179)) * (_e5009 + (((_e198 - _e5009) * vec3(pow((1f - saturate(-(_e5010))), 5f))) * _e5018))) + (_e5009 * _e4193)) + ((_e5009 + vec3(0.1f)) * vec3((pow(saturate(((sin(((v6947_.depth * 2.4f) + (v7501_ * 0.8f))) * 0.5f) + 0.5f)), 30f) * 0.55f)))), vec3(v6947_.cover));
}
let _e5285 = (0.03f + (0.55f * (0.04f + (0.96f * pow((1f - saturate(-(_e3916))), 5f)))));
let v7528_ = through_1;
let v7529_ = mirrored_1;
let v7537_ = gathered_1;
gathered_1 = (v7537_ + (((v7528_ * v7529_) * vec3(_e5285)) * vec3(0.7f)));
let v7544_ = through_1;
through_1 = (v7544_ * vec3(((1f - _e5285) * 0.6f)));
cone_1 = _e3937;
ro_1 = _e3840;
skip_1 = _e3457.y;
continue;
}
let v7550_ = gathered_1;
let v7551_ = through_1;
let _e5332 = (v7550_ + (v7551_ * (vec3<f32>(0.004f, 0.0042f, 0.0052f) + (vec3<f32>(0.012f, 0.012f, 0.013f) * vec3(exp((-(abs((_e2828.y + 0.05f))) * 6f)))))));
let v7574_ = metal_1;
result_57 = vec4<f32>(_e5332.x, _e5332.y, _e5332.z, v7574_);
left_7 = true;
break;
continuing {
let v7580_ = counter_2;
counter_2 = (v7580_ + 1u);
}
}
let v7583_ = left_7;
let v7584_ = gathered_1;
let v7585_ = metal_1;
let v7937_ = result_57;
result_57 = select(vec4<f32>(v7584_.x, v7584_.y, v7584_.z, v7585_), v7937_, v7583_);
let v7591_ = result_57;
let v141_ = c;
c = (v141_ + v7591_.xyz);
continuing {
let v143_ = counter;
counter = (v143_ + 1u);
}
}
let v146_ = c;
let v151_ = u.look.light;
let _e5381 = ((v146_ / vec3(f32(v232_))) * vec3(v151_));
return artifact_out(vec4<f32>(_e5381.x, _e5381.y, _e5381.z, 1f));
}