opendefocus 0.1.10

// This file is automatically generated by xtask. Do not modify manually.
// License: https://opendefocus.codeberg.page/license.html
// Automatic spirv generation by Rust-GPU https://github.com/rust-gpu/rust-gpu

struct opendefocus_shared_ConvolveSettings {
    process_region: vec4<i32>,
    full_region: vec4<i32>,
    resolution: vec2<u32>,
    filter_resolution: vec2<u32>,
    center: vec2<f32>,
    flags: u32,
    non_uniform_flags: u32,
    samples: u32,
    pixel_aspect: f32,
    size: f32,
    max_size: f32,
    catseye_amount: f32,
    catseye_gamma: f32,
    catseye_softness: f32,
    astigmatism_amount: f32,
    astigmatism_gamma: f32,
    barndoors_amount: f32,
    barndoors_gamma: f32,
    barndoors_top: f32,
    barndoors_bottom: f32,
    barndoors_left: f32,
    barndoors_right: f32,
    filter_aspect_ratio_normalizer: f32,
    image_elements: u32,
    ring_distance: f32,
    filter_aspect_ratio: f32,
    pixel_aspect_normalizer: f32,
    render_scale: u32,
    axial_aberration_amount: f32,
    axial_aberration_type: i32,
    _padding: u32,
}

struct type_8 {
    member: opendefocus_shared_ConvolveSettings,
}

struct type_12 {
    member: array<f32>,
}

struct opendefocus_shared_ThreadId {
    x: u32,
    y: u32,
}

struct stages_ring_Ring {
    color: vec4<f32>,
    kernel: vec4<f32>,
    count: u32,
    found: i32,
    weight: f32,
    radius: f32,
    alpha: f32,
    alpha_masked: f32,
    coc: f32,
    deep: f32,
}

struct stages_ring_Rings {
    foreground: stages_ring_Ring,
    background: stages_ring_Ring,
}

struct stages_sample_SampleResult {
    background_sample: f32,
    foreground_sample: f32,
    uses_inpaint: bool,
}

struct datamodel_NonUniformValue {
    offset: vec2<f32>,
    opacity: f32,
    scale: f32,
}

var<private> gid_1: vec3<u32>;
@group(0) @binding(0) 
var<uniform> settings: type_8;
@group(0) @binding(3) 
var<storage, read_write> output_image: type_12;
@group(0) @binding(8) 
var<storage> cached_sample_weights: type_12;
@group(0) @binding(7) 
var depth: texture_2d<f32>;
@group(0) @binding(2) 
var nearest_sampler: sampler;
@group(0) @binding(4) 
var input_image: texture_2d<f32>;
@group(0) @binding(1) 
var bilinear_sampler: sampler;
@group(0) @binding(6) 
var inpaint_image: texture_2d<f32>;
var<private> global: vec2<f32> = vec2<f32>(0f, 0f);
@group(0) @binding(5) 
var filter_: texture_2d<f32>;

