liangsheng8708
/
ruffle
mirror of https://mirror.ghproxy.com/https://github.com/ruffle-rs/ruffle.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ruffle/render/naga-agal/tests/snapshots/wgsl__complex_raytrace-2.snap

2693 lines
125 KiB
Plaintext
Raw Blame History

---
source: render/naga-agal/tests/wgsl.rs
expression: output
---
struct FragmentOutput {
@location(0) member: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> constant_registers: array<vec4<f32>,28u>;
@group(0) @binding(2)
var sampler0_: sampler;
@group(0) @binding(3)
var sampler1_: sampler;
@group(0) @binding(4)
var sampler2_: sampler;
@group(0) @binding(5)
var sampler3_: sampler;
@group(0) @binding(6)
var texture0_: texture_cube<f32>;
@fragment
fn main(@location(0) param: vec4<f32>) -> FragmentOutput {
var dest_temp: vec4<f32>;
var temporary0_: vec4<f32>;
var temporary1_: vec4<f32>;
var temporary2_: vec4<f32>;
var temporary4_: vec4<f32>;
var temporary3_: vec4<f32>;
var temporary5_: vec4<f32>;
var temporary6_: vec4<f32>;
var temporary7_: vec4<f32>;
var temporary8_: vec4<f32>;
var temporary10_: vec4<f32>;
var temporary9_: vec4<f32>;
var temporary11_: vec4<f32>;
var temporary12_: vec4<f32>;
var temporary13_: vec4<f32>;
var temporary14_: vec4<f32>;
var temporary15_: vec4<f32>;
var temporary16_: vec4<f32>;
var temporary20_: vec4<f32>;
var temporary18_: vec4<f32>;
var temporary17_: vec4<f32>;
var temporary19_: vec4<f32>;
let _e8: vec4<f32> = constant_registers[16u];
temporary0_ = _e8.xxxy;
let _e15: vec4<f32> = constant_registers[3u];
temporary1_.x = (param.xxxx * _e15.xxxx).x;
temporary1_.y = param.yyyy.x;
let _e26: vec4<f32> = constant_registers[1u];
let _e27: vec4<f32> = _e26.xxxx;
temporary1_.z = _e27.z;
temporary1_.w = _e27.w;
let _e32: vec4<f32> = temporary1_;
let _e36: vec4<f32> = constant_registers[16u];
let _e38: vec4<f32> = (_e32.zzzw * _e36.zzzz);
temporary1_.z = _e38.z;
temporary1_.w = _e38.w;
let _e43: vec4<f32> = temporary1_;
temporary1_.z = cos(_e43.zzzz).x;
let _e48: vec4<f32> = temporary1_;
let _e52: vec4<f32> = constant_registers[16u];
temporary2_.x = (_e48.zzzz * _e52.wwww).x;
let _e60: vec4<f32> = constant_registers[1u];
temporary1_.z = _e60.yyyy.x;
let _e64: vec4<f32> = temporary1_;
let _e68: vec4<f32> = constant_registers[16u];
temporary1_.z = (_e64.zzzz + _e68.yyyy).x;
let _e73: vec4<f32> = temporary1_;
let _e77: vec4<f32> = constant_registers[17u];
temporary1_.z = (_e73.zzzz * _e77.xxxx).x;
let _e82: vec4<f32> = temporary1_;
let _e86: vec4<f32> = constant_registers[17u];
temporary1_.z = max(_e82.zzzz, _e86.yyyy).x;
let _e91: vec4<f32> = temporary1_;
temporary1_.w = sin(_e91.wwww).x;
let _e96: vec4<f32> = temporary1_;
let _e100: vec4<f32> = constant_registers[16u];
temporary2_.z = (_e96.wwww * _e100.wwww).x;
let _e105: vec4<f32> = temporary1_;
temporary2_.y = _e105.zzzz.x;
let _e111: vec4<f32> = constant_registers[16u];
let _e112: vec4<f32> = _e111.xxxx;
temporary4_.x = _e112.x;
temporary4_.z = _e112.z;
let _e120: vec4<f32> = constant_registers[17u];
temporary4_.y = _e120.zzzz.x;
let _e126: vec4<f32> = constant_registers[16u];
temporary1_.w = _e126.yyyy.x;
let _e130: vec4<f32> = temporary4_;
let _e132: vec4<f32> = temporary2_;
let _e134: vec4<f32> = (_e130.xyzz - _e132.xyzz);
temporary3_.x = _e134.x;
temporary3_.y = _e134.y;
temporary3_.z = _e134.z;
let _e142: vec4<f32> = temporary3_;
let _e144: vec3<f32> = normalize(_e142.xyz);
temporary3_.x = _e144.x;
temporary3_.y = _e144.y;
temporary3_.z = _e144.z;
let _e153: vec4<f32> = constant_registers[16u];
let _e155: vec4<f32> = temporary3_;
let _e157: vec3<f32> = cross(_e153.xyx, _e155.xyz);
let _e162: vec4<f32> = vec4<f32>(_e157.x, _e157.y, _e157.z, 1.0);
temporary5_.x = _e162.x;
temporary5_.y = _e162.y;
temporary5_.z = _e162.z;
let _e170: vec4<f32> = temporary5_;
let _e172: vec3<f32> = normalize(_e170.xyz);
temporary6_.x = _e172.x;
temporary6_.y = _e172.y;
temporary6_.z = _e172.z;
let _e180: vec4<f32> = temporary3_;
let _e182: vec4<f32> = temporary6_;
let _e184: vec3<f32> = cross(_e180.xyz, _e182.xyz);
let _e189: vec4<f32> = vec4<f32>(_e184.x, _e184.y, _e184.z, 1.0);
temporary5_.x = _e189.x;
temporary5_.y = _e189.y;
temporary5_.z = _e189.z;
let _e196: vec4<f32> = temporary3_;
let _e198: vec4<f32> = temporary1_;
let _e200: vec4<f32> = (_e196.xyzz * _e198.wwww);
temporary3_.x = _e200.x;
temporary3_.y = _e200.y;
temporary3_.z = _e200.z;
let _e207: vec4<f32> = temporary6_;
let _e209: vec4<f32> = temporary1_;
let _e211: vec4<f32> = (_e207.xyzz * _e209.xxxx);
temporary6_.x = _e211.x;
temporary6_.y = _e211.y;
temporary6_.z = _e211.z;
let _e218: vec4<f32> = temporary3_;
let _e220: vec4<f32> = temporary6_;
let _e222: vec4<f32> = (_e218.xyzz + _e220.xyzz);
temporary7_.x = _e222.x;
temporary7_.y = _e222.y;
temporary7_.z = _e222.z;
let _e230: vec4<f32> = temporary5_;
let _e232: vec4<f32> = temporary1_;
let _e234: vec4<f32> = (_e230.xyzz * _e232.yyyy);
temporary5_.x = _e234.x;
temporary5_.y = _e234.y;
temporary5_.z = _e234.z;
let _e241: vec4<f32> = temporary7_;
let _e243: vec4<f32> = temporary5_;
let _e245: vec4<f32> = (_e241.xyzz + _e243.xyzz);
temporary5_.x = _e245.x;
temporary5_.y = _e245.y;
temporary5_.z = _e245.z;
let _e252: vec4<f32> = temporary5_;
let _e254: vec3<f32> = normalize(_e252.xyz);
temporary8_.x = _e254.x;
temporary8_.y = _e254.y;
temporary8_.z = _e254.z;
let _e262: vec4<f32> = temporary8_;
let _e263: vec4<f32> = _e262.xyzz;
temporary10_.x = _e263.x;
temporary10_.y = _e263.y;
temporary10_.z = _e263.z;
let _e271: vec4<f32> = temporary10_;
let _e272: vec4<f32> = _e271.xyzz;
temporary9_.x = _e272.x;
temporary9_.y = _e272.y;
temporary9_.z = _e272.z;
let _e282: vec4<f32> = constant_registers[16u];
let _e283: vec4<f32> = _e282.yxxx;
temporary11_.x = _e283.x;
temporary11_.y = _e283.y;
temporary11_.z = _e283.z;
let _e291: vec4<f32> = temporary11_;
let _e295: vec4<f32> = constant_registers[16u];
if all((_e291.xxxx != _e295.xxxx)) {
let _e301: vec4<f32> = constant_registers[16u];
temporary1_.z = _e301.xxxx.x;
let _e307: vec4<f32> = constant_registers[17u];
temporary4_.z = _e307.wwww.x;
let _e313: vec4<f32> = constant_registers[16u];
let _e314: vec4<f32> = _e313.xyxx;
temporary3_.x = _e314.x;
temporary3_.y = _e314.y;
temporary3_.z = _e314.z;
let _e321: vec4<f32> = temporary3_;
let _e322: vec4<f32> = _e321.xyzz;
temporary12_.x = _e322.x;
temporary12_.y = _e322.y;
temporary12_.z = _e322.z;
let _e332: vec4<f32> = constant_registers[17u];
temporary1_.x = _e332.wwww.x;
let _e336: vec4<f32> = temporary2_;
let _e340: vec4<f32> = constant_registers[16u];
let _e342: vec4<f32> = (_e336.xyzz - _e340.xxxx);
temporary13_.x = _e342.x;
temporary13_.y = _e342.y;
temporary13_.z = _e342.z;
let _e350: vec4<f32> = temporary13_;
let _e352: vec4<f32> = temporary12_;
temporary1_.y = dot(_e350.xyz, _e352.xyz);
let _e356: vec4<f32> = temporary1_;
temporary1_.y = -(_e356.yyyy).x;
let _e361: vec4<f32> = temporary9_;
let _e363: vec4<f32> = temporary12_;
temporary12_.x = dot(_e361.xyz, _e363.xyz);
let _e367: vec4<f32> = temporary1_;
let _e369: vec4<f32> = temporary12_;
temporary12_.y = (_e367.yyyy / _e369.xxxx).x;
let _e374: vec4<f32> = temporary12_;
temporary1_.y = _e374.yyyy.x;
let _e380: vec4<f32> = constant_registers[16u];
let _e382: vec4<f32> = temporary1_;
temporary1_.w = vec4<f32>((_e380.xxxx < _e382.yyyy)).x;
let _e388: vec4<f32> = temporary1_;
let _e392: vec4<f32> = constant_registers[16u];
if all((_e388.wwww != _e392.xxxx)) {
let _e396: vec4<f32> = temporary1_;
temporary1_.x = _e396.yyyy.x;
}
let _e400: vec4<f32> = temporary1_;
temporary4_.y = _e400.xxxx.x;
let _e404: vec4<f32> = temporary4_;
let _e406: vec4<f32> = temporary4_;
temporary1_.x = vec4<f32>((_e404.yyyy < _e406.zzzz)).x;
let _e412: vec4<f32> = temporary1_;
let _e416: vec4<f32> = constant_registers[16u];
if all((_e412.xxxx != _e416.xxxx)) {
let _e420: vec4<f32> = temporary4_;
temporary4_.z = _e420.yyyy.x;
let _e424: vec4<f32> = temporary3_;
let _e425: vec4<f32> = _e424.xyzz;
temporary6_.x = _e425.x;
temporary6_.y = _e425.y;
temporary6_.z = _e425.z;
let _e434: vec4<f32> = constant_registers[16u];
temporary1_.z = _e434.yyyy.x;
}
let _e438: vec4<f32> = temporary2_;
let _e439: vec4<f32> = _e438.xyzz;
temporary5_.x = _e439.x;
temporary5_.y = _e439.y;
temporary5_.z = _e439.z;
let _e446: vec4<f32> = temporary9_;
let _e447: vec4<f32> = _e446.xyzz;
temporary10_.x = _e447.x;
temporary10_.y = _e447.y;
temporary10_.z = _e447.z;
let _e456: vec4<f32> = constant_registers[4u];
let _e457: vec4<f32> = _e456.xyzz;
temporary8_.x = _e457.x;
temporary8_.y = _e457.y;
temporary8_.z = _e457.z;
let _e466: vec4<f32> = constant_registers[6u];
temporary14_.x = _e466.xxxx.x;
let _e471: vec4<f32> = temporary3_;
let _e472: vec4<f32> = _e471.xyzz;
temporary15_.x = _e472.x;
temporary15_.y = _e472.y;
temporary15_.z = _e472.z;
let _e482: vec4<f32> = constant_registers[17u];
temporary1_.x = _e482.wwww.x;
let _e486: vec4<f32> = temporary5_;
let _e488: vec4<f32> = temporary8_;
let _e490: vec4<f32> = (_e486.xyzz - _e488.xyzz);
temporary16_.x = _e490.x;
temporary16_.y = _e490.y;
temporary16_.z = _e490.z;
let _e498: vec4<f32> = temporary16_;
let _e500: vec4<f32> = temporary10_;
temporary14_.z = dot(_e498.xyz, _e500.xyz);
let _e504: vec4<f32> = temporary14_;
let _e506: vec4<f32> = temporary14_;
let _e508: vec4<f32> = (_e504.zzzx * _e506.zzzx);
temporary4_.x = _e508.x;
temporary4_.w = _e508.w;
let _e513: vec4<f32> = temporary16_;
let _e515: vec4<f32> = temporary16_;
temporary1_.y = dot(_e513.xyz, _e515.xyz);
let _e519: vec4<f32> = temporary4_;
let _e521: vec4<f32> = temporary1_;
temporary1_.w = (_e519.xxxx - _e521.yyyy).x;
let _e526: vec4<f32> = temporary1_;
let _e528: vec4<f32> = temporary4_;
temporary13_.x = (_e526.wwww + _e528.wwww).x;
let _e533: vec4<f32> = temporary13_;
temporary1_.w = _e533.xxxx.x;
let _e539: vec4<f32> = constant_registers[16u];
let _e541: vec4<f32> = temporary1_;
temporary2_.w = vec4<f32>((_e539.xxxx < _e541.wwww)).x;
let _e547: vec4<f32> = temporary2_;
let _e551: vec4<f32> = constant_registers[16u];
if all((_e547.wwww != _e551.xxxx)) {
let _e555: vec4<f32> = temporary1_;
temporary1_.w = sqrt(_e555.wwww).x;
let _e560: vec4<f32> = temporary14_;
temporary1_.y = -(_e560.zzzz).x;
let _e565: vec4<f32> = temporary1_;
let _e567: vec4<f32> = temporary1_;
temporary2_.w = (_e565.yyyy - _e567.wwww).x;
let _e574: vec4<f32> = constant_registers[16u];
let _e576: vec4<f32> = temporary2_;
temporary1_.y = vec4<f32>((_e574.xxxx < _e576.wwww)).x;
let _e582: vec4<f32> = temporary1_;
let _e586: vec4<f32> = constant_registers[16u];
if all((_e582.yyyy != _e586.xxxx)) {
let _e590: vec4<f32> = temporary2_;
temporary1_.x = _e590.wwww.x;
let _e594: vec4<f32> = temporary10_;
let _e596: vec4<f32> = temporary2_;
let _e598: vec4<f32> = (_e594.xyzz * _e596.wwww);
temporary13_.x = _e598.x;
temporary13_.y = _e598.y;
temporary13_.z = _e598.z;
let _e605: vec4<f32> = temporary5_;
let _e607: vec4<f32> = temporary13_;
let _e609: vec4<f32> = (_e605.xyzz + _e607.xyzz);
temporary12_.x = _e609.x;
temporary12_.y = _e609.y;
temporary12_.z = _e609.z;
let _e616: vec4<f32> = temporary12_;
let _e618: vec4<f32> = temporary8_;
let _e620: vec4<f32> = (_e616.xyzz - _e618.xyzz);
temporary14_.x = _e620.x;
temporary14_.y = _e620.y;
temporary14_.z = _e620.z;
let _e627: vec4<f32> = temporary14_;
let _e629: vec3<f32> = normalize(_e627.xyz);
temporary16_.x = _e629.x;
temporary16_.y = _e629.y;
temporary16_.z = _e629.z;
let _e636: vec4<f32> = temporary16_;
let _e637: vec4<f32> = _e636.xyzz;
temporary20_.x = _e637.x;
temporary20_.y = _e637.y;
temporary20_.z = _e637.z;
let _e645: vec4<f32> = temporary20_;
let _e646: vec4<f32> = _e645.xyzz;
temporary15_.x = _e646.x;
temporary15_.y = _e646.y;
temporary15_.z = _e646.z;
}
}
let _e653: vec4<f32> = temporary1_;
temporary4_.y = _e653.xxxx.x;
let _e657: vec4<f32> = temporary15_;
let _e658: vec4<f32> = _e657.xyzz;
temporary3_.x = _e658.x;
temporary3_.y = _e658.y;
temporary3_.z = _e658.z;
let _e665: vec4<f32> = temporary4_;
let _e667: vec4<f32> = temporary4_;
temporary1_.x = vec4<f32>((_e665.yyyy < _e667.zzzz)).x;
let _e673: vec4<f32> = temporary1_;
let _e677: vec4<f32> = constant_registers[16u];
if all((_e673.xxxx != _e677.xxxx)) {
let _e681: vec4<f32> = temporary4_;
temporary4_.z = _e681.yyyy.x;
let _e685: vec4<f32> = temporary3_;
let _e686: vec4<f32> = _e685.xyzz;
temporary6_.x = _e686.x;
temporary6_.y = _e686.y;
temporary6_.z = _e686.z;
let _e695: vec4<f32> = constant_registers[5u];
let _e696: vec4<f32> = _e695.xyzz;
temporary7_.x = _e696.x;
temporary7_.y = _e696.y;
temporary7_.z = _e696.z;
let _e705: vec4<f32> = constant_registers[18u];
temporary1_.z = _e705.xxxx.x;
}
let _e709: vec4<f32> = temporary2_;
let _e710: vec4<f32> = _e709.xyzz;
temporary5_.x = _e710.x;
temporary5_.y = _e710.y;
temporary5_.z = _e710.z;
let _e717: vec4<f32> = temporary9_;
let _e718: vec4<f32> = _e717.xyzz;
temporary10_.x = _e718.x;
temporary10_.y = _e718.y;
temporary10_.z = _e718.z;
let _e727: vec4<f32> = constant_registers[7u];
let _e728: vec4<f32> = _e727.xyzz;
temporary8_.x = _e728.x;
temporary8_.y = _e728.y;
temporary8_.z = _e728.z;
let _e737: vec4<f32> = constant_registers[9u];
temporary15_.x = _e737.xxxx.x;
let _e741: vec4<f32> = temporary3_;
let _e742: vec4<f32> = _e741.xyzz;
temporary18_.x = _e742.x;
temporary18_.y = _e742.y;
temporary18_.z = _e742.z;
let _e752: vec4<f32> = constant_registers[17u];
temporary1_.x = _e752.wwww.x;
let _e756: vec4<f32> = temporary5_;
let _e758: vec4<f32> = temporary8_;
let _e760: vec4<f32> = (_e756.xyzz - _e758.xyzz);
temporary17_.x = _e760.x;
temporary17_.y = _e760.y;
temporary17_.z = _e760.z;
let _e768: vec4<f32> = temporary17_;
let _e770: vec4<f32> = temporary10_;
temporary15_.z = dot(_e768.xyz, _e770.xyz);
let _e774: vec4<f32> = temporary15_;
let _e776: vec4<f32> = temporary15_;
let _e778: vec4<f32> = (_e774.zzzx * _e776.zzzx);
temporary4_.x = _e778.x;
temporary4_.w = _e778.w;
let _e783: vec4<f32> = temporary17_;
let _e785: vec4<f32> = temporary17_;
temporary1_.y = dot(_e783.xyz, _e785.xyz);
let _e789: vec4<f32> = temporary4_;
let _e791: vec4<f32> = temporary1_;
temporary1_.w = (_e789.xxxx - _e791.yyyy).x;
let _e796: vec4<f32> = temporary1_;
let _e798: vec4<f32> = temporary4_;
temporary13_.x = (_e796.wwww + _e798.wwww).x;
let _e803: vec4<f32> = temporary13_;
temporary1_.w = _e803.xxxx.x;
let _e809: vec4<f32> = constant_registers[16u];
let _e811: vec4<f32> = temporary1_;
temporary2_.w = vec4<f32>((_e809.xxxx < _e811.wwww)).x;
let _e817: vec4<f32> = temporary2_;
let _e821: vec4<f32> = constant_registers[16u];
if all((_e817.wwww != _e821.xxxx)) {
let _e825: vec4<f32> = temporary1_;
temporary1_.w = sqrt(_e825.wwww).x;
let _e830: vec4<f32> = temporary15_;
temporary1_.y = -(_e830.zzzz).x;
let _e835: vec4<f32> = temporary1_;
let _e837: vec4<f32> = temporary1_;
temporary2_.w = (_e835.yyyy - _e837.wwww).x;
let _e844: vec4<f32> = constant_registers[16u];
let _e846: vec4<f32> = temporary2_;
temporary1_.y = vec4<f32>((_e844.xxxx < _e846.wwww)).x;
let _e852: vec4<f32> = temporary1_;
let _e856: vec4<f32> = constant_registers[16u];
if all((_e852.yyyy != _e856.xxxx)) {
let _e860: vec4<f32> = temporary2_;
temporary1_.x = _e860.wwww.x;
let _e864: vec4<f32> = temporary10_;
let _e866: vec4<f32> = temporary2_;
let _e868: vec4<f32> = (_e864.xyzz * _e866.wwww);
temporary13_.x = _e868.x;
temporary13_.y = _e868.y;
temporary13_.z = _e868.z;
let _e875: vec4<f32> = temporary5_;
let _e877: vec4<f32> = temporary13_;
let _e879: vec4<f32> = (_e875.xyzz + _e877.xyzz);
temporary12_.x = _e879.x;
temporary12_.y = _e879.y;
temporary12_.z = _e879.z;
let _e886: vec4<f32> = temporary12_;
let _e888: vec4<f32> = temporary8_;
let _e890: vec4<f32> = (_e886.xyzz - _e888.xyzz);
temporary14_.x = _e890.x;
temporary14_.y = _e890.y;
temporary14_.z = _e890.z;
let _e897: vec4<f32> = temporary14_;
let _e899: vec3<f32> = normalize(_e897.xyz);
temporary16_.x = _e899.x;
temporary16_.y = _e899.y;
temporary16_.z = _e899.z;
let _e906: vec4<f32> = temporary16_;
let _e907: vec4<f32> = _e906.xyzz;
temporary20_.x = _e907.x;
temporary20_.y = _e907.y;
temporary20_.z = _e907.z;
let _e914: vec4<f32> = temporary20_;
let _e915: vec4<f32> = _e914.xyzz;
temporary18_.x = _e915.x;
temporary18_.y = _e915.y;
temporary18_.z = _e915.z;
}
}
let _e922: vec4<f32> = temporary1_;
temporary4_.y = _e922.xxxx.x;
let _e926: vec4<f32> = temporary18_;
let _e927: vec4<f32> = _e926.xyzz;
temporary3_.x = _e927.x;
temporary3_.y = _e927.y;
temporary3_.z = _e927.z;
let _e934: vec4<f32> = temporary4_;
let _e936: vec4<f32> = temporary4_;
temporary1_.x = vec4<f32>((_e934.yyyy < _e936.zzzz)).x;
let _e942: vec4<f32> = temporary1_;
let _e946: vec4<f32> = constant_registers[16u];
if all((_e942.xxxx != _e946.xxxx)) {
let _e950: vec4<f32> = temporary4_;
temporary4_.z = _e950.yyyy.x;
let _e954: vec4<f32> = temporary3_;
let _e955: vec4<f32> = _e954.xyzz;
temporary6_.x = _e955.x;
temporary6_.y = _e955.y;
temporary6_.z = _e955.z;
let _e964: vec4<f32> = constant_registers[8u];
let _e965: vec4<f32> = _e964.xyzz;
temporary7_.x = _e965.x;
temporary7_.y = _e965.y;
temporary7_.z = _e965.z;
let _e974: vec4<f32> = constant_registers[18u];
temporary1_.z = _e974.xxxx.x;
}
let _e978: vec4<f32> = temporary2_;
let _e979: vec4<f32> = _e978.xyzz;
temporary5_.x = _e979.x;
temporary5_.y = _e979.y;
temporary5_.z = _e979.z;
let _e986: vec4<f32> = temporary9_;
let _e987: vec4<f32> = _e986.xyzz;
temporary10_.x = _e987.x;
temporary10_.y = _e987.y;
temporary10_.z = _e987.z;
let _e996: vec4<f32> = constant_registers[10u];
let _e997: vec4<f32> = _e996.xyzz;
temporary8_.x = _e997.x;
temporary8_.y = _e997.y;
temporary8_.z = _e997.z;
let _e1006: vec4<f32> = constant_registers[12u];
temporary15_.x = _e1006.xxxx.x;
let _e1010: vec4<f32> = temporary3_;
let _e1011: vec4<f32> = _e1010.xyzz;
temporary17_.x = _e1011.x;
temporary17_.y = _e1011.y;
temporary17_.z = _e1011.z;
let _e1020: vec4<f32> = constant_registers[17u];
temporary15_.y = _e1020.wwww.x;
let _e1024: vec4<f32> = temporary5_;
let _e1026: vec4<f32> = temporary8_;
let _e1028: vec4<f32> = (_e1024.xyzz - _e1026.xyzz);
temporary18_.x = _e1028.x;
temporary18_.y = _e1028.y;
temporary18_.z = _e1028.z;
let _e1035: vec4<f32> = temporary18_;
let _e1037: vec4<f32> = temporary10_;
temporary15_.z = dot(_e1035.xyz, _e1037.xyz);
let _e1041: vec4<f32> = temporary15_;
let _e1043: vec4<f32> = temporary15_;
let _e1045: vec4<f32> = (_e1041.zzzx * _e1043.zzzx);
temporary1_.x = _e1045.x;
temporary1_.w = _e1045.w;
let _e1050: vec4<f32> = temporary18_;
let _e1052: vec4<f32> = temporary18_;
temporary19_.y = dot(_e1050.xyz, _e1052.xyz);
let _e1057: vec4<f32> = temporary1_;
let _e1059: vec4<f32> = temporary19_;
temporary19_.z = (_e1057.xxxx - _e1059.yyyy).x;
let _e1064: vec4<f32> = temporary19_;
let _e1066: vec4<f32> = temporary1_;
temporary13_.x = (_e1064.zzzz + _e1066.wwww).x;
let _e1071: vec4<f32> = temporary13_;
temporary1_.x = _e1071.xxxx.x;
let _e1077: vec4<f32> = constant_registers[16u];
let _e1079: vec4<f32> = temporary1_;
temporary19_.x = vec4<f32>((_e1077.xxxx < _e1079.xxxx)).x;
let _e1085: vec4<f32> = temporary19_;
let _e1089: vec4<f32> = constant_registers[16u];
if all((_e1085.xxxx != _e1089.xxxx)) {
let _e1093: vec4<f32> = temporary1_;
temporary1_.x = sqrt(_e1093.xxxx).x;
let _e1098: vec4<f32> = temporary15_;
temporary19_.y = -(_e1098.zzzz).x;
let _e1103: vec4<f32> = temporary19_;
let _e1105: vec4<f32> = temporary1_;
temporary19_.z = (_e1103.yyyy - _e1105.xxxx).x;
let _e1110: vec4<f32> = temporary19_;
temporary19_.x = _e1110.zzzz.x;
let _e1116: vec4<f32> = constant_registers[16u];
let _e1118: vec4<f32> = temporary19_;
temporary19_.y = vec4<f32>((_e1116.xxxx < _e1118.xxxx)).x;
let _e1124: vec4<f32> = temporary19_;
let _e1128: vec4<f32> = constant_registers[16u];
if all((_e1124.yyyy != _e1128.xxxx)) {
let _e1132: vec4<f32> = temporary19_;
temporary15_.y = _e1132.xxxx.x;
let _e1136: vec4<f32> = temporary10_;
let _e1138: vec4<f32> = temporary19_;
let _e1140: vec4<f32> = (_e1136.xyzz * _e1138.xxxx);
temporary13_.x = _e1140.x;
temporary13_.y = _e1140.y;
temporary13_.z = _e1140.z;
let _e1147: vec4<f32> = temporary5_;
let _e1149: vec4<f32> = temporary13_;
let _e1151: vec4<f32> = (_e1147.xyzz + _e1149.xyzz);
temporary12_.x = _e1151.x;
temporary12_.y = _e1151.y;
temporary12_.z = _e1151.z;
let _e1158: vec4<f32> = temporary12_;
let _e1160: vec4<f32> = temporary8_;
let _e1162: vec4<f32> = (_e1158.xyzz - _e1160.xyzz);
temporary14_.x = _e1162.x;
temporary14_.y = _e1162.y;
temporary14_.z = _e1162.z;
let _e1169: vec4<f32> = temporary14_;
let _e1171: vec3<f32> = normalize(_e1169.xyz);
temporary16_.x = _e1171.x;
temporary16_.y = _e1171.y;
temporary16_.z = _e1171.z;
let _e1178: vec4<f32> = temporary16_;
let _e1179: vec4<f32> = _e1178.xyzz;
temporary20_.x = _e1179.x;
temporary20_.y = _e1179.y;
temporary20_.z = _e1179.z;
let _e1186: vec4<f32> = temporary20_;
let _e1187: vec4<f32> = _e1186.xyzz;
temporary17_.x = _e1187.x;
temporary17_.y = _e1187.y;
temporary17_.z = _e1187.z;
}
}
let _e1194: vec4<f32> = temporary15_;
temporary4_.y = _e1194.yyyy.x;
let _e1198: vec4<f32> = temporary17_;
let _e1199: vec4<f32> = _e1198.xyzz;
temporary3_.x = _e1199.x;
temporary3_.y = _e1199.y;
temporary3_.z = _e1199.z;
let _e1206: vec4<f32> = temporary4_;
let _e1208: vec4<f32> = temporary4_;
temporary1_.y = vec4<f32>((_e1206.yyyy < _e1208.zzzz)).x;
let _e1214: vec4<f32> = temporary1_;
let _e1218: vec4<f32> = constant_registers[16u];
if all((_e1214.yyyy != _e1218.xxxx)) {
let _e1222: vec4<f32> = temporary4_;
temporary4_.z = _e1222.yyyy.x;
let _e1226: vec4<f32> = temporary3_;
let _e1227: vec4<f32> = _e1226.xyzz;
temporary6_.x = _e1227.x;
temporary6_.y = _e1227.y;
temporary6_.z = _e1227.z;
let _e1236: vec4<f32> = constant_registers[11u];
let _e1237: vec4<f32> = _e1236.xyzz;
temporary7_.x = _e1237.x;
temporary7_.y = _e1237.y;
temporary7_.z = _e1237.z;
let _e1246: vec4<f32> = constant_registers[18u];
temporary1_.z = _e1246.xxxx.x;
}
let _e1250: vec4<f32> = temporary11_;
let _e1254: vec4<f32> = constant_registers[16u];
temporary11_.y = (_e1250.yyyy + _e1254.yyyy).x;
let _e1259: vec4<f32> = temporary1_;
let _e1263: vec4<f32> = constant_registers[16u];
temporary1_.y = vec4<f32>((_e1259.zzzz == _e1263.xxxx)).x;
let _e1269: vec4<f32> = temporary1_;
let _e1273: vec4<f32> = constant_registers[16u];
if all((_e1269.yyyy != _e1273.xxxx)) {
let _e1279: vec4<f32> = constant_registers[16u];
let _e1280: vec4<f32> = _e1279.xyyy;
temporary11_.x = _e1280.x;
temporary11_.z = _e1280.z;
} else {
let _e1285: vec4<f32> = temporary9_;
let _e1287: vec4<f32> = temporary4_;
let _e1289: vec4<f32> = (_e1285.xyzz * _e1287.zzzz);
temporary5_.x = _e1289.x;
temporary5_.y = _e1289.y;
temporary5_.z = _e1289.z;
let _e1296: vec4<f32> = temporary2_;
let _e1298: vec4<f32> = temporary5_;
let _e1300: vec4<f32> = (_e1296.xyzz + _e1298.xyzz);
temporary2_.x = _e1300.x;
temporary2_.y = _e1300.y;
temporary2_.z = _e1300.z;
let _e1307: vec4<f32> = temporary9_;
let _e1309: vec4<f32> = temporary6_;
temporary1_.y = dot(_e1307.xyz, _e1309.xyz);
let _e1313: vec4<f32> = temporary1_;
let _e1317: vec4<f32> = constant_registers[18u];
temporary5_.x = (_e1313.yyyy * _e1317.xxxx).x;
let _e1322: vec4<f32> = temporary5_;
let _e1324: vec4<f32> = temporary6_;
let _e1326: vec4<f32> = (_e1322.xxxx * _e1324.xyzz);
temporary10_.x = _e1326.x;
temporary10_.y = _e1326.y;
temporary10_.z = _e1326.z;
let _e1333: vec4<f32> = temporary9_;
let _e1335: vec4<f32> = temporary10_;
let _e1337: vec4<f32> = (_e1333.xyzz - _e1335.xyzz);
temporary9_.x = _e1337.x;
temporary9_.y = _e1337.y;
temporary9_.z = _e1337.z;
let _e1344: vec4<f32> = temporary9_;
let _e1348: vec4<f32> = constant_registers[18u];
let _e1350: vec4<f32> = (_e1344.xyzz * _e1348.yyyy);
temporary5_.x = _e1350.x;
temporary5_.y = _e1350.y;
temporary5_.z = _e1350.z;
let _e1357: vec4<f32> = temporary2_;
let _e1359: vec4<f32> = temporary5_;
let _e1361: vec4<f32> = (_e1357.xyzz + _e1359.xyzz);
temporary2_.x = _e1361.x;
temporary2_.y = _e1361.y;
temporary2_.z = _e1361.z;
let _e1370: vec4<f32> = constant_registers[15u];
let _e1372: vec4<f32> = temporary2_;
let _e1374: vec4<f32> = (_e1370.xyzz - _e1372.xyzz);
temporary5_.x = _e1374.x;
temporary5_.y = _e1374.y;
temporary5_.z = _e1374.z;
let _e1381: vec4<f32> = temporary5_;
let _e1383: vec3<f32> = normalize(_e1381.xyz);
temporary10_.x = _e1383.x;
temporary10_.y = _e1383.y;
temporary10_.z = _e1383.z;
let _e1390: vec4<f32> = temporary5_;
let _e1392: vec4<f32> = temporary5_;
temporary8_.x = dot(_e1390.xyz, _e1392.xyz);
let _e1396: vec4<f32> = temporary8_;
temporary1_.y = sqrt(_e1396.xxxx).x;
let _e1401: vec4<f32> = temporary6_;
let _e1403: vec4<f32> = temporary10_;
temporary8_.y = dot(_e1401.xyz, _e1403.xyz);
let _e1407: vec4<f32> = temporary8_;
temporary8_.z = saturate(_e1407.yyyy).x;
let _e1412: vec4<f32> = temporary1_;
let _e1414: vec4<f32> = temporary1_;
temporary2_.w = (_e1412.yyyy * _e1414.yyyy).x;
let _e1419: vec4<f32> = temporary2_;
let _e1423: vec4<f32> = constant_registers[18u];
temporary15_.x = (_e1419.wwww * _e1423.zzzz).x;
let _e1430: vec4<f32> = constant_registers[18u];
let _e1432: vec4<f32> = temporary15_;
temporary15_.y = (_e1430.wwww + _e1432.xxxx).x;
let _e1437: vec4<f32> = temporary8_;
let _e1439: vec4<f32> = temporary15_;
temporary8_.x = (_e1437.zzzz / _e1439.yyyy).x;
let _e1446: vec4<f32> = constant_registers[6u];
temporary8_.z = _e1446.xxxx.x;
let _e1452: vec4<f32> = constant_registers[17u];
temporary2_.w = _e1452.wwww.x;
let _e1456: vec4<f32> = temporary2_;
let _e1460: vec4<f32> = constant_registers[4u];
let _e1462: vec4<f32> = (_e1456.xyzz - _e1460.xyzz);
temporary19_.x = _e1462.x;
temporary19_.y = _e1462.y;
temporary19_.z = _e1462.z;
let _e1469: vec4<f32> = temporary19_;
let _e1471: vec4<f32> = temporary10_;
temporary13_.x = dot(_e1469.xyz, _e1471.xyz);
let _e1475: vec4<f32> = temporary13_;
let _e1477: vec4<f32> = temporary13_;
temporary13_.z = (_e1475.xxxx * _e1477.xxxx).x;
let _e1482: vec4<f32> = temporary19_;
let _e1484: vec4<f32> = temporary19_;
temporary3_.w = dot(_e1482.xyz, _e1484.xyz);
let _e1488: vec4<f32> = temporary13_;
let _e1490: vec4<f32> = temporary3_;
temporary12_.x = (_e1488.zzzz - _e1490.wwww).x;
let _e1495: vec4<f32> = temporary8_;
let _e1497: vec4<f32> = temporary8_;
temporary12_.y = (_e1495.zzzz * _e1497.zzzz).x;
let _e1502: vec4<f32> = temporary12_;
let _e1504: vec4<f32> = temporary12_;
temporary13_.y = (_e1502.xxxx + _e1504.yyyy).x;
let _e1511: vec4<f32> = constant_registers[16u];
let _e1513: vec4<f32> = temporary13_;
temporary13_.z = vec4<f32>((_e1511.xxxx < _e1513.yyyy)).x;
let _e1519: vec4<f32> = temporary13_;
let _e1523: vec4<f32> = constant_registers[16u];
if all((_e1519.zzzz != _e1523.xxxx)) {
let _e1527: vec4<f32> = temporary13_;
temporary13_.y = sqrt(_e1527.yyyy).x;
let _e1532: vec4<f32> = temporary13_;
temporary3_.w = -(_e1532.xxxx).x;
let _e1537: vec4<f32> = temporary3_;
let _e1539: vec4<f32> = temporary13_;
temporary13_.z = (_e1537.wwww - _e1539.yyyy).x;
let _e1546: vec4<f32> = constant_registers[16u];
let _e1548: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e1546.xxxx < _e1548.zzzz)).x;
let _e1554: vec4<f32> = temporary3_;
let _e1558: vec4<f32> = constant_registers[16u];
if all((_e1554.wwww != _e1558.xxxx)) {
let _e1562: vec4<f32> = temporary13_;
temporary2_.w = _e1562.zzzz.x;
}
}
let _e1566: vec4<f32> = temporary2_;
let _e1568: vec4<f32> = temporary1_;
temporary8_.y = vec4<f32>((_e1566.wwww < _e1568.yyyy)).x;
let _e1574: vec4<f32> = temporary8_;
let _e1578: vec4<f32> = constant_registers[16u];
if all((_e1574.yyyy != _e1578.xxxx)) {
let _e1584: vec4<f32> = constant_registers[16u];
temporary8_.x = _e1584.xxxx.x;
}
let _e1590: vec4<f32> = constant_registers[9u];
temporary8_.z = _e1590.xxxx.x;
let _e1596: vec4<f32> = constant_registers[17u];
temporary2_.w = _e1596.wwww.x;
let _e1600: vec4<f32> = temporary2_;
let _e1604: vec4<f32> = constant_registers[7u];
let _e1606: vec4<f32> = (_e1600.xyzz - _e1604.xyzz);
temporary19_.x = _e1606.x;
temporary19_.y = _e1606.y;
temporary19_.z = _e1606.z;
let _e1613: vec4<f32> = temporary19_;
let _e1615: vec4<f32> = temporary10_;
temporary13_.x = dot(_e1613.xyz, _e1615.xyz);
let _e1619: vec4<f32> = temporary13_;
let _e1621: vec4<f32> = temporary13_;
temporary13_.z = (_e1619.xxxx * _e1621.xxxx).x;
let _e1626: vec4<f32> = temporary19_;
let _e1628: vec4<f32> = temporary19_;
temporary3_.w = dot(_e1626.xyz, _e1628.xyz);
let _e1632: vec4<f32> = temporary13_;
let _e1634: vec4<f32> = temporary3_;
temporary12_.x = (_e1632.zzzz - _e1634.wwww).x;
let _e1639: vec4<f32> = temporary8_;
let _e1641: vec4<f32> = temporary8_;
temporary12_.y = (_e1639.zzzz * _e1641.zzzz).x;
let _e1646: vec4<f32> = temporary12_;
let _e1648: vec4<f32> = temporary12_;
temporary13_.y = (_e1646.xxxx + _e1648.yyyy).x;
let _e1655: vec4<f32> = constant_registers[16u];
let _e1657: vec4<f32> = temporary13_;
temporary13_.z = vec4<f32>((_e1655.xxxx < _e1657.yyyy)).x;
let _e1663: vec4<f32> = temporary13_;
let _e1667: vec4<f32> = constant_registers[16u];
if all((_e1663.zzzz != _e1667.xxxx)) {
let _e1671: vec4<f32> = temporary13_;
temporary13_.y = sqrt(_e1671.yyyy).x;
let _e1676: vec4<f32> = temporary13_;
temporary3_.w = -(_e1676.xxxx).x;
let _e1681: vec4<f32> = temporary3_;
let _e1683: vec4<f32> = temporary13_;
temporary13_.z = (_e1681.wwww - _e1683.yyyy).x;
let _e1690: vec4<f32> = constant_registers[16u];
let _e1692: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e1690.xxxx < _e1692.zzzz)).x;
let _e1698: vec4<f32> = temporary3_;
let _e1702: vec4<f32> = constant_registers[16u];
if all((_e1698.wwww != _e1702.xxxx)) {
let _e1706: vec4<f32> = temporary13_;
temporary2_.w = _e1706.zzzz.x;
}
}
let _e1710: vec4<f32> = temporary2_;
let _e1712: vec4<f32> = temporary1_;
temporary8_.y = vec4<f32>((_e1710.wwww < _e1712.yyyy)).x;
let _e1718: vec4<f32> = temporary8_;
let _e1722: vec4<f32> = constant_registers[16u];
if all((_e1718.yyyy != _e1722.xxxx)) {
let _e1728: vec4<f32> = constant_registers[16u];
temporary8_.x = _e1728.xxxx.x;
}
let _e1732: vec4<f32> = temporary2_;
let _e1733: vec4<f32> = _e1732.xyzz;
temporary15_.x = _e1733.x;
temporary15_.y = _e1733.y;
temporary15_.z = _e1733.z;
let _e1740: vec4<f32> = temporary10_;
let _e1741: vec4<f32> = _e1740.xyzz;
temporary17_.x = _e1741.x;
temporary17_.y = _e1741.y;
temporary17_.z = _e1741.z;
let _e1750: vec4<f32> = constant_registers[10u];
let _e1751: vec4<f32> = _e1750.xyzz;
temporary18_.x = _e1751.x;
temporary18_.y = _e1751.y;
temporary18_.z = _e1751.z;
let _e1760: vec4<f32> = constant_registers[12u];
temporary8_.z = _e1760.xxxx.x;
let _e1766: vec4<f32> = constant_registers[17u];
temporary2_.w = _e1766.wwww.x;
let _e1770: vec4<f32> = temporary15_;
let _e1772: vec4<f32> = temporary18_;
let _e1774: vec4<f32> = (_e1770.xyzz - _e1772.xyzz);
temporary19_.x = _e1774.x;
temporary19_.y = _e1774.y;
temporary19_.z = _e1774.z;
let _e1781: vec4<f32> = temporary19_;
let _e1783: vec4<f32> = temporary17_;
temporary13_.x = dot(_e1781.xyz, _e1783.xyz);
let _e1787: vec4<f32> = temporary13_;
let _e1789: vec4<f32> = temporary13_;
temporary13_.z = (_e1787.xxxx * _e1789.xxxx).x;
let _e1794: vec4<f32> = temporary19_;
let _e1796: vec4<f32> = temporary19_;
temporary3_.w = dot(_e1794.xyz, _e1796.xyz);
let _e1800: vec4<f32> = temporary13_;
let _e1802: vec4<f32> = temporary3_;
temporary12_.x = (_e1800.zzzz - _e1802.wwww).x;
let _e1807: vec4<f32> = temporary8_;
let _e1809: vec4<f32> = temporary8_;
temporary12_.y = (_e1807.zzzz * _e1809.zzzz).x;
let _e1814: vec4<f32> = temporary12_;
let _e1816: vec4<f32> = temporary12_;
temporary12_.z = (_e1814.xxxx + _e1816.yyyy).x;
let _e1821: vec4<f32> = temporary12_;
temporary13_.y = _e1821.zzzz.x;
let _e1827: vec4<f32> = constant_registers[16u];
let _e1829: vec4<f32> = temporary13_;
temporary13_.z = vec4<f32>((_e1827.xxxx < _e1829.yyyy)).x;
let _e1835: vec4<f32> = temporary13_;
let _e1839: vec4<f32> = constant_registers[16u];
if all((_e1835.zzzz != _e1839.xxxx)) {
let _e1843: vec4<f32> = temporary13_;
temporary13_.y = sqrt(_e1843.yyyy).x;
let _e1848: vec4<f32> = temporary13_;
temporary3_.w = -(_e1848.xxxx).x;
let _e1853: vec4<f32> = temporary3_;
let _e1855: vec4<f32> = temporary13_;
temporary12_.x = (_e1853.wwww - _e1855.yyyy).x;
let _e1860: vec4<f32> = temporary12_;
temporary13_.z = _e1860.xxxx.x;
let _e1866: vec4<f32> = constant_registers[16u];
let _e1868: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e1866.xxxx < _e1868.zzzz)).x;
let _e1874: vec4<f32> = temporary3_;
let _e1878: vec4<f32> = constant_registers[16u];
if all((_e1874.wwww != _e1878.xxxx)) {
let _e1882: vec4<f32> = temporary13_;
temporary2_.w = _e1882.zzzz.x;
}
}
let _e1886: vec4<f32> = temporary2_;
temporary4_.y = _e1886.wwww.x;
let _e1890: vec4<f32> = temporary4_;
let _e1892: vec4<f32> = temporary1_;
temporary8_.y = vec4<f32>((_e1890.yyyy < _e1892.yyyy)).x;
let _e1898: vec4<f32> = temporary8_;
let _e1902: vec4<f32> = constant_registers[16u];
if all((_e1898.yyyy != _e1902.xxxx)) {
let _e1908: vec4<f32> = constant_registers[16u];
temporary8_.x = _e1908.xxxx.x;
}
let _e1912: vec4<f32> = temporary6_;
temporary8_.y = saturate(_e1912.yyyy).x;
let _e1917: vec4<f32> = temporary8_;
let _e1921: vec4<f32> = constant_registers[19u];
temporary8_.z = (_e1917.yyyy * _e1921.xxxx).x;
let _e1926: vec4<f32> = temporary8_;
let _e1928: vec4<f32> = temporary8_;
temporary8_.x = (_e1926.xxxx + _e1928.zzzz).x;
let _e1933: vec4<f32> = temporary8_;
let _e1937: vec4<f32> = constant_registers[19u];
temporary8_.z = (_e1933.xxxx * _e1937.yyyy).x;
let _e1944: vec4<f32> = constant_registers[19u];
let _e1946: vec4<f32> = temporary8_;
temporary2_.w = (_e1944.zzzz + _e1946.zzzz).x;
let _e1951: vec4<f32> = temporary2_;
temporary8_.y = _e1951.wwww.x;
let _e1955: vec4<f32> = temporary1_;
let _e1959: vec4<f32> = constant_registers[16u];
temporary8_.z = vec4<f32>((_e1955.zzzz == _e1959.yyyy)).x;
let _e1965: vec4<f32> = temporary8_;
let _e1969: vec4<f32> = constant_registers[16u];
if all((_e1965.zzzz != _e1969.xxxx)) {
let _e1973: vec4<f32> = temporary2_;
temporary8_.z = fract(_e1973.xxxx).x;
let _e1978: vec4<f32> = temporary2_;
let _e1980: vec4<f32> = temporary8_;
temporary2_.w = (_e1978.xxxx - _e1980.zzzz).x;
let _e1985: vec4<f32> = temporary2_;
temporary15_.x = fract(_e1985.zzzz).x;
let _e1990: vec4<f32> = temporary2_;
let _e1992: vec4<f32> = temporary15_;
temporary15_.y = (_e1990.zzzz - _e1992.xxxx).x;
let _e1997: vec4<f32> = temporary2_;
let _e1999: vec4<f32> = temporary15_;
temporary15_.z = (_e1997.wwww + _e1999.yyyy).x;
let _e2004: vec4<f32> = temporary15_;
let _e2008: vec4<f32> = constant_registers[18u];
temporary1_.x = (_e2004.zzzz / _e2008.xxxx).x;
let _e2013: vec4<f32> = temporary1_;
temporary17_.x = fract(_e2013.xxxx).x;
let _e2018: vec4<f32> = temporary17_;
let _e2022: vec4<f32> = constant_registers[18u];
temporary17_.y = (_e2018.xxxx * _e2022.xxxx).x;
let _e2027: vec4<f32> = temporary17_;
let _e2031: vec4<f32> = constant_registers[16u];
temporary17_.z = vec4<f32>((_e2027.yyyy == _e2031.yyyy)).x;
let _e2037: vec4<f32> = temporary17_;
let _e2041: vec4<f32> = constant_registers[16u];
if all((_e2037.zzzz != _e2041.xxxx)) {
let _e2047: vec4<f32> = constant_registers[13u];
let _e2049: vec4<f32> = temporary8_;
let _e2051: vec4<f32> = (_e2047.xyzz * _e2049.yyyy);
temporary15_.x = _e2051.x;
temporary15_.y = _e2051.y;
temporary15_.z = _e2051.z;
let _e2058: vec4<f32> = temporary0_;
let _e2060: vec4<f32> = temporary15_;
let _e2062: vec4<f32> = (_e2058.xyzz + _e2060.xyzz);
temporary0_.x = _e2062.x;
temporary0_.y = _e2062.y;
temporary0_.z = _e2062.z;
} else {
let _e2071: vec4<f32> = constant_registers[14u];
let _e2073: vec4<f32> = temporary8_;
let _e2075: vec4<f32> = (_e2071.xyzz * _e2073.yyyy);
temporary15_.x = _e2075.x;
temporary15_.y = _e2075.y;
temporary15_.z = _e2075.z;
let _e2082: vec4<f32> = temporary0_;
let _e2084: vec4<f32> = temporary15_;
let _e2086: vec4<f32> = (_e2082.xyzz + _e2084.xyzz);
temporary0_.x = _e2086.x;
temporary0_.y = _e2086.y;
temporary0_.z = _e2086.z;
}
}
let _e2093: vec4<f32> = temporary1_;
let _e2097: vec4<f32> = constant_registers[18u];
temporary8_.z = vec4<f32>((_e2093.zzzz == _e2097.xxxx)).x;
let _e2103: vec4<f32> = temporary8_;
let _e2107: vec4<f32> = constant_registers[16u];
if all((_e2103.zzzz != _e2107.xxxx)) {
let _e2111: vec4<f32> = temporary7_;
let _e2113: vec4<f32> = temporary8_;
let _e2115: vec4<f32> = (_e2111.xyzz * _e2113.yyyy);
temporary15_.x = _e2115.x;
temporary15_.y = _e2115.y;
temporary15_.z = _e2115.z;
let _e2122: vec4<f32> = temporary0_;
let _e2124: vec4<f32> = temporary15_;
let _e2126: vec4<f32> = (_e2122.xyzz + _e2124.xyzz);
temporary0_.x = _e2126.x;
temporary0_.y = _e2126.y;
temporary0_.z = _e2126.z;
}
let _e2135: vec4<f32> = constant_registers[16u];
temporary11_.x = _e2135.yyyy.x;
}
}
let _e2139: vec4<f32> = temporary11_;
let _e2143: vec4<f32> = constant_registers[16u];
if all((_e2139.xxxx != _e2143.xxxx)) {
let _e2149: vec4<f32> = constant_registers[16u];
temporary1_.z = _e2149.xxxx.x;
let _e2155: vec4<f32> = constant_registers[17u];
temporary4_.z = _e2155.wwww.x;
let _e2161: vec4<f32> = constant_registers[16u];
let _e2162: vec4<f32> = _e2161.xyxx;
temporary3_.x = _e2162.x;
temporary3_.y = _e2162.y;
temporary3_.z = _e2162.z;
let _e2169: vec4<f32> = temporary3_;
let _e2170: vec4<f32> = _e2169.xyzz;
temporary12_.x = _e2170.x;
temporary12_.y = _e2170.y;
temporary12_.z = _e2170.z;
let _e2179: vec4<f32> = constant_registers[17u];
temporary2_.w = _e2179.wwww.x;
let _e2183: vec4<f32> = temporary2_;
let _e2187: vec4<f32> = constant_registers[16u];
let _e2189: vec4<f32> = (_e2183.xyzz - _e2187.xxxx);
temporary20_.x = _e2189.x;
temporary20_.y = _e2189.y;
temporary20_.z = _e2189.z;
let _e2196: vec4<f32> = temporary20_;
let _e2198: vec4<f32> = temporary12_;
temporary14_.y = dot(_e2196.xyz, _e2198.xyz);
let _e2202: vec4<f32> = temporary14_;
temporary14_.z = -(_e2202.yyyy).x;
let _e2207: vec4<f32> = temporary9_;
let _e2209: vec4<f32> = temporary12_;
temporary4_.x = dot(_e2207.xyz, _e2209.xyz);
let _e2213: vec4<f32> = temporary14_;
let _e2215: vec4<f32> = temporary4_;
temporary16_.x = (_e2213.zzzz / _e2215.xxxx).x;
let _e2220: vec4<f32> = temporary16_;
temporary14_.x = _e2220.xxxx.x;
let _e2226: vec4<f32> = constant_registers[16u];
let _e2228: vec4<f32> = temporary14_;
temporary14_.y = vec4<f32>((_e2226.xxxx < _e2228.xxxx)).x;
let _e2234: vec4<f32> = temporary14_;
let _e2238: vec4<f32> = constant_registers[16u];
if all((_e2234.yyyy != _e2238.xxxx)) {
let _e2242: vec4<f32> = temporary14_;
temporary2_.w = _e2242.xxxx.x;
}
let _e2246: vec4<f32> = temporary2_;
temporary4_.y = _e2246.wwww.x;
let _e2250: vec4<f32> = temporary4_;
let _e2252: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e2250.yyyy < _e2252.zzzz)).x;
let _e2258: vec4<f32> = temporary8_;
let _e2262: vec4<f32> = constant_registers[16u];
if all((_e2258.zzzz != _e2262.xxxx)) {
let _e2266: vec4<f32> = temporary4_;
temporary4_.z = _e2266.yyyy.x;
let _e2270: vec4<f32> = temporary3_;
let _e2271: vec4<f32> = _e2270.xyzz;
temporary6_.x = _e2271.x;
temporary6_.y = _e2271.y;
temporary6_.z = _e2271.z;
let _e2280: vec4<f32> = constant_registers[16u];
temporary1_.z = _e2280.yyyy.x;
}
let _e2284: vec4<f32> = temporary2_;
let _e2285: vec4<f32> = _e2284.xyzz;
temporary15_.x = _e2285.x;
temporary15_.y = _e2285.y;
temporary15_.z = _e2285.z;
let _e2292: vec4<f32> = temporary9_;
let _e2293: vec4<f32> = _e2292.xyzz;
temporary17_.x = _e2293.x;
temporary17_.y = _e2293.y;
temporary17_.z = _e2293.z;
let _e2302: vec4<f32> = constant_registers[4u];
let _e2303: vec4<f32> = _e2302.xyzz;
temporary18_.x = _e2303.x;
temporary18_.y = _e2303.y;
temporary18_.z = _e2303.z;
let _e2312: vec4<f32> = constant_registers[6u];
temporary2_.w = _e2312.xxxx.x;
let _e2316: vec4<f32> = temporary3_;
let _e2317: vec4<f32> = _e2316.xyzz;
temporary19_.x = _e2317.x;
temporary19_.y = _e2317.y;
temporary19_.z = _e2317.z;
let _e2326: vec4<f32> = constant_registers[17u];
temporary13_.x = _e2326.wwww.x;
let _e2330: vec4<f32> = temporary15_;
let _e2332: vec4<f32> = temporary18_;
let _e2334: vec4<f32> = (_e2330.xyzz - _e2332.xyzz);
temporary12_.x = _e2334.x;
temporary12_.y = _e2334.y;
temporary12_.z = _e2334.z;
let _e2341: vec4<f32> = temporary12_;
let _e2343: vec4<f32> = temporary17_;
temporary13_.y = dot(_e2341.xyz, _e2343.xyz);
let _e2347: vec4<f32> = temporary13_;
let _e2349: vec4<f32> = temporary13_;
temporary3_.w = (_e2347.yyyy * _e2349.yyyy).x;
let _e2354: vec4<f32> = temporary12_;
let _e2356: vec4<f32> = temporary12_;
temporary14_.x = dot(_e2354.xyz, _e2356.xyz);
let _e2360: vec4<f32> = temporary3_;
let _e2362: vec4<f32> = temporary14_;
temporary14_.y = (_e2360.wwww - _e2362.xxxx).x;
let _e2367: vec4<f32> = temporary2_;
let _e2369: vec4<f32> = temporary2_;
temporary14_.z = (_e2367.wwww * _e2369.wwww).x;
let _e2374: vec4<f32> = temporary14_;
let _e2376: vec4<f32> = temporary14_;
temporary13_.z = (_e2374.yyyy + _e2376.zzzz).x;
let _e2383: vec4<f32> = constant_registers[16u];
let _e2385: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e2383.xxxx < _e2385.zzzz)).x;
let _e2391: vec4<f32> = temporary3_;
let _e2395: vec4<f32> = constant_registers[16u];
if all((_e2391.wwww != _e2395.xxxx)) {
let _e2399: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e2399.zzzz).x;
let _e2404: vec4<f32> = temporary13_;
temporary14_.x = -(_e2404.yyyy).x;
let _e2409: vec4<f32> = temporary14_;
let _e2411: vec4<f32> = temporary13_;
temporary14_.y = (_e2409.xxxx - _e2411.zzzz).x;
let _e2416: vec4<f32> = temporary14_;
temporary3_.w = _e2416.yyyy.x;
let _e2422: vec4<f32> = constant_registers[16u];
let _e2424: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e2422.xxxx < _e2424.wwww)).x;
let _e2430: vec4<f32> = temporary14_;
let _e2434: vec4<f32> = constant_registers[16u];
if all((_e2430.xxxx != _e2434.xxxx)) {
let _e2438: vec4<f32> = temporary3_;
temporary13_.x = _e2438.wwww.x;
let _e2442: vec4<f32> = temporary17_;
let _e2444: vec4<f32> = temporary3_;
let _e2446: vec4<f32> = (_e2442.xyzz * _e2444.wwww);
temporary14_.x = _e2446.x;
temporary14_.y = _e2446.y;
temporary14_.z = _e2446.z;
let _e2453: vec4<f32> = temporary15_;
let _e2455: vec4<f32> = temporary14_;
let _e2457: vec4<f32> = (_e2453.xyzz + _e2455.xyzz);
temporary20_.x = _e2457.x;
temporary20_.y = _e2457.y;
temporary20_.z = _e2457.z;
let _e2464: vec4<f32> = temporary20_;
let _e2466: vec4<f32> = temporary18_;
let _e2468: vec4<f32> = (_e2464.xyzz - _e2466.xyzz);
temporary16_.x = _e2468.x;
temporary16_.y = _e2468.y;
temporary16_.z = _e2468.z;
let _e2475: vec4<f32> = temporary16_;
let _e2477: vec3<f32> = normalize(_e2475.xyz);
temporary19_.x = _e2477.x;
temporary19_.y = _e2477.y;
temporary19_.z = _e2477.z;
}
}
let _e2484: vec4<f32> = temporary13_;
temporary4_.y = _e2484.xxxx.x;
let _e2488: vec4<f32> = temporary19_;
let _e2489: vec4<f32> = _e2488.xyzz;
temporary3_.x = _e2489.x;
temporary3_.y = _e2489.y;
temporary3_.z = _e2489.z;
let _e2496: vec4<f32> = temporary4_;
let _e2498: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e2496.yyyy < _e2498.zzzz)).x;
let _e2504: vec4<f32> = temporary8_;
let _e2508: vec4<f32> = constant_registers[16u];
if all((_e2504.zzzz != _e2508.xxxx)) {
let _e2512: vec4<f32> = temporary4_;
temporary4_.z = _e2512.yyyy.x;
let _e2516: vec4<f32> = temporary3_;
let _e2517: vec4<f32> = _e2516.xyzz;
temporary6_.x = _e2517.x;
temporary6_.y = _e2517.y;
temporary6_.z = _e2517.z;
let _e2526: vec4<f32> = constant_registers[5u];
let _e2527: vec4<f32> = _e2526.xyzz;
temporary7_.x = _e2527.x;
temporary7_.y = _e2527.y;
temporary7_.z = _e2527.z;
let _e2536: vec4<f32> = constant_registers[18u];
temporary1_.z = _e2536.xxxx.x;
}
let _e2540: vec4<f32> = temporary2_;
let _e2541: vec4<f32> = _e2540.xyzz;
temporary15_.x = _e2541.x;
temporary15_.y = _e2541.y;
temporary15_.z = _e2541.z;
let _e2548: vec4<f32> = temporary9_;
let _e2549: vec4<f32> = _e2548.xyzz;
temporary17_.x = _e2549.x;
temporary17_.y = _e2549.y;
temporary17_.z = _e2549.z;
let _e2558: vec4<f32> = constant_registers[7u];
let _e2559: vec4<f32> = _e2558.xyzz;
temporary18_.x = _e2559.x;
temporary18_.y = _e2559.y;
temporary18_.z = _e2559.z;
let _e2568: vec4<f32> = constant_registers[9u];
temporary2_.w = _e2568.xxxx.x;
let _e2572: vec4<f32> = temporary3_;
let _e2573: vec4<f32> = _e2572.xyzz;
temporary19_.x = _e2573.x;
temporary19_.y = _e2573.y;
temporary19_.z = _e2573.z;
let _e2582: vec4<f32> = constant_registers[17u];
temporary13_.x = _e2582.wwww.x;
let _e2586: vec4<f32> = temporary15_;
let _e2588: vec4<f32> = temporary18_;
let _e2590: vec4<f32> = (_e2586.xyzz - _e2588.xyzz);
temporary12_.x = _e2590.x;
temporary12_.y = _e2590.y;
temporary12_.z = _e2590.z;
let _e2597: vec4<f32> = temporary12_;
let _e2599: vec4<f32> = temporary17_;
temporary13_.y = dot(_e2597.xyz, _e2599.xyz);
let _e2603: vec4<f32> = temporary13_;
let _e2605: vec4<f32> = temporary13_;
temporary3_.w = (_e2603.yyyy * _e2605.yyyy).x;
let _e2610: vec4<f32> = temporary12_;
let _e2612: vec4<f32> = temporary12_;
temporary14_.x = dot(_e2610.xyz, _e2612.xyz);
let _e2616: vec4<f32> = temporary3_;
let _e2618: vec4<f32> = temporary14_;
temporary14_.y = (_e2616.wwww - _e2618.xxxx).x;
let _e2623: vec4<f32> = temporary2_;
let _e2625: vec4<f32> = temporary2_;
temporary14_.z = (_e2623.wwww * _e2625.wwww).x;
let _e2630: vec4<f32> = temporary14_;
let _e2632: vec4<f32> = temporary14_;
temporary13_.z = (_e2630.yyyy + _e2632.zzzz).x;
let _e2639: vec4<f32> = constant_registers[16u];
let _e2641: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e2639.xxxx < _e2641.zzzz)).x;
let _e2647: vec4<f32> = temporary3_;
let _e2651: vec4<f32> = constant_registers[16u];
if all((_e2647.wwww != _e2651.xxxx)) {
let _e2655: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e2655.zzzz).x;
let _e2660: vec4<f32> = temporary13_;
temporary14_.x = -(_e2660.yyyy).x;
let _e2665: vec4<f32> = temporary14_;
let _e2667: vec4<f32> = temporary13_;
temporary14_.y = (_e2665.xxxx - _e2667.zzzz).x;
let _e2672: vec4<f32> = temporary14_;
temporary3_.w = _e2672.yyyy.x;
let _e2678: vec4<f32> = constant_registers[16u];
let _e2680: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e2678.xxxx < _e2680.wwww)).x;
let _e2686: vec4<f32> = temporary14_;
let _e2690: vec4<f32> = constant_registers[16u];
if all((_e2686.xxxx != _e2690.xxxx)) {
let _e2694: vec4<f32> = temporary3_;
temporary13_.x = _e2694.wwww.x;
let _e2698: vec4<f32> = temporary17_;
let _e2700: vec4<f32> = temporary3_;
let _e2702: vec4<f32> = (_e2698.xyzz * _e2700.wwww);
temporary14_.x = _e2702.x;
temporary14_.y = _e2702.y;
temporary14_.z = _e2702.z;
let _e2709: vec4<f32> = temporary15_;
let _e2711: vec4<f32> = temporary14_;
let _e2713: vec4<f32> = (_e2709.xyzz + _e2711.xyzz);
temporary20_.x = _e2713.x;
temporary20_.y = _e2713.y;
temporary20_.z = _e2713.z;
let _e2720: vec4<f32> = temporary20_;
let _e2722: vec4<f32> = temporary18_;
let _e2724: vec4<f32> = (_e2720.xyzz - _e2722.xyzz);
temporary16_.x = _e2724.x;
temporary16_.y = _e2724.y;
temporary16_.z = _e2724.z;
let _e2731: vec4<f32> = temporary16_;
let _e2733: vec3<f32> = normalize(_e2731.xyz);
temporary19_.x = _e2733.x;
temporary19_.y = _e2733.y;
temporary19_.z = _e2733.z;
}
}
let _e2740: vec4<f32> = temporary13_;
temporary4_.y = _e2740.xxxx.x;
let _e2744: vec4<f32> = temporary19_;
let _e2745: vec4<f32> = _e2744.xyzz;
temporary3_.x = _e2745.x;
temporary3_.y = _e2745.y;
temporary3_.z = _e2745.z;
let _e2752: vec4<f32> = temporary4_;
let _e2754: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e2752.yyyy < _e2754.zzzz)).x;
let _e2760: vec4<f32> = temporary8_;
let _e2764: vec4<f32> = constant_registers[16u];
if all((_e2760.zzzz != _e2764.xxxx)) {
let _e2768: vec4<f32> = temporary4_;
temporary4_.z = _e2768.yyyy.x;
let _e2772: vec4<f32> = temporary3_;
let _e2773: vec4<f32> = _e2772.xyzz;
temporary6_.x = _e2773.x;
temporary6_.y = _e2773.y;
temporary6_.z = _e2773.z;
let _e2782: vec4<f32> = constant_registers[8u];
let _e2783: vec4<f32> = _e2782.xyzz;
temporary7_.x = _e2783.x;
temporary7_.y = _e2783.y;
temporary7_.z = _e2783.z;
let _e2792: vec4<f32> = constant_registers[18u];
temporary1_.z = _e2792.xxxx.x;
}
let _e2796: vec4<f32> = temporary2_;
let _e2797: vec4<f32> = _e2796.xyzz;
temporary15_.x = _e2797.x;
temporary15_.y = _e2797.y;
temporary15_.z = _e2797.z;
let _e2804: vec4<f32> = temporary9_;
let _e2805: vec4<f32> = _e2804.xyzz;
temporary17_.x = _e2805.x;
temporary17_.y = _e2805.y;
temporary17_.z = _e2805.z;
let _e2814: vec4<f32> = constant_registers[10u];
let _e2815: vec4<f32> = _e2814.xyzz;
temporary18_.x = _e2815.x;
temporary18_.y = _e2815.y;
temporary18_.z = _e2815.z;
let _e2824: vec4<f32> = constant_registers[12u];
temporary2_.w = _e2824.xxxx.x;
let _e2828: vec4<f32> = temporary3_;
let _e2829: vec4<f32> = _e2828.xyzz;
temporary19_.x = _e2829.x;
temporary19_.y = _e2829.y;
temporary19_.z = _e2829.z;
let _e2838: vec4<f32> = constant_registers[17u];
temporary13_.x = _e2838.wwww.x;
let _e2842: vec4<f32> = temporary15_;
let _e2844: vec4<f32> = temporary18_;
let _e2846: vec4<f32> = (_e2842.xyzz - _e2844.xyzz);
temporary12_.x = _e2846.x;
temporary12_.y = _e2846.y;
temporary12_.z = _e2846.z;
let _e2853: vec4<f32> = temporary12_;
let _e2855: vec4<f32> = temporary17_;
temporary13_.y = dot(_e2853.xyz, _e2855.xyz);
let _e2859: vec4<f32> = temporary13_;
let _e2861: vec4<f32> = temporary13_;
temporary3_.w = (_e2859.yyyy * _e2861.yyyy).x;
let _e2866: vec4<f32> = temporary12_;
let _e2868: vec4<f32> = temporary12_;
temporary14_.x = dot(_e2866.xyz, _e2868.xyz);
let _e2872: vec4<f32> = temporary3_;
let _e2874: vec4<f32> = temporary14_;
temporary14_.y = (_e2872.wwww - _e2874.xxxx).x;
let _e2879: vec4<f32> = temporary2_;
let _e2881: vec4<f32> = temporary2_;
temporary14_.z = (_e2879.wwww * _e2881.wwww).x;
let _e2886: vec4<f32> = temporary14_;
let _e2888: vec4<f32> = temporary14_;
temporary4_.x = (_e2886.yyyy + _e2888.zzzz).x;
let _e2893: vec4<f32> = temporary4_;
temporary13_.z = _e2893.xxxx.x;
let _e2899: vec4<f32> = constant_registers[16u];
let _e2901: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e2899.xxxx < _e2901.zzzz)).x;
let _e2907: vec4<f32> = temporary3_;
let _e2911: vec4<f32> = constant_registers[16u];
if all((_e2907.wwww != _e2911.xxxx)) {
let _e2915: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e2915.zzzz).x;
let _e2920: vec4<f32> = temporary13_;
temporary14_.x = -(_e2920.yyyy).x;
let _e2925: vec4<f32> = temporary14_;
let _e2927: vec4<f32> = temporary13_;
temporary14_.y = (_e2925.xxxx - _e2927.zzzz).x;
let _e2932: vec4<f32> = temporary14_;
temporary3_.w = _e2932.yyyy.x;
let _e2938: vec4<f32> = constant_registers[16u];
let _e2940: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e2938.xxxx < _e2940.wwww)).x;
let _e2946: vec4<f32> = temporary14_;
let _e2950: vec4<f32> = constant_registers[16u];
if all((_e2946.xxxx != _e2950.xxxx)) {
let _e2954: vec4<f32> = temporary3_;
temporary13_.x = _e2954.wwww.x;
let _e2958: vec4<f32> = temporary17_;
let _e2960: vec4<f32> = temporary3_;
let _e2962: vec4<f32> = (_e2958.xyzz * _e2960.wwww);
temporary14_.x = _e2962.x;
temporary14_.y = _e2962.y;
temporary14_.z = _e2962.z;
let _e2969: vec4<f32> = temporary15_;
let _e2971: vec4<f32> = temporary14_;
let _e2973: vec4<f32> = (_e2969.xyzz + _e2971.xyzz);
temporary20_.x = _e2973.x;
temporary20_.y = _e2973.y;
temporary20_.z = _e2973.z;
let _e2980: vec4<f32> = temporary20_;
let _e2982: vec4<f32> = temporary18_;
let _e2984: vec4<f32> = (_e2980.xyzz - _e2982.xyzz);
temporary16_.x = _e2984.x;
temporary16_.y = _e2984.y;
temporary16_.z = _e2984.z;
let _e2991: vec4<f32> = temporary16_;
let _e2993: vec3<f32> = normalize(_e2991.xyz);
temporary19_.x = _e2993.x;
temporary19_.y = _e2993.y;
temporary19_.z = _e2993.z;
}
}
let _e3000: vec4<f32> = temporary13_;
temporary4_.y = _e3000.xxxx.x;
let _e3004: vec4<f32> = temporary19_;
let _e3005: vec4<f32> = _e3004.xyzz;
temporary3_.x = _e3005.x;
temporary3_.y = _e3005.y;
temporary3_.z = _e3005.z;
let _e3012: vec4<f32> = temporary4_;
let _e3014: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e3012.yyyy < _e3014.zzzz)).x;
let _e3020: vec4<f32> = temporary8_;
let _e3024: vec4<f32> = constant_registers[16u];
if all((_e3020.zzzz != _e3024.xxxx)) {
let _e3028: vec4<f32> = temporary4_;
temporary4_.z = _e3028.yyyy.x;
let _e3032: vec4<f32> = temporary3_;
let _e3033: vec4<f32> = _e3032.xyzz;
temporary6_.x = _e3033.x;
temporary6_.y = _e3033.y;
temporary6_.z = _e3033.z;
let _e3042: vec4<f32> = constant_registers[11u];
let _e3043: vec4<f32> = _e3042.xyzz;
temporary7_.x = _e3043.x;
temporary7_.y = _e3043.y;
temporary7_.z = _e3043.z;
let _e3052: vec4<f32> = constant_registers[18u];
temporary1_.z = _e3052.xxxx.x;
}
let _e3056: vec4<f32> = temporary11_;
let _e3060: vec4<f32> = constant_registers[16u];
temporary11_.y = (_e3056.yyyy + _e3060.yyyy).x;
let _e3065: vec4<f32> = temporary1_;
let _e3069: vec4<f32> = constant_registers[16u];
temporary8_.z = vec4<f32>((_e3065.zzzz == _e3069.xxxx)).x;
let _e3075: vec4<f32> = temporary8_;
let _e3079: vec4<f32> = constant_registers[16u];
if all((_e3075.zzzz != _e3079.xxxx)) {
let _e3085: vec4<f32> = constant_registers[16u];
let _e3086: vec4<f32> = _e3085.xyyy;
temporary11_.x = _e3086.x;
temporary11_.z = _e3086.z;
} else {
let _e3091: vec4<f32> = temporary9_;
let _e3093: vec4<f32> = temporary4_;
let _e3095: vec4<f32> = (_e3091.xyzz * _e3093.zzzz);
temporary15_.x = _e3095.x;
temporary15_.y = _e3095.y;
temporary15_.z = _e3095.z;
let _e3102: vec4<f32> = temporary2_;
let _e3104: vec4<f32> = temporary15_;
let _e3106: vec4<f32> = (_e3102.xyzz + _e3104.xyzz);
temporary2_.x = _e3106.x;
temporary2_.y = _e3106.y;
temporary2_.z = _e3106.z;
let _e3113: vec4<f32> = temporary9_;
let _e3115: vec4<f32> = temporary6_;
temporary8_.z = dot(_e3113.xyz, _e3115.xyz);
let _e3119: vec4<f32> = temporary8_;
let _e3123: vec4<f32> = constant_registers[18u];
temporary2_.w = (_e3119.zzzz * _e3123.xxxx).x;
let _e3128: vec4<f32> = temporary2_;
let _e3130: vec4<f32> = temporary6_;
let _e3132: vec4<f32> = (_e3128.wwww * _e3130.xyzz);
temporary15_.x = _e3132.x;
temporary15_.y = _e3132.y;
temporary15_.z = _e3132.z;
let _e3139: vec4<f32> = temporary9_;
let _e3141: vec4<f32> = temporary15_;
let _e3143: vec4<f32> = (_e3139.xyzz - _e3141.xyzz);
temporary9_.x = _e3143.x;
temporary9_.y = _e3143.y;
temporary9_.z = _e3143.z;
let _e3150: vec4<f32> = temporary9_;
let _e3154: vec4<f32> = constant_registers[18u];
let _e3156: vec4<f32> = (_e3150.xyzz * _e3154.yyyy);
temporary15_.x = _e3156.x;
temporary15_.y = _e3156.y;
temporary15_.z = _e3156.z;
let _e3163: vec4<f32> = temporary2_;
let _e3165: vec4<f32> = temporary15_;
let _e3167: vec4<f32> = (_e3163.xyzz + _e3165.xyzz);
temporary2_.x = _e3167.x;
temporary2_.y = _e3167.y;
temporary2_.z = _e3167.z;
let _e3176: vec4<f32> = constant_registers[15u];
let _e3178: vec4<f32> = temporary2_;
let _e3180: vec4<f32> = (_e3176.xyzz - _e3178.xyzz);
temporary5_.x = _e3180.x;
temporary5_.y = _e3180.y;
temporary5_.z = _e3180.z;
let _e3187: vec4<f32> = temporary5_;
let _e3189: vec3<f32> = normalize(_e3187.xyz);
temporary10_.x = _e3189.x;
temporary10_.y = _e3189.y;
temporary10_.z = _e3189.z;
let _e3196: vec4<f32> = temporary5_;
let _e3198: vec4<f32> = temporary5_;
temporary8_.z = dot(_e3196.xyz, _e3198.xyz);
let _e3202: vec4<f32> = temporary8_;
temporary1_.y = sqrt(_e3202.zzzz).x;
let _e3207: vec4<f32> = temporary6_;
let _e3209: vec4<f32> = temporary10_;
temporary8_.z = dot(_e3207.xyz, _e3209.xyz);
let _e3213: vec4<f32> = temporary8_;
temporary2_.w = saturate(_e3213.zzzz).x;
let _e3218: vec4<f32> = temporary1_;
let _e3220: vec4<f32> = temporary1_;
temporary15_.x = (_e3218.yyyy * _e3220.yyyy).x;
let _e3225: vec4<f32> = temporary15_;
let _e3229: vec4<f32> = constant_registers[18u];
temporary15_.y = (_e3225.xxxx * _e3229.zzzz).x;
let _e3236: vec4<f32> = constant_registers[18u];
let _e3238: vec4<f32> = temporary15_;
temporary15_.z = (_e3236.wwww + _e3238.yyyy).x;
let _e3243: vec4<f32> = temporary2_;
let _e3245: vec4<f32> = temporary15_;
temporary1_.x = (_e3243.wwww / _e3245.zzzz).x;
let _e3250: vec4<f32> = temporary1_;
temporary8_.x = _e3250.xxxx.x;
let _e3256: vec4<f32> = constant_registers[6u];
temporary2_.w = _e3256.xxxx.x;
let _e3262: vec4<f32> = constant_registers[17u];
temporary19_.x = _e3262.wwww.x;
let _e3266: vec4<f32> = temporary2_;
let _e3270: vec4<f32> = constant_registers[4u];
let _e3272: vec4<f32> = (_e3266.xyzz - _e3270.xyzz);
temporary13_.x = _e3272.x;
temporary13_.y = _e3272.y;
temporary13_.z = _e3272.z;
let _e3279: vec4<f32> = temporary13_;
let _e3281: vec4<f32> = temporary10_;
temporary19_.y = dot(_e3279.xyz, _e3281.xyz);
let _e3285: vec4<f32> = temporary19_;
let _e3287: vec4<f32> = temporary19_;
temporary1_.w = (_e3285.yyyy * _e3287.yyyy).x;
let _e3292: vec4<f32> = temporary13_;
let _e3294: vec4<f32> = temporary13_;
temporary12_.x = dot(_e3292.xyz, _e3294.xyz);
let _e3298: vec4<f32> = temporary1_;
let _e3300: vec4<f32> = temporary12_;
temporary12_.y = (_e3298.wwww - _e3300.xxxx).x;
let _e3305: vec4<f32> = temporary2_;
let _e3307: vec4<f32> = temporary2_;
temporary12_.z = (_e3305.wwww * _e3307.wwww).x;
let _e3312: vec4<f32> = temporary12_;
let _e3314: vec4<f32> = temporary12_;
temporary19_.z = (_e3312.yyyy + _e3314.zzzz).x;
let _e3321: vec4<f32> = constant_registers[16u];
let _e3323: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e3321.xxxx < _e3323.zzzz)).x;
let _e3329: vec4<f32> = temporary1_;
let _e3333: vec4<f32> = constant_registers[16u];
if all((_e3329.wwww != _e3333.xxxx)) {
let _e3337: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e3337.zzzz).x;
let _e3342: vec4<f32> = temporary19_;
temporary12_.x = -(_e3342.yyyy).x;
let _e3347: vec4<f32> = temporary12_;
let _e3349: vec4<f32> = temporary19_;
temporary1_.w = (_e3347.xxxx - _e3349.zzzz).x;
let _e3356: vec4<f32> = constant_registers[16u];
let _e3358: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e3356.xxxx < _e3358.wwww)).x;
let _e3364: vec4<f32> = temporary12_;
let _e3368: vec4<f32> = constant_registers[16u];
if all((_e3364.xxxx != _e3368.xxxx)) {
let _e3372: vec4<f32> = temporary1_;
temporary19_.x = _e3372.wwww.x;
}
}
let _e3376: vec4<f32> = temporary19_;
let _e3378: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e3376.xxxx < _e3378.yyyy)).x;
let _e3384: vec4<f32> = temporary8_;
let _e3388: vec4<f32> = constant_registers[16u];
if all((_e3384.zzzz != _e3388.xxxx)) {
let _e3394: vec4<f32> = constant_registers[16u];
temporary8_.x = _e3394.xxxx.x;
}
let _e3400: vec4<f32> = constant_registers[9u];
temporary2_.w = _e3400.xxxx.x;
let _e3406: vec4<f32> = constant_registers[17u];
temporary19_.x = _e3406.wwww.x;
let _e3410: vec4<f32> = temporary2_;
let _e3414: vec4<f32> = constant_registers[7u];
let _e3416: vec4<f32> = (_e3410.xyzz - _e3414.xyzz);
temporary13_.x = _e3416.x;
temporary13_.y = _e3416.y;
temporary13_.z = _e3416.z;
let _e3423: vec4<f32> = temporary13_;
let _e3425: vec4<f32> = temporary10_;
temporary19_.y = dot(_e3423.xyz, _e3425.xyz);
let _e3429: vec4<f32> = temporary19_;
let _e3431: vec4<f32> = temporary19_;
temporary1_.w = (_e3429.yyyy * _e3431.yyyy).x;
let _e3436: vec4<f32> = temporary13_;
let _e3438: vec4<f32> = temporary13_;
temporary12_.x = dot(_e3436.xyz, _e3438.xyz);
let _e3442: vec4<f32> = temporary1_;
let _e3444: vec4<f32> = temporary12_;
temporary12_.y = (_e3442.wwww - _e3444.xxxx).x;
let _e3449: vec4<f32> = temporary2_;
let _e3451: vec4<f32> = temporary2_;
temporary12_.z = (_e3449.wwww * _e3451.wwww).x;
let _e3456: vec4<f32> = temporary12_;
let _e3458: vec4<f32> = temporary12_;
temporary19_.z = (_e3456.yyyy + _e3458.zzzz).x;
let _e3465: vec4<f32> = constant_registers[16u];
let _e3467: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e3465.xxxx < _e3467.zzzz)).x;
let _e3473: vec4<f32> = temporary1_;
let _e3477: vec4<f32> = constant_registers[16u];
if all((_e3473.wwww != _e3477.xxxx)) {
let _e3481: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e3481.zzzz).x;
let _e3486: vec4<f32> = temporary19_;
temporary12_.x = -(_e3486.yyyy).x;
let _e3491: vec4<f32> = temporary12_;
let _e3493: vec4<f32> = temporary19_;
temporary1_.w = (_e3491.xxxx - _e3493.zzzz).x;
let _e3500: vec4<f32> = constant_registers[16u];
let _e3502: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e3500.xxxx < _e3502.wwww)).x;
let _e3508: vec4<f32> = temporary12_;
let _e3512: vec4<f32> = constant_registers[16u];
if all((_e3508.xxxx != _e3512.xxxx)) {
let _e3516: vec4<f32> = temporary1_;
temporary19_.x = _e3516.wwww.x;
}
}
let _e3520: vec4<f32> = temporary19_;
let _e3522: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e3520.xxxx < _e3522.yyyy)).x;
let _e3528: vec4<f32> = temporary8_;
let _e3532: vec4<f32> = constant_registers[16u];
if all((_e3528.zzzz != _e3532.xxxx)) {
let _e3538: vec4<f32> = constant_registers[16u];
temporary8_.x = _e3538.xxxx.x;
}
let _e3542: vec4<f32> = temporary2_;
let _e3543: vec4<f32> = _e3542.xyzz;
temporary15_.x = _e3543.x;
temporary15_.y = _e3543.y;
temporary15_.z = _e3543.z;
let _e3550: vec4<f32> = temporary10_;
let _e3551: vec4<f32> = _e3550.xyzz;
temporary17_.x = _e3551.x;
temporary17_.y = _e3551.y;
temporary17_.z = _e3551.z;
let _e3560: vec4<f32> = constant_registers[10u];
let _e3561: vec4<f32> = _e3560.xyzz;
temporary18_.x = _e3561.x;
temporary18_.y = _e3561.y;
temporary18_.z = _e3561.z;
let _e3570: vec4<f32> = constant_registers[12u];
temporary2_.w = _e3570.xxxx.x;
let _e3576: vec4<f32> = constant_registers[17u];
temporary19_.x = _e3576.wwww.x;
let _e3580: vec4<f32> = temporary15_;
let _e3582: vec4<f32> = temporary18_;
let _e3584: vec4<f32> = (_e3580.xyzz - _e3582.xyzz);
temporary13_.x = _e3584.x;
temporary13_.y = _e3584.y;
temporary13_.z = _e3584.z;
let _e3591: vec4<f32> = temporary13_;
let _e3593: vec4<f32> = temporary17_;
temporary19_.y = dot(_e3591.xyz, _e3593.xyz);
let _e3597: vec4<f32> = temporary19_;
let _e3599: vec4<f32> = temporary19_;
temporary1_.w = (_e3597.yyyy * _e3599.yyyy).x;
let _e3604: vec4<f32> = temporary13_;
let _e3606: vec4<f32> = temporary13_;
temporary12_.x = dot(_e3604.xyz, _e3606.xyz);
let _e3610: vec4<f32> = temporary1_;
let _e3612: vec4<f32> = temporary12_;
temporary12_.y = (_e3610.wwww - _e3612.xxxx).x;
let _e3617: vec4<f32> = temporary2_;
let _e3619: vec4<f32> = temporary2_;
temporary12_.z = (_e3617.wwww * _e3619.wwww).x;
let _e3624: vec4<f32> = temporary12_;
let _e3626: vec4<f32> = temporary12_;
temporary19_.z = (_e3624.yyyy + _e3626.zzzz).x;
let _e3633: vec4<f32> = constant_registers[16u];
let _e3635: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e3633.xxxx < _e3635.zzzz)).x;
let _e3641: vec4<f32> = temporary1_;
let _e3645: vec4<f32> = constant_registers[16u];
if all((_e3641.wwww != _e3645.xxxx)) {
let _e3649: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e3649.zzzz).x;
let _e3654: vec4<f32> = temporary19_;
temporary12_.x = -(_e3654.yyyy).x;
let _e3659: vec4<f32> = temporary12_;
let _e3661: vec4<f32> = temporary19_;
temporary12_.y = (_e3659.xxxx - _e3661.zzzz).x;
let _e3666: vec4<f32> = temporary12_;
temporary1_.w = _e3666.yyyy.x;
let _e3672: vec4<f32> = constant_registers[16u];
let _e3674: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e3672.xxxx < _e3674.wwww)).x;
let _e3680: vec4<f32> = temporary12_;
let _e3684: vec4<f32> = constant_registers[16u];
if all((_e3680.xxxx != _e3684.xxxx)) {
let _e3688: vec4<f32> = temporary1_;
temporary19_.x = _e3688.wwww.x;
}
}
let _e3692: vec4<f32> = temporary19_;
temporary4_.y = _e3692.xxxx.x;
let _e3696: vec4<f32> = temporary4_;
let _e3698: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e3696.yyyy < _e3698.yyyy)).x;
let _e3704: vec4<f32> = temporary8_;
let _e3708: vec4<f32> = constant_registers[16u];
if all((_e3704.zzzz != _e3708.xxxx)) {
let _e3714: vec4<f32> = constant_registers[16u];
temporary8_.x = _e3714.xxxx.x;
}
let _e3718: vec4<f32> = temporary6_;
temporary8_.z = saturate(_e3718.yyyy).x;
let _e3723: vec4<f32> = temporary8_;
let _e3727: vec4<f32> = constant_registers[19u];
temporary2_.w = (_e3723.zzzz * _e3727.xxxx).x;
let _e3732: vec4<f32> = temporary8_;
let _e3734: vec4<f32> = temporary2_;
temporary8_.x = (_e3732.xxxx + _e3734.wwww).x;
let _e3739: vec4<f32> = temporary8_;
let _e3743: vec4<f32> = constant_registers[19u];
temporary8_.z = (_e3739.xxxx * _e3743.yyyy).x;
let _e3750: vec4<f32> = constant_registers[19u];
let _e3752: vec4<f32> = temporary8_;
temporary2_.w = (_e3750.zzzz + _e3752.zzzz).x;
let _e3757: vec4<f32> = temporary2_;
temporary8_.y = _e3757.wwww.x;
let _e3761: vec4<f32> = temporary1_;
let _e3765: vec4<f32> = constant_registers[16u];
temporary8_.z = vec4<f32>((_e3761.zzzz == _e3765.yyyy)).x;
let _e3771: vec4<f32> = temporary8_;
let _e3775: vec4<f32> = constant_registers[16u];
if all((_e3771.zzzz != _e3775.xxxx)) {
let _e3779: vec4<f32> = temporary2_;
temporary8_.z = fract(_e3779.xxxx).x;
let _e3784: vec4<f32> = temporary2_;
let _e3786: vec4<f32> = temporary8_;
temporary2_.w = (_e3784.xxxx - _e3786.zzzz).x;
let _e3791: vec4<f32> = temporary2_;
temporary15_.x = fract(_e3791.zzzz).x;
let _e3796: vec4<f32> = temporary2_;
let _e3798: vec4<f32> = temporary15_;
temporary15_.y = (_e3796.zzzz - _e3798.xxxx).x;
let _e3803: vec4<f32> = temporary2_;
let _e3805: vec4<f32> = temporary15_;
temporary15_.z = (_e3803.wwww + _e3805.yyyy).x;
let _e3810: vec4<f32> = temporary15_;
let _e3814: vec4<f32> = constant_registers[18u];
temporary1_.x = (_e3810.zzzz / _e3814.xxxx).x;
let _e3819: vec4<f32> = temporary1_;
temporary17_.x = fract(_e3819.xxxx).x;
let _e3824: vec4<f32> = temporary17_;
let _e3828: vec4<f32> = constant_registers[18u];
temporary17_.y = (_e3824.xxxx * _e3828.xxxx).x;
let _e3833: vec4<f32> = temporary17_;
let _e3837: vec4<f32> = constant_registers[16u];
temporary17_.z = vec4<f32>((_e3833.yyyy == _e3837.yyyy)).x;
let _e3843: vec4<f32> = temporary17_;
let _e3847: vec4<f32> = constant_registers[16u];
if all((_e3843.zzzz != _e3847.xxxx)) {
let _e3853: vec4<f32> = constant_registers[13u];
let _e3855: vec4<f32> = temporary8_;
let _e3857: vec4<f32> = (_e3853.xyzz * _e3855.yyyy);
temporary15_.x = _e3857.x;
temporary15_.y = _e3857.y;
temporary15_.z = _e3857.z;
let _e3864: vec4<f32> = temporary0_;
let _e3866: vec4<f32> = temporary15_;
let _e3868: vec4<f32> = (_e3864.xyzz + _e3866.xyzz);
temporary0_.x = _e3868.x;
temporary0_.y = _e3868.y;
temporary0_.z = _e3868.z;
} else {
let _e3877: vec4<f32> = constant_registers[14u];
let _e3879: vec4<f32> = temporary8_;
let _e3881: vec4<f32> = (_e3877.xyzz * _e3879.yyyy);
temporary15_.x = _e3881.x;
temporary15_.y = _e3881.y;
temporary15_.z = _e3881.z;
let _e3888: vec4<f32> = temporary0_;
let _e3890: vec4<f32> = temporary15_;
let _e3892: vec4<f32> = (_e3888.xyzz + _e3890.xyzz);
temporary0_.x = _e3892.x;
temporary0_.y = _e3892.y;
temporary0_.z = _e3892.z;
}
}
let _e3899: vec4<f32> = temporary1_;
let _e3903: vec4<f32> = constant_registers[18u];
temporary8_.z = vec4<f32>((_e3899.zzzz == _e3903.xxxx)).x;
let _e3909: vec4<f32> = temporary8_;
let _e3913: vec4<f32> = constant_registers[16u];
if all((_e3909.zzzz != _e3913.xxxx)) {
let _e3917: vec4<f32> = temporary7_;
let _e3919: vec4<f32> = temporary8_;
let _e3921: vec4<f32> = (_e3917.xyzz * _e3919.yyyy);
temporary15_.x = _e3921.x;
temporary15_.y = _e3921.y;
temporary15_.z = _e3921.z;
let _e3928: vec4<f32> = temporary0_;
let _e3930: vec4<f32> = temporary15_;
let _e3932: vec4<f32> = (_e3928.xyzz + _e3930.xyzz);
temporary0_.x = _e3932.x;
temporary0_.y = _e3932.y;
temporary0_.z = _e3932.z;
}
let _e3941: vec4<f32> = constant_registers[16u];
temporary11_.x = _e3941.yyyy.x;
}
}
let _e3945: vec4<f32> = temporary11_;
let _e3949: vec4<f32> = constant_registers[16u];
if all((_e3945.xxxx != _e3949.xxxx)) {
let _e3955: vec4<f32> = constant_registers[16u];
temporary1_.z = _e3955.xxxx.x;
let _e3961: vec4<f32> = constant_registers[17u];
temporary4_.z = _e3961.wwww.x;
let _e3967: vec4<f32> = constant_registers[16u];
let _e3968: vec4<f32> = _e3967.xyxx;
temporary3_.x = _e3968.x;
temporary3_.y = _e3968.y;
temporary3_.z = _e3968.z;
let _e3975: vec4<f32> = temporary3_;
let _e3976: vec4<f32> = _e3975.xyzz;
temporary12_.x = _e3976.x;
temporary12_.y = _e3976.y;
temporary12_.z = _e3976.z;
let _e3985: vec4<f32> = constant_registers[17u];
temporary2_.w = _e3985.wwww.x;
let _e3989: vec4<f32> = temporary2_;
let _e3993: vec4<f32> = constant_registers[16u];
let _e3995: vec4<f32> = (_e3989.xyzz - _e3993.xxxx);
temporary20_.x = _e3995.x;
temporary20_.y = _e3995.y;
temporary20_.z = _e3995.z;
let _e4002: vec4<f32> = temporary20_;
let _e4004: vec4<f32> = temporary12_;
temporary14_.y = dot(_e4002.xyz, _e4004.xyz);
let _e4008: vec4<f32> = temporary14_;
temporary14_.z = -(_e4008.yyyy).x;
let _e4013: vec4<f32> = temporary9_;
let _e4015: vec4<f32> = temporary12_;
temporary4_.x = dot(_e4013.xyz, _e4015.xyz);
let _e4019: vec4<f32> = temporary14_;
let _e4021: vec4<f32> = temporary4_;
temporary16_.x = (_e4019.zzzz / _e4021.xxxx).x;
let _e4026: vec4<f32> = temporary16_;
temporary14_.x = _e4026.xxxx.x;
let _e4032: vec4<f32> = constant_registers[16u];
let _e4034: vec4<f32> = temporary14_;
temporary14_.y = vec4<f32>((_e4032.xxxx < _e4034.xxxx)).x;
let _e4040: vec4<f32> = temporary14_;
let _e4044: vec4<f32> = constant_registers[16u];
if all((_e4040.yyyy != _e4044.xxxx)) {
let _e4048: vec4<f32> = temporary14_;
temporary2_.w = _e4048.xxxx.x;
}
let _e4052: vec4<f32> = temporary2_;
temporary4_.y = _e4052.wwww.x;
let _e4056: vec4<f32> = temporary4_;
let _e4058: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e4056.yyyy < _e4058.zzzz)).x;
let _e4064: vec4<f32> = temporary8_;
let _e4068: vec4<f32> = constant_registers[16u];
if all((_e4064.zzzz != _e4068.xxxx)) {
let _e4072: vec4<f32> = temporary4_;
temporary4_.z = _e4072.yyyy.x;
let _e4076: vec4<f32> = temporary3_;
let _e4077: vec4<f32> = _e4076.xyzz;
temporary6_.x = _e4077.x;
temporary6_.y = _e4077.y;
temporary6_.z = _e4077.z;
let _e4086: vec4<f32> = constant_registers[16u];
temporary1_.z = _e4086.yyyy.x;
}
let _e4090: vec4<f32> = temporary2_;
let _e4091: vec4<f32> = _e4090.xyzz;
temporary15_.x = _e4091.x;
temporary15_.y = _e4091.y;
temporary15_.z = _e4091.z;
let _e4098: vec4<f32> = temporary9_;
let _e4099: vec4<f32> = _e4098.xyzz;
temporary17_.x = _e4099.x;
temporary17_.y = _e4099.y;
temporary17_.z = _e4099.z;
let _e4108: vec4<f32> = constant_registers[4u];
let _e4109: vec4<f32> = _e4108.xyzz;
temporary18_.x = _e4109.x;
temporary18_.y = _e4109.y;
temporary18_.z = _e4109.z;
let _e4118: vec4<f32> = constant_registers[6u];
temporary2_.w = _e4118.xxxx.x;
let _e4122: vec4<f32> = temporary3_;
let _e4123: vec4<f32> = _e4122.xyzz;
temporary19_.x = _e4123.x;
temporary19_.y = _e4123.y;
temporary19_.z = _e4123.z;
let _e4132: vec4<f32> = constant_registers[17u];
temporary13_.x = _e4132.wwww.x;
let _e4136: vec4<f32> = temporary15_;
let _e4138: vec4<f32> = temporary18_;
let _e4140: vec4<f32> = (_e4136.xyzz - _e4138.xyzz);
temporary12_.x = _e4140.x;
temporary12_.y = _e4140.y;
temporary12_.z = _e4140.z;
let _e4147: vec4<f32> = temporary12_;
let _e4149: vec4<f32> = temporary17_;
temporary13_.y = dot(_e4147.xyz, _e4149.xyz);
let _e4153: vec4<f32> = temporary13_;
let _e4155: vec4<f32> = temporary13_;
temporary3_.w = (_e4153.yyyy * _e4155.yyyy).x;
let _e4160: vec4<f32> = temporary12_;
let _e4162: vec4<f32> = temporary12_;
temporary14_.x = dot(_e4160.xyz, _e4162.xyz);
let _e4166: vec4<f32> = temporary3_;
let _e4168: vec4<f32> = temporary14_;
temporary14_.y = (_e4166.wwww - _e4168.xxxx).x;
let _e4173: vec4<f32> = temporary2_;
let _e4175: vec4<f32> = temporary2_;
temporary14_.z = (_e4173.wwww * _e4175.wwww).x;
let _e4180: vec4<f32> = temporary14_;
let _e4182: vec4<f32> = temporary14_;
temporary13_.z = (_e4180.yyyy + _e4182.zzzz).x;
let _e4189: vec4<f32> = constant_registers[16u];
let _e4191: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e4189.xxxx < _e4191.zzzz)).x;
let _e4197: vec4<f32> = temporary3_;
let _e4201: vec4<f32> = constant_registers[16u];
if all((_e4197.wwww != _e4201.xxxx)) {
let _e4205: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e4205.zzzz).x;
let _e4210: vec4<f32> = temporary13_;
temporary14_.x = -(_e4210.yyyy).x;
let _e4215: vec4<f32> = temporary14_;
let _e4217: vec4<f32> = temporary13_;
temporary14_.y = (_e4215.xxxx - _e4217.zzzz).x;
let _e4222: vec4<f32> = temporary14_;
temporary3_.w = _e4222.yyyy.x;
let _e4228: vec4<f32> = constant_registers[16u];
let _e4230: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e4228.xxxx < _e4230.wwww)).x;
let _e4236: vec4<f32> = temporary14_;
let _e4240: vec4<f32> = constant_registers[16u];
if all((_e4236.xxxx != _e4240.xxxx)) {
let _e4244: vec4<f32> = temporary3_;
temporary13_.x = _e4244.wwww.x;
let _e4248: vec4<f32> = temporary17_;
let _e4250: vec4<f32> = temporary3_;
let _e4252: vec4<f32> = (_e4248.xyzz * _e4250.wwww);
temporary14_.x = _e4252.x;
temporary14_.y = _e4252.y;
temporary14_.z = _e4252.z;
let _e4259: vec4<f32> = temporary15_;
let _e4261: vec4<f32> = temporary14_;
let _e4263: vec4<f32> = (_e4259.xyzz + _e4261.xyzz);
temporary20_.x = _e4263.x;
temporary20_.y = _e4263.y;
temporary20_.z = _e4263.z;
let _e4270: vec4<f32> = temporary20_;
let _e4272: vec4<f32> = temporary18_;
let _e4274: vec4<f32> = (_e4270.xyzz - _e4272.xyzz);
temporary16_.x = _e4274.x;
temporary16_.y = _e4274.y;
temporary16_.z = _e4274.z;
let _e4281: vec4<f32> = temporary16_;
let _e4283: vec3<f32> = normalize(_e4281.xyz);
temporary19_.x = _e4283.x;
temporary19_.y = _e4283.y;
temporary19_.z = _e4283.z;
}
}
let _e4290: vec4<f32> = temporary13_;
temporary4_.y = _e4290.xxxx.x;
let _e4294: vec4<f32> = temporary19_;
let _e4295: vec4<f32> = _e4294.xyzz;
temporary3_.x = _e4295.x;
temporary3_.y = _e4295.y;
temporary3_.z = _e4295.z;
let _e4302: vec4<f32> = temporary4_;
let _e4304: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e4302.yyyy < _e4304.zzzz)).x;
let _e4310: vec4<f32> = temporary8_;
let _e4314: vec4<f32> = constant_registers[16u];
if all((_e4310.zzzz != _e4314.xxxx)) {
let _e4318: vec4<f32> = temporary4_;
temporary4_.z = _e4318.yyyy.x;
let _e4322: vec4<f32> = temporary3_;
let _e4323: vec4<f32> = _e4322.xyzz;
temporary6_.x = _e4323.x;
temporary6_.y = _e4323.y;
temporary6_.z = _e4323.z;
let _e4332: vec4<f32> = constant_registers[5u];
let _e4333: vec4<f32> = _e4332.xyzz;
temporary7_.x = _e4333.x;
temporary7_.y = _e4333.y;
temporary7_.z = _e4333.z;
let _e4342: vec4<f32> = constant_registers[18u];
temporary1_.z = _e4342.xxxx.x;
}
let _e4346: vec4<f32> = temporary2_;
let _e4347: vec4<f32> = _e4346.xyzz;
temporary15_.x = _e4347.x;
temporary15_.y = _e4347.y;
temporary15_.z = _e4347.z;
let _e4354: vec4<f32> = temporary9_;
let _e4355: vec4<f32> = _e4354.xyzz;
temporary17_.x = _e4355.x;
temporary17_.y = _e4355.y;
temporary17_.z = _e4355.z;
let _e4364: vec4<f32> = constant_registers[7u];
let _e4365: vec4<f32> = _e4364.xyzz;
temporary18_.x = _e4365.x;
temporary18_.y = _e4365.y;
temporary18_.z = _e4365.z;
let _e4374: vec4<f32> = constant_registers[9u];
temporary2_.w = _e4374.xxxx.x;
let _e4378: vec4<f32> = temporary3_;
let _e4379: vec4<f32> = _e4378.xyzz;
temporary19_.x = _e4379.x;
temporary19_.y = _e4379.y;
temporary19_.z = _e4379.z;
let _e4388: vec4<f32> = constant_registers[17u];
temporary13_.x = _e4388.wwww.x;
let _e4392: vec4<f32> = temporary15_;
let _e4394: vec4<f32> = temporary18_;
let _e4396: vec4<f32> = (_e4392.xyzz - _e4394.xyzz);
temporary12_.x = _e4396.x;
temporary12_.y = _e4396.y;
temporary12_.z = _e4396.z;
let _e4403: vec4<f32> = temporary12_;
let _e4405: vec4<f32> = temporary17_;
temporary13_.y = dot(_e4403.xyz, _e4405.xyz);
let _e4409: vec4<f32> = temporary13_;
let _e4411: vec4<f32> = temporary13_;
temporary3_.w = (_e4409.yyyy * _e4411.yyyy).x;
let _e4416: vec4<f32> = temporary12_;
let _e4418: vec4<f32> = temporary12_;
temporary14_.x = dot(_e4416.xyz, _e4418.xyz);
let _e4422: vec4<f32> = temporary3_;
let _e4424: vec4<f32> = temporary14_;
temporary14_.y = (_e4422.wwww - _e4424.xxxx).x;
let _e4429: vec4<f32> = temporary2_;
let _e4431: vec4<f32> = temporary2_;
temporary14_.z = (_e4429.wwww * _e4431.wwww).x;
let _e4436: vec4<f32> = temporary14_;
let _e4438: vec4<f32> = temporary14_;
temporary13_.z = (_e4436.yyyy + _e4438.zzzz).x;
let _e4445: vec4<f32> = constant_registers[16u];
let _e4447: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e4445.xxxx < _e4447.zzzz)).x;
let _e4453: vec4<f32> = temporary3_;
let _e4457: vec4<f32> = constant_registers[16u];
if all((_e4453.wwww != _e4457.xxxx)) {
let _e4461: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e4461.zzzz).x;
let _e4466: vec4<f32> = temporary13_;
temporary14_.x = -(_e4466.yyyy).x;
let _e4471: vec4<f32> = temporary14_;
let _e4473: vec4<f32> = temporary13_;
temporary14_.y = (_e4471.xxxx - _e4473.zzzz).x;
let _e4478: vec4<f32> = temporary14_;
temporary3_.w = _e4478.yyyy.x;
let _e4484: vec4<f32> = constant_registers[16u];
let _e4486: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e4484.xxxx < _e4486.wwww)).x;
let _e4492: vec4<f32> = temporary14_;
let _e4496: vec4<f32> = constant_registers[16u];
if all((_e4492.xxxx != _e4496.xxxx)) {
let _e4500: vec4<f32> = temporary3_;
temporary13_.x = _e4500.wwww.x;
let _e4504: vec4<f32> = temporary17_;
let _e4506: vec4<f32> = temporary3_;
let _e4508: vec4<f32> = (_e4504.xyzz * _e4506.wwww);
temporary14_.x = _e4508.x;
temporary14_.y = _e4508.y;
temporary14_.z = _e4508.z;
let _e4515: vec4<f32> = temporary15_;
let _e4517: vec4<f32> = temporary14_;
let _e4519: vec4<f32> = (_e4515.xyzz + _e4517.xyzz);
temporary20_.x = _e4519.x;
temporary20_.y = _e4519.y;
temporary20_.z = _e4519.z;
let _e4526: vec4<f32> = temporary20_;
let _e4528: vec4<f32> = temporary18_;
let _e4530: vec4<f32> = (_e4526.xyzz - _e4528.xyzz);
temporary16_.x = _e4530.x;
temporary16_.y = _e4530.y;
temporary16_.z = _e4530.z;
let _e4537: vec4<f32> = temporary16_;
let _e4539: vec3<f32> = normalize(_e4537.xyz);
temporary19_.x = _e4539.x;
temporary19_.y = _e4539.y;
temporary19_.z = _e4539.z;
}
}
let _e4546: vec4<f32> = temporary13_;
temporary4_.y = _e4546.xxxx.x;
let _e4550: vec4<f32> = temporary19_;
let _e4551: vec4<f32> = _e4550.xyzz;
temporary3_.x = _e4551.x;
temporary3_.y = _e4551.y;
temporary3_.z = _e4551.z;
let _e4558: vec4<f32> = temporary4_;
let _e4560: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e4558.yyyy < _e4560.zzzz)).x;
let _e4566: vec4<f32> = temporary8_;
let _e4570: vec4<f32> = constant_registers[16u];
if all((_e4566.zzzz != _e4570.xxxx)) {
let _e4574: vec4<f32> = temporary4_;
temporary4_.z = _e4574.yyyy.x;
let _e4578: vec4<f32> = temporary3_;
let _e4579: vec4<f32> = _e4578.xyzz;
temporary6_.x = _e4579.x;
temporary6_.y = _e4579.y;
temporary6_.z = _e4579.z;
let _e4588: vec4<f32> = constant_registers[8u];
let _e4589: vec4<f32> = _e4588.xyzz;
temporary7_.x = _e4589.x;
temporary7_.y = _e4589.y;
temporary7_.z = _e4589.z;
let _e4598: vec4<f32> = constant_registers[18u];
temporary1_.z = _e4598.xxxx.x;
}
let _e4602: vec4<f32> = temporary2_;
let _e4603: vec4<f32> = _e4602.xyzz;
temporary15_.x = _e4603.x;
temporary15_.y = _e4603.y;
temporary15_.z = _e4603.z;
let _e4610: vec4<f32> = temporary9_;
let _e4611: vec4<f32> = _e4610.xyzz;
temporary17_.x = _e4611.x;
temporary17_.y = _e4611.y;
temporary17_.z = _e4611.z;
let _e4620: vec4<f32> = constant_registers[10u];
let _e4621: vec4<f32> = _e4620.xyzz;
temporary18_.x = _e4621.x;
temporary18_.y = _e4621.y;
temporary18_.z = _e4621.z;
let _e4630: vec4<f32> = constant_registers[12u];
temporary2_.w = _e4630.xxxx.x;
let _e4634: vec4<f32> = temporary3_;
let _e4635: vec4<f32> = _e4634.xyzz;
temporary19_.x = _e4635.x;
temporary19_.y = _e4635.y;
temporary19_.z = _e4635.z;
let _e4644: vec4<f32> = constant_registers[17u];
temporary13_.x = _e4644.wwww.x;
let _e4648: vec4<f32> = temporary15_;
let _e4650: vec4<f32> = temporary18_;
let _e4652: vec4<f32> = (_e4648.xyzz - _e4650.xyzz);
temporary12_.x = _e4652.x;
temporary12_.y = _e4652.y;
temporary12_.z = _e4652.z;
let _e4659: vec4<f32> = temporary12_;
let _e4661: vec4<f32> = temporary17_;
temporary13_.y = dot(_e4659.xyz, _e4661.xyz);
let _e4665: vec4<f32> = temporary13_;
let _e4667: vec4<f32> = temporary13_;
temporary3_.w = (_e4665.yyyy * _e4667.yyyy).x;
let _e4672: vec4<f32> = temporary12_;
let _e4674: vec4<f32> = temporary12_;
temporary14_.x = dot(_e4672.xyz, _e4674.xyz);
let _e4678: vec4<f32> = temporary3_;
let _e4680: vec4<f32> = temporary14_;
temporary14_.y = (_e4678.wwww - _e4680.xxxx).x;
let _e4685: vec4<f32> = temporary2_;
let _e4687: vec4<f32> = temporary2_;
temporary14_.z = (_e4685.wwww * _e4687.wwww).x;
let _e4692: vec4<f32> = temporary14_;
let _e4694: vec4<f32> = temporary14_;
temporary13_.z = (_e4692.yyyy + _e4694.zzzz).x;
let _e4701: vec4<f32> = constant_registers[16u];
let _e4703: vec4<f32> = temporary13_;
temporary3_.w = vec4<f32>((_e4701.xxxx < _e4703.zzzz)).x;
let _e4709: vec4<f32> = temporary3_;
let _e4713: vec4<f32> = constant_registers[16u];
if all((_e4709.wwww != _e4713.xxxx)) {
let _e4717: vec4<f32> = temporary13_;
temporary13_.z = sqrt(_e4717.zzzz).x;
let _e4722: vec4<f32> = temporary13_;
temporary14_.x = -(_e4722.yyyy).x;
let _e4727: vec4<f32> = temporary14_;
let _e4729: vec4<f32> = temporary13_;
temporary14_.y = (_e4727.xxxx - _e4729.zzzz).x;
let _e4734: vec4<f32> = temporary14_;
temporary3_.w = _e4734.yyyy.x;
let _e4740: vec4<f32> = constant_registers[16u];
let _e4742: vec4<f32> = temporary3_;
temporary14_.x = vec4<f32>((_e4740.xxxx < _e4742.wwww)).x;
let _e4748: vec4<f32> = temporary14_;
let _e4752: vec4<f32> = constant_registers[16u];
if all((_e4748.xxxx != _e4752.xxxx)) {
let _e4756: vec4<f32> = temporary3_;
temporary13_.x = _e4756.wwww.x;
let _e4760: vec4<f32> = temporary17_;
let _e4762: vec4<f32> = temporary3_;
let _e4764: vec4<f32> = (_e4760.xyzz * _e4762.wwww);
temporary14_.x = _e4764.x;
temporary14_.y = _e4764.y;
temporary14_.z = _e4764.z;
let _e4771: vec4<f32> = temporary15_;
let _e4773: vec4<f32> = temporary14_;
let _e4775: vec4<f32> = (_e4771.xyzz + _e4773.xyzz);
temporary20_.x = _e4775.x;
temporary20_.y = _e4775.y;
temporary20_.z = _e4775.z;
let _e4782: vec4<f32> = temporary20_;
let _e4784: vec4<f32> = temporary18_;
let _e4786: vec4<f32> = (_e4782.xyzz - _e4784.xyzz);
temporary16_.x = _e4786.x;
temporary16_.y = _e4786.y;
temporary16_.z = _e4786.z;
let _e4793: vec4<f32> = temporary16_;
let _e4795: vec3<f32> = normalize(_e4793.xyz);
temporary19_.x = _e4795.x;
temporary19_.y = _e4795.y;
temporary19_.z = _e4795.z;
}
}
let _e4802: vec4<f32> = temporary13_;
temporary4_.y = _e4802.xxxx.x;
let _e4806: vec4<f32> = temporary19_;
let _e4807: vec4<f32> = _e4806.xyzz;
temporary3_.x = _e4807.x;
temporary3_.y = _e4807.y;
temporary3_.z = _e4807.z;
let _e4814: vec4<f32> = temporary4_;
let _e4816: vec4<f32> = temporary4_;
temporary8_.z = vec4<f32>((_e4814.yyyy < _e4816.zzzz)).x;
let _e4822: vec4<f32> = temporary8_;
let _e4826: vec4<f32> = constant_registers[16u];
if all((_e4822.zzzz != _e4826.xxxx)) {
let _e4830: vec4<f32> = temporary4_;
temporary4_.z = _e4830.yyyy.x;
let _e4834: vec4<f32> = temporary3_;
let _e4835: vec4<f32> = _e4834.xyzz;
temporary6_.x = _e4835.x;
temporary6_.y = _e4835.y;
temporary6_.z = _e4835.z;
let _e4844: vec4<f32> = constant_registers[11u];
let _e4845: vec4<f32> = _e4844.xyzz;
temporary7_.x = _e4845.x;
temporary7_.y = _e4845.y;
temporary7_.z = _e4845.z;
let _e4854: vec4<f32> = constant_registers[18u];
temporary1_.z = _e4854.xxxx.x;
}
let _e4858: vec4<f32> = temporary11_;
let _e4862: vec4<f32> = constant_registers[16u];
temporary11_.y = (_e4858.yyyy + _e4862.yyyy).x;
let _e4867: vec4<f32> = temporary1_;
let _e4871: vec4<f32> = constant_registers[16u];
temporary8_.z = vec4<f32>((_e4867.zzzz == _e4871.xxxx)).x;
let _e4877: vec4<f32> = temporary8_;
let _e4881: vec4<f32> = constant_registers[16u];
if all((_e4877.zzzz != _e4881.xxxx)) {
let _e4887: vec4<f32> = constant_registers[16u];
temporary11_.z = _e4887.yyyy.x;
} else {
let _e4891: vec4<f32> = temporary9_;
let _e4893: vec4<f32> = temporary4_;
let _e4895: vec4<f32> = (_e4891.xyzz * _e4893.zzzz);
temporary15_.x = _e4895.x;
temporary15_.y = _e4895.y;
temporary15_.z = _e4895.z;
let _e4902: vec4<f32> = temporary2_;
let _e4904: vec4<f32> = temporary15_;
let _e4906: vec4<f32> = (_e4902.xyzz + _e4904.xyzz);
temporary2_.x = _e4906.x;
temporary2_.y = _e4906.y;
temporary2_.z = _e4906.z;
let _e4913: vec4<f32> = temporary9_;
let _e4915: vec4<f32> = temporary6_;
temporary8_.z = dot(_e4913.xyz, _e4915.xyz);
let _e4919: vec4<f32> = temporary8_;
let _e4923: vec4<f32> = constant_registers[18u];
temporary2_.w = (_e4919.zzzz * _e4923.xxxx).x;
let _e4928: vec4<f32> = temporary2_;
let _e4930: vec4<f32> = temporary6_;
let _e4932: vec4<f32> = (_e4928.wwww * _e4930.xyzz);
temporary15_.x = _e4932.x;
temporary15_.y = _e4932.y;
temporary15_.z = _e4932.z;
let _e4939: vec4<f32> = temporary9_;
let _e4941: vec4<f32> = temporary15_;
let _e4943: vec4<f32> = (_e4939.xyzz - _e4941.xyzz);
temporary9_.x = _e4943.x;
temporary9_.y = _e4943.y;
temporary9_.z = _e4943.z;
let _e4950: vec4<f32> = temporary9_;
let _e4954: vec4<f32> = constant_registers[18u];
let _e4956: vec4<f32> = (_e4950.xyzz * _e4954.yyyy);
temporary15_.x = _e4956.x;
temporary15_.y = _e4956.y;
temporary15_.z = _e4956.z;
let _e4963: vec4<f32> = temporary2_;
let _e4965: vec4<f32> = temporary15_;
let _e4967: vec4<f32> = (_e4963.xyzz + _e4965.xyzz);
temporary2_.x = _e4967.x;
temporary2_.y = _e4967.y;
temporary2_.z = _e4967.z;
let _e4976: vec4<f32> = constant_registers[15u];
let _e4978: vec4<f32> = temporary2_;
let _e4980: vec4<f32> = (_e4976.xyzz - _e4978.xyzz);
temporary5_.x = _e4980.x;
temporary5_.y = _e4980.y;
temporary5_.z = _e4980.z;
let _e4987: vec4<f32> = temporary5_;
let _e4989: vec3<f32> = normalize(_e4987.xyz);
temporary10_.x = _e4989.x;
temporary10_.y = _e4989.y;
temporary10_.z = _e4989.z;
let _e4996: vec4<f32> = temporary5_;
let _e4998: vec4<f32> = temporary5_;
temporary8_.z = dot(_e4996.xyz, _e4998.xyz);
let _e5002: vec4<f32> = temporary8_;
temporary1_.y = sqrt(_e5002.zzzz).x;
let _e5007: vec4<f32> = temporary6_;
let _e5009: vec4<f32> = temporary10_;
temporary8_.z = dot(_e5007.xyz, _e5009.xyz);
let _e5013: vec4<f32> = temporary8_;
temporary2_.w = saturate(_e5013.zzzz).x;
let _e5018: vec4<f32> = temporary1_;
let _e5020: vec4<f32> = temporary1_;
temporary15_.x = (_e5018.yyyy * _e5020.yyyy).x;
let _e5025: vec4<f32> = temporary15_;
let _e5029: vec4<f32> = constant_registers[18u];
temporary15_.y = (_e5025.xxxx * _e5029.zzzz).x;
let _e5036: vec4<f32> = constant_registers[18u];
let _e5038: vec4<f32> = temporary15_;
temporary15_.z = (_e5036.wwww + _e5038.yyyy).x;
let _e5043: vec4<f32> = temporary2_;
let _e5045: vec4<f32> = temporary15_;
temporary1_.x = (_e5043.wwww / _e5045.zzzz).x;
let _e5050: vec4<f32> = temporary1_;
temporary8_.x = _e5050.xxxx.x;
let _e5056: vec4<f32> = constant_registers[6u];
temporary2_.w = _e5056.xxxx.x;
let _e5062: vec4<f32> = constant_registers[17u];
temporary19_.x = _e5062.wwww.x;
let _e5066: vec4<f32> = temporary2_;
let _e5070: vec4<f32> = constant_registers[4u];
let _e5072: vec4<f32> = (_e5066.xyzz - _e5070.xyzz);
temporary13_.x = _e5072.x;
temporary13_.y = _e5072.y;
temporary13_.z = _e5072.z;
let _e5079: vec4<f32> = temporary13_;
let _e5081: vec4<f32> = temporary10_;
temporary19_.y = dot(_e5079.xyz, _e5081.xyz);
let _e5085: vec4<f32> = temporary19_;
let _e5087: vec4<f32> = temporary19_;
temporary1_.w = (_e5085.yyyy * _e5087.yyyy).x;
let _e5092: vec4<f32> = temporary13_;
let _e5094: vec4<f32> = temporary13_;
temporary12_.x = dot(_e5092.xyz, _e5094.xyz);
let _e5098: vec4<f32> = temporary1_;
let _e5100: vec4<f32> = temporary12_;
temporary12_.y = (_e5098.wwww - _e5100.xxxx).x;
let _e5105: vec4<f32> = temporary2_;
let _e5107: vec4<f32> = temporary2_;
temporary12_.z = (_e5105.wwww * _e5107.wwww).x;
let _e5112: vec4<f32> = temporary12_;
let _e5114: vec4<f32> = temporary12_;
temporary19_.z = (_e5112.yyyy + _e5114.zzzz).x;
let _e5121: vec4<f32> = constant_registers[16u];
let _e5123: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e5121.xxxx < _e5123.zzzz)).x;
let _e5129: vec4<f32> = temporary1_;
let _e5133: vec4<f32> = constant_registers[16u];
if all((_e5129.wwww != _e5133.xxxx)) {
let _e5137: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e5137.zzzz).x;
let _e5142: vec4<f32> = temporary19_;
temporary12_.x = -(_e5142.yyyy).x;
let _e5147: vec4<f32> = temporary12_;
let _e5149: vec4<f32> = temporary19_;
temporary1_.w = (_e5147.xxxx - _e5149.zzzz).x;
let _e5156: vec4<f32> = constant_registers[16u];
let _e5158: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e5156.xxxx < _e5158.wwww)).x;
let _e5164: vec4<f32> = temporary12_;
let _e5168: vec4<f32> = constant_registers[16u];
if all((_e5164.xxxx != _e5168.xxxx)) {
let _e5172: vec4<f32> = temporary1_;
temporary19_.x = _e5172.wwww.x;
}
}
let _e5176: vec4<f32> = temporary19_;
let _e5178: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e5176.xxxx < _e5178.yyyy)).x;
let _e5184: vec4<f32> = temporary8_;
let _e5188: vec4<f32> = constant_registers[16u];
if all((_e5184.zzzz != _e5188.xxxx)) {
let _e5194: vec4<f32> = constant_registers[16u];
temporary8_.x = _e5194.xxxx.x;
}
let _e5200: vec4<f32> = constant_registers[9u];
temporary2_.w = _e5200.xxxx.x;
let _e5206: vec4<f32> = constant_registers[17u];
temporary19_.x = _e5206.wwww.x;
let _e5210: vec4<f32> = temporary2_;
let _e5214: vec4<f32> = constant_registers[7u];
let _e5216: vec4<f32> = (_e5210.xyzz - _e5214.xyzz);
temporary13_.x = _e5216.x;
temporary13_.y = _e5216.y;
temporary13_.z = _e5216.z;
let _e5223: vec4<f32> = temporary13_;
let _e5225: vec4<f32> = temporary10_;
temporary19_.y = dot(_e5223.xyz, _e5225.xyz);
let _e5229: vec4<f32> = temporary19_;
let _e5231: vec4<f32> = temporary19_;
temporary1_.w = (_e5229.yyyy * _e5231.yyyy).x;
let _e5236: vec4<f32> = temporary13_;
let _e5238: vec4<f32> = temporary13_;
temporary12_.x = dot(_e5236.xyz, _e5238.xyz);
let _e5242: vec4<f32> = temporary1_;
let _e5244: vec4<f32> = temporary12_;
temporary12_.y = (_e5242.wwww - _e5244.xxxx).x;
let _e5249: vec4<f32> = temporary2_;
let _e5251: vec4<f32> = temporary2_;
temporary12_.z = (_e5249.wwww * _e5251.wwww).x;
let _e5256: vec4<f32> = temporary12_;
let _e5258: vec4<f32> = temporary12_;
temporary19_.z = (_e5256.yyyy + _e5258.zzzz).x;
let _e5265: vec4<f32> = constant_registers[16u];
let _e5267: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e5265.xxxx < _e5267.zzzz)).x;
let _e5273: vec4<f32> = temporary1_;
let _e5277: vec4<f32> = constant_registers[16u];
if all((_e5273.wwww != _e5277.xxxx)) {
let _e5281: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e5281.zzzz).x;
let _e5286: vec4<f32> = temporary19_;
temporary12_.x = -(_e5286.yyyy).x;
let _e5291: vec4<f32> = temporary12_;
let _e5293: vec4<f32> = temporary19_;
temporary1_.w = (_e5291.xxxx - _e5293.zzzz).x;
let _e5300: vec4<f32> = constant_registers[16u];
let _e5302: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e5300.xxxx < _e5302.wwww)).x;
let _e5308: vec4<f32> = temporary12_;
let _e5312: vec4<f32> = constant_registers[16u];
if all((_e5308.xxxx != _e5312.xxxx)) {
let _e5316: vec4<f32> = temporary1_;
temporary19_.x = _e5316.wwww.x;
}
}
let _e5320: vec4<f32> = temporary19_;
let _e5322: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e5320.xxxx < _e5322.yyyy)).x;
let _e5328: vec4<f32> = temporary8_;
let _e5332: vec4<f32> = constant_registers[16u];
if all((_e5328.zzzz != _e5332.xxxx)) {
let _e5338: vec4<f32> = constant_registers[16u];
temporary8_.x = _e5338.xxxx.x;
}
let _e5342: vec4<f32> = temporary2_;
let _e5343: vec4<f32> = _e5342.xyzz;
temporary15_.x = _e5343.x;
temporary15_.y = _e5343.y;
temporary15_.z = _e5343.z;
let _e5350: vec4<f32> = temporary10_;
let _e5351: vec4<f32> = _e5350.xyzz;
temporary17_.x = _e5351.x;
temporary17_.y = _e5351.y;
temporary17_.z = _e5351.z;
let _e5360: vec4<f32> = constant_registers[12u];
temporary2_.w = _e5360.xxxx.x;
let _e5366: vec4<f32> = constant_registers[17u];
temporary19_.x = _e5366.wwww.x;
let _e5370: vec4<f32> = temporary15_;
let _e5374: vec4<f32> = constant_registers[10u];
let _e5376: vec4<f32> = (_e5370.xyzz - _e5374.xyzz);
temporary13_.x = _e5376.x;
temporary13_.y = _e5376.y;
temporary13_.z = _e5376.z;
let _e5383: vec4<f32> = temporary13_;
let _e5385: vec4<f32> = temporary17_;
temporary19_.y = dot(_e5383.xyz, _e5385.xyz);
let _e5389: vec4<f32> = temporary19_;
let _e5391: vec4<f32> = temporary19_;
temporary1_.w = (_e5389.yyyy * _e5391.yyyy).x;
let _e5396: vec4<f32> = temporary13_;
let _e5398: vec4<f32> = temporary13_;
temporary12_.x = dot(_e5396.xyz, _e5398.xyz);
let _e5402: vec4<f32> = temporary1_;
let _e5404: vec4<f32> = temporary12_;
temporary12_.y = (_e5402.wwww - _e5404.xxxx).x;
let _e5409: vec4<f32> = temporary2_;
let _e5411: vec4<f32> = temporary2_;
temporary12_.z = (_e5409.wwww * _e5411.wwww).x;
let _e5416: vec4<f32> = temporary12_;
let _e5418: vec4<f32> = temporary12_;
temporary19_.z = (_e5416.yyyy + _e5418.zzzz).x;
let _e5425: vec4<f32> = constant_registers[16u];
let _e5427: vec4<f32> = temporary19_;
temporary1_.w = vec4<f32>((_e5425.xxxx < _e5427.zzzz)).x;
let _e5433: vec4<f32> = temporary1_;
let _e5437: vec4<f32> = constant_registers[16u];
if all((_e5433.wwww != _e5437.xxxx)) {
let _e5441: vec4<f32> = temporary19_;
temporary19_.z = sqrt(_e5441.zzzz).x;
let _e5446: vec4<f32> = temporary19_;
temporary12_.x = -(_e5446.yyyy).x;
let _e5451: vec4<f32> = temporary12_;
let _e5453: vec4<f32> = temporary19_;
temporary1_.w = (_e5451.xxxx - _e5453.zzzz).x;
let _e5460: vec4<f32> = constant_registers[16u];
let _e5462: vec4<f32> = temporary1_;
temporary12_.x = vec4<f32>((_e5460.xxxx < _e5462.wwww)).x;
let _e5468: vec4<f32> = temporary12_;
let _e5472: vec4<f32> = constant_registers[16u];
if all((_e5468.xxxx != _e5472.xxxx)) {
let _e5476: vec4<f32> = temporary1_;
temporary19_.x = _e5476.wwww.x;
}
}
let _e5480: vec4<f32> = temporary19_;
let _e5482: vec4<f32> = temporary1_;
temporary8_.z = vec4<f32>((_e5480.xxxx < _e5482.yyyy)).x;
let _e5488: vec4<f32> = temporary8_;
let _e5492: vec4<f32> = constant_registers[16u];
if all((_e5488.zzzz != _e5492.xxxx)) {
let _e5498: vec4<f32> = constant_registers[16u];
temporary8_.x = _e5498.xxxx.x;
}
let _e5502: vec4<f32> = temporary6_;
temporary8_.z = saturate(_e5502.yyyy).x;
let _e5507: vec4<f32> = temporary8_;
let _e5511: vec4<f32> = constant_registers[19u];
temporary2_.w = (_e5507.zzzz * _e5511.xxxx).x;
let _e5516: vec4<f32> = temporary8_;
let _e5518: vec4<f32> = temporary2_;
temporary8_.x = (_e5516.xxxx + _e5518.wwww).x;
let _e5523: vec4<f32> = temporary8_;
let _e5527: vec4<f32> = constant_registers[19u];
temporary8_.z = (_e5523.xxxx * _e5527.yyyy).x;
let _e5534: vec4<f32> = constant_registers[19u];
let _e5536: vec4<f32> = temporary8_;
temporary2_.w = (_e5534.zzzz + _e5536.zzzz).x;
let _e5541: vec4<f32> = temporary2_;
temporary8_.y = _e5541.wwww.x;
let _e5545: vec4<f32> = temporary1_;
let _e5549: vec4<f32> = constant_registers[16u];
temporary8_.z = vec4<f32>((_e5545.zzzz == _e5549.yyyy)).x;
let _e5555: vec4<f32> = temporary8_;
let _e5559: vec4<f32> = constant_registers[16u];
if all((_e5555.zzzz != _e5559.xxxx)) {
let _e5563: vec4<f32> = temporary2_;
temporary8_.z = fract(_e5563.xxxx).x;
let _e5568: vec4<f32> = temporary2_;
let _e5570: vec4<f32> = temporary8_;
temporary2_.w = (_e5568.xxxx - _e5570.zzzz).x;
let _e5575: vec4<f32> = temporary2_;
temporary15_.x = fract(_e5575.zzzz).x;
let _e5580: vec4<f32> = temporary2_;
let _e5582: vec4<f32> = temporary15_;
temporary15_.y = (_e5580.zzzz - _e5582.xxxx).x;
let _e5587: vec4<f32> = temporary2_;
let _e5589: vec4<f32> = temporary15_;
temporary15_.z = (_e5587.wwww + _e5589.yyyy).x;
let _e5594: vec4<f32> = temporary15_;
let _e5598: vec4<f32> = constant_registers[18u];
temporary1_.x = (_e5594.zzzz / _e5598.xxxx).x;
let _e5603: vec4<f32> = temporary1_;
temporary17_.x = fract(_e5603.xxxx).x;
let _e5608: vec4<f32> = temporary17_;
let _e5612: vec4<f32> = constant_registers[18u];
temporary17_.y = (_e5608.xxxx * _e5612.xxxx).x;
let _e5617: vec4<f32> = temporary17_;
let _e5621: vec4<f32> = constant_registers[16u];
temporary17_.z = vec4<f32>((_e5617.yyyy == _e5621.yyyy)).x;
let _e5627: vec4<f32> = temporary17_;
let _e5631: vec4<f32> = constant_registers[16u];
if all((_e5627.zzzz != _e5631.xxxx)) {
let _e5637: vec4<f32> = constant_registers[13u];
let _e5639: vec4<f32> = temporary8_;
let _e5641: vec4<f32> = (_e5637.xyzz * _e5639.yyyy);
temporary15_.x = _e5641.x;
temporary15_.y = _e5641.y;
temporary15_.z = _e5641.z;
let _e5648: vec4<f32> = temporary0_;
let _e5650: vec4<f32> = temporary15_;
let _e5652: vec4<f32> = (_e5648.xyzz + _e5650.xyzz);
temporary0_.x = _e5652.x;
temporary0_.y = _e5652.y;
temporary0_.z = _e5652.z;
} else {
let _e5661: vec4<f32> = constant_registers[14u];
let _e5663: vec4<f32> = temporary8_;
let _e5665: vec4<f32> = (_e5661.xyzz * _e5663.yyyy);
temporary15_.x = _e5665.x;
temporary15_.y = _e5665.y;
temporary15_.z = _e5665.z;
let _e5672: vec4<f32> = temporary0_;
let _e5674: vec4<f32> = temporary15_;
let _e5676: vec4<f32> = (_e5672.xyzz + _e5674.xyzz);
temporary0_.x = _e5676.x;
temporary0_.y = _e5676.y;
temporary0_.z = _e5676.z;
}
}
let _e5683: vec4<f32> = temporary1_;
let _e5687: vec4<f32> = constant_registers[18u];
temporary8_.z = vec4<f32>((_e5683.zzzz == _e5687.xxxx)).x;
let _e5693: vec4<f32> = temporary8_;
let _e5697: vec4<f32> = constant_registers[16u];
if all((_e5693.zzzz != _e5697.xxxx)) {
let _e5701: vec4<f32> = temporary7_;
let _e5703: vec4<f32> = temporary8_;
let _e5705: vec4<f32> = (_e5701.xyzz * _e5703.yyyy);
temporary15_.x = _e5705.x;
temporary15_.y = _e5705.y;
temporary15_.z = _e5705.z;
let _e5712: vec4<f32> = temporary0_;
let _e5714: vec4<f32> = temporary15_;
let _e5716: vec4<f32> = (_e5712.xyzz + _e5714.xyzz);
temporary0_.x = _e5716.x;
temporary0_.y = _e5716.y;
temporary0_.z = _e5716.z;
}
}
}
let _e5723: vec4<f32> = temporary9_;
let _e5727: vec4<f32> = textureSample(texture0_, sampler2_, _e5723.xyzz.xyz);
temporary1_ = _e5727;
let _e5728: vec4<f32> = temporary11_;
let _e5732: vec4<f32> = constant_registers[16u];
if all((_e5728.zzzz != _e5732.xxxx)) {
let _e5736: vec4<f32> = temporary0_;
let _e5738: vec4<f32> = temporary1_;
let _e5740: vec4<f32> = (_e5736.xyzz + _e5738.xyzz);
temporary0_.x = _e5740.x;
temporary0_.y = _e5740.y;
temporary0_.z = _e5740.z;
}
let _e5747: vec4<f32> = temporary0_;
let _e5749: vec4<f32> = temporary11_;
let _e5751: vec4<f32> = (_e5747.xyzz / _e5749.yyyy);
temporary0_.x = _e5751.x;
temporary0_.y = _e5751.y;
temporary0_.z = _e5751.z;
let _e5758: vec4<f32> = temporary0_;
dest_temp = _e5758;
let _e5759: vec4<f32> = dest_temp;
return FragmentOutput(_e5759);
}
Reference in New Issue View Git Blame Copy Permalink