---
source: render/naga-agal/tests/wgsl.rs
expression: output
---
struct FragmentOutput {
    @location(0) member: vec4<f32>,
}

@group(0) @binding(1) 
var<uniform> constant_registers: array<vec4<f32>, 28>;
@group(0) @binding(10) 
var texture0_: texture_cube<f32>;
@group(0) @binding(2) 
var sampler0_: sampler;

@fragment 
fn main(@location(0) param: vec4<f32>) -> FragmentOutput {
    var dest_temp: vec4<f32>;
    var temporary0_: vec4<f32>;
    var temporary1_: vec4<f32>;
    var temporary2_: vec4<f32>;
    var temporary4_: vec4<f32>;
    var temporary3_: vec4<f32>;
    var temporary5_: vec4<f32>;
    var temporary6_: vec4<f32>;
    var temporary7_: vec4<f32>;
    var temporary8_: vec4<f32>;
    var temporary10_: vec4<f32>;
    var temporary9_: vec4<f32>;
    var temporary11_: vec4<f32>;
    var temporary12_: vec4<f32>;
    var temporary13_: vec4<f32>;
    var temporary14_: vec4<f32>;
    var temporary15_: vec4<f32>;
    var temporary16_: vec4<f32>;
    var temporary20_: vec4<f32>;
    var temporary18_: vec4<f32>;
    var temporary17_: vec4<f32>;
    var temporary19_: vec4<f32>;

    let _e4: vec4<f32> = constant_registers[16u];
    temporary0_ = _e4.xxxy;
    let _e11: vec4<f32> = constant_registers[3u];
    temporary1_.x = (param.xxxx * _e11.xxxx).x;
    temporary1_.y = param.yyyy.x;
    let _e22: vec4<f32> = constant_registers[1u];
    let _e23: vec4<f32> = _e22.xxxx;
    temporary1_.z = _e23.z;
    temporary1_.w = _e23.w;
    let _e28: vec4<f32> = temporary1_;
    let _e32: vec4<f32> = constant_registers[16u];
    let _e34: vec4<f32> = (_e28.zzzw * _e32.zzzz);
    temporary1_.z = _e34.z;
    temporary1_.w = _e34.w;
    let _e39: vec4<f32> = temporary1_;
    temporary1_.z = cos(_e39.zzzz).x;
    let _e44: vec4<f32> = temporary1_;
    let _e48: vec4<f32> = constant_registers[16u];
    temporary2_.x = (_e44.zzzz * _e48.wwww).x;
    let _e56: vec4<f32> = constant_registers[1u];
    temporary1_.z = _e56.yyyy.x;
    let _e60: vec4<f32> = temporary1_;
    let _e64: vec4<f32> = constant_registers[16u];
    temporary1_.z = (_e60.zzzz + _e64.yyyy).x;
    let _e69: vec4<f32> = temporary1_;
    let _e73: vec4<f32> = constant_registers[17u];
    temporary1_.z = (_e69.zzzz * _e73.xxxx).x;
    let _e78: vec4<f32> = temporary1_;
    let _e82: vec4<f32> = constant_registers[17u];
    temporary1_.z = max(_e78.zzzz, _e82.yyyy).x;
    let _e87: vec4<f32> = temporary1_;
    temporary1_.w = sin(_e87.wwww).x;
    let _e92: vec4<f32> = temporary1_;
    let _e96: vec4<f32> = constant_registers[16u];
    temporary2_.z = (_e92.wwww * _e96.wwww).x;
    let _e101: vec4<f32> = temporary1_;
    temporary2_.y = _e101.zzzz.x;
    let _e107: vec4<f32> = constant_registers[16u];
    let _e108: vec4<f32> = _e107.xxxx;
    temporary4_.x = _e108.x;
    temporary4_.z = _e108.z;
    let _e116: vec4<f32> = constant_registers[17u];
    temporary4_.y = _e116.zzzz.x;
    let _e122: vec4<f32> = constant_registers[16u];
    temporary1_.w = _e122.yyyy.x;
    let _e126: vec4<f32> = temporary4_;
    let _e128: vec4<f32> = temporary2_;
    let _e130: vec4<f32> = (_e126.xyzz - _e128.xyzz);
    temporary3_.x = _e130.x;
    temporary3_.y = _e130.y;
    temporary3_.z = _e130.z;
    let _e138: vec4<f32> = temporary3_;
    let _e140: vec3<f32> = normalize(_e138.xyz);
    temporary3_.x = _e140.x;
    temporary3_.y = _e140.y;
    temporary3_.z = _e140.z;
    let _e149: vec4<f32> = constant_registers[16u];
    let _e151: vec4<f32> = temporary3_;
    let _e153: vec3<f32> = cross(_e149.xyx, _e151.xyz);
    let _e158: vec4<f32> = vec4<f32>(_e153.x, _e153.y, _e153.z, 1f);
    temporary5_.x = _e158.x;
    temporary5_.y = _e158.y;
    temporary5_.z = _e158.z;
    let _e166: vec4<f32> = temporary5_;
    let _e168: vec3<f32> = normalize(_e166.xyz);
    temporary6_.x = _e168.x;
    temporary6_.y = _e168.y;
    temporary6_.z = _e168.z;
    let _e176: vec4<f32> = temporary3_;
    let _e178: vec4<f32> = temporary6_;
    let _e180: vec3<f32> = cross(_e176.xyz, _e178.xyz);
    let _e185: vec4<f32> = vec4<f32>(_e180.x, _e180.y, _e180.z, 1f);
    temporary5_.x = _e185.x;
    temporary5_.y = _e185.y;
    temporary5_.z = _e185.z;
    let _e192: vec4<f32> = temporary3_;
    let _e194: vec4<f32> = temporary1_;
    let _e196: vec4<f32> = (_e192.xyzz * _e194.wwww);
    temporary3_.x = _e196.x;
    temporary3_.y = _e196.y;
    temporary3_.z = _e196.z;
    let _e203: vec4<f32> = temporary6_;
    let _e205: vec4<f32> = temporary1_;
    let _e207: vec4<f32> = (_e203.xyzz * _e205.xxxx);
    temporary6_.x = _e207.x;
    temporary6_.y = _e207.y;
    temporary6_.z = _e207.z;
    let _e214: vec4<f32> = temporary3_;
    let _e216: vec4<f32> = temporary6_;
    let _e218: vec4<f32> = (_e214.xyzz + _e216.xyzz);
    temporary7_.x = _e218.x;
    temporary7_.y = _e218.y;
    temporary7_.z = _e218.z;
    let _e226: vec4<f32> = temporary5_;
    let _e228: vec4<f32> = temporary1_;
    let _e230: vec4<f32> = (_e226.xyzz * _e228.yyyy);
    temporary5_.x = _e230.x;
    temporary5_.y = _e230.y;
    temporary5_.z = _e230.z;
    let _e237: vec4<f32> = temporary7_;
    let _e239: vec4<f32> = temporary5_;
    let _e241: vec4<f32> = (_e237.xyzz + _e239.xyzz);
    temporary5_.x = _e241.x;
    temporary5_.y = _e241.y;
    temporary5_.z = _e241.z;
    let _e248: vec4<f32> = temporary5_;
    let _e250: vec3<f32> = normalize(_e248.xyz);
    temporary8_.x = _e250.x;
    temporary8_.y = _e250.y;
    temporary8_.z = _e250.z;
    let _e258: vec4<f32> = temporary8_;
    let _e259: vec4<f32> = _e258.xyzz;
    temporary10_.x = _e259.x;
    temporary10_.y = _e259.y;
    temporary10_.z = _e259.z;
    let _e267: vec4<f32> = temporary10_;
    let _e268: vec4<f32> = _e267.xyzz;
    temporary9_.x = _e268.x;
    temporary9_.y = _e268.y;
    temporary9_.z = _e268.z;
    let _e278: vec4<f32> = constant_registers[16u];
    let _e279: vec4<f32> = _e278.yxxx;
    temporary11_.x = _e279.x;
    temporary11_.y = _e279.y;
    temporary11_.z = _e279.z;
    let _e287: vec4<f32> = temporary11_;
    let _e291: vec4<f32> = constant_registers[16u];
    if all((_e287.xxxx != _e291.xxxx)) {
        let _e297: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e297.xxxx.x;
        let _e303: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e303.wwww.x;
        let _e309: vec4<f32> = constant_registers[16u];
        let _e310: vec4<f32> = _e309.xyxx;
        temporary3_.x = _e310.x;
        temporary3_.y = _e310.y;
        temporary3_.z = _e310.z;
        let _e317: vec4<f32> = temporary3_;
        let _e318: vec4<f32> = _e317.xyzz;
        temporary12_.x = _e318.x;
        temporary12_.y = _e318.y;
        temporary12_.z = _e318.z;
        let _e328: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e328.wwww.x;
        let _e332: vec4<f32> = temporary2_;
        let _e336: vec4<f32> = constant_registers[16u];
        let _e338: vec4<f32> = (_e332.xyzz - _e336.xxxx);
        temporary13_.x = _e338.x;
        temporary13_.y = _e338.y;
        temporary13_.z = _e338.z;
        let _e346: vec4<f32> = temporary13_;
        let _e348: vec4<f32> = temporary12_;
        temporary1_.y = dot(_e346.xyz, _e348.xyz);
        let _e352: vec4<f32> = temporary1_;
        temporary1_.y = -(_e352.yyyy).x;
        let _e357: vec4<f32> = temporary9_;
        let _e359: vec4<f32> = temporary12_;
        temporary12_.x = dot(_e357.xyz, _e359.xyz);
        let _e363: vec4<f32> = temporary1_;
        let _e365: vec4<f32> = temporary12_;
        temporary12_.y = (_e363.yyyy / _e365.xxxx).x;
        let _e370: vec4<f32> = temporary12_;
        temporary1_.y = _e370.yyyy.x;
        let _e376: vec4<f32> = constant_registers[16u];
        let _e378: vec4<f32> = temporary1_;
        temporary1_.w = vec4<f32>((_e376.xxxx < _e378.yyyy)).x;
        let _e384: vec4<f32> = temporary1_;
        let _e388: vec4<f32> = constant_registers[16u];
        if all((_e384.wwww != _e388.xxxx)) {
            let _e392: vec4<f32> = temporary1_;
            temporary1_.x = _e392.yyyy.x;
        }
        let _e396: vec4<f32> = temporary1_;
        temporary4_.y = _e396.xxxx.x;
        let _e400: vec4<f32> = temporary4_;
        let _e402: vec4<f32> = temporary4_;
        temporary1_.x = vec4<f32>((_e400.yyyy < _e402.zzzz)).x;
        let _e408: vec4<f32> = temporary1_;
        let _e412: vec4<f32> = constant_registers[16u];
        if all((_e408.xxxx != _e412.xxxx)) {
            let _e416: vec4<f32> = temporary4_;
            temporary4_.z = _e416.yyyy.x;
            let _e420: vec4<f32> = temporary3_;
            let _e421: vec4<f32> = _e420.xyzz;
            temporary6_.x = _e421.x;
            temporary6_.y = _e421.y;
            temporary6_.z = _e421.z;
            let _e430: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e430.yyyy.x;
        }
        let _e434: vec4<f32> = temporary2_;
        let _e435: vec4<f32> = _e434.xyzz;
        temporary5_.x = _e435.x;
        temporary5_.y = _e435.y;
        temporary5_.z = _e435.z;
        let _e442: vec4<f32> = temporary9_;
        let _e443: vec4<f32> = _e442.xyzz;
        temporary10_.x = _e443.x;
        temporary10_.y = _e443.y;
        temporary10_.z = _e443.z;
        let _e452: vec4<f32> = constant_registers[4u];
        let _e453: vec4<f32> = _e452.xyzz;
        temporary8_.x = _e453.x;
        temporary8_.y = _e453.y;
        temporary8_.z = _e453.z;
        let _e462: vec4<f32> = constant_registers[6u];
        temporary14_.x = _e462.xxxx.x;
        let _e467: vec4<f32> = temporary3_;
        let _e468: vec4<f32> = _e467.xyzz;
        temporary15_.x = _e468.x;
        temporary15_.y = _e468.y;
        temporary15_.z = _e468.z;
        let _e478: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e478.wwww.x;
        let _e482: vec4<f32> = temporary5_;
        let _e484: vec4<f32> = temporary8_;
        let _e486: vec4<f32> = (_e482.xyzz - _e484.xyzz);
        temporary16_.x = _e486.x;
        temporary16_.y = _e486.y;
        temporary16_.z = _e486.z;
        let _e494: vec4<f32> = temporary16_;
        let _e496: vec4<f32> = temporary10_;
        temporary14_.z = dot(_e494.xyz, _e496.xyz);
        let _e500: vec4<f32> = temporary14_;
        let _e502: vec4<f32> = temporary14_;
        let _e504: vec4<f32> = (_e500.zzzx * _e502.zzzx);
        temporary4_.x = _e504.x;
        temporary4_.w = _e504.w;
        let _e509: vec4<f32> = temporary16_;
        let _e511: vec4<f32> = temporary16_;
        temporary1_.y = dot(_e509.xyz, _e511.xyz);
        let _e515: vec4<f32> = temporary4_;
        let _e517: vec4<f32> = temporary1_;
        temporary1_.w = (_e515.xxxx - _e517.yyyy).x;
        let _e522: vec4<f32> = temporary1_;
        let _e524: vec4<f32> = temporary4_;
        temporary13_.x = (_e522.wwww + _e524.wwww).x;
        let _e529: vec4<f32> = temporary13_;
        temporary1_.w = _e529.xxxx.x;
        let _e535: vec4<f32> = constant_registers[16u];
        let _e537: vec4<f32> = temporary1_;
        temporary2_.w = vec4<f32>((_e535.xxxx < _e537.wwww)).x;
        let _e543: vec4<f32> = temporary2_;
        let _e547: vec4<f32> = constant_registers[16u];
        if all((_e543.wwww != _e547.xxxx)) {
            let _e551: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e551.wwww).x;
            let _e556: vec4<f32> = temporary14_;
            temporary1_.y = -(_e556.zzzz).x;
            let _e561: vec4<f32> = temporary1_;
            let _e563: vec4<f32> = temporary1_;
            temporary2_.w = (_e561.yyyy - _e563.wwww).x;
            let _e570: vec4<f32> = constant_registers[16u];
            let _e572: vec4<f32> = temporary2_;
            temporary1_.y = vec4<f32>((_e570.xxxx < _e572.wwww)).x;
            let _e578: vec4<f32> = temporary1_;
            let _e582: vec4<f32> = constant_registers[16u];
            if all((_e578.yyyy != _e582.xxxx)) {
                let _e586: vec4<f32> = temporary2_;
                temporary1_.x = _e586.wwww.x;
                let _e590: vec4<f32> = temporary10_;
                let _e592: vec4<f32> = temporary2_;
                let _e594: vec4<f32> = (_e590.xyzz * _e592.wwww);
                temporary13_.x = _e594.x;
                temporary13_.y = _e594.y;
                temporary13_.z = _e594.z;
                let _e601: vec4<f32> = temporary5_;
                let _e603: vec4<f32> = temporary13_;
                let _e605: vec4<f32> = (_e601.xyzz + _e603.xyzz);
                temporary12_.x = _e605.x;
                temporary12_.y = _e605.y;
                temporary12_.z = _e605.z;
                let _e612: vec4<f32> = temporary12_;
                let _e614: vec4<f32> = temporary8_;
                let _e616: vec4<f32> = (_e612.xyzz - _e614.xyzz);
                temporary14_.x = _e616.x;
                temporary14_.y = _e616.y;
                temporary14_.z = _e616.z;
                let _e623: vec4<f32> = temporary14_;
                let _e625: vec3<f32> = normalize(_e623.xyz);
                temporary16_.x = _e625.x;
                temporary16_.y = _e625.y;
                temporary16_.z = _e625.z;
                let _e632: vec4<f32> = temporary16_;
                let _e633: vec4<f32> = _e632.xyzz;
                temporary20_.x = _e633.x;
                temporary20_.y = _e633.y;
                temporary20_.z = _e633.z;
                let _e641: vec4<f32> = temporary20_;
                let _e642: vec4<f32> = _e641.xyzz;
                temporary15_.x = _e642.x;
                temporary15_.y = _e642.y;
                temporary15_.z = _e642.z;
            }
        }
        let _e649: vec4<f32> = temporary1_;
        temporary4_.y = _e649.xxxx.x;
        let _e653: vec4<f32> = temporary15_;
        let _e654: vec4<f32> = _e653.xyzz;
        temporary3_.x = _e654.x;
        temporary3_.y = _e654.y;
        temporary3_.z = _e654.z;
        let _e661: vec4<f32> = temporary4_;
        let _e663: vec4<f32> = temporary4_;
        temporary1_.x = vec4<f32>((_e661.yyyy < _e663.zzzz)).x;
        let _e669: vec4<f32> = temporary1_;
        let _e673: vec4<f32> = constant_registers[16u];
        if all((_e669.xxxx != _e673.xxxx)) {
            let _e677: vec4<f32> = temporary4_;
            temporary4_.z = _e677.yyyy.x;
            let _e681: vec4<f32> = temporary3_;
            let _e682: vec4<f32> = _e681.xyzz;
            temporary6_.x = _e682.x;
            temporary6_.y = _e682.y;
            temporary6_.z = _e682.z;
            let _e691: vec4<f32> = constant_registers[5u];
            let _e692: vec4<f32> = _e691.xyzz;
            temporary7_.x = _e692.x;
            temporary7_.y = _e692.y;
            temporary7_.z = _e692.z;
            let _e701: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e701.xxxx.x;
        }
        let _e705: vec4<f32> = temporary2_;
        let _e706: vec4<f32> = _e705.xyzz;
        temporary5_.x = _e706.x;
        temporary5_.y = _e706.y;
        temporary5_.z = _e706.z;
        let _e713: vec4<f32> = temporary9_;
        let _e714: vec4<f32> = _e713.xyzz;
        temporary10_.x = _e714.x;
        temporary10_.y = _e714.y;
        temporary10_.z = _e714.z;
        let _e723: vec4<f32> = constant_registers[7u];
        let _e724: vec4<f32> = _e723.xyzz;
        temporary8_.x = _e724.x;
        temporary8_.y = _e724.y;
        temporary8_.z = _e724.z;
        let _e733: vec4<f32> = constant_registers[9u];
        temporary15_.x = _e733.xxxx.x;
        let _e737: vec4<f32> = temporary3_;
        let _e738: vec4<f32> = _e737.xyzz;
        temporary18_.x = _e738.x;
        temporary18_.y = _e738.y;
        temporary18_.z = _e738.z;
        let _e748: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e748.wwww.x;
        let _e752: vec4<f32> = temporary5_;
        let _e754: vec4<f32> = temporary8_;
        let _e756: vec4<f32> = (_e752.xyzz - _e754.xyzz);
        temporary17_.x = _e756.x;
        temporary17_.y = _e756.y;
        temporary17_.z = _e756.z;
        let _e764: vec4<f32> = temporary17_;
        let _e766: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e764.xyz, _e766.xyz);
        let _e770: vec4<f32> = temporary15_;
        let _e772: vec4<f32> = temporary15_;
        let _e774: vec4<f32> = (_e770.zzzx * _e772.zzzx);
        temporary4_.x = _e774.x;
        temporary4_.w = _e774.w;
        let _e779: vec4<f32> = temporary17_;
        let _e781: vec4<f32> = temporary17_;
        temporary1_.y = dot(_e779.xyz, _e781.xyz);
        let _e785: vec4<f32> = temporary4_;
        let _e787: vec4<f32> = temporary1_;
        temporary1_.w = (_e785.xxxx - _e787.yyyy).x;
        let _e792: vec4<f32> = temporary1_;
        let _e794: vec4<f32> = temporary4_;
        temporary13_.x = (_e792.wwww + _e794.wwww).x;
        let _e799: vec4<f32> = temporary13_;
        temporary1_.w = _e799.xxxx.x;
        let _e805: vec4<f32> = constant_registers[16u];
        let _e807: vec4<f32> = temporary1_;
        temporary2_.w = vec4<f32>((_e805.xxxx < _e807.wwww)).x;
        let _e813: vec4<f32> = temporary2_;
        let _e817: vec4<f32> = constant_registers[16u];
        if all((_e813.wwww != _e817.xxxx)) {
            let _e821: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e821.wwww).x;
            let _e826: vec4<f32> = temporary15_;
            temporary1_.y = -(_e826.zzzz).x;
            let _e831: vec4<f32> = temporary1_;
            let _e833: vec4<f32> = temporary1_;
            temporary2_.w = (_e831.yyyy - _e833.wwww).x;
            let _e840: vec4<f32> = constant_registers[16u];
            let _e842: vec4<f32> = temporary2_;
            temporary1_.y = vec4<f32>((_e840.xxxx < _e842.wwww)).x;
            let _e848: vec4<f32> = temporary1_;
            let _e852: vec4<f32> = constant_registers[16u];
            if all((_e848.yyyy != _e852.xxxx)) {
                let _e856: vec4<f32> = temporary2_;
                temporary1_.x = _e856.wwww.x;
                let _e860: vec4<f32> = temporary10_;
                let _e862: vec4<f32> = temporary2_;
                let _e864: vec4<f32> = (_e860.xyzz * _e862.wwww);
                temporary13_.x = _e864.x;
                temporary13_.y = _e864.y;
                temporary13_.z = _e864.z;
                let _e871: vec4<f32> = temporary5_;
                let _e873: vec4<f32> = temporary13_;
                let _e875: vec4<f32> = (_e871.xyzz + _e873.xyzz);
                temporary12_.x = _e875.x;
                temporary12_.y = _e875.y;
                temporary12_.z = _e875.z;
                let _e882: vec4<f32> = temporary12_;
                let _e884: vec4<f32> = temporary8_;
                let _e886: vec4<f32> = (_e882.xyzz - _e884.xyzz);
                temporary14_.x = _e886.x;
                temporary14_.y = _e886.y;
                temporary14_.z = _e886.z;
                let _e893: vec4<f32> = temporary14_;
                let _e895: vec3<f32> = normalize(_e893.xyz);
                temporary16_.x = _e895.x;
                temporary16_.y = _e895.y;
                temporary16_.z = _e895.z;
                let _e902: vec4<f32> = temporary16_;
                let _e903: vec4<f32> = _e902.xyzz;
                temporary20_.x = _e903.x;
                temporary20_.y = _e903.y;
                temporary20_.z = _e903.z;
                let _e910: vec4<f32> = temporary20_;
                let _e911: vec4<f32> = _e910.xyzz;
                temporary18_.x = _e911.x;
                temporary18_.y = _e911.y;
                temporary18_.z = _e911.z;
            }
        }
        let _e918: vec4<f32> = temporary1_;
        temporary4_.y = _e918.xxxx.x;
        let _e922: vec4<f32> = temporary18_;
        let _e923: vec4<f32> = _e922.xyzz;
        temporary3_.x = _e923.x;
        temporary3_.y = _e923.y;
        temporary3_.z = _e923.z;
        let _e930: vec4<f32> = temporary4_;
        let _e932: vec4<f32> = temporary4_;
        temporary1_.x = vec4<f32>((_e930.yyyy < _e932.zzzz)).x;
        let _e938: vec4<f32> = temporary1_;
        let _e942: vec4<f32> = constant_registers[16u];
        if all((_e938.xxxx != _e942.xxxx)) {
            let _e946: vec4<f32> = temporary4_;
            temporary4_.z = _e946.yyyy.x;
            let _e950: vec4<f32> = temporary3_;
            let _e951: vec4<f32> = _e950.xyzz;
            temporary6_.x = _e951.x;
            temporary6_.y = _e951.y;
            temporary6_.z = _e951.z;
            let _e960: vec4<f32> = constant_registers[8u];
            let _e961: vec4<f32> = _e960.xyzz;
            temporary7_.x = _e961.x;
            temporary7_.y = _e961.y;
            temporary7_.z = _e961.z;
            let _e970: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e970.xxxx.x;
        }
        let _e974: vec4<f32> = temporary2_;
        let _e975: vec4<f32> = _e974.xyzz;
        temporary5_.x = _e975.x;
        temporary5_.y = _e975.y;
        temporary5_.z = _e975.z;
        let _e982: vec4<f32> = temporary9_;
        let _e983: vec4<f32> = _e982.xyzz;
        temporary10_.x = _e983.x;
        temporary10_.y = _e983.y;
        temporary10_.z = _e983.z;
        let _e992: vec4<f32> = constant_registers[10u];
        let _e993: vec4<f32> = _e992.xyzz;
        temporary8_.x = _e993.x;
        temporary8_.y = _e993.y;
        temporary8_.z = _e993.z;
        let _e1002: vec4<f32> = constant_registers[12u];
        temporary15_.x = _e1002.xxxx.x;
        let _e1006: vec4<f32> = temporary3_;
        let _e1007: vec4<f32> = _e1006.xyzz;
        temporary17_.x = _e1007.x;
        temporary17_.y = _e1007.y;
        temporary17_.z = _e1007.z;
        let _e1016: vec4<f32> = constant_registers[17u];
        temporary15_.y = _e1016.wwww.x;
        let _e1020: vec4<f32> = temporary5_;
        let _e1022: vec4<f32> = temporary8_;
        let _e1024: vec4<f32> = (_e1020.xyzz - _e1022.xyzz);
        temporary18_.x = _e1024.x;
        temporary18_.y = _e1024.y;
        temporary18_.z = _e1024.z;
        let _e1031: vec4<f32> = temporary18_;
        let _e1033: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e1031.xyz, _e1033.xyz);
        let _e1037: vec4<f32> = temporary15_;
        let _e1039: vec4<f32> = temporary15_;
        let _e1041: vec4<f32> = (_e1037.zzzx * _e1039.zzzx);
        temporary1_.x = _e1041.x;
        temporary1_.w = _e1041.w;
        let _e1046: vec4<f32> = temporary18_;
        let _e1048: vec4<f32> = temporary18_;
        temporary19_.y = dot(_e1046.xyz, _e1048.xyz);
        let _e1053: vec4<f32> = temporary1_;
        let _e1055: vec4<f32> = temporary19_;
        temporary19_.z = (_e1053.xxxx - _e1055.yyyy).x;
        let _e1060: vec4<f32> = temporary19_;
        let _e1062: vec4<f32> = temporary1_;
        temporary13_.x = (_e1060.zzzz + _e1062.wwww).x;
        let _e1067: vec4<f32> = temporary13_;
        temporary1_.x = _e1067.xxxx.x;
        let _e1073: vec4<f32> = constant_registers[16u];
        let _e1075: vec4<f32> = temporary1_;
        temporary19_.x = vec4<f32>((_e1073.xxxx < _e1075.xxxx)).x;
        let _e1081: vec4<f32> = temporary19_;
        let _e1085: vec4<f32> = constant_registers[16u];
        if all((_e1081.xxxx != _e1085.xxxx)) {
            let _e1089: vec4<f32> = temporary1_;
            temporary1_.x = sqrt(_e1089.xxxx).x;
            let _e1094: vec4<f32> = temporary15_;
            temporary19_.y = -(_e1094.zzzz).x;
            let _e1099: vec4<f32> = temporary19_;
            let _e1101: vec4<f32> = temporary1_;
            temporary19_.z = (_e1099.yyyy - _e1101.xxxx).x;
            let _e1106: vec4<f32> = temporary19_;
            temporary19_.x = _e1106.zzzz.x;
            let _e1112: vec4<f32> = constant_registers[16u];
            let _e1114: vec4<f32> = temporary19_;
            temporary19_.y = vec4<f32>((_e1112.xxxx < _e1114.xxxx)).x;
            let _e1120: vec4<f32> = temporary19_;
            let _e1124: vec4<f32> = constant_registers[16u];
            if all((_e1120.yyyy != _e1124.xxxx)) {
                let _e1128: vec4<f32> = temporary19_;
                temporary15_.y = _e1128.xxxx.x;
                let _e1132: vec4<f32> = temporary10_;
                let _e1134: vec4<f32> = temporary19_;
                let _e1136: vec4<f32> = (_e1132.xyzz * _e1134.xxxx);
                temporary13_.x = _e1136.x;
                temporary13_.y = _e1136.y;
                temporary13_.z = _e1136.z;
                let _e1143: vec4<f32> = temporary5_;
                let _e1145: vec4<f32> = temporary13_;
                let _e1147: vec4<f32> = (_e1143.xyzz + _e1145.xyzz);
                temporary12_.x = _e1147.x;
                temporary12_.y = _e1147.y;
                temporary12_.z = _e1147.z;
                let _e1154: vec4<f32> = temporary12_;
                let _e1156: vec4<f32> = temporary8_;
                let _e1158: vec4<f32> = (_e1154.xyzz - _e1156.xyzz);
                temporary14_.x = _e1158.x;
                temporary14_.y = _e1158.y;
                temporary14_.z = _e1158.z;
                let _e1165: vec4<f32> = temporary14_;
                let _e1167: vec3<f32> = normalize(_e1165.xyz);
                temporary16_.x = _e1167.x;
                temporary16_.y = _e1167.y;
                temporary16_.z = _e1167.z;
                let _e1174: vec4<f32> = temporary16_;
                let _e1175: vec4<f32> = _e1174.xyzz;
                temporary20_.x = _e1175.x;
                temporary20_.y = _e1175.y;
                temporary20_.z = _e1175.z;
                let _e1182: vec4<f32> = temporary20_;
                let _e1183: vec4<f32> = _e1182.xyzz;
                temporary17_.x = _e1183.x;
                temporary17_.y = _e1183.y;
                temporary17_.z = _e1183.z;
            }
        }
        let _e1190: vec4<f32> = temporary15_;
        temporary4_.y = _e1190.yyyy.x;
        let _e1194: vec4<f32> = temporary17_;
        let _e1195: vec4<f32> = _e1194.xyzz;
        temporary3_.x = _e1195.x;
        temporary3_.y = _e1195.y;
        temporary3_.z = _e1195.z;
        let _e1202: vec4<f32> = temporary4_;
        let _e1204: vec4<f32> = temporary4_;
        temporary1_.y = vec4<f32>((_e1202.yyyy < _e1204.zzzz)).x;
        let _e1210: vec4<f32> = temporary1_;
        let _e1214: vec4<f32> = constant_registers[16u];
        if all((_e1210.yyyy != _e1214.xxxx)) {
            let _e1218: vec4<f32> = temporary4_;
            temporary4_.z = _e1218.yyyy.x;
            let _e1222: vec4<f32> = temporary3_;
            let _e1223: vec4<f32> = _e1222.xyzz;
            temporary6_.x = _e1223.x;
            temporary6_.y = _e1223.y;
            temporary6_.z = _e1223.z;
            let _e1232: vec4<f32> = constant_registers[11u];
            let _e1233: vec4<f32> = _e1232.xyzz;
            temporary7_.x = _e1233.x;
            temporary7_.y = _e1233.y;
            temporary7_.z = _e1233.z;
            let _e1242: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e1242.xxxx.x;
        }
        let _e1246: vec4<f32> = temporary11_;
        let _e1250: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e1246.yyyy + _e1250.yyyy).x;
        let _e1255: vec4<f32> = temporary1_;
        let _e1259: vec4<f32> = constant_registers[16u];
        temporary1_.y = vec4<f32>((_e1255.zzzz == _e1259.xxxx)).x;
        let _e1265: vec4<f32> = temporary1_;
        let _e1269: vec4<f32> = constant_registers[16u];
        if all((_e1265.yyyy != _e1269.xxxx)) {
            let _e1275: vec4<f32> = constant_registers[16u];
            let _e1276: vec4<f32> = _e1275.xyyy;
            temporary11_.x = _e1276.x;
            temporary11_.z = _e1276.z;
        } else {
            let _e1281: vec4<f32> = temporary9_;
            let _e1283: vec4<f32> = temporary4_;
            let _e1285: vec4<f32> = (_e1281.xyzz * _e1283.zzzz);
            temporary5_.x = _e1285.x;
            temporary5_.y = _e1285.y;
            temporary5_.z = _e1285.z;
            let _e1292: vec4<f32> = temporary2_;
            let _e1294: vec4<f32> = temporary5_;
            let _e1296: vec4<f32> = (_e1292.xyzz + _e1294.xyzz);
            temporary2_.x = _e1296.x;
            temporary2_.y = _e1296.y;
            temporary2_.z = _e1296.z;
            let _e1303: vec4<f32> = temporary9_;
            let _e1305: vec4<f32> = temporary6_;
            temporary1_.y = dot(_e1303.xyz, _e1305.xyz);
            let _e1309: vec4<f32> = temporary1_;
            let _e1313: vec4<f32> = constant_registers[18u];
            temporary5_.x = (_e1309.yyyy * _e1313.xxxx).x;
            let _e1318: vec4<f32> = temporary5_;
            let _e1320: vec4<f32> = temporary6_;
            let _e1322: vec4<f32> = (_e1318.xxxx * _e1320.xyzz);
            temporary10_.x = _e1322.x;
            temporary10_.y = _e1322.y;
            temporary10_.z = _e1322.z;
            let _e1329: vec4<f32> = temporary9_;
            let _e1331: vec4<f32> = temporary10_;
            let _e1333: vec4<f32> = (_e1329.xyzz - _e1331.xyzz);
            temporary9_.x = _e1333.x;
            temporary9_.y = _e1333.y;
            temporary9_.z = _e1333.z;
            let _e1340: vec4<f32> = temporary9_;
            let _e1344: vec4<f32> = constant_registers[18u];
            let _e1346: vec4<f32> = (_e1340.xyzz * _e1344.yyyy);
            temporary5_.x = _e1346.x;
            temporary5_.y = _e1346.y;
            temporary5_.z = _e1346.z;
            let _e1353: vec4<f32> = temporary2_;
            let _e1355: vec4<f32> = temporary5_;
            let _e1357: vec4<f32> = (_e1353.xyzz + _e1355.xyzz);
            temporary2_.x = _e1357.x;
            temporary2_.y = _e1357.y;
            temporary2_.z = _e1357.z;
            let _e1366: vec4<f32> = constant_registers[15u];
            let _e1368: vec4<f32> = temporary2_;
            let _e1370: vec4<f32> = (_e1366.xyzz - _e1368.xyzz);
            temporary5_.x = _e1370.x;
            temporary5_.y = _e1370.y;
            temporary5_.z = _e1370.z;
            let _e1377: vec4<f32> = temporary5_;
            let _e1379: vec3<f32> = normalize(_e1377.xyz);
            temporary10_.x = _e1379.x;
            temporary10_.y = _e1379.y;
            temporary10_.z = _e1379.z;
            let _e1386: vec4<f32> = temporary5_;
            let _e1388: vec4<f32> = temporary5_;
            temporary8_.x = dot(_e1386.xyz, _e1388.xyz);
            let _e1392: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e1392.xxxx).x;
            let _e1397: vec4<f32> = temporary6_;
            let _e1399: vec4<f32> = temporary10_;
            temporary8_.y = dot(_e1397.xyz, _e1399.xyz);
            let _e1403: vec4<f32> = temporary8_;
            temporary8_.z = saturate(_e1403.yyyy).x;
            let _e1408: vec4<f32> = temporary1_;
            let _e1410: vec4<f32> = temporary1_;
            temporary2_.w = (_e1408.yyyy * _e1410.yyyy).x;
            let _e1415: vec4<f32> = temporary2_;
            let _e1419: vec4<f32> = constant_registers[18u];
            temporary15_.x = (_e1415.wwww * _e1419.zzzz).x;
            let _e1426: vec4<f32> = constant_registers[18u];
            let _e1428: vec4<f32> = temporary15_;
            temporary15_.y = (_e1426.wwww + _e1428.xxxx).x;
            let _e1433: vec4<f32> = temporary8_;
            let _e1435: vec4<f32> = temporary15_;
            temporary8_.x = (_e1433.zzzz / _e1435.yyyy).x;
            let _e1442: vec4<f32> = constant_registers[6u];
            temporary8_.z = _e1442.xxxx.x;
            let _e1448: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1448.wwww.x;
            let _e1452: vec4<f32> = temporary2_;
            let _e1456: vec4<f32> = constant_registers[4u];
            let _e1458: vec4<f32> = (_e1452.xyzz - _e1456.xyzz);
            temporary19_.x = _e1458.x;
            temporary19_.y = _e1458.y;
            temporary19_.z = _e1458.z;
            let _e1465: vec4<f32> = temporary19_;
            let _e1467: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1465.xyz, _e1467.xyz);
            let _e1471: vec4<f32> = temporary13_;
            let _e1473: vec4<f32> = temporary13_;
            temporary13_.z = (_e1471.xxxx * _e1473.xxxx).x;
            let _e1478: vec4<f32> = temporary19_;
            let _e1480: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1478.xyz, _e1480.xyz);
            let _e1484: vec4<f32> = temporary13_;
            let _e1486: vec4<f32> = temporary3_;
            temporary12_.x = (_e1484.zzzz - _e1486.wwww).x;
            let _e1491: vec4<f32> = temporary8_;
            let _e1493: vec4<f32> = temporary8_;
            temporary12_.y = (_e1491.zzzz * _e1493.zzzz).x;
            let _e1498: vec4<f32> = temporary12_;
            let _e1500: vec4<f32> = temporary12_;
            temporary13_.y = (_e1498.xxxx + _e1500.yyyy).x;
            let _e1507: vec4<f32> = constant_registers[16u];
            let _e1509: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1507.xxxx < _e1509.yyyy)).x;
            let _e1515: vec4<f32> = temporary13_;
            let _e1519: vec4<f32> = constant_registers[16u];
            if all((_e1515.zzzz != _e1519.xxxx)) {
                let _e1523: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1523.yyyy).x;
                let _e1528: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1528.xxxx).x;
                let _e1533: vec4<f32> = temporary3_;
                let _e1535: vec4<f32> = temporary13_;
                temporary13_.z = (_e1533.wwww - _e1535.yyyy).x;
                let _e1542: vec4<f32> = constant_registers[16u];
                let _e1544: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1542.xxxx < _e1544.zzzz)).x;
                let _e1550: vec4<f32> = temporary3_;
                let _e1554: vec4<f32> = constant_registers[16u];
                if all((_e1550.wwww != _e1554.xxxx)) {
                    let _e1558: vec4<f32> = temporary13_;
                    temporary2_.w = _e1558.zzzz.x;
                }
            }
            let _e1562: vec4<f32> = temporary2_;
            let _e1564: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1562.wwww < _e1564.yyyy)).x;
            let _e1570: vec4<f32> = temporary8_;
            let _e1574: vec4<f32> = constant_registers[16u];
            if all((_e1570.yyyy != _e1574.xxxx)) {
                let _e1580: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1580.xxxx.x;
            }
            let _e1586: vec4<f32> = constant_registers[9u];
            temporary8_.z = _e1586.xxxx.x;
            let _e1592: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1592.wwww.x;
            let _e1596: vec4<f32> = temporary2_;
            let _e1600: vec4<f32> = constant_registers[7u];
            let _e1602: vec4<f32> = (_e1596.xyzz - _e1600.xyzz);
            temporary19_.x = _e1602.x;
            temporary19_.y = _e1602.y;
            temporary19_.z = _e1602.z;
            let _e1609: vec4<f32> = temporary19_;
            let _e1611: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1609.xyz, _e1611.xyz);
            let _e1615: vec4<f32> = temporary13_;
            let _e1617: vec4<f32> = temporary13_;
            temporary13_.z = (_e1615.xxxx * _e1617.xxxx).x;
            let _e1622: vec4<f32> = temporary19_;
            let _e1624: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1622.xyz, _e1624.xyz);
            let _e1628: vec4<f32> = temporary13_;
            let _e1630: vec4<f32> = temporary3_;
            temporary12_.x = (_e1628.zzzz - _e1630.wwww).x;
            let _e1635: vec4<f32> = temporary8_;
            let _e1637: vec4<f32> = temporary8_;
            temporary12_.y = (_e1635.zzzz * _e1637.zzzz).x;
            let _e1642: vec4<f32> = temporary12_;
            let _e1644: vec4<f32> = temporary12_;
            temporary13_.y = (_e1642.xxxx + _e1644.yyyy).x;
            let _e1651: vec4<f32> = constant_registers[16u];
            let _e1653: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1651.xxxx < _e1653.yyyy)).x;
            let _e1659: vec4<f32> = temporary13_;
            let _e1663: vec4<f32> = constant_registers[16u];
            if all((_e1659.zzzz != _e1663.xxxx)) {
                let _e1667: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1667.yyyy).x;
                let _e1672: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1672.xxxx).x;
                let _e1677: vec4<f32> = temporary3_;
                let _e1679: vec4<f32> = temporary13_;
                temporary13_.z = (_e1677.wwww - _e1679.yyyy).x;
                let _e1686: vec4<f32> = constant_registers[16u];
                let _e1688: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1686.xxxx < _e1688.zzzz)).x;
                let _e1694: vec4<f32> = temporary3_;
                let _e1698: vec4<f32> = constant_registers[16u];
                if all((_e1694.wwww != _e1698.xxxx)) {
                    let _e1702: vec4<f32> = temporary13_;
                    temporary2_.w = _e1702.zzzz.x;
                }
            }
            let _e1706: vec4<f32> = temporary2_;
            let _e1708: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1706.wwww < _e1708.yyyy)).x;
            let _e1714: vec4<f32> = temporary8_;
            let _e1718: vec4<f32> = constant_registers[16u];
            if all((_e1714.yyyy != _e1718.xxxx)) {
                let _e1724: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1724.xxxx.x;
            }
            let _e1728: vec4<f32> = temporary2_;
            let _e1729: vec4<f32> = _e1728.xyzz;
            temporary15_.x = _e1729.x;
            temporary15_.y = _e1729.y;
            temporary15_.z = _e1729.z;
            let _e1736: vec4<f32> = temporary10_;
            let _e1737: vec4<f32> = _e1736.xyzz;
            temporary17_.x = _e1737.x;
            temporary17_.y = _e1737.y;
            temporary17_.z = _e1737.z;
            let _e1746: vec4<f32> = constant_registers[10u];
            let _e1747: vec4<f32> = _e1746.xyzz;
            temporary18_.x = _e1747.x;
            temporary18_.y = _e1747.y;
            temporary18_.z = _e1747.z;
            let _e1756: vec4<f32> = constant_registers[12u];
            temporary8_.z = _e1756.xxxx.x;
            let _e1762: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1762.wwww.x;
            let _e1766: vec4<f32> = temporary15_;
            let _e1768: vec4<f32> = temporary18_;
            let _e1770: vec4<f32> = (_e1766.xyzz - _e1768.xyzz);
            temporary19_.x = _e1770.x;
            temporary19_.y = _e1770.y;
            temporary19_.z = _e1770.z;
            let _e1777: vec4<f32> = temporary19_;
            let _e1779: vec4<f32> = temporary17_;
            temporary13_.x = dot(_e1777.xyz, _e1779.xyz);
            let _e1783: vec4<f32> = temporary13_;
            let _e1785: vec4<f32> = temporary13_;
            temporary13_.z = (_e1783.xxxx * _e1785.xxxx).x;
            let _e1790: vec4<f32> = temporary19_;
            let _e1792: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1790.xyz, _e1792.xyz);
            let _e1796: vec4<f32> = temporary13_;
            let _e1798: vec4<f32> = temporary3_;
            temporary12_.x = (_e1796.zzzz - _e1798.wwww).x;
            let _e1803: vec4<f32> = temporary8_;
            let _e1805: vec4<f32> = temporary8_;
            temporary12_.y = (_e1803.zzzz * _e1805.zzzz).x;
            let _e1810: vec4<f32> = temporary12_;
            let _e1812: vec4<f32> = temporary12_;
            temporary12_.z = (_e1810.xxxx + _e1812.yyyy).x;
            let _e1817: vec4<f32> = temporary12_;
            temporary13_.y = _e1817.zzzz.x;
            let _e1823: vec4<f32> = constant_registers[16u];
            let _e1825: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1823.xxxx < _e1825.yyyy)).x;
            let _e1831: vec4<f32> = temporary13_;
            let _e1835: vec4<f32> = constant_registers[16u];
            if all((_e1831.zzzz != _e1835.xxxx)) {
                let _e1839: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1839.yyyy).x;
                let _e1844: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1844.xxxx).x;
                let _e1849: vec4<f32> = temporary3_;
                let _e1851: vec4<f32> = temporary13_;
                temporary12_.x = (_e1849.wwww - _e1851.yyyy).x;
                let _e1856: vec4<f32> = temporary12_;
                temporary13_.z = _e1856.xxxx.x;
                let _e1862: vec4<f32> = constant_registers[16u];
                let _e1864: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1862.xxxx < _e1864.zzzz)).x;
                let _e1870: vec4<f32> = temporary3_;
                let _e1874: vec4<f32> = constant_registers[16u];
                if all((_e1870.wwww != _e1874.xxxx)) {
                    let _e1878: vec4<f32> = temporary13_;
                    temporary2_.w = _e1878.zzzz.x;
                }
            }
            let _e1882: vec4<f32> = temporary2_;
            temporary4_.y = _e1882.wwww.x;
            let _e1886: vec4<f32> = temporary4_;
            let _e1888: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1886.yyyy < _e1888.yyyy)).x;
            let _e1894: vec4<f32> = temporary8_;
            let _e1898: vec4<f32> = constant_registers[16u];
            if all((_e1894.yyyy != _e1898.xxxx)) {
                let _e1904: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1904.xxxx.x;
            }
            let _e1908: vec4<f32> = temporary6_;
            temporary8_.y = saturate(_e1908.yyyy).x;
            let _e1913: vec4<f32> = temporary8_;
            let _e1917: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1913.yyyy * _e1917.xxxx).x;
            let _e1922: vec4<f32> = temporary8_;
            let _e1924: vec4<f32> = temporary8_;
            temporary8_.x = (_e1922.xxxx + _e1924.zzzz).x;
            let _e1929: vec4<f32> = temporary8_;
            let _e1933: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1929.xxxx * _e1933.yyyy).x;
            let _e1940: vec4<f32> = constant_registers[19u];
            let _e1942: vec4<f32> = temporary8_;
            temporary2_.w = (_e1940.zzzz + _e1942.zzzz).x;
            let _e1947: vec4<f32> = temporary2_;
            temporary8_.y = _e1947.wwww.x;
            let _e1951: vec4<f32> = temporary1_;
            let _e1955: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e1951.zzzz == _e1955.yyyy)).x;
            let _e1961: vec4<f32> = temporary8_;
            let _e1965: vec4<f32> = constant_registers[16u];
            if all((_e1961.zzzz != _e1965.xxxx)) {
                let _e1969: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e1969.xxxx).x;
                let _e1974: vec4<f32> = temporary2_;
                let _e1976: vec4<f32> = temporary8_;
                temporary2_.w = (_e1974.xxxx - _e1976.zzzz).x;
                let _e1981: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e1981.zzzz).x;
                let _e1986: vec4<f32> = temporary2_;
                let _e1988: vec4<f32> = temporary15_;
                temporary15_.y = (_e1986.zzzz - _e1988.xxxx).x;
                let _e1993: vec4<f32> = temporary2_;
                let _e1995: vec4<f32> = temporary15_;
                temporary15_.z = (_e1993.wwww + _e1995.yyyy).x;
                let _e2000: vec4<f32> = temporary15_;
                let _e2004: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e2000.zzzz / _e2004.xxxx).x;
                let _e2009: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e2009.xxxx).x;
                let _e2014: vec4<f32> = temporary17_;
                let _e2018: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e2014.xxxx * _e2018.xxxx).x;
                let _e2023: vec4<f32> = temporary17_;
                let _e2027: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e2023.yyyy == _e2027.yyyy)).x;
                let _e2033: vec4<f32> = temporary17_;
                let _e2037: vec4<f32> = constant_registers[16u];
                if all((_e2033.zzzz != _e2037.xxxx)) {
                    let _e2043: vec4<f32> = constant_registers[13u];
                    let _e2045: vec4<f32> = temporary8_;
                    let _e2047: vec4<f32> = (_e2043.xyzz * _e2045.yyyy);
                    temporary15_.x = _e2047.x;
                    temporary15_.y = _e2047.y;
                    temporary15_.z = _e2047.z;
                    let _e2054: vec4<f32> = temporary0_;
                    let _e2056: vec4<f32> = temporary15_;
                    let _e2058: vec4<f32> = (_e2054.xyzz + _e2056.xyzz);
                    temporary0_.x = _e2058.x;
                    temporary0_.y = _e2058.y;
                    temporary0_.z = _e2058.z;
                } else {
                    let _e2067: vec4<f32> = constant_registers[14u];
                    let _e2069: vec4<f32> = temporary8_;
                    let _e2071: vec4<f32> = (_e2067.xyzz * _e2069.yyyy);
                    temporary15_.x = _e2071.x;
                    temporary15_.y = _e2071.y;
                    temporary15_.z = _e2071.z;
                    let _e2078: vec4<f32> = temporary0_;
                    let _e2080: vec4<f32> = temporary15_;
                    let _e2082: vec4<f32> = (_e2078.xyzz + _e2080.xyzz);
                    temporary0_.x = _e2082.x;
                    temporary0_.y = _e2082.y;
                    temporary0_.z = _e2082.z;
                }
            }
            let _e2089: vec4<f32> = temporary1_;
            let _e2093: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e2089.zzzz == _e2093.xxxx)).x;
            let _e2099: vec4<f32> = temporary8_;
            let _e2103: vec4<f32> = constant_registers[16u];
            if all((_e2099.zzzz != _e2103.xxxx)) {
                let _e2107: vec4<f32> = temporary7_;
                let _e2109: vec4<f32> = temporary8_;
                let _e2111: vec4<f32> = (_e2107.xyzz * _e2109.yyyy);
                temporary15_.x = _e2111.x;
                temporary15_.y = _e2111.y;
                temporary15_.z = _e2111.z;
                let _e2118: vec4<f32> = temporary0_;
                let _e2120: vec4<f32> = temporary15_;
                let _e2122: vec4<f32> = (_e2118.xyzz + _e2120.xyzz);
                temporary0_.x = _e2122.x;
                temporary0_.y = _e2122.y;
                temporary0_.z = _e2122.z;
            }
            let _e2131: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e2131.yyyy.x;
        }
    }
    let _e2135: vec4<f32> = temporary11_;
    let _e2139: vec4<f32> = constant_registers[16u];
    if all((_e2135.xxxx != _e2139.xxxx)) {
        let _e2145: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e2145.xxxx.x;
        let _e2151: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e2151.wwww.x;
        let _e2157: vec4<f32> = constant_registers[16u];
        let _e2158: vec4<f32> = _e2157.xyxx;
        temporary3_.x = _e2158.x;
        temporary3_.y = _e2158.y;
        temporary3_.z = _e2158.z;
        let _e2165: vec4<f32> = temporary3_;
        let _e2166: vec4<f32> = _e2165.xyzz;
        temporary12_.x = _e2166.x;
        temporary12_.y = _e2166.y;
        temporary12_.z = _e2166.z;
        let _e2175: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e2175.wwww.x;
        let _e2179: vec4<f32> = temporary2_;
        let _e2183: vec4<f32> = constant_registers[16u];
        let _e2185: vec4<f32> = (_e2179.xyzz - _e2183.xxxx);
        temporary20_.x = _e2185.x;
        temporary20_.y = _e2185.y;
        temporary20_.z = _e2185.z;
        let _e2192: vec4<f32> = temporary20_;
        let _e2194: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e2192.xyz, _e2194.xyz);
        let _e2198: vec4<f32> = temporary14_;
        temporary14_.z = -(_e2198.yyyy).x;
        let _e2203: vec4<f32> = temporary9_;
        let _e2205: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e2203.xyz, _e2205.xyz);
        let _e2209: vec4<f32> = temporary14_;
        let _e2211: vec4<f32> = temporary4_;
        temporary16_.x = (_e2209.zzzz / _e2211.xxxx).x;
        let _e2216: vec4<f32> = temporary16_;
        temporary14_.x = _e2216.xxxx.x;
        let _e2222: vec4<f32> = constant_registers[16u];
        let _e2224: vec4<f32> = temporary14_;
        temporary14_.y = vec4<f32>((_e2222.xxxx < _e2224.xxxx)).x;
        let _e2230: vec4<f32> = temporary14_;
        let _e2234: vec4<f32> = constant_registers[16u];
        if all((_e2230.yyyy != _e2234.xxxx)) {
            let _e2238: vec4<f32> = temporary14_;
            temporary2_.w = _e2238.xxxx.x;
        }
        let _e2242: vec4<f32> = temporary2_;
        temporary4_.y = _e2242.wwww.x;
        let _e2246: vec4<f32> = temporary4_;
        let _e2248: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2246.yyyy < _e2248.zzzz)).x;
        let _e2254: vec4<f32> = temporary8_;
        let _e2258: vec4<f32> = constant_registers[16u];
        if all((_e2254.zzzz != _e2258.xxxx)) {
            let _e2262: vec4<f32> = temporary4_;
            temporary4_.z = _e2262.yyyy.x;
            let _e2266: vec4<f32> = temporary3_;
            let _e2267: vec4<f32> = _e2266.xyzz;
            temporary6_.x = _e2267.x;
            temporary6_.y = _e2267.y;
            temporary6_.z = _e2267.z;
            let _e2276: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e2276.yyyy.x;
        }
        let _e2280: vec4<f32> = temporary2_;
        let _e2281: vec4<f32> = _e2280.xyzz;
        temporary15_.x = _e2281.x;
        temporary15_.y = _e2281.y;
        temporary15_.z = _e2281.z;
        let _e2288: vec4<f32> = temporary9_;
        let _e2289: vec4<f32> = _e2288.xyzz;
        temporary17_.x = _e2289.x;
        temporary17_.y = _e2289.y;
        temporary17_.z = _e2289.z;
        let _e2298: vec4<f32> = constant_registers[4u];
        let _e2299: vec4<f32> = _e2298.xyzz;
        temporary18_.x = _e2299.x;
        temporary18_.y = _e2299.y;
        temporary18_.z = _e2299.z;
        let _e2308: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e2308.xxxx.x;
        let _e2312: vec4<f32> = temporary3_;
        let _e2313: vec4<f32> = _e2312.xyzz;
        temporary19_.x = _e2313.x;
        temporary19_.y = _e2313.y;
        temporary19_.z = _e2313.z;
        let _e2322: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2322.wwww.x;
        let _e2326: vec4<f32> = temporary15_;
        let _e2328: vec4<f32> = temporary18_;
        let _e2330: vec4<f32> = (_e2326.xyzz - _e2328.xyzz);
        temporary12_.x = _e2330.x;
        temporary12_.y = _e2330.y;
        temporary12_.z = _e2330.z;
        let _e2337: vec4<f32> = temporary12_;
        let _e2339: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2337.xyz, _e2339.xyz);
        let _e2343: vec4<f32> = temporary13_;
        let _e2345: vec4<f32> = temporary13_;
        temporary3_.w = (_e2343.yyyy * _e2345.yyyy).x;
        let _e2350: vec4<f32> = temporary12_;
        let _e2352: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2350.xyz, _e2352.xyz);
        let _e2356: vec4<f32> = temporary3_;
        let _e2358: vec4<f32> = temporary14_;
        temporary14_.y = (_e2356.wwww - _e2358.xxxx).x;
        let _e2363: vec4<f32> = temporary2_;
        let _e2365: vec4<f32> = temporary2_;
        temporary14_.z = (_e2363.wwww * _e2365.wwww).x;
        let _e2370: vec4<f32> = temporary14_;
        let _e2372: vec4<f32> = temporary14_;
        temporary13_.z = (_e2370.yyyy + _e2372.zzzz).x;
        let _e2379: vec4<f32> = constant_registers[16u];
        let _e2381: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2379.xxxx < _e2381.zzzz)).x;
        let _e2387: vec4<f32> = temporary3_;
        let _e2391: vec4<f32> = constant_registers[16u];
        if all((_e2387.wwww != _e2391.xxxx)) {
            let _e2395: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2395.zzzz).x;
            let _e2400: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2400.yyyy).x;
            let _e2405: vec4<f32> = temporary14_;
            let _e2407: vec4<f32> = temporary13_;
            temporary14_.y = (_e2405.xxxx - _e2407.zzzz).x;
            let _e2412: vec4<f32> = temporary14_;
            temporary3_.w = _e2412.yyyy.x;
            let _e2418: vec4<f32> = constant_registers[16u];
            let _e2420: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2418.xxxx < _e2420.wwww)).x;
            let _e2426: vec4<f32> = temporary14_;
            let _e2430: vec4<f32> = constant_registers[16u];
            if all((_e2426.xxxx != _e2430.xxxx)) {
                let _e2434: vec4<f32> = temporary3_;
                temporary13_.x = _e2434.wwww.x;
                let _e2438: vec4<f32> = temporary17_;
                let _e2440: vec4<f32> = temporary3_;
                let _e2442: vec4<f32> = (_e2438.xyzz * _e2440.wwww);
                temporary14_.x = _e2442.x;
                temporary14_.y = _e2442.y;
                temporary14_.z = _e2442.z;
                let _e2449: vec4<f32> = temporary15_;
                let _e2451: vec4<f32> = temporary14_;
                let _e2453: vec4<f32> = (_e2449.xyzz + _e2451.xyzz);
                temporary20_.x = _e2453.x;
                temporary20_.y = _e2453.y;
                temporary20_.z = _e2453.z;
                let _e2460: vec4<f32> = temporary20_;
                let _e2462: vec4<f32> = temporary18_;
                let _e2464: vec4<f32> = (_e2460.xyzz - _e2462.xyzz);
                temporary16_.x = _e2464.x;
                temporary16_.y = _e2464.y;
                temporary16_.z = _e2464.z;
                let _e2471: vec4<f32> = temporary16_;
                let _e2473: vec3<f32> = normalize(_e2471.xyz);
                temporary19_.x = _e2473.x;
                temporary19_.y = _e2473.y;
                temporary19_.z = _e2473.z;
            }
        }
        let _e2480: vec4<f32> = temporary13_;
        temporary4_.y = _e2480.xxxx.x;
        let _e2484: vec4<f32> = temporary19_;
        let _e2485: vec4<f32> = _e2484.xyzz;
        temporary3_.x = _e2485.x;
        temporary3_.y = _e2485.y;
        temporary3_.z = _e2485.z;
        let _e2492: vec4<f32> = temporary4_;
        let _e2494: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2492.yyyy < _e2494.zzzz)).x;
        let _e2500: vec4<f32> = temporary8_;
        let _e2504: vec4<f32> = constant_registers[16u];
        if all((_e2500.zzzz != _e2504.xxxx)) {
            let _e2508: vec4<f32> = temporary4_;
            temporary4_.z = _e2508.yyyy.x;
            let _e2512: vec4<f32> = temporary3_;
            let _e2513: vec4<f32> = _e2512.xyzz;
            temporary6_.x = _e2513.x;
            temporary6_.y = _e2513.y;
            temporary6_.z = _e2513.z;
            let _e2522: vec4<f32> = constant_registers[5u];
            let _e2523: vec4<f32> = _e2522.xyzz;
            temporary7_.x = _e2523.x;
            temporary7_.y = _e2523.y;
            temporary7_.z = _e2523.z;
            let _e2532: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2532.xxxx.x;
        }
        let _e2536: vec4<f32> = temporary2_;
        let _e2537: vec4<f32> = _e2536.xyzz;
        temporary15_.x = _e2537.x;
        temporary15_.y = _e2537.y;
        temporary15_.z = _e2537.z;
        let _e2544: vec4<f32> = temporary9_;
        let _e2545: vec4<f32> = _e2544.xyzz;
        temporary17_.x = _e2545.x;
        temporary17_.y = _e2545.y;
        temporary17_.z = _e2545.z;
        let _e2554: vec4<f32> = constant_registers[7u];
        let _e2555: vec4<f32> = _e2554.xyzz;
        temporary18_.x = _e2555.x;
        temporary18_.y = _e2555.y;
        temporary18_.z = _e2555.z;
        let _e2564: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e2564.xxxx.x;
        let _e2568: vec4<f32> = temporary3_;
        let _e2569: vec4<f32> = _e2568.xyzz;
        temporary19_.x = _e2569.x;
        temporary19_.y = _e2569.y;
        temporary19_.z = _e2569.z;
        let _e2578: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2578.wwww.x;
        let _e2582: vec4<f32> = temporary15_;
        let _e2584: vec4<f32> = temporary18_;
        let _e2586: vec4<f32> = (_e2582.xyzz - _e2584.xyzz);
        temporary12_.x = _e2586.x;
        temporary12_.y = _e2586.y;
        temporary12_.z = _e2586.z;
        let _e2593: vec4<f32> = temporary12_;
        let _e2595: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2593.xyz, _e2595.xyz);
        let _e2599: vec4<f32> = temporary13_;
        let _e2601: vec4<f32> = temporary13_;
        temporary3_.w = (_e2599.yyyy * _e2601.yyyy).x;
        let _e2606: vec4<f32> = temporary12_;
        let _e2608: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2606.xyz, _e2608.xyz);
        let _e2612: vec4<f32> = temporary3_;
        let _e2614: vec4<f32> = temporary14_;
        temporary14_.y = (_e2612.wwww - _e2614.xxxx).x;
        let _e2619: vec4<f32> = temporary2_;
        let _e2621: vec4<f32> = temporary2_;
        temporary14_.z = (_e2619.wwww * _e2621.wwww).x;
        let _e2626: vec4<f32> = temporary14_;
        let _e2628: vec4<f32> = temporary14_;
        temporary13_.z = (_e2626.yyyy + _e2628.zzzz).x;
        let _e2635: vec4<f32> = constant_registers[16u];
        let _e2637: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2635.xxxx < _e2637.zzzz)).x;
        let _e2643: vec4<f32> = temporary3_;
        let _e2647: vec4<f32> = constant_registers[16u];
        if all((_e2643.wwww != _e2647.xxxx)) {
            let _e2651: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2651.zzzz).x;
            let _e2656: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2656.yyyy).x;
            let _e2661: vec4<f32> = temporary14_;
            let _e2663: vec4<f32> = temporary13_;
            temporary14_.y = (_e2661.xxxx - _e2663.zzzz).x;
            let _e2668: vec4<f32> = temporary14_;
            temporary3_.w = _e2668.yyyy.x;
            let _e2674: vec4<f32> = constant_registers[16u];
            let _e2676: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2674.xxxx < _e2676.wwww)).x;
            let _e2682: vec4<f32> = temporary14_;
            let _e2686: vec4<f32> = constant_registers[16u];
            if all((_e2682.xxxx != _e2686.xxxx)) {
                let _e2690: vec4<f32> = temporary3_;
                temporary13_.x = _e2690.wwww.x;
                let _e2694: vec4<f32> = temporary17_;
                let _e2696: vec4<f32> = temporary3_;
                let _e2698: vec4<f32> = (_e2694.xyzz * _e2696.wwww);
                temporary14_.x = _e2698.x;
                temporary14_.y = _e2698.y;
                temporary14_.z = _e2698.z;
                let _e2705: vec4<f32> = temporary15_;
                let _e2707: vec4<f32> = temporary14_;
                let _e2709: vec4<f32> = (_e2705.xyzz + _e2707.xyzz);
                temporary20_.x = _e2709.x;
                temporary20_.y = _e2709.y;
                temporary20_.z = _e2709.z;
                let _e2716: vec4<f32> = temporary20_;
                let _e2718: vec4<f32> = temporary18_;
                let _e2720: vec4<f32> = (_e2716.xyzz - _e2718.xyzz);
                temporary16_.x = _e2720.x;
                temporary16_.y = _e2720.y;
                temporary16_.z = _e2720.z;
                let _e2727: vec4<f32> = temporary16_;
                let _e2729: vec3<f32> = normalize(_e2727.xyz);
                temporary19_.x = _e2729.x;
                temporary19_.y = _e2729.y;
                temporary19_.z = _e2729.z;
            }
        }
        let _e2736: vec4<f32> = temporary13_;
        temporary4_.y = _e2736.xxxx.x;
        let _e2740: vec4<f32> = temporary19_;
        let _e2741: vec4<f32> = _e2740.xyzz;
        temporary3_.x = _e2741.x;
        temporary3_.y = _e2741.y;
        temporary3_.z = _e2741.z;
        let _e2748: vec4<f32> = temporary4_;
        let _e2750: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2748.yyyy < _e2750.zzzz)).x;
        let _e2756: vec4<f32> = temporary8_;
        let _e2760: vec4<f32> = constant_registers[16u];
        if all((_e2756.zzzz != _e2760.xxxx)) {
            let _e2764: vec4<f32> = temporary4_;
            temporary4_.z = _e2764.yyyy.x;
            let _e2768: vec4<f32> = temporary3_;
            let _e2769: vec4<f32> = _e2768.xyzz;
            temporary6_.x = _e2769.x;
            temporary6_.y = _e2769.y;
            temporary6_.z = _e2769.z;
            let _e2778: vec4<f32> = constant_registers[8u];
            let _e2779: vec4<f32> = _e2778.xyzz;
            temporary7_.x = _e2779.x;
            temporary7_.y = _e2779.y;
            temporary7_.z = _e2779.z;
            let _e2788: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2788.xxxx.x;
        }
        let _e2792: vec4<f32> = temporary2_;
        let _e2793: vec4<f32> = _e2792.xyzz;
        temporary15_.x = _e2793.x;
        temporary15_.y = _e2793.y;
        temporary15_.z = _e2793.z;
        let _e2800: vec4<f32> = temporary9_;
        let _e2801: vec4<f32> = _e2800.xyzz;
        temporary17_.x = _e2801.x;
        temporary17_.y = _e2801.y;
        temporary17_.z = _e2801.z;
        let _e2810: vec4<f32> = constant_registers[10u];
        let _e2811: vec4<f32> = _e2810.xyzz;
        temporary18_.x = _e2811.x;
        temporary18_.y = _e2811.y;
        temporary18_.z = _e2811.z;
        let _e2820: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e2820.xxxx.x;
        let _e2824: vec4<f32> = temporary3_;
        let _e2825: vec4<f32> = _e2824.xyzz;
        temporary19_.x = _e2825.x;
        temporary19_.y = _e2825.y;
        temporary19_.z = _e2825.z;
        let _e2834: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2834.wwww.x;
        let _e2838: vec4<f32> = temporary15_;
        let _e2840: vec4<f32> = temporary18_;
        let _e2842: vec4<f32> = (_e2838.xyzz - _e2840.xyzz);
        temporary12_.x = _e2842.x;
        temporary12_.y = _e2842.y;
        temporary12_.z = _e2842.z;
        let _e2849: vec4<f32> = temporary12_;
        let _e2851: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2849.xyz, _e2851.xyz);
        let _e2855: vec4<f32> = temporary13_;
        let _e2857: vec4<f32> = temporary13_;
        temporary3_.w = (_e2855.yyyy * _e2857.yyyy).x;
        let _e2862: vec4<f32> = temporary12_;
        let _e2864: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2862.xyz, _e2864.xyz);
        let _e2868: vec4<f32> = temporary3_;
        let _e2870: vec4<f32> = temporary14_;
        temporary14_.y = (_e2868.wwww - _e2870.xxxx).x;
        let _e2875: vec4<f32> = temporary2_;
        let _e2877: vec4<f32> = temporary2_;
        temporary14_.z = (_e2875.wwww * _e2877.wwww).x;
        let _e2882: vec4<f32> = temporary14_;
        let _e2884: vec4<f32> = temporary14_;
        temporary4_.x = (_e2882.yyyy + _e2884.zzzz).x;
        let _e2889: vec4<f32> = temporary4_;
        temporary13_.z = _e2889.xxxx.x;
        let _e2895: vec4<f32> = constant_registers[16u];
        let _e2897: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2895.xxxx < _e2897.zzzz)).x;
        let _e2903: vec4<f32> = temporary3_;
        let _e2907: vec4<f32> = constant_registers[16u];
        if all((_e2903.wwww != _e2907.xxxx)) {
            let _e2911: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2911.zzzz).x;
            let _e2916: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2916.yyyy).x;
            let _e2921: vec4<f32> = temporary14_;
            let _e2923: vec4<f32> = temporary13_;
            temporary14_.y = (_e2921.xxxx - _e2923.zzzz).x;
            let _e2928: vec4<f32> = temporary14_;
            temporary3_.w = _e2928.yyyy.x;
            let _e2934: vec4<f32> = constant_registers[16u];
            let _e2936: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2934.xxxx < _e2936.wwww)).x;
            let _e2942: vec4<f32> = temporary14_;
            let _e2946: vec4<f32> = constant_registers[16u];
            if all((_e2942.xxxx != _e2946.xxxx)) {
                let _e2950: vec4<f32> = temporary3_;
                temporary13_.x = _e2950.wwww.x;
                let _e2954: vec4<f32> = temporary17_;
                let _e2956: vec4<f32> = temporary3_;
                let _e2958: vec4<f32> = (_e2954.xyzz * _e2956.wwww);
                temporary14_.x = _e2958.x;
                temporary14_.y = _e2958.y;
                temporary14_.z = _e2958.z;
                let _e2965: vec4<f32> = temporary15_;
                let _e2967: vec4<f32> = temporary14_;
                let _e2969: vec4<f32> = (_e2965.xyzz + _e2967.xyzz);
                temporary20_.x = _e2969.x;
                temporary20_.y = _e2969.y;
                temporary20_.z = _e2969.z;
                let _e2976: vec4<f32> = temporary20_;
                let _e2978: vec4<f32> = temporary18_;
                let _e2980: vec4<f32> = (_e2976.xyzz - _e2978.xyzz);
                temporary16_.x = _e2980.x;
                temporary16_.y = _e2980.y;
                temporary16_.z = _e2980.z;
                let _e2987: vec4<f32> = temporary16_;
                let _e2989: vec3<f32> = normalize(_e2987.xyz);
                temporary19_.x = _e2989.x;
                temporary19_.y = _e2989.y;
                temporary19_.z = _e2989.z;
            }
        }
        let _e2996: vec4<f32> = temporary13_;
        temporary4_.y = _e2996.xxxx.x;
        let _e3000: vec4<f32> = temporary19_;
        let _e3001: vec4<f32> = _e3000.xyzz;
        temporary3_.x = _e3001.x;
        temporary3_.y = _e3001.y;
        temporary3_.z = _e3001.z;
        let _e3008: vec4<f32> = temporary4_;
        let _e3010: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e3008.yyyy < _e3010.zzzz)).x;
        let _e3016: vec4<f32> = temporary8_;
        let _e3020: vec4<f32> = constant_registers[16u];
        if all((_e3016.zzzz != _e3020.xxxx)) {
            let _e3024: vec4<f32> = temporary4_;
            temporary4_.z = _e3024.yyyy.x;
            let _e3028: vec4<f32> = temporary3_;
            let _e3029: vec4<f32> = _e3028.xyzz;
            temporary6_.x = _e3029.x;
            temporary6_.y = _e3029.y;
            temporary6_.z = _e3029.z;
            let _e3038: vec4<f32> = constant_registers[11u];
            let _e3039: vec4<f32> = _e3038.xyzz;
            temporary7_.x = _e3039.x;
            temporary7_.y = _e3039.y;
            temporary7_.z = _e3039.z;
            let _e3048: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e3048.xxxx.x;
        }
        let _e3052: vec4<f32> = temporary11_;
        let _e3056: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e3052.yyyy + _e3056.yyyy).x;
        let _e3061: vec4<f32> = temporary1_;
        let _e3065: vec4<f32> = constant_registers[16u];
        temporary8_.z = vec4<f32>((_e3061.zzzz == _e3065.xxxx)).x;
        let _e3071: vec4<f32> = temporary8_;
        let _e3075: vec4<f32> = constant_registers[16u];
        if all((_e3071.zzzz != _e3075.xxxx)) {
            let _e3081: vec4<f32> = constant_registers[16u];
            let _e3082: vec4<f32> = _e3081.xyyy;
            temporary11_.x = _e3082.x;
            temporary11_.z = _e3082.z;
        } else {
            let _e3087: vec4<f32> = temporary9_;
            let _e3089: vec4<f32> = temporary4_;
            let _e3091: vec4<f32> = (_e3087.xyzz * _e3089.zzzz);
            temporary15_.x = _e3091.x;
            temporary15_.y = _e3091.y;
            temporary15_.z = _e3091.z;
            let _e3098: vec4<f32> = temporary2_;
            let _e3100: vec4<f32> = temporary15_;
            let _e3102: vec4<f32> = (_e3098.xyzz + _e3100.xyzz);
            temporary2_.x = _e3102.x;
            temporary2_.y = _e3102.y;
            temporary2_.z = _e3102.z;
            let _e3109: vec4<f32> = temporary9_;
            let _e3111: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e3109.xyz, _e3111.xyz);
            let _e3115: vec4<f32> = temporary8_;
            let _e3119: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e3115.zzzz * _e3119.xxxx).x;
            let _e3124: vec4<f32> = temporary2_;
            let _e3126: vec4<f32> = temporary6_;
            let _e3128: vec4<f32> = (_e3124.wwww * _e3126.xyzz);
            temporary15_.x = _e3128.x;
            temporary15_.y = _e3128.y;
            temporary15_.z = _e3128.z;
            let _e3135: vec4<f32> = temporary9_;
            let _e3137: vec4<f32> = temporary15_;
            let _e3139: vec4<f32> = (_e3135.xyzz - _e3137.xyzz);
            temporary9_.x = _e3139.x;
            temporary9_.y = _e3139.y;
            temporary9_.z = _e3139.z;
            let _e3146: vec4<f32> = temporary9_;
            let _e3150: vec4<f32> = constant_registers[18u];
            let _e3152: vec4<f32> = (_e3146.xyzz * _e3150.yyyy);
            temporary15_.x = _e3152.x;
            temporary15_.y = _e3152.y;
            temporary15_.z = _e3152.z;
            let _e3159: vec4<f32> = temporary2_;
            let _e3161: vec4<f32> = temporary15_;
            let _e3163: vec4<f32> = (_e3159.xyzz + _e3161.xyzz);
            temporary2_.x = _e3163.x;
            temporary2_.y = _e3163.y;
            temporary2_.z = _e3163.z;
            let _e3172: vec4<f32> = constant_registers[15u];
            let _e3174: vec4<f32> = temporary2_;
            let _e3176: vec4<f32> = (_e3172.xyzz - _e3174.xyzz);
            temporary5_.x = _e3176.x;
            temporary5_.y = _e3176.y;
            temporary5_.z = _e3176.z;
            let _e3183: vec4<f32> = temporary5_;
            let _e3185: vec3<f32> = normalize(_e3183.xyz);
            temporary10_.x = _e3185.x;
            temporary10_.y = _e3185.y;
            temporary10_.z = _e3185.z;
            let _e3192: vec4<f32> = temporary5_;
            let _e3194: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e3192.xyz, _e3194.xyz);
            let _e3198: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e3198.zzzz).x;
            let _e3203: vec4<f32> = temporary6_;
            let _e3205: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e3203.xyz, _e3205.xyz);
            let _e3209: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e3209.zzzz).x;
            let _e3214: vec4<f32> = temporary1_;
            let _e3216: vec4<f32> = temporary1_;
            temporary15_.x = (_e3214.yyyy * _e3216.yyyy).x;
            let _e3221: vec4<f32> = temporary15_;
            let _e3225: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e3221.xxxx * _e3225.zzzz).x;
            let _e3232: vec4<f32> = constant_registers[18u];
            let _e3234: vec4<f32> = temporary15_;
            temporary15_.z = (_e3232.wwww + _e3234.yyyy).x;
            let _e3239: vec4<f32> = temporary2_;
            let _e3241: vec4<f32> = temporary15_;
            temporary1_.x = (_e3239.wwww / _e3241.zzzz).x;
            let _e3246: vec4<f32> = temporary1_;
            temporary8_.x = _e3246.xxxx.x;
            let _e3252: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e3252.xxxx.x;
            let _e3258: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3258.wwww.x;
            let _e3262: vec4<f32> = temporary2_;
            let _e3266: vec4<f32> = constant_registers[4u];
            let _e3268: vec4<f32> = (_e3262.xyzz - _e3266.xyzz);
            temporary13_.x = _e3268.x;
            temporary13_.y = _e3268.y;
            temporary13_.z = _e3268.z;
            let _e3275: vec4<f32> = temporary13_;
            let _e3277: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3275.xyz, _e3277.xyz);
            let _e3281: vec4<f32> = temporary19_;
            let _e3283: vec4<f32> = temporary19_;
            temporary1_.w = (_e3281.yyyy * _e3283.yyyy).x;
            let _e3288: vec4<f32> = temporary13_;
            let _e3290: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3288.xyz, _e3290.xyz);
            let _e3294: vec4<f32> = temporary1_;
            let _e3296: vec4<f32> = temporary12_;
            temporary12_.y = (_e3294.wwww - _e3296.xxxx).x;
            let _e3301: vec4<f32> = temporary2_;
            let _e3303: vec4<f32> = temporary2_;
            temporary12_.z = (_e3301.wwww * _e3303.wwww).x;
            let _e3308: vec4<f32> = temporary12_;
            let _e3310: vec4<f32> = temporary12_;
            temporary19_.z = (_e3308.yyyy + _e3310.zzzz).x;
            let _e3317: vec4<f32> = constant_registers[16u];
            let _e3319: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3317.xxxx < _e3319.zzzz)).x;
            let _e3325: vec4<f32> = temporary1_;
            let _e3329: vec4<f32> = constant_registers[16u];
            if all((_e3325.wwww != _e3329.xxxx)) {
                let _e3333: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3333.zzzz).x;
                let _e3338: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3338.yyyy).x;
                let _e3343: vec4<f32> = temporary12_;
                let _e3345: vec4<f32> = temporary19_;
                temporary1_.w = (_e3343.xxxx - _e3345.zzzz).x;
                let _e3352: vec4<f32> = constant_registers[16u];
                let _e3354: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3352.xxxx < _e3354.wwww)).x;
                let _e3360: vec4<f32> = temporary12_;
                let _e3364: vec4<f32> = constant_registers[16u];
                if all((_e3360.xxxx != _e3364.xxxx)) {
                    let _e3368: vec4<f32> = temporary1_;
                    temporary19_.x = _e3368.wwww.x;
                }
            }
            let _e3372: vec4<f32> = temporary19_;
            let _e3374: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3372.xxxx < _e3374.yyyy)).x;
            let _e3380: vec4<f32> = temporary8_;
            let _e3384: vec4<f32> = constant_registers[16u];
            if all((_e3380.zzzz != _e3384.xxxx)) {
                let _e3390: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3390.xxxx.x;
            }
            let _e3396: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e3396.xxxx.x;
            let _e3402: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3402.wwww.x;
            let _e3406: vec4<f32> = temporary2_;
            let _e3410: vec4<f32> = constant_registers[7u];
            let _e3412: vec4<f32> = (_e3406.xyzz - _e3410.xyzz);
            temporary13_.x = _e3412.x;
            temporary13_.y = _e3412.y;
            temporary13_.z = _e3412.z;
            let _e3419: vec4<f32> = temporary13_;
            let _e3421: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3419.xyz, _e3421.xyz);
            let _e3425: vec4<f32> = temporary19_;
            let _e3427: vec4<f32> = temporary19_;
            temporary1_.w = (_e3425.yyyy * _e3427.yyyy).x;
            let _e3432: vec4<f32> = temporary13_;
            let _e3434: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3432.xyz, _e3434.xyz);
            let _e3438: vec4<f32> = temporary1_;
            let _e3440: vec4<f32> = temporary12_;
            temporary12_.y = (_e3438.wwww - _e3440.xxxx).x;
            let _e3445: vec4<f32> = temporary2_;
            let _e3447: vec4<f32> = temporary2_;
            temporary12_.z = (_e3445.wwww * _e3447.wwww).x;
            let _e3452: vec4<f32> = temporary12_;
            let _e3454: vec4<f32> = temporary12_;
            temporary19_.z = (_e3452.yyyy + _e3454.zzzz).x;
            let _e3461: vec4<f32> = constant_registers[16u];
            let _e3463: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3461.xxxx < _e3463.zzzz)).x;
            let _e3469: vec4<f32> = temporary1_;
            let _e3473: vec4<f32> = constant_registers[16u];
            if all((_e3469.wwww != _e3473.xxxx)) {
                let _e3477: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3477.zzzz).x;
                let _e3482: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3482.yyyy).x;
                let _e3487: vec4<f32> = temporary12_;
                let _e3489: vec4<f32> = temporary19_;
                temporary1_.w = (_e3487.xxxx - _e3489.zzzz).x;
                let _e3496: vec4<f32> = constant_registers[16u];
                let _e3498: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3496.xxxx < _e3498.wwww)).x;
                let _e3504: vec4<f32> = temporary12_;
                let _e3508: vec4<f32> = constant_registers[16u];
                if all((_e3504.xxxx != _e3508.xxxx)) {
                    let _e3512: vec4<f32> = temporary1_;
                    temporary19_.x = _e3512.wwww.x;
                }
            }
            let _e3516: vec4<f32> = temporary19_;
            let _e3518: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3516.xxxx < _e3518.yyyy)).x;
            let _e3524: vec4<f32> = temporary8_;
            let _e3528: vec4<f32> = constant_registers[16u];
            if all((_e3524.zzzz != _e3528.xxxx)) {
                let _e3534: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3534.xxxx.x;
            }
            let _e3538: vec4<f32> = temporary2_;
            let _e3539: vec4<f32> = _e3538.xyzz;
            temporary15_.x = _e3539.x;
            temporary15_.y = _e3539.y;
            temporary15_.z = _e3539.z;
            let _e3546: vec4<f32> = temporary10_;
            let _e3547: vec4<f32> = _e3546.xyzz;
            temporary17_.x = _e3547.x;
            temporary17_.y = _e3547.y;
            temporary17_.z = _e3547.z;
            let _e3556: vec4<f32> = constant_registers[10u];
            let _e3557: vec4<f32> = _e3556.xyzz;
            temporary18_.x = _e3557.x;
            temporary18_.y = _e3557.y;
            temporary18_.z = _e3557.z;
            let _e3566: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e3566.xxxx.x;
            let _e3572: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3572.wwww.x;
            let _e3576: vec4<f32> = temporary15_;
            let _e3578: vec4<f32> = temporary18_;
            let _e3580: vec4<f32> = (_e3576.xyzz - _e3578.xyzz);
            temporary13_.x = _e3580.x;
            temporary13_.y = _e3580.y;
            temporary13_.z = _e3580.z;
            let _e3587: vec4<f32> = temporary13_;
            let _e3589: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e3587.xyz, _e3589.xyz);
            let _e3593: vec4<f32> = temporary19_;
            let _e3595: vec4<f32> = temporary19_;
            temporary1_.w = (_e3593.yyyy * _e3595.yyyy).x;
            let _e3600: vec4<f32> = temporary13_;
            let _e3602: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3600.xyz, _e3602.xyz);
            let _e3606: vec4<f32> = temporary1_;
            let _e3608: vec4<f32> = temporary12_;
            temporary12_.y = (_e3606.wwww - _e3608.xxxx).x;
            let _e3613: vec4<f32> = temporary2_;
            let _e3615: vec4<f32> = temporary2_;
            temporary12_.z = (_e3613.wwww * _e3615.wwww).x;
            let _e3620: vec4<f32> = temporary12_;
            let _e3622: vec4<f32> = temporary12_;
            temporary19_.z = (_e3620.yyyy + _e3622.zzzz).x;
            let _e3629: vec4<f32> = constant_registers[16u];
            let _e3631: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3629.xxxx < _e3631.zzzz)).x;
            let _e3637: vec4<f32> = temporary1_;
            let _e3641: vec4<f32> = constant_registers[16u];
            if all((_e3637.wwww != _e3641.xxxx)) {
                let _e3645: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3645.zzzz).x;
                let _e3650: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3650.yyyy).x;
                let _e3655: vec4<f32> = temporary12_;
                let _e3657: vec4<f32> = temporary19_;
                temporary12_.y = (_e3655.xxxx - _e3657.zzzz).x;
                let _e3662: vec4<f32> = temporary12_;
                temporary1_.w = _e3662.yyyy.x;
                let _e3668: vec4<f32> = constant_registers[16u];
                let _e3670: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3668.xxxx < _e3670.wwww)).x;
                let _e3676: vec4<f32> = temporary12_;
                let _e3680: vec4<f32> = constant_registers[16u];
                if all((_e3676.xxxx != _e3680.xxxx)) {
                    let _e3684: vec4<f32> = temporary1_;
                    temporary19_.x = _e3684.wwww.x;
                }
            }
            let _e3688: vec4<f32> = temporary19_;
            temporary4_.y = _e3688.xxxx.x;
            let _e3692: vec4<f32> = temporary4_;
            let _e3694: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3692.yyyy < _e3694.yyyy)).x;
            let _e3700: vec4<f32> = temporary8_;
            let _e3704: vec4<f32> = constant_registers[16u];
            if all((_e3700.zzzz != _e3704.xxxx)) {
                let _e3710: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3710.xxxx.x;
            }
            let _e3714: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e3714.yyyy).x;
            let _e3719: vec4<f32> = temporary8_;
            let _e3723: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e3719.zzzz * _e3723.xxxx).x;
            let _e3728: vec4<f32> = temporary8_;
            let _e3730: vec4<f32> = temporary2_;
            temporary8_.x = (_e3728.xxxx + _e3730.wwww).x;
            let _e3735: vec4<f32> = temporary8_;
            let _e3739: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e3735.xxxx * _e3739.yyyy).x;
            let _e3746: vec4<f32> = constant_registers[19u];
            let _e3748: vec4<f32> = temporary8_;
            temporary2_.w = (_e3746.zzzz + _e3748.zzzz).x;
            let _e3753: vec4<f32> = temporary2_;
            temporary8_.y = _e3753.wwww.x;
            let _e3757: vec4<f32> = temporary1_;
            let _e3761: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e3757.zzzz == _e3761.yyyy)).x;
            let _e3767: vec4<f32> = temporary8_;
            let _e3771: vec4<f32> = constant_registers[16u];
            if all((_e3767.zzzz != _e3771.xxxx)) {
                let _e3775: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e3775.xxxx).x;
                let _e3780: vec4<f32> = temporary2_;
                let _e3782: vec4<f32> = temporary8_;
                temporary2_.w = (_e3780.xxxx - _e3782.zzzz).x;
                let _e3787: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e3787.zzzz).x;
                let _e3792: vec4<f32> = temporary2_;
                let _e3794: vec4<f32> = temporary15_;
                temporary15_.y = (_e3792.zzzz - _e3794.xxxx).x;
                let _e3799: vec4<f32> = temporary2_;
                let _e3801: vec4<f32> = temporary15_;
                temporary15_.z = (_e3799.wwww + _e3801.yyyy).x;
                let _e3806: vec4<f32> = temporary15_;
                let _e3810: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e3806.zzzz / _e3810.xxxx).x;
                let _e3815: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e3815.xxxx).x;
                let _e3820: vec4<f32> = temporary17_;
                let _e3824: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e3820.xxxx * _e3824.xxxx).x;
                let _e3829: vec4<f32> = temporary17_;
                let _e3833: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e3829.yyyy == _e3833.yyyy)).x;
                let _e3839: vec4<f32> = temporary17_;
                let _e3843: vec4<f32> = constant_registers[16u];
                if all((_e3839.zzzz != _e3843.xxxx)) {
                    let _e3849: vec4<f32> = constant_registers[13u];
                    let _e3851: vec4<f32> = temporary8_;
                    let _e3853: vec4<f32> = (_e3849.xyzz * _e3851.yyyy);
                    temporary15_.x = _e3853.x;
                    temporary15_.y = _e3853.y;
                    temporary15_.z = _e3853.z;
                    let _e3860: vec4<f32> = temporary0_;
                    let _e3862: vec4<f32> = temporary15_;
                    let _e3864: vec4<f32> = (_e3860.xyzz + _e3862.xyzz);
                    temporary0_.x = _e3864.x;
                    temporary0_.y = _e3864.y;
                    temporary0_.z = _e3864.z;
                } else {
                    let _e3873: vec4<f32> = constant_registers[14u];
                    let _e3875: vec4<f32> = temporary8_;
                    let _e3877: vec4<f32> = (_e3873.xyzz * _e3875.yyyy);
                    temporary15_.x = _e3877.x;
                    temporary15_.y = _e3877.y;
                    temporary15_.z = _e3877.z;
                    let _e3884: vec4<f32> = temporary0_;
                    let _e3886: vec4<f32> = temporary15_;
                    let _e3888: vec4<f32> = (_e3884.xyzz + _e3886.xyzz);
                    temporary0_.x = _e3888.x;
                    temporary0_.y = _e3888.y;
                    temporary0_.z = _e3888.z;
                }
            }
            let _e3895: vec4<f32> = temporary1_;
            let _e3899: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e3895.zzzz == _e3899.xxxx)).x;
            let _e3905: vec4<f32> = temporary8_;
            let _e3909: vec4<f32> = constant_registers[16u];
            if all((_e3905.zzzz != _e3909.xxxx)) {
                let _e3913: vec4<f32> = temporary7_;
                let _e3915: vec4<f32> = temporary8_;
                let _e3917: vec4<f32> = (_e3913.xyzz * _e3915.yyyy);
                temporary15_.x = _e3917.x;
                temporary15_.y = _e3917.y;
                temporary15_.z = _e3917.z;
                let _e3924: vec4<f32> = temporary0_;
                let _e3926: vec4<f32> = temporary15_;
                let _e3928: vec4<f32> = (_e3924.xyzz + _e3926.xyzz);
                temporary0_.x = _e3928.x;
                temporary0_.y = _e3928.y;
                temporary0_.z = _e3928.z;
            }
            let _e3937: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e3937.yyyy.x;
        }
    }
    let _e3941: vec4<f32> = temporary11_;
    let _e3945: vec4<f32> = constant_registers[16u];
    if all((_e3941.xxxx != _e3945.xxxx)) {
        let _e3951: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e3951.xxxx.x;
        let _e3957: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e3957.wwww.x;
        let _e3963: vec4<f32> = constant_registers[16u];
        let _e3964: vec4<f32> = _e3963.xyxx;
        temporary3_.x = _e3964.x;
        temporary3_.y = _e3964.y;
        temporary3_.z = _e3964.z;
        let _e3971: vec4<f32> = temporary3_;
        let _e3972: vec4<f32> = _e3971.xyzz;
        temporary12_.x = _e3972.x;
        temporary12_.y = _e3972.y;
        temporary12_.z = _e3972.z;
        let _e3981: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e3981.wwww.x;
        let _e3985: vec4<f32> = temporary2_;
        let _e3989: vec4<f32> = constant_registers[16u];
        let _e3991: vec4<f32> = (_e3985.xyzz - _e3989.xxxx);
        temporary20_.x = _e3991.x;
        temporary20_.y = _e3991.y;
        temporary20_.z = _e3991.z;
        let _e3998: vec4<f32> = temporary20_;
        let _e4000: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e3998.xyz, _e4000.xyz);
        let _e4004: vec4<f32> = temporary14_;
        temporary14_.z = -(_e4004.yyyy).x;
        let _e4009: vec4<f32> = temporary9_;
        let _e4011: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e4009.xyz, _e4011.xyz);
        let _e4015: vec4<f32> = temporary14_;
        let _e4017: vec4<f32> = temporary4_;
        temporary16_.x = (_e4015.zzzz / _e4017.xxxx).x;
        let _e4022: vec4<f32> = temporary16_;
        temporary14_.x = _e4022.xxxx.x;
        let _e4028: vec4<f32> = constant_registers[16u];
        let _e4030: vec4<f32> = temporary14_;
        temporary14_.y = vec4<f32>((_e4028.xxxx < _e4030.xxxx)).x;
        let _e4036: vec4<f32> = temporary14_;
        let _e4040: vec4<f32> = constant_registers[16u];
        if all((_e4036.yyyy != _e4040.xxxx)) {
            let _e4044: vec4<f32> = temporary14_;
            temporary2_.w = _e4044.xxxx.x;
        }
        let _e4048: vec4<f32> = temporary2_;
        temporary4_.y = _e4048.wwww.x;
        let _e4052: vec4<f32> = temporary4_;
        let _e4054: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4052.yyyy < _e4054.zzzz)).x;
        let _e4060: vec4<f32> = temporary8_;
        let _e4064: vec4<f32> = constant_registers[16u];
        if all((_e4060.zzzz != _e4064.xxxx)) {
            let _e4068: vec4<f32> = temporary4_;
            temporary4_.z = _e4068.yyyy.x;
            let _e4072: vec4<f32> = temporary3_;
            let _e4073: vec4<f32> = _e4072.xyzz;
            temporary6_.x = _e4073.x;
            temporary6_.y = _e4073.y;
            temporary6_.z = _e4073.z;
            let _e4082: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e4082.yyyy.x;
        }
        let _e4086: vec4<f32> = temporary2_;
        let _e4087: vec4<f32> = _e4086.xyzz;
        temporary15_.x = _e4087.x;
        temporary15_.y = _e4087.y;
        temporary15_.z = _e4087.z;
        let _e4094: vec4<f32> = temporary9_;
        let _e4095: vec4<f32> = _e4094.xyzz;
        temporary17_.x = _e4095.x;
        temporary17_.y = _e4095.y;
        temporary17_.z = _e4095.z;
        let _e4104: vec4<f32> = constant_registers[4u];
        let _e4105: vec4<f32> = _e4104.xyzz;
        temporary18_.x = _e4105.x;
        temporary18_.y = _e4105.y;
        temporary18_.z = _e4105.z;
        let _e4114: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e4114.xxxx.x;
        let _e4118: vec4<f32> = temporary3_;
        let _e4119: vec4<f32> = _e4118.xyzz;
        temporary19_.x = _e4119.x;
        temporary19_.y = _e4119.y;
        temporary19_.z = _e4119.z;
        let _e4128: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4128.wwww.x;
        let _e4132: vec4<f32> = temporary15_;
        let _e4134: vec4<f32> = temporary18_;
        let _e4136: vec4<f32> = (_e4132.xyzz - _e4134.xyzz);
        temporary12_.x = _e4136.x;
        temporary12_.y = _e4136.y;
        temporary12_.z = _e4136.z;
        let _e4143: vec4<f32> = temporary12_;
        let _e4145: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4143.xyz, _e4145.xyz);
        let _e4149: vec4<f32> = temporary13_;
        let _e4151: vec4<f32> = temporary13_;
        temporary3_.w = (_e4149.yyyy * _e4151.yyyy).x;
        let _e4156: vec4<f32> = temporary12_;
        let _e4158: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4156.xyz, _e4158.xyz);
        let _e4162: vec4<f32> = temporary3_;
        let _e4164: vec4<f32> = temporary14_;
        temporary14_.y = (_e4162.wwww - _e4164.xxxx).x;
        let _e4169: vec4<f32> = temporary2_;
        let _e4171: vec4<f32> = temporary2_;
        temporary14_.z = (_e4169.wwww * _e4171.wwww).x;
        let _e4176: vec4<f32> = temporary14_;
        let _e4178: vec4<f32> = temporary14_;
        temporary13_.z = (_e4176.yyyy + _e4178.zzzz).x;
        let _e4185: vec4<f32> = constant_registers[16u];
        let _e4187: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4185.xxxx < _e4187.zzzz)).x;
        let _e4193: vec4<f32> = temporary3_;
        let _e4197: vec4<f32> = constant_registers[16u];
        if all((_e4193.wwww != _e4197.xxxx)) {
            let _e4201: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4201.zzzz).x;
            let _e4206: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4206.yyyy).x;
            let _e4211: vec4<f32> = temporary14_;
            let _e4213: vec4<f32> = temporary13_;
            temporary14_.y = (_e4211.xxxx - _e4213.zzzz).x;
            let _e4218: vec4<f32> = temporary14_;
            temporary3_.w = _e4218.yyyy.x;
            let _e4224: vec4<f32> = constant_registers[16u];
            let _e4226: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4224.xxxx < _e4226.wwww)).x;
            let _e4232: vec4<f32> = temporary14_;
            let _e4236: vec4<f32> = constant_registers[16u];
            if all((_e4232.xxxx != _e4236.xxxx)) {
                let _e4240: vec4<f32> = temporary3_;
                temporary13_.x = _e4240.wwww.x;
                let _e4244: vec4<f32> = temporary17_;
                let _e4246: vec4<f32> = temporary3_;
                let _e4248: vec4<f32> = (_e4244.xyzz * _e4246.wwww);
                temporary14_.x = _e4248.x;
                temporary14_.y = _e4248.y;
                temporary14_.z = _e4248.z;
                let _e4255: vec4<f32> = temporary15_;
                let _e4257: vec4<f32> = temporary14_;
                let _e4259: vec4<f32> = (_e4255.xyzz + _e4257.xyzz);
                temporary20_.x = _e4259.x;
                temporary20_.y = _e4259.y;
                temporary20_.z = _e4259.z;
                let _e4266: vec4<f32> = temporary20_;
                let _e4268: vec4<f32> = temporary18_;
                let _e4270: vec4<f32> = (_e4266.xyzz - _e4268.xyzz);
                temporary16_.x = _e4270.x;
                temporary16_.y = _e4270.y;
                temporary16_.z = _e4270.z;
                let _e4277: vec4<f32> = temporary16_;
                let _e4279: vec3<f32> = normalize(_e4277.xyz);
                temporary19_.x = _e4279.x;
                temporary19_.y = _e4279.y;
                temporary19_.z = _e4279.z;
            }
        }
        let _e4286: vec4<f32> = temporary13_;
        temporary4_.y = _e4286.xxxx.x;
        let _e4290: vec4<f32> = temporary19_;
        let _e4291: vec4<f32> = _e4290.xyzz;
        temporary3_.x = _e4291.x;
        temporary3_.y = _e4291.y;
        temporary3_.z = _e4291.z;
        let _e4298: vec4<f32> = temporary4_;
        let _e4300: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4298.yyyy < _e4300.zzzz)).x;
        let _e4306: vec4<f32> = temporary8_;
        let _e4310: vec4<f32> = constant_registers[16u];
        if all((_e4306.zzzz != _e4310.xxxx)) {
            let _e4314: vec4<f32> = temporary4_;
            temporary4_.z = _e4314.yyyy.x;
            let _e4318: vec4<f32> = temporary3_;
            let _e4319: vec4<f32> = _e4318.xyzz;
            temporary6_.x = _e4319.x;
            temporary6_.y = _e4319.y;
            temporary6_.z = _e4319.z;
            let _e4328: vec4<f32> = constant_registers[5u];
            let _e4329: vec4<f32> = _e4328.xyzz;
            temporary7_.x = _e4329.x;
            temporary7_.y = _e4329.y;
            temporary7_.z = _e4329.z;
            let _e4338: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4338.xxxx.x;
        }
        let _e4342: vec4<f32> = temporary2_;
        let _e4343: vec4<f32> = _e4342.xyzz;
        temporary15_.x = _e4343.x;
        temporary15_.y = _e4343.y;
        temporary15_.z = _e4343.z;
        let _e4350: vec4<f32> = temporary9_;
        let _e4351: vec4<f32> = _e4350.xyzz;
        temporary17_.x = _e4351.x;
        temporary17_.y = _e4351.y;
        temporary17_.z = _e4351.z;
        let _e4360: vec4<f32> = constant_registers[7u];
        let _e4361: vec4<f32> = _e4360.xyzz;
        temporary18_.x = _e4361.x;
        temporary18_.y = _e4361.y;
        temporary18_.z = _e4361.z;
        let _e4370: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e4370.xxxx.x;
        let _e4374: vec4<f32> = temporary3_;
        let _e4375: vec4<f32> = _e4374.xyzz;
        temporary19_.x = _e4375.x;
        temporary19_.y = _e4375.y;
        temporary19_.z = _e4375.z;
        let _e4384: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4384.wwww.x;
        let _e4388: vec4<f32> = temporary15_;
        let _e4390: vec4<f32> = temporary18_;
        let _e4392: vec4<f32> = (_e4388.xyzz - _e4390.xyzz);
        temporary12_.x = _e4392.x;
        temporary12_.y = _e4392.y;
        temporary12_.z = _e4392.z;
        let _e4399: vec4<f32> = temporary12_;
        let _e4401: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4399.xyz, _e4401.xyz);
        let _e4405: vec4<f32> = temporary13_;
        let _e4407: vec4<f32> = temporary13_;
        temporary3_.w = (_e4405.yyyy * _e4407.yyyy).x;
        let _e4412: vec4<f32> = temporary12_;
        let _e4414: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4412.xyz, _e4414.xyz);
        let _e4418: vec4<f32> = temporary3_;
        let _e4420: vec4<f32> = temporary14_;
        temporary14_.y = (_e4418.wwww - _e4420.xxxx).x;
        let _e4425: vec4<f32> = temporary2_;
        let _e4427: vec4<f32> = temporary2_;
        temporary14_.z = (_e4425.wwww * _e4427.wwww).x;
        let _e4432: vec4<f32> = temporary14_;
        let _e4434: vec4<f32> = temporary14_;
        temporary13_.z = (_e4432.yyyy + _e4434.zzzz).x;
        let _e4441: vec4<f32> = constant_registers[16u];
        let _e4443: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4441.xxxx < _e4443.zzzz)).x;
        let _e4449: vec4<f32> = temporary3_;
        let _e4453: vec4<f32> = constant_registers[16u];
        if all((_e4449.wwww != _e4453.xxxx)) {
            let _e4457: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4457.zzzz).x;
            let _e4462: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4462.yyyy).x;
            let _e4467: vec4<f32> = temporary14_;
            let _e4469: vec4<f32> = temporary13_;
            temporary14_.y = (_e4467.xxxx - _e4469.zzzz).x;
            let _e4474: vec4<f32> = temporary14_;
            temporary3_.w = _e4474.yyyy.x;
            let _e4480: vec4<f32> = constant_registers[16u];
            let _e4482: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4480.xxxx < _e4482.wwww)).x;
            let _e4488: vec4<f32> = temporary14_;
            let _e4492: vec4<f32> = constant_registers[16u];
            if all((_e4488.xxxx != _e4492.xxxx)) {
                let _e4496: vec4<f32> = temporary3_;
                temporary13_.x = _e4496.wwww.x;
                let _e4500: vec4<f32> = temporary17_;
                let _e4502: vec4<f32> = temporary3_;
                let _e4504: vec4<f32> = (_e4500.xyzz * _e4502.wwww);
                temporary14_.x = _e4504.x;
                temporary14_.y = _e4504.y;
                temporary14_.z = _e4504.z;
                let _e4511: vec4<f32> = temporary15_;
                let _e4513: vec4<f32> = temporary14_;
                let _e4515: vec4<f32> = (_e4511.xyzz + _e4513.xyzz);
                temporary20_.x = _e4515.x;
                temporary20_.y = _e4515.y;
                temporary20_.z = _e4515.z;
                let _e4522: vec4<f32> = temporary20_;
                let _e4524: vec4<f32> = temporary18_;
                let _e4526: vec4<f32> = (_e4522.xyzz - _e4524.xyzz);
                temporary16_.x = _e4526.x;
                temporary16_.y = _e4526.y;
                temporary16_.z = _e4526.z;
                let _e4533: vec4<f32> = temporary16_;
                let _e4535: vec3<f32> = normalize(_e4533.xyz);
                temporary19_.x = _e4535.x;
                temporary19_.y = _e4535.y;
                temporary19_.z = _e4535.z;
            }
        }
        let _e4542: vec4<f32> = temporary13_;
        temporary4_.y = _e4542.xxxx.x;
        let _e4546: vec4<f32> = temporary19_;
        let _e4547: vec4<f32> = _e4546.xyzz;
        temporary3_.x = _e4547.x;
        temporary3_.y = _e4547.y;
        temporary3_.z = _e4547.z;
        let _e4554: vec4<f32> = temporary4_;
        let _e4556: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4554.yyyy < _e4556.zzzz)).x;
        let _e4562: vec4<f32> = temporary8_;
        let _e4566: vec4<f32> = constant_registers[16u];
        if all((_e4562.zzzz != _e4566.xxxx)) {
            let _e4570: vec4<f32> = temporary4_;
            temporary4_.z = _e4570.yyyy.x;
            let _e4574: vec4<f32> = temporary3_;
            let _e4575: vec4<f32> = _e4574.xyzz;
            temporary6_.x = _e4575.x;
            temporary6_.y = _e4575.y;
            temporary6_.z = _e4575.z;
            let _e4584: vec4<f32> = constant_registers[8u];
            let _e4585: vec4<f32> = _e4584.xyzz;
            temporary7_.x = _e4585.x;
            temporary7_.y = _e4585.y;
            temporary7_.z = _e4585.z;
            let _e4594: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4594.xxxx.x;
        }
        let _e4598: vec4<f32> = temporary2_;
        let _e4599: vec4<f32> = _e4598.xyzz;
        temporary15_.x = _e4599.x;
        temporary15_.y = _e4599.y;
        temporary15_.z = _e4599.z;
        let _e4606: vec4<f32> = temporary9_;
        let _e4607: vec4<f32> = _e4606.xyzz;
        temporary17_.x = _e4607.x;
        temporary17_.y = _e4607.y;
        temporary17_.z = _e4607.z;
        let _e4616: vec4<f32> = constant_registers[10u];
        let _e4617: vec4<f32> = _e4616.xyzz;
        temporary18_.x = _e4617.x;
        temporary18_.y = _e4617.y;
        temporary18_.z = _e4617.z;
        let _e4626: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e4626.xxxx.x;
        let _e4630: vec4<f32> = temporary3_;
        let _e4631: vec4<f32> = _e4630.xyzz;
        temporary19_.x = _e4631.x;
        temporary19_.y = _e4631.y;
        temporary19_.z = _e4631.z;
        let _e4640: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4640.wwww.x;
        let _e4644: vec4<f32> = temporary15_;
        let _e4646: vec4<f32> = temporary18_;
        let _e4648: vec4<f32> = (_e4644.xyzz - _e4646.xyzz);
        temporary12_.x = _e4648.x;
        temporary12_.y = _e4648.y;
        temporary12_.z = _e4648.z;
        let _e4655: vec4<f32> = temporary12_;
        let _e4657: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4655.xyz, _e4657.xyz);
        let _e4661: vec4<f32> = temporary13_;
        let _e4663: vec4<f32> = temporary13_;
        temporary3_.w = (_e4661.yyyy * _e4663.yyyy).x;
        let _e4668: vec4<f32> = temporary12_;
        let _e4670: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4668.xyz, _e4670.xyz);
        let _e4674: vec4<f32> = temporary3_;
        let _e4676: vec4<f32> = temporary14_;
        temporary14_.y = (_e4674.wwww - _e4676.xxxx).x;
        let _e4681: vec4<f32> = temporary2_;
        let _e4683: vec4<f32> = temporary2_;
        temporary14_.z = (_e4681.wwww * _e4683.wwww).x;
        let _e4688: vec4<f32> = temporary14_;
        let _e4690: vec4<f32> = temporary14_;
        temporary13_.z = (_e4688.yyyy + _e4690.zzzz).x;
        let _e4697: vec4<f32> = constant_registers[16u];
        let _e4699: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4697.xxxx < _e4699.zzzz)).x;
        let _e4705: vec4<f32> = temporary3_;
        let _e4709: vec4<f32> = constant_registers[16u];
        if all((_e4705.wwww != _e4709.xxxx)) {
            let _e4713: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4713.zzzz).x;
            let _e4718: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4718.yyyy).x;
            let _e4723: vec4<f32> = temporary14_;
            let _e4725: vec4<f32> = temporary13_;
            temporary14_.y = (_e4723.xxxx - _e4725.zzzz).x;
            let _e4730: vec4<f32> = temporary14_;
            temporary3_.w = _e4730.yyyy.x;
            let _e4736: vec4<f32> = constant_registers[16u];
            let _e4738: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4736.xxxx < _e4738.wwww)).x;
            let _e4744: vec4<f32> = temporary14_;
            let _e4748: vec4<f32> = constant_registers[16u];
            if all((_e4744.xxxx != _e4748.xxxx)) {
                let _e4752: vec4<f32> = temporary3_;
                temporary13_.x = _e4752.wwww.x;
                let _e4756: vec4<f32> = temporary17_;
                let _e4758: vec4<f32> = temporary3_;
                let _e4760: vec4<f32> = (_e4756.xyzz * _e4758.wwww);
                temporary14_.x = _e4760.x;
                temporary14_.y = _e4760.y;
                temporary14_.z = _e4760.z;
                let _e4767: vec4<f32> = temporary15_;
                let _e4769: vec4<f32> = temporary14_;
                let _e4771: vec4<f32> = (_e4767.xyzz + _e4769.xyzz);
                temporary20_.x = _e4771.x;
                temporary20_.y = _e4771.y;
                temporary20_.z = _e4771.z;
                let _e4778: vec4<f32> = temporary20_;
                let _e4780: vec4<f32> = temporary18_;
                let _e4782: vec4<f32> = (_e4778.xyzz - _e4780.xyzz);
                temporary16_.x = _e4782.x;
                temporary16_.y = _e4782.y;
                temporary16_.z = _e4782.z;
                let _e4789: vec4<f32> = temporary16_;
                let _e4791: vec3<f32> = normalize(_e4789.xyz);
                temporary19_.x = _e4791.x;
                temporary19_.y = _e4791.y;
                temporary19_.z = _e4791.z;
            }
        }
        let _e4798: vec4<f32> = temporary13_;
        temporary4_.y = _e4798.xxxx.x;
        let _e4802: vec4<f32> = temporary19_;
        let _e4803: vec4<f32> = _e4802.xyzz;
        temporary3_.x = _e4803.x;
        temporary3_.y = _e4803.y;
        temporary3_.z = _e4803.z;
        let _e4810: vec4<f32> = temporary4_;
        let _e4812: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4810.yyyy < _e4812.zzzz)).x;
        let _e4818: vec4<f32> = temporary8_;
        let _e4822: vec4<f32> = constant_registers[16u];
        if all((_e4818.zzzz != _e4822.xxxx)) {
            let _e4826: vec4<f32> = temporary4_;
            temporary4_.z = _e4826.yyyy.x;
            let _e4830: vec4<f32> = temporary3_;
            let _e4831: vec4<f32> = _e4830.xyzz;
            temporary6_.x = _e4831.x;
            temporary6_.y = _e4831.y;
            temporary6_.z = _e4831.z;
            let _e4840: vec4<f32> = constant_registers[11u];
            let _e4841: vec4<f32> = _e4840.xyzz;
            temporary7_.x = _e4841.x;
            temporary7_.y = _e4841.y;
            temporary7_.z = _e4841.z;
            let _e4850: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4850.xxxx.x;
        }
        let _e4854: vec4<f32> = temporary11_;
        let _e4858: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e4854.yyyy + _e4858.yyyy).x;
        let _e4863: vec4<f32> = temporary1_;
        let _e4867: vec4<f32> = constant_registers[16u];
        temporary8_.z = vec4<f32>((_e4863.zzzz == _e4867.xxxx)).x;
        let _e4873: vec4<f32> = temporary8_;
        let _e4877: vec4<f32> = constant_registers[16u];
        if all((_e4873.zzzz != _e4877.xxxx)) {
            let _e4883: vec4<f32> = constant_registers[16u];
            temporary11_.z = _e4883.yyyy.x;
        } else {
            let _e4887: vec4<f32> = temporary9_;
            let _e4889: vec4<f32> = temporary4_;
            let _e4891: vec4<f32> = (_e4887.xyzz * _e4889.zzzz);
            temporary15_.x = _e4891.x;
            temporary15_.y = _e4891.y;
            temporary15_.z = _e4891.z;
            let _e4898: vec4<f32> = temporary2_;
            let _e4900: vec4<f32> = temporary15_;
            let _e4902: vec4<f32> = (_e4898.xyzz + _e4900.xyzz);
            temporary2_.x = _e4902.x;
            temporary2_.y = _e4902.y;
            temporary2_.z = _e4902.z;
            let _e4909: vec4<f32> = temporary9_;
            let _e4911: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e4909.xyz, _e4911.xyz);
            let _e4915: vec4<f32> = temporary8_;
            let _e4919: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e4915.zzzz * _e4919.xxxx).x;
            let _e4924: vec4<f32> = temporary2_;
            let _e4926: vec4<f32> = temporary6_;
            let _e4928: vec4<f32> = (_e4924.wwww * _e4926.xyzz);
            temporary15_.x = _e4928.x;
            temporary15_.y = _e4928.y;
            temporary15_.z = _e4928.z;
            let _e4935: vec4<f32> = temporary9_;
            let _e4937: vec4<f32> = temporary15_;
            let _e4939: vec4<f32> = (_e4935.xyzz - _e4937.xyzz);
            temporary9_.x = _e4939.x;
            temporary9_.y = _e4939.y;
            temporary9_.z = _e4939.z;
            let _e4946: vec4<f32> = temporary9_;
            let _e4950: vec4<f32> = constant_registers[18u];
            let _e4952: vec4<f32> = (_e4946.xyzz * _e4950.yyyy);
            temporary15_.x = _e4952.x;
            temporary15_.y = _e4952.y;
            temporary15_.z = _e4952.z;
            let _e4959: vec4<f32> = temporary2_;
            let _e4961: vec4<f32> = temporary15_;
            let _e4963: vec4<f32> = (_e4959.xyzz + _e4961.xyzz);
            temporary2_.x = _e4963.x;
            temporary2_.y = _e4963.y;
            temporary2_.z = _e4963.z;
            let _e4972: vec4<f32> = constant_registers[15u];
            let _e4974: vec4<f32> = temporary2_;
            let _e4976: vec4<f32> = (_e4972.xyzz - _e4974.xyzz);
            temporary5_.x = _e4976.x;
            temporary5_.y = _e4976.y;
            temporary5_.z = _e4976.z;
            let _e4983: vec4<f32> = temporary5_;
            let _e4985: vec3<f32> = normalize(_e4983.xyz);
            temporary10_.x = _e4985.x;
            temporary10_.y = _e4985.y;
            temporary10_.z = _e4985.z;
            let _e4992: vec4<f32> = temporary5_;
            let _e4994: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e4992.xyz, _e4994.xyz);
            let _e4998: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e4998.zzzz).x;
            let _e5003: vec4<f32> = temporary6_;
            let _e5005: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e5003.xyz, _e5005.xyz);
            let _e5009: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e5009.zzzz).x;
            let _e5014: vec4<f32> = temporary1_;
            let _e5016: vec4<f32> = temporary1_;
            temporary15_.x = (_e5014.yyyy * _e5016.yyyy).x;
            let _e5021: vec4<f32> = temporary15_;
            let _e5025: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e5021.xxxx * _e5025.zzzz).x;
            let _e5032: vec4<f32> = constant_registers[18u];
            let _e5034: vec4<f32> = temporary15_;
            temporary15_.z = (_e5032.wwww + _e5034.yyyy).x;
            let _e5039: vec4<f32> = temporary2_;
            let _e5041: vec4<f32> = temporary15_;
            temporary1_.x = (_e5039.wwww / _e5041.zzzz).x;
            let _e5046: vec4<f32> = temporary1_;
            temporary8_.x = _e5046.xxxx.x;
            let _e5052: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e5052.xxxx.x;
            let _e5058: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5058.wwww.x;
            let _e5062: vec4<f32> = temporary2_;
            let _e5066: vec4<f32> = constant_registers[4u];
            let _e5068: vec4<f32> = (_e5062.xyzz - _e5066.xyzz);
            temporary13_.x = _e5068.x;
            temporary13_.y = _e5068.y;
            temporary13_.z = _e5068.z;
            let _e5075: vec4<f32> = temporary13_;
            let _e5077: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5075.xyz, _e5077.xyz);
            let _e5081: vec4<f32> = temporary19_;
            let _e5083: vec4<f32> = temporary19_;
            temporary1_.w = (_e5081.yyyy * _e5083.yyyy).x;
            let _e5088: vec4<f32> = temporary13_;
            let _e5090: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5088.xyz, _e5090.xyz);
            let _e5094: vec4<f32> = temporary1_;
            let _e5096: vec4<f32> = temporary12_;
            temporary12_.y = (_e5094.wwww - _e5096.xxxx).x;
            let _e5101: vec4<f32> = temporary2_;
            let _e5103: vec4<f32> = temporary2_;
            temporary12_.z = (_e5101.wwww * _e5103.wwww).x;
            let _e5108: vec4<f32> = temporary12_;
            let _e5110: vec4<f32> = temporary12_;
            temporary19_.z = (_e5108.yyyy + _e5110.zzzz).x;
            let _e5117: vec4<f32> = constant_registers[16u];
            let _e5119: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5117.xxxx < _e5119.zzzz)).x;
            let _e5125: vec4<f32> = temporary1_;
            let _e5129: vec4<f32> = constant_registers[16u];
            if all((_e5125.wwww != _e5129.xxxx)) {
                let _e5133: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5133.zzzz).x;
                let _e5138: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5138.yyyy).x;
                let _e5143: vec4<f32> = temporary12_;
                let _e5145: vec4<f32> = temporary19_;
                temporary1_.w = (_e5143.xxxx - _e5145.zzzz).x;
                let _e5152: vec4<f32> = constant_registers[16u];
                let _e5154: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5152.xxxx < _e5154.wwww)).x;
                let _e5160: vec4<f32> = temporary12_;
                let _e5164: vec4<f32> = constant_registers[16u];
                if all((_e5160.xxxx != _e5164.xxxx)) {
                    let _e5168: vec4<f32> = temporary1_;
                    temporary19_.x = _e5168.wwww.x;
                }
            }
            let _e5172: vec4<f32> = temporary19_;
            let _e5174: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5172.xxxx < _e5174.yyyy)).x;
            let _e5180: vec4<f32> = temporary8_;
            let _e5184: vec4<f32> = constant_registers[16u];
            if all((_e5180.zzzz != _e5184.xxxx)) {
                let _e5190: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5190.xxxx.x;
            }
            let _e5196: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e5196.xxxx.x;
            let _e5202: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5202.wwww.x;
            let _e5206: vec4<f32> = temporary2_;
            let _e5210: vec4<f32> = constant_registers[7u];
            let _e5212: vec4<f32> = (_e5206.xyzz - _e5210.xyzz);
            temporary13_.x = _e5212.x;
            temporary13_.y = _e5212.y;
            temporary13_.z = _e5212.z;
            let _e5219: vec4<f32> = temporary13_;
            let _e5221: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5219.xyz, _e5221.xyz);
            let _e5225: vec4<f32> = temporary19_;
            let _e5227: vec4<f32> = temporary19_;
            temporary1_.w = (_e5225.yyyy * _e5227.yyyy).x;
            let _e5232: vec4<f32> = temporary13_;
            let _e5234: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5232.xyz, _e5234.xyz);
            let _e5238: vec4<f32> = temporary1_;
            let _e5240: vec4<f32> = temporary12_;
            temporary12_.y = (_e5238.wwww - _e5240.xxxx).x;
            let _e5245: vec4<f32> = temporary2_;
            let _e5247: vec4<f32> = temporary2_;
            temporary12_.z = (_e5245.wwww * _e5247.wwww).x;
            let _e5252: vec4<f32> = temporary12_;
            let _e5254: vec4<f32> = temporary12_;
            temporary19_.z = (_e5252.yyyy + _e5254.zzzz).x;
            let _e5261: vec4<f32> = constant_registers[16u];
            let _e5263: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5261.xxxx < _e5263.zzzz)).x;
            let _e5269: vec4<f32> = temporary1_;
            let _e5273: vec4<f32> = constant_registers[16u];
            if all((_e5269.wwww != _e5273.xxxx)) {
                let _e5277: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5277.zzzz).x;
                let _e5282: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5282.yyyy).x;
                let _e5287: vec4<f32> = temporary12_;
                let _e5289: vec4<f32> = temporary19_;
                temporary1_.w = (_e5287.xxxx - _e5289.zzzz).x;
                let _e5296: vec4<f32> = constant_registers[16u];
                let _e5298: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5296.xxxx < _e5298.wwww)).x;
                let _e5304: vec4<f32> = temporary12_;
                let _e5308: vec4<f32> = constant_registers[16u];
                if all((_e5304.xxxx != _e5308.xxxx)) {
                    let _e5312: vec4<f32> = temporary1_;
                    temporary19_.x = _e5312.wwww.x;
                }
            }
            let _e5316: vec4<f32> = temporary19_;
            let _e5318: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5316.xxxx < _e5318.yyyy)).x;
            let _e5324: vec4<f32> = temporary8_;
            let _e5328: vec4<f32> = constant_registers[16u];
            if all((_e5324.zzzz != _e5328.xxxx)) {
                let _e5334: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5334.xxxx.x;
            }
            let _e5338: vec4<f32> = temporary2_;
            let _e5339: vec4<f32> = _e5338.xyzz;
            temporary15_.x = _e5339.x;
            temporary15_.y = _e5339.y;
            temporary15_.z = _e5339.z;
            let _e5346: vec4<f32> = temporary10_;
            let _e5347: vec4<f32> = _e5346.xyzz;
            temporary17_.x = _e5347.x;
            temporary17_.y = _e5347.y;
            temporary17_.z = _e5347.z;
            let _e5356: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e5356.xxxx.x;
            let _e5362: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5362.wwww.x;
            let _e5366: vec4<f32> = temporary15_;
            let _e5370: vec4<f32> = constant_registers[10u];
            let _e5372: vec4<f32> = (_e5366.xyzz - _e5370.xyzz);
            temporary13_.x = _e5372.x;
            temporary13_.y = _e5372.y;
            temporary13_.z = _e5372.z;
            let _e5379: vec4<f32> = temporary13_;
            let _e5381: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e5379.xyz, _e5381.xyz);
            let _e5385: vec4<f32> = temporary19_;
            let _e5387: vec4<f32> = temporary19_;
            temporary1_.w = (_e5385.yyyy * _e5387.yyyy).x;
            let _e5392: vec4<f32> = temporary13_;
            let _e5394: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5392.xyz, _e5394.xyz);
            let _e5398: vec4<f32> = temporary1_;
            let _e5400: vec4<f32> = temporary12_;
            temporary12_.y = (_e5398.wwww - _e5400.xxxx).x;
            let _e5405: vec4<f32> = temporary2_;
            let _e5407: vec4<f32> = temporary2_;
            temporary12_.z = (_e5405.wwww * _e5407.wwww).x;
            let _e5412: vec4<f32> = temporary12_;
            let _e5414: vec4<f32> = temporary12_;
            temporary19_.z = (_e5412.yyyy + _e5414.zzzz).x;
            let _e5421: vec4<f32> = constant_registers[16u];
            let _e5423: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5421.xxxx < _e5423.zzzz)).x;
            let _e5429: vec4<f32> = temporary1_;
            let _e5433: vec4<f32> = constant_registers[16u];
            if all((_e5429.wwww != _e5433.xxxx)) {
                let _e5437: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5437.zzzz).x;
                let _e5442: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5442.yyyy).x;
                let _e5447: vec4<f32> = temporary12_;
                let _e5449: vec4<f32> = temporary19_;
                temporary1_.w = (_e5447.xxxx - _e5449.zzzz).x;
                let _e5456: vec4<f32> = constant_registers[16u];
                let _e5458: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5456.xxxx < _e5458.wwww)).x;
                let _e5464: vec4<f32> = temporary12_;
                let _e5468: vec4<f32> = constant_registers[16u];
                if all((_e5464.xxxx != _e5468.xxxx)) {
                    let _e5472: vec4<f32> = temporary1_;
                    temporary19_.x = _e5472.wwww.x;
                }
            }
            let _e5476: vec4<f32> = temporary19_;
            let _e5478: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5476.xxxx < _e5478.yyyy)).x;
            let _e5484: vec4<f32> = temporary8_;
            let _e5488: vec4<f32> = constant_registers[16u];
            if all((_e5484.zzzz != _e5488.xxxx)) {
                let _e5494: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5494.xxxx.x;
            }
            let _e5498: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e5498.yyyy).x;
            let _e5503: vec4<f32> = temporary8_;
            let _e5507: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e5503.zzzz * _e5507.xxxx).x;
            let _e5512: vec4<f32> = temporary8_;
            let _e5514: vec4<f32> = temporary2_;
            temporary8_.x = (_e5512.xxxx + _e5514.wwww).x;
            let _e5519: vec4<f32> = temporary8_;
            let _e5523: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e5519.xxxx * _e5523.yyyy).x;
            let _e5530: vec4<f32> = constant_registers[19u];
            let _e5532: vec4<f32> = temporary8_;
            temporary2_.w = (_e5530.zzzz + _e5532.zzzz).x;
            let _e5537: vec4<f32> = temporary2_;
            temporary8_.y = _e5537.wwww.x;
            let _e5541: vec4<f32> = temporary1_;
            let _e5545: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e5541.zzzz == _e5545.yyyy)).x;
            let _e5551: vec4<f32> = temporary8_;
            let _e5555: vec4<f32> = constant_registers[16u];
            if all((_e5551.zzzz != _e5555.xxxx)) {
                let _e5559: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e5559.xxxx).x;
                let _e5564: vec4<f32> = temporary2_;
                let _e5566: vec4<f32> = temporary8_;
                temporary2_.w = (_e5564.xxxx - _e5566.zzzz).x;
                let _e5571: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e5571.zzzz).x;
                let _e5576: vec4<f32> = temporary2_;
                let _e5578: vec4<f32> = temporary15_;
                temporary15_.y = (_e5576.zzzz - _e5578.xxxx).x;
                let _e5583: vec4<f32> = temporary2_;
                let _e5585: vec4<f32> = temporary15_;
                temporary15_.z = (_e5583.wwww + _e5585.yyyy).x;
                let _e5590: vec4<f32> = temporary15_;
                let _e5594: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e5590.zzzz / _e5594.xxxx).x;
                let _e5599: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e5599.xxxx).x;
                let _e5604: vec4<f32> = temporary17_;
                let _e5608: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e5604.xxxx * _e5608.xxxx).x;
                let _e5613: vec4<f32> = temporary17_;
                let _e5617: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e5613.yyyy == _e5617.yyyy)).x;
                let _e5623: vec4<f32> = temporary17_;
                let _e5627: vec4<f32> = constant_registers[16u];
                if all((_e5623.zzzz != _e5627.xxxx)) {
                    let _e5633: vec4<f32> = constant_registers[13u];
                    let _e5635: vec4<f32> = temporary8_;
                    let _e5637: vec4<f32> = (_e5633.xyzz * _e5635.yyyy);
                    temporary15_.x = _e5637.x;
                    temporary15_.y = _e5637.y;
                    temporary15_.z = _e5637.z;
                    let _e5644: vec4<f32> = temporary0_;
                    let _e5646: vec4<f32> = temporary15_;
                    let _e5648: vec4<f32> = (_e5644.xyzz + _e5646.xyzz);
                    temporary0_.x = _e5648.x;
                    temporary0_.y = _e5648.y;
                    temporary0_.z = _e5648.z;
                } else {
                    let _e5657: vec4<f32> = constant_registers[14u];
                    let _e5659: vec4<f32> = temporary8_;
                    let _e5661: vec4<f32> = (_e5657.xyzz * _e5659.yyyy);
                    temporary15_.x = _e5661.x;
                    temporary15_.y = _e5661.y;
                    temporary15_.z = _e5661.z;
                    let _e5668: vec4<f32> = temporary0_;
                    let _e5670: vec4<f32> = temporary15_;
                    let _e5672: vec4<f32> = (_e5668.xyzz + _e5670.xyzz);
                    temporary0_.x = _e5672.x;
                    temporary0_.y = _e5672.y;
                    temporary0_.z = _e5672.z;
                }
            }
            let _e5679: vec4<f32> = temporary1_;
            let _e5683: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e5679.zzzz == _e5683.xxxx)).x;
            let _e5689: vec4<f32> = temporary8_;
            let _e5693: vec4<f32> = constant_registers[16u];
            if all((_e5689.zzzz != _e5693.xxxx)) {
                let _e5697: vec4<f32> = temporary7_;
                let _e5699: vec4<f32> = temporary8_;
                let _e5701: vec4<f32> = (_e5697.xyzz * _e5699.yyyy);
                temporary15_.x = _e5701.x;
                temporary15_.y = _e5701.y;
                temporary15_.z = _e5701.z;
                let _e5708: vec4<f32> = temporary0_;
                let _e5710: vec4<f32> = temporary15_;
                let _e5712: vec4<f32> = (_e5708.xyzz + _e5710.xyzz);
                temporary0_.x = _e5712.x;
                temporary0_.y = _e5712.y;
                temporary0_.z = _e5712.z;
            }
        }
    }
    let _e5719: vec4<f32> = temporary9_;
    let _e5724: vec4<f32> = textureSample(texture0_, sampler0_, _e5719.xyzz.xyz);
    temporary1_ = _e5724;
    let _e5725: vec4<f32> = temporary11_;
    let _e5729: vec4<f32> = constant_registers[16u];
    if all((_e5725.zzzz != _e5729.xxxx)) {
        let _e5733: vec4<f32> = temporary0_;
        let _e5735: vec4<f32> = temporary1_;
        let _e5737: vec4<f32> = (_e5733.xyzz + _e5735.xyzz);
        temporary0_.x = _e5737.x;
        temporary0_.y = _e5737.y;
        temporary0_.z = _e5737.z;
    }
    let _e5744: vec4<f32> = temporary0_;
    let _e5746: vec4<f32> = temporary11_;
    let _e5748: vec4<f32> = (_e5744.xyzz / _e5746.yyyy);
    temporary0_.x = _e5748.x;
    temporary0_.y = _e5748.y;
    temporary0_.z = _e5748.z;
    let _e5755: vec4<f32> = temporary0_;
    dest_temp = _e5755;
    let _e5756: vec4<f32> = dest_temp;
    return FragmentOutput(_e5756);
}