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

@group(0) @binding(1) 
var<uniform> constant_registers: array<vec4<f32>,28u>;
@group(0) @binding(2) 
var sampler0_: sampler;
@group(0) @binding(3) 
var sampler1_: sampler;
@group(0) @binding(4) 
var sampler2_: sampler;
@group(0) @binding(5) 
var sampler3_: sampler;
@group(0) @binding(6) 
var texture0_: texture_cube<f32>;

@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 _e8: vec4<f32> = constant_registers[16u];
    temporary0_ = _e8.xxxy;
    let _e15: vec4<f32> = constant_registers[3u];
    temporary1_.x = (param.xxxx * _e15.xxxx).x;
    temporary1_.y = param.yyyy.x;
    let _e26: vec4<f32> = constant_registers[1u];
    let _e27: vec4<f32> = _e26.xxxx;
    temporary1_.z = _e27.z;
    temporary1_.w = _e27.w;
    let _e32: vec4<f32> = temporary1_;
    let _e36: vec4<f32> = constant_registers[16u];
    let _e38: vec4<f32> = (_e32.zzzw * _e36.zzzz);
    temporary1_.z = _e38.z;
    temporary1_.w = _e38.w;
    let _e43: vec4<f32> = temporary1_;
    temporary1_.z = cos(_e43.zzzz).x;
    let _e48: vec4<f32> = temporary1_;
    let _e52: vec4<f32> = constant_registers[16u];
    temporary2_.x = (_e48.zzzz * _e52.wwww).x;
    let _e60: vec4<f32> = constant_registers[1u];
    temporary1_.z = _e60.yyyy.x;
    let _e64: vec4<f32> = temporary1_;
    let _e68: vec4<f32> = constant_registers[16u];
    temporary1_.z = (_e64.zzzz + _e68.yyyy).x;
    let _e73: vec4<f32> = temporary1_;
    let _e77: vec4<f32> = constant_registers[17u];
    temporary1_.z = (_e73.zzzz * _e77.xxxx).x;
    let _e82: vec4<f32> = temporary1_;
    let _e86: vec4<f32> = constant_registers[17u];
    temporary1_.z = max(_e82.zzzz, _e86.yyyy).x;
    let _e91: vec4<f32> = temporary1_;
    temporary1_.w = sin(_e91.wwww).x;
    let _e96: vec4<f32> = temporary1_;
    let _e100: vec4<f32> = constant_registers[16u];
    temporary2_.z = (_e96.wwww * _e100.wwww).x;
    let _e105: vec4<f32> = temporary1_;
    temporary2_.y = _e105.zzzz.x;
    let _e111: vec4<f32> = constant_registers[16u];
    let _e112: vec4<f32> = _e111.xxxx;
    temporary4_.x = _e112.x;
    temporary4_.z = _e112.z;
    let _e120: vec4<f32> = constant_registers[17u];
    temporary4_.y = _e120.zzzz.x;
    let _e126: vec4<f32> = constant_registers[16u];
    temporary1_.w = _e126.yyyy.x;
    let _e130: vec4<f32> = temporary4_;
    let _e132: vec4<f32> = temporary2_;
    let _e134: vec4<f32> = (_e130.xyzz - _e132.xyzz);
    temporary3_.x = _e134.x;
    temporary3_.y = _e134.y;
    temporary3_.z = _e134.z;
    let _e142: vec4<f32> = temporary3_;
    let _e144: vec3<f32> = normalize(_e142.xyz);
    temporary3_.x = _e144.x;
    temporary3_.y = _e144.y;
    temporary3_.z = _e144.z;
    let _e153: vec4<f32> = constant_registers[16u];
    let _e155: vec4<f32> = temporary3_;
    let _e157: vec3<f32> = cross(_e153.xyx, _e155.xyz);
    let _e162: vec4<f32> = vec4<f32>(_e157.x, _e157.y, _e157.z, 1.0);
    temporary5_.x = _e162.x;
    temporary5_.y = _e162.y;
    temporary5_.z = _e162.z;
    let _e170: vec4<f32> = temporary5_;
    let _e172: vec3<f32> = normalize(_e170.xyz);
    temporary6_.x = _e172.x;
    temporary6_.y = _e172.y;
    temporary6_.z = _e172.z;
    let _e180: vec4<f32> = temporary3_;
    let _e182: vec4<f32> = temporary6_;
    let _e184: vec3<f32> = cross(_e180.xyz, _e182.xyz);
    let _e189: vec4<f32> = vec4<f32>(_e184.x, _e184.y, _e184.z, 1.0);
    temporary5_.x = _e189.x;
    temporary5_.y = _e189.y;
    temporary5_.z = _e189.z;
    let _e196: vec4<f32> = temporary3_;
    let _e198: vec4<f32> = temporary1_;
    let _e200: vec4<f32> = (_e196.xyzz * _e198.wwww);
    temporary3_.x = _e200.x;
    temporary3_.y = _e200.y;
    temporary3_.z = _e200.z;
    let _e207: vec4<f32> = temporary6_;
    let _e209: vec4<f32> = temporary1_;
    let _e211: vec4<f32> = (_e207.xyzz * _e209.xxxx);
    temporary6_.x = _e211.x;
    temporary6_.y = _e211.y;
    temporary6_.z = _e211.z;
    let _e218: vec4<f32> = temporary3_;
    let _e220: vec4<f32> = temporary6_;
    let _e222: vec4<f32> = (_e218.xyzz + _e220.xyzz);
    temporary7_.x = _e222.x;
    temporary7_.y = _e222.y;
    temporary7_.z = _e222.z;
    let _e230: vec4<f32> = temporary5_;
    let _e232: vec4<f32> = temporary1_;
    let _e234: vec4<f32> = (_e230.xyzz * _e232.yyyy);
    temporary5_.x = _e234.x;
    temporary5_.y = _e234.y;
    temporary5_.z = _e234.z;
    let _e241: vec4<f32> = temporary7_;
    let _e243: vec4<f32> = temporary5_;
    let _e245: vec4<f32> = (_e241.xyzz + _e243.xyzz);
    temporary5_.x = _e245.x;
    temporary5_.y = _e245.y;
    temporary5_.z = _e245.z;
    let _e252: vec4<f32> = temporary5_;
    let _e254: vec3<f32> = normalize(_e252.xyz);
    temporary8_.x = _e254.x;
    temporary8_.y = _e254.y;
    temporary8_.z = _e254.z;
    let _e262: vec4<f32> = temporary8_;
    let _e263: vec4<f32> = _e262.xyzz;
    temporary10_.x = _e263.x;
    temporary10_.y = _e263.y;
    temporary10_.z = _e263.z;
    let _e271: vec4<f32> = temporary10_;
    let _e272: vec4<f32> = _e271.xyzz;
    temporary9_.x = _e272.x;
    temporary9_.y = _e272.y;
    temporary9_.z = _e272.z;
    let _e282: vec4<f32> = constant_registers[16u];
    let _e283: vec4<f32> = _e282.yxxx;
    temporary11_.x = _e283.x;
    temporary11_.y = _e283.y;
    temporary11_.z = _e283.z;
    let _e291: vec4<f32> = temporary11_;
    let _e295: vec4<f32> = constant_registers[16u];
    if all((_e291.xxxx != _e295.xxxx)) {
        let _e301: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e301.xxxx.x;
        let _e307: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e307.wwww.x;
        let _e313: vec4<f32> = constant_registers[16u];
        let _e314: vec4<f32> = _e313.xyxx;
        temporary3_.x = _e314.x;
        temporary3_.y = _e314.y;
        temporary3_.z = _e314.z;
        let _e321: vec4<f32> = temporary3_;
        let _e322: vec4<f32> = _e321.xyzz;
        temporary12_.x = _e322.x;
        temporary12_.y = _e322.y;
        temporary12_.z = _e322.z;
        let _e332: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e332.wwww.x;
        let _e336: vec4<f32> = temporary2_;
        let _e340: vec4<f32> = constant_registers[16u];
        let _e342: vec4<f32> = (_e336.xyzz - _e340.xxxx);
        temporary13_.x = _e342.x;
        temporary13_.y = _e342.y;
        temporary13_.z = _e342.z;
        let _e350: vec4<f32> = temporary13_;
        let _e352: vec4<f32> = temporary12_;
        temporary1_.y = dot(_e350.xyz, _e352.xyz);
        let _e356: vec4<f32> = temporary1_;
        temporary1_.y = -(_e356.yyyy).x;
        let _e361: vec4<f32> = temporary9_;
        let _e363: vec4<f32> = temporary12_;
        temporary12_.x = dot(_e361.xyz, _e363.xyz);
        let _e367: vec4<f32> = temporary1_;
        let _e369: vec4<f32> = temporary12_;
        temporary12_.y = (_e367.yyyy / _e369.xxxx).x;
        let _e374: vec4<f32> = temporary12_;
        temporary1_.y = _e374.yyyy.x;
        let _e380: vec4<f32> = constant_registers[16u];
        let _e382: vec4<f32> = temporary1_;
        temporary1_.w = f32((_e380.xxxx.x < _e382.yyyy.x));
        let _e389: vec4<f32> = temporary1_;
        let _e393: vec4<f32> = constant_registers[16u];
        if all((_e389.wwww != _e393.xxxx)) {
            let _e397: vec4<f32> = temporary1_;
            temporary1_.x = _e397.yyyy.x;
        }
        let _e401: vec4<f32> = temporary1_;
        temporary4_.y = _e401.xxxx.x;
        let _e405: vec4<f32> = temporary4_;
        let _e407: vec4<f32> = temporary4_;
        temporary1_.x = f32((_e405.yyyy.x < _e407.zzzz.x));
        let _e414: vec4<f32> = temporary1_;
        let _e418: vec4<f32> = constant_registers[16u];
        if all((_e414.xxxx != _e418.xxxx)) {
            let _e422: vec4<f32> = temporary4_;
            temporary4_.z = _e422.yyyy.x;
            let _e426: vec4<f32> = temporary3_;
            let _e427: vec4<f32> = _e426.xyzz;
            temporary6_.x = _e427.x;
            temporary6_.y = _e427.y;
            temporary6_.z = _e427.z;
            let _e436: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e436.yyyy.x;
        }
        let _e440: vec4<f32> = temporary2_;
        let _e441: vec4<f32> = _e440.xyzz;
        temporary5_.x = _e441.x;
        temporary5_.y = _e441.y;
        temporary5_.z = _e441.z;
        let _e448: vec4<f32> = temporary9_;
        let _e449: vec4<f32> = _e448.xyzz;
        temporary10_.x = _e449.x;
        temporary10_.y = _e449.y;
        temporary10_.z = _e449.z;
        let _e458: vec4<f32> = constant_registers[4u];
        let _e459: vec4<f32> = _e458.xyzz;
        temporary8_.x = _e459.x;
        temporary8_.y = _e459.y;
        temporary8_.z = _e459.z;
        let _e468: vec4<f32> = constant_registers[6u];
        temporary14_.x = _e468.xxxx.x;
        let _e473: vec4<f32> = temporary3_;
        let _e474: vec4<f32> = _e473.xyzz;
        temporary15_.x = _e474.x;
        temporary15_.y = _e474.y;
        temporary15_.z = _e474.z;
        let _e484: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e484.wwww.x;
        let _e488: vec4<f32> = temporary5_;
        let _e490: vec4<f32> = temporary8_;
        let _e492: vec4<f32> = (_e488.xyzz - _e490.xyzz);
        temporary16_.x = _e492.x;
        temporary16_.y = _e492.y;
        temporary16_.z = _e492.z;
        let _e500: vec4<f32> = temporary16_;
        let _e502: vec4<f32> = temporary10_;
        temporary14_.z = dot(_e500.xyz, _e502.xyz);
        let _e506: vec4<f32> = temporary14_;
        let _e508: vec4<f32> = temporary14_;
        let _e510: vec4<f32> = (_e506.zzzx * _e508.zzzx);
        temporary4_.x = _e510.x;
        temporary4_.w = _e510.w;
        let _e515: vec4<f32> = temporary16_;
        let _e517: vec4<f32> = temporary16_;
        temporary1_.y = dot(_e515.xyz, _e517.xyz);
        let _e521: vec4<f32> = temporary4_;
        let _e523: vec4<f32> = temporary1_;
        temporary1_.w = (_e521.xxxx - _e523.yyyy).x;
        let _e528: vec4<f32> = temporary1_;
        let _e530: vec4<f32> = temporary4_;
        temporary13_.x = (_e528.wwww + _e530.wwww).x;
        let _e535: vec4<f32> = temporary13_;
        temporary1_.w = _e535.xxxx.x;
        let _e541: vec4<f32> = constant_registers[16u];
        let _e543: vec4<f32> = temporary1_;
        temporary2_.w = f32((_e541.xxxx.x < _e543.wwww.x));
        let _e550: vec4<f32> = temporary2_;
        let _e554: vec4<f32> = constant_registers[16u];
        if all((_e550.wwww != _e554.xxxx)) {
            let _e558: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e558.wwww).x;
            let _e563: vec4<f32> = temporary14_;
            temporary1_.y = -(_e563.zzzz).x;
            let _e568: vec4<f32> = temporary1_;
            let _e570: vec4<f32> = temporary1_;
            temporary2_.w = (_e568.yyyy - _e570.wwww).x;
            let _e577: vec4<f32> = constant_registers[16u];
            let _e579: vec4<f32> = temporary2_;
            temporary1_.y = f32((_e577.xxxx.x < _e579.wwww.x));
            let _e586: vec4<f32> = temporary1_;
            let _e590: vec4<f32> = constant_registers[16u];
            if all((_e586.yyyy != _e590.xxxx)) {
                let _e594: vec4<f32> = temporary2_;
                temporary1_.x = _e594.wwww.x;
                let _e598: vec4<f32> = temporary10_;
                let _e600: vec4<f32> = temporary2_;
                let _e602: vec4<f32> = (_e598.xyzz * _e600.wwww);
                temporary13_.x = _e602.x;
                temporary13_.y = _e602.y;
                temporary13_.z = _e602.z;
                let _e609: vec4<f32> = temporary5_;
                let _e611: vec4<f32> = temporary13_;
                let _e613: vec4<f32> = (_e609.xyzz + _e611.xyzz);
                temporary12_.x = _e613.x;
                temporary12_.y = _e613.y;
                temporary12_.z = _e613.z;
                let _e620: vec4<f32> = temporary12_;
                let _e622: vec4<f32> = temporary8_;
                let _e624: vec4<f32> = (_e620.xyzz - _e622.xyzz);
                temporary14_.x = _e624.x;
                temporary14_.y = _e624.y;
                temporary14_.z = _e624.z;
                let _e631: vec4<f32> = temporary14_;
                let _e633: vec3<f32> = normalize(_e631.xyz);
                temporary16_.x = _e633.x;
                temporary16_.y = _e633.y;
                temporary16_.z = _e633.z;
                let _e640: vec4<f32> = temporary16_;
                let _e641: vec4<f32> = _e640.xyzz;
                temporary20_.x = _e641.x;
                temporary20_.y = _e641.y;
                temporary20_.z = _e641.z;
                let _e649: vec4<f32> = temporary20_;
                let _e650: vec4<f32> = _e649.xyzz;
                temporary15_.x = _e650.x;
                temporary15_.y = _e650.y;
                temporary15_.z = _e650.z;
            }
        }
        let _e657: vec4<f32> = temporary1_;
        temporary4_.y = _e657.xxxx.x;
        let _e661: vec4<f32> = temporary15_;
        let _e662: vec4<f32> = _e661.xyzz;
        temporary3_.x = _e662.x;
        temporary3_.y = _e662.y;
        temporary3_.z = _e662.z;
        let _e669: vec4<f32> = temporary4_;
        let _e671: vec4<f32> = temporary4_;
        temporary1_.x = f32((_e669.yyyy.x < _e671.zzzz.x));
        let _e678: vec4<f32> = temporary1_;
        let _e682: vec4<f32> = constant_registers[16u];
        if all((_e678.xxxx != _e682.xxxx)) {
            let _e686: vec4<f32> = temporary4_;
            temporary4_.z = _e686.yyyy.x;
            let _e690: vec4<f32> = temporary3_;
            let _e691: vec4<f32> = _e690.xyzz;
            temporary6_.x = _e691.x;
            temporary6_.y = _e691.y;
            temporary6_.z = _e691.z;
            let _e700: vec4<f32> = constant_registers[5u];
            let _e701: vec4<f32> = _e700.xyzz;
            temporary7_.x = _e701.x;
            temporary7_.y = _e701.y;
            temporary7_.z = _e701.z;
            let _e710: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e710.xxxx.x;
        }
        let _e714: vec4<f32> = temporary2_;
        let _e715: vec4<f32> = _e714.xyzz;
        temporary5_.x = _e715.x;
        temporary5_.y = _e715.y;
        temporary5_.z = _e715.z;
        let _e722: vec4<f32> = temporary9_;
        let _e723: vec4<f32> = _e722.xyzz;
        temporary10_.x = _e723.x;
        temporary10_.y = _e723.y;
        temporary10_.z = _e723.z;
        let _e732: vec4<f32> = constant_registers[7u];
        let _e733: vec4<f32> = _e732.xyzz;
        temporary8_.x = _e733.x;
        temporary8_.y = _e733.y;
        temporary8_.z = _e733.z;
        let _e742: vec4<f32> = constant_registers[9u];
        temporary15_.x = _e742.xxxx.x;
        let _e746: vec4<f32> = temporary3_;
        let _e747: vec4<f32> = _e746.xyzz;
        temporary18_.x = _e747.x;
        temporary18_.y = _e747.y;
        temporary18_.z = _e747.z;
        let _e757: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e757.wwww.x;
        let _e761: vec4<f32> = temporary5_;
        let _e763: vec4<f32> = temporary8_;
        let _e765: vec4<f32> = (_e761.xyzz - _e763.xyzz);
        temporary17_.x = _e765.x;
        temporary17_.y = _e765.y;
        temporary17_.z = _e765.z;
        let _e773: vec4<f32> = temporary17_;
        let _e775: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e773.xyz, _e775.xyz);
        let _e779: vec4<f32> = temporary15_;
        let _e781: vec4<f32> = temporary15_;
        let _e783: vec4<f32> = (_e779.zzzx * _e781.zzzx);
        temporary4_.x = _e783.x;
        temporary4_.w = _e783.w;
        let _e788: vec4<f32> = temporary17_;
        let _e790: vec4<f32> = temporary17_;
        temporary1_.y = dot(_e788.xyz, _e790.xyz);
        let _e794: vec4<f32> = temporary4_;
        let _e796: vec4<f32> = temporary1_;
        temporary1_.w = (_e794.xxxx - _e796.yyyy).x;
        let _e801: vec4<f32> = temporary1_;
        let _e803: vec4<f32> = temporary4_;
        temporary13_.x = (_e801.wwww + _e803.wwww).x;
        let _e808: vec4<f32> = temporary13_;
        temporary1_.w = _e808.xxxx.x;
        let _e814: vec4<f32> = constant_registers[16u];
        let _e816: vec4<f32> = temporary1_;
        temporary2_.w = f32((_e814.xxxx.x < _e816.wwww.x));
        let _e823: vec4<f32> = temporary2_;
        let _e827: vec4<f32> = constant_registers[16u];
        if all((_e823.wwww != _e827.xxxx)) {
            let _e831: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e831.wwww).x;
            let _e836: vec4<f32> = temporary15_;
            temporary1_.y = -(_e836.zzzz).x;
            let _e841: vec4<f32> = temporary1_;
            let _e843: vec4<f32> = temporary1_;
            temporary2_.w = (_e841.yyyy - _e843.wwww).x;
            let _e850: vec4<f32> = constant_registers[16u];
            let _e852: vec4<f32> = temporary2_;
            temporary1_.y = f32((_e850.xxxx.x < _e852.wwww.x));
            let _e859: vec4<f32> = temporary1_;
            let _e863: vec4<f32> = constant_registers[16u];
            if all((_e859.yyyy != _e863.xxxx)) {
                let _e867: vec4<f32> = temporary2_;
                temporary1_.x = _e867.wwww.x;
                let _e871: vec4<f32> = temporary10_;
                let _e873: vec4<f32> = temporary2_;
                let _e875: vec4<f32> = (_e871.xyzz * _e873.wwww);
                temporary13_.x = _e875.x;
                temporary13_.y = _e875.y;
                temporary13_.z = _e875.z;
                let _e882: vec4<f32> = temporary5_;
                let _e884: vec4<f32> = temporary13_;
                let _e886: vec4<f32> = (_e882.xyzz + _e884.xyzz);
                temporary12_.x = _e886.x;
                temporary12_.y = _e886.y;
                temporary12_.z = _e886.z;
                let _e893: vec4<f32> = temporary12_;
                let _e895: vec4<f32> = temporary8_;
                let _e897: vec4<f32> = (_e893.xyzz - _e895.xyzz);
                temporary14_.x = _e897.x;
                temporary14_.y = _e897.y;
                temporary14_.z = _e897.z;
                let _e904: vec4<f32> = temporary14_;
                let _e906: vec3<f32> = normalize(_e904.xyz);
                temporary16_.x = _e906.x;
                temporary16_.y = _e906.y;
                temporary16_.z = _e906.z;
                let _e913: vec4<f32> = temporary16_;
                let _e914: vec4<f32> = _e913.xyzz;
                temporary20_.x = _e914.x;
                temporary20_.y = _e914.y;
                temporary20_.z = _e914.z;
                let _e921: vec4<f32> = temporary20_;
                let _e922: vec4<f32> = _e921.xyzz;
                temporary18_.x = _e922.x;
                temporary18_.y = _e922.y;
                temporary18_.z = _e922.z;
            }
        }
        let _e929: vec4<f32> = temporary1_;
        temporary4_.y = _e929.xxxx.x;
        let _e933: vec4<f32> = temporary18_;
        let _e934: vec4<f32> = _e933.xyzz;
        temporary3_.x = _e934.x;
        temporary3_.y = _e934.y;
        temporary3_.z = _e934.z;
        let _e941: vec4<f32> = temporary4_;
        let _e943: vec4<f32> = temporary4_;
        temporary1_.x = f32((_e941.yyyy.x < _e943.zzzz.x));
        let _e950: vec4<f32> = temporary1_;
        let _e954: vec4<f32> = constant_registers[16u];
        if all((_e950.xxxx != _e954.xxxx)) {
            let _e958: vec4<f32> = temporary4_;
            temporary4_.z = _e958.yyyy.x;
            let _e962: vec4<f32> = temporary3_;
            let _e963: vec4<f32> = _e962.xyzz;
            temporary6_.x = _e963.x;
            temporary6_.y = _e963.y;
            temporary6_.z = _e963.z;
            let _e972: vec4<f32> = constant_registers[8u];
            let _e973: vec4<f32> = _e972.xyzz;
            temporary7_.x = _e973.x;
            temporary7_.y = _e973.y;
            temporary7_.z = _e973.z;
            let _e982: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e982.xxxx.x;
        }
        let _e986: vec4<f32> = temporary2_;
        let _e987: vec4<f32> = _e986.xyzz;
        temporary5_.x = _e987.x;
        temporary5_.y = _e987.y;
        temporary5_.z = _e987.z;
        let _e994: vec4<f32> = temporary9_;
        let _e995: vec4<f32> = _e994.xyzz;
        temporary10_.x = _e995.x;
        temporary10_.y = _e995.y;
        temporary10_.z = _e995.z;
        let _e1004: vec4<f32> = constant_registers[10u];
        let _e1005: vec4<f32> = _e1004.xyzz;
        temporary8_.x = _e1005.x;
        temporary8_.y = _e1005.y;
        temporary8_.z = _e1005.z;
        let _e1014: vec4<f32> = constant_registers[12u];
        temporary15_.x = _e1014.xxxx.x;
        let _e1018: vec4<f32> = temporary3_;
        let _e1019: vec4<f32> = _e1018.xyzz;
        temporary17_.x = _e1019.x;
        temporary17_.y = _e1019.y;
        temporary17_.z = _e1019.z;
        let _e1028: vec4<f32> = constant_registers[17u];
        temporary15_.y = _e1028.wwww.x;
        let _e1032: vec4<f32> = temporary5_;
        let _e1034: vec4<f32> = temporary8_;
        let _e1036: vec4<f32> = (_e1032.xyzz - _e1034.xyzz);
        temporary18_.x = _e1036.x;
        temporary18_.y = _e1036.y;
        temporary18_.z = _e1036.z;
        let _e1043: vec4<f32> = temporary18_;
        let _e1045: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e1043.xyz, _e1045.xyz);
        let _e1049: vec4<f32> = temporary15_;
        let _e1051: vec4<f32> = temporary15_;
        let _e1053: vec4<f32> = (_e1049.zzzx * _e1051.zzzx);
        temporary1_.x = _e1053.x;
        temporary1_.w = _e1053.w;
        let _e1058: vec4<f32> = temporary18_;
        let _e1060: vec4<f32> = temporary18_;
        temporary19_.y = dot(_e1058.xyz, _e1060.xyz);
        let _e1065: vec4<f32> = temporary1_;
        let _e1067: vec4<f32> = temporary19_;
        temporary19_.z = (_e1065.xxxx - _e1067.yyyy).x;
        let _e1072: vec4<f32> = temporary19_;
        let _e1074: vec4<f32> = temporary1_;
        temporary13_.x = (_e1072.zzzz + _e1074.wwww).x;
        let _e1079: vec4<f32> = temporary13_;
        temporary1_.x = _e1079.xxxx.x;
        let _e1085: vec4<f32> = constant_registers[16u];
        let _e1087: vec4<f32> = temporary1_;
        temporary19_.x = f32((_e1085.xxxx.x < _e1087.xxxx.x));
        let _e1094: vec4<f32> = temporary19_;
        let _e1098: vec4<f32> = constant_registers[16u];
        if all((_e1094.xxxx != _e1098.xxxx)) {
            let _e1102: vec4<f32> = temporary1_;
            temporary1_.x = sqrt(_e1102.xxxx).x;
            let _e1107: vec4<f32> = temporary15_;
            temporary19_.y = -(_e1107.zzzz).x;
            let _e1112: vec4<f32> = temporary19_;
            let _e1114: vec4<f32> = temporary1_;
            temporary19_.z = (_e1112.yyyy - _e1114.xxxx).x;
            let _e1119: vec4<f32> = temporary19_;
            temporary19_.x = _e1119.zzzz.x;
            let _e1125: vec4<f32> = constant_registers[16u];
            let _e1127: vec4<f32> = temporary19_;
            temporary19_.y = f32((_e1125.xxxx.x < _e1127.xxxx.x));
            let _e1134: vec4<f32> = temporary19_;
            let _e1138: vec4<f32> = constant_registers[16u];
            if all((_e1134.yyyy != _e1138.xxxx)) {
                let _e1142: vec4<f32> = temporary19_;
                temporary15_.y = _e1142.xxxx.x;
                let _e1146: vec4<f32> = temporary10_;
                let _e1148: vec4<f32> = temporary19_;
                let _e1150: vec4<f32> = (_e1146.xyzz * _e1148.xxxx);
                temporary13_.x = _e1150.x;
                temporary13_.y = _e1150.y;
                temporary13_.z = _e1150.z;
                let _e1157: vec4<f32> = temporary5_;
                let _e1159: vec4<f32> = temporary13_;
                let _e1161: vec4<f32> = (_e1157.xyzz + _e1159.xyzz);
                temporary12_.x = _e1161.x;
                temporary12_.y = _e1161.y;
                temporary12_.z = _e1161.z;
                let _e1168: vec4<f32> = temporary12_;
                let _e1170: vec4<f32> = temporary8_;
                let _e1172: vec4<f32> = (_e1168.xyzz - _e1170.xyzz);
                temporary14_.x = _e1172.x;
                temporary14_.y = _e1172.y;
                temporary14_.z = _e1172.z;
                let _e1179: vec4<f32> = temporary14_;
                let _e1181: vec3<f32> = normalize(_e1179.xyz);
                temporary16_.x = _e1181.x;
                temporary16_.y = _e1181.y;
                temporary16_.z = _e1181.z;
                let _e1188: vec4<f32> = temporary16_;
                let _e1189: vec4<f32> = _e1188.xyzz;
                temporary20_.x = _e1189.x;
                temporary20_.y = _e1189.y;
                temporary20_.z = _e1189.z;
                let _e1196: vec4<f32> = temporary20_;
                let _e1197: vec4<f32> = _e1196.xyzz;
                temporary17_.x = _e1197.x;
                temporary17_.y = _e1197.y;
                temporary17_.z = _e1197.z;
            }
        }
        let _e1204: vec4<f32> = temporary15_;
        temporary4_.y = _e1204.yyyy.x;
        let _e1208: vec4<f32> = temporary17_;
        let _e1209: vec4<f32> = _e1208.xyzz;
        temporary3_.x = _e1209.x;
        temporary3_.y = _e1209.y;
        temporary3_.z = _e1209.z;
        let _e1216: vec4<f32> = temporary4_;
        let _e1218: vec4<f32> = temporary4_;
        temporary1_.y = f32((_e1216.yyyy.x < _e1218.zzzz.x));
        let _e1225: vec4<f32> = temporary1_;
        let _e1229: vec4<f32> = constant_registers[16u];
        if all((_e1225.yyyy != _e1229.xxxx)) {
            let _e1233: vec4<f32> = temporary4_;
            temporary4_.z = _e1233.yyyy.x;
            let _e1237: vec4<f32> = temporary3_;
            let _e1238: vec4<f32> = _e1237.xyzz;
            temporary6_.x = _e1238.x;
            temporary6_.y = _e1238.y;
            temporary6_.z = _e1238.z;
            let _e1247: vec4<f32> = constant_registers[11u];
            let _e1248: vec4<f32> = _e1247.xyzz;
            temporary7_.x = _e1248.x;
            temporary7_.y = _e1248.y;
            temporary7_.z = _e1248.z;
            let _e1257: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e1257.xxxx.x;
        }
        let _e1261: vec4<f32> = temporary11_;
        let _e1265: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e1261.yyyy + _e1265.yyyy).x;
        let _e1270: vec4<f32> = temporary1_;
        let _e1274: vec4<f32> = constant_registers[16u];
        temporary1_.y = f32((_e1270.zzzz.x == _e1274.xxxx.x));
        let _e1281: vec4<f32> = temporary1_;
        let _e1285: vec4<f32> = constant_registers[16u];
        if all((_e1281.yyyy != _e1285.xxxx)) {
            let _e1291: vec4<f32> = constant_registers[16u];
            let _e1292: vec4<f32> = _e1291.xyyy;
            temporary11_.x = _e1292.x;
            temporary11_.z = _e1292.z;
        } else {
            let _e1297: vec4<f32> = temporary9_;
            let _e1299: vec4<f32> = temporary4_;
            let _e1301: vec4<f32> = (_e1297.xyzz * _e1299.zzzz);
            temporary5_.x = _e1301.x;
            temporary5_.y = _e1301.y;
            temporary5_.z = _e1301.z;
            let _e1308: vec4<f32> = temporary2_;
            let _e1310: vec4<f32> = temporary5_;
            let _e1312: vec4<f32> = (_e1308.xyzz + _e1310.xyzz);
            temporary2_.x = _e1312.x;
            temporary2_.y = _e1312.y;
            temporary2_.z = _e1312.z;
            let _e1319: vec4<f32> = temporary9_;
            let _e1321: vec4<f32> = temporary6_;
            temporary1_.y = dot(_e1319.xyz, _e1321.xyz);
            let _e1325: vec4<f32> = temporary1_;
            let _e1329: vec4<f32> = constant_registers[18u];
            temporary5_.x = (_e1325.yyyy * _e1329.xxxx).x;
            let _e1334: vec4<f32> = temporary5_;
            let _e1336: vec4<f32> = temporary6_;
            let _e1338: vec4<f32> = (_e1334.xxxx * _e1336.xyzz);
            temporary10_.x = _e1338.x;
            temporary10_.y = _e1338.y;
            temporary10_.z = _e1338.z;
            let _e1345: vec4<f32> = temporary9_;
            let _e1347: vec4<f32> = temporary10_;
            let _e1349: vec4<f32> = (_e1345.xyzz - _e1347.xyzz);
            temporary9_.x = _e1349.x;
            temporary9_.y = _e1349.y;
            temporary9_.z = _e1349.z;
            let _e1356: vec4<f32> = temporary9_;
            let _e1360: vec4<f32> = constant_registers[18u];
            let _e1362: vec4<f32> = (_e1356.xyzz * _e1360.yyyy);
            temporary5_.x = _e1362.x;
            temporary5_.y = _e1362.y;
            temporary5_.z = _e1362.z;
            let _e1369: vec4<f32> = temporary2_;
            let _e1371: vec4<f32> = temporary5_;
            let _e1373: vec4<f32> = (_e1369.xyzz + _e1371.xyzz);
            temporary2_.x = _e1373.x;
            temporary2_.y = _e1373.y;
            temporary2_.z = _e1373.z;
            let _e1382: vec4<f32> = constant_registers[15u];
            let _e1384: vec4<f32> = temporary2_;
            let _e1386: vec4<f32> = (_e1382.xyzz - _e1384.xyzz);
            temporary5_.x = _e1386.x;
            temporary5_.y = _e1386.y;
            temporary5_.z = _e1386.z;
            let _e1393: vec4<f32> = temporary5_;
            let _e1395: vec3<f32> = normalize(_e1393.xyz);
            temporary10_.x = _e1395.x;
            temporary10_.y = _e1395.y;
            temporary10_.z = _e1395.z;
            let _e1402: vec4<f32> = temporary5_;
            let _e1404: vec4<f32> = temporary5_;
            temporary8_.x = dot(_e1402.xyz, _e1404.xyz);
            let _e1408: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e1408.xxxx).x;
            let _e1413: vec4<f32> = temporary6_;
            let _e1415: vec4<f32> = temporary10_;
            temporary8_.y = dot(_e1413.xyz, _e1415.xyz);
            let _e1419: vec4<f32> = temporary8_;
            temporary8_.z = saturate(_e1419.yyyy).x;
            let _e1424: vec4<f32> = temporary1_;
            let _e1426: vec4<f32> = temporary1_;
            temporary2_.w = (_e1424.yyyy * _e1426.yyyy).x;
            let _e1431: vec4<f32> = temporary2_;
            let _e1435: vec4<f32> = constant_registers[18u];
            temporary15_.x = (_e1431.wwww * _e1435.zzzz).x;
            let _e1442: vec4<f32> = constant_registers[18u];
            let _e1444: vec4<f32> = temporary15_;
            temporary15_.y = (_e1442.wwww + _e1444.xxxx).x;
            let _e1449: vec4<f32> = temporary8_;
            let _e1451: vec4<f32> = temporary15_;
            temporary8_.x = (_e1449.zzzz / _e1451.yyyy).x;
            let _e1458: vec4<f32> = constant_registers[6u];
            temporary8_.z = _e1458.xxxx.x;
            let _e1464: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1464.wwww.x;
            let _e1468: vec4<f32> = temporary2_;
            let _e1472: vec4<f32> = constant_registers[4u];
            let _e1474: vec4<f32> = (_e1468.xyzz - _e1472.xyzz);
            temporary19_.x = _e1474.x;
            temporary19_.y = _e1474.y;
            temporary19_.z = _e1474.z;
            let _e1481: vec4<f32> = temporary19_;
            let _e1483: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1481.xyz, _e1483.xyz);
            let _e1487: vec4<f32> = temporary13_;
            let _e1489: vec4<f32> = temporary13_;
            temporary13_.z = (_e1487.xxxx * _e1489.xxxx).x;
            let _e1494: vec4<f32> = temporary19_;
            let _e1496: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1494.xyz, _e1496.xyz);
            let _e1500: vec4<f32> = temporary13_;
            let _e1502: vec4<f32> = temporary3_;
            temporary12_.x = (_e1500.zzzz - _e1502.wwww).x;
            let _e1507: vec4<f32> = temporary8_;
            let _e1509: vec4<f32> = temporary8_;
            temporary12_.y = (_e1507.zzzz * _e1509.zzzz).x;
            let _e1514: vec4<f32> = temporary12_;
            let _e1516: vec4<f32> = temporary12_;
            temporary13_.y = (_e1514.xxxx + _e1516.yyyy).x;
            let _e1523: vec4<f32> = constant_registers[16u];
            let _e1525: vec4<f32> = temporary13_;
            temporary13_.z = f32((_e1523.xxxx.x < _e1525.yyyy.x));
            let _e1532: vec4<f32> = temporary13_;
            let _e1536: vec4<f32> = constant_registers[16u];
            if all((_e1532.zzzz != _e1536.xxxx)) {
                let _e1540: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1540.yyyy).x;
                let _e1545: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1545.xxxx).x;
                let _e1550: vec4<f32> = temporary3_;
                let _e1552: vec4<f32> = temporary13_;
                temporary13_.z = (_e1550.wwww - _e1552.yyyy).x;
                let _e1559: vec4<f32> = constant_registers[16u];
                let _e1561: vec4<f32> = temporary13_;
                temporary3_.w = f32((_e1559.xxxx.x < _e1561.zzzz.x));
                let _e1568: vec4<f32> = temporary3_;
                let _e1572: vec4<f32> = constant_registers[16u];
                if all((_e1568.wwww != _e1572.xxxx)) {
                    let _e1576: vec4<f32> = temporary13_;
                    temporary2_.w = _e1576.zzzz.x;
                }
            }
            let _e1580: vec4<f32> = temporary2_;
            let _e1582: vec4<f32> = temporary1_;
            temporary8_.y = f32((_e1580.wwww.x < _e1582.yyyy.x));
            let _e1589: vec4<f32> = temporary8_;
            let _e1593: vec4<f32> = constant_registers[16u];
            if all((_e1589.yyyy != _e1593.xxxx)) {
                let _e1599: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1599.xxxx.x;
            }
            let _e1605: vec4<f32> = constant_registers[9u];
            temporary8_.z = _e1605.xxxx.x;
            let _e1611: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1611.wwww.x;
            let _e1615: vec4<f32> = temporary2_;
            let _e1619: vec4<f32> = constant_registers[7u];
            let _e1621: vec4<f32> = (_e1615.xyzz - _e1619.xyzz);
            temporary19_.x = _e1621.x;
            temporary19_.y = _e1621.y;
            temporary19_.z = _e1621.z;
            let _e1628: vec4<f32> = temporary19_;
            let _e1630: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1628.xyz, _e1630.xyz);
            let _e1634: vec4<f32> = temporary13_;
            let _e1636: vec4<f32> = temporary13_;
            temporary13_.z = (_e1634.xxxx * _e1636.xxxx).x;
            let _e1641: vec4<f32> = temporary19_;
            let _e1643: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1641.xyz, _e1643.xyz);
            let _e1647: vec4<f32> = temporary13_;
            let _e1649: vec4<f32> = temporary3_;
            temporary12_.x = (_e1647.zzzz - _e1649.wwww).x;
            let _e1654: vec4<f32> = temporary8_;
            let _e1656: vec4<f32> = temporary8_;
            temporary12_.y = (_e1654.zzzz * _e1656.zzzz).x;
            let _e1661: vec4<f32> = temporary12_;
            let _e1663: vec4<f32> = temporary12_;
            temporary13_.y = (_e1661.xxxx + _e1663.yyyy).x;
            let _e1670: vec4<f32> = constant_registers[16u];
            let _e1672: vec4<f32> = temporary13_;
            temporary13_.z = f32((_e1670.xxxx.x < _e1672.yyyy.x));
            let _e1679: vec4<f32> = temporary13_;
            let _e1683: vec4<f32> = constant_registers[16u];
            if all((_e1679.zzzz != _e1683.xxxx)) {
                let _e1687: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1687.yyyy).x;
                let _e1692: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1692.xxxx).x;
                let _e1697: vec4<f32> = temporary3_;
                let _e1699: vec4<f32> = temporary13_;
                temporary13_.z = (_e1697.wwww - _e1699.yyyy).x;
                let _e1706: vec4<f32> = constant_registers[16u];
                let _e1708: vec4<f32> = temporary13_;
                temporary3_.w = f32((_e1706.xxxx.x < _e1708.zzzz.x));
                let _e1715: vec4<f32> = temporary3_;
                let _e1719: vec4<f32> = constant_registers[16u];
                if all((_e1715.wwww != _e1719.xxxx)) {
                    let _e1723: vec4<f32> = temporary13_;
                    temporary2_.w = _e1723.zzzz.x;
                }
            }
            let _e1727: vec4<f32> = temporary2_;
            let _e1729: vec4<f32> = temporary1_;
            temporary8_.y = f32((_e1727.wwww.x < _e1729.yyyy.x));
            let _e1736: vec4<f32> = temporary8_;
            let _e1740: vec4<f32> = constant_registers[16u];
            if all((_e1736.yyyy != _e1740.xxxx)) {
                let _e1746: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1746.xxxx.x;
            }
            let _e1750: vec4<f32> = temporary2_;
            let _e1751: vec4<f32> = _e1750.xyzz;
            temporary15_.x = _e1751.x;
            temporary15_.y = _e1751.y;
            temporary15_.z = _e1751.z;
            let _e1758: vec4<f32> = temporary10_;
            let _e1759: vec4<f32> = _e1758.xyzz;
            temporary17_.x = _e1759.x;
            temporary17_.y = _e1759.y;
            temporary17_.z = _e1759.z;
            let _e1768: vec4<f32> = constant_registers[10u];
            let _e1769: vec4<f32> = _e1768.xyzz;
            temporary18_.x = _e1769.x;
            temporary18_.y = _e1769.y;
            temporary18_.z = _e1769.z;
            let _e1778: vec4<f32> = constant_registers[12u];
            temporary8_.z = _e1778.xxxx.x;
            let _e1784: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1784.wwww.x;
            let _e1788: vec4<f32> = temporary15_;
            let _e1790: vec4<f32> = temporary18_;
            let _e1792: vec4<f32> = (_e1788.xyzz - _e1790.xyzz);
            temporary19_.x = _e1792.x;
            temporary19_.y = _e1792.y;
            temporary19_.z = _e1792.z;
            let _e1799: vec4<f32> = temporary19_;
            let _e1801: vec4<f32> = temporary17_;
            temporary13_.x = dot(_e1799.xyz, _e1801.xyz);
            let _e1805: vec4<f32> = temporary13_;
            let _e1807: vec4<f32> = temporary13_;
            temporary13_.z = (_e1805.xxxx * _e1807.xxxx).x;
            let _e1812: vec4<f32> = temporary19_;
            let _e1814: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1812.xyz, _e1814.xyz);
            let _e1818: vec4<f32> = temporary13_;
            let _e1820: vec4<f32> = temporary3_;
            temporary12_.x = (_e1818.zzzz - _e1820.wwww).x;
            let _e1825: vec4<f32> = temporary8_;
            let _e1827: vec4<f32> = temporary8_;
            temporary12_.y = (_e1825.zzzz * _e1827.zzzz).x;
            let _e1832: vec4<f32> = temporary12_;
            let _e1834: vec4<f32> = temporary12_;
            temporary12_.z = (_e1832.xxxx + _e1834.yyyy).x;
            let _e1839: vec4<f32> = temporary12_;
            temporary13_.y = _e1839.zzzz.x;
            let _e1845: vec4<f32> = constant_registers[16u];
            let _e1847: vec4<f32> = temporary13_;
            temporary13_.z = f32((_e1845.xxxx.x < _e1847.yyyy.x));
            let _e1854: vec4<f32> = temporary13_;
            let _e1858: vec4<f32> = constant_registers[16u];
            if all((_e1854.zzzz != _e1858.xxxx)) {
                let _e1862: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1862.yyyy).x;
                let _e1867: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1867.xxxx).x;
                let _e1872: vec4<f32> = temporary3_;
                let _e1874: vec4<f32> = temporary13_;
                temporary12_.x = (_e1872.wwww - _e1874.yyyy).x;
                let _e1879: vec4<f32> = temporary12_;
                temporary13_.z = _e1879.xxxx.x;
                let _e1885: vec4<f32> = constant_registers[16u];
                let _e1887: vec4<f32> = temporary13_;
                temporary3_.w = f32((_e1885.xxxx.x < _e1887.zzzz.x));
                let _e1894: vec4<f32> = temporary3_;
                let _e1898: vec4<f32> = constant_registers[16u];
                if all((_e1894.wwww != _e1898.xxxx)) {
                    let _e1902: vec4<f32> = temporary13_;
                    temporary2_.w = _e1902.zzzz.x;
                }
            }
            let _e1906: vec4<f32> = temporary2_;
            temporary4_.y = _e1906.wwww.x;
            let _e1910: vec4<f32> = temporary4_;
            let _e1912: vec4<f32> = temporary1_;
            temporary8_.y = f32((_e1910.yyyy.x < _e1912.yyyy.x));
            let _e1919: vec4<f32> = temporary8_;
            let _e1923: vec4<f32> = constant_registers[16u];
            if all((_e1919.yyyy != _e1923.xxxx)) {
                let _e1929: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1929.xxxx.x;
            }
            let _e1933: vec4<f32> = temporary6_;
            temporary8_.y = saturate(_e1933.yyyy).x;
            let _e1938: vec4<f32> = temporary8_;
            let _e1942: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1938.yyyy * _e1942.xxxx).x;
            let _e1947: vec4<f32> = temporary8_;
            let _e1949: vec4<f32> = temporary8_;
            temporary8_.x = (_e1947.xxxx + _e1949.zzzz).x;
            let _e1954: vec4<f32> = temporary8_;
            let _e1958: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1954.xxxx * _e1958.yyyy).x;
            let _e1965: vec4<f32> = constant_registers[19u];
            let _e1967: vec4<f32> = temporary8_;
            temporary2_.w = (_e1965.zzzz + _e1967.zzzz).x;
            let _e1972: vec4<f32> = temporary2_;
            temporary8_.y = _e1972.wwww.x;
            let _e1976: vec4<f32> = temporary1_;
            let _e1980: vec4<f32> = constant_registers[16u];
            temporary8_.z = f32((_e1976.zzzz.x == _e1980.yyyy.x));
            let _e1987: vec4<f32> = temporary8_;
            let _e1991: vec4<f32> = constant_registers[16u];
            if all((_e1987.zzzz != _e1991.xxxx)) {
                let _e1995: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e1995.xxxx).x;
                let _e2000: vec4<f32> = temporary2_;
                let _e2002: vec4<f32> = temporary8_;
                temporary2_.w = (_e2000.xxxx - _e2002.zzzz).x;
                let _e2007: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e2007.zzzz).x;
                let _e2012: vec4<f32> = temporary2_;
                let _e2014: vec4<f32> = temporary15_;
                temporary15_.y = (_e2012.zzzz - _e2014.xxxx).x;
                let _e2019: vec4<f32> = temporary2_;
                let _e2021: vec4<f32> = temporary15_;
                temporary15_.z = (_e2019.wwww + _e2021.yyyy).x;
                let _e2026: vec4<f32> = temporary15_;
                let _e2030: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e2026.zzzz / _e2030.xxxx).x;
                let _e2035: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e2035.xxxx).x;
                let _e2040: vec4<f32> = temporary17_;
                let _e2044: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e2040.xxxx * _e2044.xxxx).x;
                let _e2049: vec4<f32> = temporary17_;
                let _e2053: vec4<f32> = constant_registers[16u];
                temporary17_.z = f32((_e2049.yyyy.x == _e2053.yyyy.x));
                let _e2060: vec4<f32> = temporary17_;
                let _e2064: vec4<f32> = constant_registers[16u];
                if all((_e2060.zzzz != _e2064.xxxx)) {
                    let _e2070: vec4<f32> = constant_registers[13u];
                    let _e2072: vec4<f32> = temporary8_;
                    let _e2074: vec4<f32> = (_e2070.xyzz * _e2072.yyyy);
                    temporary15_.x = _e2074.x;
                    temporary15_.y = _e2074.y;
                    temporary15_.z = _e2074.z;
                    let _e2081: vec4<f32> = temporary0_;
                    let _e2083: vec4<f32> = temporary15_;
                    let _e2085: vec4<f32> = (_e2081.xyzz + _e2083.xyzz);
                    temporary0_.x = _e2085.x;
                    temporary0_.y = _e2085.y;
                    temporary0_.z = _e2085.z;
                } else {
                    let _e2094: vec4<f32> = constant_registers[14u];
                    let _e2096: vec4<f32> = temporary8_;
                    let _e2098: vec4<f32> = (_e2094.xyzz * _e2096.yyyy);
                    temporary15_.x = _e2098.x;
                    temporary15_.y = _e2098.y;
                    temporary15_.z = _e2098.z;
                    let _e2105: vec4<f32> = temporary0_;
                    let _e2107: vec4<f32> = temporary15_;
                    let _e2109: vec4<f32> = (_e2105.xyzz + _e2107.xyzz);
                    temporary0_.x = _e2109.x;
                    temporary0_.y = _e2109.y;
                    temporary0_.z = _e2109.z;
                }
            }
            let _e2116: vec4<f32> = temporary1_;
            let _e2120: vec4<f32> = constant_registers[18u];
            temporary8_.z = f32((_e2116.zzzz.x == _e2120.xxxx.x));
            let _e2127: vec4<f32> = temporary8_;
            let _e2131: vec4<f32> = constant_registers[16u];
            if all((_e2127.zzzz != _e2131.xxxx)) {
                let _e2135: vec4<f32> = temporary7_;
                let _e2137: vec4<f32> = temporary8_;
                let _e2139: vec4<f32> = (_e2135.xyzz * _e2137.yyyy);
                temporary15_.x = _e2139.x;
                temporary15_.y = _e2139.y;
                temporary15_.z = _e2139.z;
                let _e2146: vec4<f32> = temporary0_;
                let _e2148: vec4<f32> = temporary15_;
                let _e2150: vec4<f32> = (_e2146.xyzz + _e2148.xyzz);
                temporary0_.x = _e2150.x;
                temporary0_.y = _e2150.y;
                temporary0_.z = _e2150.z;
            }
            let _e2159: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e2159.yyyy.x;
        }
    }
    let _e2163: vec4<f32> = temporary11_;
    let _e2167: vec4<f32> = constant_registers[16u];
    if all((_e2163.xxxx != _e2167.xxxx)) {
        let _e2173: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e2173.xxxx.x;
        let _e2179: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e2179.wwww.x;
        let _e2185: vec4<f32> = constant_registers[16u];
        let _e2186: vec4<f32> = _e2185.xyxx;
        temporary3_.x = _e2186.x;
        temporary3_.y = _e2186.y;
        temporary3_.z = _e2186.z;
        let _e2193: vec4<f32> = temporary3_;
        let _e2194: vec4<f32> = _e2193.xyzz;
        temporary12_.x = _e2194.x;
        temporary12_.y = _e2194.y;
        temporary12_.z = _e2194.z;
        let _e2203: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e2203.wwww.x;
        let _e2207: vec4<f32> = temporary2_;
        let _e2211: vec4<f32> = constant_registers[16u];
        let _e2213: vec4<f32> = (_e2207.xyzz - _e2211.xxxx);
        temporary20_.x = _e2213.x;
        temporary20_.y = _e2213.y;
        temporary20_.z = _e2213.z;
        let _e2220: vec4<f32> = temporary20_;
        let _e2222: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e2220.xyz, _e2222.xyz);
        let _e2226: vec4<f32> = temporary14_;
        temporary14_.z = -(_e2226.yyyy).x;
        let _e2231: vec4<f32> = temporary9_;
        let _e2233: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e2231.xyz, _e2233.xyz);
        let _e2237: vec4<f32> = temporary14_;
        let _e2239: vec4<f32> = temporary4_;
        temporary16_.x = (_e2237.zzzz / _e2239.xxxx).x;
        let _e2244: vec4<f32> = temporary16_;
        temporary14_.x = _e2244.xxxx.x;
        let _e2250: vec4<f32> = constant_registers[16u];
        let _e2252: vec4<f32> = temporary14_;
        temporary14_.y = f32((_e2250.xxxx.x < _e2252.xxxx.x));
        let _e2259: vec4<f32> = temporary14_;
        let _e2263: vec4<f32> = constant_registers[16u];
        if all((_e2259.yyyy != _e2263.xxxx)) {
            let _e2267: vec4<f32> = temporary14_;
            temporary2_.w = _e2267.xxxx.x;
        }
        let _e2271: vec4<f32> = temporary2_;
        temporary4_.y = _e2271.wwww.x;
        let _e2275: vec4<f32> = temporary4_;
        let _e2277: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e2275.yyyy.x < _e2277.zzzz.x));
        let _e2284: vec4<f32> = temporary8_;
        let _e2288: vec4<f32> = constant_registers[16u];
        if all((_e2284.zzzz != _e2288.xxxx)) {
            let _e2292: vec4<f32> = temporary4_;
            temporary4_.z = _e2292.yyyy.x;
            let _e2296: vec4<f32> = temporary3_;
            let _e2297: vec4<f32> = _e2296.xyzz;
            temporary6_.x = _e2297.x;
            temporary6_.y = _e2297.y;
            temporary6_.z = _e2297.z;
            let _e2306: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e2306.yyyy.x;
        }
        let _e2310: vec4<f32> = temporary2_;
        let _e2311: vec4<f32> = _e2310.xyzz;
        temporary15_.x = _e2311.x;
        temporary15_.y = _e2311.y;
        temporary15_.z = _e2311.z;
        let _e2318: vec4<f32> = temporary9_;
        let _e2319: vec4<f32> = _e2318.xyzz;
        temporary17_.x = _e2319.x;
        temporary17_.y = _e2319.y;
        temporary17_.z = _e2319.z;
        let _e2328: vec4<f32> = constant_registers[4u];
        let _e2329: vec4<f32> = _e2328.xyzz;
        temporary18_.x = _e2329.x;
        temporary18_.y = _e2329.y;
        temporary18_.z = _e2329.z;
        let _e2338: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e2338.xxxx.x;
        let _e2342: vec4<f32> = temporary3_;
        let _e2343: vec4<f32> = _e2342.xyzz;
        temporary19_.x = _e2343.x;
        temporary19_.y = _e2343.y;
        temporary19_.z = _e2343.z;
        let _e2352: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2352.wwww.x;
        let _e2356: vec4<f32> = temporary15_;
        let _e2358: vec4<f32> = temporary18_;
        let _e2360: vec4<f32> = (_e2356.xyzz - _e2358.xyzz);
        temporary12_.x = _e2360.x;
        temporary12_.y = _e2360.y;
        temporary12_.z = _e2360.z;
        let _e2367: vec4<f32> = temporary12_;
        let _e2369: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2367.xyz, _e2369.xyz);
        let _e2373: vec4<f32> = temporary13_;
        let _e2375: vec4<f32> = temporary13_;
        temporary3_.w = (_e2373.yyyy * _e2375.yyyy).x;
        let _e2380: vec4<f32> = temporary12_;
        let _e2382: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2380.xyz, _e2382.xyz);
        let _e2386: vec4<f32> = temporary3_;
        let _e2388: vec4<f32> = temporary14_;
        temporary14_.y = (_e2386.wwww - _e2388.xxxx).x;
        let _e2393: vec4<f32> = temporary2_;
        let _e2395: vec4<f32> = temporary2_;
        temporary14_.z = (_e2393.wwww * _e2395.wwww).x;
        let _e2400: vec4<f32> = temporary14_;
        let _e2402: vec4<f32> = temporary14_;
        temporary13_.z = (_e2400.yyyy + _e2402.zzzz).x;
        let _e2409: vec4<f32> = constant_registers[16u];
        let _e2411: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e2409.xxxx.x < _e2411.zzzz.x));
        let _e2418: vec4<f32> = temporary3_;
        let _e2422: vec4<f32> = constant_registers[16u];
        if all((_e2418.wwww != _e2422.xxxx)) {
            let _e2426: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2426.zzzz).x;
            let _e2431: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2431.yyyy).x;
            let _e2436: vec4<f32> = temporary14_;
            let _e2438: vec4<f32> = temporary13_;
            temporary14_.y = (_e2436.xxxx - _e2438.zzzz).x;
            let _e2443: vec4<f32> = temporary14_;
            temporary3_.w = _e2443.yyyy.x;
            let _e2449: vec4<f32> = constant_registers[16u];
            let _e2451: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e2449.xxxx.x < _e2451.wwww.x));
            let _e2458: vec4<f32> = temporary14_;
            let _e2462: vec4<f32> = constant_registers[16u];
            if all((_e2458.xxxx != _e2462.xxxx)) {
                let _e2466: vec4<f32> = temporary3_;
                temporary13_.x = _e2466.wwww.x;
                let _e2470: vec4<f32> = temporary17_;
                let _e2472: vec4<f32> = temporary3_;
                let _e2474: vec4<f32> = (_e2470.xyzz * _e2472.wwww);
                temporary14_.x = _e2474.x;
                temporary14_.y = _e2474.y;
                temporary14_.z = _e2474.z;
                let _e2481: vec4<f32> = temporary15_;
                let _e2483: vec4<f32> = temporary14_;
                let _e2485: vec4<f32> = (_e2481.xyzz + _e2483.xyzz);
                temporary20_.x = _e2485.x;
                temporary20_.y = _e2485.y;
                temporary20_.z = _e2485.z;
                let _e2492: vec4<f32> = temporary20_;
                let _e2494: vec4<f32> = temporary18_;
                let _e2496: vec4<f32> = (_e2492.xyzz - _e2494.xyzz);
                temporary16_.x = _e2496.x;
                temporary16_.y = _e2496.y;
                temporary16_.z = _e2496.z;
                let _e2503: vec4<f32> = temporary16_;
                let _e2505: vec3<f32> = normalize(_e2503.xyz);
                temporary19_.x = _e2505.x;
                temporary19_.y = _e2505.y;
                temporary19_.z = _e2505.z;
            }
        }
        let _e2512: vec4<f32> = temporary13_;
        temporary4_.y = _e2512.xxxx.x;
        let _e2516: vec4<f32> = temporary19_;
        let _e2517: vec4<f32> = _e2516.xyzz;
        temporary3_.x = _e2517.x;
        temporary3_.y = _e2517.y;
        temporary3_.z = _e2517.z;
        let _e2524: vec4<f32> = temporary4_;
        let _e2526: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e2524.yyyy.x < _e2526.zzzz.x));
        let _e2533: vec4<f32> = temporary8_;
        let _e2537: vec4<f32> = constant_registers[16u];
        if all((_e2533.zzzz != _e2537.xxxx)) {
            let _e2541: vec4<f32> = temporary4_;
            temporary4_.z = _e2541.yyyy.x;
            let _e2545: vec4<f32> = temporary3_;
            let _e2546: vec4<f32> = _e2545.xyzz;
            temporary6_.x = _e2546.x;
            temporary6_.y = _e2546.y;
            temporary6_.z = _e2546.z;
            let _e2555: vec4<f32> = constant_registers[5u];
            let _e2556: vec4<f32> = _e2555.xyzz;
            temporary7_.x = _e2556.x;
            temporary7_.y = _e2556.y;
            temporary7_.z = _e2556.z;
            let _e2565: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2565.xxxx.x;
        }
        let _e2569: vec4<f32> = temporary2_;
        let _e2570: vec4<f32> = _e2569.xyzz;
        temporary15_.x = _e2570.x;
        temporary15_.y = _e2570.y;
        temporary15_.z = _e2570.z;
        let _e2577: vec4<f32> = temporary9_;
        let _e2578: vec4<f32> = _e2577.xyzz;
        temporary17_.x = _e2578.x;
        temporary17_.y = _e2578.y;
        temporary17_.z = _e2578.z;
        let _e2587: vec4<f32> = constant_registers[7u];
        let _e2588: vec4<f32> = _e2587.xyzz;
        temporary18_.x = _e2588.x;
        temporary18_.y = _e2588.y;
        temporary18_.z = _e2588.z;
        let _e2597: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e2597.xxxx.x;
        let _e2601: vec4<f32> = temporary3_;
        let _e2602: vec4<f32> = _e2601.xyzz;
        temporary19_.x = _e2602.x;
        temporary19_.y = _e2602.y;
        temporary19_.z = _e2602.z;
        let _e2611: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2611.wwww.x;
        let _e2615: vec4<f32> = temporary15_;
        let _e2617: vec4<f32> = temporary18_;
        let _e2619: vec4<f32> = (_e2615.xyzz - _e2617.xyzz);
        temporary12_.x = _e2619.x;
        temporary12_.y = _e2619.y;
        temporary12_.z = _e2619.z;
        let _e2626: vec4<f32> = temporary12_;
        let _e2628: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2626.xyz, _e2628.xyz);
        let _e2632: vec4<f32> = temporary13_;
        let _e2634: vec4<f32> = temporary13_;
        temporary3_.w = (_e2632.yyyy * _e2634.yyyy).x;
        let _e2639: vec4<f32> = temporary12_;
        let _e2641: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2639.xyz, _e2641.xyz);
        let _e2645: vec4<f32> = temporary3_;
        let _e2647: vec4<f32> = temporary14_;
        temporary14_.y = (_e2645.wwww - _e2647.xxxx).x;
        let _e2652: vec4<f32> = temporary2_;
        let _e2654: vec4<f32> = temporary2_;
        temporary14_.z = (_e2652.wwww * _e2654.wwww).x;
        let _e2659: vec4<f32> = temporary14_;
        let _e2661: vec4<f32> = temporary14_;
        temporary13_.z = (_e2659.yyyy + _e2661.zzzz).x;
        let _e2668: vec4<f32> = constant_registers[16u];
        let _e2670: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e2668.xxxx.x < _e2670.zzzz.x));
        let _e2677: vec4<f32> = temporary3_;
        let _e2681: vec4<f32> = constant_registers[16u];
        if all((_e2677.wwww != _e2681.xxxx)) {
            let _e2685: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2685.zzzz).x;
            let _e2690: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2690.yyyy).x;
            let _e2695: vec4<f32> = temporary14_;
            let _e2697: vec4<f32> = temporary13_;
            temporary14_.y = (_e2695.xxxx - _e2697.zzzz).x;
            let _e2702: vec4<f32> = temporary14_;
            temporary3_.w = _e2702.yyyy.x;
            let _e2708: vec4<f32> = constant_registers[16u];
            let _e2710: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e2708.xxxx.x < _e2710.wwww.x));
            let _e2717: vec4<f32> = temporary14_;
            let _e2721: vec4<f32> = constant_registers[16u];
            if all((_e2717.xxxx != _e2721.xxxx)) {
                let _e2725: vec4<f32> = temporary3_;
                temporary13_.x = _e2725.wwww.x;
                let _e2729: vec4<f32> = temporary17_;
                let _e2731: vec4<f32> = temporary3_;
                let _e2733: vec4<f32> = (_e2729.xyzz * _e2731.wwww);
                temporary14_.x = _e2733.x;
                temporary14_.y = _e2733.y;
                temporary14_.z = _e2733.z;
                let _e2740: vec4<f32> = temporary15_;
                let _e2742: vec4<f32> = temporary14_;
                let _e2744: vec4<f32> = (_e2740.xyzz + _e2742.xyzz);
                temporary20_.x = _e2744.x;
                temporary20_.y = _e2744.y;
                temporary20_.z = _e2744.z;
                let _e2751: vec4<f32> = temporary20_;
                let _e2753: vec4<f32> = temporary18_;
                let _e2755: vec4<f32> = (_e2751.xyzz - _e2753.xyzz);
                temporary16_.x = _e2755.x;
                temporary16_.y = _e2755.y;
                temporary16_.z = _e2755.z;
                let _e2762: vec4<f32> = temporary16_;
                let _e2764: vec3<f32> = normalize(_e2762.xyz);
                temporary19_.x = _e2764.x;
                temporary19_.y = _e2764.y;
                temporary19_.z = _e2764.z;
            }
        }
        let _e2771: vec4<f32> = temporary13_;
        temporary4_.y = _e2771.xxxx.x;
        let _e2775: vec4<f32> = temporary19_;
        let _e2776: vec4<f32> = _e2775.xyzz;
        temporary3_.x = _e2776.x;
        temporary3_.y = _e2776.y;
        temporary3_.z = _e2776.z;
        let _e2783: vec4<f32> = temporary4_;
        let _e2785: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e2783.yyyy.x < _e2785.zzzz.x));
        let _e2792: vec4<f32> = temporary8_;
        let _e2796: vec4<f32> = constant_registers[16u];
        if all((_e2792.zzzz != _e2796.xxxx)) {
            let _e2800: vec4<f32> = temporary4_;
            temporary4_.z = _e2800.yyyy.x;
            let _e2804: vec4<f32> = temporary3_;
            let _e2805: vec4<f32> = _e2804.xyzz;
            temporary6_.x = _e2805.x;
            temporary6_.y = _e2805.y;
            temporary6_.z = _e2805.z;
            let _e2814: vec4<f32> = constant_registers[8u];
            let _e2815: vec4<f32> = _e2814.xyzz;
            temporary7_.x = _e2815.x;
            temporary7_.y = _e2815.y;
            temporary7_.z = _e2815.z;
            let _e2824: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2824.xxxx.x;
        }
        let _e2828: vec4<f32> = temporary2_;
        let _e2829: vec4<f32> = _e2828.xyzz;
        temporary15_.x = _e2829.x;
        temporary15_.y = _e2829.y;
        temporary15_.z = _e2829.z;
        let _e2836: vec4<f32> = temporary9_;
        let _e2837: vec4<f32> = _e2836.xyzz;
        temporary17_.x = _e2837.x;
        temporary17_.y = _e2837.y;
        temporary17_.z = _e2837.z;
        let _e2846: vec4<f32> = constant_registers[10u];
        let _e2847: vec4<f32> = _e2846.xyzz;
        temporary18_.x = _e2847.x;
        temporary18_.y = _e2847.y;
        temporary18_.z = _e2847.z;
        let _e2856: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e2856.xxxx.x;
        let _e2860: vec4<f32> = temporary3_;
        let _e2861: vec4<f32> = _e2860.xyzz;
        temporary19_.x = _e2861.x;
        temporary19_.y = _e2861.y;
        temporary19_.z = _e2861.z;
        let _e2870: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2870.wwww.x;
        let _e2874: vec4<f32> = temporary15_;
        let _e2876: vec4<f32> = temporary18_;
        let _e2878: vec4<f32> = (_e2874.xyzz - _e2876.xyzz);
        temporary12_.x = _e2878.x;
        temporary12_.y = _e2878.y;
        temporary12_.z = _e2878.z;
        let _e2885: vec4<f32> = temporary12_;
        let _e2887: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2885.xyz, _e2887.xyz);
        let _e2891: vec4<f32> = temporary13_;
        let _e2893: vec4<f32> = temporary13_;
        temporary3_.w = (_e2891.yyyy * _e2893.yyyy).x;
        let _e2898: vec4<f32> = temporary12_;
        let _e2900: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2898.xyz, _e2900.xyz);
        let _e2904: vec4<f32> = temporary3_;
        let _e2906: vec4<f32> = temporary14_;
        temporary14_.y = (_e2904.wwww - _e2906.xxxx).x;
        let _e2911: vec4<f32> = temporary2_;
        let _e2913: vec4<f32> = temporary2_;
        temporary14_.z = (_e2911.wwww * _e2913.wwww).x;
        let _e2918: vec4<f32> = temporary14_;
        let _e2920: vec4<f32> = temporary14_;
        temporary4_.x = (_e2918.yyyy + _e2920.zzzz).x;
        let _e2925: vec4<f32> = temporary4_;
        temporary13_.z = _e2925.xxxx.x;
        let _e2931: vec4<f32> = constant_registers[16u];
        let _e2933: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e2931.xxxx.x < _e2933.zzzz.x));
        let _e2940: vec4<f32> = temporary3_;
        let _e2944: vec4<f32> = constant_registers[16u];
        if all((_e2940.wwww != _e2944.xxxx)) {
            let _e2948: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2948.zzzz).x;
            let _e2953: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2953.yyyy).x;
            let _e2958: vec4<f32> = temporary14_;
            let _e2960: vec4<f32> = temporary13_;
            temporary14_.y = (_e2958.xxxx - _e2960.zzzz).x;
            let _e2965: vec4<f32> = temporary14_;
            temporary3_.w = _e2965.yyyy.x;
            let _e2971: vec4<f32> = constant_registers[16u];
            let _e2973: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e2971.xxxx.x < _e2973.wwww.x));
            let _e2980: vec4<f32> = temporary14_;
            let _e2984: vec4<f32> = constant_registers[16u];
            if all((_e2980.xxxx != _e2984.xxxx)) {
                let _e2988: vec4<f32> = temporary3_;
                temporary13_.x = _e2988.wwww.x;
                let _e2992: vec4<f32> = temporary17_;
                let _e2994: vec4<f32> = temporary3_;
                let _e2996: vec4<f32> = (_e2992.xyzz * _e2994.wwww);
                temporary14_.x = _e2996.x;
                temporary14_.y = _e2996.y;
                temporary14_.z = _e2996.z;
                let _e3003: vec4<f32> = temporary15_;
                let _e3005: vec4<f32> = temporary14_;
                let _e3007: vec4<f32> = (_e3003.xyzz + _e3005.xyzz);
                temporary20_.x = _e3007.x;
                temporary20_.y = _e3007.y;
                temporary20_.z = _e3007.z;
                let _e3014: vec4<f32> = temporary20_;
                let _e3016: vec4<f32> = temporary18_;
                let _e3018: vec4<f32> = (_e3014.xyzz - _e3016.xyzz);
                temporary16_.x = _e3018.x;
                temporary16_.y = _e3018.y;
                temporary16_.z = _e3018.z;
                let _e3025: vec4<f32> = temporary16_;
                let _e3027: vec3<f32> = normalize(_e3025.xyz);
                temporary19_.x = _e3027.x;
                temporary19_.y = _e3027.y;
                temporary19_.z = _e3027.z;
            }
        }
        let _e3034: vec4<f32> = temporary13_;
        temporary4_.y = _e3034.xxxx.x;
        let _e3038: vec4<f32> = temporary19_;
        let _e3039: vec4<f32> = _e3038.xyzz;
        temporary3_.x = _e3039.x;
        temporary3_.y = _e3039.y;
        temporary3_.z = _e3039.z;
        let _e3046: vec4<f32> = temporary4_;
        let _e3048: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e3046.yyyy.x < _e3048.zzzz.x));
        let _e3055: vec4<f32> = temporary8_;
        let _e3059: vec4<f32> = constant_registers[16u];
        if all((_e3055.zzzz != _e3059.xxxx)) {
            let _e3063: vec4<f32> = temporary4_;
            temporary4_.z = _e3063.yyyy.x;
            let _e3067: vec4<f32> = temporary3_;
            let _e3068: vec4<f32> = _e3067.xyzz;
            temporary6_.x = _e3068.x;
            temporary6_.y = _e3068.y;
            temporary6_.z = _e3068.z;
            let _e3077: vec4<f32> = constant_registers[11u];
            let _e3078: vec4<f32> = _e3077.xyzz;
            temporary7_.x = _e3078.x;
            temporary7_.y = _e3078.y;
            temporary7_.z = _e3078.z;
            let _e3087: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e3087.xxxx.x;
        }
        let _e3091: vec4<f32> = temporary11_;
        let _e3095: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e3091.yyyy + _e3095.yyyy).x;
        let _e3100: vec4<f32> = temporary1_;
        let _e3104: vec4<f32> = constant_registers[16u];
        temporary8_.z = f32((_e3100.zzzz.x == _e3104.xxxx.x));
        let _e3111: vec4<f32> = temporary8_;
        let _e3115: vec4<f32> = constant_registers[16u];
        if all((_e3111.zzzz != _e3115.xxxx)) {
            let _e3121: vec4<f32> = constant_registers[16u];
            let _e3122: vec4<f32> = _e3121.xyyy;
            temporary11_.x = _e3122.x;
            temporary11_.z = _e3122.z;
        } else {
            let _e3127: vec4<f32> = temporary9_;
            let _e3129: vec4<f32> = temporary4_;
            let _e3131: vec4<f32> = (_e3127.xyzz * _e3129.zzzz);
            temporary15_.x = _e3131.x;
            temporary15_.y = _e3131.y;
            temporary15_.z = _e3131.z;
            let _e3138: vec4<f32> = temporary2_;
            let _e3140: vec4<f32> = temporary15_;
            let _e3142: vec4<f32> = (_e3138.xyzz + _e3140.xyzz);
            temporary2_.x = _e3142.x;
            temporary2_.y = _e3142.y;
            temporary2_.z = _e3142.z;
            let _e3149: vec4<f32> = temporary9_;
            let _e3151: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e3149.xyz, _e3151.xyz);
            let _e3155: vec4<f32> = temporary8_;
            let _e3159: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e3155.zzzz * _e3159.xxxx).x;
            let _e3164: vec4<f32> = temporary2_;
            let _e3166: vec4<f32> = temporary6_;
            let _e3168: vec4<f32> = (_e3164.wwww * _e3166.xyzz);
            temporary15_.x = _e3168.x;
            temporary15_.y = _e3168.y;
            temporary15_.z = _e3168.z;
            let _e3175: vec4<f32> = temporary9_;
            let _e3177: vec4<f32> = temporary15_;
            let _e3179: vec4<f32> = (_e3175.xyzz - _e3177.xyzz);
            temporary9_.x = _e3179.x;
            temporary9_.y = _e3179.y;
            temporary9_.z = _e3179.z;
            let _e3186: vec4<f32> = temporary9_;
            let _e3190: vec4<f32> = constant_registers[18u];
            let _e3192: vec4<f32> = (_e3186.xyzz * _e3190.yyyy);
            temporary15_.x = _e3192.x;
            temporary15_.y = _e3192.y;
            temporary15_.z = _e3192.z;
            let _e3199: vec4<f32> = temporary2_;
            let _e3201: vec4<f32> = temporary15_;
            let _e3203: vec4<f32> = (_e3199.xyzz + _e3201.xyzz);
            temporary2_.x = _e3203.x;
            temporary2_.y = _e3203.y;
            temporary2_.z = _e3203.z;
            let _e3212: vec4<f32> = constant_registers[15u];
            let _e3214: vec4<f32> = temporary2_;
            let _e3216: vec4<f32> = (_e3212.xyzz - _e3214.xyzz);
            temporary5_.x = _e3216.x;
            temporary5_.y = _e3216.y;
            temporary5_.z = _e3216.z;
            let _e3223: vec4<f32> = temporary5_;
            let _e3225: vec3<f32> = normalize(_e3223.xyz);
            temporary10_.x = _e3225.x;
            temporary10_.y = _e3225.y;
            temporary10_.z = _e3225.z;
            let _e3232: vec4<f32> = temporary5_;
            let _e3234: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e3232.xyz, _e3234.xyz);
            let _e3238: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e3238.zzzz).x;
            let _e3243: vec4<f32> = temporary6_;
            let _e3245: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e3243.xyz, _e3245.xyz);
            let _e3249: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e3249.zzzz).x;
            let _e3254: vec4<f32> = temporary1_;
            let _e3256: vec4<f32> = temporary1_;
            temporary15_.x = (_e3254.yyyy * _e3256.yyyy).x;
            let _e3261: vec4<f32> = temporary15_;
            let _e3265: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e3261.xxxx * _e3265.zzzz).x;
            let _e3272: vec4<f32> = constant_registers[18u];
            let _e3274: vec4<f32> = temporary15_;
            temporary15_.z = (_e3272.wwww + _e3274.yyyy).x;
            let _e3279: vec4<f32> = temporary2_;
            let _e3281: vec4<f32> = temporary15_;
            temporary1_.x = (_e3279.wwww / _e3281.zzzz).x;
            let _e3286: vec4<f32> = temporary1_;
            temporary8_.x = _e3286.xxxx.x;
            let _e3292: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e3292.xxxx.x;
            let _e3298: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3298.wwww.x;
            let _e3302: vec4<f32> = temporary2_;
            let _e3306: vec4<f32> = constant_registers[4u];
            let _e3308: vec4<f32> = (_e3302.xyzz - _e3306.xyzz);
            temporary13_.x = _e3308.x;
            temporary13_.y = _e3308.y;
            temporary13_.z = _e3308.z;
            let _e3315: vec4<f32> = temporary13_;
            let _e3317: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3315.xyz, _e3317.xyz);
            let _e3321: vec4<f32> = temporary19_;
            let _e3323: vec4<f32> = temporary19_;
            temporary1_.w = (_e3321.yyyy * _e3323.yyyy).x;
            let _e3328: vec4<f32> = temporary13_;
            let _e3330: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3328.xyz, _e3330.xyz);
            let _e3334: vec4<f32> = temporary1_;
            let _e3336: vec4<f32> = temporary12_;
            temporary12_.y = (_e3334.wwww - _e3336.xxxx).x;
            let _e3341: vec4<f32> = temporary2_;
            let _e3343: vec4<f32> = temporary2_;
            temporary12_.z = (_e3341.wwww * _e3343.wwww).x;
            let _e3348: vec4<f32> = temporary12_;
            let _e3350: vec4<f32> = temporary12_;
            temporary19_.z = (_e3348.yyyy + _e3350.zzzz).x;
            let _e3357: vec4<f32> = constant_registers[16u];
            let _e3359: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e3357.xxxx.x < _e3359.zzzz.x));
            let _e3366: vec4<f32> = temporary1_;
            let _e3370: vec4<f32> = constant_registers[16u];
            if all((_e3366.wwww != _e3370.xxxx)) {
                let _e3374: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3374.zzzz).x;
                let _e3379: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3379.yyyy).x;
                let _e3384: vec4<f32> = temporary12_;
                let _e3386: vec4<f32> = temporary19_;
                temporary1_.w = (_e3384.xxxx - _e3386.zzzz).x;
                let _e3393: vec4<f32> = constant_registers[16u];
                let _e3395: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e3393.xxxx.x < _e3395.wwww.x));
                let _e3402: vec4<f32> = temporary12_;
                let _e3406: vec4<f32> = constant_registers[16u];
                if all((_e3402.xxxx != _e3406.xxxx)) {
                    let _e3410: vec4<f32> = temporary1_;
                    temporary19_.x = _e3410.wwww.x;
                }
            }
            let _e3414: vec4<f32> = temporary19_;
            let _e3416: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e3414.xxxx.x < _e3416.yyyy.x));
            let _e3423: vec4<f32> = temporary8_;
            let _e3427: vec4<f32> = constant_registers[16u];
            if all((_e3423.zzzz != _e3427.xxxx)) {
                let _e3433: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3433.xxxx.x;
            }
            let _e3439: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e3439.xxxx.x;
            let _e3445: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3445.wwww.x;
            let _e3449: vec4<f32> = temporary2_;
            let _e3453: vec4<f32> = constant_registers[7u];
            let _e3455: vec4<f32> = (_e3449.xyzz - _e3453.xyzz);
            temporary13_.x = _e3455.x;
            temporary13_.y = _e3455.y;
            temporary13_.z = _e3455.z;
            let _e3462: vec4<f32> = temporary13_;
            let _e3464: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3462.xyz, _e3464.xyz);
            let _e3468: vec4<f32> = temporary19_;
            let _e3470: vec4<f32> = temporary19_;
            temporary1_.w = (_e3468.yyyy * _e3470.yyyy).x;
            let _e3475: vec4<f32> = temporary13_;
            let _e3477: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3475.xyz, _e3477.xyz);
            let _e3481: vec4<f32> = temporary1_;
            let _e3483: vec4<f32> = temporary12_;
            temporary12_.y = (_e3481.wwww - _e3483.xxxx).x;
            let _e3488: vec4<f32> = temporary2_;
            let _e3490: vec4<f32> = temporary2_;
            temporary12_.z = (_e3488.wwww * _e3490.wwww).x;
            let _e3495: vec4<f32> = temporary12_;
            let _e3497: vec4<f32> = temporary12_;
            temporary19_.z = (_e3495.yyyy + _e3497.zzzz).x;
            let _e3504: vec4<f32> = constant_registers[16u];
            let _e3506: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e3504.xxxx.x < _e3506.zzzz.x));
            let _e3513: vec4<f32> = temporary1_;
            let _e3517: vec4<f32> = constant_registers[16u];
            if all((_e3513.wwww != _e3517.xxxx)) {
                let _e3521: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3521.zzzz).x;
                let _e3526: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3526.yyyy).x;
                let _e3531: vec4<f32> = temporary12_;
                let _e3533: vec4<f32> = temporary19_;
                temporary1_.w = (_e3531.xxxx - _e3533.zzzz).x;
                let _e3540: vec4<f32> = constant_registers[16u];
                let _e3542: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e3540.xxxx.x < _e3542.wwww.x));
                let _e3549: vec4<f32> = temporary12_;
                let _e3553: vec4<f32> = constant_registers[16u];
                if all((_e3549.xxxx != _e3553.xxxx)) {
                    let _e3557: vec4<f32> = temporary1_;
                    temporary19_.x = _e3557.wwww.x;
                }
            }
            let _e3561: vec4<f32> = temporary19_;
            let _e3563: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e3561.xxxx.x < _e3563.yyyy.x));
            let _e3570: vec4<f32> = temporary8_;
            let _e3574: vec4<f32> = constant_registers[16u];
            if all((_e3570.zzzz != _e3574.xxxx)) {
                let _e3580: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3580.xxxx.x;
            }
            let _e3584: vec4<f32> = temporary2_;
            let _e3585: vec4<f32> = _e3584.xyzz;
            temporary15_.x = _e3585.x;
            temporary15_.y = _e3585.y;
            temporary15_.z = _e3585.z;
            let _e3592: vec4<f32> = temporary10_;
            let _e3593: vec4<f32> = _e3592.xyzz;
            temporary17_.x = _e3593.x;
            temporary17_.y = _e3593.y;
            temporary17_.z = _e3593.z;
            let _e3602: vec4<f32> = constant_registers[10u];
            let _e3603: vec4<f32> = _e3602.xyzz;
            temporary18_.x = _e3603.x;
            temporary18_.y = _e3603.y;
            temporary18_.z = _e3603.z;
            let _e3612: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e3612.xxxx.x;
            let _e3618: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3618.wwww.x;
            let _e3622: vec4<f32> = temporary15_;
            let _e3624: vec4<f32> = temporary18_;
            let _e3626: vec4<f32> = (_e3622.xyzz - _e3624.xyzz);
            temporary13_.x = _e3626.x;
            temporary13_.y = _e3626.y;
            temporary13_.z = _e3626.z;
            let _e3633: vec4<f32> = temporary13_;
            let _e3635: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e3633.xyz, _e3635.xyz);
            let _e3639: vec4<f32> = temporary19_;
            let _e3641: vec4<f32> = temporary19_;
            temporary1_.w = (_e3639.yyyy * _e3641.yyyy).x;
            let _e3646: vec4<f32> = temporary13_;
            let _e3648: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3646.xyz, _e3648.xyz);
            let _e3652: vec4<f32> = temporary1_;
            let _e3654: vec4<f32> = temporary12_;
            temporary12_.y = (_e3652.wwww - _e3654.xxxx).x;
            let _e3659: vec4<f32> = temporary2_;
            let _e3661: vec4<f32> = temporary2_;
            temporary12_.z = (_e3659.wwww * _e3661.wwww).x;
            let _e3666: vec4<f32> = temporary12_;
            let _e3668: vec4<f32> = temporary12_;
            temporary19_.z = (_e3666.yyyy + _e3668.zzzz).x;
            let _e3675: vec4<f32> = constant_registers[16u];
            let _e3677: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e3675.xxxx.x < _e3677.zzzz.x));
            let _e3684: vec4<f32> = temporary1_;
            let _e3688: vec4<f32> = constant_registers[16u];
            if all((_e3684.wwww != _e3688.xxxx)) {
                let _e3692: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3692.zzzz).x;
                let _e3697: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3697.yyyy).x;
                let _e3702: vec4<f32> = temporary12_;
                let _e3704: vec4<f32> = temporary19_;
                temporary12_.y = (_e3702.xxxx - _e3704.zzzz).x;
                let _e3709: vec4<f32> = temporary12_;
                temporary1_.w = _e3709.yyyy.x;
                let _e3715: vec4<f32> = constant_registers[16u];
                let _e3717: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e3715.xxxx.x < _e3717.wwww.x));
                let _e3724: vec4<f32> = temporary12_;
                let _e3728: vec4<f32> = constant_registers[16u];
                if all((_e3724.xxxx != _e3728.xxxx)) {
                    let _e3732: vec4<f32> = temporary1_;
                    temporary19_.x = _e3732.wwww.x;
                }
            }
            let _e3736: vec4<f32> = temporary19_;
            temporary4_.y = _e3736.xxxx.x;
            let _e3740: vec4<f32> = temporary4_;
            let _e3742: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e3740.yyyy.x < _e3742.yyyy.x));
            let _e3749: vec4<f32> = temporary8_;
            let _e3753: vec4<f32> = constant_registers[16u];
            if all((_e3749.zzzz != _e3753.xxxx)) {
                let _e3759: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3759.xxxx.x;
            }
            let _e3763: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e3763.yyyy).x;
            let _e3768: vec4<f32> = temporary8_;
            let _e3772: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e3768.zzzz * _e3772.xxxx).x;
            let _e3777: vec4<f32> = temporary8_;
            let _e3779: vec4<f32> = temporary2_;
            temporary8_.x = (_e3777.xxxx + _e3779.wwww).x;
            let _e3784: vec4<f32> = temporary8_;
            let _e3788: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e3784.xxxx * _e3788.yyyy).x;
            let _e3795: vec4<f32> = constant_registers[19u];
            let _e3797: vec4<f32> = temporary8_;
            temporary2_.w = (_e3795.zzzz + _e3797.zzzz).x;
            let _e3802: vec4<f32> = temporary2_;
            temporary8_.y = _e3802.wwww.x;
            let _e3806: vec4<f32> = temporary1_;
            let _e3810: vec4<f32> = constant_registers[16u];
            temporary8_.z = f32((_e3806.zzzz.x == _e3810.yyyy.x));
            let _e3817: vec4<f32> = temporary8_;
            let _e3821: vec4<f32> = constant_registers[16u];
            if all((_e3817.zzzz != _e3821.xxxx)) {
                let _e3825: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e3825.xxxx).x;
                let _e3830: vec4<f32> = temporary2_;
                let _e3832: vec4<f32> = temporary8_;
                temporary2_.w = (_e3830.xxxx - _e3832.zzzz).x;
                let _e3837: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e3837.zzzz).x;
                let _e3842: vec4<f32> = temporary2_;
                let _e3844: vec4<f32> = temporary15_;
                temporary15_.y = (_e3842.zzzz - _e3844.xxxx).x;
                let _e3849: vec4<f32> = temporary2_;
                let _e3851: vec4<f32> = temporary15_;
                temporary15_.z = (_e3849.wwww + _e3851.yyyy).x;
                let _e3856: vec4<f32> = temporary15_;
                let _e3860: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e3856.zzzz / _e3860.xxxx).x;
                let _e3865: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e3865.xxxx).x;
                let _e3870: vec4<f32> = temporary17_;
                let _e3874: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e3870.xxxx * _e3874.xxxx).x;
                let _e3879: vec4<f32> = temporary17_;
                let _e3883: vec4<f32> = constant_registers[16u];
                temporary17_.z = f32((_e3879.yyyy.x == _e3883.yyyy.x));
                let _e3890: vec4<f32> = temporary17_;
                let _e3894: vec4<f32> = constant_registers[16u];
                if all((_e3890.zzzz != _e3894.xxxx)) {
                    let _e3900: vec4<f32> = constant_registers[13u];
                    let _e3902: vec4<f32> = temporary8_;
                    let _e3904: vec4<f32> = (_e3900.xyzz * _e3902.yyyy);
                    temporary15_.x = _e3904.x;
                    temporary15_.y = _e3904.y;
                    temporary15_.z = _e3904.z;
                    let _e3911: vec4<f32> = temporary0_;
                    let _e3913: vec4<f32> = temporary15_;
                    let _e3915: vec4<f32> = (_e3911.xyzz + _e3913.xyzz);
                    temporary0_.x = _e3915.x;
                    temporary0_.y = _e3915.y;
                    temporary0_.z = _e3915.z;
                } else {
                    let _e3924: vec4<f32> = constant_registers[14u];
                    let _e3926: vec4<f32> = temporary8_;
                    let _e3928: vec4<f32> = (_e3924.xyzz * _e3926.yyyy);
                    temporary15_.x = _e3928.x;
                    temporary15_.y = _e3928.y;
                    temporary15_.z = _e3928.z;
                    let _e3935: vec4<f32> = temporary0_;
                    let _e3937: vec4<f32> = temporary15_;
                    let _e3939: vec4<f32> = (_e3935.xyzz + _e3937.xyzz);
                    temporary0_.x = _e3939.x;
                    temporary0_.y = _e3939.y;
                    temporary0_.z = _e3939.z;
                }
            }
            let _e3946: vec4<f32> = temporary1_;
            let _e3950: vec4<f32> = constant_registers[18u];
            temporary8_.z = f32((_e3946.zzzz.x == _e3950.xxxx.x));
            let _e3957: vec4<f32> = temporary8_;
            let _e3961: vec4<f32> = constant_registers[16u];
            if all((_e3957.zzzz != _e3961.xxxx)) {
                let _e3965: vec4<f32> = temporary7_;
                let _e3967: vec4<f32> = temporary8_;
                let _e3969: vec4<f32> = (_e3965.xyzz * _e3967.yyyy);
                temporary15_.x = _e3969.x;
                temporary15_.y = _e3969.y;
                temporary15_.z = _e3969.z;
                let _e3976: vec4<f32> = temporary0_;
                let _e3978: vec4<f32> = temporary15_;
                let _e3980: vec4<f32> = (_e3976.xyzz + _e3978.xyzz);
                temporary0_.x = _e3980.x;
                temporary0_.y = _e3980.y;
                temporary0_.z = _e3980.z;
            }
            let _e3989: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e3989.yyyy.x;
        }
    }
    let _e3993: vec4<f32> = temporary11_;
    let _e3997: vec4<f32> = constant_registers[16u];
    if all((_e3993.xxxx != _e3997.xxxx)) {
        let _e4003: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e4003.xxxx.x;
        let _e4009: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e4009.wwww.x;
        let _e4015: vec4<f32> = constant_registers[16u];
        let _e4016: vec4<f32> = _e4015.xyxx;
        temporary3_.x = _e4016.x;
        temporary3_.y = _e4016.y;
        temporary3_.z = _e4016.z;
        let _e4023: vec4<f32> = temporary3_;
        let _e4024: vec4<f32> = _e4023.xyzz;
        temporary12_.x = _e4024.x;
        temporary12_.y = _e4024.y;
        temporary12_.z = _e4024.z;
        let _e4033: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e4033.wwww.x;
        let _e4037: vec4<f32> = temporary2_;
        let _e4041: vec4<f32> = constant_registers[16u];
        let _e4043: vec4<f32> = (_e4037.xyzz - _e4041.xxxx);
        temporary20_.x = _e4043.x;
        temporary20_.y = _e4043.y;
        temporary20_.z = _e4043.z;
        let _e4050: vec4<f32> = temporary20_;
        let _e4052: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e4050.xyz, _e4052.xyz);
        let _e4056: vec4<f32> = temporary14_;
        temporary14_.z = -(_e4056.yyyy).x;
        let _e4061: vec4<f32> = temporary9_;
        let _e4063: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e4061.xyz, _e4063.xyz);
        let _e4067: vec4<f32> = temporary14_;
        let _e4069: vec4<f32> = temporary4_;
        temporary16_.x = (_e4067.zzzz / _e4069.xxxx).x;
        let _e4074: vec4<f32> = temporary16_;
        temporary14_.x = _e4074.xxxx.x;
        let _e4080: vec4<f32> = constant_registers[16u];
        let _e4082: vec4<f32> = temporary14_;
        temporary14_.y = f32((_e4080.xxxx.x < _e4082.xxxx.x));
        let _e4089: vec4<f32> = temporary14_;
        let _e4093: vec4<f32> = constant_registers[16u];
        if all((_e4089.yyyy != _e4093.xxxx)) {
            let _e4097: vec4<f32> = temporary14_;
            temporary2_.w = _e4097.xxxx.x;
        }
        let _e4101: vec4<f32> = temporary2_;
        temporary4_.y = _e4101.wwww.x;
        let _e4105: vec4<f32> = temporary4_;
        let _e4107: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e4105.yyyy.x < _e4107.zzzz.x));
        let _e4114: vec4<f32> = temporary8_;
        let _e4118: vec4<f32> = constant_registers[16u];
        if all((_e4114.zzzz != _e4118.xxxx)) {
            let _e4122: vec4<f32> = temporary4_;
            temporary4_.z = _e4122.yyyy.x;
            let _e4126: vec4<f32> = temporary3_;
            let _e4127: vec4<f32> = _e4126.xyzz;
            temporary6_.x = _e4127.x;
            temporary6_.y = _e4127.y;
            temporary6_.z = _e4127.z;
            let _e4136: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e4136.yyyy.x;
        }
        let _e4140: vec4<f32> = temporary2_;
        let _e4141: vec4<f32> = _e4140.xyzz;
        temporary15_.x = _e4141.x;
        temporary15_.y = _e4141.y;
        temporary15_.z = _e4141.z;
        let _e4148: vec4<f32> = temporary9_;
        let _e4149: vec4<f32> = _e4148.xyzz;
        temporary17_.x = _e4149.x;
        temporary17_.y = _e4149.y;
        temporary17_.z = _e4149.z;
        let _e4158: vec4<f32> = constant_registers[4u];
        let _e4159: vec4<f32> = _e4158.xyzz;
        temporary18_.x = _e4159.x;
        temporary18_.y = _e4159.y;
        temporary18_.z = _e4159.z;
        let _e4168: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e4168.xxxx.x;
        let _e4172: vec4<f32> = temporary3_;
        let _e4173: vec4<f32> = _e4172.xyzz;
        temporary19_.x = _e4173.x;
        temporary19_.y = _e4173.y;
        temporary19_.z = _e4173.z;
        let _e4182: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4182.wwww.x;
        let _e4186: vec4<f32> = temporary15_;
        let _e4188: vec4<f32> = temporary18_;
        let _e4190: vec4<f32> = (_e4186.xyzz - _e4188.xyzz);
        temporary12_.x = _e4190.x;
        temporary12_.y = _e4190.y;
        temporary12_.z = _e4190.z;
        let _e4197: vec4<f32> = temporary12_;
        let _e4199: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4197.xyz, _e4199.xyz);
        let _e4203: vec4<f32> = temporary13_;
        let _e4205: vec4<f32> = temporary13_;
        temporary3_.w = (_e4203.yyyy * _e4205.yyyy).x;
        let _e4210: vec4<f32> = temporary12_;
        let _e4212: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4210.xyz, _e4212.xyz);
        let _e4216: vec4<f32> = temporary3_;
        let _e4218: vec4<f32> = temporary14_;
        temporary14_.y = (_e4216.wwww - _e4218.xxxx).x;
        let _e4223: vec4<f32> = temporary2_;
        let _e4225: vec4<f32> = temporary2_;
        temporary14_.z = (_e4223.wwww * _e4225.wwww).x;
        let _e4230: vec4<f32> = temporary14_;
        let _e4232: vec4<f32> = temporary14_;
        temporary13_.z = (_e4230.yyyy + _e4232.zzzz).x;
        let _e4239: vec4<f32> = constant_registers[16u];
        let _e4241: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e4239.xxxx.x < _e4241.zzzz.x));
        let _e4248: vec4<f32> = temporary3_;
        let _e4252: vec4<f32> = constant_registers[16u];
        if all((_e4248.wwww != _e4252.xxxx)) {
            let _e4256: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4256.zzzz).x;
            let _e4261: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4261.yyyy).x;
            let _e4266: vec4<f32> = temporary14_;
            let _e4268: vec4<f32> = temporary13_;
            temporary14_.y = (_e4266.xxxx - _e4268.zzzz).x;
            let _e4273: vec4<f32> = temporary14_;
            temporary3_.w = _e4273.yyyy.x;
            let _e4279: vec4<f32> = constant_registers[16u];
            let _e4281: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e4279.xxxx.x < _e4281.wwww.x));
            let _e4288: vec4<f32> = temporary14_;
            let _e4292: vec4<f32> = constant_registers[16u];
            if all((_e4288.xxxx != _e4292.xxxx)) {
                let _e4296: vec4<f32> = temporary3_;
                temporary13_.x = _e4296.wwww.x;
                let _e4300: vec4<f32> = temporary17_;
                let _e4302: vec4<f32> = temporary3_;
                let _e4304: vec4<f32> = (_e4300.xyzz * _e4302.wwww);
                temporary14_.x = _e4304.x;
                temporary14_.y = _e4304.y;
                temporary14_.z = _e4304.z;
                let _e4311: vec4<f32> = temporary15_;
                let _e4313: vec4<f32> = temporary14_;
                let _e4315: vec4<f32> = (_e4311.xyzz + _e4313.xyzz);
                temporary20_.x = _e4315.x;
                temporary20_.y = _e4315.y;
                temporary20_.z = _e4315.z;
                let _e4322: vec4<f32> = temporary20_;
                let _e4324: vec4<f32> = temporary18_;
                let _e4326: vec4<f32> = (_e4322.xyzz - _e4324.xyzz);
                temporary16_.x = _e4326.x;
                temporary16_.y = _e4326.y;
                temporary16_.z = _e4326.z;
                let _e4333: vec4<f32> = temporary16_;
                let _e4335: vec3<f32> = normalize(_e4333.xyz);
                temporary19_.x = _e4335.x;
                temporary19_.y = _e4335.y;
                temporary19_.z = _e4335.z;
            }
        }
        let _e4342: vec4<f32> = temporary13_;
        temporary4_.y = _e4342.xxxx.x;
        let _e4346: vec4<f32> = temporary19_;
        let _e4347: vec4<f32> = _e4346.xyzz;
        temporary3_.x = _e4347.x;
        temporary3_.y = _e4347.y;
        temporary3_.z = _e4347.z;
        let _e4354: vec4<f32> = temporary4_;
        let _e4356: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e4354.yyyy.x < _e4356.zzzz.x));
        let _e4363: vec4<f32> = temporary8_;
        let _e4367: vec4<f32> = constant_registers[16u];
        if all((_e4363.zzzz != _e4367.xxxx)) {
            let _e4371: vec4<f32> = temporary4_;
            temporary4_.z = _e4371.yyyy.x;
            let _e4375: vec4<f32> = temporary3_;
            let _e4376: vec4<f32> = _e4375.xyzz;
            temporary6_.x = _e4376.x;
            temporary6_.y = _e4376.y;
            temporary6_.z = _e4376.z;
            let _e4385: vec4<f32> = constant_registers[5u];
            let _e4386: vec4<f32> = _e4385.xyzz;
            temporary7_.x = _e4386.x;
            temporary7_.y = _e4386.y;
            temporary7_.z = _e4386.z;
            let _e4395: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4395.xxxx.x;
        }
        let _e4399: vec4<f32> = temporary2_;
        let _e4400: vec4<f32> = _e4399.xyzz;
        temporary15_.x = _e4400.x;
        temporary15_.y = _e4400.y;
        temporary15_.z = _e4400.z;
        let _e4407: vec4<f32> = temporary9_;
        let _e4408: vec4<f32> = _e4407.xyzz;
        temporary17_.x = _e4408.x;
        temporary17_.y = _e4408.y;
        temporary17_.z = _e4408.z;
        let _e4417: vec4<f32> = constant_registers[7u];
        let _e4418: vec4<f32> = _e4417.xyzz;
        temporary18_.x = _e4418.x;
        temporary18_.y = _e4418.y;
        temporary18_.z = _e4418.z;
        let _e4427: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e4427.xxxx.x;
        let _e4431: vec4<f32> = temporary3_;
        let _e4432: vec4<f32> = _e4431.xyzz;
        temporary19_.x = _e4432.x;
        temporary19_.y = _e4432.y;
        temporary19_.z = _e4432.z;
        let _e4441: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4441.wwww.x;
        let _e4445: vec4<f32> = temporary15_;
        let _e4447: vec4<f32> = temporary18_;
        let _e4449: vec4<f32> = (_e4445.xyzz - _e4447.xyzz);
        temporary12_.x = _e4449.x;
        temporary12_.y = _e4449.y;
        temporary12_.z = _e4449.z;
        let _e4456: vec4<f32> = temporary12_;
        let _e4458: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4456.xyz, _e4458.xyz);
        let _e4462: vec4<f32> = temporary13_;
        let _e4464: vec4<f32> = temporary13_;
        temporary3_.w = (_e4462.yyyy * _e4464.yyyy).x;
        let _e4469: vec4<f32> = temporary12_;
        let _e4471: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4469.xyz, _e4471.xyz);
        let _e4475: vec4<f32> = temporary3_;
        let _e4477: vec4<f32> = temporary14_;
        temporary14_.y = (_e4475.wwww - _e4477.xxxx).x;
        let _e4482: vec4<f32> = temporary2_;
        let _e4484: vec4<f32> = temporary2_;
        temporary14_.z = (_e4482.wwww * _e4484.wwww).x;
        let _e4489: vec4<f32> = temporary14_;
        let _e4491: vec4<f32> = temporary14_;
        temporary13_.z = (_e4489.yyyy + _e4491.zzzz).x;
        let _e4498: vec4<f32> = constant_registers[16u];
        let _e4500: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e4498.xxxx.x < _e4500.zzzz.x));
        let _e4507: vec4<f32> = temporary3_;
        let _e4511: vec4<f32> = constant_registers[16u];
        if all((_e4507.wwww != _e4511.xxxx)) {
            let _e4515: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4515.zzzz).x;
            let _e4520: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4520.yyyy).x;
            let _e4525: vec4<f32> = temporary14_;
            let _e4527: vec4<f32> = temporary13_;
            temporary14_.y = (_e4525.xxxx - _e4527.zzzz).x;
            let _e4532: vec4<f32> = temporary14_;
            temporary3_.w = _e4532.yyyy.x;
            let _e4538: vec4<f32> = constant_registers[16u];
            let _e4540: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e4538.xxxx.x < _e4540.wwww.x));
            let _e4547: vec4<f32> = temporary14_;
            let _e4551: vec4<f32> = constant_registers[16u];
            if all((_e4547.xxxx != _e4551.xxxx)) {
                let _e4555: vec4<f32> = temporary3_;
                temporary13_.x = _e4555.wwww.x;
                let _e4559: vec4<f32> = temporary17_;
                let _e4561: vec4<f32> = temporary3_;
                let _e4563: vec4<f32> = (_e4559.xyzz * _e4561.wwww);
                temporary14_.x = _e4563.x;
                temporary14_.y = _e4563.y;
                temporary14_.z = _e4563.z;
                let _e4570: vec4<f32> = temporary15_;
                let _e4572: vec4<f32> = temporary14_;
                let _e4574: vec4<f32> = (_e4570.xyzz + _e4572.xyzz);
                temporary20_.x = _e4574.x;
                temporary20_.y = _e4574.y;
                temporary20_.z = _e4574.z;
                let _e4581: vec4<f32> = temporary20_;
                let _e4583: vec4<f32> = temporary18_;
                let _e4585: vec4<f32> = (_e4581.xyzz - _e4583.xyzz);
                temporary16_.x = _e4585.x;
                temporary16_.y = _e4585.y;
                temporary16_.z = _e4585.z;
                let _e4592: vec4<f32> = temporary16_;
                let _e4594: vec3<f32> = normalize(_e4592.xyz);
                temporary19_.x = _e4594.x;
                temporary19_.y = _e4594.y;
                temporary19_.z = _e4594.z;
            }
        }
        let _e4601: vec4<f32> = temporary13_;
        temporary4_.y = _e4601.xxxx.x;
        let _e4605: vec4<f32> = temporary19_;
        let _e4606: vec4<f32> = _e4605.xyzz;
        temporary3_.x = _e4606.x;
        temporary3_.y = _e4606.y;
        temporary3_.z = _e4606.z;
        let _e4613: vec4<f32> = temporary4_;
        let _e4615: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e4613.yyyy.x < _e4615.zzzz.x));
        let _e4622: vec4<f32> = temporary8_;
        let _e4626: vec4<f32> = constant_registers[16u];
        if all((_e4622.zzzz != _e4626.xxxx)) {
            let _e4630: vec4<f32> = temporary4_;
            temporary4_.z = _e4630.yyyy.x;
            let _e4634: vec4<f32> = temporary3_;
            let _e4635: vec4<f32> = _e4634.xyzz;
            temporary6_.x = _e4635.x;
            temporary6_.y = _e4635.y;
            temporary6_.z = _e4635.z;
            let _e4644: vec4<f32> = constant_registers[8u];
            let _e4645: vec4<f32> = _e4644.xyzz;
            temporary7_.x = _e4645.x;
            temporary7_.y = _e4645.y;
            temporary7_.z = _e4645.z;
            let _e4654: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4654.xxxx.x;
        }
        let _e4658: vec4<f32> = temporary2_;
        let _e4659: vec4<f32> = _e4658.xyzz;
        temporary15_.x = _e4659.x;
        temporary15_.y = _e4659.y;
        temporary15_.z = _e4659.z;
        let _e4666: vec4<f32> = temporary9_;
        let _e4667: vec4<f32> = _e4666.xyzz;
        temporary17_.x = _e4667.x;
        temporary17_.y = _e4667.y;
        temporary17_.z = _e4667.z;
        let _e4676: vec4<f32> = constant_registers[10u];
        let _e4677: vec4<f32> = _e4676.xyzz;
        temporary18_.x = _e4677.x;
        temporary18_.y = _e4677.y;
        temporary18_.z = _e4677.z;
        let _e4686: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e4686.xxxx.x;
        let _e4690: vec4<f32> = temporary3_;
        let _e4691: vec4<f32> = _e4690.xyzz;
        temporary19_.x = _e4691.x;
        temporary19_.y = _e4691.y;
        temporary19_.z = _e4691.z;
        let _e4700: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4700.wwww.x;
        let _e4704: vec4<f32> = temporary15_;
        let _e4706: vec4<f32> = temporary18_;
        let _e4708: vec4<f32> = (_e4704.xyzz - _e4706.xyzz);
        temporary12_.x = _e4708.x;
        temporary12_.y = _e4708.y;
        temporary12_.z = _e4708.z;
        let _e4715: vec4<f32> = temporary12_;
        let _e4717: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4715.xyz, _e4717.xyz);
        let _e4721: vec4<f32> = temporary13_;
        let _e4723: vec4<f32> = temporary13_;
        temporary3_.w = (_e4721.yyyy * _e4723.yyyy).x;
        let _e4728: vec4<f32> = temporary12_;
        let _e4730: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4728.xyz, _e4730.xyz);
        let _e4734: vec4<f32> = temporary3_;
        let _e4736: vec4<f32> = temporary14_;
        temporary14_.y = (_e4734.wwww - _e4736.xxxx).x;
        let _e4741: vec4<f32> = temporary2_;
        let _e4743: vec4<f32> = temporary2_;
        temporary14_.z = (_e4741.wwww * _e4743.wwww).x;
        let _e4748: vec4<f32> = temporary14_;
        let _e4750: vec4<f32> = temporary14_;
        temporary13_.z = (_e4748.yyyy + _e4750.zzzz).x;
        let _e4757: vec4<f32> = constant_registers[16u];
        let _e4759: vec4<f32> = temporary13_;
        temporary3_.w = f32((_e4757.xxxx.x < _e4759.zzzz.x));
        let _e4766: vec4<f32> = temporary3_;
        let _e4770: vec4<f32> = constant_registers[16u];
        if all((_e4766.wwww != _e4770.xxxx)) {
            let _e4774: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4774.zzzz).x;
            let _e4779: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4779.yyyy).x;
            let _e4784: vec4<f32> = temporary14_;
            let _e4786: vec4<f32> = temporary13_;
            temporary14_.y = (_e4784.xxxx - _e4786.zzzz).x;
            let _e4791: vec4<f32> = temporary14_;
            temporary3_.w = _e4791.yyyy.x;
            let _e4797: vec4<f32> = constant_registers[16u];
            let _e4799: vec4<f32> = temporary3_;
            temporary14_.x = f32((_e4797.xxxx.x < _e4799.wwww.x));
            let _e4806: vec4<f32> = temporary14_;
            let _e4810: vec4<f32> = constant_registers[16u];
            if all((_e4806.xxxx != _e4810.xxxx)) {
                let _e4814: vec4<f32> = temporary3_;
                temporary13_.x = _e4814.wwww.x;
                let _e4818: vec4<f32> = temporary17_;
                let _e4820: vec4<f32> = temporary3_;
                let _e4822: vec4<f32> = (_e4818.xyzz * _e4820.wwww);
                temporary14_.x = _e4822.x;
                temporary14_.y = _e4822.y;
                temporary14_.z = _e4822.z;
                let _e4829: vec4<f32> = temporary15_;
                let _e4831: vec4<f32> = temporary14_;
                let _e4833: vec4<f32> = (_e4829.xyzz + _e4831.xyzz);
                temporary20_.x = _e4833.x;
                temporary20_.y = _e4833.y;
                temporary20_.z = _e4833.z;
                let _e4840: vec4<f32> = temporary20_;
                let _e4842: vec4<f32> = temporary18_;
                let _e4844: vec4<f32> = (_e4840.xyzz - _e4842.xyzz);
                temporary16_.x = _e4844.x;
                temporary16_.y = _e4844.y;
                temporary16_.z = _e4844.z;
                let _e4851: vec4<f32> = temporary16_;
                let _e4853: vec3<f32> = normalize(_e4851.xyz);
                temporary19_.x = _e4853.x;
                temporary19_.y = _e4853.y;
                temporary19_.z = _e4853.z;
            }
        }
        let _e4860: vec4<f32> = temporary13_;
        temporary4_.y = _e4860.xxxx.x;
        let _e4864: vec4<f32> = temporary19_;
        let _e4865: vec4<f32> = _e4864.xyzz;
        temporary3_.x = _e4865.x;
        temporary3_.y = _e4865.y;
        temporary3_.z = _e4865.z;
        let _e4872: vec4<f32> = temporary4_;
        let _e4874: vec4<f32> = temporary4_;
        temporary8_.z = f32((_e4872.yyyy.x < _e4874.zzzz.x));
        let _e4881: vec4<f32> = temporary8_;
        let _e4885: vec4<f32> = constant_registers[16u];
        if all((_e4881.zzzz != _e4885.xxxx)) {
            let _e4889: vec4<f32> = temporary4_;
            temporary4_.z = _e4889.yyyy.x;
            let _e4893: vec4<f32> = temporary3_;
            let _e4894: vec4<f32> = _e4893.xyzz;
            temporary6_.x = _e4894.x;
            temporary6_.y = _e4894.y;
            temporary6_.z = _e4894.z;
            let _e4903: vec4<f32> = constant_registers[11u];
            let _e4904: vec4<f32> = _e4903.xyzz;
            temporary7_.x = _e4904.x;
            temporary7_.y = _e4904.y;
            temporary7_.z = _e4904.z;
            let _e4913: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4913.xxxx.x;
        }
        let _e4917: vec4<f32> = temporary11_;
        let _e4921: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e4917.yyyy + _e4921.yyyy).x;
        let _e4926: vec4<f32> = temporary1_;
        let _e4930: vec4<f32> = constant_registers[16u];
        temporary8_.z = f32((_e4926.zzzz.x == _e4930.xxxx.x));
        let _e4937: vec4<f32> = temporary8_;
        let _e4941: vec4<f32> = constant_registers[16u];
        if all((_e4937.zzzz != _e4941.xxxx)) {
            let _e4947: vec4<f32> = constant_registers[16u];
            temporary11_.z = _e4947.yyyy.x;
        } else {
            let _e4951: vec4<f32> = temporary9_;
            let _e4953: vec4<f32> = temporary4_;
            let _e4955: vec4<f32> = (_e4951.xyzz * _e4953.zzzz);
            temporary15_.x = _e4955.x;
            temporary15_.y = _e4955.y;
            temporary15_.z = _e4955.z;
            let _e4962: vec4<f32> = temporary2_;
            let _e4964: vec4<f32> = temporary15_;
            let _e4966: vec4<f32> = (_e4962.xyzz + _e4964.xyzz);
            temporary2_.x = _e4966.x;
            temporary2_.y = _e4966.y;
            temporary2_.z = _e4966.z;
            let _e4973: vec4<f32> = temporary9_;
            let _e4975: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e4973.xyz, _e4975.xyz);
            let _e4979: vec4<f32> = temporary8_;
            let _e4983: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e4979.zzzz * _e4983.xxxx).x;
            let _e4988: vec4<f32> = temporary2_;
            let _e4990: vec4<f32> = temporary6_;
            let _e4992: vec4<f32> = (_e4988.wwww * _e4990.xyzz);
            temporary15_.x = _e4992.x;
            temporary15_.y = _e4992.y;
            temporary15_.z = _e4992.z;
            let _e4999: vec4<f32> = temporary9_;
            let _e5001: vec4<f32> = temporary15_;
            let _e5003: vec4<f32> = (_e4999.xyzz - _e5001.xyzz);
            temporary9_.x = _e5003.x;
            temporary9_.y = _e5003.y;
            temporary9_.z = _e5003.z;
            let _e5010: vec4<f32> = temporary9_;
            let _e5014: vec4<f32> = constant_registers[18u];
            let _e5016: vec4<f32> = (_e5010.xyzz * _e5014.yyyy);
            temporary15_.x = _e5016.x;
            temporary15_.y = _e5016.y;
            temporary15_.z = _e5016.z;
            let _e5023: vec4<f32> = temporary2_;
            let _e5025: vec4<f32> = temporary15_;
            let _e5027: vec4<f32> = (_e5023.xyzz + _e5025.xyzz);
            temporary2_.x = _e5027.x;
            temporary2_.y = _e5027.y;
            temporary2_.z = _e5027.z;
            let _e5036: vec4<f32> = constant_registers[15u];
            let _e5038: vec4<f32> = temporary2_;
            let _e5040: vec4<f32> = (_e5036.xyzz - _e5038.xyzz);
            temporary5_.x = _e5040.x;
            temporary5_.y = _e5040.y;
            temporary5_.z = _e5040.z;
            let _e5047: vec4<f32> = temporary5_;
            let _e5049: vec3<f32> = normalize(_e5047.xyz);
            temporary10_.x = _e5049.x;
            temporary10_.y = _e5049.y;
            temporary10_.z = _e5049.z;
            let _e5056: vec4<f32> = temporary5_;
            let _e5058: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e5056.xyz, _e5058.xyz);
            let _e5062: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e5062.zzzz).x;
            let _e5067: vec4<f32> = temporary6_;
            let _e5069: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e5067.xyz, _e5069.xyz);
            let _e5073: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e5073.zzzz).x;
            let _e5078: vec4<f32> = temporary1_;
            let _e5080: vec4<f32> = temporary1_;
            temporary15_.x = (_e5078.yyyy * _e5080.yyyy).x;
            let _e5085: vec4<f32> = temporary15_;
            let _e5089: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e5085.xxxx * _e5089.zzzz).x;
            let _e5096: vec4<f32> = constant_registers[18u];
            let _e5098: vec4<f32> = temporary15_;
            temporary15_.z = (_e5096.wwww + _e5098.yyyy).x;
            let _e5103: vec4<f32> = temporary2_;
            let _e5105: vec4<f32> = temporary15_;
            temporary1_.x = (_e5103.wwww / _e5105.zzzz).x;
            let _e5110: vec4<f32> = temporary1_;
            temporary8_.x = _e5110.xxxx.x;
            let _e5116: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e5116.xxxx.x;
            let _e5122: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5122.wwww.x;
            let _e5126: vec4<f32> = temporary2_;
            let _e5130: vec4<f32> = constant_registers[4u];
            let _e5132: vec4<f32> = (_e5126.xyzz - _e5130.xyzz);
            temporary13_.x = _e5132.x;
            temporary13_.y = _e5132.y;
            temporary13_.z = _e5132.z;
            let _e5139: vec4<f32> = temporary13_;
            let _e5141: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5139.xyz, _e5141.xyz);
            let _e5145: vec4<f32> = temporary19_;
            let _e5147: vec4<f32> = temporary19_;
            temporary1_.w = (_e5145.yyyy * _e5147.yyyy).x;
            let _e5152: vec4<f32> = temporary13_;
            let _e5154: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5152.xyz, _e5154.xyz);
            let _e5158: vec4<f32> = temporary1_;
            let _e5160: vec4<f32> = temporary12_;
            temporary12_.y = (_e5158.wwww - _e5160.xxxx).x;
            let _e5165: vec4<f32> = temporary2_;
            let _e5167: vec4<f32> = temporary2_;
            temporary12_.z = (_e5165.wwww * _e5167.wwww).x;
            let _e5172: vec4<f32> = temporary12_;
            let _e5174: vec4<f32> = temporary12_;
            temporary19_.z = (_e5172.yyyy + _e5174.zzzz).x;
            let _e5181: vec4<f32> = constant_registers[16u];
            let _e5183: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e5181.xxxx.x < _e5183.zzzz.x));
            let _e5190: vec4<f32> = temporary1_;
            let _e5194: vec4<f32> = constant_registers[16u];
            if all((_e5190.wwww != _e5194.xxxx)) {
                let _e5198: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5198.zzzz).x;
                let _e5203: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5203.yyyy).x;
                let _e5208: vec4<f32> = temporary12_;
                let _e5210: vec4<f32> = temporary19_;
                temporary1_.w = (_e5208.xxxx - _e5210.zzzz).x;
                let _e5217: vec4<f32> = constant_registers[16u];
                let _e5219: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e5217.xxxx.x < _e5219.wwww.x));
                let _e5226: vec4<f32> = temporary12_;
                let _e5230: vec4<f32> = constant_registers[16u];
                if all((_e5226.xxxx != _e5230.xxxx)) {
                    let _e5234: vec4<f32> = temporary1_;
                    temporary19_.x = _e5234.wwww.x;
                }
            }
            let _e5238: vec4<f32> = temporary19_;
            let _e5240: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e5238.xxxx.x < _e5240.yyyy.x));
            let _e5247: vec4<f32> = temporary8_;
            let _e5251: vec4<f32> = constant_registers[16u];
            if all((_e5247.zzzz != _e5251.xxxx)) {
                let _e5257: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5257.xxxx.x;
            }
            let _e5263: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e5263.xxxx.x;
            let _e5269: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5269.wwww.x;
            let _e5273: vec4<f32> = temporary2_;
            let _e5277: vec4<f32> = constant_registers[7u];
            let _e5279: vec4<f32> = (_e5273.xyzz - _e5277.xyzz);
            temporary13_.x = _e5279.x;
            temporary13_.y = _e5279.y;
            temporary13_.z = _e5279.z;
            let _e5286: vec4<f32> = temporary13_;
            let _e5288: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5286.xyz, _e5288.xyz);
            let _e5292: vec4<f32> = temporary19_;
            let _e5294: vec4<f32> = temporary19_;
            temporary1_.w = (_e5292.yyyy * _e5294.yyyy).x;
            let _e5299: vec4<f32> = temporary13_;
            let _e5301: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5299.xyz, _e5301.xyz);
            let _e5305: vec4<f32> = temporary1_;
            let _e5307: vec4<f32> = temporary12_;
            temporary12_.y = (_e5305.wwww - _e5307.xxxx).x;
            let _e5312: vec4<f32> = temporary2_;
            let _e5314: vec4<f32> = temporary2_;
            temporary12_.z = (_e5312.wwww * _e5314.wwww).x;
            let _e5319: vec4<f32> = temporary12_;
            let _e5321: vec4<f32> = temporary12_;
            temporary19_.z = (_e5319.yyyy + _e5321.zzzz).x;
            let _e5328: vec4<f32> = constant_registers[16u];
            let _e5330: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e5328.xxxx.x < _e5330.zzzz.x));
            let _e5337: vec4<f32> = temporary1_;
            let _e5341: vec4<f32> = constant_registers[16u];
            if all((_e5337.wwww != _e5341.xxxx)) {
                let _e5345: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5345.zzzz).x;
                let _e5350: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5350.yyyy).x;
                let _e5355: vec4<f32> = temporary12_;
                let _e5357: vec4<f32> = temporary19_;
                temporary1_.w = (_e5355.xxxx - _e5357.zzzz).x;
                let _e5364: vec4<f32> = constant_registers[16u];
                let _e5366: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e5364.xxxx.x < _e5366.wwww.x));
                let _e5373: vec4<f32> = temporary12_;
                let _e5377: vec4<f32> = constant_registers[16u];
                if all((_e5373.xxxx != _e5377.xxxx)) {
                    let _e5381: vec4<f32> = temporary1_;
                    temporary19_.x = _e5381.wwww.x;
                }
            }
            let _e5385: vec4<f32> = temporary19_;
            let _e5387: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e5385.xxxx.x < _e5387.yyyy.x));
            let _e5394: vec4<f32> = temporary8_;
            let _e5398: vec4<f32> = constant_registers[16u];
            if all((_e5394.zzzz != _e5398.xxxx)) {
                let _e5404: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5404.xxxx.x;
            }
            let _e5408: vec4<f32> = temporary2_;
            let _e5409: vec4<f32> = _e5408.xyzz;
            temporary15_.x = _e5409.x;
            temporary15_.y = _e5409.y;
            temporary15_.z = _e5409.z;
            let _e5416: vec4<f32> = temporary10_;
            let _e5417: vec4<f32> = _e5416.xyzz;
            temporary17_.x = _e5417.x;
            temporary17_.y = _e5417.y;
            temporary17_.z = _e5417.z;
            let _e5426: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e5426.xxxx.x;
            let _e5432: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5432.wwww.x;
            let _e5436: vec4<f32> = temporary15_;
            let _e5440: vec4<f32> = constant_registers[10u];
            let _e5442: vec4<f32> = (_e5436.xyzz - _e5440.xyzz);
            temporary13_.x = _e5442.x;
            temporary13_.y = _e5442.y;
            temporary13_.z = _e5442.z;
            let _e5449: vec4<f32> = temporary13_;
            let _e5451: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e5449.xyz, _e5451.xyz);
            let _e5455: vec4<f32> = temporary19_;
            let _e5457: vec4<f32> = temporary19_;
            temporary1_.w = (_e5455.yyyy * _e5457.yyyy).x;
            let _e5462: vec4<f32> = temporary13_;
            let _e5464: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5462.xyz, _e5464.xyz);
            let _e5468: vec4<f32> = temporary1_;
            let _e5470: vec4<f32> = temporary12_;
            temporary12_.y = (_e5468.wwww - _e5470.xxxx).x;
            let _e5475: vec4<f32> = temporary2_;
            let _e5477: vec4<f32> = temporary2_;
            temporary12_.z = (_e5475.wwww * _e5477.wwww).x;
            let _e5482: vec4<f32> = temporary12_;
            let _e5484: vec4<f32> = temporary12_;
            temporary19_.z = (_e5482.yyyy + _e5484.zzzz).x;
            let _e5491: vec4<f32> = constant_registers[16u];
            let _e5493: vec4<f32> = temporary19_;
            temporary1_.w = f32((_e5491.xxxx.x < _e5493.zzzz.x));
            let _e5500: vec4<f32> = temporary1_;
            let _e5504: vec4<f32> = constant_registers[16u];
            if all((_e5500.wwww != _e5504.xxxx)) {
                let _e5508: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5508.zzzz).x;
                let _e5513: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5513.yyyy).x;
                let _e5518: vec4<f32> = temporary12_;
                let _e5520: vec4<f32> = temporary19_;
                temporary1_.w = (_e5518.xxxx - _e5520.zzzz).x;
                let _e5527: vec4<f32> = constant_registers[16u];
                let _e5529: vec4<f32> = temporary1_;
                temporary12_.x = f32((_e5527.xxxx.x < _e5529.wwww.x));
                let _e5536: vec4<f32> = temporary12_;
                let _e5540: vec4<f32> = constant_registers[16u];
                if all((_e5536.xxxx != _e5540.xxxx)) {
                    let _e5544: vec4<f32> = temporary1_;
                    temporary19_.x = _e5544.wwww.x;
                }
            }
            let _e5548: vec4<f32> = temporary19_;
            let _e5550: vec4<f32> = temporary1_;
            temporary8_.z = f32((_e5548.xxxx.x < _e5550.yyyy.x));
            let _e5557: vec4<f32> = temporary8_;
            let _e5561: vec4<f32> = constant_registers[16u];
            if all((_e5557.zzzz != _e5561.xxxx)) {
                let _e5567: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5567.xxxx.x;
            }
            let _e5571: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e5571.yyyy).x;
            let _e5576: vec4<f32> = temporary8_;
            let _e5580: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e5576.zzzz * _e5580.xxxx).x;
            let _e5585: vec4<f32> = temporary8_;
            let _e5587: vec4<f32> = temporary2_;
            temporary8_.x = (_e5585.xxxx + _e5587.wwww).x;
            let _e5592: vec4<f32> = temporary8_;
            let _e5596: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e5592.xxxx * _e5596.yyyy).x;
            let _e5603: vec4<f32> = constant_registers[19u];
            let _e5605: vec4<f32> = temporary8_;
            temporary2_.w = (_e5603.zzzz + _e5605.zzzz).x;
            let _e5610: vec4<f32> = temporary2_;
            temporary8_.y = _e5610.wwww.x;
            let _e5614: vec4<f32> = temporary1_;
            let _e5618: vec4<f32> = constant_registers[16u];
            temporary8_.z = f32((_e5614.zzzz.x == _e5618.yyyy.x));
            let _e5625: vec4<f32> = temporary8_;
            let _e5629: vec4<f32> = constant_registers[16u];
            if all((_e5625.zzzz != _e5629.xxxx)) {
                let _e5633: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e5633.xxxx).x;
                let _e5638: vec4<f32> = temporary2_;
                let _e5640: vec4<f32> = temporary8_;
                temporary2_.w = (_e5638.xxxx - _e5640.zzzz).x;
                let _e5645: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e5645.zzzz).x;
                let _e5650: vec4<f32> = temporary2_;
                let _e5652: vec4<f32> = temporary15_;
                temporary15_.y = (_e5650.zzzz - _e5652.xxxx).x;
                let _e5657: vec4<f32> = temporary2_;
                let _e5659: vec4<f32> = temporary15_;
                temporary15_.z = (_e5657.wwww + _e5659.yyyy).x;
                let _e5664: vec4<f32> = temporary15_;
                let _e5668: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e5664.zzzz / _e5668.xxxx).x;
                let _e5673: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e5673.xxxx).x;
                let _e5678: vec4<f32> = temporary17_;
                let _e5682: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e5678.xxxx * _e5682.xxxx).x;
                let _e5687: vec4<f32> = temporary17_;
                let _e5691: vec4<f32> = constant_registers[16u];
                temporary17_.z = f32((_e5687.yyyy.x == _e5691.yyyy.x));
                let _e5698: vec4<f32> = temporary17_;
                let _e5702: vec4<f32> = constant_registers[16u];
                if all((_e5698.zzzz != _e5702.xxxx)) {
                    let _e5708: vec4<f32> = constant_registers[13u];
                    let _e5710: vec4<f32> = temporary8_;
                    let _e5712: vec4<f32> = (_e5708.xyzz * _e5710.yyyy);
                    temporary15_.x = _e5712.x;
                    temporary15_.y = _e5712.y;
                    temporary15_.z = _e5712.z;
                    let _e5719: vec4<f32> = temporary0_;
                    let _e5721: vec4<f32> = temporary15_;
                    let _e5723: vec4<f32> = (_e5719.xyzz + _e5721.xyzz);
                    temporary0_.x = _e5723.x;
                    temporary0_.y = _e5723.y;
                    temporary0_.z = _e5723.z;
                } else {
                    let _e5732: vec4<f32> = constant_registers[14u];
                    let _e5734: vec4<f32> = temporary8_;
                    let _e5736: vec4<f32> = (_e5732.xyzz * _e5734.yyyy);
                    temporary15_.x = _e5736.x;
                    temporary15_.y = _e5736.y;
                    temporary15_.z = _e5736.z;
                    let _e5743: vec4<f32> = temporary0_;
                    let _e5745: vec4<f32> = temporary15_;
                    let _e5747: vec4<f32> = (_e5743.xyzz + _e5745.xyzz);
                    temporary0_.x = _e5747.x;
                    temporary0_.y = _e5747.y;
                    temporary0_.z = _e5747.z;
                }
            }
            let _e5754: vec4<f32> = temporary1_;
            let _e5758: vec4<f32> = constant_registers[18u];
            temporary8_.z = f32((_e5754.zzzz.x == _e5758.xxxx.x));
            let _e5765: vec4<f32> = temporary8_;
            let _e5769: vec4<f32> = constant_registers[16u];
            if all((_e5765.zzzz != _e5769.xxxx)) {
                let _e5773: vec4<f32> = temporary7_;
                let _e5775: vec4<f32> = temporary8_;
                let _e5777: vec4<f32> = (_e5773.xyzz * _e5775.yyyy);
                temporary15_.x = _e5777.x;
                temporary15_.y = _e5777.y;
                temporary15_.z = _e5777.z;
                let _e5784: vec4<f32> = temporary0_;
                let _e5786: vec4<f32> = temporary15_;
                let _e5788: vec4<f32> = (_e5784.xyzz + _e5786.xyzz);
                temporary0_.x = _e5788.x;
                temporary0_.y = _e5788.y;
                temporary0_.z = _e5788.z;
            }
        }
    }
    let _e5795: vec4<f32> = temporary9_;
    let _e5799: vec4<f32> = textureSample(texture0_, sampler2_, _e5795.xyzz.xyz);
    temporary1_ = _e5799;
    let _e5800: vec4<f32> = temporary11_;
    let _e5804: vec4<f32> = constant_registers[16u];
    if all((_e5800.zzzz != _e5804.xxxx)) {
        let _e5808: vec4<f32> = temporary0_;
        let _e5810: vec4<f32> = temporary1_;
        let _e5812: vec4<f32> = (_e5808.xyzz + _e5810.xyzz);
        temporary0_.x = _e5812.x;
        temporary0_.y = _e5812.y;
        temporary0_.z = _e5812.z;
    }
    let _e5819: vec4<f32> = temporary0_;
    let _e5821: vec4<f32> = temporary11_;
    let _e5823: vec4<f32> = (_e5819.xyzz / _e5821.yyyy);
    temporary0_.x = _e5823.x;
    temporary0_.y = _e5823.y;
    temporary0_.z = _e5823.z;
    let _e5830: vec4<f32> = temporary0_;
    dest_temp = _e5830;
    let _e5831: vec4<f32> = dest_temp;
    return FragmentOutput(_e5831);
}