fn function() {
    var phi_310_: bool;
    var phi_312_: bool;
    var phi_313_: bool;
    var phi_314_: bool;
    var phi_315_: bool;
    var phi_336_: f32;
    var phi_11454_: f32;
    var phi_11146_: vec4<f32>;
    var phi_10838_: vec4<f32>;
    var phi_10530_: f32;
    var phi_10226_: i32;
    var phi_9922_: f32;
    var phi_9618_: f32;
    var phi_9314_: f32;
    var phi_9010_: vec4<f32>;
    var phi_8706_: vec4<f32>;
    var phi_8392_: bool;
    var phi_371_: opendefocus_shared_ThreadId;
    var phi_372_: opendefocus_shared_ThreadId;
    var phi_395_: opendefocus_shared_ThreadId;
    var phi_440_: u32;
    var phi_465_: u32;
    var phi_488_: f32;
    var phi_500_: f32;
    var phi_502_: f32;
    var phi_503_: f32;
    var phi_504_: bool;
    var phi_529_: opendefocus_shared_ThreadId;
    var phi_532_: stages_ring_Rings;
    var phi_530_: opendefocus_shared_ThreadId;
    var phi_555_: opendefocus_shared_ThreadId;
    var phi_585_: vec2<f32>;
    var phi_602_: vec2<f32>;
    var phi_939_: stages_sample_SampleResult;
    var phi_940_: stages_sample_SampleResult;
    var phi_1603_: vec4<f32>;
    var phi_1816_: bool;
    var phi_1828_: bool;
    var phi_1940_: bool;
    var phi_1973_: bool;
    var phi_1985_: bool;
    var phi_1999_: bool;
    var phi_2011_: bool;
    var phi_2059_: bool;
    var phi_2076_: bool;
    var phi_2090_: bool;
    var phi_2107_: bool;
    var phi_2176_: datamodel_NonUniformValue;
    var phi_2178_: datamodel_NonUniformValue;
    var phi_2179_: bool;
    var phi_2184_: datamodel_NonUniformValue;
    var phi_2747_: bool;
    var phi_2762_: bool;
    var phi_2819_: vec4<f32>;
    var phi_2821_: vec4<f32>;
    var phi_2822_: bool;
    var phi_2220_: u32;
    var phi_6436_: f32;
    var phi_6462_: f32;
    var phi_6522_: f32;
    var phi_6581_: f32;
    var phi_6447_: f32;
    var phi_6629_: f32;
    var phi_6673_: f32;
    var phi_6732_: f32;
    var phi_6640_: f32;
    var phi_6822_: f32;
    var phi_6883_: f32;
    var phi_6942_: f32;
    var phi_6986_: f32;
    var phi_6833_: f32;
    var phi_2273_: bool;
    var phi_2288_: bool;
    var phi_2345_: vec4<f32>;
    var phi_2347_: vec4<f32>;
    var phi_2348_: bool;
    var phi_2390_: bool;
    var phi_2405_: bool;
    var phi_2462_: vec4<f32>;
    var phi_2464_: vec4<f32>;
    var phi_2465_: bool;
    var phi_2507_: bool;
    var phi_2522_: bool;
    var phi_2579_: vec4<f32>;
    var phi_2581_: vec4<f32>;
    var phi_2582_: bool;
    var phi_2624_: bool;
    var phi_2639_: bool;
    var phi_2696_: vec4<f32>;
    var phi_2698_: vec4<f32>;
    var phi_2699_: bool;
    var phi_2827_: vec4<f32>;
    var phi_2911_: f32;
    var phi_2972_: stages_ring_Rings;
    var phi_3642_: vec4<f32>;
    var phi_3643_: vec4<f32>;
    var phi_3856_: bool;
    var phi_3868_: bool;
    var phi_3980_: bool;
    var phi_4013_: bool;
    var phi_4025_: bool;
    var phi_4039_: bool;
    var phi_4051_: bool;
    var phi_4099_: bool;
    var phi_4116_: bool;
    var phi_4130_: bool;
    var phi_4147_: bool;
    var phi_4216_: datamodel_NonUniformValue;
    var phi_4218_: datamodel_NonUniformValue;
    var phi_4219_: bool;
    var phi_4224_: datamodel_NonUniformValue;
    var phi_4787_: bool;
    var phi_4802_: bool;
    var phi_4859_: vec4<f32>;
    var phi_4861_: vec4<f32>;
    var phi_4862_: bool;
    var phi_4260_: u32;
    var phi_7490_: f32;
    var phi_7516_: f32;
    var phi_7576_: f32;
    var phi_7635_: f32;
    var phi_7501_: f32;
    var phi_7683_: f32;
    var phi_7727_: f32;
    var phi_7786_: f32;
    var phi_7694_: f32;
    var phi_7876_: f32;
    var phi_7937_: f32;
    var phi_7996_: f32;
    var phi_8040_: f32;
    var phi_7887_: f32;
    var phi_4313_: bool;
    var phi_4328_: bool;
    var phi_4385_: vec4<f32>;
    var phi_4387_: vec4<f32>;
    var phi_4388_: bool;
    var phi_4430_: bool;
    var phi_4445_: bool;
    var phi_4502_: vec4<f32>;
    var phi_4504_: vec4<f32>;
    var phi_4505_: bool;
    var phi_4547_: bool;
    var phi_4562_: bool;
    var phi_4619_: vec4<f32>;
    var phi_4621_: vec4<f32>;
    var phi_4622_: bool;
    var phi_4664_: bool;
    var phi_4679_: bool;
    var phi_4736_: vec4<f32>;
    var phi_4738_: vec4<f32>;
    var phi_4739_: bool;
    var phi_4867_: vec4<f32>;
    var phi_5012_: stages_ring_Rings;
    var phi_5013_: stages_ring_Rings;
    var phi_533_: stages_ring_Rings;
    var phi_8380_: bool;
    var local: stages_ring_Rings;
    var local_1: stages_ring_Rings;
    var local_2: stages_ring_Rings;
    var phi_5024_: stages_ring_Rings;
    var phi_5148_: f32;
    var phi_11790_: f32;
    var phi_11789_: i32;
    var phi_11788_: f32;
    var phi_11777_: f32;
    var phi_11770_: f32;
    var phi_11763_: vec4<f32>;
    var phi_11756_: vec4<f32>;
    var phi_11752_: f32;
    var phi_11750_: vec4<f32>;
    var phi_11748_: vec4<f32>;
    var phi_11741_: bool;
    var phi_11775_: f32;
    var phi_11768_: f32;
    var phi_11761_: vec4<f32>;
    var phi_11754_: vec4<f32>;
    var phi_11751_: f32;
    var phi_11749_: vec4<f32>;
    var phi_11747_: vec4<f32>;
    var phi_11740_: bool;
    var phi_11787_: f32;
    var phi_11782_: vec4<f32>;
    var phi_11785_: f32;
    var phi_11784_: f32;
    var phi_11783_: vec4<f32>;
    var local_3: stages_ring_Rings;

    switch bitcast<i32>(0u) {
        default: {
            let _e79 = gid_1;
            let _e81 = arrayLength((&output_image.member));
            let _e83 = arrayLength((&cached_sample_weights.member));
            let _e86 = vec2<u32>(_e79.x, _e79.y);
            let _e90 = settings.member.full_region[2u];
            if (_e79.x >= bitcast<u32>(_e90)) {
            } else {
                let _e96 = settings.member.full_region[3u];
                if (_e79.y >= bitcast<u32>(_e96)) {
                } else {
                    let _e102 = settings.member.full_region[0u];
                    let _e104 = bitcast<u32>((_e90 - _e102));
                    let _e105 = f32(_e79.x);
                    let _e106 = f32(_e79.y);
                    let _e110 = settings.member.full_region[1u];
                    let _e113 = f32(_e104);
                    let _e114 = f32(bitcast<u32>((_e96 - _e110)));
                    let _e117 = bitcast<u32>(_e102);
                    let _e118 = (_e117 + _e79.x);
                    let _e119 = bitcast<u32>(_e110);
                    let _e120 = (_e119 + _e79.y);
                    let _e121 = bitcast<i32>(_e118);
                    let _e125 = settings.member.process_region[0u];
                    if (_e121 >= _e125) {
                        let _e130 = settings.member.process_region[2u];
                        if (_e121 < _e130) {
                            let _e132 = bitcast<i32>(_e120);
                            let _e136 = settings.member.process_region[1u];
                            let _e138 = (_e132 >= (_e136 - 1i));
                            if _e138 {
                                let _e142 = settings.member.process_region[3u];
                                phi_310_ = (_e132 <= _e142);
                            } else {
                                phi_310_ = bool();
                            }
                            let _e145 = phi_310_;
                            phi_312_ = _e145;
                            phi_313_ = select(true, false, _e138);
                        } else {
                            phi_312_ = bool();
                            phi_313_ = true;
                        }
                        let _e148 = phi_312_;
                        let _e150 = phi_313_;
                        phi_314_ = _e148;
                        phi_315_ = _e150;
                    } else {
                        phi_314_ = bool();
                        phi_315_ = true;
                    }
                    let _e152 = phi_314_;
                    let _e154 = phi_315_;
                    if !(select(_e152, false, _e154)) {
                    } else {
                        let _e159 = settings.member.flags;
                        let _e161 = ((_e159 & 1u) == 1u);
                        if _e161 {
                            let _e167 = settings.member.max_size;
                            phi_336_ = _e167;
                        } else {
                            let _e163 = textureSampleLevel(depth, nearest_sampler, vec2<f32>((_e105 / _e113), (_e106 / _e114)), 0f);
                            phi_336_ = _e163.x;
                        }
                        let _e169 = phi_336_;
                        let _e172 = settings.member.samples;
                        phi_11454_ = 0f;
                        phi_11146_ = vec4<f32>(0f, 0f, 0f, 0f);
                        phi_10838_ = vec4<f32>(0f, 0f, 0f, 0f);
                        phi_10530_ = 1f;
                        phi_10226_ = 0i;
                        phi_9922_ = 0f;
                        phi_9618_ = 0f;
                        phi_9314_ = 0f;
                        phi_9010_ = vec4<f32>(0f, 0f, 0f, 0f);
                        phi_8706_ = vec4<f32>(0f, 0f, 0f, 0f);
                        phi_8392_ = false;
                        phi_371_ = opendefocus_shared_ThreadId(0u, _e172);
                        loop {
                            let _e175 = phi_11454_;
                            let _e177 = phi_11146_;
                            let _e179 = phi_10838_;
                            let _e181 = phi_10530_;
                            let _e183 = phi_10226_;
                            let _e185 = phi_9922_;
                            let _e187 = phi_9618_;
                            let _e189 = phi_9314_;
                            let _e191 = phi_9010_;
                            let _e193 = phi_8706_;
                            let _e195 = phi_8392_;
                            let _e197 = phi_371_;
                            if (_e197.x < _e197.y) {
                                let _e204 = (_e197.y - 1u);
                                phi_372_ = opendefocus_shared_ThreadId(_e197.x, _e204);
                                phi_395_ = opendefocus_shared_ThreadId(1u, _e204);
                            } else {
                                phi_372_ = _e197;
                                phi_395_ = opendefocus_shared_ThreadId(0u, opendefocus_shared_ThreadId().y);
                            }
                            let _e210 = phi_372_;
                            let _e212 = phi_395_;
                            let _e216 = (bitcast<i32>(_e212.x) != 0i);
                            if _e216 {
                                let _e218 = f32(_e172);
                                let _e221 = settings.member.ring_distance;
                                let _e223 = max((f32(_e212.y) * _e221), 0.00001f);
                                let _e224 = (_e212.y == 0u);
                                if _e224 {
                                    phi_440_ = 1u;
                                } else {
                                    let _e229 = ((_e218 * 0.1f) * f32((20u + (_e212.y * 2u))));
                                    phi_440_ = select(select(u32(_e229), 0u, (_e229 < 0f)), 4294967295u, (_e229 > 4294967000f));
                                }
                                let _e236 = phi_440_;
                                if _e224 {
                                    phi_465_ = 1u;
                                } else {
                                    let _e240 = ((_e218 * 0.1f) * f32((_e212.y * 2u)));
                                    phi_465_ = select(select(u32(_e240), 0u, (_e240 < 0f)), 4294967295u, (_e240 > 4294967000f));
                                }
                                let _e247 = phi_465_;
                                let _e249 = (360f / f32(_e236));
                                let _e250 = stages_ring_Ring(vec4<f32>(0f, 0f, 0f, 0f), vec4<f32>(0f, 0f, 0f, 0f), _e236, 0i, 0f, _e223, 0f, 0f, 0f, 0f);
                                let _e252 = (_e247 == 0u);
                                if _e252 {
                                    phi_503_ = f32();
                                    phi_504_ = true;
                                } else {
                                    let _e253 = (_e236 == 0u);
                                    if _e253 {
                                        phi_502_ = f32();
                                    } else {
                                        if _e252 {
                                            phi_488_ = 1f;
                                        } else {
                                            phi_488_ = (1f / max(((_e223 * (360f / f32(_e247))) * 0.017453292f), 0.0001f));
                                        }
                                        let _e261 = phi_488_;
                                        if _e253 {
                                            phi_500_ = 1f;
                                        } else {
                                            phi_500_ = (1f / max(((_e223 * _e249) * 0.017453292f), 0.0001f));
                                        }
                                        let _e267 = phi_500_;
                                        phi_502_ = (_e267 / _e261);
                                    }
                                    let _e270 = phi_502_;
                                    phi_503_ = _e270;
                                    phi_504_ = _e253;
                                }
                                let _e272 = phi_503_;
                                let _e274 = phi_504_;
                                let _e275 = select(_e272, 1f, _e274);
                                phi_529_ = opendefocus_shared_ThreadId(0u, _e236);
                                phi_532_ = stages_ring_Rings(_e250, _e250);
                                loop {
                                    let _e278 = phi_529_;
                                    let _e280 = phi_532_;
                                    local = _e280;
                                    local_1 = _e280;
                                    local_2 = _e280;
                                    local_3 = _e280;
                                    if (_e278.x < _e278.y) {
                                        phi_530_ = opendefocus_shared_ThreadId((_e278.x + 1u), _e278.y);
                                        phi_555_ = opendefocus_shared_ThreadId(1u, _e278.x);
                                    } else {
                                        phi_530_ = _e278;
                                        phi_555_ = opendefocus_shared_ThreadId(0u, opendefocus_shared_ThreadId().y);
                                    }
                                    let _e293 = phi_530_;
                                    let _e295 = phi_555_;
                                    let _e299 = (bitcast<i32>(_e295.x) != 0i);
                                    if _e299 {
                                        let _e302 = ((_e249 * f32(_e295.y)) * 0.017453292f);
                                        let _e304 = (_e223 * cos(_e302));
                                        let _e306 = (_e223 * sin(_e302));
                                        let _e309 = settings.member.pixel_aspect;
                                        let _e310 = (_e309 > 1f);
                                        if _e310 {
                                            let _e315 = settings.member.pixel_aspect_normalizer;
                                            phi_585_ = vec2<f32>((_e304 * _e315), _e306);
                                        } else {
                                            phi_585_ = vec2<f32>(_e304, (_e306 * _e309));
                                        }
                                        let _e319 = phi_585_;
                                        let _e322 = settings.member.filter_aspect_ratio;
                                        if (_e322 < 1f) {
                                            phi_602_ = vec2<f32>((_e319.x * _e322), _e319.y);
                                        } else {
                                            let _e326 = settings.member.filter_aspect_ratio_normalizer;
                                            phi_602_ = vec2<f32>(_e319.x, (_e319.y * _e326));
                                        }
                                        let _e338 = phi_602_;
                                        let _e341 = (_e338.x + _e105);
                                        let _e342 = (_e338.y + _e106);
                                        let _e343 = (_e341 / _e113);
                                        let _e344 = (_e342 / _e114);
                                        if _e161 {
                                            let _e480 = settings.member.max_size;
                                            phi_940_ = stages_sample_SampleResult(-(_e480), 0f, false);
                                        } else {
                                            let _e346 = textureSampleLevel(depth, nearest_sampler, vec2<f32>(_e343, _e344), 0f);
                                            let _e348 = floor(_e341);
                                            let _e349 = floor(_e342);
                                            let _e350 = (_e341 - _e348);
                                            let _e352 = (_e348 / _e113);
                                            let _e353 = (_e349 / _e114);
                                            let _e355 = textureSampleLevel(depth, nearest_sampler, vec2<f32>(_e352, _e353), 0f);
                                            let _e357 = ((_e348 + 1f) / _e113);
                                            let _e358 = vec2<f32>(_e357, _e353);
                                            let _e359 = textureSampleLevel(depth, nearest_sampler, _e358, 0f);
                                            let _e360 = textureSampleLevel(depth, nearest_sampler, _e358, 0f);
                                            let _e363 = abs((_e360.x - _e346.x));
                                            let _e367 = (f32(select(0u, 1u, (_e363 > 0f))) * _e363);
                                            let _e368 = (_e367 < 1f);
                                            let _e377 = (_e350 * (1f - ((f32(select(0u, 1u, _e368)) * _e367) + f32(select(0u, 1u, !(_e368))))));
                                            let _e378 = (1f - _e377);
                                            let _e390 = ((_e349 + 1f) / _e114);
                                            let _e391 = vec2<f32>(_e352, _e390);
                                            let _e392 = textureSampleLevel(depth, nearest_sampler, _e391, 0f);
                                            let _e393 = textureSampleLevel(depth, nearest_sampler, _e391, 0f);
                                            let _e395 = vec2<f32>(_e357, _e390);
                                            let _e396 = textureSampleLevel(depth, nearest_sampler, _e395, 0f);
                                            let _e397 = textureSampleLevel(depth, nearest_sampler, _e395, 0f);
                                            let _e400 = abs((_e393.x - _e397.x));
                                            let _e404 = (f32(select(0u, 1u, (_e400 > 0f))) * _e400);
                                            let _e405 = (_e404 < 1f);
                                            let _e414 = (_e350 * (1f - ((f32(select(0u, 1u, _e405)) * _e404) + f32(select(0u, 1u, !(_e405))))));
                                            let _e415 = (1f - _e414);
                                            let _e429 = (1f - abs((mix(_e393.x, _e397.x, _e414) - _e346.x)));
                                            let _e433 = (f32(select(0u, 1u, (_e429 > 0f))) * _e429);
                                            let _e434 = (_e433 < 1f);
                                            let _e442 = ((_e342 - _e349) * ((f32(select(0u, 1u, _e434)) * _e433) + f32(select(0u, 1u, !(_e434)))));
                                            let _e443 = (1f - _e442);
                                            let _e448 = ((((_e355.x * _e378) + (_e359.x * _e377)) * _e443) + (((_e392.x * _e415) + (_e396.x * _e414)) * _e442));
                                            let _e450 = (_e448 < 0f);
                                            let _e453 = (_e169 > 0f);
                                            let _e463 = settings.member.max_size;
                                            let _e472 = ((f32(select(0u, 1u, _e450)) * ((f32(select(0u, 1u, _e453)) * -(_e169)) + (f32(select(0u, 1u, !(_e453))) * -(_e463)))) + (f32(select(0u, 1u, !(_e450))) * _e448));
                                            if (_e169 >= 0f) {
                                                phi_939_ = stages_sample_SampleResult(((((_e355.y * _e378) + (_e359.y * _e377)) * _e443) + (((_e392.y * _e415) + (_e396.y * _e414)) * _e442)), _e472, true);
                                            } else {
                                                phi_939_ = stages_sample_SampleResult(_e448, _e472, false);
                                            }
                                            let _e477 = phi_939_;
                                            phi_940_ = _e477;
                                        }
                                        let _e484 = phi_940_;
                                        if _e161 {
                                            phi_2972_ = _e280;
                                        } else {
                                            let _e486 = abs(_e484.foreground_sample);
                                            let _e490 = f32(select(0u, 1u, !((_e484.foreground_sample <= 0f))));
                                            if _e161 {
                                                let _e621 = textureSampleLevel(input_image, bilinear_sampler, vec2<f32>(_e343, _e344), 0f);
                                                phi_1603_ = _e621;
                                            } else {
                                                let _e491 = floor(_e341);
                                                let _e492 = floor(_e342);
                                                let _e493 = (_e341 - _e491);
                                                let _e495 = (_e491 / _e113);
                                                let _e496 = (_e492 / _e114);
                                                let _e498 = textureSampleLevel(input_image, nearest_sampler, vec2<f32>(_e495, _e496), 0f);
                                                let _e500 = ((_e491 + 1f) / _e113);
                                                let _e501 = vec2<f32>(_e500, _e496);
                                                let _e502 = textureSampleLevel(input_image, nearest_sampler, _e501, 0f);
                                                let _e503 = textureSampleLevel(depth, nearest_sampler, _e501, 0f);
                                                let _e506 = abs((_e503.x - _e484.foreground_sample));
                                                let _e510 = (f32(select(0u, 1u, (_e506 > 0f))) * _e506);
                                                let _e511 = (_e510 < 1f);
                                                let _e520 = (_e493 * (1f - ((f32(select(0u, 1u, _e511)) * _e510) + f32(select(0u, 1u, !(_e511))))));
                                                let _e521 = (1f - _e520);
                                                let _e543 = ((_e492 + 1f) / _e114);
                                                let _e544 = vec2<f32>(_e495, _e543);
                                                let _e545 = textureSampleLevel(input_image, nearest_sampler, _e544, 0f);
                                                let _e546 = textureSampleLevel(depth, nearest_sampler, _e544, 0f);
                                                let _e548 = vec2<f32>(_e500, _e543);
                                                let _e549 = textureSampleLevel(input_image, nearest_sampler, _e548, 0f);
                                                let _e550 = textureSampleLevel(depth, nearest_sampler, _e548, 0f);
                                                let _e553 = abs((_e546.x - _e550.x));
                                                let _e557 = (f32(select(0u, 1u, (_e553 > 0f))) * _e553);
                                                let _e558 = (_e557 < 1f);
                                                let _e567 = (_e493 * (1f - ((f32(select(0u, 1u, _e558)) * _e557) + f32(select(0u, 1u, !(_e558))))));
                                                let _e568 = (1f - _e567);
                                                let _e592 = (1f - abs((mix(_e546.x, _e550.x, _e567) - _e484.foreground_sample)));
                                                let _e596 = (f32(select(0u, 1u, (_e592 > 0f))) * _e592);
                                                let _e597 = (_e596 < 1f);
                                                let _e605 = ((_e342 - _e492) * ((f32(select(0u, 1u, _e597)) * _e596) + f32(select(0u, 1u, !(_e597)))));
                                                let _e606 = (1f - _e605);
                                                phi_1603_ = vec4<f32>(((((_e498.x * _e521) + (_e502.x * _e520)) * _e606) + (((_e545.x * _e568) + (_e549.x * _e567)) * _e605)), ((((_e498.y * _e521) + (_e502.y * _e520)) * _e606) + (((_e545.y * _e568) + (_e549.y * _e567)) * _e605)), ((((_e498.z * _e521) + (_e502.z * _e520)) * _e606) + (((_e545.z * _e568) + (_e549.z * _e567)) * _e605)), ((((_e498.w * _e521) + (_e502.w * _e520)) * _e606) + (((_e545.w * _e568) + (_e549.w * _e567)) * _e605)));
                                            }
                                            let _e623 = phi_1603_;
                                            let _e639 = (_e338.x * ((f32(select(0u, 1u, _e310)) * _e309) + f32(select(0u, 1u, !(_e310)))));
                                            let _e640 = (_e309 < 1f);
                                            let _e645 = settings.member.pixel_aspect_normalizer;
                                            let _e651 = (_e338.y * ((f32(select(0u, 1u, _e640)) * _e645) + f32(select(0u, 1u, !(_e640)))));
                                            if ((_e159 & 8u) == 8u) {
                                                let _e654 = (_e484.foreground_sample != 0f);
                                                if _e654 {
                                                    let _e655 = f32(_e118);
                                                    let _e656 = f32(_e120);
                                                    let _e664 = (1f - (2f * f32(select(0u, 1u, ((_e159 & 64u) == 64u)))));
                                                    let _e665 = (_e639 / _e484.foreground_sample);
                                                    let _e667 = (_e665 * 2f);
                                                    let _e668 = ((_e651 / _e484.foreground_sample) * 2f);
                                                    let _e672 = settings.member.center[0u];
                                                    let _e676 = settings.member.center[1u];
                                                    let _e681 = ((((_e655 + _e639) - _e672) / _e672) * _e664);
                                                    let _e682 = ((((_e656 + _e651) - _e676) / _e676) * _e664);
                                                    let _e685 = settings.member.non_uniform_flags;
                                                    let _e687 = ((_e685 & 32u) == 32u);
                                                    let _e692 = settings.member.barndoors_amount;
                                                    let _e693 = (_e486 * 0.2f);
                                                    let _e695 = select(_e693, 0f, (_e693 < 0f));
                                                    let _e698 = (_e692 * select(_e695, 1f, (_e695 > 1f)));
                                                    let _e699 = (_e681 < 0f);
                                                    let _e704 = settings.member.barndoors_right;
                                                    let _e712 = settings.member.barndoors_left;
                                                    let _e717 = (_e682 < 0f);
                                                    let _e722 = settings.member.barndoors_top;
                                                    let _e730 = settings.member.barndoors_bottom;
                                                    let _e737 = settings.member.barndoors_gamma;
                                                    let _e738 = (1f / _e737);
                                                    let _e739 = abs(_e681);
                                                    let _e744 = (bitcast<u32>(_e681) & 2147483648u);
                                                    let _e747 = abs(_e682);
                                                    let _e752 = (bitcast<u32>(_e682) & 2147483648u);
                                                    let _e756 = ((_e685 & 64u) == 64u);
                                                    let _e765 = ((_e685 & 128u) == 128u);
                                                    if _e765 {
                                                        phi_1816_ = (_e484.foreground_sample > 0f);
                                                    } else {
                                                        phi_1816_ = false;
                                                    }
                                                    let _e768 = phi_1816_;
                                                    if _e765 {
                                                        phi_1828_ = (_e484.foreground_sample > 0f);
                                                    } else {
                                                        phi_1828_ = false;
                                                    }
                                                    let _e774 = phi_1828_;
                                                    let _e779 = ((f32(select(0u, 1u, _e756)) + (f32(select(0u, 1u, !(_e756))) * -1f)) * ((f32(select(0u, 1u, _e768)) * -1f) + f32(select(0u, 1u, !(_e774)))));
                                                    let _e811 = f32(select(0u, 1u, ((_e685 & 16u) == 16u)));
                                                    let _e813 = (vec2<u32>(_e117, _e119) + _e86);
                                                    let _e816 = f32(_e813.x);
                                                    let _e817 = f32(_e813.y);
                                                    let _e818 = (_e672 - _e816);
                                                    let _e819 = (_e676 - _e817);
                                                    let _e820 = (_e817 < _e676);
                                                    let _e825 = -(_e818);
                                                    let _e832 = atan2(_e819, _e818);
                                                    let _e835 = ((f32(select(0u, 1u, _e820)) * (atan2(-(abs(_e819)), _e825) + 1.5707964f)) + (f32(select(0u, 1u, !(_e820))) * (_e832 + 1.5707964f)));
                                                    let _e836 = (_e816 < _e672);
                                                    let _e846 = ((f32(select(0u, 1u, _e836)) * _e832) + (f32(select(0u, 1u, !(_e836))) * atan2(-(_e819), _e825)));
                                                    let _e862 = settings.member.astigmatism_amount;
                                                    let _e869 = settings.member.astigmatism_gamma;
                                                    let _e870 = (1f / _e869);
                                                    let _e878 = global[0u];
                                                    if ((_e655 - _e681) == _e878) {
                                                        let _e881 = global[1u];
                                                        phi_1940_ = ((_e656 - _e682) == _e881);
                                                    } else {
                                                        phi_1940_ = false;
                                                    }
                                                    let _e884 = phi_1940_;
                                                    let _e887 = f32(select(0u, 1u, !(_e884)));
                                                    let _e896 = datamodel_NonUniformValue(vec2<f32>((_e811 * (_e887 * ((((((_e667 * cos(_e835)) + (_e668 * sin(_e835))) * _e484.foreground_sample) * _e862) * 0.4f) * pow(_e747, _e870)))), (_e811 * (_e887 * (((((((_e665 * -2f) * sin(_e846)) + (_e668 * cos(_e846))) * _e484.foreground_sample) * _e862) * 0.4f) * pow(_e739, _e870))))), datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f).opacity, datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f).scale);
                                                    let _e897 = (_e484.foreground_sample > 0f);
                                                    if _e897 {
                                                        phi_1973_ = ((_e685 & 2u) == 2u);
                                                    } else {
                                                        phi_1973_ = false;
                                                    }
                                                    let _e901 = phi_1973_;
                                                    if _e897 {
                                                        phi_1985_ = ((_e685 & 2u) == 2u);
                                                    } else {
                                                        phi_1985_ = false;
                                                    }
                                                    let _e908 = phi_1985_;
                                                    if _e897 {
                                                        phi_1999_ = ((_e685 & 4u) == 4u);
                                                    } else {
                                                        phi_1999_ = false;
                                                    }
                                                    let _e916 = phi_1999_;
                                                    if _e897 {
                                                        phi_2011_ = ((_e685 & 4u) == 4u);
                                                    } else {
                                                        phi_2011_ = false;
                                                    }
                                                    let _e923 = phi_2011_;
                                                    let _e928 = (((f32(select(0u, 1u, _e901)) * -1f) + f32(select(0u, 1u, !(_e908)))) * ((f32(select(0u, 1u, _e916)) * -1f) + f32(select(0u, 1u, !(_e923)))));
                                                    let _e930 = abs((_e484.foreground_sample * 0.2f));
                                                    let _e932 = select(_e930, 0f, (_e930 < 0f));
                                                    let _e934 = select(_e932, 1f, (_e932 > 1f));
                                                    let _e935 = (_e681 * _e934);
                                                    let _e936 = (_e682 * _e934);
                                                    let _e940 = settings.member.resolution[1u];
                                                    let _e942 = (f32(_e940) * _e645);
                                                    let _e944 = ((_e685 & 8u) == 8u);
                                                    if _e944 {
                                                        let _e948 = settings.member.resolution[0u];
                                                        phi_2059_ = (f32(_e948) > _e942);
                                                    } else {
                                                        phi_2059_ = false;
                                                    }
                                                    let _e952 = phi_2059_;
                                                    let _e958 = settings.member.resolution[0u];
                                                    let _e959 = f32(_e958);
                                                    if _e944 {
                                                        phi_2076_ = (_e959 > _e942);
                                                    } else {
                                                        phi_2076_ = false;
                                                    }
                                                    let _e964 = phi_2076_;
                                                    if _e944 {
                                                        phi_2090_ = (_e959 < _e942);
                                                    } else {
                                                        phi_2090_ = false;
                                                    }
                                                    let _e971 = phi_2090_;
                                                    if _e944 {
                                                        phi_2107_ = (_e959 < _e942);
                                                    } else {
                                                        phi_2107_ = false;
                                                    }
                                                    let _e978 = phi_2107_;
                                                    let _e985 = settings.member.catseye_gamma;
                                                    let _e1006 = settings.member.catseye_amount;
                                                    let _e1011 = (_e667 + (_e928 * (bitcast<f32>(((bitcast<u32>(pow(abs(_e935), (((f32(select(0u, 1u, _e952)) * (_e942 / _e959)) + f32(select(0u, 1u, !(_e964)))) / _e985))) & 2147483647u) | (bitcast<u32>(_e935) & 2147483648u))) * _e1006)));
                                                    let _e1012 = (_e668 + (_e928 * (bitcast<f32>(((bitcast<u32>(pow(abs(_e936), (((f32(select(0u, 1u, _e971)) * (_e959 / _e942)) + f32(select(0u, 1u, !(_e978)))) / _e985))) & 2147483647u) | (bitcast<u32>(_e936) & 2147483648u))) * _e1006)));
                                                    let _e1020 = settings.member.catseye_softness;
                                                    let _e1022 = ((1f - (((_e1011 * _e1011) + (_e1012 * _e1012)) * 0.25f)) / (_e1020 * 0.5f));
                                                    let _e1024 = select(_e1022, 0f, (_e1022 < 0f));
                                                    phi_2176_ = datamodel_NonUniformValue(_e896.offset, (((f32(select(0u, 1u, _e687)) * min(f32(select(0u, 1u, ((1f - (((_e779 * _e667) + (((_e698 * ((f32(select(0u, 1u, _e699)) * (_e704 * 0.02f)) + (f32(select(0u, 1u, !(_e699))) * (_e712 * 0.02f)))) - 0.5f) * bitcast<f32>((1065353216u | _e744)))) * bitcast<f32>(((bitcast<u32>(pow(_e739, _e738)) & 2147483647u) | _e744)))) > 0f))), f32(select(0u, 1u, ((1f - (((_e779 * _e668) + (((_e698 * ((f32(select(0u, 1u, _e717)) * (_e722 * 0.02f)) + (f32(select(0u, 1u, !(_e717))) * (_e730 * 0.02f)))) - 0.5f) * bitcast<f32>((1065353216u | _e752)))) * bitcast<f32>(((bitcast<u32>(pow(_e747, _e738)) & 2147483647u) | _e752)))) > 0f))))) + f32(select(0u, 1u, !(_e687)))) * select(_e1024, 1f, (_e1024 > 1f))), _e896.scale);
                                                } else {
                                                    phi_2176_ = datamodel_NonUniformValue();
                                                }
                                                let _e1033 = phi_2176_;
                                                phi_2178_ = _e1033;
                                                phi_2179_ = select(true, false, _e654);
                                            } else {
                                                phi_2178_ = datamodel_NonUniformValue();
                                                phi_2179_ = true;
                                            }
                                            let _e1036 = phi_2178_;
                                            let _e1038 = phi_2179_;
                                            if _e1038 {
                                                phi_2184_ = datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f);
                                            } else {
                                                phi_2184_ = _e1036;
                                            }
                                            let _e1040 = phi_2184_;
                                            let _e1043 = settings.member.render_scale;
                                            let _e1048 = smoothstep(0f, 1f, abs(((_e486 * f32(_e1043)) * 0.75f)));
                                            if ((_e159 & 32u) == 32u) {
                                                let _e1137 = settings.member.axial_aberration_amount;
                                                let _e1140 = settings.member.axial_aberration_type;
                                                switch _e1140 {
                                                    case 1: {
                                                        phi_2220_ = 1u;
                                                        break;
                                                    }
                                                    case 2: {
                                                        phi_2220_ = 2u;
                                                        break;
                                                    }
                                                    case 3: {
                                                        phi_2220_ = 3u;
                                                        break;
                                                    }
                                                    default: {
                                                        phi_2220_ = 1u;
                                                        break;
                                                    }
                                                }
                                                let _e1142 = phi_2220_;
                                                let _e1143 = (_e1137 * 0.25f);
                                                let _e1145 = (_e484.foreground_sample * _e1040.scale);
                                                let _e1146 = (_e1145 < 0f);
                                                if _e1146 {
                                                    phi_6436_ = _e1137;
                                                } else {
                                                    phi_6436_ = -(_e1137);
                                                }
                                                let _e1149 = phi_6436_;
                                                switch bitcast<i32>(_e1142) {
                                                    case 1: {
                                                        let _e1163 = (_e1149 > 0f);
                                                        if _e1163 {
                                                            phi_6581_ = abs(_e1143);
                                                        } else {
                                                            phi_6581_ = f32();
                                                        }
                                                        let _e1166 = phi_6581_;
                                                        phi_6447_ = select(_e1166, 0f, select(true, false, _e1163));
                                                        break;
                                                    }
                                                    case 2: {
                                                        let _e1157 = (_e1149 < 0f);
                                                        if _e1157 {
                                                            phi_6522_ = abs(_e1143);
                                                        } else {
                                                            phi_6522_ = f32();
                                                        }
                                                        let _e1160 = phi_6522_;
                                                        phi_6447_ = select(_e1160, 0f, select(true, false, _e1157));
                                                        break;
                                                    }
                                                    case 3: {
                                                        let _e1151 = (_e1149 > 0f);
                                                        if _e1151 {
                                                            phi_6462_ = abs(_e1143);
                                                        } else {
                                                            phi_6462_ = f32();
                                                        }
                                                        let _e1154 = phi_6462_;
                                                        phi_6447_ = select(_e1154, 0f, select(true, false, _e1151));
                                                        break;
                                                    }
                                                    default: {
                                                        phi_6447_ = f32();
                                                        break;
                                                    }
                                                }
                                                let _e1170 = phi_6447_;
                                                let _e1172 = (_e1145 * (1f - _e1170));
                                                if _e1146 {
                                                    phi_6629_ = _e1137;
                                                } else {
                                                    phi_6629_ = -(_e1137);
                                                }
                                                let _e1175 = phi_6629_;
                                                switch bitcast<i32>(_e1142) {
                                                    case 1: {
                                                        phi_6640_ = (abs(_e1143) * 0.5f);
                                                        break;
                                                    }
                                                    case 2: {
                                                        let _e1184 = (_e1175 < 0f);
                                                        if _e1184 {
                                                            phi_6732_ = abs(_e1143);
                                                        } else {
                                                            phi_6732_ = f32();
                                                        }
                                                        let _e1187 = phi_6732_;
                                                        phi_6640_ = select(_e1187, 0f, select(true, false, _e1184));
                                                        break;
                                                    }
                                                    case 3: {
                                                        let _e1177 = (_e1175 < 0f);
                                                        if _e1177 {
                                                            phi_6673_ = (abs(_e1143) * 0.5f);
                                                        } else {
                                                            phi_6673_ = f32();
                                                        }
                                                        let _e1181 = phi_6673_;
                                                        phi_6640_ = select(_e1181, 0f, select(true, false, _e1177));
                                                        break;
                                                    }
                                                    default: {
                                                        phi_6640_ = f32();
                                                        break;
                                                    }
                                                }
                                                let _e1193 = phi_6640_;
                                                let _e1195 = (_e1145 * (1f - _e1193));
                                                if _e1146 {
                                                    phi_6822_ = _e1137;
                                                } else {
                                                    phi_6822_ = -(_e1137);
                                                }
                                                let _e1198 = phi_6822_;
                                                switch bitcast<i32>(_e1142) {
                                                    case 1: {
                                                        let _e1212 = (_e1198 < 0f);
                                                        if _e1212 {
                                                            phi_6986_ = abs(_e1143);
                                                        } else {
                                                            phi_6986_ = f32();
                                                        }
                                                        let _e1215 = phi_6986_;
                                                        phi_6833_ = select(_e1215, 0f, select(true, false, _e1212));
                                                        break;
                                                    }
                                                    case 2: {
                                                        let _e1206 = (_e1198 > 0f);
                                                        if _e1206 {
                                                            phi_6942_ = abs(_e1143);
                                                        } else {
                                                            phi_6942_ = f32();
                                                        }
                                                        let _e1209 = phi_6942_;
                                                        phi_6833_ = select(_e1209, 0f, select(true, false, _e1206));
                                                        break;
                                                    }
                                                    case 3: {
                                                        let _e1200 = (_e1198 > 0f);
                                                        if _e1200 {
                                                            phi_6883_ = abs(_e1143);
                                                        } else {
                                                            phi_6883_ = f32();
                                                        }
                                                        let _e1203 = phi_6883_;
                                                        phi_6833_ = select(_e1203, 0f, select(true, false, _e1200));
                                                        break;
                                                    }
                                                    default: {
                                                        phi_6833_ = f32();
                                                        break;
                                                    }
                                                }
                                                let _e1219 = phi_6833_;
                                                let _e1221 = (_e1145 * (1f - _e1219));
                                                let _e1230 = max((abs(_e1172) * 2f), 1f);
                                                let _e1234 = settings.member.filter_resolution[0u];
                                                let _e1235 = f32(_e1234);
                                                let _e1239 = settings.member.filter_resolution[1u];
                                                let _e1240 = f32(_e1239);
                                                let _e1243 = -((_e1040.offset.x + _e338.x));
                                                let _e1244 = -((_e1040.offset.y + _e338.y));
                                                let _e1247 = (_e1235 * 0.5f);
                                                let _e1248 = (_e1240 * 0.5f);
                                                let _e1249 = ((_e1243 * (_e1235 / _e1230)) + _e1247);
                                                let _e1250 = ((_e1244 * (_e1240 / _e1230)) + _e1248);
                                                let _e1251 = (_e1172 > 0f);
                                                if _e1251 {
                                                    phi_2273_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2273_ = false;
                                                }
                                                let _e1255 = phi_2273_;
                                                let _e1257 = f32(select(0u, 1u, _e1255));
                                                if _e1251 {
                                                    phi_2288_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2288_ = false;
                                                }
                                                let _e1265 = phi_2288_;
                                                let _e1268 = f32(select(0u, 1u, !(_e1265)));
                                                let _e1273 = (_e1230 / _e1235);
                                                let _e1274 = (_e1230 / _e1240);
                                                let _e1280 = (((_e1257 * (_e1249 - 1f)) + (_e1268 * _e1249)) / _e1235);
                                                let _e1281 = (((_e1257 * (_e1250 - 1f)) + (_e1268 * _e1250)) / _e1240);
                                                let _e1289 = ((pow(((_e1280 - 0.5f) * 2f), 2f) + pow(((_e1281 - 0.5f) * 2f), 2f)) >= 1f);
                                                if _e1289 {
                                                    phi_2347_ = vec4<f32>();
                                                    phi_2348_ = true;
                                                } else {
                                                    let _e1291 = ((_e159 & 2u) == 2u);
                                                    if _e1291 {
                                                        phi_2345_ = vec4<f32>();
                                                    } else {
                                                        let _e1293 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e1280, _e1281), max(0f, log2((1f / select(_e1274, _e1273, (_e1273 > _e1274))))));
                                                        phi_2345_ = _e1293;
                                                    }
                                                    let _e1295 = phi_2345_;
                                                    phi_2347_ = _e1295;
                                                    phi_2348_ = _e1291;
                                                }
                                                let _e1297 = phi_2347_;
                                                let _e1299 = phi_2348_;
                                                let _e1307 = max((abs(_e1195) * 2f), 1f);
                                                let _e1312 = ((_e1243 * (_e1235 / _e1307)) + _e1247);
                                                let _e1313 = ((_e1244 * (_e1240 / _e1307)) + _e1248);
                                                let _e1314 = (_e1195 > 0f);
                                                if _e1314 {
                                                    phi_2390_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2390_ = false;
                                                }
                                                let _e1318 = phi_2390_;
                                                let _e1320 = f32(select(0u, 1u, _e1318));
                                                if _e1314 {
                                                    phi_2405_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2405_ = false;
                                                }
                                                let _e1328 = phi_2405_;
                                                let _e1331 = f32(select(0u, 1u, !(_e1328)));
                                                let _e1336 = (_e1307 / _e1235);
                                                let _e1337 = (_e1307 / _e1240);
                                                let _e1343 = (((_e1320 * (_e1312 - 1f)) + (_e1331 * _e1312)) / _e1235);
                                                let _e1344 = (((_e1320 * (_e1313 - 1f)) + (_e1331 * _e1313)) / _e1240);
                                                let _e1352 = ((pow(((_e1343 - 0.5f) * 2f), 2f) + pow(((_e1344 - 0.5f) * 2f), 2f)) >= 1f);
                                                if _e1352 {
                                                    phi_2464_ = vec4<f32>();
                                                    phi_2465_ = true;
                                                } else {
                                                    let _e1354 = ((_e159 & 2u) == 2u);
                                                    if _e1354 {
                                                        phi_2462_ = vec4<f32>();
                                                    } else {
                                                        let _e1356 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e1343, _e1344), max(0f, log2((1f / select(_e1337, _e1336, (_e1336 > _e1337))))));
                                                        phi_2462_ = _e1356;
                                                    }
                                                    let _e1358 = phi_2462_;
                                                    phi_2464_ = _e1358;
                                                    phi_2465_ = _e1354;
                                                }
                                                let _e1360 = phi_2464_;
                                                let _e1362 = phi_2465_;
                                                let _e1370 = max((abs(_e1221) * 2f), 1f);
                                                let _e1375 = ((_e1243 * (_e1235 / _e1370)) + _e1247);
                                                let _e1376 = ((_e1244 * (_e1240 / _e1370)) + _e1248);
                                                let _e1377 = (_e1221 > 0f);
                                                if _e1377 {
                                                    phi_2507_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2507_ = false;
                                                }
                                                let _e1381 = phi_2507_;
                                                let _e1383 = f32(select(0u, 1u, _e1381));
                                                if _e1377 {
                                                    phi_2522_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2522_ = false;
                                                }
                                                let _e1391 = phi_2522_;
                                                let _e1394 = f32(select(0u, 1u, !(_e1391)));
                                                let _e1399 = (_e1370 / _e1235);
                                                let _e1400 = (_e1370 / _e1240);
                                                let _e1406 = (((_e1383 * (_e1375 - 1f)) + (_e1394 * _e1375)) / _e1235);
                                                let _e1407 = (((_e1383 * (_e1376 - 1f)) + (_e1394 * _e1376)) / _e1240);
                                                let _e1415 = ((pow(((_e1406 - 0.5f) * 2f), 2f) + pow(((_e1407 - 0.5f) * 2f), 2f)) >= 1f);
                                                if _e1415 {
                                                    phi_2581_ = vec4<f32>();
                                                    phi_2582_ = true;
                                                } else {
                                                    let _e1417 = ((_e159 & 2u) == 2u);
                                                    if _e1417 {
                                                        phi_2579_ = vec4<f32>();
                                                    } else {
                                                        let _e1419 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e1406, _e1407), max(0f, log2((1f / select(_e1400, _e1399, (_e1399 > _e1400))))));
                                                        phi_2579_ = _e1419;
                                                    }
                                                    let _e1421 = phi_2579_;
                                                    phi_2581_ = _e1421;
                                                    phi_2582_ = _e1417;
                                                }
                                                let _e1423 = phi_2581_;
                                                let _e1425 = phi_2582_;
                                                let _e1433 = max((abs(_e1145) * 2f), 1f);
                                                let _e1438 = ((_e1243 * (_e1235 / _e1433)) + _e1247);
                                                let _e1439 = ((_e1244 * (_e1240 / _e1433)) + _e1248);
                                                let _e1440 = (_e1145 > 0f);
                                                if _e1440 {
                                                    phi_2624_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2624_ = false;
                                                }
                                                let _e1444 = phi_2624_;
                                                let _e1446 = f32(select(0u, 1u, _e1444));
                                                if _e1440 {
                                                    phi_2639_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2639_ = false;
                                                }
                                                let _e1454 = phi_2639_;
                                                let _e1457 = f32(select(0u, 1u, !(_e1454)));
                                                let _e1462 = (_e1433 / _e1235);
                                                let _e1463 = (_e1433 / _e1240);
                                                let _e1469 = (((_e1446 * (_e1438 - 1f)) + (_e1457 * _e1438)) / _e1235);
                                                let _e1470 = (((_e1446 * (_e1439 - 1f)) + (_e1457 * _e1439)) / _e1240);
                                                let _e1478 = ((pow(((_e1469 - 0.5f) * 2f), 2f) + pow(((_e1470 - 0.5f) * 2f), 2f)) >= 1f);
                                                if _e1478 {
                                                    phi_2698_ = vec4<f32>();
                                                    phi_2699_ = true;
                                                } else {
                                                    let _e1480 = ((_e159 & 2u) == 2u);
                                                    if _e1480 {
                                                        phi_2696_ = vec4<f32>();
                                                    } else {
                                                        let _e1482 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e1469, _e1470), max(0f, log2((1f / select(_e1463, _e1462, (_e1462 > _e1463))))));
                                                        phi_2696_ = _e1482;
                                                    }
                                                    let _e1484 = phi_2696_;
                                                    phi_2698_ = _e1484;
                                                    phi_2699_ = _e1480;
                                                }
                                                let _e1486 = phi_2698_;
                                                let _e1488 = phi_2699_;
                                                phi_2827_ = vec4<f32>(select(_e1297, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e1289)), vec4(_e1299)).x, select(_e1360, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e1352)), vec4(_e1362)).y, select(_e1423, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e1415)), vec4(_e1425)).z, select(_e1486, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e1478)), vec4(_e1488)).w);
                                            } else {
                                                let _e1052 = (_e484.foreground_sample * _e1040.scale);
                                                let _e1061 = max((abs(_e1052) * 2f), 1f);
                                                let _e1065 = settings.member.filter_resolution[0u];
                                                let _e1066 = f32(_e1065);
                                                let _e1070 = settings.member.filter_resolution[1u];
                                                let _e1071 = f32(_e1070);
                                                let _e1080 = ((-((_e1040.offset.x + _e338.x)) * (_e1066 / _e1061)) + (_e1066 * 0.5f));
                                                let _e1081 = ((-((_e1040.offset.y + _e338.y)) * (_e1071 / _e1061)) + (_e1071 * 0.5f));
                                                let _e1082 = (_e1052 > 0f);
                                                if _e1082 {
                                                    phi_2747_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2747_ = false;
                                                }
                                                let _e1086 = phi_2747_;
                                                let _e1088 = f32(select(0u, 1u, _e1086));
                                                if _e1082 {
                                                    phi_2762_ = ((_e159 & 16u) == 16u);
                                                } else {
                                                    phi_2762_ = false;
                                                }
                                                let _e1096 = phi_2762_;
                                                let _e1099 = f32(select(0u, 1u, !(_e1096)));
                                                let _e1104 = (_e1061 / _e1066);
                                                let _e1105 = (_e1061 / _e1071);
                                                let _e1111 = (((_e1088 * (_e1080 - 1f)) + (_e1099 * _e1080)) / _e1066);
                                                let _e1112 = (((_e1088 * (_e1081 - 1f)) + (_e1099 * _e1081)) / _e1071);
                                                let _e1120 = ((pow(((_e1111 - 0.5f) * 2f), 2f) + pow(((_e1112 - 0.5f) * 2f), 2f)) >= 1f);
                                                if _e1120 {
                                                    phi_2821_ = vec4<f32>();
                                                    phi_2822_ = true;
                                                } else {
                                                    let _e1122 = ((_e159 & 2u) == 2u);
                                                    if _e1122 {
                                                        phi_2819_ = vec4<f32>();
                                                    } else {
                                                        let _e1124 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e1111, _e1112), max(0f, log2((1f / select(_e1105, _e1104, (_e1104 > _e1105))))));
                                                        phi_2819_ = _e1124;
                                                    }
                                                    let _e1126 = phi_2819_;
                                                    phi_2821_ = _e1126;
                                                    phi_2822_ = _e1122;
                                                }
                                                let _e1128 = phi_2821_;
                                                let _e1130 = phi_2822_;
                                                phi_2827_ = select(_e1128, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e1120)), vec4(_e1130));
                                            }
                                            let _e1496 = phi_2827_;
                                            let _e1503 = (_e1496.z * _e1040.opacity);
                                            let _e1507 = abs(_e486);
                                            let _e1508 = floor(_e1507);
                                            let _e1513 = select(select(u32(_e1508), 0u, (_e1508 < 0f)), 4294967295u, (_e1508 > 4294967000f));
                                            let _e1514 = ceil(_e1507);
                                            let _e1519 = select(select(u32(_e1514), 0u, (_e1514 < 0f)), 4294967295u, (_e1514 > 4294967000f));
                                            if (_e1513 < _e83) {
                                            } else {
                                                phi_8380_ = true;
                                                break;
                                            }
                                            let _e1523 = cached_sample_weights.member[_e1513];
                                            if (_e1519 < _e83) {
                                            } else {
                                                phi_8380_ = true;
                                                break;
                                            }
                                            let _e1527 = cached_sample_weights.member[_e1519];
                                            let _e1530 = (mix(_e1523, _e1527, (_e1507 - _e1508)) / _e275);
                                            let _e1538 = (((_e490 * _e623.w) * (_e1496.w * _e1040.opacity)) * _e1048);
                                            let _e1541 = select(false, true, (_e484.foreground_sample >= 0f));
                                            if _e1541 {
                                                phi_2911_ = (_e1048 * _e1503);
                                            } else {
                                                phi_2911_ = 0f;
                                            }
                                            let _e1545 = phi_2911_;
                                            let _e1546 = (vec4<f32>((((_e490 * _e623.x) * (_e1496.x * _e1040.opacity)) * _e1048), (((_e490 * _e623.y) * (_e1496.y * _e1040.opacity)) * _e1048), (((_e490 * _e623.z) * _e1503) * _e1048), _e1538) * _e1530);
                                            let _e1547 = ((_e1496 * _e1040.opacity) * _e1530);
                                            let _e1555 = (_e280.foreground.color.x + _e1546.x);
                                            let _e1574 = stages_ring_Rings(stages_ring_Ring(vec4<f32>(_e1555, _e280.foreground.color.y, _e280.foreground.color.z, _e280.foreground.color.w), _e280.foreground.kernel, _e280.foreground.count, _e280.foreground.found, _e280.foreground.weight, _e280.foreground.radius, _e280.foreground.alpha, _e280.foreground.alpha_masked, _e280.foreground.coc, _e280.foreground.deep), _e280.background);
                                            let _e1579 = (_e280.foreground.color.y + _e1546.y);
                                            let _e1598 = stages_ring_Rings(stages_ring_Ring(vec4<f32>(_e1574.foreground.color.x, _e1579, _e1574.foreground.color.z, _e1574.foreground.color.w), _e1574.foreground.kernel, _e1574.foreground.count, _e1574.foreground.found, _e1574.foreground.weight, _e1574.foreground.radius, _e1574.foreground.alpha, _e1574.foreground.alpha_masked, _e1574.foreground.coc, _e1574.foreground.deep), _e1574.background);
                                            let _e1603 = (_e280.foreground.color.z + _e1546.z);
                                            let _e1622 = stages_ring_Rings(stages_ring_Ring(vec4<f32>(_e1598.foreground.color.x, _e1598.foreground.color.y, _e1603, _e1598.foreground.color.w), _e1598.foreground.kernel, _e1598.foreground.count, _e1598.foreground.found, _e1598.foreground.weight, _e1598.foreground.radius, _e1598.foreground.alpha, _e1598.foreground.alpha_masked, _e1598.foreground.coc, _e1598.foreground.deep), _e1598.background);
                                            let _e1642 = stages_ring_Rings(stages_ring_Ring(vec4<f32>(_e1555, _e1579, _e1603, (_e280.foreground.color.w + _e1546.w)), _e1622.foreground.kernel, _e1622.foreground.count, _e1622.foreground.found, _e1622.foreground.weight, _e1622.foreground.radius, _e1622.foreground.alpha, _e1622.foreground.alpha_masked, _e1622.foreground.coc, _e1622.foreground.deep), _e1622.background);
                                            let _e1647 = (_e280.foreground.kernel.x + _e1547.x);
                                            let _e1666 = stages_ring_Rings(stages_ring_Ring(_e1642.foreground.color, vec4<f32>(_e1647, _e1642.foreground.kernel.y, _e1642.foreground.kernel.z, _e1642.foreground.kernel.w), _e1642.foreground.count, _e1642.foreground.found, _e1642.foreground.weight, _e1642.foreground.radius, _e1642.foreground.alpha, _e1642.foreground.alpha_masked, _e1642.foreground.coc, _e1642.foreground.deep), _e1642.background);
                                            let _e1671 = (_e280.foreground.kernel.y + _e1547.y);
                                            let _e1690 = stages_ring_Rings(stages_ring_Ring(_e1666.foreground.color, vec4<f32>(_e1666.foreground.kernel.x, _e1671, _e1666.foreground.kernel.z, _e1666.foreground.kernel.w), _e1666.foreground.count, _e1666.foreground.found, _e1666.foreground.weight, _e1666.foreground.radius, _e1666.foreground.alpha, _e1666.foreground.alpha_masked, _e1666.foreground.coc, _e1666.foreground.deep), _e1666.background);
                                            let _e1695 = (_e280.foreground.kernel.z + _e1547.z);
                                            let _e1714 = stages_ring_Rings(stages_ring_Ring(_e1690.foreground.color, vec4<f32>(_e1690.foreground.kernel.x, _e1690.foreground.kernel.y, _e1695, _e1690.foreground.kernel.w), _e1690.foreground.count, _e1690.foreground.found, _e1690.foreground.weight, _e1690.foreground.radius, _e1690.foreground.alpha, _e1690.foreground.alpha_masked, _e1690.foreground.coc, _e1690.foreground.deep), _e1690.background);
                                            let _e1734 = stages_ring_Rings(stages_ring_Ring(_e1714.foreground.color, vec4<f32>(_e1647, _e1671, _e1695, (_e280.foreground.kernel.w + _e1547.w)), _e1714.foreground.count, _e1714.foreground.found, _e1714.foreground.weight, _e1714.foreground.radius, _e1714.foreground.alpha, _e1714.foreground.alpha_masked, _e1714.foreground.coc, _e1714.foreground.deep), _e1714.background);
                                            let _e1751 = stages_ring_Rings(stages_ring_Ring(_e1734.foreground.color, _e1734.foreground.kernel, _e1734.foreground.count, _e1734.foreground.found, _e1734.foreground.weight, _e1734.foreground.radius, _e1734.foreground.alpha, (_e280.foreground.alpha_masked + (_e1545 * _e1530)), _e1734.foreground.coc, _e1734.foreground.deep), _e1734.background);
                                            let _e1768 = stages_ring_Rings(stages_ring_Ring(_e1751.foreground.color, _e1751.foreground.kernel, _e1751.foreground.count, _e1751.foreground.found, _e1751.foreground.weight, _e1751.foreground.radius, (_e280.foreground.alpha + (select(0f, _e1503, _e1541) * _e1530)), _e1751.foreground.alpha_masked, _e1751.foreground.coc, _e1751.foreground.deep), _e1751.background);
                                            let _e1785 = stages_ring_Rings(stages_ring_Ring(_e1768.foreground.color, _e1768.foreground.kernel, _e1768.foreground.count, _e1768.foreground.found, (_e280.foreground.weight + _e1530), _e1768.foreground.radius, _e1768.foreground.alpha, _e1768.foreground.alpha_masked, _e1768.foreground.coc, _e1768.foreground.deep), _e1768.background);
                                            let _e1802 = stages_ring_Rings(stages_ring_Ring(_e1785.foreground.color, _e1785.foreground.kernel, _e1785.foreground.count, (_e280.foreground.found + 1i), _e1785.foreground.weight, _e1785.foreground.radius, _e1785.foreground.alpha, _e1785.foreground.alpha_masked, _e1785.foreground.coc, _e1785.foreground.deep), _e1785.background);
                                            let _e1819 = stages_ring_Rings(stages_ring_Ring(_e1802.foreground.color, _e1802.foreground.kernel, _e1802.foreground.count, _e1802.foreground.found, _e1802.foreground.weight, _e1802.foreground.radius, _e1802.foreground.alpha, _e1802.foreground.alpha_masked, (_e280.foreground.coc + _e486), _e1802.foreground.deep), _e1802.background);
                                            phi_2972_ = stages_ring_Rings(stages_ring_Ring(_e1819.foreground.color, _e1819.foreground.kernel, _e1819.foreground.count, _e1819.foreground.found, _e1819.foreground.weight, _e1819.foreground.radius, _e1819.foreground.alpha, _e1819.foreground.alpha_masked, _e1819.foreground.coc, (_e280.foreground.deep + (_e1538 * _e1530))), _e1819.background);
                                        }
                                        let _e1838 = phi_2972_;
                                        let _e1843 = abs(_e484.background_sample);
                                        if (_e484.background_sample < 0f) {
                                            if (((_e338.x * _e338.x) + (_e338.y * _e338.y)) <= pow(ceil(_e1843), 2f)) {
                                                if _e161 {
                                                    let _e2110 = textureSampleLevel(input_image, bilinear_sampler, vec2<f32>(_e343, _e344), 0f);
                                                    phi_3643_ = _e2110;
                                                } else {
                                                    if _e484.uses_inpaint {
                                                        let _e1978 = floor(_e341);
                                                        let _e1979 = floor(_e342);
                                                        let _e1980 = (_e341 - _e1978);
                                                        let _e1982 = (_e1978 / _e113);
                                                        let _e1983 = (_e1979 / _e114);
                                                        let _e1985 = textureSampleLevel(inpaint_image, nearest_sampler, vec2<f32>(_e1982, _e1983), 0f);
                                                        let _e1987 = ((_e1978 + 1f) / _e113);
                                                        let _e1988 = vec2<f32>(_e1987, _e1983);
                                                        let _e1989 = textureSampleLevel(inpaint_image, nearest_sampler, _e1988, 0f);
                                                        let _e1990 = textureSampleLevel(depth, nearest_sampler, _e1988, 0f);
                                                        let _e1993 = abs((_e1990.x - _e484.background_sample));
                                                        let _e1997 = (f32(select(0u, 1u, (_e1993 > 0f))) * _e1993);
                                                        let _e1998 = (_e1997 < 1f);
                                                        let _e2007 = (_e1980 * (1f - ((f32(select(0u, 1u, _e1998)) * _e1997) + f32(select(0u, 1u, !(_e1998))))));
                                                        let _e2008 = (1f - _e2007);
                                                        let _e2030 = ((_e1979 + 1f) / _e114);
                                                        let _e2031 = vec2<f32>(_e1982, _e2030);
                                                        let _e2032 = textureSampleLevel(inpaint_image, nearest_sampler, _e2031, 0f);
                                                        let _e2033 = textureSampleLevel(depth, nearest_sampler, _e2031, 0f);
                                                        let _e2035 = vec2<f32>(_e1987, _e2030);
                                                        let _e2036 = textureSampleLevel(inpaint_image, nearest_sampler, _e2035, 0f);
                                                        let _e2037 = textureSampleLevel(depth, nearest_sampler, _e2035, 0f);
                                                        let _e2040 = abs((_e2033.x - _e2037.x));
                                                        let _e2044 = (f32(select(0u, 1u, (_e2040 > 0f))) * _e2040);
                                                        let _e2045 = (_e2044 < 1f);
                                                        let _e2054 = (_e1980 * (1f - ((f32(select(0u, 1u, _e2045)) * _e2044) + f32(select(0u, 1u, !(_e2045))))));
                                                        let _e2055 = (1f - _e2054);
                                                        let _e2079 = (1f - abs((mix(_e2033.x, _e2037.x, _e2054) - _e484.background_sample)));
                                                        let _e2083 = (f32(select(0u, 1u, (_e2079 > 0f))) * _e2079);
                                                        let _e2084 = (_e2083 < 1f);
                                                        let _e2092 = ((_e342 - _e1979) * ((f32(select(0u, 1u, _e2084)) * _e2083) + f32(select(0u, 1u, !(_e2084)))));
                                                        let _e2093 = (1f - _e2092);
                                                        phi_3642_ = vec4<f32>(((((_e1985.x * _e2008) + (_e1989.x * _e2007)) * _e2093) + (((_e2032.x * _e2055) + (_e2036.x * _e2054)) * _e2092)), ((((_e1985.y * _e2008) + (_e1989.y * _e2007)) * _e2093) + (((_e2032.y * _e2055) + (_e2036.y * _e2054)) * _e2092)), ((((_e1985.z * _e2008) + (_e1989.z * _e2007)) * _e2093) + (((_e2032.z * _e2055) + (_e2036.z * _e2054)) * _e2092)), ((((_e1985.w * _e2008) + (_e1989.w * _e2007)) * _e2093) + (((_e2032.w * _e2055) + (_e2036.w * _e2054)) * _e2092)));
                                                    } else {
                                                        let _e1849 = floor(_e341);
                                                        let _e1850 = floor(_e342);
                                                        let _e1851 = (_e341 - _e1849);
                                                        let _e1853 = (_e1849 / _e113);
                                                        let _e1854 = (_e1850 / _e114);
                                                        let _e1856 = textureSampleLevel(input_image, nearest_sampler, vec2<f32>(_e1853, _e1854), 0f);
                                                        let _e1858 = ((_e1849 + 1f) / _e113);
                                                        let _e1859 = vec2<f32>(_e1858, _e1854);
                                                        let _e1860 = textureSampleLevel(input_image, nearest_sampler, _e1859, 0f);
                                                        let _e1861 = textureSampleLevel(depth, nearest_sampler, _e1859, 0f);
                                                        let _e1864 = abs((_e1861.x - _e484.background_sample));
                                                        let _e1868 = (f32(select(0u, 1u, (_e1864 > 0f))) * _e1864);
                                                        let _e1869 = (_e1868 < 1f);
                                                        let _e1878 = (_e1851 * (1f - ((f32(select(0u, 1u, _e1869)) * _e1868) + f32(select(0u, 1u, !(_e1869))))));
                                                        let _e1879 = (1f - _e1878);
                                                        let _e1901 = ((_e1850 + 1f) / _e114);
                                                        let _e1902 = vec2<f32>(_e1853, _e1901);
                                                        let _e1903 = textureSampleLevel(input_image, nearest_sampler, _e1902, 0f);
                                                        let _e1904 = textureSampleLevel(depth, nearest_sampler, _e1902, 0f);
                                                        let _e1906 = vec2<f32>(_e1858, _e1901);
                                                        let _e1907 = textureSampleLevel(input_image, nearest_sampler, _e1906, 0f);
                                                        let _e1908 = textureSampleLevel(depth, nearest_sampler, _e1906, 0f);
                                                        let _e1911 = abs((_e1904.x - _e1908.x));
                                                        let _e1915 = (f32(select(0u, 1u, (_e1911 > 0f))) * _e1911);
                                                        let _e1916 = (_e1915 < 1f);
                                                        let _e1925 = (_e1851 * (1f - ((f32(select(0u, 1u, _e1916)) * _e1915) + f32(select(0u, 1u, !(_e1916))))));
                                                        let _e1926 = (1f - _e1925);
                                                        let _e1950 = (1f - abs((mix(_e1904.x, _e1908.x, _e1925) - _e484.background_sample)));
                                                        let _e1954 = (f32(select(0u, 1u, (_e1950 > 0f))) * _e1950);
                                                        let _e1955 = (_e1954 < 1f);
                                                        let _e1963 = ((_e342 - _e1850) * ((f32(select(0u, 1u, _e1955)) * _e1954) + f32(select(0u, 1u, !(_e1955)))));
                                                        let _e1964 = (1f - _e1963);
                                                        phi_3642_ = vec4<f32>(((((_e1856.x * _e1879) + (_e1860.x * _e1878)) * _e1964) + (((_e1903.x * _e1926) + (_e1907.x * _e1925)) * _e1963)), ((((_e1856.y * _e1879) + (_e1860.y * _e1878)) * _e1964) + (((_e1903.y * _e1926) + (_e1907.y * _e1925)) * _e1963)), ((((_e1856.z * _e1879) + (_e1860.z * _e1878)) * _e1964) + (((_e1903.z * _e1926) + (_e1907.z * _e1925)) * _e1963)), ((((_e1856.w * _e1879) + (_e1860.w * _e1878)) * _e1964) + (((_e1903.w * _e1926) + (_e1907.w * _e1925)) * _e1963)));
                                                    }
                                                    let _e2108 = phi_3642_;
                                                    phi_3643_ = _e2108;
                                                }
                                                let _e2112 = phi_3643_;
                                                let _e2124 = (_e338.x * ((f32(select(0u, 1u, _e310)) * _e309) + f32(select(0u, 1u, !(_e310)))));
                                                let _e2125 = (_e309 < 1f);
                                                let _e2130 = settings.member.pixel_aspect_normalizer;
                                                let _e2136 = (_e338.y * ((f32(select(0u, 1u, _e2125)) * _e2130) + f32(select(0u, 1u, !(_e2125)))));
                                                if ((_e159 & 8u) == 8u) {
                                                    let _e2139 = (_e484.background_sample != 0f);
                                                    if _e2139 {
                                                        let _e2140 = f32(_e118);
                                                        let _e2141 = f32(_e120);
                                                        let _e2149 = (1f - (2f * f32(select(0u, 1u, ((_e159 & 64u) == 64u)))));
                                                        let _e2150 = (_e2124 / _e484.background_sample);
                                                        let _e2152 = (_e2150 * 2f);
                                                        let _e2153 = ((_e2136 / _e484.background_sample) * 2f);
                                                        let _e2157 = settings.member.center[0u];
                                                        let _e2161 = settings.member.center[1u];
                                                        let _e2166 = ((((_e2140 + _e2124) - _e2157) / _e2157) * _e2149);
                                                        let _e2167 = ((((_e2141 + _e2136) - _e2161) / _e2161) * _e2149);
                                                        let _e2170 = settings.member.non_uniform_flags;
                                                        let _e2172 = ((_e2170 & 32u) == 32u);
                                                        let _e2177 = settings.member.barndoors_amount;
                                                        let _e2178 = (_e1843 * 0.2f);
                                                        let _e2180 = select(_e2178, 0f, (_e2178 < 0f));
                                                        let _e2183 = (_e2177 * select(_e2180, 1f, (_e2180 > 1f)));
                                                        let _e2184 = (_e2166 < 0f);
                                                        let _e2189 = settings.member.barndoors_right;
                                                        let _e2197 = settings.member.barndoors_left;
                                                        let _e2202 = (_e2167 < 0f);
                                                        let _e2207 = settings.member.barndoors_top;
                                                        let _e2215 = settings.member.barndoors_bottom;
                                                        let _e2222 = settings.member.barndoors_gamma;
                                                        let _e2223 = (1f / _e2222);
                                                        let _e2224 = abs(_e2166);
                                                        let _e2229 = (bitcast<u32>(_e2166) & 2147483648u);
                                                        let _e2232 = abs(_e2167);
                                                        let _e2237 = (bitcast<u32>(_e2167) & 2147483648u);
                                                        let _e2241 = ((_e2170 & 64u) == 64u);
                                                        let _e2250 = ((_e2170 & 128u) == 128u);
                                                        if _e2250 {
                                                            phi_3856_ = (_e484.background_sample > 0f);
                                                        } else {
                                                            phi_3856_ = false;
                                                        }
                                                        let _e2253 = phi_3856_;
                                                        if _e2250 {
                                                            phi_3868_ = (_e484.background_sample > 0f);
                                                        } else {
                                                            phi_3868_ = false;
                                                        }
                                                        let _e2259 = phi_3868_;
                                                        let _e2264 = ((f32(select(0u, 1u, _e2241)) + (f32(select(0u, 1u, !(_e2241))) * -1f)) * ((f32(select(0u, 1u, _e2253)) * -1f) + f32(select(0u, 1u, !(_e2259)))));
                                                        let _e2296 = f32(select(0u, 1u, ((_e2170 & 16u) == 16u)));
                                                        let _e2298 = (vec2<u32>(_e117, _e119) + _e86);
                                                        let _e2301 = f32(_e2298.x);
                                                        let _e2302 = f32(_e2298.y);
                                                        let _e2303 = (_e2157 - _e2301);
                                                        let _e2304 = (_e2161 - _e2302);
                                                        let _e2305 = (_e2302 < _e2161);
                                                        let _e2310 = -(_e2303);
                                                        let _e2317 = atan2(_e2304, _e2303);
                                                        let _e2320 = ((f32(select(0u, 1u, _e2305)) * (atan2(-(abs(_e2304)), _e2310) + 1.5707964f)) + (f32(select(0u, 1u, !(_e2305))) * (_e2317 + 1.5707964f)));
                                                        let _e2321 = (_e2301 < _e2157);
                                                        let _e2331 = ((f32(select(0u, 1u, _e2321)) * _e2317) + (f32(select(0u, 1u, !(_e2321))) * atan2(-(_e2304), _e2310)));
                                                        let _e2347 = settings.member.astigmatism_amount;
                                                        let _e2354 = settings.member.astigmatism_gamma;
                                                        let _e2355 = (1f / _e2354);
                                                        let _e2363 = global[0u];
                                                        if ((_e2140 - _e2166) == _e2363) {
                                                            let _e2366 = global[1u];
                                                            phi_3980_ = ((_e2141 - _e2167) == _e2366);
                                                        } else {
                                                            phi_3980_ = false;
                                                        }
                                                        let _e2369 = phi_3980_;
                                                        let _e2372 = f32(select(0u, 1u, !(_e2369)));
                                                        let _e2381 = datamodel_NonUniformValue(vec2<f32>((_e2296 * (_e2372 * ((((((_e2152 * cos(_e2320)) + (_e2153 * sin(_e2320))) * _e484.background_sample) * _e2347) * 0.4f) * pow(_e2232, _e2355)))), (_e2296 * (_e2372 * (((((((_e2150 * -2f) * sin(_e2331)) + (_e2153 * cos(_e2331))) * _e484.background_sample) * _e2347) * 0.4f) * pow(_e2224, _e2355))))), datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f).opacity, datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f).scale);
                                                        let _e2382 = (_e484.background_sample > 0f);
                                                        if _e2382 {
                                                            phi_4013_ = ((_e2170 & 2u) == 2u);
                                                        } else {
                                                            phi_4013_ = false;
                                                        }
                                                        let _e2386 = phi_4013_;
                                                        if _e2382 {
                                                            phi_4025_ = ((_e2170 & 2u) == 2u);
                                                        } else {
                                                            phi_4025_ = false;
                                                        }
                                                        let _e2393 = phi_4025_;
                                                        if _e2382 {
                                                            phi_4039_ = ((_e2170 & 4u) == 4u);
                                                        } else {
                                                            phi_4039_ = false;
                                                        }
                                                        let _e2401 = phi_4039_;
                                                        if _e2382 {
                                                            phi_4051_ = ((_e2170 & 4u) == 4u);
                                                        } else {
                                                            phi_4051_ = false;
                                                        }
                                                        let _e2408 = phi_4051_;
                                                        let _e2413 = (((f32(select(0u, 1u, _e2386)) * -1f) + f32(select(0u, 1u, !(_e2393)))) * ((f32(select(0u, 1u, _e2401)) * -1f) + f32(select(0u, 1u, !(_e2408)))));
                                                        let _e2415 = abs((_e484.background_sample * 0.2f));
                                                        let _e2417 = select(_e2415, 0f, (_e2415 < 0f));
                                                        let _e2419 = select(_e2417, 1f, (_e2417 > 1f));
                                                        let _e2420 = (_e2166 * _e2419);
                                                        let _e2421 = (_e2167 * _e2419);
                                                        let _e2425 = settings.member.resolution[1u];
                                                        let _e2427 = (f32(_e2425) * _e2130);
                                                        let _e2429 = ((_e2170 & 8u) == 8u);
                                                        if _e2429 {
                                                            let _e2433 = settings.member.resolution[0u];
                                                            phi_4099_ = (f32(_e2433) > _e2427);
                                                        } else {
                                                            phi_4099_ = false;
                                                        }
                                                        let _e2437 = phi_4099_;
                                                        let _e2443 = settings.member.resolution[0u];
                                                        let _e2444 = f32(_e2443);
                                                        if _e2429 {
                                                            phi_4116_ = (_e2444 > _e2427);
                                                        } else {
                                                            phi_4116_ = false;
                                                        }
                                                        let _e2449 = phi_4116_;
                                                        if _e2429 {
                                                            phi_4130_ = (_e2444 < _e2427);
                                                        } else {
                                                            phi_4130_ = false;
                                                        }
                                                        let _e2456 = phi_4130_;
                                                        if _e2429 {
                                                            phi_4147_ = (_e2444 < _e2427);
                                                        } else {
                                                            phi_4147_ = false;
                                                        }
                                                        let _e2463 = phi_4147_;
                                                        let _e2470 = settings.member.catseye_gamma;
                                                        let _e2491 = settings.member.catseye_amount;
                                                        let _e2496 = (_e2152 + (_e2413 * (bitcast<f32>(((bitcast<u32>(pow(abs(_e2420), (((f32(select(0u, 1u, _e2437)) * (_e2427 / _e2444)) + f32(select(0u, 1u, !(_e2449)))) / _e2470))) & 2147483647u) | (bitcast<u32>(_e2420) & 2147483648u))) * _e2491)));
                                                        let _e2497 = (_e2153 + (_e2413 * (bitcast<f32>(((bitcast<u32>(pow(abs(_e2421), (((f32(select(0u, 1u, _e2456)) * (_e2444 / _e2427)) + f32(select(0u, 1u, !(_e2463)))) / _e2470))) & 2147483647u) | (bitcast<u32>(_e2421) & 2147483648u))) * _e2491)));
                                                        let _e2505 = settings.member.catseye_softness;
                                                        let _e2507 = ((1f - (((_e2496 * _e2496) + (_e2497 * _e2497)) * 0.25f)) / (_e2505 * 0.5f));
                                                        let _e2509 = select(_e2507, 0f, (_e2507 < 0f));
                                                        phi_4216_ = datamodel_NonUniformValue(_e2381.offset, (((f32(select(0u, 1u, _e2172)) * min(f32(select(0u, 1u, ((1f - (((_e2264 * _e2152) + (((_e2183 * ((f32(select(0u, 1u, _e2184)) * (_e2189 * 0.02f)) + (f32(select(0u, 1u, !(_e2184))) * (_e2197 * 0.02f)))) - 0.5f) * bitcast<f32>((1065353216u | _e2229)))) * bitcast<f32>(((bitcast<u32>(pow(_e2224, _e2223)) & 2147483647u) | _e2229)))) > 0f))), f32(select(0u, 1u, ((1f - (((_e2264 * _e2153) + (((_e2183 * ((f32(select(0u, 1u, _e2202)) * (_e2207 * 0.02f)) + (f32(select(0u, 1u, !(_e2202))) * (_e2215 * 0.02f)))) - 0.5f) * bitcast<f32>((1065353216u | _e2237)))) * bitcast<f32>(((bitcast<u32>(pow(_e2232, _e2223)) & 2147483647u) | _e2237)))) > 0f))))) + f32(select(0u, 1u, !(_e2172)))) * select(_e2509, 1f, (_e2509 > 1f))), _e2381.scale);
                                                    } else {
                                                        phi_4216_ = datamodel_NonUniformValue();
                                                    }
                                                    let _e2518 = phi_4216_;
                                                    phi_4218_ = _e2518;
                                                    phi_4219_ = select(true, false, _e2139);
                                                } else {
                                                    phi_4218_ = datamodel_NonUniformValue();
                                                    phi_4219_ = true;
                                                }
                                                let _e2521 = phi_4218_;
                                                let _e2523 = phi_4219_;
                                                if _e2523 {
                                                    phi_4224_ = datamodel_NonUniformValue(vec2<f32>(0f, 0f), 1f, 1f);
                                                } else {
                                                    phi_4224_ = _e2521;
                                                }
                                                let _e2525 = phi_4224_;
                                                let _e2533 = settings.member.render_scale;
                                                let _e2540 = (f32(select(0u, 1u, _e484.uses_inpaint)) + (f32(select(0u, 1u, !(_e484.uses_inpaint))) * smoothstep(0f, 1f, abs(((_e1843 * f32(_e2533)) * 0.75f)))));
                                                if ((_e159 & 32u) == 32u) {
                                                    let _e2629 = settings.member.axial_aberration_amount;
                                                    let _e2632 = settings.member.axial_aberration_type;
                                                    switch _e2632 {
                                                        case 1: {
                                                            phi_4260_ = 1u;
                                                            break;
                                                        }
                                                        case 2: {
                                                            phi_4260_ = 2u;
                                                            break;
                                                        }
                                                        case 3: {
                                                            phi_4260_ = 3u;
                                                            break;
                                                        }
                                                        default: {
                                                            phi_4260_ = 1u;
                                                            break;
                                                        }
                                                    }
                                                    let _e2634 = phi_4260_;
                                                    let _e2635 = (_e2629 * 0.25f);
                                                    let _e2637 = (_e484.background_sample * _e2525.scale);
                                                    let _e2638 = (_e2637 < 0f);
                                                    if _e2638 {
                                                        phi_7490_ = _e2629;
                                                    } else {
                                                        phi_7490_ = -(_e2629);
                                                    }
                                                    let _e2641 = phi_7490_;
                                                    switch bitcast<i32>(_e2634) {
                                                        case 1: {
                                                            let _e2655 = (_e2641 > 0f);
                                                            if _e2655 {
                                                                phi_7635_ = abs(_e2635);
                                                            } else {
                                                                phi_7635_ = f32();
                                                            }
                                                            let _e2658 = phi_7635_;
                                                            phi_7501_ = select(_e2658, 0f, select(true, false, _e2655));
                                                            break;
                                                        }
                                                        case 2: {
                                                            let _e2649 = (_e2641 < 0f);
                                                            if _e2649 {
                                                                phi_7576_ = abs(_e2635);
                                                            } else {
                                                                phi_7576_ = f32();
                                                            }
                                                            let _e2652 = phi_7576_;
                                                            phi_7501_ = select(_e2652, 0f, select(true, false, _e2649));
                                                            break;
                                                        }
                                                        case 3: {
                                                            let _e2643 = (_e2641 > 0f);
                                                            if _e2643 {
                                                                phi_7516_ = abs(_e2635);
                                                            } else {
                                                                phi_7516_ = f32();
                                                            }
                                                            let _e2646 = phi_7516_;
                                                            phi_7501_ = select(_e2646, 0f, select(true, false, _e2643));
                                                            break;
                                                        }
                                                        default: {
                                                            phi_7501_ = f32();
                                                            break;
                                                        }
                                                    }
                                                    let _e2662 = phi_7501_;
                                                    let _e2664 = (_e2637 * (1f - _e2662));
                                                    if _e2638 {
                                                        phi_7683_ = _e2629;
                                                    } else {
                                                        phi_7683_ = -(_e2629);
                                                    }
                                                    let _e2667 = phi_7683_;
                                                    switch bitcast<i32>(_e2634) {
                                                        case 1: {
                                                            phi_7694_ = (abs(_e2635) * 0.5f);
                                                            break;
                                                        }
                                                        case 2: {
                                                            let _e2676 = (_e2667 < 0f);
                                                            if _e2676 {
                                                                phi_7786_ = abs(_e2635);
                                                            } else {
                                                                phi_7786_ = f32();
                                                            }
                                                            let _e2679 = phi_7786_;
                                                            phi_7694_ = select(_e2679, 0f, select(true, false, _e2676));
                                                            break;
                                                        }
                                                        case 3: {
                                                            let _e2669 = (_e2667 < 0f);
                                                            if _e2669 {
                                                                phi_7727_ = (abs(_e2635) * 0.5f);
                                                            } else {
                                                                phi_7727_ = f32();
                                                            }
                                                            let _e2673 = phi_7727_;
                                                            phi_7694_ = select(_e2673, 0f, select(true, false, _e2669));
                                                            break;
                                                        }
                                                        default: {
                                                            phi_7694_ = f32();
                                                            break;
                                                        }
                                                    }
                                                    let _e2685 = phi_7694_;
                                                    let _e2687 = (_e2637 * (1f - _e2685));
                                                    if _e2638 {
                                                        phi_7876_ = _e2629;
                                                    } else {
                                                        phi_7876_ = -(_e2629);
                                                    }
                                                    let _e2690 = phi_7876_;
                                                    switch bitcast<i32>(_e2634) {
                                                        case 1: {
                                                            let _e2704 = (_e2690 < 0f);
                                                            if _e2704 {
                                                                phi_8040_ = abs(_e2635);
                                                            } else {
                                                                phi_8040_ = f32();
                                                            }
                                                            let _e2707 = phi_8040_;
                                                            phi_7887_ = select(_e2707, 0f, select(true, false, _e2704));
                                                            break;
                                                        }
                                                        case 2: {
                                                            let _e2698 = (_e2690 > 0f);
                                                            if _e2698 {
                                                                phi_7996_ = abs(_e2635);
                                                            } else {
                                                                phi_7996_ = f32();
                                                            }
                                                            let _e2701 = phi_7996_;
                                                            phi_7887_ = select(_e2701, 0f, select(true, false, _e2698));
                                                            break;
                                                        }
                                                        case 3: {
                                                            let _e2692 = (_e2690 > 0f);
                                                            if _e2692 {
                                                                phi_7937_ = abs(_e2635);
                                                            } else {
                                                                phi_7937_ = f32();
                                                            }
                                                            let _e2695 = phi_7937_;
                                                            phi_7887_ = select(_e2695, 0f, select(true, false, _e2692));
                                                            break;
                                                        }
                                                        default: {
                                                            phi_7887_ = f32();
                                                            break;
                                                        }
                                                    }
                                                    let _e2711 = phi_7887_;
                                                    let _e2713 = (_e2637 * (1f - _e2711));
                                                    let _e2722 = max((abs(_e2664) * 2f), 1f);
                                                    let _e2726 = settings.member.filter_resolution[0u];
                                                    let _e2727 = f32(_e2726);
                                                    let _e2731 = settings.member.filter_resolution[1u];
                                                    let _e2732 = f32(_e2731);
                                                    let _e2735 = -((_e2525.offset.x + _e338.x));
                                                    let _e2736 = -((_e2525.offset.y + _e338.y));
                                                    let _e2739 = (_e2727 * 0.5f);
                                                    let _e2740 = (_e2732 * 0.5f);
                                                    let _e2741 = ((_e2735 * (_e2727 / _e2722)) + _e2739);
                                                    let _e2742 = ((_e2736 * (_e2732 / _e2722)) + _e2740);
                                                    let _e2743 = (_e2664 > 0f);
                                                    if _e2743 {
                                                        phi_4313_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4313_ = false;
                                                    }
                                                    let _e2747 = phi_4313_;
                                                    let _e2749 = f32(select(0u, 1u, _e2747));
                                                    if _e2743 {
                                                        phi_4328_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4328_ = false;
                                                    }
                                                    let _e2757 = phi_4328_;
                                                    let _e2760 = f32(select(0u, 1u, !(_e2757)));
                                                    let _e2765 = (_e2722 / _e2727);
                                                    let _e2766 = (_e2722 / _e2732);
                                                    let _e2772 = (((_e2749 * (_e2741 - 1f)) + (_e2760 * _e2741)) / _e2727);
                                                    let _e2773 = (((_e2749 * (_e2742 - 1f)) + (_e2760 * _e2742)) / _e2732);
                                                    let _e2781 = ((pow(((_e2772 - 0.5f) * 2f), 2f) + pow(((_e2773 - 0.5f) * 2f), 2f)) >= 1f);
                                                    if _e2781 {
                                                        phi_4387_ = vec4<f32>();
                                                        phi_4388_ = true;
                                                    } else {
                                                        let _e2783 = ((_e159 & 2u) == 2u);
                                                        if _e2783 {
                                                            phi_4385_ = vec4<f32>();
                                                        } else {
                                                            let _e2785 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e2772, _e2773), max(0f, log2((1f / select(_e2766, _e2765, (_e2765 > _e2766))))));
                                                            phi_4385_ = _e2785;
                                                        }
                                                        let _e2787 = phi_4385_;
                                                        phi_4387_ = _e2787;
                                                        phi_4388_ = _e2783;
                                                    }
                                                    let _e2789 = phi_4387_;
                                                    let _e2791 = phi_4388_;
                                                    let _e2799 = max((abs(_e2687) * 2f), 1f);
                                                    let _e2804 = ((_e2735 * (_e2727 / _e2799)) + _e2739);
                                                    let _e2805 = ((_e2736 * (_e2732 / _e2799)) + _e2740);
                                                    let _e2806 = (_e2687 > 0f);
                                                    if _e2806 {
                                                        phi_4430_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4430_ = false;
                                                    }
                                                    let _e2810 = phi_4430_;
                                                    let _e2812 = f32(select(0u, 1u, _e2810));
                                                    if _e2806 {
                                                        phi_4445_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4445_ = false;
                                                    }
                                                    let _e2820 = phi_4445_;
                                                    let _e2823 = f32(select(0u, 1u, !(_e2820)));
                                                    let _e2828 = (_e2799 / _e2727);
                                                    let _e2829 = (_e2799 / _e2732);
                                                    let _e2835 = (((_e2812 * (_e2804 - 1f)) + (_e2823 * _e2804)) / _e2727);
                                                    let _e2836 = (((_e2812 * (_e2805 - 1f)) + (_e2823 * _e2805)) / _e2732);
                                                    let _e2844 = ((pow(((_e2835 - 0.5f) * 2f), 2f) + pow(((_e2836 - 0.5f) * 2f), 2f)) >= 1f);
                                                    if _e2844 {
                                                        phi_4504_ = vec4<f32>();
                                                        phi_4505_ = true;
                                                    } else {
                                                        let _e2846 = ((_e159 & 2u) == 2u);
                                                        if _e2846 {
                                                            phi_4502_ = vec4<f32>();
                                                        } else {
                                                            let _e2848 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e2835, _e2836), max(0f, log2((1f / select(_e2829, _e2828, (_e2828 > _e2829))))));
                                                            phi_4502_ = _e2848;
                                                        }
                                                        let _e2850 = phi_4502_;
                                                        phi_4504_ = _e2850;
                                                        phi_4505_ = _e2846;
                                                    }
                                                    let _e2852 = phi_4504_;
                                                    let _e2854 = phi_4505_;
                                                    let _e2862 = max((abs(_e2713) * 2f), 1f);
                                                    let _e2867 = ((_e2735 * (_e2727 / _e2862)) + _e2739);
                                                    let _e2868 = ((_e2736 * (_e2732 / _e2862)) + _e2740);
                                                    let _e2869 = (_e2713 > 0f);
                                                    if _e2869 {
                                                        phi_4547_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4547_ = false;
                                                    }
                                                    let _e2873 = phi_4547_;
                                                    let _e2875 = f32(select(0u, 1u, _e2873));
                                                    if _e2869 {
                                                        phi_4562_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4562_ = false;
                                                    }
                                                    let _e2883 = phi_4562_;
                                                    let _e2886 = f32(select(0u, 1u, !(_e2883)));
                                                    let _e2891 = (_e2862 / _e2727);
                                                    let _e2892 = (_e2862 / _e2732);
                                                    let _e2898 = (((_e2875 * (_e2867 - 1f)) + (_e2886 * _e2867)) / _e2727);
                                                    let _e2899 = (((_e2875 * (_e2868 - 1f)) + (_e2886 * _e2868)) / _e2732);
                                                    let _e2907 = ((pow(((_e2898 - 0.5f) * 2f), 2f) + pow(((_e2899 - 0.5f) * 2f), 2f)) >= 1f);
                                                    if _e2907 {
                                                        phi_4621_ = vec4<f32>();
                                                        phi_4622_ = true;
                                                    } else {
                                                        let _e2909 = ((_e159 & 2u) == 2u);
                                                        if _e2909 {
                                                            phi_4619_ = vec4<f32>();
                                                        } else {
                                                            let _e2911 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e2898, _e2899), max(0f, log2((1f / select(_e2892, _e2891, (_e2891 > _e2892))))));
                                                            phi_4619_ = _e2911;
                                                        }
                                                        let _e2913 = phi_4619_;
                                                        phi_4621_ = _e2913;
                                                        phi_4622_ = _e2909;
                                                    }
                                                    let _e2915 = phi_4621_;
                                                    let _e2917 = phi_4622_;
                                                    let _e2925 = max((abs(_e2637) * 2f), 1f);
                                                    let _e2930 = ((_e2735 * (_e2727 / _e2925)) + _e2739);
                                                    let _e2931 = ((_e2736 * (_e2732 / _e2925)) + _e2740);
                                                    let _e2932 = (_e2637 > 0f);
                                                    if _e2932 {
                                                        phi_4664_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4664_ = false;
                                                    }
                                                    let _e2936 = phi_4664_;
                                                    let _e2938 = f32(select(0u, 1u, _e2936));
                                                    if _e2932 {
                                                        phi_4679_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4679_ = false;
                                                    }
                                                    let _e2946 = phi_4679_;
                                                    let _e2949 = f32(select(0u, 1u, !(_e2946)));
                                                    let _e2954 = (_e2925 / _e2727);
                                                    let _e2955 = (_e2925 / _e2732);
                                                    let _e2961 = (((_e2938 * (_e2930 - 1f)) + (_e2949 * _e2930)) / _e2727);
                                                    let _e2962 = (((_e2938 * (_e2931 - 1f)) + (_e2949 * _e2931)) / _e2732);
                                                    let _e2970 = ((pow(((_e2961 - 0.5f) * 2f), 2f) + pow(((_e2962 - 0.5f) * 2f), 2f)) >= 1f);
                                                    if _e2970 {
                                                        phi_4738_ = vec4<f32>();
                                                        phi_4739_ = true;
                                                    } else {
                                                        let _e2972 = ((_e159 & 2u) == 2u);
                                                        if _e2972 {
                                                            phi_4736_ = vec4<f32>();
                                                        } else {
                                                            let _e2974 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e2961, _e2962), max(0f, log2((1f / select(_e2955, _e2954, (_e2954 > _e2955))))));
                                                            phi_4736_ = _e2974;
                                                        }
                                                        let _e2976 = phi_4736_;
                                                        phi_4738_ = _e2976;
                                                        phi_4739_ = _e2972;
                                                    }
                                                    let _e2978 = phi_4738_;
                                                    let _e2980 = phi_4739_;
                                                    phi_4867_ = vec4<f32>(select(_e2789, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e2781)), vec4(_e2791)).x, select(_e2852, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e2844)), vec4(_e2854)).y, select(_e2915, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e2907)), vec4(_e2917)).z, select(_e2978, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e2970)), vec4(_e2980)).w);
                                                } else {
                                                    let _e2544 = (_e484.background_sample * _e2525.scale);
                                                    let _e2553 = max((abs(_e2544) * 2f), 1f);
                                                    let _e2557 = settings.member.filter_resolution[0u];
                                                    let _e2558 = f32(_e2557);
                                                    let _e2562 = settings.member.filter_resolution[1u];
                                                    let _e2563 = f32(_e2562);
                                                    let _e2572 = ((-((_e2525.offset.x + _e338.x)) * (_e2558 / _e2553)) + (_e2558 * 0.5f));
                                                    let _e2573 = ((-((_e2525.offset.y + _e338.y)) * (_e2563 / _e2553)) + (_e2563 * 0.5f));
                                                    let _e2574 = (_e2544 > 0f);
                                                    if _e2574 {
                                                        phi_4787_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4787_ = false;
                                                    }
                                                    let _e2578 = phi_4787_;
                                                    let _e2580 = f32(select(0u, 1u, _e2578));
                                                    if _e2574 {
                                                        phi_4802_ = ((_e159 & 16u) == 16u);
                                                    } else {
                                                        phi_4802_ = false;
                                                    }
                                                    let _e2588 = phi_4802_;
                                                    let _e2591 = f32(select(0u, 1u, !(_e2588)));
                                                    let _e2596 = (_e2553 / _e2558);
                                                    let _e2597 = (_e2553 / _e2563);
                                                    let _e2603 = (((_e2580 * (_e2572 - 1f)) + (_e2591 * _e2572)) / _e2558);
                                                    let _e2604 = (((_e2580 * (_e2573 - 1f)) + (_e2591 * _e2573)) / _e2563);
                                                    let _e2612 = ((pow(((_e2603 - 0.5f) * 2f), 2f) + pow(((_e2604 - 0.5f) * 2f), 2f)) >= 1f);
                                                    if _e2612 {
                                                        phi_4861_ = vec4<f32>();
                                                        phi_4862_ = true;
                                                    } else {
                                                        let _e2614 = ((_e159 & 2u) == 2u);
                                                        if _e2614 {
                                                            phi_4859_ = vec4<f32>();
                                                        } else {
                                                            let _e2616 = textureSampleLevel(filter_, bilinear_sampler, vec2<f32>(_e2603, _e2604), max(0f, log2((1f / select(_e2597, _e2596, (_e2596 > _e2597))))));
                                                            phi_4859_ = _e2616;
                                                        }
                                                        let _e2618 = phi_4859_;
                                                        phi_4861_ = _e2618;
                                                        phi_4862_ = _e2614;
                                                    }
                                                    let _e2620 = phi_4861_;
                                                    let _e2622 = phi_4862_;
                                                    phi_4867_ = select(_e2620, select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 0f), vec4(_e2612)), vec4(_e2622));
                                                }
                                                let _e2988 = phi_4867_;
                                                let _e2995 = (_e2988.z * _e2525.opacity);
                                                let _e2999 = abs(_e1843);
                                                let _e3000 = floor(_e2999);
                                                let _e3005 = select(select(u32(_e3000), 0u, (_e3000 < 0f)), 4294967295u, (_e3000 > 4294967000f));
                                                let _e3006 = ceil(_e2999);
                                                let _e3011 = select(select(u32(_e3006), 0u, (_e3006 < 0f)), 4294967295u, (_e3006 > 4294967000f));
                                                if (_e3005 < _e83) {
                                                } else {
                                                    phi_8380_ = true;
                                                    break;
                                                }
                                                let _e3015 = cached_sample_weights.member[_e3005];
                                                if (_e3011 < _e83) {
                                                } else {
                                                    phi_8380_ = true;
                                                    break;
                                                }
                                                let _e3019 = cached_sample_weights.member[_e3011];
                                                let _e3022 = (mix(_e3015, _e3019, (_e2999 - _e3000)) / _e275);
                                                let _e3030 = ((_e2112.w * (_e2988.w * _e2525.opacity)) * _e2540);
                                                let _e3033 = (vec4<f32>(((_e2112.x * (_e2988.x * _e2525.opacity)) * _e2540), ((_e2112.y * (_e2988.y * _e2525.opacity)) * _e2540), ((_e2112.z * _e2995) * _e2540), _e3030) * _e3022);
                                                let _e3034 = ((_e2988 * _e2525.opacity) * _e3022);
                                                let _e3042 = (_e1838.background.color.x + _e3033.x);
                                                let _e3061 = stages_ring_Rings(_e1838.foreground, stages_ring_Ring(vec4<f32>(_e3042, _e1838.background.color.y, _e1838.background.color.z, _e1838.background.color.w), _e1838.background.kernel, _e1838.background.count, _e1838.background.found, _e1838.background.weight, _e1838.background.radius, _e1838.background.alpha, _e1838.background.alpha_masked, _e1838.background.coc, _e1838.background.deep));
                                                let _e3066 = (_e1838.background.color.y + _e3033.y);
                                                let _e3085 = stages_ring_Rings(_e3061.foreground, stages_ring_Ring(vec4<f32>(_e3061.background.color.x, _e3066, _e3061.background.color.z, _e3061.background.color.w), _e3061.background.kernel, _e3061.background.count, _e3061.background.found, _e3061.background.weight, _e3061.background.radius, _e3061.background.alpha, _e3061.background.alpha_masked, _e3061.background.coc, _e3061.background.deep));
                                                let _e3090 = (_e1838.background.color.z + _e3033.z);
                                                let _e3109 = stages_ring_Rings(_e3085.foreground, stages_ring_Ring(vec4<f32>(_e3085.background.color.x, _e3085.background.color.y, _e3090, _e3085.background.color.w), _e3085.background.kernel, _e3085.background.count, _e3085.background.found, _e3085.background.weight, _e3085.background.radius, _e3085.background.alpha, _e3085.background.alpha_masked, _e3085.background.coc, _e3085.background.deep));
                                                let _e3129 = stages_ring_Rings(_e3109.foreground, stages_ring_Ring(vec4<f32>(_e3042, _e3066, _e3090, (_e1838.background.color.w + _e3033.w)), _e3109.background.kernel, _e3109.background.count, _e3109.background.found, _e3109.background.weight, _e3109.background.radius, _e3109.background.alpha, _e3109.background.alpha_masked, _e3109.background.coc, _e3109.background.deep));
                                                let _e3134 = (_e1838.background.kernel.x + _e3034.x);
                                                let _e3153 = stages_ring_Rings(_e3129.foreground, stages_ring_Ring(_e3129.background.color, vec4<f32>(_e3134, _e3129.background.kernel.y, _e3129.background.kernel.z, _e3129.background.kernel.w), _e3129.background.count, _e3129.background.found, _e3129.background.weight, _e3129.background.radius, _e3129.background.alpha, _e3129.background.alpha_masked, _e3129.background.coc, _e3129.background.deep));
                                                let _e3158 = (_e1838.background.kernel.y + _e3034.y);
                                                let _e3177 = stages_ring_Rings(_e3153.foreground, stages_ring_Ring(_e3153.background.color, vec4<f32>(_e3153.background.kernel.x, _e3158, _e3153.background.kernel.z, _e3153.background.kernel.w), _e3153.background.count, _e3153.background.found, _e3153.background.weight, _e3153.background.radius, _e3153.background.alpha, _e3153.background.alpha_masked, _e3153.background.coc, _e3153.background.deep));
                                                let _e3182 = (_e1838.background.kernel.z + _e3034.z);
                                                let _e3201 = stages_ring_Rings(_e3177.foreground, stages_ring_Ring(_e3177.background.color, vec4<f32>(_e3177.background.kernel.x, _e3177.background.kernel.y, _e3182, _e3177.background.kernel.w), _e3177.background.count, _e3177.background.found, _e3177.background.weight, _e3177.background.radius, _e3177.background.alpha, _e3177.background.alpha_masked, _e3177.background.coc, _e3177.background.deep));
                                                let _e3221 = stages_ring_Rings(_e3201.foreground, stages_ring_Ring(_e3201.background.color, vec4<f32>(_e3134, _e3158, _e3182, (_e1838.background.kernel.w + _e3034.w)), _e3201.background.count, _e3201.background.found, _e3201.background.weight, _e3201.background.radius, _e3201.background.alpha, _e3201.background.alpha_masked, _e3201.background.coc, _e3201.background.deep));
                                                let _e3238 = stages_ring_Rings(_e3221.foreground, stages_ring_Ring(_e3221.background.color, _e3221.background.kernel, _e3221.background.count, _e3221.background.found, _e3221.background.weight, _e3221.background.radius, _e3221.background.alpha, (_e1838.background.alpha_masked + ((_e2540 * _e2995) * _e3022)), _e3221.background.coc, _e3221.background.deep));
                                                let _e3255 = stages_ring_Rings(_e3238.foreground, stages_ring_Ring(_e3238.background.color, _e3238.background.kernel, _e3238.background.count, _e3238.background.found, _e3238.background.weight, _e3238.background.radius, (_e1838.background.alpha + (_e2995 * _e3022)), _e3238.background.alpha_masked, _e3238.background.coc, _e3238.background.deep));
                                                let _e3272 = stages_ring_Rings(_e3255.foreground, stages_ring_Ring(_e3255.background.color, _e3255.background.kernel, _e3255.background.count, _e3255.background.found, (_e1838.background.weight + _e3022), _e3255.background.radius, _e3255.background.alpha, _e3255.background.alpha_masked, _e3255.background.coc, _e3255.background.deep));
                                                let _e3289 = stages_ring_Rings(_e3272.foreground, stages_ring_Ring(_e3272.background.color, _e3272.background.kernel, _e3272.background.count, (_e1838.background.found + 1i), _e3272.background.weight, _e3272.background.radius, _e3272.background.alpha, _e3272.background.alpha_masked, _e3272.background.coc, _e3272.background.deep));
                                                let _e3306 = stages_ring_Rings(_e3289.foreground, stages_ring_Ring(_e3289.background.color, _e3289.background.kernel, _e3289.background.count, _e3289.background.found, _e3289.background.weight, _e3289.background.radius, _e3289.background.alpha, _e3289.background.alpha_masked, (_e1838.background.coc + _e1843), _e3289.background.deep));
                                                phi_5012_ = stages_ring_Rings(_e3306.foreground, stages_ring_Ring(_e3306.background.color, _e3306.background.kernel, _e3306.background.count, _e3306.background.found, _e3306.background.weight, _e3306.background.radius, _e3306.background.alpha, _e3306.background.alpha_masked, _e3306.background.coc, (_e1838.background.deep + (_e3030 * _e3022))));
                                            } else {
                                                phi_5012_ = _e1838;
                                            }
                                            let _e3325 = phi_5012_;
                                            phi_5013_ = _e3325;
                                        } else {
                                            phi_5013_ = _e1838;
                                        }
                                        let _e3327 = phi_5013_;
                                        phi_533_ = _e3327;
                                    } else {
                                        phi_533_ = stages_ring_Rings();
                                    }
                                    let _e3329 = phi_533_;
                                    continue;
                                    continuing {
                                        phi_529_ = _e293;
                                        phi_532_ = _e3329;
                                        phi_8380_ = _e195;
                                        break if !(_e299);
                                    }
                                }
                                let _e3332 = phi_8380_;
                                phi_11775_ = _e187;
                                phi_11768_ = _e189;
                                phi_11761_ = _e193;
                                phi_11754_ = _e191;
                                phi_11751_ = _e175;
                                phi_11749_ = _e179;
                                phi_11747_ = _e177;
                                phi_11740_ = _e3332;
                                if _e3332 {
                                    break;
                                }
                                let _e3334 = local;
                                if (_e3334.background.found == 0i) {
                                    let _e3860 = local_3;
                                    phi_5024_ = _e3860;
                                } else {
                                    let _e3340 = local_1;
                                    let _e3345 = local_2;
                                    phi_5024_ = stages_ring_Rings(_e3345.foreground, stages_ring_Ring(_e3345.background.color, _e3345.background.kernel, _e3345.background.count, _e3345.background.found, _e3345.background.weight, _e3345.background.radius, _e3345.background.alpha, _e3345.background.alpha_masked, (_e3340.background.coc / f32(_e3334.background.found)), _e3345.background.deep));
                                }
                                let _e3361 = phi_5024_;
                                let _e3376 = vec4<f32>((_e193.x + _e3361.foreground.color.x), (_e193.y + _e3361.foreground.color.y), (_e193.z + _e3361.foreground.color.z), (_e193.w + _e3361.foreground.color.w));
                                let _e3390 = vec4<f32>((_e191.x + _e3361.foreground.kernel.x), (_e191.y + _e3361.foreground.kernel.y), (_e191.z + _e3361.foreground.kernel.z), (_e191.w + _e3361.foreground.kernel.w));
                                let _e3392 = (_e189 + _e3361.foreground.alpha);
                                let _e3394 = (_e187 + _e3361.foreground.alpha_masked);
                                let _e3396 = abs(_e185);
                                let _e3397 = floor(_e3396);
                                let _e3402 = select(select(u32(_e3397), 0u, (_e3397 < 0f)), 4294967295u, (_e3397 > 4294967000f));
                                let _e3403 = ceil(_e3396);
                                let _e3408 = select(select(u32(_e3403), 0u, (_e3403 < 0f)), 4294967295u, (_e3403 > 4294967000f));
                                if (_e3402 < _e83) {
                                } else {
                                    phi_11775_ = _e3394;
                                    phi_11768_ = _e3392;
                                    phi_11761_ = _e3376;
                                    phi_11754_ = _e3390;
                                    phi_11751_ = _e175;
                                    phi_11749_ = _e179;
                                    phi_11747_ = _e177;
                                    phi_11740_ = true;
                                    break;
                                }
                                let _e3412 = cached_sample_weights.member[_e3402];
                                if (_e3408 < _e83) {
                                } else {
                                    phi_11775_ = _e3394;
                                    phi_11768_ = _e3392;
                                    phi_11761_ = _e3376;
                                    phi_11754_ = _e3390;
                                    phi_11751_ = _e175;
                                    phi_11749_ = _e179;
                                    phi_11747_ = _e177;
                                    phi_11740_ = true;
                                    break;
                                }
                                let _e3416 = cached_sample_weights.member[_e3408];
                                let _e3422 = abs(_e3361.background.coc);
                                let _e3423 = floor(_e3422);
                                let _e3428 = select(select(u32(_e3423), 0u, (_e3423 < 0f)), 4294967295u, (_e3423 > 4294967000f));
                                let _e3429 = ceil(_e3422);
                                let _e3434 = select(select(u32(_e3429), 0u, (_e3429 < 0f)), 4294967295u, (_e3429 > 4294967000f));
                                if (_e3428 < _e83) {
                                } else {
                                    phi_11775_ = _e3394;
                                    phi_11768_ = _e3392;
                                    phi_11761_ = _e3376;
                                    phi_11754_ = _e3390;
                                    phi_11751_ = _e175;
                                    phi_11749_ = _e179;
                                    phi_11747_ = _e177;
                                    phi_11740_ = true;
                                    break;
                                }
                                let _e3438 = cached_sample_weights.member[_e3428];
                                if (_e3434 < _e83) {
                                } else {
                                    phi_11775_ = _e3394;
                                    phi_11768_ = _e3392;
                                    phi_11761_ = _e3376;
                                    phi_11754_ = _e3390;
                                    phi_11751_ = _e175;
                                    phi_11749_ = _e179;
                                    phi_11747_ = _e177;
                                    phi_11740_ = true;
                                    break;
                                }
                                let _e3442 = cached_sample_weights.member[_e3434];
                                let _e3450 = (_e3361.background.radius * (mix(_e3438, _e3442, (_e3422 - _e3423)) * f32(_e3361.background.found)));
                                if (_e3450 == 0f) {
                                    phi_5148_ = 0f;
                                } else {
                                    let _e3453 = abs(_e3450);
                                    let _e3456 = (-((abs((_e181 * (mix(_e3412, _e3416, (_e3396 - _e3397)) * f32(_e183)))) - _e3453)) / _e3453);
                                    let _e3458 = select(_e3456, 0f, (_e3456 < 0f));
                                    phi_5148_ = select(_e3458, 1f, (_e3458 > 1f));
                                }
                                let _e3462 = phi_5148_;
                                let _e3464 = (1f - smoothstep(0f, 1f, _e3462));
                                phi_11790_ = _e3361.background.radius;
                                phi_11789_ = _e3361.background.found;
                                phi_11788_ = _e3361.background.coc;
                                phi_11777_ = _e3394;
                                phi_11770_ = _e3392;
                                phi_11763_ = _e3376;
                                phi_11756_ = _e3390;
                                phi_11752_ = (_e3361.background.alpha_masked + (_e175 * _e3464));
                                phi_11750_ = (_e3361.background.color + vec4<f32>((_e179.x * _e3464), (_e179.y * _e3464), (_e179.z * _e3464), (_e179.w * _e3464)));
                                phi_11748_ = (_e3361.background.kernel + vec4<f32>((_e177.x * _e3464), (_e177.y * _e3464), (_e177.z * _e3464), (_e177.w * _e3464)));
                                phi_11741_ = _e3332;
                            } else {
                                phi_11790_ = _e181;
                                phi_11789_ = _e183;
                                phi_11788_ = _e185;
                                phi_11777_ = _e187;
                                phi_11770_ = _e189;
                                phi_11763_ = _e193;
                                phi_11756_ = _e191;
                                phi_11752_ = _e175;
                                phi_11750_ = _e179;
                                phi_11748_ = _e177;
                                phi_11741_ = _e195;
                            }
                            let _e3491 = phi_11790_;
                            let _e3493 = phi_11789_;
                            let _e3495 = phi_11788_;
                            let _e3497 = phi_11777_;
                            let _e3499 = phi_11770_;
                            let _e3501 = phi_11763_;
                            let _e3503 = phi_11756_;
                            let _e3505 = phi_11752_;
                            let _e3507 = phi_11750_;
                            let _e3509 = phi_11748_;
                            let _e3511 = phi_11741_;
                            continue;
                            continuing {
                                phi_11454_ = _e3505;
                                phi_11146_ = _e3509;
                                phi_10838_ = _e3507;
                                phi_10530_ = _e3491;
                                phi_10226_ = _e3493;
                                phi_9922_ = _e3495;
                                phi_9618_ = _e3497;
                                phi_9314_ = _e3499;
                                phi_9010_ = _e3503;
                                phi_8706_ = _e3501;
                                phi_8392_ = _e3511;
                                phi_371_ = _e210;
                                phi_11775_ = _e3497;
                                phi_11768_ = _e3499;
                                phi_11761_ = _e3501;
                                phi_11754_ = _e3503;
                                phi_11751_ = _e3505;
                                phi_11749_ = _e3507;
                                phi_11747_ = _e3509;
                                phi_11740_ = _e3511;
                                break if !(_e216);
                            }
                        }
                        let _e3514 = phi_11775_;
                        let _e3516 = phi_11768_;
                        let _e3518 = phi_11761_;
                        let _e3520 = phi_11754_;
                        let _e3522 = phi_11751_;
                        let _e3524 = phi_11749_;
                        let _e3526 = phi_11747_;
                        let _e3528 = phi_11740_;
                        if _e3528 {
                            break;
                        }
                        if (_e3526.z != 0f) {
                            phi_11787_ = (_e3522 / _e3526.z);
                            phi_11782_ = vec4<f32>((_e3524.x / _e3526.x), (_e3524.y / _e3526.y), (_e3524.z / _e3526.z), (_e3524.w / _e3526.w));
                        } else {
                            phi_11787_ = _e3522;
                            phi_11782_ = _e3524;
                        }
                        let _e3545 = phi_11787_;
                        let _e3547 = phi_11782_;
                        if _e161 {
                            let _e3640 = settings.member.render_scale;
                            let _e3645 = smoothstep(0f, 1f, abs(((_e169 * f32(_e3640)) * 0.75f)));
                            let _e3647 = (_e3547.x * _e3645);
                            let _e3649 = (_e3547.y * _e3645);
                            let _e3651 = (_e3547.z * _e3645);
                            let _e3653 = (_e3547.w * _e3645);
                            if (_e81 == 5u) {
                                if (0u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[0u] = _e3647;
                                if (1u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[1u] = _e3649;
                                if (2u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[2u] = _e3651;
                                if (3u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[3u] = _e3653;
                                if (4u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[4u] = _e3645;
                            } else {
                                if (_e79.x >= _e104) {
                                } else {
                                    let _e3658 = (_e79.x * 5u);
                                    if (((((_e79.y * _e104) * 5u) + _e3658) + 5u) > _e81) {
                                    } else {
                                        let _e3664 = ((_e79.y * (_e104 * 5u)) + _e3658);
                                        if (_e3664 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3664] = _e3647;
                                        let _e3668 = (_e3664 + 1u);
                                        if (_e3668 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3668] = _e3649;
                                        let _e3672 = (_e3664 + 2u);
                                        if (_e3672 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3672] = _e3651;
                                        let _e3676 = (_e3664 + 3u);
                                        if (_e3676 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3676] = _e3653;
                                        let _e3680 = (_e3664 + 4u);
                                        if (_e3680 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3680] = _e3645;
                                    }
                                }
                            }
                        } else {
                            if (_e3520.z != 0f) {
                                phi_11785_ = (_e3514 / _e3520.z);
                                phi_11784_ = (_e3516 / _e3520.z);
                                phi_11783_ = vec4<f32>((_e3518.x / _e3520.x), (_e3518.y / _e3520.y), (_e3518.z / _e3520.z), (_e3518.w / _e3520.w));
                            } else {
                                phi_11785_ = _e3514;
                                phi_11784_ = _e3516;
                                phi_11783_ = _e3518;
                            }
                            let _e3565 = phi_11785_;
                            let _e3567 = phi_11784_;
                            let _e3569 = phi_11783_;
                            let _e3570 = (1f - _e3567);
                            let _e3580 = (_e3569.x + (_e3547.x * _e3570));
                            let _e3582 = (_e3569.y + (_e3547.y * _e3570));
                            let _e3584 = (_e3569.z + (_e3547.z * _e3570));
                            let _e3586 = (_e3569.w + (_e3547.w * _e3570));
                            let _e3588 = (_e3565 + (_e3545 * _e3570));
                            let _e3590 = select(_e3588, 0f, (_e3588 < 0f));
                            let _e3592 = select(_e3590, 1f, (_e3590 > 1f));
                            if (_e81 == 5u) {
                                if (0u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[0u] = _e3580;
                                if (1u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[1u] = _e3582;
                                if (2u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[2u] = _e3584;
                                if (3u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[3u] = _e3586;
                                if (4u < _e81) {
                                } else {
                                    break;
                                }
                                output_image.member[4u] = _e3592;
                            } else {
                                if (_e79.x >= _e104) {
                                } else {
                                    let _e3597 = (_e79.x * 5u);
                                    if (((((_e79.y * _e104) * 5u) + _e3597) + 5u) > _e81) {
                                    } else {
                                        let _e3603 = ((_e79.y * (_e104 * 5u)) + _e3597);
                                        if (_e3603 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3603] = _e3580;
                                        let _e3607 = (_e3603 + 1u);
                                        if (_e3607 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3607] = _e3582;
                                        let _e3611 = (_e3603 + 2u);
                                        if (_e3611 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3611] = _e3584;
                                        let _e3615 = (_e3603 + 3u);
                                        if (_e3615 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3615] = _e3586;
                                        let _e3619 = (_e3603 + 4u);
                                        if (_e3619 < _e81) {
                                        } else {
                                            break;
                                        }
                                        output_image.member[_e3619] = _e3592;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            break;
        }
    }
    return;
}

@compute @workgroup_size(16, 16, 1) 
fn convolve_kernel_f32_(@builtin(global_invocation_id) gid: vec3<u32>) {
    gid_1 = gid;
    function();
}