---
source: render/naga-agal/tests/wgsl.rs
assertion_line: 132
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;

@fragment 
fn main(@location(0) param: vec4<f32>) -> FragmentOutput {
    var dest_temp: vec4<f32>;
    var temporary0_: vec4<f32>;
    var temporary1_: vec4<f32>;
    var temporary3_: vec4<f32>;
    var temporary2_: vec4<f32>;

    let _e11: vec4<f32> = param.xyyy;
    temporary0_.x = _e11.x;
    temporary0_.y = _e11.y;
    let _e19: vec4<f32> = constant_registers[0u];
    let _e20: vec4<f32> = _e19.xxxx;
    temporary0_.z = _e20.z;
    temporary0_.w = _e20.w;
    let _e27: vec4<f32> = constant_registers[0u];
    temporary1_.x = _e27.xxxx.x;
    let _e32: vec4<f32> = temporary0_;
    temporary0_.z = -(_e32.yyyy).x;
    let _e39: vec4<f32> = constant_registers[0u];
    let _e41: vec4<f32> = temporary0_;
    temporary3_.x = (_e39.zzzz * _e41.xxxx).x;
    let _e47: vec4<f32> = temporary0_;
    let _e49: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e47.xyw, _e49.xzw);
    let _e53: vec4<f32> = temporary3_;
    let _e55: vec4<f32> = temporary0_;
    temporary0_.y = (_e53.xxxx * _e55.yyyy).x;
    let _e60: vec4<f32> = temporary0_;
    let _e64: vec4<f32> = constant_registers[3u];
    let _e66: vec4<f32> = (_e60.xyyy + _e64.xyyy);
    temporary0_.x = _e66.x;
    temporary0_.y = _e66.y;
    let _e71: vec4<f32> = temporary0_;
    let _e73: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e71.xyw, _e73.xyw);
    let _e78: vec4<f32> = temporary2_;
    let _e82: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e78.xxxx < _e82.wwww)).x;
    let _e88: vec4<f32> = temporary1_;
    let _e90: vec4<f32> = temporary3_;
    temporary1_.x = (_e88.xxxx + _e90.xxxx).x;
    let _e95: vec4<f32> = temporary0_;
    temporary0_.z = -(_e95.yyyy).x;
    let _e102: vec4<f32> = constant_registers[0u];
    let _e104: vec4<f32> = temporary0_;
    temporary3_.x = (_e102.zzzz * _e104.xxxx).x;
    let _e109: vec4<f32> = temporary0_;
    let _e111: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e109.xyw, _e111.xzw);
    let _e115: vec4<f32> = temporary3_;
    let _e117: vec4<f32> = temporary0_;
    temporary0_.y = (_e115.xxxx * _e117.yyyy).x;
    let _e122: vec4<f32> = temporary0_;
    let _e126: vec4<f32> = constant_registers[3u];
    let _e128: vec4<f32> = (_e122.xyyy + _e126.xyyy);
    temporary0_.x = _e128.x;
    temporary0_.y = _e128.y;
    let _e133: vec4<f32> = temporary0_;
    let _e135: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e133.xyw, _e135.xyw);
    let _e139: vec4<f32> = temporary2_;
    let _e143: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e139.xxxx < _e143.wwww)).x;
    let _e149: vec4<f32> = temporary1_;
    let _e151: vec4<f32> = temporary3_;
    temporary1_.x = (_e149.xxxx + _e151.xxxx).x;
    let _e156: vec4<f32> = temporary0_;
    temporary0_.z = -(_e156.yyyy).x;
    let _e163: vec4<f32> = constant_registers[0u];
    let _e165: vec4<f32> = temporary0_;
    temporary3_.x = (_e163.zzzz * _e165.xxxx).x;
    let _e170: vec4<f32> = temporary0_;
    let _e172: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e170.xyw, _e172.xzw);
    let _e176: vec4<f32> = temporary3_;
    let _e178: vec4<f32> = temporary0_;
    temporary0_.y = (_e176.xxxx * _e178.yyyy).x;
    let _e183: vec4<f32> = temporary0_;
    let _e187: vec4<f32> = constant_registers[3u];
    let _e189: vec4<f32> = (_e183.xyyy + _e187.xyyy);
    temporary0_.x = _e189.x;
    temporary0_.y = _e189.y;
    let _e194: vec4<f32> = temporary0_;
    let _e196: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e194.xyw, _e196.xyw);
    let _e200: vec4<f32> = temporary2_;
    let _e204: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e200.xxxx < _e204.wwww)).x;
    let _e210: vec4<f32> = temporary1_;
    let _e212: vec4<f32> = temporary3_;
    temporary1_.x = (_e210.xxxx + _e212.xxxx).x;
    let _e217: vec4<f32> = temporary0_;
    temporary0_.z = -(_e217.yyyy).x;
    let _e224: vec4<f32> = constant_registers[0u];
    let _e226: vec4<f32> = temporary0_;
    temporary3_.x = (_e224.zzzz * _e226.xxxx).x;
    let _e231: vec4<f32> = temporary0_;
    let _e233: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e231.xyw, _e233.xzw);
    let _e237: vec4<f32> = temporary3_;
    let _e239: vec4<f32> = temporary0_;
    temporary0_.y = (_e237.xxxx * _e239.yyyy).x;
    let _e244: vec4<f32> = temporary0_;
    let _e248: vec4<f32> = constant_registers[3u];
    let _e250: vec4<f32> = (_e244.xyyy + _e248.xyyy);
    temporary0_.x = _e250.x;
    temporary0_.y = _e250.y;
    let _e255: vec4<f32> = temporary0_;
    let _e257: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e255.xyw, _e257.xyw);
    let _e261: vec4<f32> = temporary2_;
    let _e265: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e261.xxxx < _e265.wwww)).x;
    let _e271: vec4<f32> = temporary1_;
    let _e273: vec4<f32> = temporary3_;
    temporary1_.x = (_e271.xxxx + _e273.xxxx).x;
    let _e278: vec4<f32> = temporary0_;
    temporary0_.z = -(_e278.yyyy).x;
    let _e285: vec4<f32> = constant_registers[0u];
    let _e287: vec4<f32> = temporary0_;
    temporary3_.x = (_e285.zzzz * _e287.xxxx).x;
    let _e292: vec4<f32> = temporary0_;
    let _e294: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e292.xyw, _e294.xzw);
    let _e298: vec4<f32> = temporary3_;
    let _e300: vec4<f32> = temporary0_;
    temporary0_.y = (_e298.xxxx * _e300.yyyy).x;
    let _e305: vec4<f32> = temporary0_;
    let _e309: vec4<f32> = constant_registers[3u];
    let _e311: vec4<f32> = (_e305.xyyy + _e309.xyyy);
    temporary0_.x = _e311.x;
    temporary0_.y = _e311.y;
    let _e316: vec4<f32> = temporary0_;
    let _e318: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e316.xyw, _e318.xyw);
    let _e322: vec4<f32> = temporary2_;
    let _e326: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e322.xxxx < _e326.wwww)).x;
    let _e332: vec4<f32> = temporary1_;
    let _e334: vec4<f32> = temporary3_;
    temporary1_.x = (_e332.xxxx + _e334.xxxx).x;
    let _e339: vec4<f32> = temporary0_;
    temporary0_.z = -(_e339.yyyy).x;
    let _e346: vec4<f32> = constant_registers[0u];
    let _e348: vec4<f32> = temporary0_;
    temporary3_.x = (_e346.zzzz * _e348.xxxx).x;
    let _e353: vec4<f32> = temporary0_;
    let _e355: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e353.xyw, _e355.xzw);
    let _e359: vec4<f32> = temporary3_;
    let _e361: vec4<f32> = temporary0_;
    temporary0_.y = (_e359.xxxx * _e361.yyyy).x;
    let _e366: vec4<f32> = temporary0_;
    let _e370: vec4<f32> = constant_registers[3u];
    let _e372: vec4<f32> = (_e366.xyyy + _e370.xyyy);
    temporary0_.x = _e372.x;
    temporary0_.y = _e372.y;
    let _e377: vec4<f32> = temporary0_;
    let _e379: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e377.xyw, _e379.xyw);
    let _e383: vec4<f32> = temporary2_;
    let _e387: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e383.xxxx < _e387.wwww)).x;
    let _e393: vec4<f32> = temporary1_;
    let _e395: vec4<f32> = temporary3_;
    temporary1_.x = (_e393.xxxx + _e395.xxxx).x;
    let _e400: vec4<f32> = temporary0_;
    temporary0_.z = -(_e400.yyyy).x;
    let _e407: vec4<f32> = constant_registers[0u];
    let _e409: vec4<f32> = temporary0_;
    temporary3_.x = (_e407.zzzz * _e409.xxxx).x;
    let _e414: vec4<f32> = temporary0_;
    let _e416: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e414.xyw, _e416.xzw);
    let _e420: vec4<f32> = temporary3_;
    let _e422: vec4<f32> = temporary0_;
    temporary0_.y = (_e420.xxxx * _e422.yyyy).x;
    let _e427: vec4<f32> = temporary0_;
    let _e431: vec4<f32> = constant_registers[3u];
    let _e433: vec4<f32> = (_e427.xyyy + _e431.xyyy);
    temporary0_.x = _e433.x;
    temporary0_.y = _e433.y;
    let _e438: vec4<f32> = temporary0_;
    let _e440: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e438.xyw, _e440.xyw);
    let _e444: vec4<f32> = temporary2_;
    let _e448: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e444.xxxx < _e448.wwww)).x;
    let _e454: vec4<f32> = temporary1_;
    let _e456: vec4<f32> = temporary3_;
    temporary1_.x = (_e454.xxxx + _e456.xxxx).x;
    let _e461: vec4<f32> = temporary0_;
    temporary0_.z = -(_e461.yyyy).x;
    let _e468: vec4<f32> = constant_registers[0u];
    let _e470: vec4<f32> = temporary0_;
    temporary3_.x = (_e468.zzzz * _e470.xxxx).x;
    let _e475: vec4<f32> = temporary0_;
    let _e477: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e475.xyw, _e477.xzw);
    let _e481: vec4<f32> = temporary3_;
    let _e483: vec4<f32> = temporary0_;
    temporary0_.y = (_e481.xxxx * _e483.yyyy).x;
    let _e488: vec4<f32> = temporary0_;
    let _e492: vec4<f32> = constant_registers[3u];
    let _e494: vec4<f32> = (_e488.xyyy + _e492.xyyy);
    temporary0_.x = _e494.x;
    temporary0_.y = _e494.y;
    let _e499: vec4<f32> = temporary0_;
    let _e501: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e499.xyw, _e501.xyw);
    let _e505: vec4<f32> = temporary2_;
    let _e509: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e505.xxxx < _e509.wwww)).x;
    let _e515: vec4<f32> = temporary1_;
    let _e517: vec4<f32> = temporary3_;
    temporary1_.x = (_e515.xxxx + _e517.xxxx).x;
    let _e522: vec4<f32> = temporary0_;
    temporary0_.z = -(_e522.yyyy).x;
    let _e529: vec4<f32> = constant_registers[0u];
    let _e531: vec4<f32> = temporary0_;
    temporary3_.x = (_e529.zzzz * _e531.xxxx).x;
    let _e536: vec4<f32> = temporary0_;
    let _e538: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e536.xyw, _e538.xzw);
    let _e542: vec4<f32> = temporary3_;
    let _e544: vec4<f32> = temporary0_;
    temporary0_.y = (_e542.xxxx * _e544.yyyy).x;
    let _e549: vec4<f32> = temporary0_;
    let _e553: vec4<f32> = constant_registers[3u];
    let _e555: vec4<f32> = (_e549.xyyy + _e553.xyyy);
    temporary0_.x = _e555.x;
    temporary0_.y = _e555.y;
    let _e560: vec4<f32> = temporary0_;
    let _e562: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e560.xyw, _e562.xyw);
    let _e566: vec4<f32> = temporary2_;
    let _e570: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e566.xxxx < _e570.wwww)).x;
    let _e576: vec4<f32> = temporary1_;
    let _e578: vec4<f32> = temporary3_;
    temporary1_.x = (_e576.xxxx + _e578.xxxx).x;
    let _e583: vec4<f32> = temporary0_;
    temporary0_.z = -(_e583.yyyy).x;
    let _e590: vec4<f32> = constant_registers[0u];
    let _e592: vec4<f32> = temporary0_;
    temporary3_.x = (_e590.zzzz * _e592.xxxx).x;
    let _e597: vec4<f32> = temporary0_;
    let _e599: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e597.xyw, _e599.xzw);
    let _e603: vec4<f32> = temporary3_;
    let _e605: vec4<f32> = temporary0_;
    temporary0_.y = (_e603.xxxx * _e605.yyyy).x;
    let _e610: vec4<f32> = temporary0_;
    let _e614: vec4<f32> = constant_registers[3u];
    let _e616: vec4<f32> = (_e610.xyyy + _e614.xyyy);
    temporary0_.x = _e616.x;
    temporary0_.y = _e616.y;
    let _e621: vec4<f32> = temporary0_;
    let _e623: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e621.xyw, _e623.xyw);
    let _e627: vec4<f32> = temporary2_;
    let _e631: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e627.xxxx < _e631.wwww)).x;
    let _e637: vec4<f32> = temporary1_;
    let _e639: vec4<f32> = temporary3_;
    temporary1_.x = (_e637.xxxx + _e639.xxxx).x;
    let _e644: vec4<f32> = temporary0_;
    temporary0_.z = -(_e644.yyyy).x;
    let _e651: vec4<f32> = constant_registers[0u];
    let _e653: vec4<f32> = temporary0_;
    temporary3_.x = (_e651.zzzz * _e653.xxxx).x;
    let _e658: vec4<f32> = temporary0_;
    let _e660: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e658.xyw, _e660.xzw);
    let _e664: vec4<f32> = temporary3_;
    let _e666: vec4<f32> = temporary0_;
    temporary0_.y = (_e664.xxxx * _e666.yyyy).x;
    let _e671: vec4<f32> = temporary0_;
    let _e675: vec4<f32> = constant_registers[3u];
    let _e677: vec4<f32> = (_e671.xyyy + _e675.xyyy);
    temporary0_.x = _e677.x;
    temporary0_.y = _e677.y;
    let _e682: vec4<f32> = temporary0_;
    let _e684: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e682.xyw, _e684.xyw);
    let _e688: vec4<f32> = temporary2_;
    let _e692: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e688.xxxx < _e692.wwww)).x;
    let _e698: vec4<f32> = temporary1_;
    let _e700: vec4<f32> = temporary3_;
    temporary1_.x = (_e698.xxxx + _e700.xxxx).x;
    let _e705: vec4<f32> = temporary0_;
    temporary0_.z = -(_e705.yyyy).x;
    let _e712: vec4<f32> = constant_registers[0u];
    let _e714: vec4<f32> = temporary0_;
    temporary3_.x = (_e712.zzzz * _e714.xxxx).x;
    let _e719: vec4<f32> = temporary0_;
    let _e721: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e719.xyw, _e721.xzw);
    let _e725: vec4<f32> = temporary3_;
    let _e727: vec4<f32> = temporary0_;
    temporary0_.y = (_e725.xxxx * _e727.yyyy).x;
    let _e732: vec4<f32> = temporary0_;
    let _e736: vec4<f32> = constant_registers[3u];
    let _e738: vec4<f32> = (_e732.xyyy + _e736.xyyy);
    temporary0_.x = _e738.x;
    temporary0_.y = _e738.y;
    let _e743: vec4<f32> = temporary0_;
    let _e745: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e743.xyw, _e745.xyw);
    let _e749: vec4<f32> = temporary2_;
    let _e753: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e749.xxxx < _e753.wwww)).x;
    let _e759: vec4<f32> = temporary1_;
    let _e761: vec4<f32> = temporary3_;
    temporary1_.x = (_e759.xxxx + _e761.xxxx).x;
    let _e766: vec4<f32> = temporary0_;
    temporary0_.z = -(_e766.yyyy).x;
    let _e773: vec4<f32> = constant_registers[0u];
    let _e775: vec4<f32> = temporary0_;
    temporary3_.x = (_e773.zzzz * _e775.xxxx).x;
    let _e780: vec4<f32> = temporary0_;
    let _e782: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e780.xyw, _e782.xzw);
    let _e786: vec4<f32> = temporary3_;
    let _e788: vec4<f32> = temporary0_;
    temporary0_.y = (_e786.xxxx * _e788.yyyy).x;
    let _e793: vec4<f32> = temporary0_;
    let _e797: vec4<f32> = constant_registers[3u];
    let _e799: vec4<f32> = (_e793.xyyy + _e797.xyyy);
    temporary0_.x = _e799.x;
    temporary0_.y = _e799.y;
    let _e804: vec4<f32> = temporary0_;
    let _e806: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e804.xyw, _e806.xyw);
    let _e810: vec4<f32> = temporary2_;
    let _e814: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e810.xxxx < _e814.wwww)).x;
    let _e820: vec4<f32> = temporary1_;
    let _e822: vec4<f32> = temporary3_;
    temporary1_.x = (_e820.xxxx + _e822.xxxx).x;
    let _e827: vec4<f32> = temporary0_;
    temporary0_.z = -(_e827.yyyy).x;
    let _e834: vec4<f32> = constant_registers[0u];
    let _e836: vec4<f32> = temporary0_;
    temporary3_.x = (_e834.zzzz * _e836.xxxx).x;
    let _e841: vec4<f32> = temporary0_;
    let _e843: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e841.xyw, _e843.xzw);
    let _e847: vec4<f32> = temporary3_;
    let _e849: vec4<f32> = temporary0_;
    temporary0_.y = (_e847.xxxx * _e849.yyyy).x;
    let _e854: vec4<f32> = temporary0_;
    let _e858: vec4<f32> = constant_registers[3u];
    let _e860: vec4<f32> = (_e854.xyyy + _e858.xyyy);
    temporary0_.x = _e860.x;
    temporary0_.y = _e860.y;
    let _e865: vec4<f32> = temporary0_;
    let _e867: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e865.xyw, _e867.xyw);
    let _e871: vec4<f32> = temporary2_;
    let _e875: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e871.xxxx < _e875.wwww)).x;
    let _e881: vec4<f32> = temporary1_;
    let _e883: vec4<f32> = temporary3_;
    temporary1_.x = (_e881.xxxx + _e883.xxxx).x;
    let _e888: vec4<f32> = temporary0_;
    temporary0_.z = -(_e888.yyyy).x;
    let _e895: vec4<f32> = constant_registers[0u];
    let _e897: vec4<f32> = temporary0_;
    temporary3_.x = (_e895.zzzz * _e897.xxxx).x;
    let _e902: vec4<f32> = temporary0_;
    let _e904: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e902.xyw, _e904.xzw);
    let _e908: vec4<f32> = temporary3_;
    let _e910: vec4<f32> = temporary0_;
    temporary0_.y = (_e908.xxxx * _e910.yyyy).x;
    let _e915: vec4<f32> = temporary0_;
    let _e919: vec4<f32> = constant_registers[3u];
    let _e921: vec4<f32> = (_e915.xyyy + _e919.xyyy);
    temporary0_.x = _e921.x;
    temporary0_.y = _e921.y;
    let _e926: vec4<f32> = temporary0_;
    let _e928: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e926.xyw, _e928.xyw);
    let _e932: vec4<f32> = temporary2_;
    let _e936: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e932.xxxx < _e936.wwww)).x;
    let _e942: vec4<f32> = temporary1_;
    let _e944: vec4<f32> = temporary3_;
    temporary1_.x = (_e942.xxxx + _e944.xxxx).x;
    let _e949: vec4<f32> = temporary0_;
    temporary0_.z = -(_e949.yyyy).x;
    let _e956: vec4<f32> = constant_registers[0u];
    let _e958: vec4<f32> = temporary0_;
    temporary3_.x = (_e956.zzzz * _e958.xxxx).x;
    let _e963: vec4<f32> = temporary0_;
    let _e965: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e963.xyw, _e965.xzw);
    let _e969: vec4<f32> = temporary3_;
    let _e971: vec4<f32> = temporary0_;
    temporary0_.y = (_e969.xxxx * _e971.yyyy).x;
    let _e976: vec4<f32> = temporary0_;
    let _e980: vec4<f32> = constant_registers[3u];
    let _e982: vec4<f32> = (_e976.xyyy + _e980.xyyy);
    temporary0_.x = _e982.x;
    temporary0_.y = _e982.y;
    let _e987: vec4<f32> = temporary0_;
    let _e989: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e987.xyw, _e989.xyw);
    let _e993: vec4<f32> = temporary2_;
    let _e997: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e993.xxxx < _e997.wwww)).x;
    let _e1003: vec4<f32> = temporary1_;
    let _e1005: vec4<f32> = temporary3_;
    temporary1_.x = (_e1003.xxxx + _e1005.xxxx).x;
    let _e1010: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1010.yyyy).x;
    let _e1017: vec4<f32> = constant_registers[0u];
    let _e1019: vec4<f32> = temporary0_;
    temporary3_.x = (_e1017.zzzz * _e1019.xxxx).x;
    let _e1024: vec4<f32> = temporary0_;
    let _e1026: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1024.xyw, _e1026.xzw);
    let _e1030: vec4<f32> = temporary3_;
    let _e1032: vec4<f32> = temporary0_;
    temporary0_.y = (_e1030.xxxx * _e1032.yyyy).x;
    let _e1037: vec4<f32> = temporary0_;
    let _e1041: vec4<f32> = constant_registers[3u];
    let _e1043: vec4<f32> = (_e1037.xyyy + _e1041.xyyy);
    temporary0_.x = _e1043.x;
    temporary0_.y = _e1043.y;
    let _e1048: vec4<f32> = temporary0_;
    let _e1050: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1048.xyw, _e1050.xyw);
    let _e1054: vec4<f32> = temporary2_;
    let _e1058: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1054.xxxx < _e1058.wwww)).x;
    let _e1064: vec4<f32> = temporary1_;
    let _e1066: vec4<f32> = temporary3_;
    temporary1_.x = (_e1064.xxxx + _e1066.xxxx).x;
    let _e1071: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1071.yyyy).x;
    let _e1078: vec4<f32> = constant_registers[0u];
    let _e1080: vec4<f32> = temporary0_;
    temporary3_.x = (_e1078.zzzz * _e1080.xxxx).x;
    let _e1085: vec4<f32> = temporary0_;
    let _e1087: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1085.xyw, _e1087.xzw);
    let _e1091: vec4<f32> = temporary3_;
    let _e1093: vec4<f32> = temporary0_;
    temporary0_.y = (_e1091.xxxx * _e1093.yyyy).x;
    let _e1098: vec4<f32> = temporary0_;
    let _e1102: vec4<f32> = constant_registers[3u];
    let _e1104: vec4<f32> = (_e1098.xyyy + _e1102.xyyy);
    temporary0_.x = _e1104.x;
    temporary0_.y = _e1104.y;
    let _e1109: vec4<f32> = temporary0_;
    let _e1111: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1109.xyw, _e1111.xyw);
    let _e1115: vec4<f32> = temporary2_;
    let _e1119: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1115.xxxx < _e1119.wwww)).x;
    let _e1125: vec4<f32> = temporary1_;
    let _e1127: vec4<f32> = temporary3_;
    temporary1_.x = (_e1125.xxxx + _e1127.xxxx).x;
    let _e1132: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1132.yyyy).x;
    let _e1139: vec4<f32> = constant_registers[0u];
    let _e1141: vec4<f32> = temporary0_;
    temporary3_.x = (_e1139.zzzz * _e1141.xxxx).x;
    let _e1146: vec4<f32> = temporary0_;
    let _e1148: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1146.xyw, _e1148.xzw);
    let _e1152: vec4<f32> = temporary3_;
    let _e1154: vec4<f32> = temporary0_;
    temporary0_.y = (_e1152.xxxx * _e1154.yyyy).x;
    let _e1159: vec4<f32> = temporary0_;
    let _e1163: vec4<f32> = constant_registers[3u];
    let _e1165: vec4<f32> = (_e1159.xyyy + _e1163.xyyy);
    temporary0_.x = _e1165.x;
    temporary0_.y = _e1165.y;
    let _e1170: vec4<f32> = temporary0_;
    let _e1172: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1170.xyw, _e1172.xyw);
    let _e1176: vec4<f32> = temporary2_;
    let _e1180: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1176.xxxx < _e1180.wwww)).x;
    let _e1186: vec4<f32> = temporary1_;
    let _e1188: vec4<f32> = temporary3_;
    temporary1_.x = (_e1186.xxxx + _e1188.xxxx).x;
    let _e1193: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1193.yyyy).x;
    let _e1200: vec4<f32> = constant_registers[0u];
    let _e1202: vec4<f32> = temporary0_;
    temporary3_.x = (_e1200.zzzz * _e1202.xxxx).x;
    let _e1207: vec4<f32> = temporary0_;
    let _e1209: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1207.xyw, _e1209.xzw);
    let _e1213: vec4<f32> = temporary3_;
    let _e1215: vec4<f32> = temporary0_;
    temporary0_.y = (_e1213.xxxx * _e1215.yyyy).x;
    let _e1220: vec4<f32> = temporary0_;
    let _e1224: vec4<f32> = constant_registers[3u];
    let _e1226: vec4<f32> = (_e1220.xyyy + _e1224.xyyy);
    temporary0_.x = _e1226.x;
    temporary0_.y = _e1226.y;
    let _e1231: vec4<f32> = temporary0_;
    let _e1233: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1231.xyw, _e1233.xyw);
    let _e1237: vec4<f32> = temporary2_;
    let _e1241: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1237.xxxx < _e1241.wwww)).x;
    let _e1247: vec4<f32> = temporary1_;
    let _e1249: vec4<f32> = temporary3_;
    temporary1_.x = (_e1247.xxxx + _e1249.xxxx).x;
    let _e1254: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1254.yyyy).x;
    let _e1261: vec4<f32> = constant_registers[0u];
    let _e1263: vec4<f32> = temporary0_;
    temporary3_.x = (_e1261.zzzz * _e1263.xxxx).x;
    let _e1268: vec4<f32> = temporary0_;
    let _e1270: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1268.xyw, _e1270.xzw);
    let _e1274: vec4<f32> = temporary3_;
    let _e1276: vec4<f32> = temporary0_;
    temporary0_.y = (_e1274.xxxx * _e1276.yyyy).x;
    let _e1281: vec4<f32> = temporary0_;
    let _e1285: vec4<f32> = constant_registers[3u];
    let _e1287: vec4<f32> = (_e1281.xyyy + _e1285.xyyy);
    temporary0_.x = _e1287.x;
    temporary0_.y = _e1287.y;
    let _e1292: vec4<f32> = temporary0_;
    let _e1294: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1292.xyw, _e1294.xyw);
    let _e1298: vec4<f32> = temporary2_;
    let _e1302: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1298.xxxx < _e1302.wwww)).x;
    let _e1308: vec4<f32> = temporary1_;
    let _e1310: vec4<f32> = temporary3_;
    temporary1_.x = (_e1308.xxxx + _e1310.xxxx).x;
    let _e1315: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1315.yyyy).x;
    let _e1322: vec4<f32> = constant_registers[0u];
    let _e1324: vec4<f32> = temporary0_;
    temporary3_.x = (_e1322.zzzz * _e1324.xxxx).x;
    let _e1329: vec4<f32> = temporary0_;
    let _e1331: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1329.xyw, _e1331.xzw);
    let _e1335: vec4<f32> = temporary3_;
    let _e1337: vec4<f32> = temporary0_;
    temporary0_.y = (_e1335.xxxx * _e1337.yyyy).x;
    let _e1342: vec4<f32> = temporary0_;
    let _e1346: vec4<f32> = constant_registers[3u];
    let _e1348: vec4<f32> = (_e1342.xyyy + _e1346.xyyy);
    temporary0_.x = _e1348.x;
    temporary0_.y = _e1348.y;
    let _e1353: vec4<f32> = temporary0_;
    let _e1355: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1353.xyw, _e1355.xyw);
    let _e1359: vec4<f32> = temporary2_;
    let _e1363: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1359.xxxx < _e1363.wwww)).x;
    let _e1369: vec4<f32> = temporary1_;
    let _e1371: vec4<f32> = temporary3_;
    temporary1_.x = (_e1369.xxxx + _e1371.xxxx).x;
    let _e1376: vec4<f32> = temporary0_;
    temporary0_.z = -(_e1376.yyyy).x;
    let _e1383: vec4<f32> = constant_registers[0u];
    let _e1385: vec4<f32> = temporary0_;
    temporary3_.x = (_e1383.zzzz * _e1385.xxxx).x;
    let _e1390: vec4<f32> = temporary0_;
    let _e1392: vec4<f32> = temporary0_;
    temporary0_.x = dot(_e1390.xyw, _e1392.xzw);
    let _e1396: vec4<f32> = temporary3_;
    let _e1398: vec4<f32> = temporary0_;
    temporary0_.y = (_e1396.xxxx * _e1398.yyyy).x;
    let _e1403: vec4<f32> = temporary0_;
    let _e1407: vec4<f32> = constant_registers[3u];
    let _e1409: vec4<f32> = (_e1403.xyyy + _e1407.xyyy);
    temporary0_.x = _e1409.x;
    temporary0_.y = _e1409.y;
    let _e1414: vec4<f32> = temporary0_;
    let _e1416: vec4<f32> = temporary0_;
    temporary2_.x = dot(_e1414.xyw, _e1416.xyw);
    let _e1420: vec4<f32> = temporary2_;
    let _e1424: vec4<f32> = constant_registers[0u];
    temporary3_.x = vec4<f32>((_e1420.xxxx < _e1424.wwww)).x;
    let _e1430: vec4<f32> = temporary1_;
    let _e1432: vec4<f32> = temporary3_;
    temporary1_.x = (_e1430.xxxx + _e1432.xxxx).x;
    let _e1437: vec4<f32> = temporary1_;
    let _e1441: vec4<f32> = constant_registers[2u];
    temporary2_.x = (_e1437.xxxx / _e1441.yyyy).x;
    let _e1446: vec4<f32> = temporary2_;
    let _e1450: vec4<f32> = constant_registers[1u];
    temporary2_ = (_e1446.xxxx + _e1450);
    let _e1452: vec4<f32> = temporary2_;
    let _e1455: vec4<f32> = constant_registers[1u];
    temporary2_ = (_e1452 + _e1455.wwww);
    let _e1458: vec4<f32> = temporary2_;
    let _e1461: vec4<f32> = constant_registers[0u];
    temporary2_ = (_e1458 / _e1461.zzzz);
    let _e1464: vec4<f32> = temporary2_;
    temporary2_ = fract(_e1464);
    let _e1466: vec4<f32> = temporary2_;
    let _e1469: vec4<f32> = constant_registers[0u];
    temporary2_ = (_e1466 * _e1469.zzzz);
    let _e1472: vec4<f32> = temporary2_;
    let _e1475: vec4<f32> = constant_registers[2u];
    temporary2_ = (_e1472 - _e1475.zzzz);
    let _e1478: vec4<f32> = temporary2_;
    temporary2_ = abs(_e1478);
    let _e1480: vec4<f32> = temporary1_;
    let _e1484: vec4<f32> = constant_registers[2u];
    temporary1_ = vec4<f32>((_e1480.xxxx < _e1484.yyyy));
    let _e1488: vec4<f32> = temporary1_;
    let _e1489: vec4<f32> = temporary2_;
    dest_temp = (_e1488 * _e1489);
    let _e1491: vec4<f32> = dest_temp;
    return FragmentOutput(_e1491);
}