struct Backdrop {
sizes: vec4<f32>,
look: vec4<f32>,
tint: vec4<f32>,
screen: vec4<f32>,
behind: vec4<f32>,
}

struct Uniforms_quad_backdrop {
screen: vec2<f32>,
rect: vec4<f32>,
look: Backdrop,
}

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 backdrop_out {
@location(0) color0_: vec4<f32>,
}

@group(0) @binding(1) 
var hero: texture_2d<f32>;
@group(0) @binding(2) 
var cover: texture_2d<f32>;
@group(0) @binding(3) 
var linear: sampler;
@group(0) @binding(0) 
var<uniform> u: Uniforms_quad_backdrop;

@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 backdrop(varyings: Vertex_io) -> backdrop_out {
var stand: vec3<f32>;
var logic: bool;
var color: vec3<f32>;
var local: i32;
var local_1: i32;

let v0_1 = Vertex(ClipPosition(varyings.v0_), varyings.v1_, varyings.v2_);
let v1_ = u.look.screen;
let _e10 = v1_.xy;
let v4_ = u.look.look;
let v8_ = u.look.tint;
let v10_ = u.look.tint.w;
let _e35 = (v0_1.pixel.y / _e10.y);
stand = (mix(vec3(0.16f), v8_.xyz, vec3(v10_)) * vec3(mix(0.42f, 0.18f, _e35)));
let v22_1 = u.look.sizes.z;
let _e46 = (v22_1 > 0f);
logic = _e46;
let v25_ = u.look.look.x;
let v738_ = logic;
logic = select(v738_, (v25_ < 1f), _e46);
let v28_ = logic;
if v28_ {
let v36_ = u.look.sizes;
let _e69 = v36_.zw;
let _e79 = vec2(0.5f);
let _e86 = (((((v0_1.pixel - (v4_.zw * vec2(0.6f))) - (_e10 * _e79)) / vec2((max((_e10.x / _e69.x), (_e10.y / _e69.y)) * 1.03f))) + (_e69 * _e79)) / _e69);
let v39_ = u.look.sizes.z;
let v42_ = u.look.sizes.w;
let _e100 = vec2<f32>((1.6f / v39_), (1.6f / v42_));
let v250_ = textureSampleLevel(cover, linear, _e86, 0f);
local = 0i;
let _e107 = local;
let _e108 = f32(_e107);
let _e110 = (_e108 * 2.3999631f);
let v324_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e110), sin(_e110)) * _e100) * vec2(sqrt(((_e108 + 0.5f) / 12f))))), 0f);
local_1 = 0i;
let _e129 = local_1;
let _e130 = (_e129 + 1i);
let _e131 = f32(_e130);
let _e132 = (_e131 * 2.3999631f);
let v361_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e132), sin(_e132)) * _e100) * vec2(sqrt(((_e131 + 0.5f) / 12f))))), 0f);
let _e148 = (_e130 + 1i);
let _e149 = f32(_e148);
let _e150 = (_e149 * 2.3999631f);
let v398_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e150), sin(_e150)) * _e100) * vec2(sqrt(((_e149 + 0.5f) / 12f))))), 0f);
let _e166 = (_e148 + 1i);
let _e167 = f32(_e166);
let _e168 = (_e167 * 2.3999631f);
let v435_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e168), sin(_e168)) * _e100) * vec2(sqrt(((_e167 + 0.5f) / 12f))))), 0f);
let _e184 = (_e166 + 1i);
let _e185 = f32(_e184);
let _e186 = (_e185 * 2.3999631f);
let v472_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e186), sin(_e186)) * _e100) * vec2(sqrt(((_e185 + 0.5f) / 12f))))), 0f);
let _e202 = (_e184 + 1i);
let _e203 = f32(_e202);
let _e204 = (_e203 * 2.3999631f);
let v509_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e204), sin(_e204)) * _e100) * vec2(sqrt(((_e203 + 0.5f) / 12f))))), 0f);
let _e220 = (_e202 + 1i);
let _e221 = f32(_e220);
let _e222 = (_e221 * 2.3999631f);
let v546_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e222), sin(_e222)) * _e100) * vec2(sqrt(((_e221 + 0.5f) / 12f))))), 0f);
let _e238 = (_e220 + 1i);
let _e239 = f32(_e238);
let _e240 = (_e239 * 2.3999631f);
let v583_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e240), sin(_e240)) * _e100) * vec2(sqrt(((_e239 + 0.5f) / 12f))))), 0f);
let _e256 = (_e238 + 1i);
let _e257 = f32(_e256);
let _e258 = (_e257 * 2.3999631f);
let v620_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e258), sin(_e258)) * _e100) * vec2(sqrt(((_e257 + 0.5f) / 12f))))), 0f);
let _e274 = (_e256 + 1i);
let _e275 = f32(_e274);
let _e276 = (_e275 * 2.3999631f);
let v657_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e276), sin(_e276)) * _e100) * vec2(sqrt(((_e275 + 0.5f) / 12f))))), 0f);
let _e292 = (_e274 + 1i);
let _e293 = f32(_e292);
let _e294 = (_e293 * 2.3999631f);
let v694_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e294), sin(_e294)) * _e100) * vec2(sqrt(((_e293 + 0.5f) / 12f))))), 0f);
let _e311 = f32((_e292 + 1i));
let _e312 = (_e311 * 2.3999631f);
let v731_ = textureSampleLevel(cover, linear, (_e86 + ((vec2<f32>(cos(_e312), sin(_e312)) * _e100) * vec2(sqrt(((_e311 + 0.5f) / 12f))))), 0f);
stand = ((((((((((((((v250_.xyz + v324_.xyz) + v361_.xyz) + v398_.xyz) + v435_.xyz) + v472_.xyz) + v509_.xyz) + v546_.xyz) + v583_.xyz) + v620_.xyz) + v657_.xyz) + v694_.xyz) + v731_.xyz) / vec3(13f)) * vec3(0.78f));
}
let v93_ = stand;
color = v93_;
let v94_ = u.look.sizes.x;
if (v94_ > 0f) {
let v102_ = u.look.sizes;
let _e349 = v102_.xy;
let _e359 = vec2(0.5f);
let v283_ = textureSampleLevel(hero, linear, (((((v0_1.pixel - vec2(0f)) - (_e10 * _e359)) / vec2((max((_e10.x / _e349.x), (_e10.y / _e349.y)) * 1f))) + (_e349 * _e359)) / _e349), 0f);
let v109_ = stand;
let v110_ = u.look.look.x;
color = mix(v109_, v283_.xyz, vec3(v110_));
}
let v120_ = u.look.screen.z;
let _e390 = (1f - smoothstep(0f, v120_, (v0_1.pixel.x / _e10.x)));
let v136_ = u.look.screen.w;
let _e418 = (1f - (((1f - (((0.86f * _e390) * _e390) * (3f - (2f * _e390)))) * (1f - (0.78f * smoothstep((1f - v136_), 1f, _e35)))) * (1f - (0.4f * (1f - smoothstep(0f, 0.14f, _e35))))));
let v165_ = u.look.tint;
let v170_ = u.look.tint.w;
let _e433 = ((v165_.xyz * vec3(0.05f)) * vec3(v170_));
let v175_ = u.look.behind.x;
let _e439 = smoothstep(0f, 1f, v175_);
let v178_ = color;
let _e442 = vec3(_e418);
let v196_ = u.look.look.y;
let _e472 = ((((mix(v178_, _e433, _e442) * vec3((1f - _e439))) + ((_e433 * _e442) * vec3(_e439))) * vec3(v196_)) + vec3(((fract((sin(dot(floor(v0_1.pixel), vec2<f32>(12.9898f, 78.233f))) * 43758.547f)) - 0.5f) / 255f)));
let v213_ = u.look.look.y;
return backdrop_out(vec4<f32>(_e472.x, _e472.y, _e472.z, (1f - ((_e439 * (1f - _e418)) * v213_))));
}