ruffle/render/naga-agal/tests/snapshots/wgsl__complex_raytrace-2.snap

---
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 sampler4_: sampler;
@group(0) @binding(7) 
var sampler5_: sampler;
@group(0) @binding(8) 
var sampler6_: sampler;
@group(0) @binding(9) 
var sampler7_: sampler;
@group(0) @binding(10) 
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 _e12: vec4<f32> = constant_registers[16u];
    temporary0_ = _e12.xxxy;
    let _e19: vec4<f32> = constant_registers[3u];
    temporary1_.x = (param.xxxx * _e19.xxxx).x;
    temporary1_.y = param.yyyy.x;
    let _e30: vec4<f32> = constant_registers[1u];
    let _e31: vec4<f32> = _e30.xxxx;
    temporary1_.z = _e31.z;
    temporary1_.w = _e31.w;
    let _e36: vec4<f32> = temporary1_;
    let _e40: vec4<f32> = constant_registers[16u];
    let _e42: vec4<f32> = (_e36.zzzw * _e40.zzzz);
    temporary1_.z = _e42.z;
    temporary1_.w = _e42.w;
    let _e47: vec4<f32> = temporary1_;
    temporary1_.z = cos(_e47.zzzz).x;
    let _e52: vec4<f32> = temporary1_;
    let _e56: vec4<f32> = constant_registers[16u];
    temporary2_.x = (_e52.zzzz * _e56.wwww).x;
    let _e64: vec4<f32> = constant_registers[1u];
    temporary1_.z = _e64.yyyy.x;
    let _e68: vec4<f32> = temporary1_;
    let _e72: vec4<f32> = constant_registers[16u];
    temporary1_.z = (_e68.zzzz + _e72.yyyy).x;
    let _e77: vec4<f32> = temporary1_;
    let _e81: vec4<f32> = constant_registers[17u];
    temporary1_.z = (_e77.zzzz * _e81.xxxx).x;
    let _e86: vec4<f32> = temporary1_;
    let _e90: vec4<f32> = constant_registers[17u];
    temporary1_.z = max(_e86.zzzz, _e90.yyyy).x;
    let _e95: vec4<f32> = temporary1_;
    temporary1_.w = sin(_e95.wwww).x;
    let _e100: vec4<f32> = temporary1_;
    let _e104: vec4<f32> = constant_registers[16u];
    temporary2_.z = (_e100.wwww * _e104.wwww).x;
    let _e109: vec4<f32> = temporary1_;
    temporary2_.y = _e109.zzzz.x;
    let _e115: vec4<f32> = constant_registers[16u];
    let _e116: vec4<f32> = _e115.xxxx;
    temporary4_.x = _e116.x;
    temporary4_.z = _e116.z;
    let _e124: vec4<f32> = constant_registers[17u];
    temporary4_.y = _e124.zzzz.x;
    let _e130: vec4<f32> = constant_registers[16u];
    temporary1_.w = _e130.yyyy.x;
    let _e134: vec4<f32> = temporary4_;
    let _e136: vec4<f32> = temporary2_;
    let _e138: vec4<f32> = (_e134.xyzz - _e136.xyzz);
    temporary3_.x = _e138.x;
    temporary3_.y = _e138.y;
    temporary3_.z = _e138.z;
    let _e146: vec4<f32> = temporary3_;
    let _e148: vec3<f32> = normalize(_e146.xyz);
    temporary3_.x = _e148.x;
    temporary3_.y = _e148.y;
    temporary3_.z = _e148.z;
    let _e157: vec4<f32> = constant_registers[16u];
    let _e159: vec4<f32> = temporary3_;
    let _e161: vec3<f32> = cross(_e157.xyx, _e159.xyz);
    let _e166: vec4<f32> = vec4<f32>(_e161.x, _e161.y, _e161.z, 1.0);
    temporary5_.x = _e166.x;
    temporary5_.y = _e166.y;
    temporary5_.z = _e166.z;
    let _e174: vec4<f32> = temporary5_;
    let _e176: vec3<f32> = normalize(_e174.xyz);
    temporary6_.x = _e176.x;
    temporary6_.y = _e176.y;
    temporary6_.z = _e176.z;
    let _e184: vec4<f32> = temporary3_;
    let _e186: vec4<f32> = temporary6_;
    let _e188: vec3<f32> = cross(_e184.xyz, _e186.xyz);
    let _e193: vec4<f32> = vec4<f32>(_e188.x, _e188.y, _e188.z, 1.0);
    temporary5_.x = _e193.x;
    temporary5_.y = _e193.y;
    temporary5_.z = _e193.z;
    let _e200: vec4<f32> = temporary3_;
    let _e202: vec4<f32> = temporary1_;
    let _e204: vec4<f32> = (_e200.xyzz * _e202.wwww);
    temporary3_.x = _e204.x;
    temporary3_.y = _e204.y;
    temporary3_.z = _e204.z;
    let _e211: vec4<f32> = temporary6_;
    let _e213: vec4<f32> = temporary1_;
    let _e215: vec4<f32> = (_e211.xyzz * _e213.xxxx);
    temporary6_.x = _e215.x;
    temporary6_.y = _e215.y;
    temporary6_.z = _e215.z;
    let _e222: vec4<f32> = temporary3_;
    let _e224: vec4<f32> = temporary6_;
    let _e226: vec4<f32> = (_e222.xyzz + _e224.xyzz);
    temporary7_.x = _e226.x;
    temporary7_.y = _e226.y;
    temporary7_.z = _e226.z;
    let _e234: vec4<f32> = temporary5_;
    let _e236: vec4<f32> = temporary1_;
    let _e238: vec4<f32> = (_e234.xyzz * _e236.yyyy);
    temporary5_.x = _e238.x;
    temporary5_.y = _e238.y;
    temporary5_.z = _e238.z;
    let _e245: vec4<f32> = temporary7_;
    let _e247: vec4<f32> = temporary5_;
    let _e249: vec4<f32> = (_e245.xyzz + _e247.xyzz);
    temporary5_.x = _e249.x;
    temporary5_.y = _e249.y;
    temporary5_.z = _e249.z;
    let _e256: vec4<f32> = temporary5_;
    let _e258: vec3<f32> = normalize(_e256.xyz);
    temporary8_.x = _e258.x;
    temporary8_.y = _e258.y;
    temporary8_.z = _e258.z;
    let _e266: vec4<f32> = temporary8_;
    let _e267: vec4<f32> = _e266.xyzz;
    temporary10_.x = _e267.x;
    temporary10_.y = _e267.y;
    temporary10_.z = _e267.z;
    let _e275: vec4<f32> = temporary10_;
    let _e276: vec4<f32> = _e275.xyzz;
    temporary9_.x = _e276.x;
    temporary9_.y = _e276.y;
    temporary9_.z = _e276.z;
    let _e286: vec4<f32> = constant_registers[16u];
    let _e287: vec4<f32> = _e286.yxxx;
    temporary11_.x = _e287.x;
    temporary11_.y = _e287.y;
    temporary11_.z = _e287.z;
    let _e295: vec4<f32> = temporary11_;
    let _e299: vec4<f32> = constant_registers[16u];
    if all((_e295.xxxx != _e299.xxxx)) {
        let _e305: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e305.xxxx.x;
        let _e311: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e311.wwww.x;
        let _e317: vec4<f32> = constant_registers[16u];
        let _e318: vec4<f32> = _e317.xyxx;
        temporary3_.x = _e318.x;
        temporary3_.y = _e318.y;
        temporary3_.z = _e318.z;
        let _e325: vec4<f32> = temporary3_;
        let _e326: vec4<f32> = _e325.xyzz;
        temporary12_.x = _e326.x;
        temporary12_.y = _e326.y;
        temporary12_.z = _e326.z;
        let _e336: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e336.wwww.x;
        let _e340: vec4<f32> = temporary2_;
        let _e344: vec4<f32> = constant_registers[16u];
        let _e346: vec4<f32> = (_e340.xyzz - _e344.xxxx);
        temporary13_.x = _e346.x;
        temporary13_.y = _e346.y;
        temporary13_.z = _e346.z;
        let _e354: vec4<f32> = temporary13_;
        let _e356: vec4<f32> = temporary12_;
        temporary1_.y = dot(_e354.xyz, _e356.xyz);
        let _e360: vec4<f32> = temporary1_;
        temporary1_.y = -(_e360.yyyy).x;
        let _e365: vec4<f32> = temporary9_;
        let _e367: vec4<f32> = temporary12_;
        temporary12_.x = dot(_e365.xyz, _e367.xyz);
        let _e371: vec4<f32> = temporary1_;
        let _e373: vec4<f32> = temporary12_;
        temporary12_.y = (_e371.yyyy / _e373.xxxx).x;
        let _e378: vec4<f32> = temporary12_;
        temporary1_.y = _e378.yyyy.x;
        let _e384: vec4<f32> = constant_registers[16u];
        let _e386: vec4<f32> = temporary1_;
        temporary1_.w = vec4<f32>((_e384.xxxx < _e386.yyyy)).x;
        let _e392: vec4<f32> = temporary1_;
        let _e396: vec4<f32> = constant_registers[16u];
        if all((_e392.wwww != _e396.xxxx)) {
            let _e400: vec4<f32> = temporary1_;
            temporary1_.x = _e400.yyyy.x;
        }
        let _e404: vec4<f32> = temporary1_;
        temporary4_.y = _e404.xxxx.x;
        let _e408: vec4<f32> = temporary4_;
        let _e410: vec4<f32> = temporary4_;
        temporary1_.x = vec4<f32>((_e408.yyyy < _e410.zzzz)).x;
        let _e416: vec4<f32> = temporary1_;
        let _e420: vec4<f32> = constant_registers[16u];
        if all((_e416.xxxx != _e420.xxxx)) {
            let _e424: vec4<f32> = temporary4_;
            temporary4_.z = _e424.yyyy.x;
            let _e428: vec4<f32> = temporary3_;
            let _e429: vec4<f32> = _e428.xyzz;
            temporary6_.x = _e429.x;
            temporary6_.y = _e429.y;
            temporary6_.z = _e429.z;
            let _e438: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e438.yyyy.x;
        }
        let _e442: vec4<f32> = temporary2_;
        let _e443: vec4<f32> = _e442.xyzz;
        temporary5_.x = _e443.x;
        temporary5_.y = _e443.y;
        temporary5_.z = _e443.z;
        let _e450: vec4<f32> = temporary9_;
        let _e451: vec4<f32> = _e450.xyzz;
        temporary10_.x = _e451.x;
        temporary10_.y = _e451.y;
        temporary10_.z = _e451.z;
        let _e460: vec4<f32> = constant_registers[4u];
        let _e461: vec4<f32> = _e460.xyzz;
        temporary8_.x = _e461.x;
        temporary8_.y = _e461.y;
        temporary8_.z = _e461.z;
        let _e470: vec4<f32> = constant_registers[6u];
        temporary14_.x = _e470.xxxx.x;
        let _e475: vec4<f32> = temporary3_;
        let _e476: vec4<f32> = _e475.xyzz;
        temporary15_.x = _e476.x;
        temporary15_.y = _e476.y;
        temporary15_.z = _e476.z;
        let _e486: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e486.wwww.x;
        let _e490: vec4<f32> = temporary5_;
        let _e492: vec4<f32> = temporary8_;
        let _e494: vec4<f32> = (_e490.xyzz - _e492.xyzz);
        temporary16_.x = _e494.x;
        temporary16_.y = _e494.y;
        temporary16_.z = _e494.z;
        let _e502: vec4<f32> = temporary16_;
        let _e504: vec4<f32> = temporary10_;
        temporary14_.z = dot(_e502.xyz, _e504.xyz);
        let _e508: vec4<f32> = temporary14_;
        let _e510: vec4<f32> = temporary14_;
        let _e512: vec4<f32> = (_e508.zzzx * _e510.zzzx);
        temporary4_.x = _e512.x;
        temporary4_.w = _e512.w;
        let _e517: vec4<f32> = temporary16_;
        let _e519: vec4<f32> = temporary16_;
        temporary1_.y = dot(_e517.xyz, _e519.xyz);
        let _e523: vec4<f32> = temporary4_;
        let _e525: vec4<f32> = temporary1_;
        temporary1_.w = (_e523.xxxx - _e525.yyyy).x;
        let _e530: vec4<f32> = temporary1_;
        let _e532: vec4<f32> = temporary4_;
        temporary13_.x = (_e530.wwww + _e532.wwww).x;
        let _e537: vec4<f32> = temporary13_;
        temporary1_.w = _e537.xxxx.x;
        let _e543: vec4<f32> = constant_registers[16u];
        let _e545: vec4<f32> = temporary1_;
        temporary2_.w = vec4<f32>((_e543.xxxx < _e545.wwww)).x;
        let _e551: vec4<f32> = temporary2_;
        let _e555: vec4<f32> = constant_registers[16u];
        if all((_e551.wwww != _e555.xxxx)) {
            let _e559: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e559.wwww).x;
            let _e564: vec4<f32> = temporary14_;
            temporary1_.y = -(_e564.zzzz).x;
            let _e569: vec4<f32> = temporary1_;
            let _e571: vec4<f32> = temporary1_;
            temporary2_.w = (_e569.yyyy - _e571.wwww).x;
            let _e578: vec4<f32> = constant_registers[16u];
            let _e580: vec4<f32> = temporary2_;
            temporary1_.y = vec4<f32>((_e578.xxxx < _e580.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 = vec4<f32>((_e669.yyyy < _e671.zzzz)).x;
        let _e677: vec4<f32> = temporary1_;
        let _e681: vec4<f32> = constant_registers[16u];
        if all((_e677.xxxx != _e681.xxxx)) {
            let _e685: vec4<f32> = temporary4_;
            temporary4_.z = _e685.yyyy.x;
            let _e689: vec4<f32> = temporary3_;
            let _e690: vec4<f32> = _e689.xyzz;
            temporary6_.x = _e690.x;
            temporary6_.y = _e690.y;
            temporary6_.z = _e690.z;
            let _e699: vec4<f32> = constant_registers[5u];
            let _e700: vec4<f32> = _e699.xyzz;
            temporary7_.x = _e700.x;
            temporary7_.y = _e700.y;
            temporary7_.z = _e700.z;
            let _e709: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e709.xxxx.x;
        }
        let _e713: vec4<f32> = temporary2_;
        let _e714: vec4<f32> = _e713.xyzz;
        temporary5_.x = _e714.x;
        temporary5_.y = _e714.y;
        temporary5_.z = _e714.z;
        let _e721: vec4<f32> = temporary9_;
        let _e722: vec4<f32> = _e721.xyzz;
        temporary10_.x = _e722.x;
        temporary10_.y = _e722.y;
        temporary10_.z = _e722.z;
        let _e731: vec4<f32> = constant_registers[7u];
        let _e732: vec4<f32> = _e731.xyzz;
        temporary8_.x = _e732.x;
        temporary8_.y = _e732.y;
        temporary8_.z = _e732.z;
        let _e741: vec4<f32> = constant_registers[9u];
        temporary15_.x = _e741.xxxx.x;
        let _e745: vec4<f32> = temporary3_;
        let _e746: vec4<f32> = _e745.xyzz;
        temporary18_.x = _e746.x;
        temporary18_.y = _e746.y;
        temporary18_.z = _e746.z;
        let _e756: vec4<f32> = constant_registers[17u];
        temporary1_.x = _e756.wwww.x;
        let _e760: vec4<f32> = temporary5_;
        let _e762: vec4<f32> = temporary8_;
        let _e764: vec4<f32> = (_e760.xyzz - _e762.xyzz);
        temporary17_.x = _e764.x;
        temporary17_.y = _e764.y;
        temporary17_.z = _e764.z;
        let _e772: vec4<f32> = temporary17_;
        let _e774: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e772.xyz, _e774.xyz);
        let _e778: vec4<f32> = temporary15_;
        let _e780: vec4<f32> = temporary15_;
        let _e782: vec4<f32> = (_e778.zzzx * _e780.zzzx);
        temporary4_.x = _e782.x;
        temporary4_.w = _e782.w;
        let _e787: vec4<f32> = temporary17_;
        let _e789: vec4<f32> = temporary17_;
        temporary1_.y = dot(_e787.xyz, _e789.xyz);
        let _e793: vec4<f32> = temporary4_;
        let _e795: vec4<f32> = temporary1_;
        temporary1_.w = (_e793.xxxx - _e795.yyyy).x;
        let _e800: vec4<f32> = temporary1_;
        let _e802: vec4<f32> = temporary4_;
        temporary13_.x = (_e800.wwww + _e802.wwww).x;
        let _e807: vec4<f32> = temporary13_;
        temporary1_.w = _e807.xxxx.x;
        let _e813: vec4<f32> = constant_registers[16u];
        let _e815: vec4<f32> = temporary1_;
        temporary2_.w = vec4<f32>((_e813.xxxx < _e815.wwww)).x;
        let _e821: vec4<f32> = temporary2_;
        let _e825: vec4<f32> = constant_registers[16u];
        if all((_e821.wwww != _e825.xxxx)) {
            let _e829: vec4<f32> = temporary1_;
            temporary1_.w = sqrt(_e829.wwww).x;
            let _e834: vec4<f32> = temporary15_;
            temporary1_.y = -(_e834.zzzz).x;
            let _e839: vec4<f32> = temporary1_;
            let _e841: vec4<f32> = temporary1_;
            temporary2_.w = (_e839.yyyy - _e841.wwww).x;
            let _e848: vec4<f32> = constant_registers[16u];
            let _e850: vec4<f32> = temporary2_;
            temporary1_.y = vec4<f32>((_e848.xxxx < _e850.wwww)).x;
            let _e856: vec4<f32> = temporary1_;
            let _e860: vec4<f32> = constant_registers[16u];
            if all((_e856.yyyy != _e860.xxxx)) {
                let _e864: vec4<f32> = temporary2_;
                temporary1_.x = _e864.wwww.x;
                let _e868: vec4<f32> = temporary10_;
                let _e870: vec4<f32> = temporary2_;
                let _e872: vec4<f32> = (_e868.xyzz * _e870.wwww);
                temporary13_.x = _e872.x;
                temporary13_.y = _e872.y;
                temporary13_.z = _e872.z;
                let _e879: vec4<f32> = temporary5_;
                let _e881: vec4<f32> = temporary13_;
                let _e883: vec4<f32> = (_e879.xyzz + _e881.xyzz);
                temporary12_.x = _e883.x;
                temporary12_.y = _e883.y;
                temporary12_.z = _e883.z;
                let _e890: vec4<f32> = temporary12_;
                let _e892: vec4<f32> = temporary8_;
                let _e894: vec4<f32> = (_e890.xyzz - _e892.xyzz);
                temporary14_.x = _e894.x;
                temporary14_.y = _e894.y;
                temporary14_.z = _e894.z;
                let _e901: vec4<f32> = temporary14_;
                let _e903: vec3<f32> = normalize(_e901.xyz);
                temporary16_.x = _e903.x;
                temporary16_.y = _e903.y;
                temporary16_.z = _e903.z;
                let _e910: vec4<f32> = temporary16_;
                let _e911: vec4<f32> = _e910.xyzz;
                temporary20_.x = _e911.x;
                temporary20_.y = _e911.y;
                temporary20_.z = _e911.z;
                let _e918: vec4<f32> = temporary20_;
                let _e919: vec4<f32> = _e918.xyzz;
                temporary18_.x = _e919.x;
                temporary18_.y = _e919.y;
                temporary18_.z = _e919.z;
            }
        }
        let _e926: vec4<f32> = temporary1_;
        temporary4_.y = _e926.xxxx.x;
        let _e930: vec4<f32> = temporary18_;
        let _e931: vec4<f32> = _e930.xyzz;
        temporary3_.x = _e931.x;
        temporary3_.y = _e931.y;
        temporary3_.z = _e931.z;
        let _e938: vec4<f32> = temporary4_;
        let _e940: vec4<f32> = temporary4_;
        temporary1_.x = vec4<f32>((_e938.yyyy < _e940.zzzz)).x;
        let _e946: vec4<f32> = temporary1_;
        let _e950: vec4<f32> = constant_registers[16u];
        if all((_e946.xxxx != _e950.xxxx)) {
            let _e954: vec4<f32> = temporary4_;
            temporary4_.z = _e954.yyyy.x;
            let _e958: vec4<f32> = temporary3_;
            let _e959: vec4<f32> = _e958.xyzz;
            temporary6_.x = _e959.x;
            temporary6_.y = _e959.y;
            temporary6_.z = _e959.z;
            let _e968: vec4<f32> = constant_registers[8u];
            let _e969: vec4<f32> = _e968.xyzz;
            temporary7_.x = _e969.x;
            temporary7_.y = _e969.y;
            temporary7_.z = _e969.z;
            let _e978: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e978.xxxx.x;
        }
        let _e982: vec4<f32> = temporary2_;
        let _e983: vec4<f32> = _e982.xyzz;
        temporary5_.x = _e983.x;
        temporary5_.y = _e983.y;
        temporary5_.z = _e983.z;
        let _e990: vec4<f32> = temporary9_;
        let _e991: vec4<f32> = _e990.xyzz;
        temporary10_.x = _e991.x;
        temporary10_.y = _e991.y;
        temporary10_.z = _e991.z;
        let _e1000: vec4<f32> = constant_registers[10u];
        let _e1001: vec4<f32> = _e1000.xyzz;
        temporary8_.x = _e1001.x;
        temporary8_.y = _e1001.y;
        temporary8_.z = _e1001.z;
        let _e1010: vec4<f32> = constant_registers[12u];
        temporary15_.x = _e1010.xxxx.x;
        let _e1014: vec4<f32> = temporary3_;
        let _e1015: vec4<f32> = _e1014.xyzz;
        temporary17_.x = _e1015.x;
        temporary17_.y = _e1015.y;
        temporary17_.z = _e1015.z;
        let _e1024: vec4<f32> = constant_registers[17u];
        temporary15_.y = _e1024.wwww.x;
        let _e1028: vec4<f32> = temporary5_;
        let _e1030: vec4<f32> = temporary8_;
        let _e1032: vec4<f32> = (_e1028.xyzz - _e1030.xyzz);
        temporary18_.x = _e1032.x;
        temporary18_.y = _e1032.y;
        temporary18_.z = _e1032.z;
        let _e1039: vec4<f32> = temporary18_;
        let _e1041: vec4<f32> = temporary10_;
        temporary15_.z = dot(_e1039.xyz, _e1041.xyz);
        let _e1045: vec4<f32> = temporary15_;
        let _e1047: vec4<f32> = temporary15_;
        let _e1049: vec4<f32> = (_e1045.zzzx * _e1047.zzzx);
        temporary1_.x = _e1049.x;
        temporary1_.w = _e1049.w;
        let _e1054: vec4<f32> = temporary18_;
        let _e1056: vec4<f32> = temporary18_;
        temporary19_.y = dot(_e1054.xyz, _e1056.xyz);
        let _e1061: vec4<f32> = temporary1_;
        let _e1063: vec4<f32> = temporary19_;
        temporary19_.z = (_e1061.xxxx - _e1063.yyyy).x;
        let _e1068: vec4<f32> = temporary19_;
        let _e1070: vec4<f32> = temporary1_;
        temporary13_.x = (_e1068.zzzz + _e1070.wwww).x;
        let _e1075: vec4<f32> = temporary13_;
        temporary1_.x = _e1075.xxxx.x;
        let _e1081: vec4<f32> = constant_registers[16u];
        let _e1083: vec4<f32> = temporary1_;
        temporary19_.x = vec4<f32>((_e1081.xxxx < _e1083.xxxx)).x;
        let _e1089: vec4<f32> = temporary19_;
        let _e1093: vec4<f32> = constant_registers[16u];
        if all((_e1089.xxxx != _e1093.xxxx)) {
            let _e1097: vec4<f32> = temporary1_;
            temporary1_.x = sqrt(_e1097.xxxx).x;
            let _e1102: vec4<f32> = temporary15_;
            temporary19_.y = -(_e1102.zzzz).x;
            let _e1107: vec4<f32> = temporary19_;
            let _e1109: vec4<f32> = temporary1_;
            temporary19_.z = (_e1107.yyyy - _e1109.xxxx).x;
            let _e1114: vec4<f32> = temporary19_;
            temporary19_.x = _e1114.zzzz.x;
            let _e1120: vec4<f32> = constant_registers[16u];
            let _e1122: vec4<f32> = temporary19_;
            temporary19_.y = vec4<f32>((_e1120.xxxx < _e1122.xxxx)).x;
            let _e1128: vec4<f32> = temporary19_;
            let _e1132: vec4<f32> = constant_registers[16u];
            if all((_e1128.yyyy != _e1132.xxxx)) {
                let _e1136: vec4<f32> = temporary19_;
                temporary15_.y = _e1136.xxxx.x;
                let _e1140: vec4<f32> = temporary10_;
                let _e1142: vec4<f32> = temporary19_;
                let _e1144: vec4<f32> = (_e1140.xyzz * _e1142.xxxx);
                temporary13_.x = _e1144.x;
                temporary13_.y = _e1144.y;
                temporary13_.z = _e1144.z;
                let _e1151: vec4<f32> = temporary5_;
                let _e1153: vec4<f32> = temporary13_;
                let _e1155: vec4<f32> = (_e1151.xyzz + _e1153.xyzz);
                temporary12_.x = _e1155.x;
                temporary12_.y = _e1155.y;
                temporary12_.z = _e1155.z;
                let _e1162: vec4<f32> = temporary12_;
                let _e1164: vec4<f32> = temporary8_;
                let _e1166: vec4<f32> = (_e1162.xyzz - _e1164.xyzz);
                temporary14_.x = _e1166.x;
                temporary14_.y = _e1166.y;
                temporary14_.z = _e1166.z;
                let _e1173: vec4<f32> = temporary14_;
                let _e1175: vec3<f32> = normalize(_e1173.xyz);
                temporary16_.x = _e1175.x;
                temporary16_.y = _e1175.y;
                temporary16_.z = _e1175.z;
                let _e1182: vec4<f32> = temporary16_;
                let _e1183: vec4<f32> = _e1182.xyzz;
                temporary20_.x = _e1183.x;
                temporary20_.y = _e1183.y;
                temporary20_.z = _e1183.z;
                let _e1190: vec4<f32> = temporary20_;
                let _e1191: vec4<f32> = _e1190.xyzz;
                temporary17_.x = _e1191.x;
                temporary17_.y = _e1191.y;
                temporary17_.z = _e1191.z;
            }
        }
        let _e1198: vec4<f32> = temporary15_;
        temporary4_.y = _e1198.yyyy.x;
        let _e1202: vec4<f32> = temporary17_;
        let _e1203: vec4<f32> = _e1202.xyzz;
        temporary3_.x = _e1203.x;
        temporary3_.y = _e1203.y;
        temporary3_.z = _e1203.z;
        let _e1210: vec4<f32> = temporary4_;
        let _e1212: vec4<f32> = temporary4_;
        temporary1_.y = vec4<f32>((_e1210.yyyy < _e1212.zzzz)).x;
        let _e1218: vec4<f32> = temporary1_;
        let _e1222: vec4<f32> = constant_registers[16u];
        if all((_e1218.yyyy != _e1222.xxxx)) {
            let _e1226: vec4<f32> = temporary4_;
            temporary4_.z = _e1226.yyyy.x;
            let _e1230: vec4<f32> = temporary3_;
            let _e1231: vec4<f32> = _e1230.xyzz;
            temporary6_.x = _e1231.x;
            temporary6_.y = _e1231.y;
            temporary6_.z = _e1231.z;
            let _e1240: vec4<f32> = constant_registers[11u];
            let _e1241: vec4<f32> = _e1240.xyzz;
            temporary7_.x = _e1241.x;
            temporary7_.y = _e1241.y;
            temporary7_.z = _e1241.z;
            let _e1250: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e1250.xxxx.x;
        }
        let _e1254: vec4<f32> = temporary11_;
        let _e1258: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e1254.yyyy + _e1258.yyyy).x;
        let _e1263: vec4<f32> = temporary1_;
        let _e1267: vec4<f32> = constant_registers[16u];
        temporary1_.y = vec4<f32>((_e1263.zzzz == _e1267.xxxx)).x;
        let _e1273: vec4<f32> = temporary1_;
        let _e1277: vec4<f32> = constant_registers[16u];
        if all((_e1273.yyyy != _e1277.xxxx)) {
            let _e1283: vec4<f32> = constant_registers[16u];
            let _e1284: vec4<f32> = _e1283.xyyy;
            temporary11_.x = _e1284.x;
            temporary11_.z = _e1284.z;
        } else {
            let _e1289: vec4<f32> = temporary9_;
            let _e1291: vec4<f32> = temporary4_;
            let _e1293: vec4<f32> = (_e1289.xyzz * _e1291.zzzz);
            temporary5_.x = _e1293.x;
            temporary5_.y = _e1293.y;
            temporary5_.z = _e1293.z;
            let _e1300: vec4<f32> = temporary2_;
            let _e1302: vec4<f32> = temporary5_;
            let _e1304: vec4<f32> = (_e1300.xyzz + _e1302.xyzz);
            temporary2_.x = _e1304.x;
            temporary2_.y = _e1304.y;
            temporary2_.z = _e1304.z;
            let _e1311: vec4<f32> = temporary9_;
            let _e1313: vec4<f32> = temporary6_;
            temporary1_.y = dot(_e1311.xyz, _e1313.xyz);
            let _e1317: vec4<f32> = temporary1_;
            let _e1321: vec4<f32> = constant_registers[18u];
            temporary5_.x = (_e1317.yyyy * _e1321.xxxx).x;
            let _e1326: vec4<f32> = temporary5_;
            let _e1328: vec4<f32> = temporary6_;
            let _e1330: vec4<f32> = (_e1326.xxxx * _e1328.xyzz);
            temporary10_.x = _e1330.x;
            temporary10_.y = _e1330.y;
            temporary10_.z = _e1330.z;
            let _e1337: vec4<f32> = temporary9_;
            let _e1339: vec4<f32> = temporary10_;
            let _e1341: vec4<f32> = (_e1337.xyzz - _e1339.xyzz);
            temporary9_.x = _e1341.x;
            temporary9_.y = _e1341.y;
            temporary9_.z = _e1341.z;
            let _e1348: vec4<f32> = temporary9_;
            let _e1352: vec4<f32> = constant_registers[18u];
            let _e1354: vec4<f32> = (_e1348.xyzz * _e1352.yyyy);
            temporary5_.x = _e1354.x;
            temporary5_.y = _e1354.y;
            temporary5_.z = _e1354.z;
            let _e1361: vec4<f32> = temporary2_;
            let _e1363: vec4<f32> = temporary5_;
            let _e1365: vec4<f32> = (_e1361.xyzz + _e1363.xyzz);
            temporary2_.x = _e1365.x;
            temporary2_.y = _e1365.y;
            temporary2_.z = _e1365.z;
            let _e1374: vec4<f32> = constant_registers[15u];
            let _e1376: vec4<f32> = temporary2_;
            let _e1378: vec4<f32> = (_e1374.xyzz - _e1376.xyzz);
            temporary5_.x = _e1378.x;
            temporary5_.y = _e1378.y;
            temporary5_.z = _e1378.z;
            let _e1385: vec4<f32> = temporary5_;
            let _e1387: vec3<f32> = normalize(_e1385.xyz);
            temporary10_.x = _e1387.x;
            temporary10_.y = _e1387.y;
            temporary10_.z = _e1387.z;
            let _e1394: vec4<f32> = temporary5_;
            let _e1396: vec4<f32> = temporary5_;
            temporary8_.x = dot(_e1394.xyz, _e1396.xyz);
            let _e1400: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e1400.xxxx).x;
            let _e1405: vec4<f32> = temporary6_;
            let _e1407: vec4<f32> = temporary10_;
            temporary8_.y = dot(_e1405.xyz, _e1407.xyz);
            let _e1411: vec4<f32> = temporary8_;
            temporary8_.z = saturate(_e1411.yyyy).x;
            let _e1416: vec4<f32> = temporary1_;
            let _e1418: vec4<f32> = temporary1_;
            temporary2_.w = (_e1416.yyyy * _e1418.yyyy).x;
            let _e1423: vec4<f32> = temporary2_;
            let _e1427: vec4<f32> = constant_registers[18u];
            temporary15_.x = (_e1423.wwww * _e1427.zzzz).x;
            let _e1434: vec4<f32> = constant_registers[18u];
            let _e1436: vec4<f32> = temporary15_;
            temporary15_.y = (_e1434.wwww + _e1436.xxxx).x;
            let _e1441: vec4<f32> = temporary8_;
            let _e1443: vec4<f32> = temporary15_;
            temporary8_.x = (_e1441.zzzz / _e1443.yyyy).x;
            let _e1450: vec4<f32> = constant_registers[6u];
            temporary8_.z = _e1450.xxxx.x;
            let _e1456: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1456.wwww.x;
            let _e1460: vec4<f32> = temporary2_;
            let _e1464: vec4<f32> = constant_registers[4u];
            let _e1466: vec4<f32> = (_e1460.xyzz - _e1464.xyzz);
            temporary19_.x = _e1466.x;
            temporary19_.y = _e1466.y;
            temporary19_.z = _e1466.z;
            let _e1473: vec4<f32> = temporary19_;
            let _e1475: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1473.xyz, _e1475.xyz);
            let _e1479: vec4<f32> = temporary13_;
            let _e1481: vec4<f32> = temporary13_;
            temporary13_.z = (_e1479.xxxx * _e1481.xxxx).x;
            let _e1486: vec4<f32> = temporary19_;
            let _e1488: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1486.xyz, _e1488.xyz);
            let _e1492: vec4<f32> = temporary13_;
            let _e1494: vec4<f32> = temporary3_;
            temporary12_.x = (_e1492.zzzz - _e1494.wwww).x;
            let _e1499: vec4<f32> = temporary8_;
            let _e1501: vec4<f32> = temporary8_;
            temporary12_.y = (_e1499.zzzz * _e1501.zzzz).x;
            let _e1506: vec4<f32> = temporary12_;
            let _e1508: vec4<f32> = temporary12_;
            temporary13_.y = (_e1506.xxxx + _e1508.yyyy).x;
            let _e1515: vec4<f32> = constant_registers[16u];
            let _e1517: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1515.xxxx < _e1517.yyyy)).x;
            let _e1523: vec4<f32> = temporary13_;
            let _e1527: vec4<f32> = constant_registers[16u];
            if all((_e1523.zzzz != _e1527.xxxx)) {
                let _e1531: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1531.yyyy).x;
                let _e1536: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1536.xxxx).x;
                let _e1541: vec4<f32> = temporary3_;
                let _e1543: vec4<f32> = temporary13_;
                temporary13_.z = (_e1541.wwww - _e1543.yyyy).x;
                let _e1550: vec4<f32> = constant_registers[16u];
                let _e1552: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1550.xxxx < _e1552.zzzz)).x;
                let _e1558: vec4<f32> = temporary3_;
                let _e1562: vec4<f32> = constant_registers[16u];
                if all((_e1558.wwww != _e1562.xxxx)) {
                    let _e1566: vec4<f32> = temporary13_;
                    temporary2_.w = _e1566.zzzz.x;
                }
            }
            let _e1570: vec4<f32> = temporary2_;
            let _e1572: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1570.wwww < _e1572.yyyy)).x;
            let _e1578: vec4<f32> = temporary8_;
            let _e1582: vec4<f32> = constant_registers[16u];
            if all((_e1578.yyyy != _e1582.xxxx)) {
                let _e1588: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1588.xxxx.x;
            }
            let _e1594: vec4<f32> = constant_registers[9u];
            temporary8_.z = _e1594.xxxx.x;
            let _e1600: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1600.wwww.x;
            let _e1604: vec4<f32> = temporary2_;
            let _e1608: vec4<f32> = constant_registers[7u];
            let _e1610: vec4<f32> = (_e1604.xyzz - _e1608.xyzz);
            temporary19_.x = _e1610.x;
            temporary19_.y = _e1610.y;
            temporary19_.z = _e1610.z;
            let _e1617: vec4<f32> = temporary19_;
            let _e1619: vec4<f32> = temporary10_;
            temporary13_.x = dot(_e1617.xyz, _e1619.xyz);
            let _e1623: vec4<f32> = temporary13_;
            let _e1625: vec4<f32> = temporary13_;
            temporary13_.z = (_e1623.xxxx * _e1625.xxxx).x;
            let _e1630: vec4<f32> = temporary19_;
            let _e1632: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1630.xyz, _e1632.xyz);
            let _e1636: vec4<f32> = temporary13_;
            let _e1638: vec4<f32> = temporary3_;
            temporary12_.x = (_e1636.zzzz - _e1638.wwww).x;
            let _e1643: vec4<f32> = temporary8_;
            let _e1645: vec4<f32> = temporary8_;
            temporary12_.y = (_e1643.zzzz * _e1645.zzzz).x;
            let _e1650: vec4<f32> = temporary12_;
            let _e1652: vec4<f32> = temporary12_;
            temporary13_.y = (_e1650.xxxx + _e1652.yyyy).x;
            let _e1659: vec4<f32> = constant_registers[16u];
            let _e1661: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1659.xxxx < _e1661.yyyy)).x;
            let _e1667: vec4<f32> = temporary13_;
            let _e1671: vec4<f32> = constant_registers[16u];
            if all((_e1667.zzzz != _e1671.xxxx)) {
                let _e1675: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1675.yyyy).x;
                let _e1680: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1680.xxxx).x;
                let _e1685: vec4<f32> = temporary3_;
                let _e1687: vec4<f32> = temporary13_;
                temporary13_.z = (_e1685.wwww - _e1687.yyyy).x;
                let _e1694: vec4<f32> = constant_registers[16u];
                let _e1696: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1694.xxxx < _e1696.zzzz)).x;
                let _e1702: vec4<f32> = temporary3_;
                let _e1706: vec4<f32> = constant_registers[16u];
                if all((_e1702.wwww != _e1706.xxxx)) {
                    let _e1710: vec4<f32> = temporary13_;
                    temporary2_.w = _e1710.zzzz.x;
                }
            }
            let _e1714: vec4<f32> = temporary2_;
            let _e1716: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1714.wwww < _e1716.yyyy)).x;
            let _e1722: vec4<f32> = temporary8_;
            let _e1726: vec4<f32> = constant_registers[16u];
            if all((_e1722.yyyy != _e1726.xxxx)) {
                let _e1732: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1732.xxxx.x;
            }
            let _e1736: vec4<f32> = temporary2_;
            let _e1737: vec4<f32> = _e1736.xyzz;
            temporary15_.x = _e1737.x;
            temporary15_.y = _e1737.y;
            temporary15_.z = _e1737.z;
            let _e1744: vec4<f32> = temporary10_;
            let _e1745: vec4<f32> = _e1744.xyzz;
            temporary17_.x = _e1745.x;
            temporary17_.y = _e1745.y;
            temporary17_.z = _e1745.z;
            let _e1754: vec4<f32> = constant_registers[10u];
            let _e1755: vec4<f32> = _e1754.xyzz;
            temporary18_.x = _e1755.x;
            temporary18_.y = _e1755.y;
            temporary18_.z = _e1755.z;
            let _e1764: vec4<f32> = constant_registers[12u];
            temporary8_.z = _e1764.xxxx.x;
            let _e1770: vec4<f32> = constant_registers[17u];
            temporary2_.w = _e1770.wwww.x;
            let _e1774: vec4<f32> = temporary15_;
            let _e1776: vec4<f32> = temporary18_;
            let _e1778: vec4<f32> = (_e1774.xyzz - _e1776.xyzz);
            temporary19_.x = _e1778.x;
            temporary19_.y = _e1778.y;
            temporary19_.z = _e1778.z;
            let _e1785: vec4<f32> = temporary19_;
            let _e1787: vec4<f32> = temporary17_;
            temporary13_.x = dot(_e1785.xyz, _e1787.xyz);
            let _e1791: vec4<f32> = temporary13_;
            let _e1793: vec4<f32> = temporary13_;
            temporary13_.z = (_e1791.xxxx * _e1793.xxxx).x;
            let _e1798: vec4<f32> = temporary19_;
            let _e1800: vec4<f32> = temporary19_;
            temporary3_.w = dot(_e1798.xyz, _e1800.xyz);
            let _e1804: vec4<f32> = temporary13_;
            let _e1806: vec4<f32> = temporary3_;
            temporary12_.x = (_e1804.zzzz - _e1806.wwww).x;
            let _e1811: vec4<f32> = temporary8_;
            let _e1813: vec4<f32> = temporary8_;
            temporary12_.y = (_e1811.zzzz * _e1813.zzzz).x;
            let _e1818: vec4<f32> = temporary12_;
            let _e1820: vec4<f32> = temporary12_;
            temporary12_.z = (_e1818.xxxx + _e1820.yyyy).x;
            let _e1825: vec4<f32> = temporary12_;
            temporary13_.y = _e1825.zzzz.x;
            let _e1831: vec4<f32> = constant_registers[16u];
            let _e1833: vec4<f32> = temporary13_;
            temporary13_.z = vec4<f32>((_e1831.xxxx < _e1833.yyyy)).x;
            let _e1839: vec4<f32> = temporary13_;
            let _e1843: vec4<f32> = constant_registers[16u];
            if all((_e1839.zzzz != _e1843.xxxx)) {
                let _e1847: vec4<f32> = temporary13_;
                temporary13_.y = sqrt(_e1847.yyyy).x;
                let _e1852: vec4<f32> = temporary13_;
                temporary3_.w = -(_e1852.xxxx).x;
                let _e1857: vec4<f32> = temporary3_;
                let _e1859: vec4<f32> = temporary13_;
                temporary12_.x = (_e1857.wwww - _e1859.yyyy).x;
                let _e1864: vec4<f32> = temporary12_;
                temporary13_.z = _e1864.xxxx.x;
                let _e1870: vec4<f32> = constant_registers[16u];
                let _e1872: vec4<f32> = temporary13_;
                temporary3_.w = vec4<f32>((_e1870.xxxx < _e1872.zzzz)).x;
                let _e1878: vec4<f32> = temporary3_;
                let _e1882: vec4<f32> = constant_registers[16u];
                if all((_e1878.wwww != _e1882.xxxx)) {
                    let _e1886: vec4<f32> = temporary13_;
                    temporary2_.w = _e1886.zzzz.x;
                }
            }
            let _e1890: vec4<f32> = temporary2_;
            temporary4_.y = _e1890.wwww.x;
            let _e1894: vec4<f32> = temporary4_;
            let _e1896: vec4<f32> = temporary1_;
            temporary8_.y = vec4<f32>((_e1894.yyyy < _e1896.yyyy)).x;
            let _e1902: vec4<f32> = temporary8_;
            let _e1906: vec4<f32> = constant_registers[16u];
            if all((_e1902.yyyy != _e1906.xxxx)) {
                let _e1912: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e1912.xxxx.x;
            }
            let _e1916: vec4<f32> = temporary6_;
            temporary8_.y = saturate(_e1916.yyyy).x;
            let _e1921: vec4<f32> = temporary8_;
            let _e1925: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1921.yyyy * _e1925.xxxx).x;
            let _e1930: vec4<f32> = temporary8_;
            let _e1932: vec4<f32> = temporary8_;
            temporary8_.x = (_e1930.xxxx + _e1932.zzzz).x;
            let _e1937: vec4<f32> = temporary8_;
            let _e1941: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e1937.xxxx * _e1941.yyyy).x;
            let _e1948: vec4<f32> = constant_registers[19u];
            let _e1950: vec4<f32> = temporary8_;
            temporary2_.w = (_e1948.zzzz + _e1950.zzzz).x;
            let _e1955: vec4<f32> = temporary2_;
            temporary8_.y = _e1955.wwww.x;
            let _e1959: vec4<f32> = temporary1_;
            let _e1963: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e1959.zzzz == _e1963.yyyy)).x;
            let _e1969: vec4<f32> = temporary8_;
            let _e1973: vec4<f32> = constant_registers[16u];
            if all((_e1969.zzzz != _e1973.xxxx)) {
                let _e1977: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e1977.xxxx).x;
                let _e1982: vec4<f32> = temporary2_;
                let _e1984: vec4<f32> = temporary8_;
                temporary2_.w = (_e1982.xxxx - _e1984.zzzz).x;
                let _e1989: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e1989.zzzz).x;
                let _e1994: vec4<f32> = temporary2_;
                let _e1996: vec4<f32> = temporary15_;
                temporary15_.y = (_e1994.zzzz - _e1996.xxxx).x;
                let _e2001: vec4<f32> = temporary2_;
                let _e2003: vec4<f32> = temporary15_;
                temporary15_.z = (_e2001.wwww + _e2003.yyyy).x;
                let _e2008: vec4<f32> = temporary15_;
                let _e2012: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e2008.zzzz / _e2012.xxxx).x;
                let _e2017: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e2017.xxxx).x;
                let _e2022: vec4<f32> = temporary17_;
                let _e2026: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e2022.xxxx * _e2026.xxxx).x;
                let _e2031: vec4<f32> = temporary17_;
                let _e2035: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e2031.yyyy == _e2035.yyyy)).x;
                let _e2041: vec4<f32> = temporary17_;
                let _e2045: vec4<f32> = constant_registers[16u];
                if all((_e2041.zzzz != _e2045.xxxx)) {
                    let _e2051: vec4<f32> = constant_registers[13u];
                    let _e2053: vec4<f32> = temporary8_;
                    let _e2055: vec4<f32> = (_e2051.xyzz * _e2053.yyyy);
                    temporary15_.x = _e2055.x;
                    temporary15_.y = _e2055.y;
                    temporary15_.z = _e2055.z;
                    let _e2062: vec4<f32> = temporary0_;
                    let _e2064: vec4<f32> = temporary15_;
                    let _e2066: vec4<f32> = (_e2062.xyzz + _e2064.xyzz);
                    temporary0_.x = _e2066.x;
                    temporary0_.y = _e2066.y;
                    temporary0_.z = _e2066.z;
                } else {
                    let _e2075: vec4<f32> = constant_registers[14u];
                    let _e2077: vec4<f32> = temporary8_;
                    let _e2079: vec4<f32> = (_e2075.xyzz * _e2077.yyyy);
                    temporary15_.x = _e2079.x;
                    temporary15_.y = _e2079.y;
                    temporary15_.z = _e2079.z;
                    let _e2086: vec4<f32> = temporary0_;
                    let _e2088: vec4<f32> = temporary15_;
                    let _e2090: vec4<f32> = (_e2086.xyzz + _e2088.xyzz);
                    temporary0_.x = _e2090.x;
                    temporary0_.y = _e2090.y;
                    temporary0_.z = _e2090.z;
                }
            }
            let _e2097: vec4<f32> = temporary1_;
            let _e2101: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e2097.zzzz == _e2101.xxxx)).x;
            let _e2107: vec4<f32> = temporary8_;
            let _e2111: vec4<f32> = constant_registers[16u];
            if all((_e2107.zzzz != _e2111.xxxx)) {
                let _e2115: vec4<f32> = temporary7_;
                let _e2117: vec4<f32> = temporary8_;
                let _e2119: vec4<f32> = (_e2115.xyzz * _e2117.yyyy);
                temporary15_.x = _e2119.x;
                temporary15_.y = _e2119.y;
                temporary15_.z = _e2119.z;
                let _e2126: vec4<f32> = temporary0_;
                let _e2128: vec4<f32> = temporary15_;
                let _e2130: vec4<f32> = (_e2126.xyzz + _e2128.xyzz);
                temporary0_.x = _e2130.x;
                temporary0_.y = _e2130.y;
                temporary0_.z = _e2130.z;
            }
            let _e2139: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e2139.yyyy.x;
        }
    }
    let _e2143: vec4<f32> = temporary11_;
    let _e2147: vec4<f32> = constant_registers[16u];
    if all((_e2143.xxxx != _e2147.xxxx)) {
        let _e2153: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e2153.xxxx.x;
        let _e2159: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e2159.wwww.x;
        let _e2165: vec4<f32> = constant_registers[16u];
        let _e2166: vec4<f32> = _e2165.xyxx;
        temporary3_.x = _e2166.x;
        temporary3_.y = _e2166.y;
        temporary3_.z = _e2166.z;
        let _e2173: vec4<f32> = temporary3_;
        let _e2174: vec4<f32> = _e2173.xyzz;
        temporary12_.x = _e2174.x;
        temporary12_.y = _e2174.y;
        temporary12_.z = _e2174.z;
        let _e2183: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e2183.wwww.x;
        let _e2187: vec4<f32> = temporary2_;
        let _e2191: vec4<f32> = constant_registers[16u];
        let _e2193: vec4<f32> = (_e2187.xyzz - _e2191.xxxx);
        temporary20_.x = _e2193.x;
        temporary20_.y = _e2193.y;
        temporary20_.z = _e2193.z;
        let _e2200: vec4<f32> = temporary20_;
        let _e2202: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e2200.xyz, _e2202.xyz);
        let _e2206: vec4<f32> = temporary14_;
        temporary14_.z = -(_e2206.yyyy).x;
        let _e2211: vec4<f32> = temporary9_;
        let _e2213: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e2211.xyz, _e2213.xyz);
        let _e2217: vec4<f32> = temporary14_;
        let _e2219: vec4<f32> = temporary4_;
        temporary16_.x = (_e2217.zzzz / _e2219.xxxx).x;
        let _e2224: vec4<f32> = temporary16_;
        temporary14_.x = _e2224.xxxx.x;
        let _e2230: vec4<f32> = constant_registers[16u];
        let _e2232: vec4<f32> = temporary14_;
        temporary14_.y = vec4<f32>((_e2230.xxxx < _e2232.xxxx)).x;
        let _e2238: vec4<f32> = temporary14_;
        let _e2242: vec4<f32> = constant_registers[16u];
        if all((_e2238.yyyy != _e2242.xxxx)) {
            let _e2246: vec4<f32> = temporary14_;
            temporary2_.w = _e2246.xxxx.x;
        }
        let _e2250: vec4<f32> = temporary2_;
        temporary4_.y = _e2250.wwww.x;
        let _e2254: vec4<f32> = temporary4_;
        let _e2256: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2254.yyyy < _e2256.zzzz)).x;
        let _e2262: vec4<f32> = temporary8_;
        let _e2266: vec4<f32> = constant_registers[16u];
        if all((_e2262.zzzz != _e2266.xxxx)) {
            let _e2270: vec4<f32> = temporary4_;
            temporary4_.z = _e2270.yyyy.x;
            let _e2274: vec4<f32> = temporary3_;
            let _e2275: vec4<f32> = _e2274.xyzz;
            temporary6_.x = _e2275.x;
            temporary6_.y = _e2275.y;
            temporary6_.z = _e2275.z;
            let _e2284: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e2284.yyyy.x;
        }
        let _e2288: vec4<f32> = temporary2_;
        let _e2289: vec4<f32> = _e2288.xyzz;
        temporary15_.x = _e2289.x;
        temporary15_.y = _e2289.y;
        temporary15_.z = _e2289.z;
        let _e2296: vec4<f32> = temporary9_;
        let _e2297: vec4<f32> = _e2296.xyzz;
        temporary17_.x = _e2297.x;
        temporary17_.y = _e2297.y;
        temporary17_.z = _e2297.z;
        let _e2306: vec4<f32> = constant_registers[4u];
        let _e2307: vec4<f32> = _e2306.xyzz;
        temporary18_.x = _e2307.x;
        temporary18_.y = _e2307.y;
        temporary18_.z = _e2307.z;
        let _e2316: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e2316.xxxx.x;
        let _e2320: vec4<f32> = temporary3_;
        let _e2321: vec4<f32> = _e2320.xyzz;
        temporary19_.x = _e2321.x;
        temporary19_.y = _e2321.y;
        temporary19_.z = _e2321.z;
        let _e2330: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2330.wwww.x;
        let _e2334: vec4<f32> = temporary15_;
        let _e2336: vec4<f32> = temporary18_;
        let _e2338: vec4<f32> = (_e2334.xyzz - _e2336.xyzz);
        temporary12_.x = _e2338.x;
        temporary12_.y = _e2338.y;
        temporary12_.z = _e2338.z;
        let _e2345: vec4<f32> = temporary12_;
        let _e2347: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2345.xyz, _e2347.xyz);
        let _e2351: vec4<f32> = temporary13_;
        let _e2353: vec4<f32> = temporary13_;
        temporary3_.w = (_e2351.yyyy * _e2353.yyyy).x;
        let _e2358: vec4<f32> = temporary12_;
        let _e2360: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2358.xyz, _e2360.xyz);
        let _e2364: vec4<f32> = temporary3_;
        let _e2366: vec4<f32> = temporary14_;
        temporary14_.y = (_e2364.wwww - _e2366.xxxx).x;
        let _e2371: vec4<f32> = temporary2_;
        let _e2373: vec4<f32> = temporary2_;
        temporary14_.z = (_e2371.wwww * _e2373.wwww).x;
        let _e2378: vec4<f32> = temporary14_;
        let _e2380: vec4<f32> = temporary14_;
        temporary13_.z = (_e2378.yyyy + _e2380.zzzz).x;
        let _e2387: vec4<f32> = constant_registers[16u];
        let _e2389: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2387.xxxx < _e2389.zzzz)).x;
        let _e2395: vec4<f32> = temporary3_;
        let _e2399: vec4<f32> = constant_registers[16u];
        if all((_e2395.wwww != _e2399.xxxx)) {
            let _e2403: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2403.zzzz).x;
            let _e2408: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2408.yyyy).x;
            let _e2413: vec4<f32> = temporary14_;
            let _e2415: vec4<f32> = temporary13_;
            temporary14_.y = (_e2413.xxxx - _e2415.zzzz).x;
            let _e2420: vec4<f32> = temporary14_;
            temporary3_.w = _e2420.yyyy.x;
            let _e2426: vec4<f32> = constant_registers[16u];
            let _e2428: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2426.xxxx < _e2428.wwww)).x;
            let _e2434: vec4<f32> = temporary14_;
            let _e2438: vec4<f32> = constant_registers[16u];
            if all((_e2434.xxxx != _e2438.xxxx)) {
                let _e2442: vec4<f32> = temporary3_;
                temporary13_.x = _e2442.wwww.x;
                let _e2446: vec4<f32> = temporary17_;
                let _e2448: vec4<f32> = temporary3_;
                let _e2450: vec4<f32> = (_e2446.xyzz * _e2448.wwww);
                temporary14_.x = _e2450.x;
                temporary14_.y = _e2450.y;
                temporary14_.z = _e2450.z;
                let _e2457: vec4<f32> = temporary15_;
                let _e2459: vec4<f32> = temporary14_;
                let _e2461: vec4<f32> = (_e2457.xyzz + _e2459.xyzz);
                temporary20_.x = _e2461.x;
                temporary20_.y = _e2461.y;
                temporary20_.z = _e2461.z;
                let _e2468: vec4<f32> = temporary20_;
                let _e2470: vec4<f32> = temporary18_;
                let _e2472: vec4<f32> = (_e2468.xyzz - _e2470.xyzz);
                temporary16_.x = _e2472.x;
                temporary16_.y = _e2472.y;
                temporary16_.z = _e2472.z;
                let _e2479: vec4<f32> = temporary16_;
                let _e2481: vec3<f32> = normalize(_e2479.xyz);
                temporary19_.x = _e2481.x;
                temporary19_.y = _e2481.y;
                temporary19_.z = _e2481.z;
            }
        }
        let _e2488: vec4<f32> = temporary13_;
        temporary4_.y = _e2488.xxxx.x;
        let _e2492: vec4<f32> = temporary19_;
        let _e2493: vec4<f32> = _e2492.xyzz;
        temporary3_.x = _e2493.x;
        temporary3_.y = _e2493.y;
        temporary3_.z = _e2493.z;
        let _e2500: vec4<f32> = temporary4_;
        let _e2502: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2500.yyyy < _e2502.zzzz)).x;
        let _e2508: vec4<f32> = temporary8_;
        let _e2512: vec4<f32> = constant_registers[16u];
        if all((_e2508.zzzz != _e2512.xxxx)) {
            let _e2516: vec4<f32> = temporary4_;
            temporary4_.z = _e2516.yyyy.x;
            let _e2520: vec4<f32> = temporary3_;
            let _e2521: vec4<f32> = _e2520.xyzz;
            temporary6_.x = _e2521.x;
            temporary6_.y = _e2521.y;
            temporary6_.z = _e2521.z;
            let _e2530: vec4<f32> = constant_registers[5u];
            let _e2531: vec4<f32> = _e2530.xyzz;
            temporary7_.x = _e2531.x;
            temporary7_.y = _e2531.y;
            temporary7_.z = _e2531.z;
            let _e2540: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2540.xxxx.x;
        }
        let _e2544: vec4<f32> = temporary2_;
        let _e2545: vec4<f32> = _e2544.xyzz;
        temporary15_.x = _e2545.x;
        temporary15_.y = _e2545.y;
        temporary15_.z = _e2545.z;
        let _e2552: vec4<f32> = temporary9_;
        let _e2553: vec4<f32> = _e2552.xyzz;
        temporary17_.x = _e2553.x;
        temporary17_.y = _e2553.y;
        temporary17_.z = _e2553.z;
        let _e2562: vec4<f32> = constant_registers[7u];
        let _e2563: vec4<f32> = _e2562.xyzz;
        temporary18_.x = _e2563.x;
        temporary18_.y = _e2563.y;
        temporary18_.z = _e2563.z;
        let _e2572: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e2572.xxxx.x;
        let _e2576: vec4<f32> = temporary3_;
        let _e2577: vec4<f32> = _e2576.xyzz;
        temporary19_.x = _e2577.x;
        temporary19_.y = _e2577.y;
        temporary19_.z = _e2577.z;
        let _e2586: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2586.wwww.x;
        let _e2590: vec4<f32> = temporary15_;
        let _e2592: vec4<f32> = temporary18_;
        let _e2594: vec4<f32> = (_e2590.xyzz - _e2592.xyzz);
        temporary12_.x = _e2594.x;
        temporary12_.y = _e2594.y;
        temporary12_.z = _e2594.z;
        let _e2601: vec4<f32> = temporary12_;
        let _e2603: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2601.xyz, _e2603.xyz);
        let _e2607: vec4<f32> = temporary13_;
        let _e2609: vec4<f32> = temporary13_;
        temporary3_.w = (_e2607.yyyy * _e2609.yyyy).x;
        let _e2614: vec4<f32> = temporary12_;
        let _e2616: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2614.xyz, _e2616.xyz);
        let _e2620: vec4<f32> = temporary3_;
        let _e2622: vec4<f32> = temporary14_;
        temporary14_.y = (_e2620.wwww - _e2622.xxxx).x;
        let _e2627: vec4<f32> = temporary2_;
        let _e2629: vec4<f32> = temporary2_;
        temporary14_.z = (_e2627.wwww * _e2629.wwww).x;
        let _e2634: vec4<f32> = temporary14_;
        let _e2636: vec4<f32> = temporary14_;
        temporary13_.z = (_e2634.yyyy + _e2636.zzzz).x;
        let _e2643: vec4<f32> = constant_registers[16u];
        let _e2645: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2643.xxxx < _e2645.zzzz)).x;
        let _e2651: vec4<f32> = temporary3_;
        let _e2655: vec4<f32> = constant_registers[16u];
        if all((_e2651.wwww != _e2655.xxxx)) {
            let _e2659: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2659.zzzz).x;
            let _e2664: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2664.yyyy).x;
            let _e2669: vec4<f32> = temporary14_;
            let _e2671: vec4<f32> = temporary13_;
            temporary14_.y = (_e2669.xxxx - _e2671.zzzz).x;
            let _e2676: vec4<f32> = temporary14_;
            temporary3_.w = _e2676.yyyy.x;
            let _e2682: vec4<f32> = constant_registers[16u];
            let _e2684: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2682.xxxx < _e2684.wwww)).x;
            let _e2690: vec4<f32> = temporary14_;
            let _e2694: vec4<f32> = constant_registers[16u];
            if all((_e2690.xxxx != _e2694.xxxx)) {
                let _e2698: vec4<f32> = temporary3_;
                temporary13_.x = _e2698.wwww.x;
                let _e2702: vec4<f32> = temporary17_;
                let _e2704: vec4<f32> = temporary3_;
                let _e2706: vec4<f32> = (_e2702.xyzz * _e2704.wwww);
                temporary14_.x = _e2706.x;
                temporary14_.y = _e2706.y;
                temporary14_.z = _e2706.z;
                let _e2713: vec4<f32> = temporary15_;
                let _e2715: vec4<f32> = temporary14_;
                let _e2717: vec4<f32> = (_e2713.xyzz + _e2715.xyzz);
                temporary20_.x = _e2717.x;
                temporary20_.y = _e2717.y;
                temporary20_.z = _e2717.z;
                let _e2724: vec4<f32> = temporary20_;
                let _e2726: vec4<f32> = temporary18_;
                let _e2728: vec4<f32> = (_e2724.xyzz - _e2726.xyzz);
                temporary16_.x = _e2728.x;
                temporary16_.y = _e2728.y;
                temporary16_.z = _e2728.z;
                let _e2735: vec4<f32> = temporary16_;
                let _e2737: vec3<f32> = normalize(_e2735.xyz);
                temporary19_.x = _e2737.x;
                temporary19_.y = _e2737.y;
                temporary19_.z = _e2737.z;
            }
        }
        let _e2744: vec4<f32> = temporary13_;
        temporary4_.y = _e2744.xxxx.x;
        let _e2748: vec4<f32> = temporary19_;
        let _e2749: vec4<f32> = _e2748.xyzz;
        temporary3_.x = _e2749.x;
        temporary3_.y = _e2749.y;
        temporary3_.z = _e2749.z;
        let _e2756: vec4<f32> = temporary4_;
        let _e2758: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e2756.yyyy < _e2758.zzzz)).x;
        let _e2764: vec4<f32> = temporary8_;
        let _e2768: vec4<f32> = constant_registers[16u];
        if all((_e2764.zzzz != _e2768.xxxx)) {
            let _e2772: vec4<f32> = temporary4_;
            temporary4_.z = _e2772.yyyy.x;
            let _e2776: vec4<f32> = temporary3_;
            let _e2777: vec4<f32> = _e2776.xyzz;
            temporary6_.x = _e2777.x;
            temporary6_.y = _e2777.y;
            temporary6_.z = _e2777.z;
            let _e2786: vec4<f32> = constant_registers[8u];
            let _e2787: vec4<f32> = _e2786.xyzz;
            temporary7_.x = _e2787.x;
            temporary7_.y = _e2787.y;
            temporary7_.z = _e2787.z;
            let _e2796: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e2796.xxxx.x;
        }
        let _e2800: vec4<f32> = temporary2_;
        let _e2801: vec4<f32> = _e2800.xyzz;
        temporary15_.x = _e2801.x;
        temporary15_.y = _e2801.y;
        temporary15_.z = _e2801.z;
        let _e2808: vec4<f32> = temporary9_;
        let _e2809: vec4<f32> = _e2808.xyzz;
        temporary17_.x = _e2809.x;
        temporary17_.y = _e2809.y;
        temporary17_.z = _e2809.z;
        let _e2818: vec4<f32> = constant_registers[10u];
        let _e2819: vec4<f32> = _e2818.xyzz;
        temporary18_.x = _e2819.x;
        temporary18_.y = _e2819.y;
        temporary18_.z = _e2819.z;
        let _e2828: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e2828.xxxx.x;
        let _e2832: vec4<f32> = temporary3_;
        let _e2833: vec4<f32> = _e2832.xyzz;
        temporary19_.x = _e2833.x;
        temporary19_.y = _e2833.y;
        temporary19_.z = _e2833.z;
        let _e2842: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e2842.wwww.x;
        let _e2846: vec4<f32> = temporary15_;
        let _e2848: vec4<f32> = temporary18_;
        let _e2850: vec4<f32> = (_e2846.xyzz - _e2848.xyzz);
        temporary12_.x = _e2850.x;
        temporary12_.y = _e2850.y;
        temporary12_.z = _e2850.z;
        let _e2857: vec4<f32> = temporary12_;
        let _e2859: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e2857.xyz, _e2859.xyz);
        let _e2863: vec4<f32> = temporary13_;
        let _e2865: vec4<f32> = temporary13_;
        temporary3_.w = (_e2863.yyyy * _e2865.yyyy).x;
        let _e2870: vec4<f32> = temporary12_;
        let _e2872: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e2870.xyz, _e2872.xyz);
        let _e2876: vec4<f32> = temporary3_;
        let _e2878: vec4<f32> = temporary14_;
        temporary14_.y = (_e2876.wwww - _e2878.xxxx).x;
        let _e2883: vec4<f32> = temporary2_;
        let _e2885: vec4<f32> = temporary2_;
        temporary14_.z = (_e2883.wwww * _e2885.wwww).x;
        let _e2890: vec4<f32> = temporary14_;
        let _e2892: vec4<f32> = temporary14_;
        temporary4_.x = (_e2890.yyyy + _e2892.zzzz).x;
        let _e2897: vec4<f32> = temporary4_;
        temporary13_.z = _e2897.xxxx.x;
        let _e2903: vec4<f32> = constant_registers[16u];
        let _e2905: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e2903.xxxx < _e2905.zzzz)).x;
        let _e2911: vec4<f32> = temporary3_;
        let _e2915: vec4<f32> = constant_registers[16u];
        if all((_e2911.wwww != _e2915.xxxx)) {
            let _e2919: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e2919.zzzz).x;
            let _e2924: vec4<f32> = temporary13_;
            temporary14_.x = -(_e2924.yyyy).x;
            let _e2929: vec4<f32> = temporary14_;
            let _e2931: vec4<f32> = temporary13_;
            temporary14_.y = (_e2929.xxxx - _e2931.zzzz).x;
            let _e2936: vec4<f32> = temporary14_;
            temporary3_.w = _e2936.yyyy.x;
            let _e2942: vec4<f32> = constant_registers[16u];
            let _e2944: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e2942.xxxx < _e2944.wwww)).x;
            let _e2950: vec4<f32> = temporary14_;
            let _e2954: vec4<f32> = constant_registers[16u];
            if all((_e2950.xxxx != _e2954.xxxx)) {
                let _e2958: vec4<f32> = temporary3_;
                temporary13_.x = _e2958.wwww.x;
                let _e2962: vec4<f32> = temporary17_;
                let _e2964: vec4<f32> = temporary3_;
                let _e2966: vec4<f32> = (_e2962.xyzz * _e2964.wwww);
                temporary14_.x = _e2966.x;
                temporary14_.y = _e2966.y;
                temporary14_.z = _e2966.z;
                let _e2973: vec4<f32> = temporary15_;
                let _e2975: vec4<f32> = temporary14_;
                let _e2977: vec4<f32> = (_e2973.xyzz + _e2975.xyzz);
                temporary20_.x = _e2977.x;
                temporary20_.y = _e2977.y;
                temporary20_.z = _e2977.z;
                let _e2984: vec4<f32> = temporary20_;
                let _e2986: vec4<f32> = temporary18_;
                let _e2988: vec4<f32> = (_e2984.xyzz - _e2986.xyzz);
                temporary16_.x = _e2988.x;
                temporary16_.y = _e2988.y;
                temporary16_.z = _e2988.z;
                let _e2995: vec4<f32> = temporary16_;
                let _e2997: vec3<f32> = normalize(_e2995.xyz);
                temporary19_.x = _e2997.x;
                temporary19_.y = _e2997.y;
                temporary19_.z = _e2997.z;
            }
        }
        let _e3004: vec4<f32> = temporary13_;
        temporary4_.y = _e3004.xxxx.x;
        let _e3008: vec4<f32> = temporary19_;
        let _e3009: vec4<f32> = _e3008.xyzz;
        temporary3_.x = _e3009.x;
        temporary3_.y = _e3009.y;
        temporary3_.z = _e3009.z;
        let _e3016: vec4<f32> = temporary4_;
        let _e3018: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e3016.yyyy < _e3018.zzzz)).x;
        let _e3024: vec4<f32> = temporary8_;
        let _e3028: vec4<f32> = constant_registers[16u];
        if all((_e3024.zzzz != _e3028.xxxx)) {
            let _e3032: vec4<f32> = temporary4_;
            temporary4_.z = _e3032.yyyy.x;
            let _e3036: vec4<f32> = temporary3_;
            let _e3037: vec4<f32> = _e3036.xyzz;
            temporary6_.x = _e3037.x;
            temporary6_.y = _e3037.y;
            temporary6_.z = _e3037.z;
            let _e3046: vec4<f32> = constant_registers[11u];
            let _e3047: vec4<f32> = _e3046.xyzz;
            temporary7_.x = _e3047.x;
            temporary7_.y = _e3047.y;
            temporary7_.z = _e3047.z;
            let _e3056: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e3056.xxxx.x;
        }
        let _e3060: vec4<f32> = temporary11_;
        let _e3064: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e3060.yyyy + _e3064.yyyy).x;
        let _e3069: vec4<f32> = temporary1_;
        let _e3073: vec4<f32> = constant_registers[16u];
        temporary8_.z = vec4<f32>((_e3069.zzzz == _e3073.xxxx)).x;
        let _e3079: vec4<f32> = temporary8_;
        let _e3083: vec4<f32> = constant_registers[16u];
        if all((_e3079.zzzz != _e3083.xxxx)) {
            let _e3089: vec4<f32> = constant_registers[16u];
            let _e3090: vec4<f32> = _e3089.xyyy;
            temporary11_.x = _e3090.x;
            temporary11_.z = _e3090.z;
        } else {
            let _e3095: vec4<f32> = temporary9_;
            let _e3097: vec4<f32> = temporary4_;
            let _e3099: vec4<f32> = (_e3095.xyzz * _e3097.zzzz);
            temporary15_.x = _e3099.x;
            temporary15_.y = _e3099.y;
            temporary15_.z = _e3099.z;
            let _e3106: vec4<f32> = temporary2_;
            let _e3108: vec4<f32> = temporary15_;
            let _e3110: vec4<f32> = (_e3106.xyzz + _e3108.xyzz);
            temporary2_.x = _e3110.x;
            temporary2_.y = _e3110.y;
            temporary2_.z = _e3110.z;
            let _e3117: vec4<f32> = temporary9_;
            let _e3119: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e3117.xyz, _e3119.xyz);
            let _e3123: vec4<f32> = temporary8_;
            let _e3127: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e3123.zzzz * _e3127.xxxx).x;
            let _e3132: vec4<f32> = temporary2_;
            let _e3134: vec4<f32> = temporary6_;
            let _e3136: vec4<f32> = (_e3132.wwww * _e3134.xyzz);
            temporary15_.x = _e3136.x;
            temporary15_.y = _e3136.y;
            temporary15_.z = _e3136.z;
            let _e3143: vec4<f32> = temporary9_;
            let _e3145: vec4<f32> = temporary15_;
            let _e3147: vec4<f32> = (_e3143.xyzz - _e3145.xyzz);
            temporary9_.x = _e3147.x;
            temporary9_.y = _e3147.y;
            temporary9_.z = _e3147.z;
            let _e3154: vec4<f32> = temporary9_;
            let _e3158: vec4<f32> = constant_registers[18u];
            let _e3160: vec4<f32> = (_e3154.xyzz * _e3158.yyyy);
            temporary15_.x = _e3160.x;
            temporary15_.y = _e3160.y;
            temporary15_.z = _e3160.z;
            let _e3167: vec4<f32> = temporary2_;
            let _e3169: vec4<f32> = temporary15_;
            let _e3171: vec4<f32> = (_e3167.xyzz + _e3169.xyzz);
            temporary2_.x = _e3171.x;
            temporary2_.y = _e3171.y;
            temporary2_.z = _e3171.z;
            let _e3180: vec4<f32> = constant_registers[15u];
            let _e3182: vec4<f32> = temporary2_;
            let _e3184: vec4<f32> = (_e3180.xyzz - _e3182.xyzz);
            temporary5_.x = _e3184.x;
            temporary5_.y = _e3184.y;
            temporary5_.z = _e3184.z;
            let _e3191: vec4<f32> = temporary5_;
            let _e3193: vec3<f32> = normalize(_e3191.xyz);
            temporary10_.x = _e3193.x;
            temporary10_.y = _e3193.y;
            temporary10_.z = _e3193.z;
            let _e3200: vec4<f32> = temporary5_;
            let _e3202: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e3200.xyz, _e3202.xyz);
            let _e3206: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e3206.zzzz).x;
            let _e3211: vec4<f32> = temporary6_;
            let _e3213: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e3211.xyz, _e3213.xyz);
            let _e3217: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e3217.zzzz).x;
            let _e3222: vec4<f32> = temporary1_;
            let _e3224: vec4<f32> = temporary1_;
            temporary15_.x = (_e3222.yyyy * _e3224.yyyy).x;
            let _e3229: vec4<f32> = temporary15_;
            let _e3233: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e3229.xxxx * _e3233.zzzz).x;
            let _e3240: vec4<f32> = constant_registers[18u];
            let _e3242: vec4<f32> = temporary15_;
            temporary15_.z = (_e3240.wwww + _e3242.yyyy).x;
            let _e3247: vec4<f32> = temporary2_;
            let _e3249: vec4<f32> = temporary15_;
            temporary1_.x = (_e3247.wwww / _e3249.zzzz).x;
            let _e3254: vec4<f32> = temporary1_;
            temporary8_.x = _e3254.xxxx.x;
            let _e3260: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e3260.xxxx.x;
            let _e3266: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3266.wwww.x;
            let _e3270: vec4<f32> = temporary2_;
            let _e3274: vec4<f32> = constant_registers[4u];
            let _e3276: vec4<f32> = (_e3270.xyzz - _e3274.xyzz);
            temporary13_.x = _e3276.x;
            temporary13_.y = _e3276.y;
            temporary13_.z = _e3276.z;
            let _e3283: vec4<f32> = temporary13_;
            let _e3285: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3283.xyz, _e3285.xyz);
            let _e3289: vec4<f32> = temporary19_;
            let _e3291: vec4<f32> = temporary19_;
            temporary1_.w = (_e3289.yyyy * _e3291.yyyy).x;
            let _e3296: vec4<f32> = temporary13_;
            let _e3298: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3296.xyz, _e3298.xyz);
            let _e3302: vec4<f32> = temporary1_;
            let _e3304: vec4<f32> = temporary12_;
            temporary12_.y = (_e3302.wwww - _e3304.xxxx).x;
            let _e3309: vec4<f32> = temporary2_;
            let _e3311: vec4<f32> = temporary2_;
            temporary12_.z = (_e3309.wwww * _e3311.wwww).x;
            let _e3316: vec4<f32> = temporary12_;
            let _e3318: vec4<f32> = temporary12_;
            temporary19_.z = (_e3316.yyyy + _e3318.zzzz).x;
            let _e3325: vec4<f32> = constant_registers[16u];
            let _e3327: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3325.xxxx < _e3327.zzzz)).x;
            let _e3333: vec4<f32> = temporary1_;
            let _e3337: vec4<f32> = constant_registers[16u];
            if all((_e3333.wwww != _e3337.xxxx)) {
                let _e3341: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3341.zzzz).x;
                let _e3346: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3346.yyyy).x;
                let _e3351: vec4<f32> = temporary12_;
                let _e3353: vec4<f32> = temporary19_;
                temporary1_.w = (_e3351.xxxx - _e3353.zzzz).x;
                let _e3360: vec4<f32> = constant_registers[16u];
                let _e3362: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3360.xxxx < _e3362.wwww)).x;
                let _e3368: vec4<f32> = temporary12_;
                let _e3372: vec4<f32> = constant_registers[16u];
                if all((_e3368.xxxx != _e3372.xxxx)) {
                    let _e3376: vec4<f32> = temporary1_;
                    temporary19_.x = _e3376.wwww.x;
                }
            }
            let _e3380: vec4<f32> = temporary19_;
            let _e3382: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3380.xxxx < _e3382.yyyy)).x;
            let _e3388: vec4<f32> = temporary8_;
            let _e3392: vec4<f32> = constant_registers[16u];
            if all((_e3388.zzzz != _e3392.xxxx)) {
                let _e3398: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3398.xxxx.x;
            }
            let _e3404: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e3404.xxxx.x;
            let _e3410: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3410.wwww.x;
            let _e3414: vec4<f32> = temporary2_;
            let _e3418: vec4<f32> = constant_registers[7u];
            let _e3420: vec4<f32> = (_e3414.xyzz - _e3418.xyzz);
            temporary13_.x = _e3420.x;
            temporary13_.y = _e3420.y;
            temporary13_.z = _e3420.z;
            let _e3427: vec4<f32> = temporary13_;
            let _e3429: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e3427.xyz, _e3429.xyz);
            let _e3433: vec4<f32> = temporary19_;
            let _e3435: vec4<f32> = temporary19_;
            temporary1_.w = (_e3433.yyyy * _e3435.yyyy).x;
            let _e3440: vec4<f32> = temporary13_;
            let _e3442: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3440.xyz, _e3442.xyz);
            let _e3446: vec4<f32> = temporary1_;
            let _e3448: vec4<f32> = temporary12_;
            temporary12_.y = (_e3446.wwww - _e3448.xxxx).x;
            let _e3453: vec4<f32> = temporary2_;
            let _e3455: vec4<f32> = temporary2_;
            temporary12_.z = (_e3453.wwww * _e3455.wwww).x;
            let _e3460: vec4<f32> = temporary12_;
            let _e3462: vec4<f32> = temporary12_;
            temporary19_.z = (_e3460.yyyy + _e3462.zzzz).x;
            let _e3469: vec4<f32> = constant_registers[16u];
            let _e3471: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3469.xxxx < _e3471.zzzz)).x;
            let _e3477: vec4<f32> = temporary1_;
            let _e3481: vec4<f32> = constant_registers[16u];
            if all((_e3477.wwww != _e3481.xxxx)) {
                let _e3485: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3485.zzzz).x;
                let _e3490: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3490.yyyy).x;
                let _e3495: vec4<f32> = temporary12_;
                let _e3497: vec4<f32> = temporary19_;
                temporary1_.w = (_e3495.xxxx - _e3497.zzzz).x;
                let _e3504: vec4<f32> = constant_registers[16u];
                let _e3506: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3504.xxxx < _e3506.wwww)).x;
                let _e3512: vec4<f32> = temporary12_;
                let _e3516: vec4<f32> = constant_registers[16u];
                if all((_e3512.xxxx != _e3516.xxxx)) {
                    let _e3520: vec4<f32> = temporary1_;
                    temporary19_.x = _e3520.wwww.x;
                }
            }
            let _e3524: vec4<f32> = temporary19_;
            let _e3526: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3524.xxxx < _e3526.yyyy)).x;
            let _e3532: vec4<f32> = temporary8_;
            let _e3536: vec4<f32> = constant_registers[16u];
            if all((_e3532.zzzz != _e3536.xxxx)) {
                let _e3542: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3542.xxxx.x;
            }
            let _e3546: vec4<f32> = temporary2_;
            let _e3547: vec4<f32> = _e3546.xyzz;
            temporary15_.x = _e3547.x;
            temporary15_.y = _e3547.y;
            temporary15_.z = _e3547.z;
            let _e3554: vec4<f32> = temporary10_;
            let _e3555: vec4<f32> = _e3554.xyzz;
            temporary17_.x = _e3555.x;
            temporary17_.y = _e3555.y;
            temporary17_.z = _e3555.z;
            let _e3564: vec4<f32> = constant_registers[10u];
            let _e3565: vec4<f32> = _e3564.xyzz;
            temporary18_.x = _e3565.x;
            temporary18_.y = _e3565.y;
            temporary18_.z = _e3565.z;
            let _e3574: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e3574.xxxx.x;
            let _e3580: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e3580.wwww.x;
            let _e3584: vec4<f32> = temporary15_;
            let _e3586: vec4<f32> = temporary18_;
            let _e3588: vec4<f32> = (_e3584.xyzz - _e3586.xyzz);
            temporary13_.x = _e3588.x;
            temporary13_.y = _e3588.y;
            temporary13_.z = _e3588.z;
            let _e3595: vec4<f32> = temporary13_;
            let _e3597: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e3595.xyz, _e3597.xyz);
            let _e3601: vec4<f32> = temporary19_;
            let _e3603: vec4<f32> = temporary19_;
            temporary1_.w = (_e3601.yyyy * _e3603.yyyy).x;
            let _e3608: vec4<f32> = temporary13_;
            let _e3610: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e3608.xyz, _e3610.xyz);
            let _e3614: vec4<f32> = temporary1_;
            let _e3616: vec4<f32> = temporary12_;
            temporary12_.y = (_e3614.wwww - _e3616.xxxx).x;
            let _e3621: vec4<f32> = temporary2_;
            let _e3623: vec4<f32> = temporary2_;
            temporary12_.z = (_e3621.wwww * _e3623.wwww).x;
            let _e3628: vec4<f32> = temporary12_;
            let _e3630: vec4<f32> = temporary12_;
            temporary19_.z = (_e3628.yyyy + _e3630.zzzz).x;
            let _e3637: vec4<f32> = constant_registers[16u];
            let _e3639: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e3637.xxxx < _e3639.zzzz)).x;
            let _e3645: vec4<f32> = temporary1_;
            let _e3649: vec4<f32> = constant_registers[16u];
            if all((_e3645.wwww != _e3649.xxxx)) {
                let _e3653: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e3653.zzzz).x;
                let _e3658: vec4<f32> = temporary19_;
                temporary12_.x = -(_e3658.yyyy).x;
                let _e3663: vec4<f32> = temporary12_;
                let _e3665: vec4<f32> = temporary19_;
                temporary12_.y = (_e3663.xxxx - _e3665.zzzz).x;
                let _e3670: vec4<f32> = temporary12_;
                temporary1_.w = _e3670.yyyy.x;
                let _e3676: vec4<f32> = constant_registers[16u];
                let _e3678: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e3676.xxxx < _e3678.wwww)).x;
                let _e3684: vec4<f32> = temporary12_;
                let _e3688: vec4<f32> = constant_registers[16u];
                if all((_e3684.xxxx != _e3688.xxxx)) {
                    let _e3692: vec4<f32> = temporary1_;
                    temporary19_.x = _e3692.wwww.x;
                }
            }
            let _e3696: vec4<f32> = temporary19_;
            temporary4_.y = _e3696.xxxx.x;
            let _e3700: vec4<f32> = temporary4_;
            let _e3702: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e3700.yyyy < _e3702.yyyy)).x;
            let _e3708: vec4<f32> = temporary8_;
            let _e3712: vec4<f32> = constant_registers[16u];
            if all((_e3708.zzzz != _e3712.xxxx)) {
                let _e3718: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e3718.xxxx.x;
            }
            let _e3722: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e3722.yyyy).x;
            let _e3727: vec4<f32> = temporary8_;
            let _e3731: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e3727.zzzz * _e3731.xxxx).x;
            let _e3736: vec4<f32> = temporary8_;
            let _e3738: vec4<f32> = temporary2_;
            temporary8_.x = (_e3736.xxxx + _e3738.wwww).x;
            let _e3743: vec4<f32> = temporary8_;
            let _e3747: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e3743.xxxx * _e3747.yyyy).x;
            let _e3754: vec4<f32> = constant_registers[19u];
            let _e3756: vec4<f32> = temporary8_;
            temporary2_.w = (_e3754.zzzz + _e3756.zzzz).x;
            let _e3761: vec4<f32> = temporary2_;
            temporary8_.y = _e3761.wwww.x;
            let _e3765: vec4<f32> = temporary1_;
            let _e3769: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e3765.zzzz == _e3769.yyyy)).x;
            let _e3775: vec4<f32> = temporary8_;
            let _e3779: vec4<f32> = constant_registers[16u];
            if all((_e3775.zzzz != _e3779.xxxx)) {
                let _e3783: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e3783.xxxx).x;
                let _e3788: vec4<f32> = temporary2_;
                let _e3790: vec4<f32> = temporary8_;
                temporary2_.w = (_e3788.xxxx - _e3790.zzzz).x;
                let _e3795: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e3795.zzzz).x;
                let _e3800: vec4<f32> = temporary2_;
                let _e3802: vec4<f32> = temporary15_;
                temporary15_.y = (_e3800.zzzz - _e3802.xxxx).x;
                let _e3807: vec4<f32> = temporary2_;
                let _e3809: vec4<f32> = temporary15_;
                temporary15_.z = (_e3807.wwww + _e3809.yyyy).x;
                let _e3814: vec4<f32> = temporary15_;
                let _e3818: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e3814.zzzz / _e3818.xxxx).x;
                let _e3823: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e3823.xxxx).x;
                let _e3828: vec4<f32> = temporary17_;
                let _e3832: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e3828.xxxx * _e3832.xxxx).x;
                let _e3837: vec4<f32> = temporary17_;
                let _e3841: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e3837.yyyy == _e3841.yyyy)).x;
                let _e3847: vec4<f32> = temporary17_;
                let _e3851: vec4<f32> = constant_registers[16u];
                if all((_e3847.zzzz != _e3851.xxxx)) {
                    let _e3857: vec4<f32> = constant_registers[13u];
                    let _e3859: vec4<f32> = temporary8_;
                    let _e3861: vec4<f32> = (_e3857.xyzz * _e3859.yyyy);
                    temporary15_.x = _e3861.x;
                    temporary15_.y = _e3861.y;
                    temporary15_.z = _e3861.z;
                    let _e3868: vec4<f32> = temporary0_;
                    let _e3870: vec4<f32> = temporary15_;
                    let _e3872: vec4<f32> = (_e3868.xyzz + _e3870.xyzz);
                    temporary0_.x = _e3872.x;
                    temporary0_.y = _e3872.y;
                    temporary0_.z = _e3872.z;
                } else {
                    let _e3881: vec4<f32> = constant_registers[14u];
                    let _e3883: vec4<f32> = temporary8_;
                    let _e3885: vec4<f32> = (_e3881.xyzz * _e3883.yyyy);
                    temporary15_.x = _e3885.x;
                    temporary15_.y = _e3885.y;
                    temporary15_.z = _e3885.z;
                    let _e3892: vec4<f32> = temporary0_;
                    let _e3894: vec4<f32> = temporary15_;
                    let _e3896: vec4<f32> = (_e3892.xyzz + _e3894.xyzz);
                    temporary0_.x = _e3896.x;
                    temporary0_.y = _e3896.y;
                    temporary0_.z = _e3896.z;
                }
            }
            let _e3903: vec4<f32> = temporary1_;
            let _e3907: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e3903.zzzz == _e3907.xxxx)).x;
            let _e3913: vec4<f32> = temporary8_;
            let _e3917: vec4<f32> = constant_registers[16u];
            if all((_e3913.zzzz != _e3917.xxxx)) {
                let _e3921: vec4<f32> = temporary7_;
                let _e3923: vec4<f32> = temporary8_;
                let _e3925: vec4<f32> = (_e3921.xyzz * _e3923.yyyy);
                temporary15_.x = _e3925.x;
                temporary15_.y = _e3925.y;
                temporary15_.z = _e3925.z;
                let _e3932: vec4<f32> = temporary0_;
                let _e3934: vec4<f32> = temporary15_;
                let _e3936: vec4<f32> = (_e3932.xyzz + _e3934.xyzz);
                temporary0_.x = _e3936.x;
                temporary0_.y = _e3936.y;
                temporary0_.z = _e3936.z;
            }
            let _e3945: vec4<f32> = constant_registers[16u];
            temporary11_.x = _e3945.yyyy.x;
        }
    }
    let _e3949: vec4<f32> = temporary11_;
    let _e3953: vec4<f32> = constant_registers[16u];
    if all((_e3949.xxxx != _e3953.xxxx)) {
        let _e3959: vec4<f32> = constant_registers[16u];
        temporary1_.z = _e3959.xxxx.x;
        let _e3965: vec4<f32> = constant_registers[17u];
        temporary4_.z = _e3965.wwww.x;
        let _e3971: vec4<f32> = constant_registers[16u];
        let _e3972: vec4<f32> = _e3971.xyxx;
        temporary3_.x = _e3972.x;
        temporary3_.y = _e3972.y;
        temporary3_.z = _e3972.z;
        let _e3979: vec4<f32> = temporary3_;
        let _e3980: vec4<f32> = _e3979.xyzz;
        temporary12_.x = _e3980.x;
        temporary12_.y = _e3980.y;
        temporary12_.z = _e3980.z;
        let _e3989: vec4<f32> = constant_registers[17u];
        temporary2_.w = _e3989.wwww.x;
        let _e3993: vec4<f32> = temporary2_;
        let _e3997: vec4<f32> = constant_registers[16u];
        let _e3999: vec4<f32> = (_e3993.xyzz - _e3997.xxxx);
        temporary20_.x = _e3999.x;
        temporary20_.y = _e3999.y;
        temporary20_.z = _e3999.z;
        let _e4006: vec4<f32> = temporary20_;
        let _e4008: vec4<f32> = temporary12_;
        temporary14_.y = dot(_e4006.xyz, _e4008.xyz);
        let _e4012: vec4<f32> = temporary14_;
        temporary14_.z = -(_e4012.yyyy).x;
        let _e4017: vec4<f32> = temporary9_;
        let _e4019: vec4<f32> = temporary12_;
        temporary4_.x = dot(_e4017.xyz, _e4019.xyz);
        let _e4023: vec4<f32> = temporary14_;
        let _e4025: vec4<f32> = temporary4_;
        temporary16_.x = (_e4023.zzzz / _e4025.xxxx).x;
        let _e4030: vec4<f32> = temporary16_;
        temporary14_.x = _e4030.xxxx.x;
        let _e4036: vec4<f32> = constant_registers[16u];
        let _e4038: vec4<f32> = temporary14_;
        temporary14_.y = vec4<f32>((_e4036.xxxx < _e4038.xxxx)).x;
        let _e4044: vec4<f32> = temporary14_;
        let _e4048: vec4<f32> = constant_registers[16u];
        if all((_e4044.yyyy != _e4048.xxxx)) {
            let _e4052: vec4<f32> = temporary14_;
            temporary2_.w = _e4052.xxxx.x;
        }
        let _e4056: vec4<f32> = temporary2_;
        temporary4_.y = _e4056.wwww.x;
        let _e4060: vec4<f32> = temporary4_;
        let _e4062: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4060.yyyy < _e4062.zzzz)).x;
        let _e4068: vec4<f32> = temporary8_;
        let _e4072: vec4<f32> = constant_registers[16u];
        if all((_e4068.zzzz != _e4072.xxxx)) {
            let _e4076: vec4<f32> = temporary4_;
            temporary4_.z = _e4076.yyyy.x;
            let _e4080: vec4<f32> = temporary3_;
            let _e4081: vec4<f32> = _e4080.xyzz;
            temporary6_.x = _e4081.x;
            temporary6_.y = _e4081.y;
            temporary6_.z = _e4081.z;
            let _e4090: vec4<f32> = constant_registers[16u];
            temporary1_.z = _e4090.yyyy.x;
        }
        let _e4094: vec4<f32> = temporary2_;
        let _e4095: vec4<f32> = _e4094.xyzz;
        temporary15_.x = _e4095.x;
        temporary15_.y = _e4095.y;
        temporary15_.z = _e4095.z;
        let _e4102: vec4<f32> = temporary9_;
        let _e4103: vec4<f32> = _e4102.xyzz;
        temporary17_.x = _e4103.x;
        temporary17_.y = _e4103.y;
        temporary17_.z = _e4103.z;
        let _e4112: vec4<f32> = constant_registers[4u];
        let _e4113: vec4<f32> = _e4112.xyzz;
        temporary18_.x = _e4113.x;
        temporary18_.y = _e4113.y;
        temporary18_.z = _e4113.z;
        let _e4122: vec4<f32> = constant_registers[6u];
        temporary2_.w = _e4122.xxxx.x;
        let _e4126: vec4<f32> = temporary3_;
        let _e4127: vec4<f32> = _e4126.xyzz;
        temporary19_.x = _e4127.x;
        temporary19_.y = _e4127.y;
        temporary19_.z = _e4127.z;
        let _e4136: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4136.wwww.x;
        let _e4140: vec4<f32> = temporary15_;
        let _e4142: vec4<f32> = temporary18_;
        let _e4144: vec4<f32> = (_e4140.xyzz - _e4142.xyzz);
        temporary12_.x = _e4144.x;
        temporary12_.y = _e4144.y;
        temporary12_.z = _e4144.z;
        let _e4151: vec4<f32> = temporary12_;
        let _e4153: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4151.xyz, _e4153.xyz);
        let _e4157: vec4<f32> = temporary13_;
        let _e4159: vec4<f32> = temporary13_;
        temporary3_.w = (_e4157.yyyy * _e4159.yyyy).x;
        let _e4164: vec4<f32> = temporary12_;
        let _e4166: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4164.xyz, _e4166.xyz);
        let _e4170: vec4<f32> = temporary3_;
        let _e4172: vec4<f32> = temporary14_;
        temporary14_.y = (_e4170.wwww - _e4172.xxxx).x;
        let _e4177: vec4<f32> = temporary2_;
        let _e4179: vec4<f32> = temporary2_;
        temporary14_.z = (_e4177.wwww * _e4179.wwww).x;
        let _e4184: vec4<f32> = temporary14_;
        let _e4186: vec4<f32> = temporary14_;
        temporary13_.z = (_e4184.yyyy + _e4186.zzzz).x;
        let _e4193: vec4<f32> = constant_registers[16u];
        let _e4195: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4193.xxxx < _e4195.zzzz)).x;
        let _e4201: vec4<f32> = temporary3_;
        let _e4205: vec4<f32> = constant_registers[16u];
        if all((_e4201.wwww != _e4205.xxxx)) {
            let _e4209: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4209.zzzz).x;
            let _e4214: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4214.yyyy).x;
            let _e4219: vec4<f32> = temporary14_;
            let _e4221: vec4<f32> = temporary13_;
            temporary14_.y = (_e4219.xxxx - _e4221.zzzz).x;
            let _e4226: vec4<f32> = temporary14_;
            temporary3_.w = _e4226.yyyy.x;
            let _e4232: vec4<f32> = constant_registers[16u];
            let _e4234: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4232.xxxx < _e4234.wwww)).x;
            let _e4240: vec4<f32> = temporary14_;
            let _e4244: vec4<f32> = constant_registers[16u];
            if all((_e4240.xxxx != _e4244.xxxx)) {
                let _e4248: vec4<f32> = temporary3_;
                temporary13_.x = _e4248.wwww.x;
                let _e4252: vec4<f32> = temporary17_;
                let _e4254: vec4<f32> = temporary3_;
                let _e4256: vec4<f32> = (_e4252.xyzz * _e4254.wwww);
                temporary14_.x = _e4256.x;
                temporary14_.y = _e4256.y;
                temporary14_.z = _e4256.z;
                let _e4263: vec4<f32> = temporary15_;
                let _e4265: vec4<f32> = temporary14_;
                let _e4267: vec4<f32> = (_e4263.xyzz + _e4265.xyzz);
                temporary20_.x = _e4267.x;
                temporary20_.y = _e4267.y;
                temporary20_.z = _e4267.z;
                let _e4274: vec4<f32> = temporary20_;
                let _e4276: vec4<f32> = temporary18_;
                let _e4278: vec4<f32> = (_e4274.xyzz - _e4276.xyzz);
                temporary16_.x = _e4278.x;
                temporary16_.y = _e4278.y;
                temporary16_.z = _e4278.z;
                let _e4285: vec4<f32> = temporary16_;
                let _e4287: vec3<f32> = normalize(_e4285.xyz);
                temporary19_.x = _e4287.x;
                temporary19_.y = _e4287.y;
                temporary19_.z = _e4287.z;
            }
        }
        let _e4294: vec4<f32> = temporary13_;
        temporary4_.y = _e4294.xxxx.x;
        let _e4298: vec4<f32> = temporary19_;
        let _e4299: vec4<f32> = _e4298.xyzz;
        temporary3_.x = _e4299.x;
        temporary3_.y = _e4299.y;
        temporary3_.z = _e4299.z;
        let _e4306: vec4<f32> = temporary4_;
        let _e4308: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4306.yyyy < _e4308.zzzz)).x;
        let _e4314: vec4<f32> = temporary8_;
        let _e4318: vec4<f32> = constant_registers[16u];
        if all((_e4314.zzzz != _e4318.xxxx)) {
            let _e4322: vec4<f32> = temporary4_;
            temporary4_.z = _e4322.yyyy.x;
            let _e4326: vec4<f32> = temporary3_;
            let _e4327: vec4<f32> = _e4326.xyzz;
            temporary6_.x = _e4327.x;
            temporary6_.y = _e4327.y;
            temporary6_.z = _e4327.z;
            let _e4336: vec4<f32> = constant_registers[5u];
            let _e4337: vec4<f32> = _e4336.xyzz;
            temporary7_.x = _e4337.x;
            temporary7_.y = _e4337.y;
            temporary7_.z = _e4337.z;
            let _e4346: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4346.xxxx.x;
        }
        let _e4350: vec4<f32> = temporary2_;
        let _e4351: vec4<f32> = _e4350.xyzz;
        temporary15_.x = _e4351.x;
        temporary15_.y = _e4351.y;
        temporary15_.z = _e4351.z;
        let _e4358: vec4<f32> = temporary9_;
        let _e4359: vec4<f32> = _e4358.xyzz;
        temporary17_.x = _e4359.x;
        temporary17_.y = _e4359.y;
        temporary17_.z = _e4359.z;
        let _e4368: vec4<f32> = constant_registers[7u];
        let _e4369: vec4<f32> = _e4368.xyzz;
        temporary18_.x = _e4369.x;
        temporary18_.y = _e4369.y;
        temporary18_.z = _e4369.z;
        let _e4378: vec4<f32> = constant_registers[9u];
        temporary2_.w = _e4378.xxxx.x;
        let _e4382: vec4<f32> = temporary3_;
        let _e4383: vec4<f32> = _e4382.xyzz;
        temporary19_.x = _e4383.x;
        temporary19_.y = _e4383.y;
        temporary19_.z = _e4383.z;
        let _e4392: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4392.wwww.x;
        let _e4396: vec4<f32> = temporary15_;
        let _e4398: vec4<f32> = temporary18_;
        let _e4400: vec4<f32> = (_e4396.xyzz - _e4398.xyzz);
        temporary12_.x = _e4400.x;
        temporary12_.y = _e4400.y;
        temporary12_.z = _e4400.z;
        let _e4407: vec4<f32> = temporary12_;
        let _e4409: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4407.xyz, _e4409.xyz);
        let _e4413: vec4<f32> = temporary13_;
        let _e4415: vec4<f32> = temporary13_;
        temporary3_.w = (_e4413.yyyy * _e4415.yyyy).x;
        let _e4420: vec4<f32> = temporary12_;
        let _e4422: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4420.xyz, _e4422.xyz);
        let _e4426: vec4<f32> = temporary3_;
        let _e4428: vec4<f32> = temporary14_;
        temporary14_.y = (_e4426.wwww - _e4428.xxxx).x;
        let _e4433: vec4<f32> = temporary2_;
        let _e4435: vec4<f32> = temporary2_;
        temporary14_.z = (_e4433.wwww * _e4435.wwww).x;
        let _e4440: vec4<f32> = temporary14_;
        let _e4442: vec4<f32> = temporary14_;
        temporary13_.z = (_e4440.yyyy + _e4442.zzzz).x;
        let _e4449: vec4<f32> = constant_registers[16u];
        let _e4451: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4449.xxxx < _e4451.zzzz)).x;
        let _e4457: vec4<f32> = temporary3_;
        let _e4461: vec4<f32> = constant_registers[16u];
        if all((_e4457.wwww != _e4461.xxxx)) {
            let _e4465: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4465.zzzz).x;
            let _e4470: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4470.yyyy).x;
            let _e4475: vec4<f32> = temporary14_;
            let _e4477: vec4<f32> = temporary13_;
            temporary14_.y = (_e4475.xxxx - _e4477.zzzz).x;
            let _e4482: vec4<f32> = temporary14_;
            temporary3_.w = _e4482.yyyy.x;
            let _e4488: vec4<f32> = constant_registers[16u];
            let _e4490: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4488.xxxx < _e4490.wwww)).x;
            let _e4496: vec4<f32> = temporary14_;
            let _e4500: vec4<f32> = constant_registers[16u];
            if all((_e4496.xxxx != _e4500.xxxx)) {
                let _e4504: vec4<f32> = temporary3_;
                temporary13_.x = _e4504.wwww.x;
                let _e4508: vec4<f32> = temporary17_;
                let _e4510: vec4<f32> = temporary3_;
                let _e4512: vec4<f32> = (_e4508.xyzz * _e4510.wwww);
                temporary14_.x = _e4512.x;
                temporary14_.y = _e4512.y;
                temporary14_.z = _e4512.z;
                let _e4519: vec4<f32> = temporary15_;
                let _e4521: vec4<f32> = temporary14_;
                let _e4523: vec4<f32> = (_e4519.xyzz + _e4521.xyzz);
                temporary20_.x = _e4523.x;
                temporary20_.y = _e4523.y;
                temporary20_.z = _e4523.z;
                let _e4530: vec4<f32> = temporary20_;
                let _e4532: vec4<f32> = temporary18_;
                let _e4534: vec4<f32> = (_e4530.xyzz - _e4532.xyzz);
                temporary16_.x = _e4534.x;
                temporary16_.y = _e4534.y;
                temporary16_.z = _e4534.z;
                let _e4541: vec4<f32> = temporary16_;
                let _e4543: vec3<f32> = normalize(_e4541.xyz);
                temporary19_.x = _e4543.x;
                temporary19_.y = _e4543.y;
                temporary19_.z = _e4543.z;
            }
        }
        let _e4550: vec4<f32> = temporary13_;
        temporary4_.y = _e4550.xxxx.x;
        let _e4554: vec4<f32> = temporary19_;
        let _e4555: vec4<f32> = _e4554.xyzz;
        temporary3_.x = _e4555.x;
        temporary3_.y = _e4555.y;
        temporary3_.z = _e4555.z;
        let _e4562: vec4<f32> = temporary4_;
        let _e4564: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4562.yyyy < _e4564.zzzz)).x;
        let _e4570: vec4<f32> = temporary8_;
        let _e4574: vec4<f32> = constant_registers[16u];
        if all((_e4570.zzzz != _e4574.xxxx)) {
            let _e4578: vec4<f32> = temporary4_;
            temporary4_.z = _e4578.yyyy.x;
            let _e4582: vec4<f32> = temporary3_;
            let _e4583: vec4<f32> = _e4582.xyzz;
            temporary6_.x = _e4583.x;
            temporary6_.y = _e4583.y;
            temporary6_.z = _e4583.z;
            let _e4592: vec4<f32> = constant_registers[8u];
            let _e4593: vec4<f32> = _e4592.xyzz;
            temporary7_.x = _e4593.x;
            temporary7_.y = _e4593.y;
            temporary7_.z = _e4593.z;
            let _e4602: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4602.xxxx.x;
        }
        let _e4606: vec4<f32> = temporary2_;
        let _e4607: vec4<f32> = _e4606.xyzz;
        temporary15_.x = _e4607.x;
        temporary15_.y = _e4607.y;
        temporary15_.z = _e4607.z;
        let _e4614: vec4<f32> = temporary9_;
        let _e4615: vec4<f32> = _e4614.xyzz;
        temporary17_.x = _e4615.x;
        temporary17_.y = _e4615.y;
        temporary17_.z = _e4615.z;
        let _e4624: vec4<f32> = constant_registers[10u];
        let _e4625: vec4<f32> = _e4624.xyzz;
        temporary18_.x = _e4625.x;
        temporary18_.y = _e4625.y;
        temporary18_.z = _e4625.z;
        let _e4634: vec4<f32> = constant_registers[12u];
        temporary2_.w = _e4634.xxxx.x;
        let _e4638: vec4<f32> = temporary3_;
        let _e4639: vec4<f32> = _e4638.xyzz;
        temporary19_.x = _e4639.x;
        temporary19_.y = _e4639.y;
        temporary19_.z = _e4639.z;
        let _e4648: vec4<f32> = constant_registers[17u];
        temporary13_.x = _e4648.wwww.x;
        let _e4652: vec4<f32> = temporary15_;
        let _e4654: vec4<f32> = temporary18_;
        let _e4656: vec4<f32> = (_e4652.xyzz - _e4654.xyzz);
        temporary12_.x = _e4656.x;
        temporary12_.y = _e4656.y;
        temporary12_.z = _e4656.z;
        let _e4663: vec4<f32> = temporary12_;
        let _e4665: vec4<f32> = temporary17_;
        temporary13_.y = dot(_e4663.xyz, _e4665.xyz);
        let _e4669: vec4<f32> = temporary13_;
        let _e4671: vec4<f32> = temporary13_;
        temporary3_.w = (_e4669.yyyy * _e4671.yyyy).x;
        let _e4676: vec4<f32> = temporary12_;
        let _e4678: vec4<f32> = temporary12_;
        temporary14_.x = dot(_e4676.xyz, _e4678.xyz);
        let _e4682: vec4<f32> = temporary3_;
        let _e4684: vec4<f32> = temporary14_;
        temporary14_.y = (_e4682.wwww - _e4684.xxxx).x;
        let _e4689: vec4<f32> = temporary2_;
        let _e4691: vec4<f32> = temporary2_;
        temporary14_.z = (_e4689.wwww * _e4691.wwww).x;
        let _e4696: vec4<f32> = temporary14_;
        let _e4698: vec4<f32> = temporary14_;
        temporary13_.z = (_e4696.yyyy + _e4698.zzzz).x;
        let _e4705: vec4<f32> = constant_registers[16u];
        let _e4707: vec4<f32> = temporary13_;
        temporary3_.w = vec4<f32>((_e4705.xxxx < _e4707.zzzz)).x;
        let _e4713: vec4<f32> = temporary3_;
        let _e4717: vec4<f32> = constant_registers[16u];
        if all((_e4713.wwww != _e4717.xxxx)) {
            let _e4721: vec4<f32> = temporary13_;
            temporary13_.z = sqrt(_e4721.zzzz).x;
            let _e4726: vec4<f32> = temporary13_;
            temporary14_.x = -(_e4726.yyyy).x;
            let _e4731: vec4<f32> = temporary14_;
            let _e4733: vec4<f32> = temporary13_;
            temporary14_.y = (_e4731.xxxx - _e4733.zzzz).x;
            let _e4738: vec4<f32> = temporary14_;
            temporary3_.w = _e4738.yyyy.x;
            let _e4744: vec4<f32> = constant_registers[16u];
            let _e4746: vec4<f32> = temporary3_;
            temporary14_.x = vec4<f32>((_e4744.xxxx < _e4746.wwww)).x;
            let _e4752: vec4<f32> = temporary14_;
            let _e4756: vec4<f32> = constant_registers[16u];
            if all((_e4752.xxxx != _e4756.xxxx)) {
                let _e4760: vec4<f32> = temporary3_;
                temporary13_.x = _e4760.wwww.x;
                let _e4764: vec4<f32> = temporary17_;
                let _e4766: vec4<f32> = temporary3_;
                let _e4768: vec4<f32> = (_e4764.xyzz * _e4766.wwww);
                temporary14_.x = _e4768.x;
                temporary14_.y = _e4768.y;
                temporary14_.z = _e4768.z;
                let _e4775: vec4<f32> = temporary15_;
                let _e4777: vec4<f32> = temporary14_;
                let _e4779: vec4<f32> = (_e4775.xyzz + _e4777.xyzz);
                temporary20_.x = _e4779.x;
                temporary20_.y = _e4779.y;
                temporary20_.z = _e4779.z;
                let _e4786: vec4<f32> = temporary20_;
                let _e4788: vec4<f32> = temporary18_;
                let _e4790: vec4<f32> = (_e4786.xyzz - _e4788.xyzz);
                temporary16_.x = _e4790.x;
                temporary16_.y = _e4790.y;
                temporary16_.z = _e4790.z;
                let _e4797: vec4<f32> = temporary16_;
                let _e4799: vec3<f32> = normalize(_e4797.xyz);
                temporary19_.x = _e4799.x;
                temporary19_.y = _e4799.y;
                temporary19_.z = _e4799.z;
            }
        }
        let _e4806: vec4<f32> = temporary13_;
        temporary4_.y = _e4806.xxxx.x;
        let _e4810: vec4<f32> = temporary19_;
        let _e4811: vec4<f32> = _e4810.xyzz;
        temporary3_.x = _e4811.x;
        temporary3_.y = _e4811.y;
        temporary3_.z = _e4811.z;
        let _e4818: vec4<f32> = temporary4_;
        let _e4820: vec4<f32> = temporary4_;
        temporary8_.z = vec4<f32>((_e4818.yyyy < _e4820.zzzz)).x;
        let _e4826: vec4<f32> = temporary8_;
        let _e4830: vec4<f32> = constant_registers[16u];
        if all((_e4826.zzzz != _e4830.xxxx)) {
            let _e4834: vec4<f32> = temporary4_;
            temporary4_.z = _e4834.yyyy.x;
            let _e4838: vec4<f32> = temporary3_;
            let _e4839: vec4<f32> = _e4838.xyzz;
            temporary6_.x = _e4839.x;
            temporary6_.y = _e4839.y;
            temporary6_.z = _e4839.z;
            let _e4848: vec4<f32> = constant_registers[11u];
            let _e4849: vec4<f32> = _e4848.xyzz;
            temporary7_.x = _e4849.x;
            temporary7_.y = _e4849.y;
            temporary7_.z = _e4849.z;
            let _e4858: vec4<f32> = constant_registers[18u];
            temporary1_.z = _e4858.xxxx.x;
        }
        let _e4862: vec4<f32> = temporary11_;
        let _e4866: vec4<f32> = constant_registers[16u];
        temporary11_.y = (_e4862.yyyy + _e4866.yyyy).x;
        let _e4871: vec4<f32> = temporary1_;
        let _e4875: vec4<f32> = constant_registers[16u];
        temporary8_.z = vec4<f32>((_e4871.zzzz == _e4875.xxxx)).x;
        let _e4881: vec4<f32> = temporary8_;
        let _e4885: vec4<f32> = constant_registers[16u];
        if all((_e4881.zzzz != _e4885.xxxx)) {
            let _e4891: vec4<f32> = constant_registers[16u];
            temporary11_.z = _e4891.yyyy.x;
        } else {
            let _e4895: vec4<f32> = temporary9_;
            let _e4897: vec4<f32> = temporary4_;
            let _e4899: vec4<f32> = (_e4895.xyzz * _e4897.zzzz);
            temporary15_.x = _e4899.x;
            temporary15_.y = _e4899.y;
            temporary15_.z = _e4899.z;
            let _e4906: vec4<f32> = temporary2_;
            let _e4908: vec4<f32> = temporary15_;
            let _e4910: vec4<f32> = (_e4906.xyzz + _e4908.xyzz);
            temporary2_.x = _e4910.x;
            temporary2_.y = _e4910.y;
            temporary2_.z = _e4910.z;
            let _e4917: vec4<f32> = temporary9_;
            let _e4919: vec4<f32> = temporary6_;
            temporary8_.z = dot(_e4917.xyz, _e4919.xyz);
            let _e4923: vec4<f32> = temporary8_;
            let _e4927: vec4<f32> = constant_registers[18u];
            temporary2_.w = (_e4923.zzzz * _e4927.xxxx).x;
            let _e4932: vec4<f32> = temporary2_;
            let _e4934: vec4<f32> = temporary6_;
            let _e4936: vec4<f32> = (_e4932.wwww * _e4934.xyzz);
            temporary15_.x = _e4936.x;
            temporary15_.y = _e4936.y;
            temporary15_.z = _e4936.z;
            let _e4943: vec4<f32> = temporary9_;
            let _e4945: vec4<f32> = temporary15_;
            let _e4947: vec4<f32> = (_e4943.xyzz - _e4945.xyzz);
            temporary9_.x = _e4947.x;
            temporary9_.y = _e4947.y;
            temporary9_.z = _e4947.z;
            let _e4954: vec4<f32> = temporary9_;
            let _e4958: vec4<f32> = constant_registers[18u];
            let _e4960: vec4<f32> = (_e4954.xyzz * _e4958.yyyy);
            temporary15_.x = _e4960.x;
            temporary15_.y = _e4960.y;
            temporary15_.z = _e4960.z;
            let _e4967: vec4<f32> = temporary2_;
            let _e4969: vec4<f32> = temporary15_;
            let _e4971: vec4<f32> = (_e4967.xyzz + _e4969.xyzz);
            temporary2_.x = _e4971.x;
            temporary2_.y = _e4971.y;
            temporary2_.z = _e4971.z;
            let _e4980: vec4<f32> = constant_registers[15u];
            let _e4982: vec4<f32> = temporary2_;
            let _e4984: vec4<f32> = (_e4980.xyzz - _e4982.xyzz);
            temporary5_.x = _e4984.x;
            temporary5_.y = _e4984.y;
            temporary5_.z = _e4984.z;
            let _e4991: vec4<f32> = temporary5_;
            let _e4993: vec3<f32> = normalize(_e4991.xyz);
            temporary10_.x = _e4993.x;
            temporary10_.y = _e4993.y;
            temporary10_.z = _e4993.z;
            let _e5000: vec4<f32> = temporary5_;
            let _e5002: vec4<f32> = temporary5_;
            temporary8_.z = dot(_e5000.xyz, _e5002.xyz);
            let _e5006: vec4<f32> = temporary8_;
            temporary1_.y = sqrt(_e5006.zzzz).x;
            let _e5011: vec4<f32> = temporary6_;
            let _e5013: vec4<f32> = temporary10_;
            temporary8_.z = dot(_e5011.xyz, _e5013.xyz);
            let _e5017: vec4<f32> = temporary8_;
            temporary2_.w = saturate(_e5017.zzzz).x;
            let _e5022: vec4<f32> = temporary1_;
            let _e5024: vec4<f32> = temporary1_;
            temporary15_.x = (_e5022.yyyy * _e5024.yyyy).x;
            let _e5029: vec4<f32> = temporary15_;
            let _e5033: vec4<f32> = constant_registers[18u];
            temporary15_.y = (_e5029.xxxx * _e5033.zzzz).x;
            let _e5040: vec4<f32> = constant_registers[18u];
            let _e5042: vec4<f32> = temporary15_;
            temporary15_.z = (_e5040.wwww + _e5042.yyyy).x;
            let _e5047: vec4<f32> = temporary2_;
            let _e5049: vec4<f32> = temporary15_;
            temporary1_.x = (_e5047.wwww / _e5049.zzzz).x;
            let _e5054: vec4<f32> = temporary1_;
            temporary8_.x = _e5054.xxxx.x;
            let _e5060: vec4<f32> = constant_registers[6u];
            temporary2_.w = _e5060.xxxx.x;
            let _e5066: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5066.wwww.x;
            let _e5070: vec4<f32> = temporary2_;
            let _e5074: vec4<f32> = constant_registers[4u];
            let _e5076: vec4<f32> = (_e5070.xyzz - _e5074.xyzz);
            temporary13_.x = _e5076.x;
            temporary13_.y = _e5076.y;
            temporary13_.z = _e5076.z;
            let _e5083: vec4<f32> = temporary13_;
            let _e5085: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5083.xyz, _e5085.xyz);
            let _e5089: vec4<f32> = temporary19_;
            let _e5091: vec4<f32> = temporary19_;
            temporary1_.w = (_e5089.yyyy * _e5091.yyyy).x;
            let _e5096: vec4<f32> = temporary13_;
            let _e5098: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5096.xyz, _e5098.xyz);
            let _e5102: vec4<f32> = temporary1_;
            let _e5104: vec4<f32> = temporary12_;
            temporary12_.y = (_e5102.wwww - _e5104.xxxx).x;
            let _e5109: vec4<f32> = temporary2_;
            let _e5111: vec4<f32> = temporary2_;
            temporary12_.z = (_e5109.wwww * _e5111.wwww).x;
            let _e5116: vec4<f32> = temporary12_;
            let _e5118: vec4<f32> = temporary12_;
            temporary19_.z = (_e5116.yyyy + _e5118.zzzz).x;
            let _e5125: vec4<f32> = constant_registers[16u];
            let _e5127: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5125.xxxx < _e5127.zzzz)).x;
            let _e5133: vec4<f32> = temporary1_;
            let _e5137: vec4<f32> = constant_registers[16u];
            if all((_e5133.wwww != _e5137.xxxx)) {
                let _e5141: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5141.zzzz).x;
                let _e5146: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5146.yyyy).x;
                let _e5151: vec4<f32> = temporary12_;
                let _e5153: vec4<f32> = temporary19_;
                temporary1_.w = (_e5151.xxxx - _e5153.zzzz).x;
                let _e5160: vec4<f32> = constant_registers[16u];
                let _e5162: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5160.xxxx < _e5162.wwww)).x;
                let _e5168: vec4<f32> = temporary12_;
                let _e5172: vec4<f32> = constant_registers[16u];
                if all((_e5168.xxxx != _e5172.xxxx)) {
                    let _e5176: vec4<f32> = temporary1_;
                    temporary19_.x = _e5176.wwww.x;
                }
            }
            let _e5180: vec4<f32> = temporary19_;
            let _e5182: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5180.xxxx < _e5182.yyyy)).x;
            let _e5188: vec4<f32> = temporary8_;
            let _e5192: vec4<f32> = constant_registers[16u];
            if all((_e5188.zzzz != _e5192.xxxx)) {
                let _e5198: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5198.xxxx.x;
            }
            let _e5204: vec4<f32> = constant_registers[9u];
            temporary2_.w = _e5204.xxxx.x;
            let _e5210: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5210.wwww.x;
            let _e5214: vec4<f32> = temporary2_;
            let _e5218: vec4<f32> = constant_registers[7u];
            let _e5220: vec4<f32> = (_e5214.xyzz - _e5218.xyzz);
            temporary13_.x = _e5220.x;
            temporary13_.y = _e5220.y;
            temporary13_.z = _e5220.z;
            let _e5227: vec4<f32> = temporary13_;
            let _e5229: vec4<f32> = temporary10_;
            temporary19_.y = dot(_e5227.xyz, _e5229.xyz);
            let _e5233: vec4<f32> = temporary19_;
            let _e5235: vec4<f32> = temporary19_;
            temporary1_.w = (_e5233.yyyy * _e5235.yyyy).x;
            let _e5240: vec4<f32> = temporary13_;
            let _e5242: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5240.xyz, _e5242.xyz);
            let _e5246: vec4<f32> = temporary1_;
            let _e5248: vec4<f32> = temporary12_;
            temporary12_.y = (_e5246.wwww - _e5248.xxxx).x;
            let _e5253: vec4<f32> = temporary2_;
            let _e5255: vec4<f32> = temporary2_;
            temporary12_.z = (_e5253.wwww * _e5255.wwww).x;
            let _e5260: vec4<f32> = temporary12_;
            let _e5262: vec4<f32> = temporary12_;
            temporary19_.z = (_e5260.yyyy + _e5262.zzzz).x;
            let _e5269: vec4<f32> = constant_registers[16u];
            let _e5271: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5269.xxxx < _e5271.zzzz)).x;
            let _e5277: vec4<f32> = temporary1_;
            let _e5281: vec4<f32> = constant_registers[16u];
            if all((_e5277.wwww != _e5281.xxxx)) {
                let _e5285: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5285.zzzz).x;
                let _e5290: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5290.yyyy).x;
                let _e5295: vec4<f32> = temporary12_;
                let _e5297: vec4<f32> = temporary19_;
                temporary1_.w = (_e5295.xxxx - _e5297.zzzz).x;
                let _e5304: vec4<f32> = constant_registers[16u];
                let _e5306: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5304.xxxx < _e5306.wwww)).x;
                let _e5312: vec4<f32> = temporary12_;
                let _e5316: vec4<f32> = constant_registers[16u];
                if all((_e5312.xxxx != _e5316.xxxx)) {
                    let _e5320: vec4<f32> = temporary1_;
                    temporary19_.x = _e5320.wwww.x;
                }
            }
            let _e5324: vec4<f32> = temporary19_;
            let _e5326: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5324.xxxx < _e5326.yyyy)).x;
            let _e5332: vec4<f32> = temporary8_;
            let _e5336: vec4<f32> = constant_registers[16u];
            if all((_e5332.zzzz != _e5336.xxxx)) {
                let _e5342: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5342.xxxx.x;
            }
            let _e5346: vec4<f32> = temporary2_;
            let _e5347: vec4<f32> = _e5346.xyzz;
            temporary15_.x = _e5347.x;
            temporary15_.y = _e5347.y;
            temporary15_.z = _e5347.z;
            let _e5354: vec4<f32> = temporary10_;
            let _e5355: vec4<f32> = _e5354.xyzz;
            temporary17_.x = _e5355.x;
            temporary17_.y = _e5355.y;
            temporary17_.z = _e5355.z;
            let _e5364: vec4<f32> = constant_registers[12u];
            temporary2_.w = _e5364.xxxx.x;
            let _e5370: vec4<f32> = constant_registers[17u];
            temporary19_.x = _e5370.wwww.x;
            let _e5374: vec4<f32> = temporary15_;
            let _e5378: vec4<f32> = constant_registers[10u];
            let _e5380: vec4<f32> = (_e5374.xyzz - _e5378.xyzz);
            temporary13_.x = _e5380.x;
            temporary13_.y = _e5380.y;
            temporary13_.z = _e5380.z;
            let _e5387: vec4<f32> = temporary13_;
            let _e5389: vec4<f32> = temporary17_;
            temporary19_.y = dot(_e5387.xyz, _e5389.xyz);
            let _e5393: vec4<f32> = temporary19_;
            let _e5395: vec4<f32> = temporary19_;
            temporary1_.w = (_e5393.yyyy * _e5395.yyyy).x;
            let _e5400: vec4<f32> = temporary13_;
            let _e5402: vec4<f32> = temporary13_;
            temporary12_.x = dot(_e5400.xyz, _e5402.xyz);
            let _e5406: vec4<f32> = temporary1_;
            let _e5408: vec4<f32> = temporary12_;
            temporary12_.y = (_e5406.wwww - _e5408.xxxx).x;
            let _e5413: vec4<f32> = temporary2_;
            let _e5415: vec4<f32> = temporary2_;
            temporary12_.z = (_e5413.wwww * _e5415.wwww).x;
            let _e5420: vec4<f32> = temporary12_;
            let _e5422: vec4<f32> = temporary12_;
            temporary19_.z = (_e5420.yyyy + _e5422.zzzz).x;
            let _e5429: vec4<f32> = constant_registers[16u];
            let _e5431: vec4<f32> = temporary19_;
            temporary1_.w = vec4<f32>((_e5429.xxxx < _e5431.zzzz)).x;
            let _e5437: vec4<f32> = temporary1_;
            let _e5441: vec4<f32> = constant_registers[16u];
            if all((_e5437.wwww != _e5441.xxxx)) {
                let _e5445: vec4<f32> = temporary19_;
                temporary19_.z = sqrt(_e5445.zzzz).x;
                let _e5450: vec4<f32> = temporary19_;
                temporary12_.x = -(_e5450.yyyy).x;
                let _e5455: vec4<f32> = temporary12_;
                let _e5457: vec4<f32> = temporary19_;
                temporary1_.w = (_e5455.xxxx - _e5457.zzzz).x;
                let _e5464: vec4<f32> = constant_registers[16u];
                let _e5466: vec4<f32> = temporary1_;
                temporary12_.x = vec4<f32>((_e5464.xxxx < _e5466.wwww)).x;
                let _e5472: vec4<f32> = temporary12_;
                let _e5476: vec4<f32> = constant_registers[16u];
                if all((_e5472.xxxx != _e5476.xxxx)) {
                    let _e5480: vec4<f32> = temporary1_;
                    temporary19_.x = _e5480.wwww.x;
                }
            }
            let _e5484: vec4<f32> = temporary19_;
            let _e5486: vec4<f32> = temporary1_;
            temporary8_.z = vec4<f32>((_e5484.xxxx < _e5486.yyyy)).x;
            let _e5492: vec4<f32> = temporary8_;
            let _e5496: vec4<f32> = constant_registers[16u];
            if all((_e5492.zzzz != _e5496.xxxx)) {
                let _e5502: vec4<f32> = constant_registers[16u];
                temporary8_.x = _e5502.xxxx.x;
            }
            let _e5506: vec4<f32> = temporary6_;
            temporary8_.z = saturate(_e5506.yyyy).x;
            let _e5511: vec4<f32> = temporary8_;
            let _e5515: vec4<f32> = constant_registers[19u];
            temporary2_.w = (_e5511.zzzz * _e5515.xxxx).x;
            let _e5520: vec4<f32> = temporary8_;
            let _e5522: vec4<f32> = temporary2_;
            temporary8_.x = (_e5520.xxxx + _e5522.wwww).x;
            let _e5527: vec4<f32> = temporary8_;
            let _e5531: vec4<f32> = constant_registers[19u];
            temporary8_.z = (_e5527.xxxx * _e5531.yyyy).x;
            let _e5538: vec4<f32> = constant_registers[19u];
            let _e5540: vec4<f32> = temporary8_;
            temporary2_.w = (_e5538.zzzz + _e5540.zzzz).x;
            let _e5545: vec4<f32> = temporary2_;
            temporary8_.y = _e5545.wwww.x;
            let _e5549: vec4<f32> = temporary1_;
            let _e5553: vec4<f32> = constant_registers[16u];
            temporary8_.z = vec4<f32>((_e5549.zzzz == _e5553.yyyy)).x;
            let _e5559: vec4<f32> = temporary8_;
            let _e5563: vec4<f32> = constant_registers[16u];
            if all((_e5559.zzzz != _e5563.xxxx)) {
                let _e5567: vec4<f32> = temporary2_;
                temporary8_.z = fract(_e5567.xxxx).x;
                let _e5572: vec4<f32> = temporary2_;
                let _e5574: vec4<f32> = temporary8_;
                temporary2_.w = (_e5572.xxxx - _e5574.zzzz).x;
                let _e5579: vec4<f32> = temporary2_;
                temporary15_.x = fract(_e5579.zzzz).x;
                let _e5584: vec4<f32> = temporary2_;
                let _e5586: vec4<f32> = temporary15_;
                temporary15_.y = (_e5584.zzzz - _e5586.xxxx).x;
                let _e5591: vec4<f32> = temporary2_;
                let _e5593: vec4<f32> = temporary15_;
                temporary15_.z = (_e5591.wwww + _e5593.yyyy).x;
                let _e5598: vec4<f32> = temporary15_;
                let _e5602: vec4<f32> = constant_registers[18u];
                temporary1_.x = (_e5598.zzzz / _e5602.xxxx).x;
                let _e5607: vec4<f32> = temporary1_;
                temporary17_.x = fract(_e5607.xxxx).x;
                let _e5612: vec4<f32> = temporary17_;
                let _e5616: vec4<f32> = constant_registers[18u];
                temporary17_.y = (_e5612.xxxx * _e5616.xxxx).x;
                let _e5621: vec4<f32> = temporary17_;
                let _e5625: vec4<f32> = constant_registers[16u];
                temporary17_.z = vec4<f32>((_e5621.yyyy == _e5625.yyyy)).x;
                let _e5631: vec4<f32> = temporary17_;
                let _e5635: vec4<f32> = constant_registers[16u];
                if all((_e5631.zzzz != _e5635.xxxx)) {
                    let _e5641: vec4<f32> = constant_registers[13u];
                    let _e5643: vec4<f32> = temporary8_;
                    let _e5645: vec4<f32> = (_e5641.xyzz * _e5643.yyyy);
                    temporary15_.x = _e5645.x;
                    temporary15_.y = _e5645.y;
                    temporary15_.z = _e5645.z;
                    let _e5652: vec4<f32> = temporary0_;
                    let _e5654: vec4<f32> = temporary15_;
                    let _e5656: vec4<f32> = (_e5652.xyzz + _e5654.xyzz);
                    temporary0_.x = _e5656.x;
                    temporary0_.y = _e5656.y;
                    temporary0_.z = _e5656.z;
                } else {
                    let _e5665: vec4<f32> = constant_registers[14u];
                    let _e5667: vec4<f32> = temporary8_;
                    let _e5669: vec4<f32> = (_e5665.xyzz * _e5667.yyyy);
                    temporary15_.x = _e5669.x;
                    temporary15_.y = _e5669.y;
                    temporary15_.z = _e5669.z;
                    let _e5676: vec4<f32> = temporary0_;
                    let _e5678: vec4<f32> = temporary15_;
                    let _e5680: vec4<f32> = (_e5676.xyzz + _e5678.xyzz);
                    temporary0_.x = _e5680.x;
                    temporary0_.y = _e5680.y;
                    temporary0_.z = _e5680.z;
                }
            }
            let _e5687: vec4<f32> = temporary1_;
            let _e5691: vec4<f32> = constant_registers[18u];
            temporary8_.z = vec4<f32>((_e5687.zzzz == _e5691.xxxx)).x;
            let _e5697: vec4<f32> = temporary8_;
            let _e5701: vec4<f32> = constant_registers[16u];
            if all((_e5697.zzzz != _e5701.xxxx)) {
                let _e5705: vec4<f32> = temporary7_;
                let _e5707: vec4<f32> = temporary8_;
                let _e5709: vec4<f32> = (_e5705.xyzz * _e5707.yyyy);
                temporary15_.x = _e5709.x;
                temporary15_.y = _e5709.y;
                temporary15_.z = _e5709.z;
                let _e5716: vec4<f32> = temporary0_;
                let _e5718: vec4<f32> = temporary15_;
                let _e5720: vec4<f32> = (_e5716.xyzz + _e5718.xyzz);
                temporary0_.x = _e5720.x;
                temporary0_.y = _e5720.y;
                temporary0_.z = _e5720.z;
            }
        }
    }
    let _e5727: vec4<f32> = temporary9_;
    let _e5731: vec4<f32> = textureSample(texture0_, sampler2_, _e5727.xyzz.xyz);
    temporary1_ = _e5731;
    let _e5732: vec4<f32> = temporary11_;
    let _e5736: vec4<f32> = constant_registers[16u];
    if all((_e5732.zzzz != _e5736.xxxx)) {
        let _e5740: vec4<f32> = temporary0_;
        let _e5742: vec4<f32> = temporary1_;
        let _e5744: vec4<f32> = (_e5740.xyzz + _e5742.xyzz);
        temporary0_.x = _e5744.x;
        temporary0_.y = _e5744.y;
        temporary0_.z = _e5744.z;
    }
    let _e5751: vec4<f32> = temporary0_;
    let _e5753: vec4<f32> = temporary11_;
    let _e5755: vec4<f32> = (_e5751.xyzz / _e5753.yyyy);
    temporary0_.x = _e5755.x;
    temporary0_.y = _e5755.y;
    temporary0_.z = _e5755.z;
    let _e5762: vec4<f32> = temporary0_;
    dest_temp = _e5762;
    let _e5763: vec4<f32> = dest_temp;
    return FragmentOutput(_e5763);
}