bardd commited on
Commit
cef80f7
·
verified ·
1 Parent(s): 6d45d6d

Add files using upload-large-folder tool

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. b/8b0b5899ed/audio-worklet.js +29 -0
  2. b/8b0b5899ed/game.js +0 -0
  3. b/8b0b5899ed/io_worker.js +644 -0
  4. b/8b0b5899ed/loader.js +146 -0
  5. b/8b0b5899ed/shaders/00241e5e1825408e.consts.json +1 -0
  6. b/8b0b5899ed/shaders/00241e5e1825408e.wgsl +95 -0
  7. b/8b0b5899ed/shaders/0030c87264713865.wgsl +89 -0
  8. b/8b0b5899ed/shaders/0035f4d295d61e54.wgsl +188 -0
  9. b/8b0b5899ed/shaders/00395a471b59502d.consts.json +1 -0
  10. b/8b0b5899ed/shaders/00395a471b59502d.wgsl +810 -0
  11. b/8b0b5899ed/shaders/003e341f763296f0.wgsl +106 -0
  12. b/8b0b5899ed/shaders/00434aea0a2de164.wgsl +189 -0
  13. b/8b0b5899ed/shaders/0061ed6188dc3969.wgsl +26 -0
  14. b/8b0b5899ed/shaders/006957a1aede62d1.wgsl +497 -0
  15. b/8b0b5899ed/shaders/006bd653d319ed4e.wgsl +53 -0
  16. b/8b0b5899ed/shaders/007089a30fcd7fd8.consts.json +1 -0
  17. b/8b0b5899ed/shaders/007089a30fcd7fd8.wgsl +230 -0
  18. b/8b0b5899ed/shaders/00716d7357599de4.wgsl +100 -0
  19. b/8b0b5899ed/shaders/007db7c8f96e98aa.wgsl +333 -0
  20. b/8b0b5899ed/shaders/0081a738fe9b7258.wgsl +28 -0
  21. b/8b0b5899ed/shaders/0083d1a975976c79.wgsl +145 -0
  22. b/8b0b5899ed/shaders/00845f3f8756888a.wgsl +89 -0
  23. b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.consts.json +1 -0
  24. b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.wgsl +1213 -0
  25. b/8b0b5899ed/shaders/008de4769b557904.wgsl +75 -0
  26. b/8b0b5899ed/shaders/00928753ac46ae0c.wgsl +25 -0
  27. b/8b0b5899ed/shaders/00c3781b22af3678.consts.json +1 -0
  28. b/8b0b5899ed/shaders/00c3781b22af3678.wgsl +957 -0
  29. b/8b0b5899ed/shaders/00c5eac137500fba.consts.json +1 -0
  30. b/8b0b5899ed/shaders/00c5eac137500fba.wgsl +660 -0
  31. b/8b0b5899ed/shaders/00dfd3a1331419c1.consts.json +1 -0
  32. b/8b0b5899ed/shaders/00dfd3a1331419c1.wgsl +957 -0
  33. b/8b0b5899ed/shaders/00e6b4c4b7cbbb2d.wgsl +415 -0
  34. b/8b0b5899ed/shaders/00edbec406bcb4a0.wgsl +306 -0
  35. b/8b0b5899ed/shaders/010379dc47445f90.consts.json +1 -0
  36. b/8b0b5899ed/shaders/010379dc47445f90.wgsl +276 -0
  37. b/8b0b5899ed/shaders/0105421a564158db.wgsl +147 -0
  38. b/8b0b5899ed/shaders/010e1159a3a24d20.wgsl +56 -0
  39. b/8b0b5899ed/shaders/01175517e8e0e635.consts.json +1 -0
  40. b/8b0b5899ed/shaders/01175517e8e0e635.wgsl +927 -0
  41. b/8b0b5899ed/shaders/01179bc0ec7d3e35.wgsl +132 -0
  42. b/8b0b5899ed/shaders/011e02044e8ffb82.consts.json +1 -0
  43. b/8b0b5899ed/shaders/011e02044e8ffb82.wgsl +1233 -0
  44. b/8b0b5899ed/shaders/011f3f3fcac784b6.consts.json +1 -0
  45. b/8b0b5899ed/shaders/011f3f3fcac784b6.wgsl +428 -0
  46. b/8b0b5899ed/shaders/0138abd67681916a.wgsl +56 -0
  47. b/8b0b5899ed/shaders/0139fe33bda035a7.consts.json +1 -0
  48. b/8b0b5899ed/shaders/0139fe33bda035a7.wgsl +742 -0
  49. b/8b0b5899ed/shaders/013d56caa6391a99.consts.json +1 -0
  50. b/8b0b5899ed/shaders/013d56caa6391a99.wgsl +1239 -0
b/8b0b5899ed/audio-worklet.js ADDED
@@ -0,0 +1,29 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // AudioWorklet processor: plays the engine mixer's stereo output from the ring buffer in the shared wasm memory
2
+ // (platform/audio/browser_audio_wasm.cpp). Header (uint32 words): write, read, capacity, heartbeat; float data (interleaved L R) at byte 64.
3
+ class GameAudio extends AudioWorkletProcessor {
4
+ constructor(options) {
5
+ super();
6
+ const { memory, ring, capacity } = options.processorOptions;
7
+ this.hdr = new Int32Array(memory.buffer, ring, 8); // word 4: peak sample since the page last looked (x 1e6), diagnostics
8
+ this.data = new Float32Array(memory.buffer, ring + 64, capacity * 2);
9
+ this.mask = capacity - 1;
10
+ }
11
+ process(inputs, outputs) {
12
+ const out = outputs[0], left = out[0], right = out[1] || out[0], n = left.length;
13
+ const read = Atomics.load(this.hdr, 1), write = Atomics.load(this.hdr, 0);
14
+ const avail = (write - read) >>> 0, take = Math.min(avail, n);
15
+ for (let i = 0; i < take; i++) {
16
+ const at = ((read + i) & this.mask) * 2;
17
+ left[i] = this.data[at];
18
+ right[i] = this.data[at + 1];
19
+ }
20
+ let peak = 0;
21
+ for (let i = 0; i < take; i++) peak = Math.max(peak, Math.abs(left[i]), Math.abs(right[i]));
22
+ if (peak > 0) Atomics.store(this.hdr, 4, Math.max(Atomics.load(this.hdr, 4), (peak * 1e6) | 0));
23
+ for (let i = take; i < n; i++) { left[i] = 0; right[i] = 0; } // underrun: silence
24
+ Atomics.store(this.hdr, 1, (read + take) | 0);
25
+ Atomics.add(this.hdr, 3, 1);
26
+ return true;
27
+ }
28
+ }
29
+ registerProcessor('game-audio', GameAudio);
b/8b0b5899ed/game.js ADDED
The diff for this file is too large to render. See raw diff
 
b/8b0b5899ed/io_worker.js ADDED
@@ -0,0 +1,644 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // HTTP read worker + persistent block cache: serves every file read of the engine threads (platform/file/httpfs_wasm.cpp).
2
+ //
3
+ // Engine threads used to read with their own synchronous XMLHttpRequest, behind a service worker that cached the blocks. Each response is a fresh ArrayBuffer (plus the
4
+ // request's own copy of the body) that the browser frees only when that worker's GC runs, and an engine thread that is mostly inside wasm or blocked in Atomics.wait
5
+ // almost never does: the bytes read piled up as ~1.5 GB of renderer memory (reproduced with 30 blank workers reading 1.8 GB: 3.6 GB working set, whatever is done to
6
+ // the buffers afterwards), and the service worker added another ~0.9 GB of its own.
7
+ // This worker has an event loop and streams every response chunk by chunk straight into a persistent store in the Origin Private File System; reads are then served
8
+ // from the store into the shared wasm heap. No JavaScript buffers are involved, so nothing has to be garbage collected.
9
+ //
10
+ // Store: `store.bin` is append-only. A range fetch reserves room at the end (whole 256 KB blocks of the file), streams the body into it, and records where every block
11
+ // went in `journal.bin` (16-byte entries: file id, block, offset low, offset high) after the data has been flushed. The journal header carries the manifest version;
12
+ // another version (or a foreign magic) starts an empty store. Without OPFS (or when another tab has the store open: sync access handles are exclusive) blocks are
13
+ // only kept in a 48 MB memory cache.
14
+ //
15
+ // Protocol with the engine threads (all in the shared wasm heap, `table` = address of an Int32 table, see httpfs_wasm.cpp):
16
+ // header: [0] doorbell (incremented by every request or hint), [1] slot counter (each engine thread takes one slot on its first read),
17
+ // [2] word offset of the hint ring, [3] its entries, [4] hints claimed by the engine, [5] hints consumed here
18
+ // slot i (16 words at 16 + 16*i): [0] state 0 idle / 1 requested / 3 taken by this worker / 2 done, [1] file id, [2..3] offset, [4..5] destination address, [6] length, [7] result (bytes or -1)
19
+ // hint ring (4 words per entry): file id, offset low, offset high, length (written last; 0 = free): a read the engine has queued and will perform later, one at a time (the
20
+ // streamer's single reader thread); fetching it now, HINT_PAR at a time, turns ~3 reads/s (one round trip each) into as many as the link carries. See drainHints.
21
+ 'use strict';
22
+ let mem, HEAP32, HEAPU8, table;
23
+ let files = [], base = '', bc = null, pendingBytes = 0, lastPost = 0, noHints = false, dataQuery = ''; // noHints: ?nohints=1 (diagnostics), see drainHints; dataQuery: ?v=<manifest version> on every data URL
24
+ // Store block size 4 KB. The engine mounts ~1,200 archives at boot and reads only each one's table of contents (16 bytes, the entries, the names: median 3 KB, 4.9 MB for all
25
+ // of them, measured with ?trace=1); fetching 256 KB (first version) or 16 KB blocks plus a growing read-ahead (second) made the boot download 25x larger for those files.
26
+ // Read-ahead now only follows *large* sequential reads (streamed resources), see serve().
27
+ const BS = 4096, MAX_RUN = 256, MAX_AHEAD = 512 * 1024, FIRST_AHEAD = 64 * 1024, AHEAD_MIN_READ = 65536;
28
+ const MBS = 262144; // block size of the memory-only fallback (no store)
29
+ let remoteLog = false; // ?log=1 on the page (loader.js passes it in the init message): this worker's diagnostics go to the dev server
30
+ function log(text) { if (remoteLog) fetch('/log', { method: 'POST', body: text }).catch(() => {}); }
31
+
32
+ const pathIndex = new Map();
33
+ const fileBytes = new Map(); // diagnostics: network bytes per file path, top of the list goes to the server log every 25 MB
34
+ let statTotal = 0, statNext = 25 * 1048576, statT0 = performance.now();
35
+ function tally(f, n) {
36
+ fileBytes.set(f.path, (fileBytes.get(f.path) || 0) + n);
37
+ statTotal += n;
38
+ if (statTotal >= statNext) {
39
+ statNext += 25 * 1048576;
40
+ const top = [...fileBytes].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([p, b]) => p.split('/').slice(-2).join('/') + ' ' + (b / 1048576 | 0) + 'MB').join(' | ');
41
+ const ext = new Map(), sizes = [0, 0, 0, 0]; // bytes by extension; bytes by fetched amount per file: <1 MB, <8 MB, <32 MB, more
42
+ for (const [pth, b] of fileBytes) {
43
+ const e = (pth.match(/\.(\w+)$/) || [, '?'])[1]; ext.set(e, (ext.get(e) || 0) + b);
44
+ sizes[b < 1048576 ? 0 : b < 8388608 ? 1 : b < 33554432 ? 2 : 3] += b;
45
+ }
46
+ log('[io] by extension: ' + [...ext].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([e, b]) => e + ' ' + (b / 1048576 | 0) + 'MB').join(' ') + ' | by per-file bytes: <1MB ' + (sizes[0] / 1048576 | 0) + ' <8MB ' + (sizes[1] / 1048576 | 0) + ' <32MB ' + (sizes[2] / 1048576 | 0) + ' MB');
47
+ const r = reqStats, mb = (b) => (b / 1048576).toFixed(0);
48
+ let wholeN = 0, wholeB = 0, partN = 0, partB = 0; const wholeBig = [];
49
+ for (const [pth, b] of fileBytes) {
50
+ const f = files[pathIndex.get(pth)];
51
+ if (f.size > 262144 && b >= 0.9 * f.size) { wholeN++; wholeB += b; wholeBig.push([pth, b]); } else { partN++; partB += b; }
52
+ }
53
+ wholeBig.sort((a, b) => b[1] - a[1]);
54
+ log('[io] files read (almost) completely: ' + wholeN + ' = ' + (wholeB / 1048576 | 0) + ' MB; everything else: ' + partN + ' files = ' + (partB / 1048576 | 0) + ' MB; biggest whole reads: ' + wholeBig.slice(0, 12).map(([pth, b]) => pth.split('/').slice(-2).join('/') + ' ' + (b / 1048576 | 0)).join(' | '));
55
+ log('[io] engine requests: ' + r.n + ' (' + mb(r.bytes) + ' MB asked) <=64K: ' + r.small[0] + ' (' + mb(r.small[1]) + ' MB), <=1M: ' + r.mid[0] + ' (' + mb(r.mid[1]) + ' MB), >1M: ' + r.big[0] + ' (' + mb(r.big[1]) + ' MB); starting in the first 1 MB of a file: ' + r.head[0] + ' (' + mb(r.head[1]) + ' MB)');
56
+ log('[io] ' + ((performance.now() - statT0) / 1000 | 0) + 's ' + (statTotal / 1048576 | 0) + ' MB fetched, ' + fileBytes.size + ' files; top: ' + top);
57
+ }
58
+ }
59
+ const reqStats = { n: 0, bytes: 0, small: [0, 0], mid: [0, 0], big: [0, 0], head: [0, 0] }; // diagnostics: requests by size class; `head` = starting in the first 1 MB of a file
60
+ // ?log=1: every 5 s, how the network is used (how many fetches are in flight is the speed: a fetch costs a round trip) and how often and how long the engine waited for it
61
+ const netStat = { started: 0, active: 0, maxActive: 0, demand: 0, demandMiss: 0, demandWaitMs: 0, cold: 0, slowLogged: 0 }; // cold: reads that had to start their own fetch (nobody hinted them); the other misses joined a fetch in flight (hinted, but not finished yet)
62
+ function startNetStats() {
63
+ let last = { started: 0, demand: 0, demandMiss: 0, demandWaitMs: 0, bytes: 0, cold: 0 }, t = performance.now();
64
+ setInterval(() => {
65
+ const now = performance.now(), s = (now - t) / 1000, mb = (statTotal - last.bytes) / 1048576;
66
+ const started = netStat.started - last.started, demand = netStat.demand - last.demand, miss = netStat.demandMiss - last.demandMiss, wait = netStat.demandWaitMs - last.demandWaitMs, cold = netStat.cold - last.cold;
67
+ t = now; last = { started: netStat.started, demand: netStat.demand, demandMiss: netStat.demandMiss, demandWaitMs: netStat.demandWaitMs, bytes: statTotal, cold: netStat.cold };
68
+ if (!started && !demand) return;
69
+ log('[io] net ' + s.toFixed(0) + ' s: ' + mb.toFixed(1) + ' MB (' + (mb / s).toFixed(2) + ' MB/s), fetches started ' + started + ', in flight now ' + netStat.active + ' (most ' + netStat.maxActive + '), engine reads ' + demand + ', of which ' + miss + ' waited for the network (' + cold + ' not hinted; ' + (miss ? (wait / miss).toFixed(0) : 0) + ' ms each), hint queue ' + hintQueue.length + ', hints seen ' + hintsSeen + ' fetched ' + hintsFetched);
70
+ netStat.maxActive = netStat.active;
71
+ }, 5000);
72
+ }
73
+ let traceOn = false, traceBuf = [], traceN = 0;
74
+ function noteTrace(id, off, len) { // ?trace=1: every engine request (file index, offset, length), posted in batches: tools analyse them offline
75
+ if (traceN++ > 60000) return;
76
+ traceBuf.push(id + ',' + off + ',' + len);
77
+ if (traceBuf.length >= 2000) { log('[trace] ' + traceBuf.join(';')); traceBuf = []; }
78
+ }
79
+ function noteRequest(off, len) {
80
+ const r = reqStats; r.n++; r.bytes += len;
81
+ const c = len <= 65536 ? r.small : len <= 1048576 ? r.mid : r.big; c[0]++; c[1] += len;
82
+ if (off < 1048576) { r.head[0]++; r.head[1] += len; }
83
+ }
84
+ function report(n) {
85
+ pendingBytes += n;
86
+ const now = performance.now();
87
+ if (now - lastPost > 400) { lastPost = now; bc.postMessage({ dl: pendingBytes }); pendingBytes = 0; }
88
+ }
89
+
90
+ // ---- persistent store --------------------------------------------------------------------------------------------------------------------------------------
91
+ let sh = null, jh = null, storeEnd = 0, journalEnd = 16;
92
+ const index = new Map(); // id * 1048576 + block -> offset in store.bin
93
+ const pendingJournal = [];
94
+ const inflight = new Map(); // same key -> Promise of the run fetching the block
95
+ const memCache = new Map(); // fallback without a store: key -> Uint8Array (LRU)
96
+ let memBytes = 0;
97
+ const blockLen = (f, block) => Math.min(BS, f.size - block * BS);
98
+ // The server's copy of a file is shorter than the manifest says (it changed after the manifest was made: serve.py warns at start): from now on the file is that long, so
99
+ // reads past its end come back short (end of file) instead of failing over and over (the engine retries a failed read forever: CFileMgr::ReadLine on loadingtime.dat).
100
+ function shrink(f, size) {
101
+ if (size >= f.size) return;
102
+ log('[io] ' + f.path + ' is ' + size + ' bytes on the server, not ' + f.size + ' as the manifest says: reading it as ' + size + ' bytes (regenerate the manifest)');
103
+ f.size = size;
104
+ }
105
+ // Indexes the blocks a..b of a run of file f stored at `offset`, of which `got` of `fullBytes` bytes arrived (fewer: the file ends inside the run).
106
+ function indexRun(id, f, a, b, offset, got, fullBytes) {
107
+ const keep = (k) => { index.set(id * 1048576 + k, offset + (k - a) * BS); pendingJournal.push([id, k, offset + (k - a) * BS]); };
108
+ if (got >= fullBytes) { for (let k = a; k <= b; k++) keep(k); return; }
109
+ shrink(f, a * BS + got);
110
+ const whole = Math.floor(got / BS);
111
+ for (let k = a; k < a + whole; k++) keep(k);
112
+ // The file's new last block, partly filled: this session only. The journal would bring it back next time under the manifest's longer size, and reads would run past its
113
+ // bytes into whatever follows in the store.
114
+ if (got % BS) index.set(id * 1048576 + a + whole, offset + whole * BS);
115
+ }
116
+
117
+ async function openStore(version) {
118
+ try {
119
+ const root = await navigator.storage.getDirectory();
120
+ const dir = await root.getDirectoryHandle('gamedata', { create: true });
121
+ // A reload while the previous page's io worker is still shutting down finds the files locked (sync access handles are exclusive): wait for it to let go.
122
+ const openHandle = async (name) => {
123
+ for (let attempt = 0; ; attempt++) {
124
+ try { return await (await dir.getFileHandle(name, { create: true })).createSyncAccessHandle(); }
125
+ catch (e) { if (attempt >= 40 || e.name !== 'NoModificationAllowedError') throw e; await new Promise((r) => setTimeout(r, 250)); } // up to 10 s
126
+ }
127
+ };
128
+ const s = await openHandle('store.bin');
129
+ let j;
130
+ try { j = await openHandle('journal.bin'); } catch (e) { s.close(); throw e; }
131
+ const head = new DataView(new ArrayBuffer(16));
132
+ let ok = false;
133
+ if (j.getSize() >= 16) {
134
+ j.read(new Uint8Array(head.buffer), { at: 0 });
135
+ ok = head.getUint32(0, true) === 0x4a415449 && head.getFloat64(8, true) === version;
136
+ }
137
+ if (!ok) {
138
+ s.truncate(0); j.truncate(0);
139
+ head.setUint32(0, 0x4a415449, true); head.setFloat64(8, version, true);
140
+ j.write(new Uint8Array(head.buffer), { at: 0 });
141
+ j.flush();
142
+ }
143
+ storeEnd = s.getSize();
144
+ const size = j.getSize();
145
+ const n = Math.floor((size - 16) / 16);
146
+ const buf = new Uint8Array(n * 16);
147
+ if (n) j.read(buf, { at: 16 });
148
+ const dv = new DataView(buf.buffer);
149
+ let good = 0;
150
+ for (let i = 0; i < n; i++) {
151
+ const id = dv.getUint32(i * 16, true), block = dv.getUint32(i * 16 + 4, true), off = dv.getUint32(i * 16 + 8, true) + dv.getUint32(i * 16 + 12, true) * 4294967296;
152
+ const f = files[id];
153
+ if (f && off + blockLen(f, block) <= storeEnd) { index.set(id * 1048576 + block, off); good++; }
154
+ }
155
+ journalEnd = 16 + n * 16;
156
+ sh = s; jh = j;
157
+ log('[io] persistent store: ' + good + ' blocks (' + (good * BS / 1048576 | 0) + ' MB), store.bin ' + (storeEnd / 1048576 | 0) + ' MB');
158
+ } catch (e) {
159
+ sh = jh = null;
160
+ log('[io] no persistent store (' + e.message + '): blocks are cached in memory only');
161
+ }
162
+ }
163
+
164
+ // ---- boot read set: recorded with ?record=1, replayed at page load ----------------------------------------------------------------------------------------
165
+ // The engine reads (almost) the same ~600 MB of archive headers and start-up data on every boot. A run with ?record=1 logs the block ranges per file in order of first
166
+ // touch (POST /log, record_bootset.py extracts them); every later page load fetches that set right away, with several requests in flight, in parallel with the download
167
+ // and start-up of the engine instead of one blocking request at a time from its threads.
168
+ let recording = false;
169
+ const touched = new Map(); // path -> [[first, last], ...]
170
+ function recordTouch(id, a, b) { // byte range actually asked for by the engine (no read-ahead, independent of the block size)
171
+ const p = files[id].path;
172
+ let r = touched.get(p);
173
+ if (!r) { r = []; touched.set(p, r); if (touched.size === 1) setTimeout(dumpRecording, 75000); }
174
+ r.push([a, b]);
175
+ }
176
+ function dumpRecording() {
177
+ const out = [];
178
+ for (const [p, r] of touched) {
179
+ r.sort((x, y) => x[0] - y[0]);
180
+ const m = [];
181
+ for (const [a, b] of r) { const l = m[m.length - 1]; if (l && a <= l[1] + 4096) l[1] = Math.max(l[1], b); else m.push([a, b]); }
182
+ out.push([p, m]);
183
+ }
184
+ log('[bootset] ' + JSON.stringify(out));
185
+ }
186
+
187
+ // An overloaded host answers 503/500/429 (seen 2026-10-06: 10,000 visitors in a day, thousands of error responses, and the engine quits when a data file cannot be read): such an
188
+ // answer, or none, is retried up to 8 times with growing, jittered waits (~20 s in all). Only the start of a response is retried (nothing of its body has been used yet).
189
+ async function fetchRetry(url, init) {
190
+ for (let attempt = 0; ; attempt++) {
191
+ let res = null, err = null;
192
+ try { res = await fetch(url, init); } catch (e) { err = e; }
193
+ if (res && res.status < 500 && res.status !== 429) return res;
194
+ if (attempt >= 7) { if (res) return res; throw err; }
195
+ netStat.retries = (netStat.retries || 0) + 1;
196
+ await new Promise((r) => setTimeout(r, Math.min(5000, 300 * 2 ** attempt) * (0.5 + Math.random())));
197
+ }
198
+ }
199
+ async function sha1Hex(s) { return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-1', new TextEncoder().encode(s))), (b) => b.toString(16).padStart(2, '0')).join(''); }
200
+ let dataVersion = ''; // the manifest's version (set when it is loaded): part of a cached batch's name
201
+ // One POST /data/batch answers a list of block runs with one streamed body: thousands of small archive pieces cost one round trip per batch instead of one each.
202
+ // The boot set's batches are the same for every visitor (`wanted` marks the files this visitor still needs; the rest of the batch is read and dropped), so the host keeps each one as a
203
+ // static file named after a hash of its request (host/index.php save_batch): it is asked for with a plain GET first, which Cloudflare caches, and only if that fails (not built yet,
204
+ // an old host, no DecompressionStream) does the POST build it.
205
+ function batchFetch(runsIn, compressed, wanted) {
206
+ const runs = runsIn.map((r) => {
207
+ const f = files[r.id], bytes = (r.b - r.a) * BS + blockLen(f, r.b), skip = !!wanted && !wanted.has(r.id), offset = skip ? 0 : storeEnd;
208
+ if (!skip) storeEnd += bytes;
209
+ return { id: r.id, a: r.a, b: r.b, f, bytes, offset, skip };
210
+ });
211
+ netStat.started++; if (++netStat.active > netStat.maxActive) netStat.maxActive = netStat.active;
212
+ const p = (async () => {
213
+ const body = JSON.stringify(runs.map((r) => [r.f.path, r.a * BS, r.a * BS + r.bytes - 1]));
214
+ let lens = runs.map((r) => r.bytes);
215
+ const consume = async (reader) => {
216
+ let ri = 0, inRun = 0;
217
+ while (ri < runs.length && lens[ri] === 0) ri++;
218
+ for (;;) {
219
+ const { done, value } = await reader.read();
220
+ if (done) break;
221
+ report(value.length);
222
+ for (let pos = 0; pos < value.length && ri < runs.length;) {
223
+ const r = runs[ri], n = Math.min(value.length - pos, lens[ri] - inRun);
224
+ if (!r.skip) { sh.write(value.subarray(pos, pos + n), { at: r.offset + inRun }); tally(r.f, n); }
225
+ inRun += n; pos += n;
226
+ if (inRun === lens[ri]) { ri++; inRun = 0; while (ri < runs.length && lens[ri] === 0) ri++; }
227
+ }
228
+ }
229
+ if (ri !== runs.length) throw new Error('short batch answer: ' + ri + ' of ' + runs.length + ' runs');
230
+ };
231
+ let cached = false;
232
+ if (compressed && dataVersion && self.crypto && crypto.subtle && typeof DecompressionStream !== 'undefined') {
233
+ try {
234
+ const res = await fetch(base + 'batchc/' + await sha1Hex(dataVersion + ':' + body) + '.bin' + dataQuery, { priority: 'low' });
235
+ if (res.ok && res.body) { await consume(res.body.pipeThrough(new DecompressionStream('gzip')).getReader()); cached = true; netStat.batchCached = (netStat.batchCached || 0) + 1; }
236
+ } catch (e) { /* not built yet or unusable: the POST below builds and sends it (blocks written so far are written again at the same places) */ }
237
+ }
238
+ if (!cached) {
239
+ const res = await fetchRetry(base + (compressed ? 'batch?gz=1' + (dataVersion ? '&c=1&v=' + encodeURIComponent(dataVersion) : '') : 'batch'), { method: 'POST', priority: 'low', body });
240
+ if (!res.ok) throw new Error('HTTP ' + res.status + ' for a batch');
241
+ // the length of each range as sent (a range is clamped at the end of the server's copy of the file); without the header, the lengths asked for
242
+ const sent = (res.headers.get('X-Run-Lengths') || '').split(',').map(Number);
243
+ lens = sent.length === runs.length && sent.every((n, i) => n >= 0 && n <= runs[i].bytes) ? sent : runs.map((r) => r.bytes);
244
+ await consume(res.body.getReader());
245
+ }
246
+ runs.forEach((r, i) => { if (!r.skip) indexRun(r.id, r.f, r.a, r.b, r.offset, lens[i], r.bytes); });
247
+ scheduleFlush();
248
+ })();
249
+ const done = () => { netStat.active--; for (const r of runs) if (!r.skip) for (let k = r.a; k <= r.b; k++) inflight.delete(r.id * 1048576 + k); };
250
+ for (const r of runs) if (!r.skip) for (let k = r.a; k <= r.b; k++) inflight.set(r.id * 1048576 + k, p);
251
+ p.then(done, done);
252
+ return p;
253
+ }
254
+
255
+ // Lanes: the host answers a Range request (Apache) at a few hundred KB/s per stream whatever the link is, and the speed grows with the number of streams (measured from here:
256
+ // 6 in flight 3.4 MB/s, 32 3.6, 64 7.1, 128 14.1 MB/s): the boot set (~580 MB) is fetched as ranges, RUN_LANES at a time. Compressible small files still go through the host's
257
+ // PHP (compressed batches), few at a time: PHP answers about 16 requests at once.
258
+ const RUN_LANES = 32, BATCH_LANES = 4, RUN_GAP = 64; // RUN_GAP: blocks; two ranges of a file closer than this are fetched as one (the bytes between are read next to them)
259
+ async function prefetch(name) {
260
+ let set;
261
+ try { const r = await fetchRetry(base + name, { cache: 'no-store' }); if (!r.ok) return; set = await r.json(); } catch (e) { return; }
262
+ // in boot order: compressible small files whole, in compressed batches; everything else as runs of at most MAX_RUN blocks (1 MB)
263
+ const runs = [], batches = [];
264
+ let cbatch = [], cbytes = 0;
265
+ const addRuns = (id, a, b) => { for (let k = a; k <= b; k += MAX_RUN) runs.push({ id, a: k, b: Math.min(b, k + MAX_RUN - 1) }); };
266
+ for (const [path, ranges] of set) {
267
+ const id = pathIndex.get(path);
268
+ if (id === undefined) continue;
269
+ const f = files[id], lastBlock = Math.ceil(f.size / BS) - 1;
270
+ if (COMPRESSIBLE.test(f.path) && f.size <= WHOLE_MAX) { // small compressible files: whole files, several per request, compressed by the server
271
+ cbatch.push({ id, a: 0, b: lastBlock }); cbytes += f.size;
272
+ if (cbytes >= 4194304 || cbatch.length >= 300) { batches.push(cbatch); cbatch = []; cbytes = 0; }
273
+ continue;
274
+ }
275
+ let cur = null;
276
+ for (const [x, y] of ranges) {
277
+ const a = Math.floor(x / BS), b = Math.min(Math.floor(y / BS), lastBlock);
278
+ if (cur && a <= cur.b + RUN_GAP) cur.b = Math.max(cur.b, b);
279
+ else { if (cur) addRuns(id, cur.a, cur.b); cur = { a, b }; }
280
+ }
281
+ if (cur) addRuns(id, cur.a, cur.b);
282
+ }
283
+ if (cbatch.length) batches.push(cbatch);
284
+ const t0 = performance.now();
285
+ log('[io] prefetching the boot set: ' + set.length + ' files, ' + runs.length + ' ranges, ' + batches.length + ' compressed batches');
286
+ let nextRun = 0, nextBatch = 0;
287
+ const runLane = async () => {
288
+ while (nextRun < runs.length) {
289
+ const r = runs[nextRun++];
290
+ try { await ensureBlocks(r.id, r.a, r.b, true); } catch (e) { log('[io] prefetch failed: ' + e.message); } // blocks already stored or on their way cost nothing
291
+ }
292
+ };
293
+ const batchLane = async () => {
294
+ while (nextBatch < batches.length) {
295
+ const full = batches[nextBatch++], wanted = new Set(full.filter((it) => untouched(it.id, files[it.id])).map((it) => it.id)); // files the engine already fetched meanwhile are dropped from the answer, not from the request: the request is the same for everybody
296
+ try { if (wanted.size) await batchFetch(full, true, wanted); } catch (e) { log('[io] prefetch failed: ' + e.message); }
297
+ }
298
+ };
299
+ await Promise.all([...Array.from({ length: RUN_LANES }, runLane), ...Array.from({ length: BATCH_LANES }, batchLane)]);
300
+ log('[io] boot set prefetched in ' + ((performance.now() - t0) / 1000 | 0) + ' s, ' + (statTotal / 1048576 | 0) + ' MB fetched so far; ' + (netStat.batchCached || 0) + ' of ' + batches.length + ' batches from the host\'s static copies, ' + (netStat.retries || 0) + ' retried requests');
301
+ }
302
+
303
+ let flushTimer = 0;
304
+ function writeJournal() {
305
+ if (!pendingJournal.length || !jh || !sh) return;
306
+ const n = pendingJournal.length;
307
+ const buf = new DataView(new ArrayBuffer(n * 16));
308
+ pendingJournal.forEach((e, i) => { buf.setUint32(i * 16, e[0], true); buf.setUint32(i * 16 + 4, e[1], true); buf.setUint32(i * 16 + 8, e[2] % 4294967296, true); buf.setUint32(i * 16 + 12, Math.floor(e[2] / 4294967296), true); });
309
+ pendingJournal.length = 0;
310
+ try {
311
+ sh.flush(); // the data first, then the entries that point at it
312
+ jh.write(new Uint8Array(buf.buffer), { at: journalEnd });
313
+ journalEnd += n * 16;
314
+ jh.flush();
315
+ } catch (e) { log('[io] journal write failed: ' + e.message); }
316
+ }
317
+ function scheduleFlush() {
318
+ if (flushTimer || !jh) return;
319
+ flushTimer = setTimeout(() => { flushTimer = 0; writeJournal(); }, 2000);
320
+ }
321
+
322
+ // ---- fetching --------------------------------------------------------------------------------------------------------------------------------------------------
323
+ // Streams bytes [start, end] of file f; onChunk(u8, positionInRange) receives the body as it arrives. `low`: speculative (boot set, read-ahead): the browser serves it after everything
324
+ // else on the connection (fetch priority), so that a read the engine is blocked on is not queued behind megabytes of it (measured: engine reads waited up to 6.6 s behind 32 prefetch streams).
325
+ async function fetchRange(f, start, end, onChunk, whole, low) {
326
+ netStat.started++; if (++netStat.active > netStat.maxActive) netStat.maxActive = netStat.active;
327
+ try { return await fetchRangeRaw(f, start, end, onChunk, whole, low); } finally { netStat.active--; }
328
+ }
329
+ async function fetchRangeRaw(f, start, end, onChunk, whole, low) {
330
+ const url = base + f.path.split('/').map(encodeURIComponent).join('/') + dataQuery; // ?v=<manifest version>: the same URL always has the same bytes, so the host (and Cloudflare, with a rule for /data/) may cache it for ever
331
+ // no-store: the host's own static serving of a range (Apache, host/data/.htaccess) sends no Cache-Control, and Chrome would keep every 206 in its HTTP cache next to this store
332
+ const init = { cache: 'no-store', priority: low ? 'low' : 'high' };
333
+ if (!whole) init.headers = { Range: 'bytes=' + start + '-' + end }; // whole: the server sends a compressed copy, the browser decodes it
334
+ const res = await fetchRetry(url, init);
335
+ if (res.status !== 206 && res.status !== 200) throw new Error('HTTP ' + res.status + ' for ' + f.path);
336
+ let skip = res.status === 200 ? start : 0; // a server that ignores Range sends the whole file
337
+ const total = end - start + 1;
338
+ const reader = res.body.getReader();
339
+ let pos = 0;
340
+ for (;;) {
341
+ const { done, value } = await reader.read();
342
+ if (done) break;
343
+ report(value.length); tally(f, value.length);
344
+ let chunk = value;
345
+ if (skip) {
346
+ const drop = Math.min(skip, chunk.length);
347
+ skip -= drop; chunk = chunk.subarray(drop);
348
+ }
349
+ if (chunk.length > total - pos) chunk = chunk.subarray(0, total - pos);
350
+ if (chunk.length) { onChunk(chunk, pos); pos += chunk.length; }
351
+ if (pos >= total) { reader.cancel().catch(() => {}); break; }
352
+ }
353
+ return pos;
354
+ }
355
+
356
+ // Makes sure blocks first..last of file id are in the store; returns when they are.
357
+ // Compressible small files (shader effects, metadata) are fetched whole, compressed by the server: the engine reads them completely anyway.
358
+ const COMPRESSIBLE = /\.(fxc|meta|xml|dat|ymt|txt|csv|gfx|json|sps|cfg)$/i, WHOLE_MAX = 8 * 1048576;
359
+ function untouched(id, f) {
360
+ if (!COMPRESSIBLE.test(f.path) || f.size > WHOLE_MAX) return false;
361
+ for (let b = 0, n = Math.ceil(f.size / BS); b < n; b++) if (index.has(id * 1048576 + b) || inflight.has(id * 1048576 + b)) return false;
362
+ return true;
363
+ }
364
+ const SLICE_BLOCKS = 32; // 128 KB: see startRun
365
+ async function ensureBlocks(id, first, last, low) {
366
+ const f = files[id], waits = [];
367
+ last = Math.min(last, Math.ceil(f.size / BS) - 1); // the file may have turned out shorter than the manifest says (shrink)
368
+ if (first > last) return;
369
+ let runStart = -1;
370
+ if (untouched(id, f)) { first = 0; last = Math.ceil(f.size / BS) - 1; }
371
+ const whole = first === 0 && last === Math.ceil(f.size / BS) - 1 && untouched(id, f);
372
+ const startRun = (a, b, wholeFile) => {
373
+ const offset = storeEnd, bytes = (b - a) * BS + blockLen(f, b); // a run is whole blocks of the file: only the last can be short
374
+ storeEnd += bytes;
375
+ const p = (async () => {
376
+ // A read the engine may be blocked on (not low) is cut into slices fetched side by side: one stream through the host moves ~0.15 MB/s after its round trip of ~0.6 s (a 512 KB
377
+ // read took 2-5 s, measured), so eight of them in parallel finish in about a second. Speculative runs (low) stay whole: their speed is the number in flight, not their latency.
378
+ const slice = wholeFile || low ? b - a + 1 : SLICE_BLOCKS, jobs = [];
379
+ for (let s = a; s <= b; s += slice) {
380
+ const e = Math.min(b, s + slice - 1), pos = (s - a) * BS, n = (e - s) * BS + blockLen(f, e);
381
+ jobs.push(fetchRange(f, s * BS, s * BS + n - 1, (chunk, at) => sh.write(chunk, { at: offset + pos + at }), wholeFile, low).then((g) => [g, n]));
382
+ }
383
+ let got = 0;
384
+ for (const [g, n] of await Promise.all(jobs)) { got += g; if (g < n) break; } // a short slice: the file ends there
385
+ indexRun(id, f, a, b, offset, got, bytes);
386
+ scheduleFlush();
387
+ })();
388
+ for (let k = a; k <= b; k++) inflight.set(id * 1048576 + k, p);
389
+ p.then(() => { for (let k = a; k <= b; k++) inflight.delete(id * 1048576 + k); }, () => { for (let k = a; k <= b; k++) inflight.delete(id * 1048576 + k); });
390
+ waits.push(p);
391
+ };
392
+ if (whole) { startRun(0, last, true); await Promise.all(waits); return; }
393
+ for (let b = first; b <= last + 1; b++) {
394
+ const need = b <= last && !index.has(id * 1048576 + b) && !inflight.has(id * 1048576 + b);
395
+ if (need && runStart < 0) runStart = b;
396
+ if (runStart >= 0 && (!need || b - runStart + 1 > MAX_RUN)) {
397
+ startRun(runStart, b - 1);
398
+ runStart = need ? b : -1;
399
+ }
400
+ if (b <= last && inflight.has(id * 1048576 + b)) waits.push(inflight.get(id * 1048576 + b));
401
+ }
402
+ await Promise.all(waits);
403
+ }
404
+
405
+ const seq = new Map(); // file id -> { end: offset after the last read, ahead: current read-ahead bytes }
406
+ let sharedReadFails = false;
407
+ // Copies [off, off + len) of file id from the store into the heap at dst.
408
+ function readFromStore(id, off, len, dst) {
409
+ let done = 0;
410
+ while (done < len) {
411
+ const pos = off + done, block = Math.floor(pos / BS);
412
+ let storeOff = index.get(id * 1048576 + block) + (pos - block * BS), n = Math.min(len - done, (block + 1) * BS - pos);
413
+ // merge the following blocks while they are contiguous in the store
414
+ for (let b = block + 1; done + n < len; b++) {
415
+ const nextOff = index.get(id * 1048576 + b);
416
+ if (nextOff === undefined || nextOff !== storeOff + n) break;
417
+ n += Math.min(len - done - n, BS);
418
+ }
419
+ let got;
420
+ if (!sharedReadFails) {
421
+ try { got = sh.read(HEAPU8.subarray(dst + done, dst + done + n), { at: storeOff }); }
422
+ catch (e) { sharedReadFails = true; log('[io] store read into the shared heap failed (' + e.message + '): going through a temporary buffer'); }
423
+ }
424
+ if (sharedReadFails) {
425
+ const tmp = new Uint8Array(n);
426
+ got = sh.read(tmp, { at: storeOff });
427
+ HEAPU8.set(tmp, dst + done);
428
+ }
429
+ if (got !== n) throw new Error('store read returned ' + got + ' of ' + n);
430
+ done += n;
431
+ }
432
+ }
433
+
434
+ // ---- without a store ---------------------------------------------------------------------------------------------------------------------------------------
435
+ async function getMemBlock(id, block) {
436
+ const key = id * 1048576 + block;
437
+ const hit = memCache.get(key);
438
+ if (hit) { memCache.delete(key); memCache.set(key, hit); return hit; }
439
+ let p = inflight.get(key);
440
+ if (!p) {
441
+ const f = files[id];
442
+ p = (async () => {
443
+ let data = new Uint8Array(Math.min(MBS, f.size - block * MBS));
444
+ let got = await fetchRange(f, block * MBS, block * MBS + data.length - 1, (chunk, at) => data.set(chunk, at));
445
+ if (got < data.length) { shrink(f, block * MBS + got); data = data.subarray(0, got); }
446
+ memCache.set(key, data); memBytes += data.length;
447
+ while (memBytes > 48 * 1048576) { const old = memCache.keys().next().value; memBytes -= memCache.get(old).length; memCache.delete(old); }
448
+ return data;
449
+ })();
450
+ inflight.set(key, p);
451
+ p.then(() => inflight.delete(key), () => inflight.delete(key));
452
+ }
453
+ return p;
454
+ }
455
+
456
+ async function readWithoutStore(id, off, len, dst) {
457
+ let done = 0;
458
+ while (done < len) {
459
+ const pos = off + done, block = Math.floor(pos / MBS);
460
+ const data = await getMemBlock(id, block);
461
+ const inBlock = pos - block * MBS, n = Math.min(len - done, data.length - inBlock);
462
+ if (n <= 0) break;
463
+ HEAPU8.set(data.subarray(inBlock, inBlock + n), dst + done);
464
+ done += n;
465
+ }
466
+ return done;
467
+ }
468
+
469
+ // ---- requests ---------------------------------------------------------------------------------------------------------------------------------------------------
470
+ function views() {
471
+ if (HEAPU8.length !== mem.buffer.byteLength) { HEAP32 = new Int32Array(mem.buffer); HEAPU8 = new Uint8Array(mem.buffer); }
472
+ }
473
+
474
+ async function serve(slot) {
475
+ views();
476
+ const w = Math.floor(table / 4) + 16 + 16 * slot; // word index of the slot (no bit shift: the memory can grow past 4 GB)
477
+ const id = HEAP32[w + 1], off = (HEAP32[w + 2] >>> 0) + (HEAP32[w + 3] >>> 0) * 4294967296;
478
+ const dst = (HEAP32[w + 4] >>> 0) + (HEAP32[w + 5] >>> 0) * 4294967296;
479
+ let len = HEAP32[w + 6];
480
+ let result = -1;
481
+ try {
482
+ const f = files[id];
483
+ noteRequest(off, len); netStat.demand++;
484
+ if (traceOn) noteTrace(id, off, len);
485
+ if (off >= f.size) result = 0;
486
+ else {
487
+ if (off + len > f.size) len = f.size - off;
488
+ if (sh) {
489
+ // read-ahead: a read that continues the previous one of this file (a sequential scan) also fetches the next bytes, doubling up to MAX_AHEAD; anything else fetches only what it needs
490
+ const st = seq.get(id) || { end: -1, ahead: 0 };
491
+ // radio and talk-radio streams (audio/sfx/RADIO_*.rpf) are read as ~33 KB blocks, one after another and each a network round trip, with nothing queued behind for the
492
+ // hints to use: a read that starts at or soon after the end of the previous one (blocks of one track) counts as sequential whatever its size
493
+ const radio = /\/RADIO_/i.test(f.path);
494
+ const sequential = radio ? (st.end >= 0 && off >= st.end && off - st.end <= 65536) : (off === st.end && len >= AHEAD_MIN_READ);
495
+ st.ahead = sequential ? Math.min(MAX_AHEAD, st.ahead ? st.ahead * 2 : FIRST_AHEAD) : 0;
496
+ st.end = off + len;
497
+ seq.set(id, st);
498
+ const lastByte = Math.min(f.size, off + len + st.ahead) - 1;
499
+ if (recording) recordTouch(id, off, off + len - 1);
500
+ // Only the requested blocks are waited for: the read-ahead is started but the engine's read completes as soon as its own bytes are in (it waited for the read-ahead
501
+ // download too). A request whose blocks are all stored is served synchronously, without the async block bookkeeping.
502
+ const first = Math.floor(off / BS), needLast = Math.floor((off + len - 1) / BS), aheadLast = Math.floor(lastByte / BS);
503
+ let need = null, cold = false; const waitStart = performance.now();
504
+ for (let b = first; b <= needLast; b++) if (!index.has(id * 1048576 + b)) { cold = cold || !inflight.has(id * 1048576 + b); need = need || true; }
505
+ if (need) need = ensureBlocks(id, first, needLast);
506
+ if (aheadLast > needLast) ensureBlocks(id, needLast + 1, aheadLast, true).catch((e) => log('[io] read-ahead failed: ' + e.message));
507
+ if (need) {
508
+ await need; views();
509
+ const waited = performance.now() - waitStart;
510
+ netStat.demandMiss++; netStat.demandWaitMs += waited; if (cold) netStat.cold++;
511
+ if (waited > 1500 && netStat.slowLogged++ < 60) log('[io] slow read ' + (waited | 0) + ' ms (' + (cold ? 'not hinted' : 'hinted, not finished') + '): ' + f.path + ' at ' + off + ' for ' + len + ' bytes, in flight ' + netStat.active);
512
+ }
513
+ if (off + len > f.size) len = Math.max(0, f.size - off); // the file turned out shorter than the manifest says (shrink)
514
+ readFromStore(id, off, len, dst);
515
+ result = len;
516
+ } else result = await readWithoutStore(id, off, len, dst);
517
+ }
518
+ } catch (e) {
519
+ log('[io] read failed: ' + e.message);
520
+ }
521
+ views();
522
+ Atomics.store(HEAP32, w + 7, result);
523
+ Atomics.store(HEAP32, w, 2);
524
+ Atomics.notify(HEAP32, w, 1);
525
+ }
526
+
527
+ // Hints (read announcements from the engine, see the protocol above): queued here and fetched into the store; a demand read that arrives meanwhile joins the fetch in flight
528
+ // (ensureBlocks), one that arrives after finds its blocks stored. Hints for blocks already stored or on their way cost nothing. Two kinds: reads the engine has queued (normal) and
529
+ // look-ahead at objects it has requested but not queued yet (bit 30 of the length: strStreamingInfoManager::WasmAnnounceUpcoming); the first are fetched first, the second only while
530
+ // fewer than LOW_PAR are in flight and at low fetch priority, so that the reads the engine blocks on (the audio engine's included) are not queued behind them.
531
+ const HINT_PAR = 96, LOW_PAR = 48, HINT_QUEUE_MAX = 2000; // 96 in flight: a small read takes ~1.5 s whatever the link, so the speed is the number in flight (measured: 15 in flight = 1.3 MB/s)
532
+ const hintQueue = [], lowQueue = [];
533
+ let hintActive = 0, lowActive = 0, hintsSeen = 0, hintsFetched = 0;
534
+ function pumpHints() {
535
+ for (;;) {
536
+ const low = !hintQueue.length;
537
+ if (hintActive + lowActive >= HINT_PAR || (low && (!lowQueue.length || lowActive >= LOW_PAR))) return;
538
+ const [id, off, len] = (low ? lowQueue : hintQueue).shift();
539
+ const f = files[id];
540
+ if (!f || off >= f.size) continue;
541
+ const a = Math.floor(off / BS), b = Math.floor((Math.min(f.size, off + len) - 1) / BS);
542
+ let need = false;
543
+ for (let k = a; k <= b && !need; k++) need = !index.has(id * 1048576 + k) && !inflight.has(id * 1048576 + k);
544
+ if (!need) continue;
545
+ if (low) lowActive++; else hintActive++;
546
+ hintsFetched++;
547
+ ensureBlocks(id, a, b, low).catch(() => {}).finally(() => { if (low) lowActive--; else hintActive--; pumpHints(); });
548
+ }
549
+ }
550
+ function drainHints(bell) {
551
+ const ring = Atomics.load(HEAP32, bell + 2), cap = Atomics.load(HEAP32, bell + 3);
552
+ if (!ring || !cap || !sh || noHints) return; // an engine without hints, no store to fetch into, or ?nohints=1
553
+ const head = Atomics.load(HEAP32, bell + 4) >>> 0;
554
+ let tail = Atomics.load(HEAP32, bell + 5) >>> 0;
555
+ if (((head - tail) >>> 0) > cap) tail = (head - cap) >>> 0; // the engine lapped us: the oldest hints were overwritten
556
+ while (tail !== head) {
557
+ const e = bell + ring + 4 * (tail % cap);
558
+ const raw = Atomics.load(HEAP32, e + 3);
559
+ if (!raw) break; // claimed but not written yet: its writer rings the doorbell again when it is
560
+ (raw & 0x40000000 ? lowQueue : hintQueue).push([HEAP32[e], (HEAP32[e + 1] >>> 0) + (HEAP32[e + 2] >>> 0) * 4294967296, raw & 0x3fffffff]);
561
+ hintsSeen++;
562
+ Atomics.store(HEAP32, e + 3, 0);
563
+ tail = (tail + 1) >>> 0;
564
+ }
565
+ Atomics.store(HEAP32, bell + 5, tail);
566
+ if (hintQueue.length > HINT_QUEUE_MAX) hintQueue.splice(0, hintQueue.length - HINT_QUEUE_MAX);
567
+ if (lowQueue.length > HINT_QUEUE_MAX) lowQueue.splice(0, lowQueue.length - HINT_QUEUE_MAX);
568
+ pumpHints();
569
+ }
570
+
571
+ async function loop() {
572
+ const bell = Math.floor(table / 4);
573
+ for (;;) {
574
+ views();
575
+ const seen = Atomics.load(HEAP32, bell); // read before the scan: a request posted during the scan changes the doorbell and the wait below returns at once
576
+ const n = Atomics.load(HEAP32, bell + 1);
577
+ for (let slot = 0; slot < n; slot++)
578
+ if (Atomics.compareExchange(HEAP32, bell + 16 + 16 * slot, 1, 3) === 1)
579
+ serve(slot);
580
+ drainHints(bell);
581
+ const r = Atomics.waitAsync(HEAP32, bell, seen);
582
+ if (r.async) await r.value;
583
+ }
584
+ }
585
+
586
+ let ready = null;
587
+ async function init(m) {
588
+ base = m.base; bc = new BroadcastChannel('game-progress'); remoteLog = !!m.log; noHints = !!m.noHints;
589
+ const j = await (await fetchRetry(base + 'manifest.json', { cache: 'no-store' })).json();
590
+ files = j.files.map((f) => ({ path: f[0], size: f[1] }));
591
+ dataQuery = j.version ? '?v=' + encodeURIComponent(j.version) : ''; dataVersion = j.version ? String(j.version) : '';
592
+ files.forEach((f, i) => pathIndex.set(f.path, i));
593
+ recording = !!m.record; traceOn = !!m.trace;
594
+ if (remoteLog) startNetStats();
595
+ if (!m.noStore) await openStore(Number(String(j.version).replace(/\D/g, '')) || 0);
596
+ if (sh && m.bootset && !m.record) prefetch(m.bootset);
597
+ }
598
+
599
+ // The page tells us when it is going away (pagehide): close the handles at once so the next load can take them.
600
+ new BroadcastChannel('game-io').onmessage = (ev) => {
601
+ if (ev.data !== 'close') return;
602
+ if (flushTimer) { clearTimeout(flushTimer); flushTimer = 0; }
603
+ writeJournal();
604
+ try { if (sh) sh.close(); if (jh) jh.close(); } catch (e) {}
605
+ sh = jh = null;
606
+ };
607
+
608
+ // ---- the engine's per-user files (savegames, settings): platform/file/userdata_wasm.cpp posts {userdata: {path, data, mtime}} when a file under /userdata/Documents has settled and
609
+ // {userdataDelete: path} when one is gone; they are kept in IndexedDB "gta5-userdata" / store "files" (key: path, value: {data, mtime}) and put back into the engine's
610
+ // in-memory /userdata by loader.js before it starts. IndexedDB, not the OPFS store above: that one is exclusive to a single tab and is keyed to the game data's version.
611
+ let userdataDb = null;
612
+ const openUserdata = () => userdataDb || (userdataDb = new Promise((resolve, reject) => {
613
+ const r = indexedDB.open('gta5-userdata', 1);
614
+ r.onupgradeneeded = () => r.result.createObjectStore('files');
615
+ r.onsuccess = () => resolve(r.result);
616
+ r.onerror = () => { userdataDb = null; reject(r.error); };
617
+ }));
618
+ async function userdataWrite(path, record) {
619
+ try {
620
+ const db = await openUserdata();
621
+ await new Promise((resolve, reject) => {
622
+ const t = db.transaction('files', 'readwrite');
623
+ if (record) t.objectStore('files').put(record, path); else t.objectStore('files').delete(path);
624
+ t.oncomplete = resolve;
625
+ t.onerror = t.onabort = () => reject(t.error);
626
+ });
627
+ log('[io] userdata ' + (record ? 'stored ' + path + ' (' + record.data.length + ' bytes)' : 'deleted ' + path));
628
+ } catch (e) {
629
+ fetch('/log', { method: 'POST', body: '[io] userdata ' + path + ' NOT stored (the save will be lost when the tab closes): ' + e }).catch(() => {}); // whatever ?log=1 says: a lost save is worth a line
630
+ }
631
+ }
632
+
633
+ self.onmessage = async (ev) => {
634
+ const m = ev.data;
635
+ if (m.userdata) { userdataWrite(m.userdata.path, { data: m.userdata.data, mtime: m.userdata.mtime }); return; }
636
+ if (m.userdataDelete) { userdataWrite(m.userdataDelete, null); return; }
637
+ if (m.init) { ready = init(m); return; } // sent by loader.js as soon as the page starts
638
+ if (!m.memory) return;
639
+ mem = m.memory; HEAP32 = new Int32Array(mem.buffer); HEAPU8 = new Uint8Array(mem.buffer);
640
+ table = m.table;
641
+ await ready; // the store is open and the manifest is loaded
642
+ loop();
643
+ };
644
+ self.postMessage({ loaded: true });
b/8b0b5899ed/loader.js ADDED
@@ -0,0 +1,146 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ // Worker that hosts the engine ("main runtime thread" of the Emscripten module). importScripts('game.js') runs the static constructors
2
+ // and main() here; the loop blocks this worker, which is fine (nothing else runs on it). game.js also runs in every pthread worker.
3
+ 'use strict';
4
+ let started = false;
5
+ self.onmessage = (ev) => {
6
+ if (started) return;
7
+ started = true;
8
+ const m = ev.data;
9
+ // ?cores=N (debug): pretend to be a machine with N logical cores; the engine sizes its worker pools from it
10
+ if (m.cores) Object.defineProperty(navigator, 'hardwareConcurrency', { value: m.cores });
11
+ // The GPU worker must be up before the engine blocks this thread: Chrome fetches the script of a worker nested in a worker through
12
+ // the parent's event loop. It idles until the engine sends its start message (wgpu_backend.cpp: wgpu_start_worker).
13
+ const gq = new URLSearchParams(); // the GPU worker reads its options from its own URL
14
+ if (m.slots) gq.set('slots', m.slots);
15
+ if (m.syncPipelines) gq.set('syncpipelines', '1');
16
+ if (m.remoteLog) gq.set('log', '1'); // ?log=1 on the page: its log lines go to the dev server (off by default)
17
+ if (m.lowMemory) gq.set('low', '1'); // the low-memory profile: its own pipeline seed (wgpu_worker.js loadRecipes)
18
+ if (m.noPack) gq.set('nopack', '1'); // ?nopack=1: shaders one by one instead of from the packs (diagnostics)
19
+ if (m.shotRt) gq.set('shotrt', '1'); // ?shotrt=1 (with ?shot=N): every render target of one frame after the world is shown goes to the dev server (diagnosis)
20
+ if (m.gpuLimits) gq.set('limits', m.gpuLimits); // ?limits=name:value,...: a smaller device (diagnosis of weaker GPUs)
21
+ const B = m.base || ''; // the page's URL prefix for everything it loads (index.html BASE): /b/<build> on the PHP host, empty otherwise
22
+ const gpu = new Worker(B + '/wgpu_worker.js' + (gq.toString() ? '?' + gq : ''));
23
+ const io = new Worker(B + '/io_worker.js');
24
+ io.postMessage({ init: true, base: self.location.origin + '/data/', noStore: !!m.noStore, record: !!m.record, trace: !!m.trace, log: !!m.remoteLog, noHints: !!m.noHints, bootset: m.lowMemory ? 'bootset_low.json' : 'bootset.json' }); // starts the prefetch of the boot read set at once // HTTP reads of all engine threads (platform/file/httpfs_wasm.cpp); same reason to create it up front
25
+ let loaded = 0;
26
+ io.onmessage = (e) => { if (e.data.loaded && ++loaded === 2) start(); };
27
+ gpu.onmessage = (e) => {
28
+ if (e.data.loaded && ++loaded === 2) start();
29
+ };
30
+ // An overloaded host answers 503/500/429 (2026-10-06): retried up to 8 times with growing, jittered waits (~20 s in all) instead of compiling an error page.
31
+ const fetchWasm = async () => {
32
+ for (let attempt = 0; ; attempt++) {
33
+ let res = null, err = null;
34
+ try { res = await fetch(B + '/game.wasm'); } catch (e) { err = e; }
35
+ if (res && res.ok) return res;
36
+ if (attempt >= 7) { if (res) throw new Error('HTTP ' + res.status + ' for game.wasm'); throw err; }
37
+ bc0.postMessage({ label: 'The server is busy, retrying (' + (attempt + 1) + ')' });
38
+ await new Promise((r) => setTimeout(r, Math.min(5000, 300 * 2 ** attempt) * (0.5 + Math.random())));
39
+ }
40
+ };
41
+ const bc0 = new BroadcastChannel('game-progress');
42
+ const start = () => {
43
+ const bc = new BroadcastChannel('game-progress');
44
+ self.Module = {
45
+ // Download game.wasm ourselves to report progress (0-20 %); emscripten hands the compiled module on to the pthread workers.
46
+ instantiateWasm: (imports, done) => {
47
+ // Streaming compilation: the module compiles while it downloads (no compile wait after the download, no 2 x 63 MB buffer copy, and Chrome can cache the
48
+ // compiled code of a fetched response for the next visit). Progress is counted on a clone of the response. Any failure falls back to download-then-compile.
49
+ const buffered = async () => {
50
+ const res = await fetchWasm();
51
+ const total = +(res.headers.get('X-Uncompressed-Length') || res.headers.get('Content-Length')) || 0;
52
+ const reader = res.body.getReader(), chunks = [];
53
+ let got = 0;
54
+ for (;;) {
55
+ const { done: end, value } = await reader.read();
56
+ if (end) break;
57
+ chunks.push(value);
58
+ got += value.length;
59
+ bc.postMessage({ pct: total ? 20 * got / total : 0, label: 'Downloading the engine (' + (got / 1048576 | 0) + ' MB)' });
60
+ }
61
+ const bytes = new Uint8Array(got);
62
+ let o = 0;
63
+ for (const c of chunks) { bytes.set(c, o); o += c.length; }
64
+ bc.postMessage({ pct: 20, label: 'Compiling the engine' });
65
+ return WebAssembly.instantiate(bytes, imports);
66
+ };
67
+ const streaming = async () => {
68
+ const res = await fetchWasm();
69
+ const total = +(res.headers.get('X-Uncompressed-Length') || res.headers.get('Content-Length')) || 0; // the body is decoded while it is read: count decoded bytes
70
+ const counter = res.clone().body.getReader();
71
+ (async () => {
72
+ let got = 0;
73
+ for (;;) {
74
+ const { done: end, value } = await counter.read();
75
+ if (end) break;
76
+ got += value.length;
77
+ bc.postMessage({ pct: total ? 20 * got / total : 0, label: 'Downloading and compiling the engine (' + (got / 1048576 | 0) + ' MB)' });
78
+ }
79
+ bc.postMessage({ pct: 20, label: 'Compiling the engine' });
80
+ })().catch(() => {});
81
+ return WebAssembly.instantiateStreaming(res, imports);
82
+ };
83
+ (async () => {
84
+ let r;
85
+ try { r = await streaming(); }
86
+ catch (e) { console.warn('streaming instantiation failed (' + e + '): downloading first'); r = await buffered(); }
87
+ bc.postMessage({ pct: 22, label: 'Starting the engine' });
88
+ done(r.instance, r.module);
89
+ })().catch((e) => { bc.postMessage({ error: 'engine download failed: ' + e }); });
90
+ return {};
91
+ },
92
+ canvas: m.canvas,
93
+ arguments: m.args,
94
+ wgpuWorker: gpu,
95
+ ioWorker: io,
96
+ fullConsole: !!m.fullConsole, // ?console=1: every engine line in the browser console (default: errors, warnings, the port's lines)
97
+ remoteLog: !!m.remoteLog, // ?log=1: every engine line to the dev server's log (prejs.js; default: none)
98
+ wgpuShaderUrl: B + '/shaders',
99
+ wgpuShotEvery: m.shotEvery,
100
+ keepThreads: m.keepThreads|0, // bit mask of engine thread groups that are NOT skipped (1 replay, 2 net, 4 bink), see ipc_wasm.cpp
101
+ mainScriptUrlOrBlob: B + '/game.js' + ((m.fullConsole || m.remoteLog) ? '?' + [m.fullConsole ? 'console=1' : '', m.remoteLog ? 'log=1' : ''].filter(Boolean).join('&') : ''), // pthreads read both from it, and take game.wasm's folder from it
102
+ locateFile: (p) => B + '/' + p,
103
+ onExit: (code) => { console.error('EXIT ' + code); self.__log('EXIT ' + code); self.__logFlush(); if (code) self.__crash('exit', 'EXIT ' + code); },
104
+ onAbort: (what) => { console.error('ABORT ' + what); self.__log('ABORT ' + what); self.__logFlush(); self.__crash('abort', 'ABORT ' + what); },
105
+ // Savegames and settings kept in IndexedDB by io_worker.js (platform/file/userdata_wasm.cpp sends them): put them back into the in-memory /userdata before the engine looks at it. The run
106
+ // dependency holds main() until they are in (or 8 s, so a broken IndexedDB cannot keep the game from starting). Only /userdata/ paths are accepted.
107
+ preRun: [() => {
108
+ if (typeof FS === 'undefined' || typeof addRunDependency !== 'function' || typeof indexedDB === 'undefined') return;
109
+ addRunDependency('userdata');
110
+ let finished = false;
111
+ const finish = (note) => { if (finished) return; finished = true; self.__log('[loader] userdata: ' + note); self.__logFlush(); removeRunDependency('userdata'); };
112
+ setTimeout(() => finish('timed out'), 8000);
113
+ try {
114
+ const r = indexedDB.open('gta5-userdata', 1);
115
+ r.onupgradeneeded = () => r.result.createObjectStore('files');
116
+ r.onerror = () => finish('IndexedDB unavailable: ' + r.error);
117
+ r.onsuccess = () => {
118
+ let n = 0, bytes = 0;
119
+ try {
120
+ const req = r.result.transaction('files', 'readonly').objectStore('files').openCursor();
121
+ req.onerror = () => finish('read failed: ' + req.error);
122
+ req.onsuccess = () => {
123
+ const c = req.result;
124
+ if (!c) { finish('restored ' + n + ' file(s), ' + bytes + ' bytes'); return; }
125
+ const path = String(c.key);
126
+ try {
127
+ if (path.startsWith('/userdata/') && c.value && c.value.data) {
128
+ FS.mkdirTree(path.slice(0, path.lastIndexOf('/')));
129
+ FS.writeFile(path, c.value.data);
130
+ FS.utime(path, c.value.mtime, c.value.mtime);
131
+ n++; bytes += c.value.data.length;
132
+ }
133
+ } catch (e) { self.__log('[loader] userdata: ' + path + ' not restored: ' + e); }
134
+ c.continue();
135
+ };
136
+ } catch (e) { finish('read failed: ' + e); }
137
+ };
138
+ } catch (e) { finish('failed: ' + e); }
139
+ }],
140
+ };
141
+ // __log/__logFlush come from prejs.js, which only exists once game.js is loaded: note the start line in the console.
142
+ console.log('loader: starting engine: ' + m.args.join(' ') + ' (cores ' + m.cores + ')');
143
+ importScripts(B + '/game.js');
144
+ };
145
+ gpu.onerror = (e) => console.error('gpu worker failed to load: ' + e.message);
146
+ };
b/8b0b5899ed/shaders/00241e5e1825408e.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [4294967295]
b/8b0b5899ed/shaders/00241e5e1825408e.wgsl ADDED
@@ -0,0 +1,95 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ struct cb73_struct {
12
+ tint_symbol : array<vec4<f32>, 73u>,
13
+ }
14
+
15
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb73_struct;
16
+
17
+ @group(1u) @binding(17u) var s1 : sampler;
18
+
19
+ @group(1u) @binding(26u) var s10 : sampler;
20
+
21
+ @group(1u) @binding(33u) var t1 : texture_2d<f32>;
22
+
23
+ @group(1u) @binding(42u) var t10 : texture_2d<f32>;
24
+
25
+ var<private> o0 : vec4<f32>;
26
+
27
+ struct tint_symbol_2 {
28
+ tint_symbol_1 : array<vec4<u32>, 1u>,
29
+ }
30
+
31
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_2;
32
+
33
+ fn main_inner(v1 : vec4<f32>) {
34
+ r0 = vec4<f32>(0.0f, 0.0f, 0.0f, bitcast<f32>(v.tint_symbol_1[0i].x));
35
+ loop {
36
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (1i < bitcast<i32>(r0.w))));
37
+ if ((bitcast<u32>(r1.x) != 0u)) {
38
+ break;
39
+ }
40
+ r1.y = f32(bitcast<i32>(r0.w));
41
+ let v_1 = r0;
42
+ r2 = vec4<f32>(v_1.xyz, r2.w);
43
+ r1.z = bitcast<f32>(v.tint_symbol_1[0i].x);
44
+ loop {
45
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (1i < bitcast<i32>(r1.z))));
46
+ if ((bitcast<u32>(r1.w) != 0u)) {
47
+ break;
48
+ }
49
+ r1.x = f32(bitcast<i32>(r1.z));
50
+ let v_2 = fma(cb5_5.tint_symbol[72u].xy, r1.xy, v1.xy);
51
+ r1 = vec4<f32>(v_2.x, r1.yz, v_2.y);
52
+ r3 = textureSample(t10, s10, r1.xwxx.xy);
53
+ let v_3 = fma(r3.xyz, vec3<f32>(0.11111111193895339966f), r2.xyz);
54
+ r2 = vec4<f32>(v_3.xyz, r2.w);
55
+ r1.z = bitcast<f32>((bitcast<i32>(r1.z) + 1i));
56
+ }
57
+ let v_4 = r2;
58
+ r0 = vec4<f32>(v_4.xyz, r0.w);
59
+ r0.w = bitcast<f32>((bitcast<i32>(r0.w) + 1i));
60
+ }
61
+ r1 = textureSample(t1, s1, vec2<f32>());
62
+ let v_5 = (r0.xyz * r1.xxx);
63
+ r1 = vec4<f32>(v_5.xyz, r1.w);
64
+ let v_6 = (r1.xyz * cb5_5.tint_symbol[8u].www);
65
+ r1 = vec4<f32>(v_6.xyz, r1.w);
66
+ r0.w = dot(r1.xyz, vec3<f32>(0.3333333134651184082f));
67
+ r0.w = max(r0.w, 0.00000000099999997172f);
68
+ let v_7 = -(cb5_5.tint_symbol[7u].xxxx);
69
+ r1.x = (r0.w + v_7.x);
70
+ r1.x = clamp(((r1.xxxx * cb5_5.tint_symbol[7u].zzzz)).x, 0.0f, 1.0f);
71
+ r1.x = (r0.w * r1.x);
72
+ let v_8 = bitcast<vec3<f32>>(select(vec3<u32>(), vec3<u32>(4294967295u), !((r0.xyz == r0.xyz))));
73
+ r1 = vec4<f32>(r1.x, v_8.xyz);
74
+ let v_9 = bitcast<vec3<f32>>((bitcast<vec3<u32>>(r0.xyz) & vec3<u32>(2147483647u)));
75
+ r2 = vec4<f32>(v_9.xyz, r2.w);
76
+ let v_10 = bitcast<vec3<f32>>(select(vec3<u32>(), vec3<u32>(4294967295u), (bitcast<vec3<i32>>(r2.xyz) == vec3<i32>(2139095040i))));
77
+ r2 = vec4<f32>(v_10.xyz, r2.w);
78
+ let v_11 = bitcast<vec3<f32>>((bitcast<vec3<u32>>(r1.yzw) | bitcast<vec3<u32>>(r2.xyz)));
79
+ r1 = vec4<f32>(r1.x, v_11.xyz);
80
+ let v_12 = max(r0.xyz, vec3<f32>());
81
+ r0 = vec4<f32>(v_12.xyz, r0.w);
82
+ r0.w = (r1.x / r0.w);
83
+ let v_13 = (r0.www * r0.xyz);
84
+ r0 = vec4<f32>(v_13.xyz, r0.w);
85
+ let v_14 = bitcast<vec3<u32>>(r1.yzw);
86
+ let v_15 = select(r0.xyz, vec3<f32>(1000.0f, 0.0f, 1000.0f), (v_14 != vec3<u32>()));
87
+ o0 = vec4<f32>(v_15.xyz, o0.w);
88
+ o0.w = 0.0f;
89
+ }
90
+
91
+ @fragment
92
+ fn main(@location(1u) v1 : vec4<f32>) -> @location(0u) vec4<f32> {
93
+ main_inner(v1);
94
+ return o0;
95
+ }
b/8b0b5899ed/shaders/0030c87264713865.wgsl ADDED
@@ -0,0 +1,89 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ struct cb46_struct {
10
+ tint_symbol : array<vec4<f32>, 46u>,
11
+ }
12
+
13
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb46_struct;
14
+
15
+ struct cb23_struct {
16
+ tint_symbol_1 : array<vec4<f32>, 23u>,
17
+ }
18
+
19
+ @group(1u) @binding(10u) var<uniform> cb10_10 : cb23_struct;
20
+
21
+ @group(1u) @binding(18u) var s2 : sampler;
22
+
23
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
24
+
25
+ var<private> o0 : vec4<f32>;
26
+
27
+ var<private> o1 : vec4<f32>;
28
+
29
+ var<private> o2 : vec4<f32>;
30
+
31
+ var<private> o3 : vec4<f32>;
32
+
33
+ fn main_inner(v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>) {
34
+ r0.x = v2.w;
35
+ r0.y = v3.w;
36
+ r0 = textureSample(t2, s2, r0.xyxx.xy);
37
+ r0.w = (r0.w * v1.w);
38
+ r0.w = (r0.w * cb10_10.tint_symbol_1[22u].x);
39
+ r0.w = (r0.w * cb10_10.tint_symbol_1[22u].w);
40
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (r0.w < cb10_10.tint_symbol_1[22u].y)));
41
+ v((bitcast<u32>(r1.x) != 0u));
42
+ r1.x = dot(v2.xyz, v2.xyz);
43
+ r1.x = inverseSqrt(r1.x);
44
+ let v_1 = (r1.xxx * v2.xyz);
45
+ r1 = vec4<f32>(v_1.xyz, r1.w);
46
+ let v_2 = (r0.xyz * v1.xyz);
47
+ r0 = vec4<f32>(v_2.xyz, r0.w);
48
+ let v_3 = -(r0.xyzx);
49
+ let v_4 = fma(r0.xyz, v4.xyz, v_3.xyz);
50
+ r2 = vec4<f32>(v_4.xyz, r2.w);
51
+ let v_5 = fma(v4.www, r2.xyz, r0.xyz);
52
+ o0 = vec4<f32>(v_5.xyz, o0.w);
53
+ let v_6 = fma(r1.xyz, vec3<f32>(0.5f), vec3<f32>(0.5f));
54
+ o1 = vec4<f32>(v_6.xyz, o1.w);
55
+ r0.x = (v5.x + cb3_3.tint_symbol[45u].w);
56
+ r0.x = (r0.x * 0.5f);
57
+ r0.y = 0.0f;
58
+ let v_7 = sqrt(r0.xy);
59
+ o3 = vec4<f32>(v_7.xy, o3.zw);
60
+ o0.w = r0.w;
61
+ o1.w = 1.0f;
62
+ o2 = vec4<f32>(0.0f, 0.0f, 0.98000001907348632812f, 1.0f);
63
+ o3.z = 0.0f;
64
+ o3.w = (cb10_10.tint_symbol_1[22u].z * 0.49607843160629272461f);
65
+ }
66
+
67
+ fn v(v_8 : bool) {
68
+ if (v_8) {
69
+ discard;
70
+ return;
71
+ }
72
+ }
73
+
74
+ struct tint_symbol_2 {
75
+ @location(0u)
76
+ o0 : vec4<f32>,
77
+ @location(1u)
78
+ o1 : vec4<f32>,
79
+ @location(2u)
80
+ o2 : vec4<f32>,
81
+ @location(3u)
82
+ o3 : vec4<f32>,
83
+ }
84
+
85
+ @fragment
86
+ fn main(@location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>) -> tint_symbol_2 {
87
+ main_inner(v1, v2, v3, v4, v5);
88
+ return tint_symbol_2(o0, o1, o2, o3);
89
+ }
b/8b0b5899ed/shaders/0035f4d295d61e54.wgsl ADDED
@@ -0,0 +1,188 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ struct cb765_struct {
20
+ tint_symbol : array<vec4<f32>, 765u>,
21
+ }
22
+
23
+ @group(0u) @binding(4u) var<uniform> cb4_4 : cb765_struct;
24
+
25
+ struct cb16_struct {
26
+ tint_symbol_1 : array<vec4<f32>, 16u>,
27
+ }
28
+
29
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
30
+
31
+ struct cb17_struct {
32
+ tint_symbol_2 : array<vec4<f32>, 17u>,
33
+ }
34
+
35
+ @group(0u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
36
+
37
+ struct cb18_struct {
38
+ tint_symbol_3 : array<vec4<f32>, 18u>,
39
+ }
40
+
41
+ @group(0u) @binding(13u) var<uniform> cb13_13 : cb18_struct;
42
+
43
+ struct cb2_struct {
44
+ tint_symbol_4 : array<vec4<f32>, 2u>,
45
+ }
46
+
47
+ @group(0u) @binding(8u) var<uniform> cb8_8 : cb2_struct;
48
+
49
+ var<private> o0 : vec4<f32>;
50
+
51
+ var<private> o1 : vec4<f32>;
52
+
53
+ var<private> o2 : vec4<f32>;
54
+
55
+ var<private> o3 : vec4<f32>;
56
+
57
+ var<private> o4 : vec4<f32>;
58
+
59
+ var<private> o5 : vec4<f32>;
60
+
61
+ var<private> o6 : vec4<f32>;
62
+
63
+ var<private> o7 : vec4<f32>;
64
+
65
+ fn main_inner(v0 : vec3<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec2<f32>, v4 : vec3<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v7 : vec4<f32>) {
66
+ r0.x = (v7.y * 6.28318500518798828125f);
67
+ let v = (cb13_13.tint_symbol_3[1u].zzw * cb8_8.tint_symbol_4[1u].zzw);
68
+ r0 = vec4<f32>(r0.x, v.xyz);
69
+ let v_1 = fma(cb2_2.tint_symbol_2[16u].xxx, r0.yzw, r0.xxx);
70
+ r0 = vec4<f32>(v_1.xyz, r0.w);
71
+ let v_2 = sin(r0.xyzx.xyz);
72
+ r0 = vec4<f32>(v_2.xyz, r0.w);
73
+ let v_3 = (v7.xxz * cb8_8.tint_symbol_4[1u].xxy);
74
+ r1 = vec4<f32>(v_3.xyz, r1.w);
75
+ let v_4 = (r1.xyz * cb13_13.tint_symbol_3[1u].xxy);
76
+ r1 = vec4<f32>(v_4.xyz, r1.w);
77
+ r2 = (v2 * vec4<f32>(255.001953125f));
78
+ let v_5 = r2;
79
+ let v_6 = max(v_5, vec4<f32>(-2147483648.0f));
80
+ r2 = bitcast<vec4<f32>>(select(select(vec4<i32>(v_6), vec4<i32>(2147483647i), (v_6 >= vec4<f32>(2147483648.0f))), vec4<i32>(), !((v_5 == v_5))));
81
+ r2 = bitcast<vec4<f32>>((bitcast<vec4<i32>>(r2) * vec4<i32>(3i)));
82
+ r3 = (v1.yyyy * cb4_4.tint_symbol[bitcast<i32>(r2.y)]);
83
+ r3 = fma(cb4_4.tint_symbol[bitcast<i32>(r2.x)], v1.xxxx, r3);
84
+ r3 = fma(cb4_4.tint_symbol[bitcast<i32>(r2.z)], v1.zzzz, r3);
85
+ r3 = fma(cb4_4.tint_symbol[bitcast<i32>(r2.w)], v1.wwww, r3);
86
+ r4 = vec4<f32>(v0.xyz, r4.w);
87
+ r4.w = 1.0f;
88
+ r5.x = dot(r3, r4);
89
+ r6 = (v1.yyyy * cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.y) + 1i))]);
90
+ r6 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.x) + 1i))], v1.xxxx, r6);
91
+ r6 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.z) + 1i))], v1.zzzz, r6);
92
+ r6 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.w) + 1i))], v1.wwww, r6);
93
+ r5.y = dot(r6, r4);
94
+ r7 = (v1.yyyy * cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.y) + 2i))]);
95
+ r7 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.x) + 2i))], v1.xxxx, r7);
96
+ r7 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.z) + 2i))], v1.zzzz, r7);
97
+ r2 = fma(cb4_4.tint_symbol[bitcast<u32>((bitcast<i32>(r2.w) + 2i))], v1.wwww, r7);
98
+ r5.z = dot(r2, r4);
99
+ let v_7 = fma(r0.xyz, r1.xyz, r5.xyz);
100
+ r0 = vec4<f32>(v_7.xyz, r0.w);
101
+ let v_8 = (r5.yyy * cb1_1.tint_symbol_1[1u].xyz);
102
+ r1 = vec4<f32>(v_8.xyz, r1.w);
103
+ let v_9 = fma(r5.xxx, cb1_1.tint_symbol_1[0u].xyz, r1.xyz);
104
+ r1 = vec4<f32>(v_9.xyz, r1.w);
105
+ let v_10 = fma(r5.zzz, cb1_1.tint_symbol_1[2u].xyz, r1.xyz);
106
+ r1 = vec4<f32>(v_10.xyz, r1.w);
107
+ let v_11 = (r1.xyz + cb1_1.tint_symbol_1[3u].xyz);
108
+ r1 = vec4<f32>(v_11.xyz, r1.w);
109
+ o4 = (((-(r1.xyzx)).xyz + cb1_1.tint_symbol_1[15u].xyz)).xyzx;
110
+ r1 = (r0.yyyy * cb1_1.tint_symbol_1[9u]);
111
+ r1 = fma(r0.xxxx, cb1_1.tint_symbol_1[8u], r1);
112
+ r0 = fma(r0.zzzz, cb1_1.tint_symbol_1[10u], r1);
113
+ o0 = (r0 + cb1_1.tint_symbol_1[11u]);
114
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (cb13_13.tint_symbol_3[0u].w < 0.0f)));
115
+ r0.x = select(v0.z, 0.0f, (bitcast<u32>(r0.x) != 0u));
116
+ let v_12 = -(cb13_13.tint_symbol_3[0u].xyxx);
117
+ let v_13 = (r0.xx + v_12.xy);
118
+ r0 = vec4<f32>(v_13.xy, r0.zw);
119
+ let v_14 = clamp(((r0.xyxx / cb13_13.tint_symbol_3[17u].wwww)).xy, vec2<f32>(), vec2<f32>(1.0f));
120
+ r0 = vec4<f32>(v_14.xy, r0.zw);
121
+ r0.z = ((-(cb13_13.tint_symbol_3[0u].zzzz)).z + cb13_13.tint_symbol_3[0u].w);
122
+ r0.x = fma(r0.x, r0.z, cb13_13.tint_symbol_3[0u].z);
123
+ r0.y = ((-(r0.yyyy)).y + 1.0f);
124
+ r0.x = (r0.y * r0.x);
125
+ r0.y = (v7.w * cb13_13.tint_symbol_3[2u].w);
126
+ let v_15 = abs(r0.xxxx);
127
+ o1.z = max(r0.y, v_15.z);
128
+ o1 = vec3<f32>(v3.xy, o1.xyz.z).xyzx;
129
+ r0.x = dot(r6.xyz, v4);
130
+ r0.y = dot(r6.xyz, v5.xyz);
131
+ let v_16 = (r0.yyy * cb1_1.tint_symbol_1[1u].xyz);
132
+ r0 = vec4<f32>(r0.x, v_16.xyz);
133
+ let v_17 = (r0.xxx * cb1_1.tint_symbol_1[1u].xyz);
134
+ r1 = vec4<f32>(v_17.xyz, r1.w);
135
+ r0.x = dot(r3.xyz, v4);
136
+ r1.w = dot(r3.xyz, v5.xyz);
137
+ let v_18 = fma(r1.www, cb1_1.tint_symbol_1[0u].xyz, r0.yzw);
138
+ r0 = vec4<f32>(r0.x, v_18.xyz);
139
+ let v_19 = fma(r0.xxx, cb1_1.tint_symbol_1[0u].xyz, r1.xyz);
140
+ r1 = vec4<f32>(v_19.xyz, r1.w);
141
+ r0.x = dot(r2.xyz, v4);
142
+ r1.w = dot(r2.xyz, v5.xyz);
143
+ let v_20 = fma(r1.www, cb1_1.tint_symbol_1[2u].xyz, r0.yzw);
144
+ r0 = vec4<f32>(r0.x, v_20.xyz);
145
+ let v_21 = fma(r0.xxx, cb1_1.tint_symbol_1[2u].xyz, r1.xyz);
146
+ r1 = vec4<f32>(v_21.xyz, r1.w);
147
+ o2 = r1.xyz.xyzx;
148
+ o3 = vec4<f32>(v6.xyz, o3.w);
149
+ o3.w = 1.0f;
150
+ o5 = r0.yzw.xyzx;
151
+ let v_22 = (r0.wyz * r1.yzx);
152
+ r2 = vec4<f32>(v_22.xyz, r2.w);
153
+ let v_23 = -(r2.xyzx);
154
+ let v_24 = fma(r0.zwy, r1.zxy, v_23.xyz);
155
+ r0 = vec4<f32>(v_24.xyz, r0.w);
156
+ o6 = ((r0.xyz * v5.www)).xyzx;
157
+ o7.y = fma((-(v6.yyyy)).y, 25.5f, 1.0f);
158
+ r0 = vec4<f32>(((v6.yy + vec2<f32>(0.52941179275512695312f, -0.03921568766236305237f))).xy, r0.zw);
159
+ r0.z = (r0.x * r0.x);
160
+ o7.z = (r0.x * r0.z);
161
+ r0.x = (r0.y * cb2_2.tint_symbol_2[16u].w);
162
+ o7.x = (r0.x * 0.96078431606292724609f);
163
+ }
164
+
165
+ struct tint_symbol_5 {
166
+ @builtin(position)
167
+ o0 : vec4<f32>,
168
+ @location(1u)
169
+ o1 : vec4<f32>,
170
+ @location(2u)
171
+ o2 : vec4<f32>,
172
+ @location(3u)
173
+ o3 : vec4<f32>,
174
+ @location(4u)
175
+ o4 : vec4<f32>,
176
+ @location(5u)
177
+ o5 : vec4<f32>,
178
+ @location(6u)
179
+ o6 : vec4<f32>,
180
+ @location(7u)
181
+ o7 : vec4<f32>,
182
+ }
183
+
184
+ @vertex
185
+ fn main(@location(0u) v0 : vec3<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec2<f32>, @location(4u) v4 : vec3<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @location(7u) v7 : vec4<f32>) -> tint_symbol_5 {
186
+ main_inner(v0, v1, v2, v3, v4, v5, v6, v7);
187
+ return tint_symbol_5(o0, o1, o2, o3, o4, o5, o6, o7);
188
+ }
b/8b0b5899ed/shaders/00395a471b59502d.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/00395a471b59502d.wgsl ADDED
@@ -0,0 +1,810 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ struct cb16_struct {
46
+ tint_symbol : array<vec4<f32>, 16u>,
47
+ }
48
+
49
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
50
+
51
+ struct cb18_struct {
52
+ tint_symbol_1 : array<vec4<f32>, 18u>,
53
+ }
54
+
55
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb18_struct;
56
+
57
+ struct cb59_struct {
58
+ tint_symbol_2 : array<vec4<f32>, 59u>,
59
+ }
60
+
61
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
62
+
63
+ struct cb1_struct {
64
+ tint_symbol_3 : array<vec4<f32>, 1u>,
65
+ }
66
+
67
+ @group(1u) @binding(11u) var<uniform> cb11_11 : cb1_struct;
68
+
69
+ struct cb15_struct {
70
+ tint_symbol_4 : array<vec4<f32>, 15u>,
71
+ }
72
+
73
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
74
+
75
+ @group(1u) @binding(16u) var s0 : sampler;
76
+
77
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
78
+
79
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
80
+
81
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
82
+
83
+ var<private> v8 : array<f32, 4u>;
84
+
85
+ var<private> o0 : vec4<f32>;
86
+
87
+ var<private> x0 : array<vec4<f32>, 4u>;
88
+
89
+ var<private> x1 : array<vec4<f32>, 1u>;
90
+
91
+ struct tint_symbol_6 {
92
+ tint_symbol_5 : array<vec4<u32>, 4u>,
93
+ }
94
+
95
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_6;
96
+
97
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v6 : vec4<f32>) {
98
+ x1[0u].x = v8[0u];
99
+ x1[0u].y = v8[1u];
100
+ x1[0u].z = v8[2u];
101
+ x1[0u].w = v8[3u];
102
+ r0 = textureSample(t0, s0, v0.xy.xyxx.xy);
103
+ let v_1 = (r0.xyz * cb11_11.tint_symbol_3[0u].xyz);
104
+ r0 = vec4<f32>(v_1.xyz, r0.w);
105
+ r0 = (r0 * v6.xxxw);
106
+ let v_2 = (v6.xx * cb2_2.tint_symbol_1[15u].zy);
107
+ r1 = vec4<f32>(v_2.xy, r1.zw);
108
+ r1.z = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).z, 0.0f, 1.0f);
109
+ r1.y = (r1.z * r1.y);
110
+ let v_3 = (r0.xyz * r0.xyz);
111
+ r0 = vec4<f32>(v_3.xyz, r0.w);
112
+ let v_4 = -(v2.xyzx);
113
+ let v_5 = (v_4.xyz + cb1_1.tint_symbol[15u].xyz);
114
+ r2 = vec4<f32>(v_5.xyz, r2.w);
115
+ r1.z = dot(r2.xyz, cb1_1.tint_symbol[14u].xyz);
116
+ let v_6 = (v2.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
117
+ r2 = vec4<f32>(v_6.xyz, r2.w);
118
+ let v_7 = (r2.yyy * cb6_6.tint_symbol_4[1u].xyz);
119
+ r3 = vec4<f32>(v_7.xyz, r3.w);
120
+ let v_8 = fma(r2.xxx, cb6_6.tint_symbol_4[0u].xyz, r3.xyz);
121
+ r3 = vec4<f32>(v_8.xyz, r3.w);
122
+ let v_9 = fma(r2.zzz, cb6_6.tint_symbol_4[2u].xyz, r3.xyz);
123
+ r3 = vec4<f32>(v_9.xyz, r3.w);
124
+ let v_10 = fma(r3.xyz, cb6_6.tint_symbol_4[4u].xyz, cb6_6.tint_symbol_4[8u].xyz);
125
+ r4 = vec4<f32>(v_10.xyz, r4.w);
126
+ let v_11 = &(x0[0u]);
127
+ let v_12 = r4;
128
+ *(v_11) = vec4<f32>(v_12.xyz, (*(v_11)).w);
129
+ let v_13 = fma(r3.xyz, cb6_6.tint_symbol_4[5u].xyz, cb6_6.tint_symbol_4[9u].xyz);
130
+ r5 = vec4<f32>(v_13.xyz, r5.w);
131
+ let v_14 = &(x0[1u]);
132
+ let v_15 = r5;
133
+ *(v_14) = vec4<f32>(v_15.xyz, (*(v_14)).w);
134
+ let v_16 = fma(r3.xyz, cb6_6.tint_symbol_4[6u].xyz, cb6_6.tint_symbol_4[10u].xyz);
135
+ r6 = vec4<f32>(v_16.xyz, r6.w);
136
+ let v_17 = &(x0[2u]);
137
+ let v_18 = r6;
138
+ *(v_17) = vec4<f32>(v_18.xyz, (*(v_17)).w);
139
+ let v_19 = fma(r3.xyz, cb6_6.tint_symbol_4[7u].xyz, cb6_6.tint_symbol_4[11u].xyz);
140
+ r3 = vec4<f32>(v_19.xyz, r3.w);
141
+ let v_20 = &(x0[3u]);
142
+ let v_21 = r3;
143
+ *(v_20) = vec4<f32>(v_21.xyz, (*(v_20)).w);
144
+ let v_22 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
145
+ let v_23 = r7;
146
+ r7 = vec4<f32>(v_23.x, v_22.x, v_23.z, v_22.y);
147
+ r1.w = fma((-(cb6_6.tint_symbol_4[14u].zzzz)).w, 1.5f, 1.0f);
148
+ r1.w = (r1.w * 0.5f);
149
+ let v_24 = abs(r6.yyyy);
150
+ r2.w = max(v_24.w, abs(r6.xxxx).w);
151
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (r2.w < r1.w)));
152
+ let v_25 = (bitcast<u32>(r2.w) != 0u);
153
+ let v_26 = bitcast<f32>(v.tint_symbol_5[0i].x);
154
+ r2.w = select(bitcast<f32>(v.tint_symbol_5[1i].x), v_26, v_25);
155
+ let v_27 = abs(r5.yyyy);
156
+ r3.z = max(v_27.z, abs(r5.xxxx).z);
157
+ r3.z = bitcast<f32>(select(0u, 4294967295u, (r3.z < r1.w)));
158
+ let v_28 = bitcast<u32>(r3.z);
159
+ r2.w = select(r2.w, bitcast<f32>(v.tint_symbol_5[2i].x), (v_28 != 0u));
160
+ let v_29 = abs(r4.yyyy);
161
+ r3.z = max(v_29.z, abs(r4.xxxx).z);
162
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (r3.z < r1.w)));
163
+ let v_30 = bitcast<u32>(r1.w);
164
+ r1.w = select(r2.w, 0.0f, (v_30 != 0u));
165
+ let v_31 = x0[bitcast<i32>(r1.w)];
166
+ r4 = vec4<f32>(v_31.xyz, r4.w);
167
+ r1.w = f32(bitcast<i32>(r1.w));
168
+ r2.w = (r1.w + 0.5f);
169
+ r2.w = (r2.w * 0.25f);
170
+ r5 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r1.wwww)));
171
+ r5 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r5) & vec4<u32>(1065353216u)));
172
+ r1.w = dot(r5, cb6_6.tint_symbol_4[12u]);
173
+ r3.z = dot(r5, cb6_6.tint_symbol_4[13u]);
174
+ r5.x = (r4.x + 0.5f);
175
+ r5.y = fma(r4.y, 0.25f, r2.w);
176
+ r2.w = bitcast<f32>(select(0u, 4294967295u, !((r1.w == 0.0f))));
177
+ r1.w = ((-(r1.wwww)).w + r4.z);
178
+ let v_32 = dpdx(r5.xyy);
179
+ r6 = vec4<f32>(v_32.xy, r6.z, v_32.z);
180
+ r6.z = dpdx(r1.w);
181
+ let v_33 = dpdy(r5.yxy);
182
+ r8 = vec4<f32>(v_33.xyz, r8.w);
183
+ r8.w = dpdy(r1.w);
184
+ let v_34 = (r6.yw * r8.yw);
185
+ r4 = vec4<f32>(v_34.xy, r4.zw);
186
+ let v_35 = -(r4.xyxx);
187
+ let v_36 = fma(r6.xz, r8.xz, v_35.xy);
188
+ r9 = vec4<f32>(v_36.xy, r9.zw);
189
+ r3.w = (1.0f / r9.x);
190
+ r4.x = (r6.z * r8.y);
191
+ let v_37 = -(r4.xxxx);
192
+ r9.z = fma(r6.x, r8.w, v_37.z);
193
+ let v_38 = (r3.ww * r9.yz);
194
+ r4 = vec4<f32>(v_38.xy, r4.zw);
195
+ let v_39 = max(r4.xy, vec2<f32>());
196
+ r4 = vec4<f32>(v_39.xy, r4.zw);
197
+ let v_40 = min(r4.xy, vec2<f32>(0.5f));
198
+ r4 = vec4<f32>(v_40.xy, r4.zw);
199
+ r1.w = fma((-(r3.zzzz)).w, r4.x, r1.w);
200
+ r1.w = fma((-(r3.zzzz)).w, r4.y, r1.w);
201
+ let v_41 = bitcast<u32>(r2.w);
202
+ let v_42 = r1.w;
203
+ r7.z = select(r4.z, v_42, (v_41 != 0u));
204
+ r5.z = 0.0f;
205
+ let v_43 = (r5.xyz + r7.ywz);
206
+ r4 = vec4<f32>(v_43.xyz, r4.w);
207
+ let v_44 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
208
+ r7 = vec4<f32>(v_44.xy, r7.zw);
209
+ let v_45 = (r5.xyz + r7.xyz);
210
+ r6 = vec4<f32>(v_45.xyz, r6.w);
211
+ let v_46 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
212
+ r7 = vec4<f32>(v_46.xy, r7.zw);
213
+ let v_47 = (r5.xyz + r7.xyz);
214
+ r8 = vec4<f32>(v_47.xyz, r8.w);
215
+ let v_48 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
216
+ r7 = vec4<f32>(v_48.xy, r7.zw);
217
+ let v_49 = (r5.xyz + r7.xyz);
218
+ r9 = vec4<f32>(v_49.xyz, r9.w);
219
+ let v_50 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
220
+ r7 = vec4<f32>(v_50.xy, r7.zw);
221
+ let v_51 = (r5.xyz + r7.xyz);
222
+ r10 = vec4<f32>(v_51.xyz, r10.w);
223
+ let v_52 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
224
+ r7 = vec4<f32>(v_52.xy, r7.zw);
225
+ let v_53 = (r5.xyz + r7.xyz);
226
+ r11 = vec4<f32>(v_53.xyz, r11.w);
227
+ let v_54 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
228
+ r7 = vec4<f32>(v_54.xy, r7.zw);
229
+ let v_55 = (r5.xyz + r7.xyz);
230
+ r12 = vec4<f32>(v_55.xyz, r12.w);
231
+ let v_56 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
232
+ r7 = vec4<f32>(v_56.xy, r7.zw);
233
+ let v_57 = (r5.xyz + r7.xyz);
234
+ r13 = vec4<f32>(v_57.xyz, r13.w);
235
+ let v_58 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
236
+ r7 = vec4<f32>(v_58.xy, r7.zw);
237
+ let v_59 = (r5.xyz + r7.xyz);
238
+ r14 = vec4<f32>(v_59.xyz, r14.w);
239
+ let v_60 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
240
+ r7 = vec4<f32>(v_60.xy, r7.zw);
241
+ let v_61 = (r5.xyz + r7.xyz);
242
+ r15 = vec4<f32>(v_61.xyz, r15.w);
243
+ let v_62 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
244
+ r7 = vec4<f32>(v_62.xy, r7.zw);
245
+ let v_63 = (r5.xyz + r7.xyz);
246
+ r16 = vec4<f32>(v_63.xyz, r16.w);
247
+ let v_64 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
248
+ r7 = vec4<f32>(v_64.xy, r7.zw);
249
+ let v_65 = (r5.xyz + r7.xyz);
250
+ r17 = vec4<f32>(v_65.xyz, r17.w);
251
+ let v_66 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
252
+ r7 = vec4<f32>(v_66.xy, r7.zw);
253
+ let v_67 = (r5.xyz + r7.xyz);
254
+ r18 = vec4<f32>(v_67.xyz, r18.w);
255
+ let v_68 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
256
+ r7 = vec4<f32>(v_68.xy, r7.zw);
257
+ let v_69 = (r5.xyz + r7.xyz);
258
+ r19 = vec4<f32>(v_69.xyz, r19.w);
259
+ let v_70 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
260
+ r7 = vec4<f32>(v_70.xy, r7.zw);
261
+ let v_71 = (r5.xyz + r7.xyz);
262
+ r20 = vec4<f32>(v_71.xyz, r20.w);
263
+ let v_72 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
264
+ r7 = vec4<f32>(v_72.xy, r7.zw);
265
+ let v_73 = (r5.xyz + r7.xyz);
266
+ r5 = vec4<f32>(v_73.xyz, r5.w);
267
+ let v_74 = r4.xyxx;
268
+ r4.x = textureSampleCompareLevel(t15, s15, v_74.xy, r4.z);
269
+ let v_75 = r6.xyxx;
270
+ r4.y = textureSampleCompareLevel(t15, s15, v_75.xy, r6.z);
271
+ let v_76 = r8.xyxx;
272
+ r4.z = textureSampleCompareLevel(t15, s15, v_76.xy, r8.z);
273
+ let v_77 = r9.xyxx;
274
+ r4.w = textureSampleCompareLevel(t15, s15, v_77.xy, r9.z);
275
+ let v_78 = r10.xyxx;
276
+ r6.x = textureSampleCompareLevel(t15, s15, v_78.xy, r10.z);
277
+ let v_79 = r11.xyxx;
278
+ r6.y = textureSampleCompareLevel(t15, s15, v_79.xy, r11.z);
279
+ let v_80 = r12.xyxx;
280
+ r6.z = textureSampleCompareLevel(t15, s15, v_80.xy, r12.z);
281
+ let v_81 = r13.xyxx;
282
+ r6.w = textureSampleCompareLevel(t15, s15, v_81.xy, r13.z);
283
+ let v_82 = r14.xyxx;
284
+ r7.x = textureSampleCompareLevel(t15, s15, v_82.xy, r14.z);
285
+ let v_83 = r15.xyxx;
286
+ r7.y = textureSampleCompareLevel(t15, s15, v_83.xy, r15.z);
287
+ let v_84 = r16.xyxx;
288
+ r7.z = textureSampleCompareLevel(t15, s15, v_84.xy, r16.z);
289
+ let v_85 = r17.xyxx;
290
+ r7.w = textureSampleCompareLevel(t15, s15, v_85.xy, r17.z);
291
+ let v_86 = r18.xyxx;
292
+ r8.x = textureSampleCompareLevel(t15, s15, v_86.xy, r18.z);
293
+ let v_87 = r19.xyxx;
294
+ r8.y = textureSampleCompareLevel(t15, s15, v_87.xy, r19.z);
295
+ let v_88 = r20.xyxx;
296
+ r8.z = textureSampleCompareLevel(t15, s15, v_88.xy, r20.z);
297
+ let v_89 = r5.xyxx;
298
+ r8.w = textureSampleCompareLevel(t15, s15, v_89.xy, r5.z);
299
+ r4 = (r4 + r6);
300
+ r4 = (r7 + r4);
301
+ r4 = (r8 + r4);
302
+ r1.w = dot(r4, vec4<f32>(1.0f));
303
+ r1.z = clamp(fma(r1.zzzz, cb6_6.tint_symbol_4[0u].wwww, cb6_6.tint_symbol_4[1u].wwww).z, 0.0f, 1.0f);
304
+ let v_90 = abs(r3.yyyy);
305
+ r2.w = max(v_90.w, abs(r3.xxxx).w);
306
+ r2.w = clamp(fma(r2.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
307
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
308
+ r1.z = (r2.w * r1.z);
309
+ r1.z = fma(r1.w, 0.0625f, r1.z);
310
+ let v_91 = (r1.xyz * r1.xyz);
311
+ r1 = vec4<f32>(v_91.xyz, r1.w);
312
+ r1.z = min(r1.z, 1.0f);
313
+ r1.w = clamp(fma(v2.zzzz, cb6_6.tint_symbol_4[3u].xxxx, cb6_6.tint_symbol_4[3u].yyyy).w, 0.0f, 1.0f);
314
+ r1.w = sqrt(r1.w);
315
+ r1.w = (r1.w * cb6_6.tint_symbol_4[3u].z);
316
+ let v_92 = -(r1.zzzz);
317
+ r1.z = fma(r1.w, v_92.z, r1.z);
318
+ let v_93 = dot(v1.xyz, (-(cb3_3.tint_symbol_2[0u].xyzx)).xyz);
319
+ r1.w = clamp(vec4<f32>(v_93, v_93, v_93, v_93).w, 0.0f, 1.0f);
320
+ let v_94 = (r0.xyz * r1.www);
321
+ r3 = vec4<f32>(v_94.xyz, r3.w);
322
+ let v_95 = (r3.xyz * cb3_3.tint_symbol_2[1u].xyz);
323
+ r3 = vec4<f32>(v_95.xyz, r3.w);
324
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
325
+ if ((bitcast<u32>(r1.w) != 0u)) {
326
+ r4 = vec4<f32>(vec3<f32>(), r4.w);
327
+ } else {
328
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
329
+ let v_96 = (v_4.xyz + cb3_3.tint_symbol_2[3u].xyz);
330
+ r4 = vec4<f32>(v_96.xyz, r4.w);
331
+ let v_97 = (v2.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
332
+ r5 = vec4<f32>(v_97.xyz, r5.w);
333
+ r3.w = dot(r5.xyz, cb3_3.tint_symbol_2[11u].xyz);
334
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
335
+ r3.w = (r3.w * cb3_3.tint_symbol_2[19u].w);
336
+ let v_98 = fma(cb3_3.tint_symbol_2[11u].xyz, r3.www, cb3_3.tint_symbol_2[3u].xyz);
337
+ r5 = vec4<f32>(v_98.xyz, r5.w);
338
+ let v_99 = (r5.xyz + v_4.xyz);
339
+ r5 = vec4<f32>(v_99.xyz, r5.w);
340
+ let v_100 = bitcast<vec3<u32>>(r2.www);
341
+ let v_101 = r4.xyz;
342
+ let v_102 = select(r5.xyz, v_101, (v_100 != vec3<u32>()));
343
+ r4 = vec4<f32>(v_102.xyz, r4.w);
344
+ r2.w = dot(r4.xyz, r4.xyz);
345
+ let v_103 = (r4.xyz + vec3<f32>(0.00000099999999747524f));
346
+ r4 = vec4<f32>(v_103.xyz, r4.w);
347
+ r3.w = dot(r4.xyz, r4.xyz);
348
+ r3.w = inverseSqrt(r3.w);
349
+ let v_104 = (r3.www * r4.xyz);
350
+ r4 = vec4<f32>(v_104.xyz, r4.w);
351
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
352
+ r3.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
353
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[11u].w);
354
+ r2.w = (r2.w / r3.w);
355
+ let v_105 = -(cb3_3.tint_symbol_2[11u].xyzx);
356
+ r3.w = dot(r4.xyz, v_105.xyz);
357
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
358
+ let v_106 = dot(r4.xyz, v1.xyz);
359
+ r4.x = clamp(vec4<f32>(v_106, v_106, v_106, v_106).x, 0.0f, 1.0f);
360
+ r3.w = (r3.w * r4.x);
361
+ r2.w = (r2.w * r3.w);
362
+ let v_107 = (r2.www * cb3_3.tint_symbol_2[19u].xyz);
363
+ r4 = vec4<f32>(v_107.xyz, r4.w);
364
+ let v_108 = (r0.xyz * r4.xyz);
365
+ r4 = vec4<f32>(v_108.xyz, r4.w);
366
+ }
367
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
368
+ if ((bitcast<u32>(r2.w) != 0u)) {
369
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
370
+ r2.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
371
+ let v_109 = bitcast<u32>(r3.w);
372
+ let v_110 = r2.w;
373
+ r1.w = select(r1.w, v_110, (v_109 != 0u));
374
+ if ((bitcast<u32>(r1.w) != 0u)) {
375
+ } else {
376
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
377
+ let v_111 = (v_4.xyz + cb3_3.tint_symbol_2[4u].xyz);
378
+ r5 = vec4<f32>(v_111.xyz, r5.w);
379
+ let v_112 = (v2.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
380
+ r6 = vec4<f32>(v_112.xyz, r6.w);
381
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[12u].xyz);
382
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
383
+ r3.w = (r3.w * cb3_3.tint_symbol_2[20u].w);
384
+ let v_113 = fma(cb3_3.tint_symbol_2[12u].xyz, r3.www, cb3_3.tint_symbol_2[4u].xyz);
385
+ r6 = vec4<f32>(v_113.xyz, r6.w);
386
+ let v_114 = (r6.xyz + v_4.xyz);
387
+ r6 = vec4<f32>(v_114.xyz, r6.w);
388
+ let v_115 = bitcast<vec3<u32>>(r2.www);
389
+ let v_116 = r5.xyz;
390
+ let v_117 = select(r6.xyz, v_116, (v_115 != vec3<u32>()));
391
+ r5 = vec4<f32>(v_117.xyz, r5.w);
392
+ r2.w = dot(r5.xyz, r5.xyz);
393
+ let v_118 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
394
+ r5 = vec4<f32>(v_118.xyz, r5.w);
395
+ r3.w = dot(r5.xyz, r5.xyz);
396
+ r3.w = inverseSqrt(r3.w);
397
+ let v_119 = (r3.www * r5.xyz);
398
+ r5 = vec4<f32>(v_119.xyz, r5.w);
399
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
400
+ r3.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
401
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[12u].w);
402
+ r2.w = (r2.w / r3.w);
403
+ let v_120 = -(cb3_3.tint_symbol_2[12u].xyzx);
404
+ r3.w = dot(r5.xyz, v_120.xyz);
405
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
406
+ let v_121 = dot(r5.xyz, v1.xyz);
407
+ r4.w = clamp(vec4<f32>(v_121, v_121, v_121, v_121).w, 0.0f, 1.0f);
408
+ r3.w = (r3.w * r4.w);
409
+ r2.w = (r2.w * r3.w);
410
+ let v_122 = (r2.www * cb3_3.tint_symbol_2[20u].xyz);
411
+ r5 = vec4<f32>(v_122.xyz, r5.w);
412
+ let v_123 = fma(r5.xyz, r0.xyz, r4.xyz);
413
+ r4 = vec4<f32>(v_123.xyz, r4.w);
414
+ }
415
+ } else {
416
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
417
+ }
418
+ if ((bitcast<u32>(r1.w) != 0u)) {
419
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
420
+ } else {
421
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
422
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
423
+ if ((bitcast<u32>(r1.w) != 0u)) {
424
+ } else {
425
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
426
+ let v_124 = (v_4.xyz + cb3_3.tint_symbol_2[5u].xyz);
427
+ r5 = vec4<f32>(v_124.xyz, r5.w);
428
+ let v_125 = (v2.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
429
+ r6 = vec4<f32>(v_125.xyz, r6.w);
430
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[13u].xyz);
431
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
432
+ r3.w = (r3.w * cb3_3.tint_symbol_2[21u].w);
433
+ let v_126 = fma(cb3_3.tint_symbol_2[13u].xyz, r3.www, cb3_3.tint_symbol_2[5u].xyz);
434
+ r6 = vec4<f32>(v_126.xyz, r6.w);
435
+ let v_127 = (r6.xyz + v_4.xyz);
436
+ r6 = vec4<f32>(v_127.xyz, r6.w);
437
+ let v_128 = bitcast<vec3<u32>>(r2.www);
438
+ let v_129 = r5.xyz;
439
+ let v_130 = select(r6.xyz, v_129, (v_128 != vec3<u32>()));
440
+ r5 = vec4<f32>(v_130.xyz, r5.w);
441
+ r2.w = dot(r5.xyz, r5.xyz);
442
+ let v_131 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
443
+ r5 = vec4<f32>(v_131.xyz, r5.w);
444
+ r3.w = dot(r5.xyz, r5.xyz);
445
+ r3.w = inverseSqrt(r3.w);
446
+ let v_132 = (r3.www * r5.xyz);
447
+ r5 = vec4<f32>(v_132.xyz, r5.w);
448
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
449
+ r3.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
450
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[13u].w);
451
+ r2.w = (r2.w / r3.w);
452
+ let v_133 = -(cb3_3.tint_symbol_2[13u].xyzx);
453
+ r3.w = dot(r5.xyz, v_133.xyz);
454
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
455
+ let v_134 = dot(r5.xyz, v1.xyz);
456
+ r4.w = clamp(vec4<f32>(v_134, v_134, v_134, v_134).w, 0.0f, 1.0f);
457
+ r3.w = (r3.w * r4.w);
458
+ r2.w = (r2.w * r3.w);
459
+ let v_135 = (r2.www * cb3_3.tint_symbol_2[21u].xyz);
460
+ r5 = vec4<f32>(v_135.xyz, r5.w);
461
+ let v_136 = fma(r5.xyz, r0.xyz, r4.xyz);
462
+ r4 = vec4<f32>(v_136.xyz, r4.w);
463
+ }
464
+ }
465
+ if ((bitcast<u32>(r1.w) != 0u)) {
466
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
467
+ } else {
468
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
469
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
470
+ if ((bitcast<u32>(r1.w) != 0u)) {
471
+ } else {
472
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
473
+ let v_137 = (v_4.xyz + cb3_3.tint_symbol_2[6u].xyz);
474
+ r5 = vec4<f32>(v_137.xyz, r5.w);
475
+ let v_138 = (v2.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
476
+ r6 = vec4<f32>(v_138.xyz, r6.w);
477
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[14u].xyz);
478
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
479
+ r3.w = (r3.w * cb3_3.tint_symbol_2[22u].w);
480
+ let v_139 = fma(cb3_3.tint_symbol_2[14u].xyz, r3.www, cb3_3.tint_symbol_2[6u].xyz);
481
+ r6 = vec4<f32>(v_139.xyz, r6.w);
482
+ let v_140 = (r6.xyz + v_4.xyz);
483
+ r6 = vec4<f32>(v_140.xyz, r6.w);
484
+ let v_141 = bitcast<vec3<u32>>(r2.www);
485
+ let v_142 = r5.xyz;
486
+ let v_143 = select(r6.xyz, v_142, (v_141 != vec3<u32>()));
487
+ r5 = vec4<f32>(v_143.xyz, r5.w);
488
+ r2.w = dot(r5.xyz, r5.xyz);
489
+ let v_144 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
490
+ r5 = vec4<f32>(v_144.xyz, r5.w);
491
+ r3.w = dot(r5.xyz, r5.xyz);
492
+ r3.w = inverseSqrt(r3.w);
493
+ let v_145 = (r3.www * r5.xyz);
494
+ r5 = vec4<f32>(v_145.xyz, r5.w);
495
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
496
+ r3.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
497
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[14u].w);
498
+ r2.w = (r2.w / r3.w);
499
+ let v_146 = -(cb3_3.tint_symbol_2[14u].xyzx);
500
+ r3.w = dot(r5.xyz, v_146.xyz);
501
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
502
+ let v_147 = dot(r5.xyz, v1.xyz);
503
+ r4.w = clamp(vec4<f32>(v_147, v_147, v_147, v_147).w, 0.0f, 1.0f);
504
+ r3.w = (r3.w * r4.w);
505
+ r2.w = (r2.w * r3.w);
506
+ let v_148 = (r2.www * cb3_3.tint_symbol_2[22u].xyz);
507
+ r5 = vec4<f32>(v_148.xyz, r5.w);
508
+ let v_149 = fma(r5.xyz, r0.xyz, r4.xyz);
509
+ r4 = vec4<f32>(v_149.xyz, r4.w);
510
+ }
511
+ }
512
+ if ((bitcast<u32>(r1.w) != 0u)) {
513
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
514
+ } else {
515
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (4i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
516
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
517
+ if ((bitcast<u32>(r1.w) != 0u)) {
518
+ } else {
519
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f)));
520
+ let v_150 = (v_4.xyz + cb3_3.tint_symbol_2[7u].xyz);
521
+ r5 = vec4<f32>(v_150.xyz, r5.w);
522
+ let v_151 = (v2.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz);
523
+ r6 = vec4<f32>(v_151.xyz, r6.w);
524
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[15u].xyz);
525
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f);
526
+ r3.w = (r3.w * cb3_3.tint_symbol_2[23u].w);
527
+ let v_152 = fma(cb3_3.tint_symbol_2[15u].xyz, r3.www, cb3_3.tint_symbol_2[7u].xyz);
528
+ r6 = vec4<f32>(v_152.xyz, r6.w);
529
+ let v_153 = (r6.xyz + v_4.xyz);
530
+ r6 = vec4<f32>(v_153.xyz, r6.w);
531
+ let v_154 = bitcast<vec3<u32>>(r2.www);
532
+ let v_155 = r5.xyz;
533
+ let v_156 = select(r6.xyz, v_155, (v_154 != vec3<u32>()));
534
+ r5 = vec4<f32>(v_156.xyz, r5.w);
535
+ r2.w = dot(r5.xyz, r5.xyz);
536
+ let v_157 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
537
+ r5 = vec4<f32>(v_157.xyz, r5.w);
538
+ r3.w = dot(r5.xyz, r5.xyz);
539
+ r3.w = inverseSqrt(r3.w);
540
+ let v_158 = (r3.www * r5.xyz);
541
+ r5 = vec4<f32>(v_158.xyz, r5.w);
542
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[7u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
543
+ r3.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f);
544
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[15u].w);
545
+ r2.w = (r2.w / r3.w);
546
+ let v_159 = -(cb3_3.tint_symbol_2[15u].xyzx);
547
+ r3.w = dot(r5.xyz, v_159.xyz);
548
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f);
549
+ let v_160 = dot(r5.xyz, v1.xyz);
550
+ r4.w = clamp(vec4<f32>(v_160, v_160, v_160, v_160).w, 0.0f, 1.0f);
551
+ r3.w = (r3.w * r4.w);
552
+ r2.w = (r2.w * r3.w);
553
+ let v_161 = (r2.www * cb3_3.tint_symbol_2[23u].xyz);
554
+ r5 = vec4<f32>(v_161.xyz, r5.w);
555
+ let v_162 = fma(r5.xyz, r0.xyz, r4.xyz);
556
+ r4 = vec4<f32>(v_162.xyz, r4.w);
557
+ }
558
+ }
559
+ if ((bitcast<u32>(r1.w) != 0u)) {
560
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
561
+ } else {
562
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (5i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
563
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
564
+ if ((bitcast<u32>(r1.w) != 0u)) {
565
+ } else {
566
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f)));
567
+ let v_163 = (v_4.xyz + cb3_3.tint_symbol_2[8u].xyz);
568
+ r5 = vec4<f32>(v_163.xyz, r5.w);
569
+ let v_164 = (v2.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz);
570
+ r6 = vec4<f32>(v_164.xyz, r6.w);
571
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[16u].xyz);
572
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f);
573
+ r3.w = (r3.w * cb3_3.tint_symbol_2[24u].w);
574
+ let v_165 = fma(cb3_3.tint_symbol_2[16u].xyz, r3.www, cb3_3.tint_symbol_2[8u].xyz);
575
+ r6 = vec4<f32>(v_165.xyz, r6.w);
576
+ let v_166 = (r6.xyz + v_4.xyz);
577
+ r6 = vec4<f32>(v_166.xyz, r6.w);
578
+ let v_167 = bitcast<vec3<u32>>(r2.www);
579
+ let v_168 = r5.xyz;
580
+ let v_169 = select(r6.xyz, v_168, (v_167 != vec3<u32>()));
581
+ r5 = vec4<f32>(v_169.xyz, r5.w);
582
+ r2.w = dot(r5.xyz, r5.xyz);
583
+ let v_170 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
584
+ r5 = vec4<f32>(v_170.xyz, r5.w);
585
+ r3.w = dot(r5.xyz, r5.xyz);
586
+ r3.w = inverseSqrt(r3.w);
587
+ let v_171 = (r3.www * r5.xyz);
588
+ r5 = vec4<f32>(v_171.xyz, r5.w);
589
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[8u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
590
+ r3.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f);
591
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[16u].w);
592
+ r2.w = (r2.w / r3.w);
593
+ let v_172 = -(cb3_3.tint_symbol_2[16u].xyzx);
594
+ r3.w = dot(r5.xyz, v_172.xyz);
595
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f);
596
+ let v_173 = dot(r5.xyz, v1.xyz);
597
+ r4.w = clamp(vec4<f32>(v_173, v_173, v_173, v_173).w, 0.0f, 1.0f);
598
+ r3.w = (r3.w * r4.w);
599
+ r2.w = (r2.w * r3.w);
600
+ let v_174 = (r2.www * cb3_3.tint_symbol_2[24u].xyz);
601
+ r5 = vec4<f32>(v_174.xyz, r5.w);
602
+ let v_175 = fma(r5.xyz, r0.xyz, r4.xyz);
603
+ r4 = vec4<f32>(v_175.xyz, r4.w);
604
+ }
605
+ }
606
+ if ((bitcast<u32>(r1.w) != 0u)) {
607
+ r1.w = bitcast<f32>(v.tint_symbol_5[3i].x);
608
+ } else {
609
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (6i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
610
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
611
+ if ((bitcast<u32>(r1.w) != 0u)) {
612
+ } else {
613
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f)));
614
+ let v_176 = (v_4.xyz + cb3_3.tint_symbol_2[9u].xyz);
615
+ r5 = vec4<f32>(v_176.xyz, r5.w);
616
+ let v_177 = (v2.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz);
617
+ r6 = vec4<f32>(v_177.xyz, r6.w);
618
+ r3.w = dot(r6.xyz, cb3_3.tint_symbol_2[17u].xyz);
619
+ r3.w = clamp(((r3.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f);
620
+ r3.w = (r3.w * cb3_3.tint_symbol_2[25u].w);
621
+ let v_178 = fma(cb3_3.tint_symbol_2[17u].xyz, r3.www, cb3_3.tint_symbol_2[9u].xyz);
622
+ r6 = vec4<f32>(v_178.xyz, r6.w);
623
+ let v_179 = (r6.xyz + v_4.xyz);
624
+ r6 = vec4<f32>(v_179.xyz, r6.w);
625
+ let v_180 = bitcast<vec3<u32>>(r2.www);
626
+ let v_181 = r5.xyz;
627
+ let v_182 = select(r6.xyz, v_181, (v_180 != vec3<u32>()));
628
+ r5 = vec4<f32>(v_182.xyz, r5.w);
629
+ r2.w = dot(r5.xyz, r5.xyz);
630
+ let v_183 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
631
+ r5 = vec4<f32>(v_183.xyz, r5.w);
632
+ r3.w = dot(r5.xyz, r5.xyz);
633
+ r3.w = inverseSqrt(r3.w);
634
+ let v_184 = (r3.www * r5.xyz);
635
+ r5 = vec4<f32>(v_184.xyz, r5.w);
636
+ r2.w = clamp(fma(-(r2.wwww), cb3_3.tint_symbol_2[9u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
637
+ r3.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f);
638
+ r3.w = fma(r3.w, r2.w, cb3_3.tint_symbol_2[17u].w);
639
+ r2.w = (r2.w / r3.w);
640
+ let v_185 = -(cb3_3.tint_symbol_2[17u].xyzx);
641
+ r3.w = dot(r5.xyz, v_185.xyz);
642
+ r3.w = clamp(fma(r3.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f);
643
+ let v_186 = dot(r5.xyz, v1.xyz);
644
+ r4.w = clamp(vec4<f32>(v_186, v_186, v_186, v_186).w, 0.0f, 1.0f);
645
+ r3.w = (r3.w * r4.w);
646
+ r2.w = (r2.w * r3.w);
647
+ let v_187 = (r2.www * cb3_3.tint_symbol_2[25u].xyz);
648
+ r5 = vec4<f32>(v_187.xyz, r5.w);
649
+ let v_188 = fma(r5.xyz, r0.xyz, r4.xyz);
650
+ r4 = vec4<f32>(v_188.xyz, r4.w);
651
+ }
652
+ }
653
+ if ((bitcast<u32>(r1.w) != 0u)) {
654
+ } else {
655
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (7i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
656
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.w)));
657
+ if ((bitcast<u32>(r1.w) != 0u)) {
658
+ } else {
659
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f)));
660
+ let v_189 = (v_4.xyz + cb3_3.tint_symbol_2[10u].xyz);
661
+ r5 = vec4<f32>(v_189.xyz, r5.w);
662
+ let v_190 = (v2.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz);
663
+ r6 = vec4<f32>(v_190.xyz, r6.w);
664
+ r2.w = dot(r6.xyz, cb3_3.tint_symbol_2[18u].xyz);
665
+ r2.w = clamp(((r2.wwww / cb3_3.tint_symbol_2[26u].wwww)).w, 0.0f, 1.0f);
666
+ r2.w = (r2.w * cb3_3.tint_symbol_2[26u].w);
667
+ let v_191 = fma(cb3_3.tint_symbol_2[18u].xyz, r2.www, cb3_3.tint_symbol_2[10u].xyz);
668
+ r6 = vec4<f32>(v_191.xyz, r6.w);
669
+ let v_192 = (r6.xyz + v_4.xyz);
670
+ r6 = vec4<f32>(v_192.xyz, r6.w);
671
+ let v_193 = bitcast<vec3<u32>>(r1.www);
672
+ let v_194 = r5.xyz;
673
+ let v_195 = select(r6.xyz, v_194, (v_193 != vec3<u32>()));
674
+ r5 = vec4<f32>(v_195.xyz, r5.w);
675
+ r1.w = dot(r5.xyz, r5.xyz);
676
+ let v_196 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
677
+ r5 = vec4<f32>(v_196.xyz, r5.w);
678
+ r2.w = dot(r5.xyz, r5.xyz);
679
+ r2.w = inverseSqrt(r2.w);
680
+ let v_197 = (r2.www * r5.xyz);
681
+ r5 = vec4<f32>(v_197.xyz, r5.w);
682
+ r1.w = clamp(fma(-(r1.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
683
+ r2.w = ((-(cb3_3.tint_symbol_2[18u].wwww)).w + 1.0f);
684
+ r2.w = fma(r2.w, r1.w, cb3_3.tint_symbol_2[18u].w);
685
+ r1.w = (r1.w / r2.w);
686
+ let v_198 = -(cb3_3.tint_symbol_2[18u].xyzx);
687
+ r2.w = dot(r5.xyz, v_198.xyz);
688
+ r2.w = clamp(fma(r2.wwww, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).w, 0.0f, 1.0f);
689
+ let v_199 = dot(r5.xyz, v1.xyz);
690
+ r3.w = clamp(vec4<f32>(v_199, v_199, v_199, v_199).w, 0.0f, 1.0f);
691
+ r2.w = (r2.w * r3.w);
692
+ r1.w = (r1.w * r2.w);
693
+ let v_200 = (r1.www * cb3_3.tint_symbol_2[26u].xyz);
694
+ r5 = vec4<f32>(v_200.xyz, r5.w);
695
+ let v_201 = fma(r5.xyz, r0.xyz, r4.xyz);
696
+ r4 = vec4<f32>(v_201.xyz, r4.w);
697
+ }
698
+ }
699
+ let v_202 = fma(r3.xyz, r1.zzz, r4.xyz);
700
+ r3 = vec4<f32>(v_202.xyz, r3.w);
701
+ r1.z = (v1.z + cb3_3.tint_symbol_2[43u].w);
702
+ r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w);
703
+ r1.z = max(r1.z, 0.0f);
704
+ let v_203 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz);
705
+ r4 = vec4<f32>(v_203.xyz, r4.w);
706
+ r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
707
+ let v_204 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz);
708
+ r5 = vec4<f32>(v_204.xyz, r5.w);
709
+ let v_205 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz);
710
+ r5 = vec4<f32>(v_205.xyz, r5.w);
711
+ let v_206 = fma(r4.xyz, r1.www, r5.xyz);
712
+ r4 = vec4<f32>(v_206.xyz, r4.w);
713
+ let v_207 = (r1.yyy * r4.xyz);
714
+ r4 = vec4<f32>(v_207.xyz, r4.w);
715
+ let v_208 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz);
716
+ r1 = vec4<f32>(r1.x, v_208.xyz);
717
+ r5.x = cb3_3.tint_symbol_2[46u].w;
718
+ r5.y = cb3_3.tint_symbol_2[47u].w;
719
+ r5.z = cb3_3.tint_symbol_2[48u].w;
720
+ let v_209 = dot(r5.xyz, v1.xyz);
721
+ r2.w = clamp(vec4<f32>(v_209, v_209, v_209, v_209).w, 0.0f, 1.0f);
722
+ let v_210 = fma(cb3_3.tint_symbol_2[49u].xyz, r2.www, r1.yzw);
723
+ r1 = vec4<f32>(r1.x, v_210.xyz);
724
+ let v_211 = fma(r1.yzw, r1.xxx, r4.xyz);
725
+ r1 = vec4<f32>(v_211.xyz, r1.w);
726
+ let v_212 = fma(r1.xyz, r0.xyz, r3.xyz);
727
+ r0 = vec4<f32>(v_212.xyz, r0.w);
728
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
729
+ r0.w = dot(r2.xyz, r2.xyz);
730
+ r1.x = sqrt(r0.w);
731
+ let v_213 = -(cb3_3.tint_symbol_2[50u].xxxx);
732
+ r1.y = (r1.x + v_213.y);
733
+ r1.y = max(r1.y, 0.0f);
734
+ r1.x = (r1.y / r1.x);
735
+ r1.x = (r1.x * r2.z);
736
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
737
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
738
+ r1.w = (r1.z * -1.44269502162933349609f);
739
+ r1.w = exp2(r1.w);
740
+ r1.w = ((-(r1.wwww)).w + 1.0f);
741
+ r1.z = (r1.w / r1.z);
742
+ let v_214 = bitcast<u32>(r1.x);
743
+ r1.x = select(1.0f, r1.z, (v_214 != 0u));
744
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
745
+ r1.x = (r1.x * r1.z);
746
+ r1.x = min(r1.x, 1.0f);
747
+ r1.x = (r1.x * 1.44269502162933349609f);
748
+ r1.x = exp2(r1.x);
749
+ r1.x = min(r1.x, 1.0f);
750
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
751
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
752
+ r0.w = inverseSqrt(r0.w);
753
+ let v_215 = (r0.www * r2.xyz);
754
+ r2 = vec4<f32>(v_215.xyz, r2.w);
755
+ let v_216 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
756
+ r0.w = clamp(vec4<f32>(v_216, v_216, v_216, v_216).w, 0.0f, 1.0f);
757
+ r0.w = log2(r0.w);
758
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
759
+ r0.w = exp2(r0.w);
760
+ let v_217 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
761
+ r1.w = clamp(vec4<f32>(v_217, v_217, v_217, v_217).w, 0.0f, 1.0f);
762
+ r1.w = log2(r1.w);
763
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
764
+ r1.w = exp2(r1.w);
765
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
766
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
767
+ let v_218 = -(cb3_3.tint_symbol_2[52u].xxxx);
768
+ r2.x = (r1.y + v_218.x);
769
+ r2.x = max(r2.x, 0.0f);
770
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
771
+ r2.x = (r2.x * 1.44269502162933349609f);
772
+ r2.x = exp2(r2.x);
773
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
774
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
775
+ let v_219 = -(cb3_3.tint_symbol_2[51u].zzzz);
776
+ r1.y = (r1.y * v_219.y);
777
+ r1.y = (r1.y * 1.44269502162933349609f);
778
+ r1.y = exp2(r1.y);
779
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
780
+ let v_220 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
781
+ r2 = vec4<f32>(v_220.xyz, r2.w);
782
+ let v_221 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
783
+ r2 = vec4<f32>(v_221.xyz, r2.w);
784
+ let v_222 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
785
+ r3 = vec4<f32>(v_222.xyz, r3.w);
786
+ let v_223 = fma(r1.www, r3.xyz, r2.xyz);
787
+ r2 = vec4<f32>(v_223.xyz, r2.w);
788
+ let v_224 = -(cb3_3.tint_symbol_2[57u].xyzx);
789
+ let v_225 = (r2.xyz + v_224.xyz);
790
+ r2 = vec4<f32>(v_225.xyz, r2.w);
791
+ let v_226 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
792
+ r2 = vec4<f32>(v_226.xyz, r2.w);
793
+ r3.x = ((-(r2.xxxx)).x + cb3_3.tint_symbol_2[55u].w);
794
+ r3.y = ((-(r2.yyyy)).y + cb3_3.tint_symbol_2[56u].w);
795
+ r3.z = ((-(r2.zzzz)).z + cb3_3.tint_symbol_2[57u].w);
796
+ let v_227 = fma(r1.xxx, r3.xyz, r2.xyz);
797
+ r1 = vec4<f32>(v_227.xy, r1.z, v_227.z);
798
+ let v_228 = ((-(r0.xyxz)).xyw + r1.xyw);
799
+ r1 = vec4<f32>(v_228.xy, r1.z, v_228.z);
800
+ let v_229 = fma(r1.zzz, r1.xyw, r0.xyz);
801
+ r0 = vec4<f32>(v_229.xyz, r0.w);
802
+ let v_230 = (r0.xyz * cb2_2.tint_symbol_1[17u].zzz);
803
+ o0 = vec4<f32>(v_230.xyz, o0.w);
804
+ }
805
+
806
+ @fragment
807
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(6u) v6 : vec4<f32>) -> @location(0u) vec4<f32> {
808
+ main_inner(v0, v1, v2, v6);
809
+ return o0;
810
+ }
b/8b0b5899ed/shaders/003e341f763296f0.wgsl ADDED
@@ -0,0 +1,106 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ struct cb16_struct {
8
+ tint_symbol : array<vec4<f32>, 16u>,
9
+ }
10
+
11
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
12
+
13
+ struct cb17_struct {
14
+ tint_symbol_1 : array<vec4<f32>, 17u>,
15
+ }
16
+
17
+ @group(0u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
18
+
19
+ struct cb50_struct {
20
+ tint_symbol_2 : array<vec4<f32>, 50u>,
21
+ }
22
+
23
+ @group(0u) @binding(3u) var<uniform> cb3_3 : cb50_struct;
24
+
25
+ struct cb1_struct {
26
+ tint_symbol_3 : array<vec4<f32>, 1u>,
27
+ }
28
+
29
+ @group(0u) @binding(13u) var<uniform> cb13_13 : cb1_struct;
30
+
31
+ @group(0u) @binding(18u) var s2 : sampler;
32
+
33
+ @group(0u) @binding(34u) var t2 : texture_2d<f32>;
34
+
35
+ var<private> o0 : vec4<f32>;
36
+
37
+ var<private> o1 : vec4<f32>;
38
+
39
+ var<private> o2 : vec4<f32>;
40
+
41
+ var<private> o3 : vec4<f32>;
42
+
43
+ var<private> o4 : vec4<f32>;
44
+
45
+ var<private> o5 : vec4<f32>;
46
+
47
+ fn main_inner(v0 : vec3<f32>, v1 : vec4<f32>, v2 : vec2<f32>, v6 : vec3<f32>) {
48
+ r0 = (v0.yyyy * cb1_1.tint_symbol[9u]);
49
+ r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0);
50
+ r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0);
51
+ o0 = (r0 + cb1_1.tint_symbol[11u]);
52
+ let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz);
53
+ r0 = vec4<f32>(v.xyz, r0.w);
54
+ let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz);
55
+ r0 = vec4<f32>(v_1.xyz, r0.w);
56
+ let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz);
57
+ r0 = vec4<f32>(v_2.xyz, r0.w);
58
+ let v_3 = (r0.xyz + cb1_1.tint_symbol[3u].xyz);
59
+ r0 = vec4<f32>(v_3.xyz, r0.w);
60
+ let v_4 = ((-(r0.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz);
61
+ r1 = vec4<f32>(v_4.xyz, r1.w);
62
+ o5 = r0.xyz.xyzx;
63
+ r0.x = dot(r1.xyz, r1.xyz);
64
+ r0.x = (r0.x * 0.00000399999998990097f);
65
+ r0.x = min(r0.x, 1.0f);
66
+ r0.y = ((-(r0.xxxx)).y + 1.0f);
67
+ let v_5 = -(cb2_2.tint_symbol_1[16u].zzzz);
68
+ let v_6 = clamp(((r0.xyxx + v_5)).xy, vec2<f32>(), vec2<f32>(1.0f));
69
+ r0 = vec4<f32>(v_6.xy, r0.zw);
70
+ r0.z = (cb3_3.tint_symbol_2[49u].w + -1.0f);
71
+ let v_7 = fma(r0.xy, r0.zz, vec2<f32>(1.0f));
72
+ r0 = vec4<f32>(v_7.xy, r0.zw);
73
+ let v_8 = clamp(((r0.xyxx * v1.xyxx)).xy, vec2<f32>(), vec2<f32>(1.0f));
74
+ o1 = vec4<f32>(v_8.xy, o1.zw);
75
+ o1 = vec4<f32>(o1.xy, v1.zw);
76
+ r0.x = v1.z;
77
+ r0.y = cb13_13.tint_symbol_3[0u].x;
78
+ o2 = textureSampleLevel(t2, s2, r0.xyxx.xy, 0.0f);
79
+ o3 = v2.xyxy;
80
+ let v_9 = (v6.yyy * cb1_1.tint_symbol[1u].xyz);
81
+ r0 = vec4<f32>(v_9.xyz, r0.w);
82
+ let v_10 = fma(v6.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz);
83
+ r0 = vec4<f32>(v_10.xyz, r0.w);
84
+ o4 = fma(v6.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz).xyzx;
85
+ }
86
+
87
+ struct tint_symbol_4 {
88
+ @builtin(position)
89
+ o0 : vec4<f32>,
90
+ @location(1u)
91
+ o1 : vec4<f32>,
92
+ @location(2u)
93
+ o2 : vec4<f32>,
94
+ @location(3u)
95
+ o3 : vec4<f32>,
96
+ @location(4u)
97
+ o4 : vec4<f32>,
98
+ @location(5u)
99
+ o5 : vec4<f32>,
100
+ }
101
+
102
+ @vertex
103
+ fn main(@location(0u) v0 : vec3<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec2<f32>, @location(6u) v6 : vec3<f32>) -> tint_symbol_4 {
104
+ main_inner(v0, v1, v2, v6);
105
+ return tint_symbol_4(o0, o1, o2, o3, o4, o5);
106
+ }
b/8b0b5899ed/shaders/00434aea0a2de164.wgsl ADDED
@@ -0,0 +1,189 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ struct cb17_struct {
16
+ tint_symbol : array<vec4<f32>, 17u>,
17
+ }
18
+
19
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
20
+
21
+ struct cb46_struct {
22
+ tint_symbol_1 : array<vec4<f32>, 46u>,
23
+ }
24
+
25
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb46_struct;
26
+
27
+ struct cb5_struct {
28
+ tint_symbol_2 : array<vec4<f32>, 5u>,
29
+ }
30
+
31
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb5_struct;
32
+
33
+ struct cb3_struct {
34
+ tint_symbol_3 : array<vec4<f32>, 3u>,
35
+ }
36
+
37
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb3_struct;
38
+
39
+ @group(1u) @binding(16u) var s0 : sampler;
40
+
41
+ @group(1u) @binding(19u) var s3 : sampler;
42
+
43
+ @group(1u) @binding(20u) var s4 : sampler;
44
+
45
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
46
+
47
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
48
+
49
+ @group(1u) @binding(36u) var t4 : texture_2d<f32>;
50
+
51
+ var<private> icb0 : array<vec4<f32>, 4u> = array<vec4<f32>, 4u>(vec4<f32>(1.0f, 0.0f, 0.0f, 0.0f), vec4<f32>(0.0f, 1.0f, 0.0f, 0.0f), vec4<f32>(0.0f, 0.0f, 1.0f, 0.0f), vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f));
52
+
53
+ var<private> v0 : vec4<f32>;
54
+
55
+ var<private> o0 : vec4<f32>;
56
+
57
+ var<private> o1 : vec4<f32>;
58
+
59
+ var<private> o2 : vec4<f32>;
60
+
61
+ var<private> o3 : vec4<f32>;
62
+
63
+ fn main_inner(v : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>) {
64
+ var v_1 : vec4<f32> = v;
65
+ v_1.w = (1.0f / v.w);
66
+ v0 = v_1;
67
+ let v_2 = max(v0.xy, vec2<f32>());
68
+ let v_3 = bitcast<vec2<f32>>(select(vec2<u32>(v_2), vec2<u32>(4294967295u), (v_2 >= vec2<f32>(4294967296.0f))));
69
+ r0 = vec4<f32>(v_3.xy, r0.zw);
70
+ let v_4 = bitcast<vec2<f32>>((bitcast<vec2<u32>>(r0.xy) & vec2<u32>(1u)));
71
+ r0 = vec4<f32>(v_4.xy, r0.zw);
72
+ r0.y = bitcast<f32>((bitcast<i32>(r0.y) << 1u));
73
+ r0.x = bitcast<f32>((bitcast<i32>(r0.x) + bitcast<i32>(r0.y)));
74
+ r0.x = dot(cb2_2.tint_symbol[0u], icb0[bitcast<i32>(r0.x)]);
75
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (r0.x < 1.0f)));
76
+ v_5((bitcast<u32>(r0.x) != 0u));
77
+ r0 = textureSample(t0, s0, v3.xy.xyxx.xy);
78
+ r1.x = (r0.w * cb2_2.tint_symbol[15u].x);
79
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_2[4u].x >= r1.x)));
80
+ v_5((bitcast<u32>(r1.x) != 0u));
81
+ r1 = textureSample(t3, s3, v3.xy.xyxx.xy);
82
+ let v_6 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
83
+ r1 = vec4<f32>(v_6.xy, r1.zw);
84
+ r1.z = dot(r1.xy, r1.xy);
85
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
86
+ r1.z = sqrt(abs(r1.zzzz).z);
87
+ r1.w = max(cb12_12.tint_symbol_3[1u].w, 0.00100000004749745131f);
88
+ let v_7 = (r1.ww * r1.xy);
89
+ r1 = vec4<f32>(v_7.xy, r1.zw);
90
+ let v_8 = (r1.yyy * v6.xyz);
91
+ r2 = vec4<f32>(v_8.xyz, r2.w);
92
+ let v_9 = fma(r1.xxx, v5.xyz, r2.xyz);
93
+ r1 = vec4<f32>(v_9.xy, r1.z, v_9.z);
94
+ let v_10 = fma(r1.zzz, v4.xyz, r1.xyw);
95
+ r1 = vec4<f32>(v_10.xyz, r1.w);
96
+ r1.w = dot(r1.xyz, r1.xyz);
97
+ r1.w = inverseSqrt(r1.w);
98
+ let v_11 = (r1.www * r1.xyz);
99
+ r2 = vec4<f32>(v_11.xyz, r2.w);
100
+ r3 = textureSample(t4, s4, v3.xy.xyxx.xy);
101
+ let v_12 = (r3.xy * r3.xy);
102
+ r3 = vec4<f32>(v_12.xy, r3.zw);
103
+ r1.x = dot(r3.xyz, cb12_12.tint_symbol_3[1u].xyz);
104
+ r3.x = (r1.x * cb12_12.tint_symbol_3[0u].z);
105
+ r1.y = (r3.w * cb12_12.tint_symbol_3[0u].y);
106
+ let v_13 = (r0.xyz * v2.xyz);
107
+ r0 = vec4<f32>(v_13.xyz, r0.w);
108
+ r0.w = (r0.w * v1.w);
109
+ let v_14 = (v1.xy * cb2_2.tint_symbol[15u].zy);
110
+ let v_15 = r4;
111
+ r4 = vec4<f32>(v_15.x, v_14.xy, v_15.w);
112
+ o0.w = (r0.w * cb2_2.tint_symbol[15u].x);
113
+ let v_16 = fma(r2.xyz, vec3<f32>(0.5f), vec3<f32>(0.5f));
114
+ r2 = vec4<f32>(v_16.xyz, r2.w);
115
+ let v_17 = (r2.xyz * vec3<f32>(256.0f));
116
+ r5 = vec4<f32>(v_17.xyz, r5.w);
117
+ let v_18 = floor(r5.xyz);
118
+ r5 = vec4<f32>(v_18.xyz, r5.w);
119
+ let v_19 = -(r5.xyzx);
120
+ let v_20 = fma(r2.xyz, vec3<f32>(256.0f), v_19.xyz);
121
+ r2 = vec4<f32>(v_20.xyz, r2.w);
122
+ let v_21 = (r2.xyz * vec3<f32>(8.0f, 8.0f, 4.0f));
123
+ r2 = vec4<f32>(v_21.xyz, r2.w);
124
+ let v_22 = floor(r2.xyz);
125
+ r2 = vec4<f32>(v_22.xyz, r2.w);
126
+ r0.w = dot(r2.xyz, vec3<f32>(32.0f, 4.0f, 1.0f));
127
+ o1.w = (r0.w * 0.0039215688593685627f);
128
+ let v_23 = (r5.xyz * vec3<f32>(0.00390625f));
129
+ o1 = vec4<f32>(v_23.xyz, o1.w);
130
+ r3.y = (r1.y * 0.001953125f);
131
+ r4.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w);
132
+ let v_24 = (r4.xz * vec2<f32>(0.5f));
133
+ r2 = vec4<f32>(v_24.xy, r2.zw);
134
+ let v_25 = sqrt(r2.xy);
135
+ o3 = vec4<f32>(v_25.xy, o3.zw);
136
+ r0.w = fma(r1.z, r1.w, -0.34999999403953552246f);
137
+ r0.w = clamp(((r0.wwww * vec4<f32>(1.53846156597137451172f))).w, 0.0f, 1.0f);
138
+ r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z);
139
+ r1.y = ((-(cb2_2.tint_symbol[16u].zzzz)).y + 1.0f);
140
+ r0.w = (r0.w * r1.y);
141
+ r0.w = (r4.y * r0.w);
142
+ r1.y = fma((-(r3.xxxx)).y, 0.5f, 1.0f);
143
+ r1.y = (r0.w * r1.y);
144
+ r0.w = (r0.w * cb12_12.tint_symbol_3[2u].x);
145
+ r1.y = fma(r1.y, -0.5f, 1.0f);
146
+ let v_26 = (r0.xyz * r1.yyy);
147
+ o0 = vec4<f32>(v_26.xyz, o0.w);
148
+ r0.x = clamp(fma(r1.xxxx, cb12_12.tint_symbol_3[0u].zzzz, vec4<f32>(0.40000000596046447754f)).x, 0.0f, 1.0f);
149
+ let v_27 = (r0.xx * vec2<f32>(0.5f, 0.48828125f));
150
+ r0 = vec4<f32>(v_27.xy, r0.zw);
151
+ r3.z = cb12_12.tint_symbol_3[0u].x;
152
+ r0.z = 0.97000002861022949219f;
153
+ let v_28 = -(r3.xyzx);
154
+ let v_29 = (r0.xyz + v_28.xyz);
155
+ r0 = vec4<f32>(v_29.xyz, r0.w);
156
+ let v_30 = max(r0.xyz, vec3<f32>());
157
+ r0 = vec4<f32>(v_30.xyz, r0.w);
158
+ let v_31 = fma(r0.xyz, r0.www, r3.xyz);
159
+ r0 = vec4<f32>(v_31.xyz, r0.w);
160
+ let v_32 = sqrt(r0.xy);
161
+ o2 = vec4<f32>(v_32.xy, o2.zw);
162
+ o2.z = r0.z;
163
+ o2.w = 1.0f;
164
+ o3 = vec4<f32>(o3.xy, vec2<f32>(0.0f, 1.00188386440277099609f));
165
+ }
166
+
167
+ fn v_5(v_33 : bool) {
168
+ if (v_33) {
169
+ discard;
170
+ return;
171
+ }
172
+ }
173
+
174
+ struct tint_symbol_4 {
175
+ @location(0u)
176
+ o0 : vec4<f32>,
177
+ @location(1u)
178
+ o1 : vec4<f32>,
179
+ @location(2u)
180
+ o2 : vec4<f32>,
181
+ @location(3u)
182
+ o3 : vec4<f32>,
183
+ }
184
+
185
+ @fragment
186
+ fn main(@builtin(position) v_34 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>) -> tint_symbol_4 {
187
+ main_inner(v_34, v1, v2, v3, v4, v5, v6);
188
+ return tint_symbol_4(o0, o1, o2, o3);
189
+ }
b/8b0b5899ed/shaders/0061ed6188dc3969.wgsl ADDED
@@ -0,0 +1,26 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ @group(1u) @binding(19u) var s3 : sampler;
6
+
7
+ @group(1u) @binding(35u) var t3 : texture_cube<f32>;
8
+
9
+ var<private> o0 : vec4<f32>;
10
+
11
+ fn main_inner(v1 : vec4<f32>) {
12
+ r0.x = dot(v1.xy, v1.xy);
13
+ r0.x = (r0.x + -1.0f);
14
+ r0.z = (r0.x * v1.z);
15
+ r0 = vec4<f32>(((v1.xy * vec2<f32>(-2.0f))).xy, r0.zw);
16
+ r0 = textureSampleLevel(t3, s3, r0.xyzx.xyz, 0.0f);
17
+ let v = r0;
18
+ o0 = vec4<f32>(v.xyz, o0.w);
19
+ o0.w = 1.0f;
20
+ }
21
+
22
+ @fragment
23
+ fn main(@location(1u) v1 : vec4<f32>) -> @location(0u) vec4<f32> {
24
+ main_inner(v1);
25
+ return o0;
26
+ }
b/8b0b5899ed/shaders/006957a1aede62d1.wgsl ADDED
@@ -0,0 +1,497 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ struct cb16_struct {
22
+ tint_symbol : array<vec4<f32>, 16u>,
23
+ }
24
+
25
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
26
+
27
+ struct cb15_struct {
28
+ tint_symbol_1 : array<vec4<f32>, 15u>,
29
+ }
30
+
31
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
32
+
33
+ struct cb46_struct {
34
+ tint_symbol_2 : array<vec4<f32>, 46u>,
35
+ }
36
+
37
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb46_struct;
38
+
39
+ @group(1u) @binding(20u) var s4 : sampler;
40
+
41
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
42
+
43
+ @group(1u) @binding(36u) var t4 : texture_2d<f32>;
44
+
45
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
46
+
47
+ var<private> v0 : vec4<f32>;
48
+
49
+ var<private> o0 : vec4<f32>;
50
+
51
+ fn main_inner(v : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>) {
52
+ var v_1 : vec4<f32> = v;
53
+ v_1.w = (1.0f / v.w);
54
+ v0 = v_1;
55
+ r0 = textureSample(t4, s4, v1.xyxx.xy);
56
+ r0.x = ((-(r0.xxxx)).x + cb5_5.tint_symbol_2[0u].w);
57
+ r0.x = (r0.x + 1.0f);
58
+ r0.x = (cb5_5.tint_symbol_2[0u].z / r0.x);
59
+ let v_2 = (r0.xxx * v2.xyz);
60
+ r0 = vec4<f32>(r0.x, v_2.xyz);
61
+ r1.x = dot(r0.yzw, r0.yzw);
62
+ r1.x = sqrt(r1.x);
63
+ r1.y = dot(v1.xy, vec2<f32>(25.9796009063720703125f, 156.46600341796875f));
64
+ r1.y = sin(r1.yyyy.y);
65
+ r1.y = (r1.y * 43758.546875f);
66
+ r1.y = fract(r1.y);
67
+ r1.y = fma(r1.y, 2.0f, -1.0f);
68
+ r1.y = (r1.y * 0.5f);
69
+ r2.x = (r1.x * cb5_5.tint_symbol_2[45u].y);
70
+ r1.x = clamp(fma(r1.xxxx, cb5_5.tint_symbol_2[45u].zzzz, cb5_5.tint_symbol_2[45u].wwww).x, 0.0f, 1.0f);
71
+ r1.x = (r1.y * r1.x);
72
+ let v_3 = (v0.xy * vec2<f32>(0.3333333432674407959f));
73
+ let v_4 = r1;
74
+ r1 = vec4<f32>(v_4.x, v_3.xy, v_4.w);
75
+ let v_5 = -(r1.yyzy);
76
+ let v_6 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz >= v_5.yz)));
77
+ let v_7 = r2;
78
+ r2 = vec4<f32>(v_7.x, v_6.xy, v_7.w);
79
+ let v_8 = fract(abs(r1.yyzy).yz);
80
+ let v_9 = r1;
81
+ r1 = vec4<f32>(v_9.x, v_8.xy, v_9.w);
82
+ let v_10 = -(r1.yyzy);
83
+ let v_11 = bitcast<vec2<u32>>(r2.yz);
84
+ let v_12 = select(v_10.yz, r1.yz, (v_11 != vec2<u32>()));
85
+ let v_13 = r1;
86
+ r1 = vec4<f32>(v_13.x, v_12.xy, v_13.w);
87
+ let v_14 = (r1.yz * vec2<f32>(3.0f, 9.0f));
88
+ let v_15 = r1;
89
+ r1 = vec4<f32>(v_15.x, v_14.xy, v_15.w);
90
+ r1.y = (r1.z + r1.y);
91
+ let v_16 = (r0.yzw * vec3<f32>(0.11111111193895339966f));
92
+ r0 = vec4<f32>(r0.x, v_16.xyz);
93
+ let v_17 = (r1.yyy * r0.yzw);
94
+ r1 = vec4<f32>(r1.x, v_17.xyz);
95
+ let v_18 = fma(r1.yzw, vec3<f32>(0.11111111193895339966f), cb1_1.tint_symbol[15u].xyz);
96
+ r1 = vec4<f32>(r1.x, v_18.xyz);
97
+ let v_19 = fma(r1.xxx, r0.yzw, r1.yzw);
98
+ r1 = vec4<f32>(v_19.xyz, r1.w);
99
+ r1.w = fma((-(cb6_6.tint_symbol_1[14u].zzzz)).w, 1.5f, 1.0f);
100
+ r1.w = (r1.w * 0.5f);
101
+ let v_20 = -(cb1_1.tint_symbol[15u].xyzx);
102
+ let v_21 = (r1.xyz + v_20.xyz);
103
+ r1 = vec4<f32>(v_21.xyz, r1.w);
104
+ let v_22 = (r1.yyy * cb6_6.tint_symbol_1[1u].xyz);
105
+ r2 = vec4<f32>(r2.x, v_22.xyz);
106
+ let v_23 = fma(r1.xxx, cb6_6.tint_symbol_1[0u].xyz, r2.yzw);
107
+ r2 = vec4<f32>(r2.x, v_23.xyz);
108
+ let v_24 = fma(r1.zzz, cb6_6.tint_symbol_1[2u].xyz, r2.yzw);
109
+ r1 = vec4<f32>(v_24.xyz, r1.w);
110
+ let v_25 = (r0.zzz * cb6_6.tint_symbol_1[1u].xyz);
111
+ r2 = vec4<f32>(r2.x, v_25.xyz);
112
+ let v_26 = fma(r0.yyy, cb6_6.tint_symbol_1[0u].xyz, r2.yzw);
113
+ r2 = vec4<f32>(r2.x, v_26.xyz);
114
+ let v_27 = fma(r0.www, cb6_6.tint_symbol_1[2u].xyz, r2.yzw);
115
+ r0 = vec4<f32>(r0.x, v_27.xyz);
116
+ let v_28 = fma(r1.xyz, cb6_6.tint_symbol_1[4u].xyz, cb6_6.tint_symbol_1[8u].xyz);
117
+ r3 = vec4<f32>(v_28.xyz, r3.w);
118
+ let v_29 = fma(r1.xyz, cb6_6.tint_symbol_1[5u].xyz, cb6_6.tint_symbol_1[9u].xyz);
119
+ r4 = vec4<f32>(v_29.xyz, r4.w);
120
+ let v_30 = fma(r1.xyz, cb6_6.tint_symbol_1[6u].xyz, cb6_6.tint_symbol_1[10u].xyz);
121
+ r5 = vec4<f32>(v_30.xyz, r5.w);
122
+ let v_31 = fma(r1.xyz, cb6_6.tint_symbol_1[7u].xyz, cb6_6.tint_symbol_1[11u].xyz);
123
+ r6 = vec4<f32>(v_31.xyz, r6.w);
124
+ let v_32 = abs(r3.yyyy);
125
+ r1.x = max(v_32.x, abs(r3.xxxx).x);
126
+ let v_33 = abs(r4.yyyy);
127
+ r1.y = max(v_33.y, abs(r4.xxxx).y);
128
+ let v_34 = abs(r5.yyyy);
129
+ r1.z = max(v_34.z, abs(r5.xxxx).z);
130
+ let v_35 = bitcast<vec3<f32>>(select(vec3<u32>(), vec3<u32>(4294967295u), (r1.xyz < r1.www)));
131
+ r1 = vec4<f32>(v_35.xyz, r1.w);
132
+ let v_36 = abs(r6.yyyy);
133
+ r2.y = max(v_36.y, abs(r6.xxxx).y);
134
+ r2.y = bitcast<f32>(select(0u, 4294967295u, (r2.y < r1.w)));
135
+ r6.w = 0.875f;
136
+ let v_37 = bitcast<vec4<u32>>(r2.yyyy);
137
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_37 != vec4<u32>()));
138
+ r5.w = 0.625f;
139
+ let v_38 = bitcast<vec4<u32>>(r1.zzzz);
140
+ let v_39 = r5;
141
+ r7 = select(r7, v_39, (v_38 != vec4<u32>()));
142
+ r4.w = 0.375f;
143
+ let v_40 = bitcast<vec4<u32>>(r1.yyyy);
144
+ let v_41 = r4;
145
+ r7 = select(r7, v_41, (v_40 != vec4<u32>()));
146
+ r3.w = 0.125f;
147
+ let v_42 = bitcast<vec4<u32>>(r1.xxxx);
148
+ let v_43 = r3;
149
+ r7 = select(r7, v_43, (v_42 != vec4<u32>()));
150
+ r1.x = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
151
+ if ((bitcast<u32>(r1.x) != 0u)) {
152
+ r1.x = (r7.x + 0.5f);
153
+ r1.y = fma(r7.y, 0.25f, r7.w);
154
+ let v_44 = r1.xyxx;
155
+ r1.x = textureSampleCompareLevel(t15, s15, v_44.xy, r7.z);
156
+ } else {
157
+ r1.x = 1.0f;
158
+ }
159
+ let v_45 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
160
+ r3 = vec4<f32>(v_45.xyz, r3.w);
161
+ let v_46 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
162
+ r4 = vec4<f32>(v_46.xyz, r4.w);
163
+ let v_47 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
164
+ r5 = vec4<f32>(v_47.xyz, r5.w);
165
+ let v_48 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
166
+ r6 = vec4<f32>(v_48.xyz, r6.w);
167
+ let v_49 = abs(r3.yyyy);
168
+ r1.y = max(v_49.y, abs(r3.xxxx).y);
169
+ let v_50 = abs(r4.yyyy);
170
+ r1.z = max(v_50.z, abs(r4.xxxx).z);
171
+ let v_51 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
172
+ let v_52 = r1;
173
+ r1 = vec4<f32>(v_52.x, v_51.xy, v_52.w);
174
+ let v_53 = abs(r5.yyyy);
175
+ r2.y = max(v_53.y, abs(r5.xxxx).y);
176
+ let v_54 = abs(r6.yyyy);
177
+ r2.z = max(v_54.z, abs(r6.xxxx).z);
178
+ let v_55 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
179
+ let v_56 = r2;
180
+ r2 = vec4<f32>(v_56.x, v_55.xy, v_56.w);
181
+ r6.w = 0.875f;
182
+ let v_57 = bitcast<vec4<u32>>(r2.zzzz);
183
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_57 != vec4<u32>()));
184
+ r5.w = 0.625f;
185
+ let v_58 = bitcast<vec4<u32>>(r2.yyyy);
186
+ let v_59 = r5;
187
+ r7 = select(r7, v_59, (v_58 != vec4<u32>()));
188
+ r4.w = 0.375f;
189
+ let v_60 = bitcast<vec4<u32>>(r1.zzzz);
190
+ let v_61 = r4;
191
+ r7 = select(r7, v_61, (v_60 != vec4<u32>()));
192
+ r3.w = 0.125f;
193
+ let v_62 = bitcast<vec4<u32>>(r1.yyyy);
194
+ let v_63 = r3;
195
+ r7 = select(r7, v_63, (v_62 != vec4<u32>()));
196
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
197
+ if ((bitcast<u32>(r1.y) != 0u)) {
198
+ r8.x = (r7.x + 0.5f);
199
+ r8.y = fma(r7.y, 0.25f, r7.w);
200
+ let v_64 = r8.xyxx;
201
+ r1.y = textureSampleCompareLevel(t15, s15, v_64.xy, r7.z);
202
+ } else {
203
+ r1.y = 1.0f;
204
+ }
205
+ r1.x = (r1.y + r1.x);
206
+ let v_65 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
207
+ r3 = vec4<f32>(v_65.xyz, r3.w);
208
+ let v_66 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
209
+ r4 = vec4<f32>(v_66.xyz, r4.w);
210
+ let v_67 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
211
+ r5 = vec4<f32>(v_67.xyz, r5.w);
212
+ let v_68 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
213
+ r6 = vec4<f32>(v_68.xyz, r6.w);
214
+ let v_69 = abs(r3.yyyy);
215
+ r1.y = max(v_69.y, abs(r3.xxxx).y);
216
+ let v_70 = abs(r4.yyyy);
217
+ r1.z = max(v_70.z, abs(r4.xxxx).z);
218
+ let v_71 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
219
+ let v_72 = r1;
220
+ r1 = vec4<f32>(v_72.x, v_71.xy, v_72.w);
221
+ let v_73 = abs(r5.yyyy);
222
+ r2.y = max(v_73.y, abs(r5.xxxx).y);
223
+ let v_74 = abs(r6.yyyy);
224
+ r2.z = max(v_74.z, abs(r6.xxxx).z);
225
+ let v_75 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
226
+ let v_76 = r2;
227
+ r2 = vec4<f32>(v_76.x, v_75.xy, v_76.w);
228
+ r6.w = 0.875f;
229
+ let v_77 = bitcast<vec4<u32>>(r2.zzzz);
230
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_77 != vec4<u32>()));
231
+ r5.w = 0.625f;
232
+ let v_78 = bitcast<vec4<u32>>(r2.yyyy);
233
+ let v_79 = r5;
234
+ r7 = select(r7, v_79, (v_78 != vec4<u32>()));
235
+ r4.w = 0.375f;
236
+ let v_80 = bitcast<vec4<u32>>(r1.zzzz);
237
+ let v_81 = r4;
238
+ r7 = select(r7, v_81, (v_80 != vec4<u32>()));
239
+ r3.w = 0.125f;
240
+ let v_82 = bitcast<vec4<u32>>(r1.yyyy);
241
+ let v_83 = r3;
242
+ r7 = select(r7, v_83, (v_82 != vec4<u32>()));
243
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
244
+ if ((bitcast<u32>(r1.y) != 0u)) {
245
+ r8.x = (r7.x + 0.5f);
246
+ r8.y = fma(r7.y, 0.25f, r7.w);
247
+ let v_84 = r8.xyxx;
248
+ r1.y = textureSampleCompareLevel(t15, s15, v_84.xy, r7.z);
249
+ } else {
250
+ r1.y = 1.0f;
251
+ }
252
+ r1.x = (r1.y + r1.x);
253
+ let v_85 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
254
+ r3 = vec4<f32>(v_85.xyz, r3.w);
255
+ let v_86 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
256
+ r4 = vec4<f32>(v_86.xyz, r4.w);
257
+ let v_87 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
258
+ r5 = vec4<f32>(v_87.xyz, r5.w);
259
+ let v_88 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
260
+ r6 = vec4<f32>(v_88.xyz, r6.w);
261
+ let v_89 = abs(r3.yyyy);
262
+ r1.y = max(v_89.y, abs(r3.xxxx).y);
263
+ let v_90 = abs(r4.yyyy);
264
+ r1.z = max(v_90.z, abs(r4.xxxx).z);
265
+ let v_91 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
266
+ let v_92 = r1;
267
+ r1 = vec4<f32>(v_92.x, v_91.xy, v_92.w);
268
+ let v_93 = abs(r5.yyyy);
269
+ r2.y = max(v_93.y, abs(r5.xxxx).y);
270
+ let v_94 = abs(r6.yyyy);
271
+ r2.z = max(v_94.z, abs(r6.xxxx).z);
272
+ let v_95 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
273
+ let v_96 = r2;
274
+ r2 = vec4<f32>(v_96.x, v_95.xy, v_96.w);
275
+ r6.w = 0.875f;
276
+ let v_97 = bitcast<vec4<u32>>(r2.zzzz);
277
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_97 != vec4<u32>()));
278
+ r5.w = 0.625f;
279
+ let v_98 = bitcast<vec4<u32>>(r2.yyyy);
280
+ let v_99 = r5;
281
+ r7 = select(r7, v_99, (v_98 != vec4<u32>()));
282
+ r4.w = 0.375f;
283
+ let v_100 = bitcast<vec4<u32>>(r1.zzzz);
284
+ let v_101 = r4;
285
+ r7 = select(r7, v_101, (v_100 != vec4<u32>()));
286
+ r3.w = 0.125f;
287
+ let v_102 = bitcast<vec4<u32>>(r1.yyyy);
288
+ let v_103 = r3;
289
+ r7 = select(r7, v_103, (v_102 != vec4<u32>()));
290
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
291
+ if ((bitcast<u32>(r1.y) != 0u)) {
292
+ r8.x = (r7.x + 0.5f);
293
+ r8.y = fma(r7.y, 0.25f, r7.w);
294
+ let v_104 = r8.xyxx;
295
+ r1.y = textureSampleCompareLevel(t15, s15, v_104.xy, r7.z);
296
+ } else {
297
+ r1.y = 1.0f;
298
+ }
299
+ r1.x = (r1.y + r1.x);
300
+ let v_105 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
301
+ r3 = vec4<f32>(v_105.xyz, r3.w);
302
+ let v_106 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
303
+ r4 = vec4<f32>(v_106.xyz, r4.w);
304
+ let v_107 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
305
+ r5 = vec4<f32>(v_107.xyz, r5.w);
306
+ let v_108 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
307
+ r6 = vec4<f32>(v_108.xyz, r6.w);
308
+ let v_109 = abs(r3.yyyy);
309
+ r1.y = max(v_109.y, abs(r3.xxxx).y);
310
+ let v_110 = abs(r4.yyyy);
311
+ r1.z = max(v_110.z, abs(r4.xxxx).z);
312
+ let v_111 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
313
+ let v_112 = r1;
314
+ r1 = vec4<f32>(v_112.x, v_111.xy, v_112.w);
315
+ let v_113 = abs(r5.yyyy);
316
+ r2.y = max(v_113.y, abs(r5.xxxx).y);
317
+ let v_114 = abs(r6.yyyy);
318
+ r2.z = max(v_114.z, abs(r6.xxxx).z);
319
+ let v_115 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
320
+ let v_116 = r2;
321
+ r2 = vec4<f32>(v_116.x, v_115.xy, v_116.w);
322
+ r6.w = 0.875f;
323
+ let v_117 = bitcast<vec4<u32>>(r2.zzzz);
324
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_117 != vec4<u32>()));
325
+ r5.w = 0.625f;
326
+ let v_118 = bitcast<vec4<u32>>(r2.yyyy);
327
+ let v_119 = r5;
328
+ r7 = select(r7, v_119, (v_118 != vec4<u32>()));
329
+ r4.w = 0.375f;
330
+ let v_120 = bitcast<vec4<u32>>(r1.zzzz);
331
+ let v_121 = r4;
332
+ r7 = select(r7, v_121, (v_120 != vec4<u32>()));
333
+ r3.w = 0.125f;
334
+ let v_122 = bitcast<vec4<u32>>(r1.yyyy);
335
+ let v_123 = r3;
336
+ r7 = select(r7, v_123, (v_122 != vec4<u32>()));
337
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
338
+ if ((bitcast<u32>(r1.y) != 0u)) {
339
+ r8.x = (r7.x + 0.5f);
340
+ r8.y = fma(r7.y, 0.25f, r7.w);
341
+ let v_124 = r8.xyxx;
342
+ r1.y = textureSampleCompareLevel(t15, s15, v_124.xy, r7.z);
343
+ } else {
344
+ r1.y = 1.0f;
345
+ }
346
+ r1.x = (r1.y + r1.x);
347
+ let v_125 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
348
+ r3 = vec4<f32>(v_125.xyz, r3.w);
349
+ let v_126 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
350
+ r4 = vec4<f32>(v_126.xyz, r4.w);
351
+ let v_127 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
352
+ r5 = vec4<f32>(v_127.xyz, r5.w);
353
+ let v_128 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
354
+ r6 = vec4<f32>(v_128.xyz, r6.w);
355
+ let v_129 = abs(r3.yyyy);
356
+ r1.y = max(v_129.y, abs(r3.xxxx).y);
357
+ let v_130 = abs(r4.yyyy);
358
+ r1.z = max(v_130.z, abs(r4.xxxx).z);
359
+ let v_131 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
360
+ let v_132 = r1;
361
+ r1 = vec4<f32>(v_132.x, v_131.xy, v_132.w);
362
+ let v_133 = abs(r5.yyyy);
363
+ r2.y = max(v_133.y, abs(r5.xxxx).y);
364
+ let v_134 = abs(r6.yyyy);
365
+ r2.z = max(v_134.z, abs(r6.xxxx).z);
366
+ let v_135 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
367
+ let v_136 = r2;
368
+ r2 = vec4<f32>(v_136.x, v_135.xy, v_136.w);
369
+ r6.w = 0.875f;
370
+ let v_137 = bitcast<vec4<u32>>(r2.zzzz);
371
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_137 != vec4<u32>()));
372
+ r5.w = 0.625f;
373
+ let v_138 = bitcast<vec4<u32>>(r2.yyyy);
374
+ let v_139 = r5;
375
+ r7 = select(r7, v_139, (v_138 != vec4<u32>()));
376
+ r4.w = 0.375f;
377
+ let v_140 = bitcast<vec4<u32>>(r1.zzzz);
378
+ let v_141 = r4;
379
+ r7 = select(r7, v_141, (v_140 != vec4<u32>()));
380
+ r3.w = 0.125f;
381
+ let v_142 = bitcast<vec4<u32>>(r1.yyyy);
382
+ let v_143 = r3;
383
+ r7 = select(r7, v_143, (v_142 != vec4<u32>()));
384
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
385
+ if ((bitcast<u32>(r1.y) != 0u)) {
386
+ r8.x = (r7.x + 0.5f);
387
+ r8.y = fma(r7.y, 0.25f, r7.w);
388
+ let v_144 = r8.xyxx;
389
+ r1.y = textureSampleCompareLevel(t15, s15, v_144.xy, r7.z);
390
+ } else {
391
+ r1.y = 1.0f;
392
+ }
393
+ r1.x = (r1.y + r1.x);
394
+ let v_145 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
395
+ r3 = vec4<f32>(v_145.xyz, r3.w);
396
+ let v_146 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
397
+ r4 = vec4<f32>(v_146.xyz, r4.w);
398
+ let v_147 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
399
+ r5 = vec4<f32>(v_147.xyz, r5.w);
400
+ let v_148 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
401
+ r6 = vec4<f32>(v_148.xyz, r6.w);
402
+ let v_149 = abs(r3.yyyy);
403
+ r1.y = max(v_149.y, abs(r3.xxxx).y);
404
+ let v_150 = abs(r4.yyyy);
405
+ r1.z = max(v_150.z, abs(r4.xxxx).z);
406
+ let v_151 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r1.yz < r1.ww)));
407
+ let v_152 = r1;
408
+ r1 = vec4<f32>(v_152.x, v_151.xy, v_152.w);
409
+ let v_153 = abs(r5.yyyy);
410
+ r2.y = max(v_153.y, abs(r5.xxxx).y);
411
+ let v_154 = abs(r6.yyyy);
412
+ r2.z = max(v_154.z, abs(r6.xxxx).z);
413
+ let v_155 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.yz < r1.ww)));
414
+ let v_156 = r2;
415
+ r2 = vec4<f32>(v_156.x, v_155.xy, v_156.w);
416
+ r6.w = 0.875f;
417
+ let v_157 = bitcast<vec4<u32>>(r2.zzzz);
418
+ r7 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_157 != vec4<u32>()));
419
+ r5.w = 0.625f;
420
+ let v_158 = bitcast<vec4<u32>>(r2.yyyy);
421
+ let v_159 = r5;
422
+ r7 = select(r7, v_159, (v_158 != vec4<u32>()));
423
+ r4.w = 0.375f;
424
+ let v_160 = bitcast<vec4<u32>>(r1.zzzz);
425
+ let v_161 = r4;
426
+ r7 = select(r7, v_161, (v_160 != vec4<u32>()));
427
+ r3.w = 0.125f;
428
+ let v_162 = bitcast<vec4<u32>>(r1.yyyy);
429
+ let v_163 = r3;
430
+ r7 = select(r7, v_163, (v_162 != vec4<u32>()));
431
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r7.w == 5.0f))));
432
+ if ((bitcast<u32>(r1.y) != 0u)) {
433
+ r8.x = (r7.x + 0.5f);
434
+ r8.y = fma(r7.y, 0.25f, r7.w);
435
+ let v_164 = r8.xyxx;
436
+ r1.y = textureSampleCompareLevel(t15, s15, v_164.xy, r7.z);
437
+ } else {
438
+ r1.y = 1.0f;
439
+ }
440
+ r1.x = (r1.y + r1.x);
441
+ let v_165 = fma(r0.yzw, cb6_6.tint_symbol_1[4u].xyz, r3.xyz);
442
+ r3 = vec4<f32>(v_165.xyz, r3.w);
443
+ let v_166 = fma(r0.yzw, cb6_6.tint_symbol_1[5u].xyz, r4.xyz);
444
+ r4 = vec4<f32>(v_166.xyz, r4.w);
445
+ let v_167 = fma(r0.yzw, cb6_6.tint_symbol_1[6u].xyz, r5.xyz);
446
+ r5 = vec4<f32>(v_167.xyz, r5.w);
447
+ let v_168 = fma(r0.yzw, cb6_6.tint_symbol_1[7u].xyz, r6.xyz);
448
+ r6 = vec4<f32>(v_168.xyz, r6.w);
449
+ let v_169 = abs(r3.yyyy);
450
+ r0.y = max(v_169.y, abs(r3.xxxx).y);
451
+ let v_170 = abs(r4.yyyy);
452
+ r0.z = max(v_170.z, abs(r4.xxxx).z);
453
+ let v_171 = abs(r5.yyyy);
454
+ r0.w = max(v_171.w, abs(r5.xxxx).w);
455
+ let v_172 = bitcast<vec3<f32>>(select(vec3<u32>(), vec3<u32>(4294967295u), (r0.yzw < r1.www)));
456
+ r0 = vec4<f32>(r0.x, v_172.xyz);
457
+ let v_173 = abs(r6.yyyy);
458
+ r1.y = max(v_173.y, abs(r6.xxxx).y);
459
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (r1.y < r1.w)));
460
+ r6.w = 0.875f;
461
+ let v_174 = bitcast<vec4<u32>>(r1.yyyy);
462
+ r6 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 5.0f), r6, (v_174 != vec4<u32>()));
463
+ r5.w = 0.625f;
464
+ let v_175 = bitcast<vec4<u32>>(r0.wwww);
465
+ let v_176 = r5;
466
+ r5 = select(r6, v_176, (v_175 != vec4<u32>()));
467
+ r4.w = 0.375f;
468
+ let v_177 = bitcast<vec4<u32>>(r0.zzzz);
469
+ let v_178 = r4;
470
+ r4 = select(r5, v_178, (v_177 != vec4<u32>()));
471
+ r3.w = 0.125f;
472
+ let v_179 = bitcast<vec4<u32>>(r0.yyyy);
473
+ let v_180 = r3;
474
+ r3 = select(r4, v_180, (v_179 != vec4<u32>()));
475
+ r0.y = bitcast<f32>(select(0u, 4294967295u, !((r3.w == 5.0f))));
476
+ if ((bitcast<u32>(r0.y) != 0u)) {
477
+ r4.x = (r3.x + 0.5f);
478
+ r4.y = fma(r3.y, 0.25f, r3.w);
479
+ let v_181 = r4.xyxx;
480
+ r0.y = textureSampleCompareLevel(t15, s15, v_181.xy, r3.z);
481
+ } else {
482
+ r0.y = 1.0f;
483
+ }
484
+ r0.y = (r0.y + r1.x);
485
+ r0.y = (r0.y * 0.125f);
486
+ r2.x = clamp(r2.xxxx.x, 0.0f, 1.0f);
487
+ r0.z = ((-(r2.xxxx)).z + 1.0f);
488
+ o0.x = fma(r0.z, r0.y, r2.x);
489
+ o0 = vec4<f32>(o0.xy, vec2<f32>());
490
+ o0.y = r0.x;
491
+ }
492
+
493
+ @fragment
494
+ fn main(@builtin(position) v_182 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>) -> @location(0u) vec4<f32> {
495
+ main_inner(v_182, v1, v2);
496
+ return o0;
497
+ }
b/8b0b5899ed/shaders/006bd653d319ed4e.wgsl ADDED
@@ -0,0 +1,53 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ struct cb25_struct {
8
+ tint_symbol : array<vec4<f32>, 25u>,
9
+ }
10
+
11
+ @group(0u) @binding(5u) var<uniform> cb5_5 : cb25_struct;
12
+
13
+ @group(0u) @binding(16u) var s0 : sampler;
14
+
15
+ @group(0u) @binding(32u) var t0 : texture_2d<f32>;
16
+
17
+ var<private> o0 : vec4<f32>;
18
+
19
+ var<private> o1 : vec4<f32>;
20
+
21
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>) {
22
+ r0 = textureSampleLevel(t0, s0, v1.zwzz.xy, 0.0f);
23
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (r0.x >= cb5_5.tint_symbol[24u].x)));
24
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (r0.z >= 0.0f)));
25
+ r0.x = bitcast<f32>((bitcast<u32>(r0.y) & bitcast<u32>(r0.x)));
26
+ r0.x = bitcast<f32>((bitcast<u32>(r0.x) & 1065353216u));
27
+ r1.x = fma(v1.x, v0.z, v0.x);
28
+ r1.y = fma((-(v1.yyyy)).y, v0.w, v0.y);
29
+ let v = (r1.xy + vec2<f32>(-0.5f, 0.5f));
30
+ let v_1 = r0;
31
+ r0 = vec4<f32>(v_1.x, v.xy, v_1.w);
32
+ let v_2 = (r0.yz + r0.yz);
33
+ r1 = vec4<f32>(v_2.xy, r1.zw);
34
+ let v_3 = fma(r1.xy, vec2<f32>(1.0f, -1.0f), vec2<f32>(1.0f));
35
+ let v_4 = r0;
36
+ r0 = vec4<f32>(v_4.x, v_3.xy, v_4.w);
37
+ o1 = ((r0.yz * vec2<f32>(0.5f))).xyxy;
38
+ r1 = vec4<f32>(r1.xy, vec2<f32>(0.0f, 1.0f));
39
+ o0 = (r0.xxxx * r1);
40
+ }
41
+
42
+ struct tint_symbol_1 {
43
+ @builtin(position)
44
+ o0 : vec4<f32>,
45
+ @location(1u)
46
+ o1 : vec4<f32>,
47
+ }
48
+
49
+ @vertex
50
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>) -> tint_symbol_1 {
51
+ main_inner(v0, v1);
52
+ return tint_symbol_1(o0, o1);
53
+ }
b/8b0b5899ed/shaders/007089a30fcd7fd8.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1]
b/8b0b5899ed/shaders/007089a30fcd7fd8.wgsl ADDED
@@ -0,0 +1,230 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ struct cb19_struct {
18
+ tint_symbol : array<vec4<f32>, 19u>,
19
+ }
20
+
21
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb19_struct;
22
+
23
+ struct cb15_struct {
24
+ tint_symbol_1 : array<vec4<f32>, 15u>,
25
+ }
26
+
27
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
28
+
29
+ struct cb2_struct {
30
+ tint_symbol_2 : array<vec4<f32>, 2u>,
31
+ }
32
+
33
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
34
+
35
+ struct cb6_struct {
36
+ tint_symbol_3 : array<vec4<f32>, 6u>,
37
+ }
38
+
39
+ @group(1u) @binding(11u) var<uniform> cb11_11 : cb6_struct;
40
+
41
+ @group(1u) @binding(18u) var s2 : sampler;
42
+
43
+ @group(1u) @binding(19u) var s3 : sampler;
44
+
45
+ @group(1u) @binding(21u) var s5 : sampler;
46
+
47
+ @group(1u) @binding(22u) var s6 : sampler;
48
+
49
+ @group(1u) @binding(30u) var s14 : sampler;
50
+
51
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
52
+
53
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
54
+
55
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
56
+
57
+ @group(1u) @binding(37u) var t5 : texture_2d<f32>;
58
+
59
+ @group(1u) @binding(38u) var t6 : texture_2d<f32>;
60
+
61
+ @group(1u) @binding(46u) var t14 : texture_2d<f32>;
62
+
63
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
64
+
65
+ var<private> o0 : vec4<f32>;
66
+
67
+ var<private> x0 : array<vec4<f32>, 4u>;
68
+
69
+ struct tint_symbol_5 {
70
+ tint_symbol_4 : array<vec4<u32>, 3u>,
71
+ }
72
+
73
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_5;
74
+
75
+ fn main_inner(v1 : vec4<f32>, v3 : vec4<f32>) {
76
+ let v_1 = fma(v1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
77
+ r0 = vec4<f32>(v_1.xy, r0.zw);
78
+ let v_2 = fma(r0.xy, vec2<f32>(1.0f, -1.0f), cb11_11.tint_symbol_3[4u].xy);
79
+ r0 = vec4<f32>(v_2.xy, r0.zw);
80
+ r0.x = (r0.x * cb11_11.tint_symbol_3[0u].w);
81
+ r0.y = (r0.y * cb11_11.tint_symbol_3[1u].w);
82
+ let v_3 = (r0.yyy * cb11_11.tint_symbol_3[1u].xyz);
83
+ r0 = vec4<f32>(r0.x, v_3.xyz);
84
+ let v_4 = fma(r0.xxx, cb11_11.tint_symbol_3[0u].xyz, r0.yzw);
85
+ r0 = vec4<f32>(v_4.xyz, r0.w);
86
+ let v_5 = -(cb11_11.tint_symbol_3[2u].xyzx);
87
+ let v_6 = (r0.xyz + v_5.xyz);
88
+ r0 = vec4<f32>(v_6.xyz, r0.w);
89
+ r1 = textureSample(t3, s3, v1.xy.xyxx.xy);
90
+ r0.w = (cb11_11.tint_symbol_3[3u].w + 1.0f);
91
+ r0.w = ((-(r1.xxxx)).w + r0.w);
92
+ r0.w = (cb11_11.tint_symbol_3[2u].w / r0.w);
93
+ let v_7 = fma(r0.xyz, r0.www, cb11_11.tint_symbol_3[3u].xyz);
94
+ r0 = vec4<f32>(v_7.xyz, r0.w);
95
+ let v_8 = (r0.www * v3.xyz);
96
+ r1 = vec4<f32>(v_8.xyz, r1.w);
97
+ let v_9 = (v1.xy * cb2_2.tint_symbol[18u].xy);
98
+ r2 = vec4<f32>(v_9.xy, r2.zw);
99
+ let v_10 = (r2.xy * vec2<f32>(0.015625f));
100
+ r2 = vec4<f32>(v_10.xy, r2.zw);
101
+ r2 = textureSample(t14, s14, r2.xyxx.xy);
102
+ r1.w = (r2.z * cb12_12.tint_symbol_2[0u].w);
103
+ let v_11 = fma(r1.xyz, cb6_6.tint_symbol_1[4u].xyz, cb6_6.tint_symbol_1[8u].xyz);
104
+ r2 = vec4<f32>(v_11.xyz, r2.w);
105
+ let v_12 = &(x0[0u]);
106
+ let v_13 = r2;
107
+ *(v_12) = vec4<f32>(v_13.xyz, (*(v_12)).w);
108
+ let v_14 = fma(r1.xyz, cb6_6.tint_symbol_1[5u].xyz, cb6_6.tint_symbol_1[9u].xyz);
109
+ r3 = vec4<f32>(v_14.xyz, r3.w);
110
+ let v_15 = &(x0[1u]);
111
+ let v_16 = r3;
112
+ *(v_15) = vec4<f32>(v_16.xyz, (*(v_15)).w);
113
+ let v_17 = fma(r1.xyz, cb6_6.tint_symbol_1[6u].xyz, cb6_6.tint_symbol_1[10u].xyz);
114
+ r4 = vec4<f32>(v_17.xyz, r4.w);
115
+ let v_18 = &(x0[2u]);
116
+ let v_19 = r4;
117
+ *(v_18) = vec4<f32>(v_19.xyz, (*(v_18)).w);
118
+ let v_20 = fma(r1.xyz, cb6_6.tint_symbol_1[7u].xyz, cb6_6.tint_symbol_1[11u].xyz);
119
+ r1 = vec4<f32>(v_20.xyz, r1.w);
120
+ let v_21 = &(x0[3u]);
121
+ let v_22 = r1;
122
+ *(v_21) = vec4<f32>(v_22.xyz, (*(v_21)).w);
123
+ r1.z = fma((-(cb6_6.tint_symbol_1[14u].zzzz)).z, 1.5f, 1.0f);
124
+ let v_23 = -(r1.wwww);
125
+ r1.z = fma(r1.z, 0.5f, v_23.z);
126
+ let v_24 = abs(r4.yyyy);
127
+ r1.w = max(v_24.w, abs(r4.xxxx).w);
128
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (r1.w < r1.z)));
129
+ let v_25 = (bitcast<u32>(r1.w) != 0u);
130
+ let v_26 = bitcast<f32>(v.tint_symbol_4[0i].x);
131
+ r1.w = select(bitcast<f32>(v.tint_symbol_4[1i].x), v_26, v_25);
132
+ let v_27 = abs(r3.yyyy);
133
+ r2.z = max(v_27.z, abs(r3.xxxx).z);
134
+ r2.z = bitcast<f32>(select(0u, 4294967295u, (r2.z < r1.z)));
135
+ let v_28 = bitcast<u32>(r2.z);
136
+ r1.w = select(r1.w, bitcast<f32>(v.tint_symbol_4[2i].x), (v_28 != 0u));
137
+ let v_29 = abs(r2.yyyy);
138
+ r2.x = max(v_29.x, abs(r2.xxxx).x);
139
+ r1.z = bitcast<f32>(select(0u, 4294967295u, (r2.x < r1.z)));
140
+ let v_30 = bitcast<u32>(r1.z);
141
+ r1.z = select(r1.w, 0.0f, (v_30 != 0u));
142
+ let v_31 = x0[bitcast<i32>(r1.z)];
143
+ r2 = vec4<f32>(v_31.xyz, r2.w);
144
+ r1.z = f32(bitcast<i32>(r1.z));
145
+ r1.w = (r1.z + 0.5f);
146
+ r1.w = (r1.w * 0.25f);
147
+ r3 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r1.zzzz)));
148
+ r3 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r3) & vec4<u32>(1065353216u)));
149
+ r1.z = dot(r3, cb6_6.tint_symbol_1[12u]);
150
+ r2.w = dot(r3, cb6_6.tint_symbol_1[13u]);
151
+ r3.x = (r2.x + 0.5f);
152
+ r3.y = fma(r2.y, 0.25f, r1.w);
153
+ r1.w = bitcast<f32>(select(0u, 4294967295u, !((r1.z == 0.0f))));
154
+ r1.z = ((-(r1.zzzz)).z + r2.z);
155
+ let v_32 = dpdx(r3.xyy);
156
+ r4 = vec4<f32>(v_32.xy, r4.z, v_32.z);
157
+ r4.z = dpdx(r1.z);
158
+ let v_33 = dpdy(r3.yxy);
159
+ r5 = vec4<f32>(v_33.xyz, r5.w);
160
+ r5.w = dpdy(r1.z);
161
+ let v_34 = (r4.yw * r5.yw);
162
+ r2 = vec4<f32>(v_34.xy, r2.zw);
163
+ let v_35 = -(r2.xyxx);
164
+ let v_36 = fma(r4.xz, r5.xz, v_35.xy);
165
+ r6 = vec4<f32>(v_36.xy, r6.zw);
166
+ r2.x = (1.0f / r6.x);
167
+ r2.y = (r4.z * r5.y);
168
+ let v_37 = -(r2.yyyy);
169
+ r6.z = fma(r4.x, r5.w, v_37.z);
170
+ let v_38 = (r2.xx * r6.yz);
171
+ r2 = vec4<f32>(v_38.xy, r2.zw);
172
+ let v_39 = max(r2.xy, vec2<f32>());
173
+ r2 = vec4<f32>(v_39.xy, r2.zw);
174
+ let v_40 = min(r2.xy, vec2<f32>(0.5f));
175
+ r2 = vec4<f32>(v_40.xy, r2.zw);
176
+ r1.z = fma((-(r2.wwww)).z, r2.x, r1.z);
177
+ r1.z = fma((-(r2.wwww)).z, r2.y, r1.z);
178
+ let v_41 = bitcast<u32>(r1.w);
179
+ let v_42 = r1.z;
180
+ r1.z = select(r2.z, v_42, (v_41 != 0u));
181
+ r2.x = (r3.x + cb6_6.tint_symbol_1[14u].z);
182
+ r2.y = fma(cb6_6.tint_symbol_1[14u].w, 0.25f, r3.y);
183
+ let v_43 = r2.xyxx;
184
+ r2.x = textureSampleCompareLevel(t15, s15, v_43.xy, r1.z);
185
+ r1.z = bitcast<f32>(select(0u, 4294967295u, !((cb12_12.tint_symbol_2[1u].x == 0.0f))));
186
+ if ((bitcast<u32>(r1.z) != 0u)) {
187
+ r3 = textureSample(t2, s2, r3.xyxx.xy);
188
+ r2.y = ((-(r3.wwww)).y + 1.0f);
189
+ } else {
190
+ r2.y = 1.0f;
191
+ }
192
+ r0.w = clamp(fma(r0.wwww, cb6_6.tint_symbol_1[0u].wwww, cb6_6.tint_symbol_1[1u].wwww).w, 0.0f, 1.0f);
193
+ let v_44 = abs(r1.yyyy);
194
+ r1.x = max(v_44.x, abs(r1.xxxx).x);
195
+ r1.x = clamp(fma(r1.xxxx, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).x, 0.0f, 1.0f);
196
+ r0.w = ((-(r0.wwww)).w + 1.0f);
197
+ let v_45 = fma(r0.ww, r1.xx, r2.xy);
198
+ r1 = vec4<f32>(v_45.xy, r1.zw);
199
+ let v_46 = (r1.xy * r1.xy);
200
+ r1 = vec4<f32>(v_46.xy, r1.zw);
201
+ let v_47 = min(r1.xy, vec2<f32>(1.0f));
202
+ let v_48 = r1;
203
+ r1 = vec4<f32>(v_48.x, v_47.xy, v_48.w);
204
+ r0.w = bitcast<f32>(select(0u, 4294967295u, !((0.0f == cb12_12.tint_symbol_2[1u].y))));
205
+ r1.w = (r1.z * r1.y);
206
+ let v_49 = bitcast<u32>(r0.w);
207
+ let v_50 = r1.w;
208
+ r1.x = select(r1.y, v_50, (v_49 != 0u));
209
+ r2.x = (-(cb11_11.tint_symbol_3[5u].wwww)).x;
210
+ let v_51 = r2;
211
+ r2 = vec4<f32>(v_51.x, 0.0f, v_51.z, 0.5f);
212
+ let v_52 = fma(r0.xy, vec2<f32>(0.00028571428265422583f), r2.xy);
213
+ r0 = vec4<f32>(v_52.xy, r0.zw);
214
+ r3 = textureSample(t5, s5, r0.xyxx.xy);
215
+ r2.z = r3.y;
216
+ r2 = textureSample(t6, s6, r2.zwzz.xy);
217
+ r0.x = clamp(fma(r0.zzzz, cb6_6.tint_symbol_1[3u].xxxx, cb6_6.tint_symbol_1[3u].yyyy).x, 0.0f, 1.0f);
218
+ r0.x = sqrt(r0.x);
219
+ r0.x = fma((-(r0.xxxx)).x, cb6_6.tint_symbol_1[3u].z, 1.0f);
220
+ r0.x = (r0.x * r2.x);
221
+ let v_53 = (r0.xx * r1.xz);
222
+ r0 = vec4<f32>(v_53.xy, r0.zw);
223
+ o0 = min(r0.yyyy, r0.xxxx);
224
+ }
225
+
226
+ @fragment
227
+ fn main(@location(1u) v1 : vec4<f32>, @location(3u) v3 : vec4<f32>) -> @location(0u) vec4<f32> {
228
+ main_inner(v1, v3);
229
+ return o0;
230
+ }
b/8b0b5899ed/shaders/00716d7357599de4.wgsl ADDED
@@ -0,0 +1,100 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ enable clip_distances;
2
+ diagnostic(off, derivative_uniformity);
3
+
4
+ var<private> r0 : vec4<f32>;
5
+
6
+ var<private> r1 : vec4<f32>;
7
+
8
+ var<private> r2 : vec4<f32>;
9
+
10
+ struct cb12_struct {
11
+ tint_symbol : array<vec4<f32>, 12u>,
12
+ }
13
+
14
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb12_struct;
15
+
16
+ struct cb1_struct {
17
+ tint_symbol_1 : array<vec4<f32>, 1u>,
18
+ }
19
+
20
+ @group(0u) @binding(0u) var<uniform> cb0_0 : cb1_struct;
21
+
22
+ struct cb44_struct {
23
+ tint_symbol_2 : array<vec4<f32>, 44u>,
24
+ }
25
+
26
+ @group(0u) @binding(3u) var<uniform> cb3_3 : cb44_struct;
27
+
28
+ var<private> o0 : vec4<f32>;
29
+
30
+ var<private> o1 : vec4<f32>;
31
+
32
+ var<private> o2 : vec4<f32>;
33
+
34
+ var<private> o3 : array<f32, 4u>;
35
+
36
+ var<private> v : vec4<f32>;
37
+
38
+ var<private> x0 : array<vec4<f32>, 1u>;
39
+
40
+ fn main_inner(v0 : vec3<f32>) {
41
+ o0 = ((v0 + cb1_1.tint_symbol[3u].xyz)).xyzx;
42
+ r0 = (v0.yyyy * cb1_1.tint_symbol[9u]);
43
+ r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0);
44
+ r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0);
45
+ r0 = (r0 + cb1_1.tint_symbol[11u]);
46
+ r1 = (cb3_3.tint_symbol_2[1u] + cb3_3.tint_symbol_2[43u]);
47
+ r1.x = dot(r1, vec4<f32>(1.0f));
48
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (r1.x < 0.0f)));
49
+ if ((bitcast<u32>(r1.x) != 0u)) {
50
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x >= -1.0f)));
51
+ if ((bitcast<u32>(r1.x) != 0u)) {
52
+ o1 = vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f);
53
+ } else {
54
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x == -2.0f)));
55
+ if ((bitcast<u32>(r1.x) != 0u)) {
56
+ o1 = vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f);
57
+ } else {
58
+ r1 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (cb3_3.tint_symbol_2[43u].xxxx == vec4<f32>(-3.0f, -4.0f, -5.0f, -9.0f))));
59
+ r2.x = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[43u].x == -10.0f)));
60
+ r1.w = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r2.x)));
61
+ r2 = select(vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f), vec4<f32>(), (bitcast<vec4<u32>>(r1.wwww) != vec4<u32>()));
62
+ r1.y = bitcast<f32>((bitcast<u32>(r1.y) | bitcast<u32>(r1.z)));
63
+ let v_1 = bitcast<vec4<u32>>(r1.yyyy);
64
+ r2 = select(r2, vec4<f32>(0.5f, 0.5f, 0.5f, 1.0f), (v_1 != vec4<u32>()));
65
+ let v_2 = bitcast<vec4<u32>>(r1.xxxx);
66
+ o1 = select(r2, vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f), (v_2 != vec4<u32>()));
67
+ }
68
+ }
69
+ } else {
70
+ o1 = vec4<f32>();
71
+ }
72
+ x0[0u].x = dot(r0, cb0_0.tint_symbol_1[0u]);
73
+ o2 = r0;
74
+ let v_3 = &(x0[0u]);
75
+ *(v_3) = vec4<f32>((*(v_3)).x, vec3<f32>());
76
+ o3[0u] = x0[0u].x;
77
+ o3[1u] = x0[0u].y;
78
+ o3[2u] = x0[0u].z;
79
+ o3[3u] = x0[0u].w;
80
+ v = vec4<f32>(o3[0u], o3[1u], o3[2u], o3[3u]);
81
+ }
82
+
83
+ struct tint_symbol_4 {
84
+ @location(0u)
85
+ o0 : vec4<f32>,
86
+ @location(1u)
87
+ o1 : vec4<f32>,
88
+ @builtin(position)
89
+ o2 : vec4<f32>,
90
+ @builtin(clip_distances)
91
+ o3 : array<f32, 4u>,
92
+ @location(15u)
93
+ tint_symbol_3 : vec4<f32>,
94
+ }
95
+
96
+ @vertex
97
+ fn main(@location(0u) v0 : vec3<f32>) -> tint_symbol_4 {
98
+ main_inner(v0);
99
+ return tint_symbol_4(o0, o1, o2, o3, v);
100
+ }
b/8b0b5899ed/shaders/007db7c8f96e98aa.wgsl ADDED
@@ -0,0 +1,333 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ struct cb17_struct {
20
+ tint_symbol : array<vec4<f32>, 17u>,
21
+ }
22
+
23
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
24
+
25
+ struct cb46_struct {
26
+ tint_symbol_1 : array<vec4<f32>, 46u>,
27
+ }
28
+
29
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb46_struct;
30
+
31
+ struct cb4_struct {
32
+ tint_symbol_2 : array<vec4<f32>, 4u>,
33
+ }
34
+
35
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb4_struct;
36
+
37
+ struct cb2_struct {
38
+ tint_symbol_3 : array<vec4<f32>, 2u>,
39
+ }
40
+
41
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
42
+
43
+ @group(1u) @binding(16u) var s0 : sampler;
44
+
45
+ @group(1u) @binding(18u) var s2 : sampler;
46
+
47
+ @group(1u) @binding(19u) var s3 : sampler;
48
+
49
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
50
+
51
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
52
+
53
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
54
+
55
+ var<private> o0 : vec4<f32>;
56
+
57
+ var<private> o1 : vec4<f32>;
58
+
59
+ var<private> o2 : vec4<f32>;
60
+
61
+ var<private> o3 : vec4<f32>;
62
+
63
+ fn main_inner(v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>) {
64
+ let v = clamp(v2.zw, vec2<f32>(), vec2<f32>(1.0f));
65
+ r0 = vec4<f32>(v.xy, r0.zw);
66
+ let v_1 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (cb2_2.tint_symbol[2u].xy == vec2<f32>(1.0f))));
67
+ r1 = vec4<f32>(v_1.xy, r1.zw);
68
+ if ((bitcast<u32>(r1.x) != 0u)) {
69
+ r2 = vec4<f32>(v2.xy, r2.zw);
70
+ let v_2 = r1;
71
+ r1 = vec4<f32>(v2.x, v_2.y, v2.y, v_2.w);
72
+ } else {
73
+ r1.z = ((-(r0.xxxx)).z + 1.0f);
74
+ r1.w = ((-(v2.wwww)).w + 1.0f);
75
+ r1.w = max(r1.w, 0.10000000149011611938f);
76
+ r1.w = min(r1.w, 1.0f);
77
+ r2.x = dot(v5.xyz, v4.xyz);
78
+ r2.y = dot(v6.xyz, v4.xyz);
79
+ r2.z = dot(v3.xyz, v4.xyz);
80
+ r2.w = dot(r2.xyz, r2.xyz);
81
+ r2.w = inverseSqrt(r2.w);
82
+ let v_3 = (r2.www * r2.xyz);
83
+ r2 = vec4<f32>(v_3.xyz, r2.w);
84
+ r1.w = max(r1.w, r2.z);
85
+ r2.z = dot(v4.xyz, v4.xyz);
86
+ r2.z = inverseSqrt(r2.z);
87
+ let v_4 = (r2.zzz * v4.xyz);
88
+ r3 = vec4<f32>(v_4.xyz, r3.w);
89
+ r2.z = dot(v3.xyz, v3.xyz);
90
+ r2.z = inverseSqrt(r2.z);
91
+ let v_5 = (r2.zzz * v3.xyz);
92
+ r4 = vec4<f32>(v_5.xyz, r4.w);
93
+ r2.z = dot(r3.xyz, r4.xyz);
94
+ r2.w = ((-(cb2_2.tint_symbol[3u].wwww)).w + cb2_2.tint_symbol[3u].z);
95
+ r2.w = fma(abs(r2.zzzz).w, r2.w, cb2_2.tint_symbol[3u].w);
96
+ r1.z = (r1.z * cb2_2.tint_symbol[1u].x);
97
+ r3.x = clamp(((r2.wwww + vec4<f32>(-1.0f))).x, 0.0f, 1.0f);
98
+ r1.z = (r1.z * r3.x);
99
+ r2.z = (abs(r2.zzzz).z * 4.0f);
100
+ r2.z = min(r2.z, 1.0f);
101
+ r1.z = (r1.z * r2.z);
102
+ let v_6 = ((-(r2.xyxx)).xy / r1.ww);
103
+ r3 = vec4<f32>(v_6.xy, r3.zw);
104
+ let v_7 = (r3.xy * cb12_12.tint_symbol_3[1u].xx);
105
+ r3 = vec4<f32>(v_7.xy, r3.zw);
106
+ let v_8 = (r1.zz * r3.xy);
107
+ r3 = vec4<f32>(v_8.xy, r3.zw);
108
+ let v_9 = (r2.xy / r1.ww);
109
+ r2 = vec4<f32>(v_9.xy, r2.zw);
110
+ let v_10 = (r2.xy * cb12_12.tint_symbol_3[1u].yy);
111
+ r2 = vec4<f32>(v_10.xy, r2.zw);
112
+ let v_11 = (r1.zz * r2.xy);
113
+ r1 = vec4<f32>(r1.xy, v_11.xy);
114
+ let v_12 = r2.w;
115
+ let v_13 = max(v_12, -2147483648.0f);
116
+ r2.x = bitcast<f32>(select(select(i32(v_13), 2147483647i, (v_13 >= 2147483648.0f)), 0i, !((v_12 == v_12))));
117
+ r2.y = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r2.x) == 0i)));
118
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r2.y)));
119
+ if ((bitcast<u32>(r1.x) != 0u)) {
120
+ r1.x = 0.0f;
121
+ } else {
122
+ r1.x = trunc(r2.w);
123
+ r1.x = (1.0f / r1.x);
124
+ let v_14 = dpdx(v2.xy);
125
+ let v_15 = r2;
126
+ r2 = vec4<f32>(v_15.x, v_14.xy, v_15.w);
127
+ let v_16 = dpdy(v2.xy);
128
+ r3 = vec4<f32>(r3.xy, v_16.xy);
129
+ r4 = textureSampleGrad(t2, s2, v2.xyxx.xy, r2.yz, r3.zw);
130
+ r2.w = (r4.x + 0.00000099999999747524f);
131
+ let v_17 = r1;
132
+ r4 = vec4<f32>(v_17.zw, r4.zw);
133
+ r4 = vec4<f32>(r4.xy, vec2<f32>(1.0f));
134
+ let v_18 = r2;
135
+ r5 = vec4<f32>(v_18.ww, r5.zw);
136
+ r5.z = 0.0f;
137
+ loop {
138
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r5.z) >= bitcast<i32>(r2.x))));
139
+ if ((bitcast<u32>(r5.w) != 0u)) {
140
+ break;
141
+ }
142
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (r5.x < r4.z)));
143
+ if ((bitcast<u32>(r5.w) != 0u)) {
144
+ r5.w = ((-(r1.xxxx)).w + r4.z);
145
+ let v_19 = fma(r3.xy, r1.xx, r4.xy);
146
+ r4 = vec4<f32>(v_19.xy, r4.zw);
147
+ let v_20 = (r4.xy + v2.xy);
148
+ r6 = vec4<f32>(v_20.xy, r6.zw);
149
+ let v_21 = r2.yz;
150
+ let v_22 = r3.zw;
151
+ r6 = textureSampleGrad(t2, s2, r6.xyxx.xy, v_21, v_22);
152
+ r4.w = r4.z;
153
+ let v_23 = r5;
154
+ let v_24 = r5;
155
+ r5 = vec4<f32>(v_24.x, v_23.xz, v_24.w);
156
+ r4.z = r5.w;
157
+ r5.x = r6.x;
158
+ } else {
159
+ r5.z = r2.x;
160
+ }
161
+ r5.z = bitcast<f32>((bitcast<i32>(r5.z) + 1i));
162
+ }
163
+ let v_25 = -(r5.xxxx);
164
+ r1.x = (r4.z + v_25.x);
165
+ let v_26 = -(r5.yyyy);
166
+ r2.x = (r4.w + v_26.x);
167
+ r2.y = ((-(r1.xxxx)).y + r2.x);
168
+ r2.z = bitcast<f32>(select(0u, 4294967295u, (0.0f < r2.y)));
169
+ r1.x = (r1.x * r4.w);
170
+ let v_27 = -(r1.xxxx);
171
+ r1.x = fma(r4.z, r2.x, v_27.x);
172
+ r1.x = (r1.x / r2.y);
173
+ let v_28 = bitcast<vec4<u32>>(r2.zzzz);
174
+ let v_29 = r1.xxxx;
175
+ r1.x = clamp(select(r5.xxxx, v_29, (v_28 != vec4<u32>())).x, 0.0f, 1.0f);
176
+ }
177
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
178
+ let v_30 = fma(r3.xy, r1.xx, r1.zw);
179
+ let v_31 = r1;
180
+ r1 = vec4<f32>(v_30.x, v_31.y, v_30.y, v_31.w);
181
+ let v_32 = (r1.xz + v2.xy);
182
+ let v_33 = r1;
183
+ r1 = vec4<f32>(v_32.x, v_33.y, v_32.y, v_33.w);
184
+ let v_34 = r1;
185
+ r2 = vec4<f32>(v_34.xz, r2.zw);
186
+ }
187
+ r3 = textureSample(t0, s0, r2.xyxx.xy);
188
+ r4 = textureSample(t3, s3, r1.xzxx.xy);
189
+ let v_35 = fma(r4.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
190
+ let v_36 = r1;
191
+ r1 = vec4<f32>(v_35.x, v_36.y, v_35.y, v_36.w);
192
+ r1.w = dot(r1.xz, r1.xz);
193
+ r1.w = ((-(r1.wwww)).w + 1.0f);
194
+ r1.w = sqrt(abs(r1.wwww).w);
195
+ r2.z = max(cb12_12.tint_symbol_3[0u].w, 0.00100000004749745131f);
196
+ let v_37 = (r1.xz * r2.zz);
197
+ let v_38 = r1;
198
+ r1 = vec4<f32>(v_37.x, v_38.y, v_37.y, v_38.w);
199
+ let v_39 = (r1.zzz * v6.xyz);
200
+ r4 = vec4<f32>(v_39.xyz, r4.w);
201
+ let v_40 = fma(r1.xxx, v5.xyz, r4.xyz);
202
+ r4 = vec4<f32>(v_40.xyz, r4.w);
203
+ let v_41 = fma(r1.www, v3.xyz, r4.xyz);
204
+ r1 = vec4<f32>(v_41.x, r1.y, v_41.yz);
205
+ r2.z = dot(r1.xzw, r1.xzw);
206
+ r2.z = inverseSqrt(r2.z);
207
+ let v_42 = (r1.xzw * r2.zzz);
208
+ r4 = vec4<f32>(v_42.xyz, r4.w);
209
+ r5.x = dot(v5.xyz, cb3_3.tint_symbol_1[0u].xyz);
210
+ r5.y = dot(v6.xyz, cb3_3.tint_symbol_1[0u].xyz);
211
+ r1.x = dot(v3.xyz, cb3_3.tint_symbol_1[0u].xyz);
212
+ r1.z = ((-(v2.zzzz)).z + 1.0f);
213
+ r2.w = (cb2_2.tint_symbol[1u].x * cb12_12.tint_symbol_3[1u].x);
214
+ let v_43 = (r2.ww * r5.xy);
215
+ r5 = vec4<f32>(v_43.xy, r5.zw);
216
+ let v_44 = (r1.zz * r5.xy);
217
+ r5 = vec4<f32>(v_44.xy, r5.zw);
218
+ let v_45 = (r5.xy / r1.xx);
219
+ let v_46 = r1;
220
+ r1 = vec4<f32>(v_45.x, v_46.y, v_45.y, v_46.w);
221
+ r5 = textureSample(t2, s2, r2.xyxx.xy);
222
+ r6 = fma(r1.xzxz, vec4<f32>(0.87999999523162841797f, 0.87999999523162841797f, 0.76999998092651367188f, 0.76999998092651367188f), r2.xyxy);
223
+ r7 = textureSample(t2, s2, r6.xyxx.xy);
224
+ r2.w = ((-(r5.xxxx)).w + r7.x);
225
+ r2.w = (r2.w + -0.87999999523162841797f);
226
+ r6 = textureSample(t2, s2, r6.zwzz.xy);
227
+ r4.w = ((-(r5.xxxx)).w + r6.x);
228
+ r4.w = (r4.w + -0.76999998092651367188f);
229
+ r4.w = (r4.w + r4.w);
230
+ r6 = fma(r1.xzxz, vec4<f32>(0.66000002622604370117f, 0.66000002622604370117f, 0.55000001192092895508f, 0.55000001192092895508f), r2.xyxy);
231
+ r7 = textureSample(t2, s2, r6.xyxx.xy);
232
+ r5.y = ((-(r5.xxxx)).y + r7.x);
233
+ r5.y = (r5.y + -0.66000002622604370117f);
234
+ r6 = textureSample(t2, s2, r6.zwzz.xy);
235
+ r5.z = ((-(r5.xxxx)).z + r6.x);
236
+ r5.z = (r5.z + -0.55000001192092895508f);
237
+ r6 = fma(r1.xzxz, vec4<f32>(0.43999999761581420898f, 0.43999999761581420898f, 0.33000001311302185059f, 0.33000001311302185059f), r2.xyxy);
238
+ r7 = textureSample(t2, s2, r6.xyxx.xy);
239
+ r5.w = ((-(r5.xxxx)).w + r7.x);
240
+ r5.w = (r5.w + -0.43999999761581420898f);
241
+ let v_47 = (r5.yzw * vec3<f32>(4.0f, 6.0f, 8.0f));
242
+ r5 = vec4<f32>(r5.x, v_47.xyz);
243
+ r6 = textureSample(t2, s2, r6.zwzz.xy);
244
+ r6.x = ((-(r5.xxxx)).x + r6.x);
245
+ r6.x = (r6.x + -0.33000001311302185059f);
246
+ r6.x = (r6.x * 10.0f);
247
+ let v_48 = fma(r1.xz, vec2<f32>(0.21999999880790710449f), r2.xy);
248
+ let v_49 = r1;
249
+ r1 = vec4<f32>(v_48.x, v_49.y, v_48.y, v_49.w);
250
+ r7 = textureSample(t2, s2, r1.xzxx.xy);
251
+ r1.x = ((-(r5.xxxx)).x + r7.x);
252
+ r1.x = (r1.x + -0.21999999880790710449f);
253
+ r1.x = (r1.x * 12.0f);
254
+ r1.z = max(r2.w, r4.w);
255
+ r1.z = max(r5.y, r1.z);
256
+ r1.z = max(r5.z, r1.z);
257
+ r1.z = max(r5.w, r1.z);
258
+ r1.z = max(r6.x, r1.z);
259
+ r1.x = clamp(max(r1.xxxx, r1.zzzz).x, 0.0f, 1.0f);
260
+ o2.w = fma((-(r1.xxxx)).w, cb12_12.tint_symbol_3[1u].z, 1.0f);
261
+ r0.z = ((-(r0.yyyy)).z + 1.0f);
262
+ r0.w = 0.0f;
263
+ let v_50 = bitcast<vec3<u32>>(r1.yyy);
264
+ let v_51 = r0.xzw;
265
+ let v_52 = select(r3.xyz, v_51, (v_50 != vec3<u32>()));
266
+ r0 = vec4<f32>(v_52.xyz, r0.w);
267
+ r0.w = clamp(fma(v3.xyz.zzzz, vec4<f32>(128.0f), vec4<f32>(-127.0f)).w, 0.0f, 1.0f);
268
+ r1.x = (r3.w * v1.w);
269
+ let v_53 = (v1.xy * cb2_2.tint_symbol[15u].zy);
270
+ let v_54 = r3;
271
+ r3 = vec4<f32>(v_54.x, v_53.xy, v_54.w);
272
+ o0.w = (r1.x * cb2_2.tint_symbol[15u].x);
273
+ let v_55 = fma(r4.xyz, vec3<f32>(0.5f), vec3<f32>(0.5f));
274
+ o1 = vec4<f32>(v_55.xyz, o1.w);
275
+ r1.x = (cb12_12.tint_symbol_3[1u].w + -0.20000000298023223877f);
276
+ r1.x = clamp(((r1.xxxx * vec4<f32>(10.0f))).x, 0.0f, 1.0f);
277
+ o1.w = (r0.w * r1.x);
278
+ r3.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w);
279
+ let v_56 = (r3.xz * vec2<f32>(0.5f));
280
+ r1 = vec4<f32>(v_56.xy, r1.zw);
281
+ let v_57 = sqrt(r1.xy);
282
+ o3 = vec4<f32>(v_57.xy, o3.zw);
283
+ r0.w = fma(r1.w, r2.z, -0.34999999403953552246f);
284
+ r0.w = clamp(((r0.wwww * vec4<f32>(1.53846156597137451172f))).w, 0.0f, 1.0f);
285
+ r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z);
286
+ r1.x = ((-(cb2_2.tint_symbol[16u].zzzz)).x + 1.0f);
287
+ r0.w = (r0.w * r1.x);
288
+ r0.w = (r3.y * r0.w);
289
+ r1.x = (cb12_12.tint_symbol_3[0u].y * 0.001953125f);
290
+ r1.z = (-(r1.xxxx)).z;
291
+ r2.x = fma((-(cb12_12.tint_symbol_3[0u].zzzz)).x, 0.5f, 1.0f);
292
+ r2.x = (r0.w * r2.x);
293
+ r0.w = (r0.w * cb12_12.tint_symbol_3[1u].w);
294
+ r2.x = fma(r2.x, -0.5f, 1.0f);
295
+ let v_58 = (r0.xyz * r2.xxx);
296
+ o0 = vec4<f32>(v_58.xyz, o0.w);
297
+ r0.x = clamp(((cb12_12.tint_symbol_3[0u].zzzz + vec4<f32>(0.40000000596046447754f))).x, 0.0f, 1.0f);
298
+ let v_59 = (r0.xx * vec2<f32>(0.5f, 0.48828125f));
299
+ r0 = vec4<f32>(v_59.xy, r0.zw);
300
+ let v_60 = (-(cb12_12.tint_symbol_3[0u].zzzx)).yw;
301
+ let v_61 = r1;
302
+ r1 = vec4<f32>(v_61.x, v_60.x, v_61.z, v_60.y);
303
+ r0.z = 0.97000002861022949219f;
304
+ let v_62 = (r0.xyz + r1.yzw);
305
+ r0 = vec4<f32>(v_62.xyz, r0.w);
306
+ let v_63 = max(r0.xyz, vec3<f32>());
307
+ r0 = vec4<f32>(v_63.xyz, r0.w);
308
+ let v_64 = fma(r0.xz, r0.ww, cb12_12.tint_symbol_3[0u].zx);
309
+ let v_65 = r2;
310
+ r2 = vec4<f32>(v_64.x, v_65.y, v_64.y, v_65.w);
311
+ r2.y = fma(r0.y, r0.w, r1.x);
312
+ let v_66 = sqrt(r2.xy);
313
+ o2 = vec4<f32>(v_66.xy, o2.zw);
314
+ o2.z = r2.z;
315
+ o3 = vec4<f32>(o3.xy, vec2<f32>(0.0f, 1.00188386440277099609f));
316
+ }
317
+
318
+ struct tint_symbol_4 {
319
+ @location(0u)
320
+ o0 : vec4<f32>,
321
+ @location(1u)
322
+ o1 : vec4<f32>,
323
+ @location(2u)
324
+ o2 : vec4<f32>,
325
+ @location(3u)
326
+ o3 : vec4<f32>,
327
+ }
328
+
329
+ @fragment
330
+ fn main(@location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>) -> tint_symbol_4 {
331
+ main_inner(v1, v2, v3, v4, v5, v6);
332
+ return tint_symbol_4(o0, o1, o2, o3);
333
+ }
b/8b0b5899ed/shaders/0081a738fe9b7258.wgsl ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ @group(1u) @binding(47u) var t15 : texture_multisampled_2d<f32>;
6
+
7
+ var<private> v0 : vec4<f32>;
8
+
9
+ var<private> oDepth : f32;
10
+
11
+ fn main_inner(v : vec4<f32>) {
12
+ var v_1 : vec4<f32> = v;
13
+ v_1.w = (1.0f / v.w);
14
+ v0 = v_1;
15
+ let v_2 = v0.xy;
16
+ let v_3 = max(v_2, vec2<f32>(-2147483648.0f));
17
+ let v_4 = bitcast<vec2<f32>>(select(select(vec2<i32>(v_3), vec2<i32>(2147483647i), (v_3 >= vec2<f32>(2147483648.0f))), vec2<i32>(), !((v_2 == v_2))));
18
+ r0 = vec4<f32>(v_4.xy, r0.zw);
19
+ r0 = vec4<f32>(r0.xy, vec2<f32>());
20
+ r0.x = textureLoad(t15, bitcast<vec2<i32>>(r0.xy), 0i).x;
21
+ oDepth = r0.x;
22
+ }
23
+
24
+ @fragment
25
+ fn main(@builtin(position) v_5 : vec4<f32>) -> @builtin(frag_depth) f32 {
26
+ main_inner(v_5);
27
+ return oDepth;
28
+ }
b/8b0b5899ed/shaders/0083d1a975976c79.wgsl ADDED
@@ -0,0 +1,145 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ struct cb17_struct {
12
+ tint_symbol : array<vec4<f32>, 17u>,
13
+ }
14
+
15
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
16
+
17
+ struct cb46_struct {
18
+ tint_symbol_1 : array<vec4<f32>, 46u>,
19
+ }
20
+
21
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb46_struct;
22
+
23
+ struct cb4_struct {
24
+ tint_symbol_2 : array<vec4<f32>, 4u>,
25
+ }
26
+
27
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb4_struct;
28
+
29
+ struct cb2_struct {
30
+ tint_symbol_3 : array<vec4<f32>, 2u>,
31
+ }
32
+
33
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
34
+
35
+ @group(1u) @binding(16u) var s0 : sampler;
36
+
37
+ @group(1u) @binding(18u) var s2 : sampler;
38
+
39
+ @group(1u) @binding(19u) var s3 : sampler;
40
+
41
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
42
+
43
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
44
+
45
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
46
+
47
+ var<private> o0 : vec4<f32>;
48
+
49
+ var<private> o1 : vec4<f32>;
50
+
51
+ var<private> o2 : vec4<f32>;
52
+
53
+ var<private> o3 : vec4<f32>;
54
+
55
+ fn main_inner(v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>) {
56
+ r0.x = dot(v4.xyz, v4.xyz);
57
+ r0.x = inverseSqrt(r0.x);
58
+ let v = (r0.xxx * v4.xyz);
59
+ r0 = vec4<f32>(v.xyz, r0.w);
60
+ r0.w = dot(v3.xyz, v3.xyz);
61
+ r0.w = inverseSqrt(r0.w);
62
+ let v_1 = (r0.www * v3.xyz);
63
+ r1 = vec4<f32>(v_1.xyz, r1.w);
64
+ r0.w = fma(v3.z, r0.w, -0.34999999403953552246f);
65
+ r0.w = clamp(((r0.wwww * vec4<f32>(1.53846156597137451172f))).w, 0.0f, 1.0f);
66
+ r0.w = (r0.w * cb5_5.tint_symbol_2[3u].z);
67
+ r1.w = dot((-(r0.xyzx)).xyz, r1.xyz);
68
+ r1.w = (r1.w + r1.w);
69
+ let v_2 = -(r1.wwww);
70
+ let v_3 = -(r0.xyzx);
71
+ let v_4 = fma(r1.xyz, v_2.xyz, v_3.xyz);
72
+ r0 = vec4<f32>(v_4.xyz, r0.w);
73
+ let v_5 = fma(r1.xyz, vec3<f32>(0.5f), vec3<f32>(0.5f));
74
+ o1 = vec4<f32>(v_5.xyz, o1.w);
75
+ r0.y = dot(r0.xyz, r0.xyz);
76
+ r0.y = inverseSqrt(r0.y);
77
+ let v_6 = fma(r0.xz, r0.yy, vec2<f32>(1.0f));
78
+ r0 = vec4<f32>(v_6.xy, r0.zw);
79
+ let v_7 = (r0.xy * vec2<f32>(-0.5f));
80
+ r0 = vec4<f32>(v_7.xy, r0.zw);
81
+ r1 = textureSample(t3, s3, r0.xyxx.xy);
82
+ r2 = textureSample(t0, s0, v2.xy.xyxx.xy);
83
+ let v_8 = fma(r1.xyz, cb12_12.tint_symbol_3[1u].www, r2.xyz);
84
+ r0 = vec4<f32>(v_8.xyz, r0.w);
85
+ r1.x = (r2.w * v1.w);
86
+ o0.w = (r1.x * cb2_2.tint_symbol[15u].x);
87
+ r1.x = ((-(cb2_2.tint_symbol[16u].zzzz)).x + 1.0f);
88
+ r0.w = (r0.w * r1.x);
89
+ let v_9 = (v1.xy * cb2_2.tint_symbol[15u].zy);
90
+ let v_10 = r1;
91
+ r1 = vec4<f32>(v_10.x, v_9.xy, v_10.w);
92
+ r0.w = (r0.w * r1.y);
93
+ r2 = textureSample(t2, s2, v2.xy.xyxx.xy);
94
+ let v_11 = (r2.xy * r2.xy);
95
+ r2 = vec4<f32>(v_11.xy, r2.zw);
96
+ r1.y = (r2.w * cb12_12.tint_symbol_3[0u].y);
97
+ r3.y = (r1.y * 0.001953125f);
98
+ r1.y = dot(r2.xyz, cb12_12.tint_symbol_3[1u].xyz);
99
+ r3.x = (r1.y * cb12_12.tint_symbol_3[0u].z);
100
+ r1.y = clamp(fma(r1.yyyy, cb12_12.tint_symbol_3[0u].zzzz, vec4<f32>(0.40000000596046447754f)).y, 0.0f, 1.0f);
101
+ let v_12 = (r1.yy * vec2<f32>(0.5f, 0.48828125f));
102
+ r2 = vec4<f32>(v_12.xy, r2.zw);
103
+ r1.y = fma((-(r3.xxxx)).y, 0.5f, 1.0f);
104
+ r1.y = (r0.w * r1.y);
105
+ r1.y = fma(r1.y, -0.5f, 1.0f);
106
+ let v_13 = (r0.xyz * r1.yyy);
107
+ o0 = vec4<f32>(v_13.xyz, o0.w);
108
+ o1.w = clamp(fma(v3.xyz.zzzz, vec4<f32>(128.0f), vec4<f32>(-127.0f)).w, 0.0f, 1.0f);
109
+ r2.z = 0.97000002861022949219f;
110
+ r3.z = cb12_12.tint_symbol_3[0u].x;
111
+ let v_14 = -(r3.xyzx);
112
+ let v_15 = (r2.xyz + v_14.xyz);
113
+ r0 = vec4<f32>(v_15.xyz, r0.w);
114
+ let v_16 = max(r0.xyz, vec3<f32>());
115
+ r0 = vec4<f32>(v_16.xyz, r0.w);
116
+ let v_17 = fma(r0.xyz, r0.www, r3.xyz);
117
+ r0 = vec4<f32>(v_17.xyz, r0.w);
118
+ let v_18 = sqrt(r0.xy);
119
+ o2 = vec4<f32>(v_18.xy, o2.zw);
120
+ o2.z = r0.z;
121
+ o2.w = 1.0f;
122
+ r1.x = fma(v1.x, cb2_2.tint_symbol[15u].z, cb3_3.tint_symbol_1[45u].w);
123
+ let v_19 = (r1.xz * vec2<f32>(0.5f));
124
+ r0 = vec4<f32>(v_19.xy, r0.zw);
125
+ let v_20 = sqrt(r0.xy);
126
+ o3 = vec4<f32>(v_20.xy, o3.zw);
127
+ o3 = vec4<f32>(o3.xy, vec2<f32>(0.0f, 1.00188386440277099609f));
128
+ }
129
+
130
+ struct tint_symbol_4 {
131
+ @location(0u)
132
+ o0 : vec4<f32>,
133
+ @location(1u)
134
+ o1 : vec4<f32>,
135
+ @location(2u)
136
+ o2 : vec4<f32>,
137
+ @location(3u)
138
+ o3 : vec4<f32>,
139
+ }
140
+
141
+ @fragment
142
+ fn main(@location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>) -> tint_symbol_4 {
143
+ main_inner(v1, v2, v3, v4);
144
+ return tint_symbol_4(o0, o1, o2, o3);
145
+ }
b/8b0b5899ed/shaders/00845f3f8756888a.wgsl ADDED
@@ -0,0 +1,89 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ struct cb4_struct {
8
+ tint_symbol : array<vec4<f32>, 4u>,
9
+ }
10
+
11
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb4_struct;
12
+
13
+ struct cb29_struct {
14
+ tint_symbol_1 : array<vec4<f32>, 29u>,
15
+ }
16
+
17
+ @group(0u) @binding(12u) var<uniform> cb12_12 : cb29_struct;
18
+
19
+ var<private> o0 : vec4<f32>;
20
+
21
+ var<private> o1 : vec4<f32>;
22
+
23
+ var<private> o2 : vec4<f32>;
24
+
25
+ var<private> o3 : vec4<f32>;
26
+
27
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v3 : vec2<f32>) {
28
+ r0.x = bitcast<f32>(select(0u, 4294967295u, !((0.0f == cb12_12.tint_symbol_1[23u].w))));
29
+ let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz);
30
+ r0 = vec4<f32>(r0.x, v.xyz);
31
+ let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.yzw);
32
+ r0 = vec4<f32>(r0.x, v_1.xyz);
33
+ let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.yzw);
34
+ r0 = vec4<f32>(r0.x, v_2.xyz);
35
+ let v_3 = fma(v0.www, cb1_1.tint_symbol[3u].xyz, r0.yzw);
36
+ r0 = vec4<f32>(r0.x, v_3.xyz);
37
+ r1 = (r0.zzzz * cb12_12.tint_symbol_1[20u]);
38
+ r1 = fma(r0.yyyy, cb12_12.tint_symbol_1[19u], r1);
39
+ r1 = fma(r0.wwww, cb12_12.tint_symbol_1[21u], r1);
40
+ r1 = (r1 + cb12_12.tint_symbol_1[22u]);
41
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (r1.z < 0.0f)));
42
+ r0.z = (0.10000000149011611938f / r1.w);
43
+ let v_4 = bitcast<u32>(r0.y);
44
+ let v_5 = r0.z;
45
+ r0.y = select(r1.z, v_5, (v_4 != 0u));
46
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (r1.w < r1.z)));
47
+ r0.w = (r1.w + -0.10000000149011611938f);
48
+ let v_6 = bitcast<u32>(r0.z);
49
+ let v_7 = r0.w;
50
+ r0.z = select(r1.z, v_7, (v_6 != 0u));
51
+ let v_8 = bitcast<u32>(r0.x);
52
+ let v_9 = r0.y;
53
+ r0.x = select(r0.z, v_9, (v_8 != 0u));
54
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (0.0f < r1.w)));
55
+ let v_10 = bitcast<u32>(r0.y);
56
+ let v_11 = r0.x;
57
+ o0.z = select(r1.z, v_11, (v_10 != 0u));
58
+ let v_12 = r1;
59
+ o0 = vec4<f32>(v_12.xy, o0.z, v_12.w);
60
+ o1 = v1;
61
+ let v_13 = fma(v3, cb12_12.tint_symbol_1[25u].zw, cb12_12.tint_symbol_1[24u].xy);
62
+ r0 = vec4<f32>(v_13.xy, r0.zw);
63
+ o2 = fma(cb12_12.tint_symbol_1[17u].xy, cb12_12.tint_symbol_1[27u].zw, r0.xy).xyxy;
64
+ let v_14 = fma(v3, cb12_12.tint_symbol_1[26u].xy, cb12_12.tint_symbol_1[24u].zw);
65
+ r0 = vec4<f32>(v_14.xy, r0.zw);
66
+ let v_15 = fma(cb12_12.tint_symbol_1[17u].zw, cb12_12.tint_symbol_1[28u].xy, r0.xy);
67
+ o3 = vec4<f32>(v_15.xy, o3.zw);
68
+ let v_16 = fma(v3, cb12_12.tint_symbol_1[26u].zw, cb12_12.tint_symbol_1[25u].xy);
69
+ r0 = vec4<f32>(v_16.xy, r0.zw);
70
+ let v_17 = fma(cb12_12.tint_symbol_1[18u].xy, cb12_12.tint_symbol_1[28u].zw, r0.xy);
71
+ o3 = vec4<f32>(o3.xy, v_17.xy);
72
+ }
73
+
74
+ struct tint_symbol_2 {
75
+ @builtin(position)
76
+ o0 : vec4<f32>,
77
+ @location(1u)
78
+ o1 : vec4<f32>,
79
+ @location(2u)
80
+ o2 : vec4<f32>,
81
+ @location(3u)
82
+ o3 : vec4<f32>,
83
+ }
84
+
85
+ @vertex
86
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(3u) v3 : vec2<f32>) -> tint_symbol_2 {
87
+ main_inner(v0, v1, v3);
88
+ return tint_symbol_2(o0, o1, o2, o3);
89
+ }
b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/008c1f8fcf3bdc1f.wgsl ADDED
@@ -0,0 +1,1213 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ var<private> r25 : vec4<f32>;
54
+
55
+ struct cb16_struct {
56
+ tint_symbol : array<vec4<f32>, 16u>,
57
+ }
58
+
59
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
60
+
61
+ struct cb23_struct {
62
+ tint_symbol_1 : array<vec4<f32>, 23u>,
63
+ }
64
+
65
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
66
+
67
+ struct cb59_struct {
68
+ tint_symbol_2 : array<vec4<f32>, 59u>,
69
+ }
70
+
71
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
72
+
73
+ struct cb8_struct {
74
+ tint_symbol_3 : array<vec4<f32>, 8u>,
75
+ }
76
+
77
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
78
+
79
+ struct cb3_struct {
80
+ tint_symbol_4 : array<vec4<f32>, 3u>,
81
+ }
82
+
83
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb3_struct;
84
+
85
+ struct cb15_struct {
86
+ tint_symbol_5 : array<vec4<f32>, 15u>,
87
+ }
88
+
89
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
90
+
91
+ @group(1u) @binding(16u) var s0 : sampler;
92
+
93
+ @group(1u) @binding(20u) var s4 : sampler;
94
+
95
+ @group(1u) @binding(21u) var s5 : sampler;
96
+
97
+ @group(1u) @binding(27u) var s11 : sampler;
98
+
99
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
100
+
101
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
102
+
103
+ @group(1u) @binding(36u) var t4 : texture_2d<f32>;
104
+
105
+ @group(1u) @binding(37u) var t5 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
108
+
109
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
110
+
111
+ var<private> v7 : vec4<f32>;
112
+
113
+ var<private> v8 : array<f32, 4u>;
114
+
115
+ var<private> o0 : vec4<f32>;
116
+
117
+ var<private> x0 : array<vec4<f32>, 4u>;
118
+
119
+ var<private> x1 : array<vec4<f32>, 1u>;
120
+
121
+ struct tint_symbol_7 {
122
+ tint_symbol_6 : array<vec4<u32>, 4u>,
123
+ }
124
+
125
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
126
+
127
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v_1 : vec4<f32>) {
128
+ var v_2 : vec4<f32> = v_1;
129
+ v_2.w = (1.0f / v_1.w);
130
+ v7 = v_2;
131
+ x1[0u].x = v8[0u];
132
+ x1[0u].y = v8[1u];
133
+ x1[0u].z = v8[2u];
134
+ x1[0u].w = v8[3u];
135
+ r0 = textureSample(t0, s0, v2.xy.xyxx.xy);
136
+ r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x);
137
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x)));
138
+ v_3((bitcast<u32>(r1.x) != 0u));
139
+ r1 = textureSample(t4, s4, v2.xy.xyxx.xy);
140
+ let v_4 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
141
+ r1 = vec4<f32>(v_4.xy, r1.zw);
142
+ r1.z = dot(r1.xy, r1.xy);
143
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
144
+ r1.z = sqrt(abs(r1.zzzz).z);
145
+ r1.w = max(cb12_12.tint_symbol_4[2u].x, 0.00100000004749745131f);
146
+ let v_5 = (r1.ww * r1.xy);
147
+ r1 = vec4<f32>(v_5.xy, r1.zw);
148
+ let v_6 = (r1.yyy * v5.xyz);
149
+ r2 = vec4<f32>(v_6.xyz, r2.w);
150
+ let v_7 = fma(r1.xxx, v4.xyz, r2.xyz);
151
+ r1 = vec4<f32>(v_7.xy, r1.z, v_7.z);
152
+ let v_8 = fma(r1.zzz, v3.xyz, r1.xyw);
153
+ r1 = vec4<f32>(v_8.xyz, r1.w);
154
+ r1.w = dot(r1.xyz, r1.xyz);
155
+ r1.w = inverseSqrt(r1.w);
156
+ let v_9 = (r1.www * r1.xyz);
157
+ r2 = vec4<f32>(v_9.xyz, r2.w);
158
+ r3 = textureSample(t5, s5, v2.xy.xyxx.xy);
159
+ let v_10 = (r3.xy * r3.xy);
160
+ r1 = vec4<f32>(v_10.xy, r1.zw);
161
+ r1.x = (r1.x * cb12_12.tint_symbol_4[0u].z);
162
+ let v_11 = (r0.xyz * v1.xyz);
163
+ r0 = vec4<f32>(v_11.xyz, r0.w);
164
+ r0.w = (r0.w * v0.w);
165
+ let v_12 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
166
+ r3 = vec4<f32>(v_12.xy, r3.zw);
167
+ let v_13 = (r0.xyz * r0.xyz);
168
+ r0 = vec4<f32>(v_13.xyz, r0.w);
169
+ let v_14 = -(v6.xyzx);
170
+ let v_15 = (v_14.xyz + cb1_1.tint_symbol[15u].xyz);
171
+ r4 = vec4<f32>(v_15.xyz, r4.w);
172
+ r2.w = dot(r4.xyz, r4.xyz);
173
+ r2.w = inverseSqrt(r2.w);
174
+ let v_16 = (r2.www * r4.xyz);
175
+ r5 = vec4<f32>(v_16.xyz, r5.w);
176
+ let v_17 = -(cb3_3.tint_symbol_2[0u].xyzx);
177
+ let v_18 = fma(r4.xyz, r2.www, v_17.xyz);
178
+ r6 = vec4<f32>(v_18.xyz, r6.w);
179
+ r3.z = dot(r6.xyz, r6.xyz);
180
+ r3.z = inverseSqrt(r3.z);
181
+ let v_19 = (r3.zzz * r6.xyz);
182
+ r6 = vec4<f32>(v_19.xyz, r6.w);
183
+ r1.x = clamp(r1.xxxx.x, 0.0f, 1.0f);
184
+ r3.z = fma(r1.y, cb12_12.tint_symbol_4[0u].y, -500.0f);
185
+ r3.z = max(r3.z, 0.0f);
186
+ let v_20 = -(r3.zzzz);
187
+ r1.y = fma(r1.y, cb12_12.tint_symbol_4[0u].y, v_20.y);
188
+ r3.z = (r3.z * 558.0f);
189
+ r1.y = fma(r1.y, 3.0f, r3.z);
190
+ r3.z = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz);
191
+ let v_21 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
192
+ r7 = vec4<f32>(v_21.xyz, r7.w);
193
+ let v_22 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz);
194
+ r8 = vec4<f32>(v_22.xyz, r8.w);
195
+ let v_23 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz);
196
+ r8 = vec4<f32>(v_23.xyz, r8.w);
197
+ let v_24 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz);
198
+ r8 = vec4<f32>(v_24.xyz, r8.w);
199
+ let v_25 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
200
+ r9 = vec4<f32>(v_25.xyz, r9.w);
201
+ let v_26 = &(x0[0u]);
202
+ let v_27 = r9;
203
+ *(v_26) = vec4<f32>(v_27.xyz, (*(v_26)).w);
204
+ let v_28 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
205
+ r10 = vec4<f32>(v_28.xyz, r10.w);
206
+ let v_29 = &(x0[1u]);
207
+ let v_30 = r10;
208
+ *(v_29) = vec4<f32>(v_30.xyz, (*(v_29)).w);
209
+ let v_31 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
210
+ r11 = vec4<f32>(v_31.xyz, r11.w);
211
+ let v_32 = &(x0[2u]);
212
+ let v_33 = r11;
213
+ *(v_32) = vec4<f32>(v_33.xyz, (*(v_32)).w);
214
+ let v_34 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
215
+ r8 = vec4<f32>(v_34.xyz, r8.w);
216
+ let v_35 = &(x0[3u]);
217
+ let v_36 = r8;
218
+ *(v_35) = vec4<f32>(v_36.xyz, (*(v_35)).w);
219
+ let v_37 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
220
+ let v_38 = r12;
221
+ r12 = vec4<f32>(v_38.x, v_37.x, v_38.z, v_37.y);
222
+ r3.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
223
+ r3.w = (r3.w * 0.5f);
224
+ let v_39 = abs(r11.yyyy);
225
+ r4.w = max(v_39.w, abs(r11.xxxx).w);
226
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (r4.w < r3.w)));
227
+ let v_40 = (bitcast<u32>(r4.w) != 0u);
228
+ let v_41 = bitcast<f32>(v.tint_symbol_6[0i].x);
229
+ r4.w = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_41, v_40);
230
+ let v_42 = abs(r10.yyyy);
231
+ r5.w = max(v_42.w, abs(r10.xxxx).w);
232
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (r5.w < r3.w)));
233
+ let v_43 = bitcast<u32>(r5.w);
234
+ r4.w = select(r4.w, bitcast<f32>(v.tint_symbol_6[2i].x), (v_43 != 0u));
235
+ let v_44 = abs(r9.yyyy);
236
+ r5.w = max(v_44.w, abs(r9.xxxx).w);
237
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r5.w < r3.w)));
238
+ let v_45 = bitcast<u32>(r3.w);
239
+ r3.w = select(r4.w, 0.0f, (v_45 != 0u));
240
+ let v_46 = x0[bitcast<i32>(r3.w)];
241
+ r9 = vec4<f32>(v_46.xyz, r9.w);
242
+ r3.w = f32(bitcast<i32>(r3.w));
243
+ r4.w = (r3.w + 0.5f);
244
+ r4.w = (r4.w * 0.25f);
245
+ r10 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r3.wwww)));
246
+ r10 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r10) & vec4<u32>(1065353216u)));
247
+ r3.w = dot(r10, cb6_6.tint_symbol_5[12u]);
248
+ r5.w = dot(r10, cb6_6.tint_symbol_5[13u]);
249
+ r10.x = (r9.x + 0.5f);
250
+ r10.y = fma(r9.y, 0.25f, r4.w);
251
+ r4.w = bitcast<f32>(select(0u, 4294967295u, !((r3.w == 0.0f))));
252
+ r3.w = ((-(r3.wwww)).w + r9.z);
253
+ let v_47 = dpdx(r10.xyy);
254
+ r11 = vec4<f32>(v_47.xy, r11.z, v_47.z);
255
+ r11.z = dpdx(r3.w);
256
+ let v_48 = dpdy(r10.yxy);
257
+ r13 = vec4<f32>(v_48.xyz, r13.w);
258
+ r13.w = dpdy(r3.w);
259
+ let v_49 = (r11.yw * r13.yw);
260
+ r8 = vec4<f32>(r8.xy, v_49.xy);
261
+ let v_50 = -(r8.zwzz);
262
+ let v_51 = fma(r11.xz, r13.xz, v_50.xy);
263
+ r14 = vec4<f32>(v_51.xy, r14.zw);
264
+ r6.w = (1.0f / r14.x);
265
+ r7.w = (r11.z * r13.y);
266
+ let v_52 = -(r7.wwww);
267
+ r14.z = fma(r11.x, r13.w, v_52.z);
268
+ let v_53 = (r6.ww * r14.yz);
269
+ r8 = vec4<f32>(r8.xy, v_53.xy);
270
+ let v_54 = max(r8.zw, vec2<f32>());
271
+ r8 = vec4<f32>(r8.xy, v_54.xy);
272
+ let v_55 = min(r8.zw, vec2<f32>(0.5f));
273
+ r8 = vec4<f32>(r8.xy, v_55.xy);
274
+ r3.w = fma((-(r5.wwww)).w, r8.z, r3.w);
275
+ r3.w = fma((-(r5.wwww)).w, r8.w, r3.w);
276
+ let v_56 = bitcast<u32>(r4.w);
277
+ let v_57 = r3.w;
278
+ r12.z = select(r9.z, v_57, (v_56 != 0u));
279
+ r10.z = 0.0f;
280
+ let v_58 = (r10.xyz + r12.ywz);
281
+ r9 = vec4<f32>(v_58.xyz, r9.w);
282
+ let v_59 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
283
+ r12 = vec4<f32>(v_59.xy, r12.zw);
284
+ let v_60 = (r10.xyz + r12.xyz);
285
+ r11 = vec4<f32>(v_60.xyz, r11.w);
286
+ let v_61 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
287
+ r12 = vec4<f32>(v_61.xy, r12.zw);
288
+ let v_62 = (r10.xyz + r12.xyz);
289
+ r13 = vec4<f32>(v_62.xyz, r13.w);
290
+ let v_63 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
291
+ r12 = vec4<f32>(v_63.xy, r12.zw);
292
+ let v_64 = (r10.xyz + r12.xyz);
293
+ r14 = vec4<f32>(v_64.xyz, r14.w);
294
+ let v_65 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
295
+ r12 = vec4<f32>(v_65.xy, r12.zw);
296
+ let v_66 = (r10.xyz + r12.xyz);
297
+ r15 = vec4<f32>(v_66.xyz, r15.w);
298
+ let v_67 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
299
+ r12 = vec4<f32>(v_67.xy, r12.zw);
300
+ let v_68 = (r10.xyz + r12.xyz);
301
+ r16 = vec4<f32>(v_68.xyz, r16.w);
302
+ let v_69 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
303
+ r12 = vec4<f32>(v_69.xy, r12.zw);
304
+ let v_70 = (r10.xyz + r12.xyz);
305
+ r17 = vec4<f32>(v_70.xyz, r17.w);
306
+ let v_71 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
307
+ r12 = vec4<f32>(v_71.xy, r12.zw);
308
+ let v_72 = (r10.xyz + r12.xyz);
309
+ r18 = vec4<f32>(v_72.xyz, r18.w);
310
+ let v_73 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
311
+ r12 = vec4<f32>(v_73.xy, r12.zw);
312
+ let v_74 = (r10.xyz + r12.xyz);
313
+ r19 = vec4<f32>(v_74.xyz, r19.w);
314
+ let v_75 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
315
+ r12 = vec4<f32>(v_75.xy, r12.zw);
316
+ let v_76 = (r10.xyz + r12.xyz);
317
+ r20 = vec4<f32>(v_76.xyz, r20.w);
318
+ let v_77 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
319
+ r12 = vec4<f32>(v_77.xy, r12.zw);
320
+ let v_78 = (r10.xyz + r12.xyz);
321
+ r21 = vec4<f32>(v_78.xyz, r21.w);
322
+ let v_79 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
323
+ r12 = vec4<f32>(v_79.xy, r12.zw);
324
+ let v_80 = (r10.xyz + r12.xyz);
325
+ r22 = vec4<f32>(v_80.xyz, r22.w);
326
+ let v_81 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
327
+ r12 = vec4<f32>(v_81.xy, r12.zw);
328
+ let v_82 = (r10.xyz + r12.xyz);
329
+ r23 = vec4<f32>(v_82.xyz, r23.w);
330
+ let v_83 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
331
+ r12 = vec4<f32>(v_83.xy, r12.zw);
332
+ let v_84 = (r10.xyz + r12.xyz);
333
+ r24 = vec4<f32>(v_84.xyz, r24.w);
334
+ let v_85 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
335
+ r12 = vec4<f32>(v_85.xy, r12.zw);
336
+ let v_86 = (r10.xyz + r12.xyz);
337
+ r25 = vec4<f32>(v_86.xyz, r25.w);
338
+ let v_87 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
339
+ r12 = vec4<f32>(v_87.xy, r12.zw);
340
+ let v_88 = (r10.xyz + r12.xyz);
341
+ r10 = vec4<f32>(v_88.xyz, r10.w);
342
+ let v_89 = r9.xyxx;
343
+ r9.x = textureSampleCompareLevel(t15, s15, v_89.xy, r9.z);
344
+ let v_90 = r11.xyxx;
345
+ r9.y = textureSampleCompareLevel(t15, s15, v_90.xy, r11.z);
346
+ let v_91 = r13.xyxx;
347
+ r9.z = textureSampleCompareLevel(t15, s15, v_91.xy, r13.z);
348
+ let v_92 = r14.xyxx;
349
+ r9.w = textureSampleCompareLevel(t15, s15, v_92.xy, r14.z);
350
+ let v_93 = r15.xyxx;
351
+ r11.x = textureSampleCompareLevel(t15, s15, v_93.xy, r15.z);
352
+ let v_94 = r16.xyxx;
353
+ r11.y = textureSampleCompareLevel(t15, s15, v_94.xy, r16.z);
354
+ let v_95 = r17.xyxx;
355
+ r11.z = textureSampleCompareLevel(t15, s15, v_95.xy, r17.z);
356
+ let v_96 = r18.xyxx;
357
+ r11.w = textureSampleCompareLevel(t15, s15, v_96.xy, r18.z);
358
+ let v_97 = r19.xyxx;
359
+ r12.x = textureSampleCompareLevel(t15, s15, v_97.xy, r19.z);
360
+ let v_98 = r20.xyxx;
361
+ r12.y = textureSampleCompareLevel(t15, s15, v_98.xy, r20.z);
362
+ let v_99 = r21.xyxx;
363
+ r12.z = textureSampleCompareLevel(t15, s15, v_99.xy, r21.z);
364
+ let v_100 = r22.xyxx;
365
+ r12.w = textureSampleCompareLevel(t15, s15, v_100.xy, r22.z);
366
+ let v_101 = r23.xyxx;
367
+ r13.x = textureSampleCompareLevel(t15, s15, v_101.xy, r23.z);
368
+ let v_102 = r24.xyxx;
369
+ r13.y = textureSampleCompareLevel(t15, s15, v_102.xy, r24.z);
370
+ let v_103 = r25.xyxx;
371
+ r13.z = textureSampleCompareLevel(t15, s15, v_103.xy, r25.z);
372
+ let v_104 = r10.xyxx;
373
+ r13.w = textureSampleCompareLevel(t15, s15, v_104.xy, r10.z);
374
+ r9 = (r9 + r11);
375
+ r9 = (r12 + r9);
376
+ r9 = (r13 + r9);
377
+ r3.w = dot(r9, vec4<f32>(1.0f));
378
+ r3.z = clamp(fma(r3.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f);
379
+ let v_105 = abs(r8.yyyy);
380
+ r4.w = max(v_105.w, abs(r8.xxxx).w);
381
+ r4.w = clamp(fma(r4.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
382
+ r3.z = ((-(r3.zzzz)).z + 1.0f);
383
+ r3.z = (r4.w * r3.z);
384
+ r3.z = fma(r3.w, 0.0625f, r3.z);
385
+ let v_106 = (r3.xyz * r3.xyz);
386
+ r3 = vec4<f32>(v_106.xyz, r3.w);
387
+ r3.z = min(r3.z, 1.0f);
388
+ r3.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
389
+ r3.w = sqrt(r3.w);
390
+ r3.w = (r3.w * cb6_6.tint_symbol_5[3u].z);
391
+ let v_107 = -(r3.zzzz);
392
+ r3.z = fma(r3.w, v_107.z, r3.z);
393
+ let v_108 = dot(r2.xyz, v_17.xyz);
394
+ r3.w = clamp(vec4<f32>(v_108, v_108, v_108, v_108).w, 0.0f, 1.0f);
395
+ let v_109 = dot(r5.xyz, r2.xyz);
396
+ r8.x = clamp(vec4<f32>(v_109, v_109, v_109, v_109).x, 0.0f, 1.0f);
397
+ let v_110 = dot(r6.xyz, v_17.xyz);
398
+ r8.y = clamp(vec4<f32>(v_110, v_110, v_110, v_110).y, 0.0f, 1.0f);
399
+ let v_111 = ((-(r8.xyxx)).xy + vec2<f32>(1.0f));
400
+ r8 = vec4<f32>(v_111.xy, r8.zw);
401
+ let v_112 = (r8.xy * r8.xy);
402
+ r8 = vec4<f32>(r8.xy, v_112.xy);
403
+ let v_113 = (r8.zw * r8.zw);
404
+ r8 = vec4<f32>(r8.xy, v_113.xy);
405
+ let v_114 = (r8.xy * r8.zw);
406
+ r8 = vec4<f32>(v_114.xy, r8.zw);
407
+ r4.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f);
408
+ let v_115 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r4.ww);
409
+ r8 = vec4<f32>(v_115.xy, r8.zw);
410
+ let v_116 = (r1.yy + vec2<f32>(2.0f, 0.00000000999999993923f));
411
+ r8 = vec4<f32>(r8.xy, v_116.xy);
412
+ r1.y = (r8.z * 0.125f);
413
+ r5.w = fma((-(r1.xxxx)).w, r8.x, 1.0f);
414
+ r6.x = dot(r2.xyz, r6.xyz);
415
+ r6.x = clamp(((r6.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
416
+ r6.x = log2(r6.x);
417
+ r6.x = (r6.x * r8.w);
418
+ r6.x = exp2(r6.x);
419
+ r6.x = (r8.y * r6.x);
420
+ r6.x = (r1.y * r6.x);
421
+ r6.x = (r1.x * r6.x);
422
+ r6.x = (r3.w * r6.x);
423
+ r3.w = (r3.w * r5.w);
424
+ let v_117 = fma(r0.xyz, r3.www, r6.xxx);
425
+ r6 = vec4<f32>(v_117.xyz, r6.w);
426
+ let v_118 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz);
427
+ r6 = vec4<f32>(v_118.xyz, r6.w);
428
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
429
+ if ((bitcast<u32>(r3.w) != 0u)) {
430
+ r9 = vec4<f32>(vec3<f32>(), r9.w);
431
+ r8 = vec4<f32>(vec3<f32>(), r8.w);
432
+ } else {
433
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
434
+ let v_119 = (v_14.xyz + cb3_3.tint_symbol_2[3u].xyz);
435
+ r8 = vec4<f32>(v_119.xyz, r8.w);
436
+ let v_120 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
437
+ r9 = vec4<f32>(v_120.xyz, r9.w);
438
+ r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz);
439
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
440
+ r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w);
441
+ let v_121 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz);
442
+ r9 = vec4<f32>(v_121.xyz, r9.w);
443
+ let v_122 = (r9.xyz + v_14.xyz);
444
+ r9 = vec4<f32>(v_122.xyz, r9.w);
445
+ let v_123 = bitcast<vec3<u32>>(r6.www);
446
+ let v_124 = r8.xyz;
447
+ let v_125 = select(r9.xyz, v_124, (v_123 != vec3<u32>()));
448
+ r8 = vec4<f32>(v_125.xyz, r8.w);
449
+ r6.w = dot(r8.xyz, r8.xyz);
450
+ let v_126 = (r8.xyz + vec3<f32>(0.00000099999999747524f));
451
+ r8 = vec4<f32>(v_126.xyz, r8.w);
452
+ r7.w = dot(r8.xyz, r8.xyz);
453
+ r7.w = inverseSqrt(r7.w);
454
+ let v_127 = (r7.www * r8.xyz);
455
+ r8 = vec4<f32>(v_127.xyz, r8.w);
456
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
457
+ r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
458
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w);
459
+ r6.w = (r6.w / r7.w);
460
+ let v_128 = -(cb3_3.tint_symbol_2[11u].xyzx);
461
+ r7.w = dot(r8.xyz, v_128.xyz);
462
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
463
+ let v_129 = dot(r8.xyz, r2.xyz);
464
+ r9.x = clamp(vec4<f32>(v_129, v_129, v_129, v_129).x, 0.0f, 1.0f);
465
+ r7.w = (r7.w * r9.x);
466
+ r9.x = (r6.w * r7.w);
467
+ let v_130 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz);
468
+ r9 = vec4<f32>(v_130.xyz, r9.w);
469
+ let v_131 = (r0.xyz * r9.xyz);
470
+ r9 = vec4<f32>(v_131.xyz, r9.w);
471
+ let v_132 = fma(r4.xyz, r2.www, r8.xyz);
472
+ r8 = vec4<f32>(v_132.xyz, r8.w);
473
+ r9.w = dot(r8.xyz, r8.xyz);
474
+ r9.w = inverseSqrt(r9.w);
475
+ let v_133 = (r8.xyz * r9.www);
476
+ r8 = vec4<f32>(v_133.xyz, r8.w);
477
+ let v_134 = dot(r8.xyz, r5.xyz);
478
+ r9.w = clamp(vec4<f32>(v_134, v_134, v_134, v_134).w, 0.0f, 1.0f);
479
+ r9.w = ((-(r9.wwww)).w + 1.0f);
480
+ r10.x = (r9.w * r9.w);
481
+ r10.x = (r10.x * r10.x);
482
+ r9.w = (r9.w * r10.x);
483
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
484
+ let v_135 = dot(r8.xyz, r2.xyz);
485
+ r8.x = clamp(vec4<f32>(v_135, v_135, v_135, v_135).x, 0.0f, 1.0f);
486
+ r8.x = log2(r8.x);
487
+ r8.x = (r8.x * r8.w);
488
+ r8.x = exp2(r8.x);
489
+ r8.x = (r8.x * r9.w);
490
+ r7.w = (r7.w * r8.x);
491
+ r6.w = (r6.w * r7.w);
492
+ r6.w = (r1.y * r6.w);
493
+ let v_136 = (r6.www * cb3_3.tint_symbol_2[19u].xyz);
494
+ r8 = vec4<f32>(v_136.xyz, r8.w);
495
+ }
496
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
497
+ if ((bitcast<u32>(r6.w) != 0u)) {
498
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
499
+ r6.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
500
+ let v_137 = bitcast<u32>(r7.w);
501
+ let v_138 = r6.w;
502
+ r3.w = select(r3.w, v_138, (v_137 != 0u));
503
+ if ((bitcast<u32>(r3.w) != 0u)) {
504
+ } else {
505
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
506
+ let v_139 = (v_14.xyz + cb3_3.tint_symbol_2[4u].xyz);
507
+ r10 = vec4<f32>(v_139.xyz, r10.w);
508
+ let v_140 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
509
+ r11 = vec4<f32>(v_140.xyz, r11.w);
510
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz);
511
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
512
+ r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w);
513
+ let v_141 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz);
514
+ r11 = vec4<f32>(v_141.xyz, r11.w);
515
+ let v_142 = (r11.xyz + v_14.xyz);
516
+ r11 = vec4<f32>(v_142.xyz, r11.w);
517
+ let v_143 = bitcast<vec3<u32>>(r6.www);
518
+ let v_144 = r10.xyz;
519
+ let v_145 = select(r11.xyz, v_144, (v_143 != vec3<u32>()));
520
+ r10 = vec4<f32>(v_145.xyz, r10.w);
521
+ r6.w = dot(r10.xyz, r10.xyz);
522
+ let v_146 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
523
+ r10 = vec4<f32>(v_146.xyz, r10.w);
524
+ r7.w = dot(r10.xyz, r10.xyz);
525
+ r7.w = inverseSqrt(r7.w);
526
+ let v_147 = (r7.www * r10.xyz);
527
+ r10 = vec4<f32>(v_147.xyz, r10.w);
528
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
529
+ r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
530
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w);
531
+ r6.w = (r6.w / r7.w);
532
+ let v_148 = -(cb3_3.tint_symbol_2[12u].xyzx);
533
+ r7.w = dot(r10.xyz, v_148.xyz);
534
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
535
+ let v_149 = dot(r10.xyz, r2.xyz);
536
+ r9.w = clamp(vec4<f32>(v_149, v_149, v_149, v_149).w, 0.0f, 1.0f);
537
+ r7.w = (r7.w * r9.w);
538
+ r9.w = (r6.w * r7.w);
539
+ let v_150 = (r9.www * cb3_3.tint_symbol_2[20u].xyz);
540
+ r11 = vec4<f32>(v_150.xyz, r11.w);
541
+ let v_151 = fma(r11.xyz, r0.xyz, r9.xyz);
542
+ r9 = vec4<f32>(v_151.xyz, r9.w);
543
+ let v_152 = fma(r4.xyz, r2.www, r10.xyz);
544
+ r10 = vec4<f32>(v_152.xyz, r10.w);
545
+ r9.w = dot(r10.xyz, r10.xyz);
546
+ r9.w = inverseSqrt(r9.w);
547
+ let v_153 = (r9.www * r10.xyz);
548
+ r10 = vec4<f32>(v_153.xyz, r10.w);
549
+ let v_154 = dot(r10.xyz, r5.xyz);
550
+ r9.w = clamp(vec4<f32>(v_154, v_154, v_154, v_154).w, 0.0f, 1.0f);
551
+ r9.w = ((-(r9.wwww)).w + 1.0f);
552
+ r10.w = (r9.w * r9.w);
553
+ r10.w = (r10.w * r10.w);
554
+ r9.w = (r9.w * r10.w);
555
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
556
+ let v_155 = dot(r10.xyz, r2.xyz);
557
+ r10.x = clamp(vec4<f32>(v_155, v_155, v_155, v_155).x, 0.0f, 1.0f);
558
+ r10.x = log2(r10.x);
559
+ r10.x = (r8.w * r10.x);
560
+ r10.x = exp2(r10.x);
561
+ r9.w = (r9.w * r10.x);
562
+ r7.w = (r7.w * r9.w);
563
+ r6.w = (r6.w * r7.w);
564
+ r6.w = (r1.y * r6.w);
565
+ let v_156 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xyz);
566
+ r8 = vec4<f32>(v_156.xyz, r8.w);
567
+ }
568
+ } else {
569
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
570
+ }
571
+ if ((bitcast<u32>(r3.w) != 0u)) {
572
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
573
+ } else {
574
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
575
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
576
+ if ((bitcast<u32>(r3.w) != 0u)) {
577
+ } else {
578
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
579
+ let v_157 = (v_14.xyz + cb3_3.tint_symbol_2[5u].xyz);
580
+ r10 = vec4<f32>(v_157.xyz, r10.w);
581
+ let v_158 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
582
+ r11 = vec4<f32>(v_158.xyz, r11.w);
583
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz);
584
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
585
+ r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w);
586
+ let v_159 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz);
587
+ r11 = vec4<f32>(v_159.xyz, r11.w);
588
+ let v_160 = (r11.xyz + v_14.xyz);
589
+ r11 = vec4<f32>(v_160.xyz, r11.w);
590
+ let v_161 = bitcast<vec3<u32>>(r6.www);
591
+ let v_162 = r10.xyz;
592
+ let v_163 = select(r11.xyz, v_162, (v_161 != vec3<u32>()));
593
+ r10 = vec4<f32>(v_163.xyz, r10.w);
594
+ r6.w = dot(r10.xyz, r10.xyz);
595
+ let v_164 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
596
+ r10 = vec4<f32>(v_164.xyz, r10.w);
597
+ r7.w = dot(r10.xyz, r10.xyz);
598
+ r7.w = inverseSqrt(r7.w);
599
+ let v_165 = (r7.www * r10.xyz);
600
+ r10 = vec4<f32>(v_165.xyz, r10.w);
601
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
602
+ r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
603
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w);
604
+ r6.w = (r6.w / r7.w);
605
+ let v_166 = -(cb3_3.tint_symbol_2[13u].xyzx);
606
+ r7.w = dot(r10.xyz, v_166.xyz);
607
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
608
+ let v_167 = dot(r10.xyz, r2.xyz);
609
+ r9.w = clamp(vec4<f32>(v_167, v_167, v_167, v_167).w, 0.0f, 1.0f);
610
+ r7.w = (r7.w * r9.w);
611
+ r9.w = (r6.w * r7.w);
612
+ let v_168 = (r9.www * cb3_3.tint_symbol_2[21u].xyz);
613
+ r11 = vec4<f32>(v_168.xyz, r11.w);
614
+ let v_169 = fma(r11.xyz, r0.xyz, r9.xyz);
615
+ r9 = vec4<f32>(v_169.xyz, r9.w);
616
+ let v_170 = fma(r4.xyz, r2.www, r10.xyz);
617
+ r10 = vec4<f32>(v_170.xyz, r10.w);
618
+ r9.w = dot(r10.xyz, r10.xyz);
619
+ r9.w = inverseSqrt(r9.w);
620
+ let v_171 = (r9.www * r10.xyz);
621
+ r10 = vec4<f32>(v_171.xyz, r10.w);
622
+ let v_172 = dot(r10.xyz, r5.xyz);
623
+ r9.w = clamp(vec4<f32>(v_172, v_172, v_172, v_172).w, 0.0f, 1.0f);
624
+ r9.w = ((-(r9.wwww)).w + 1.0f);
625
+ r10.w = (r9.w * r9.w);
626
+ r10.w = (r10.w * r10.w);
627
+ r9.w = (r9.w * r10.w);
628
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
629
+ let v_173 = dot(r10.xyz, r2.xyz);
630
+ r10.x = clamp(vec4<f32>(v_173, v_173, v_173, v_173).x, 0.0f, 1.0f);
631
+ r10.x = log2(r10.x);
632
+ r10.x = (r8.w * r10.x);
633
+ r10.x = exp2(r10.x);
634
+ r9.w = (r9.w * r10.x);
635
+ r7.w = (r7.w * r9.w);
636
+ r6.w = (r6.w * r7.w);
637
+ r6.w = (r1.y * r6.w);
638
+ let v_174 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xyz);
639
+ r8 = vec4<f32>(v_174.xyz, r8.w);
640
+ }
641
+ }
642
+ if ((bitcast<u32>(r3.w) != 0u)) {
643
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
644
+ } else {
645
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
646
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
647
+ if ((bitcast<u32>(r3.w) != 0u)) {
648
+ } else {
649
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
650
+ let v_175 = (v_14.xyz + cb3_3.tint_symbol_2[6u].xyz);
651
+ r10 = vec4<f32>(v_175.xyz, r10.w);
652
+ let v_176 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
653
+ r11 = vec4<f32>(v_176.xyz, r11.w);
654
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz);
655
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
656
+ r7.w = (r7.w * cb3_3.tint_symbol_2[22u].w);
657
+ let v_177 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.www, cb3_3.tint_symbol_2[6u].xyz);
658
+ r11 = vec4<f32>(v_177.xyz, r11.w);
659
+ let v_178 = (r11.xyz + v_14.xyz);
660
+ r11 = vec4<f32>(v_178.xyz, r11.w);
661
+ let v_179 = bitcast<vec3<u32>>(r6.www);
662
+ let v_180 = r10.xyz;
663
+ let v_181 = select(r11.xyz, v_180, (v_179 != vec3<u32>()));
664
+ r10 = vec4<f32>(v_181.xyz, r10.w);
665
+ r6.w = dot(r10.xyz, r10.xyz);
666
+ let v_182 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
667
+ r10 = vec4<f32>(v_182.xyz, r10.w);
668
+ r7.w = dot(r10.xyz, r10.xyz);
669
+ r7.w = inverseSqrt(r7.w);
670
+ let v_183 = (r7.www * r10.xyz);
671
+ r10 = vec4<f32>(v_183.xyz, r10.w);
672
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
673
+ r7.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
674
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[14u].w);
675
+ r6.w = (r6.w / r7.w);
676
+ let v_184 = -(cb3_3.tint_symbol_2[14u].xyzx);
677
+ r7.w = dot(r10.xyz, v_184.xyz);
678
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
679
+ let v_185 = dot(r10.xyz, r2.xyz);
680
+ r9.w = clamp(vec4<f32>(v_185, v_185, v_185, v_185).w, 0.0f, 1.0f);
681
+ r7.w = (r7.w * r9.w);
682
+ r9.w = (r6.w * r7.w);
683
+ let v_186 = (r9.www * cb3_3.tint_symbol_2[22u].xyz);
684
+ r11 = vec4<f32>(v_186.xyz, r11.w);
685
+ let v_187 = fma(r11.xyz, r0.xyz, r9.xyz);
686
+ r9 = vec4<f32>(v_187.xyz, r9.w);
687
+ let v_188 = fma(r4.xyz, r2.www, r10.xyz);
688
+ r10 = vec4<f32>(v_188.xyz, r10.w);
689
+ r9.w = dot(r10.xyz, r10.xyz);
690
+ r9.w = inverseSqrt(r9.w);
691
+ let v_189 = (r9.www * r10.xyz);
692
+ r10 = vec4<f32>(v_189.xyz, r10.w);
693
+ let v_190 = dot(r10.xyz, r5.xyz);
694
+ r9.w = clamp(vec4<f32>(v_190, v_190, v_190, v_190).w, 0.0f, 1.0f);
695
+ r9.w = ((-(r9.wwww)).w + 1.0f);
696
+ r10.w = (r9.w * r9.w);
697
+ r10.w = (r10.w * r10.w);
698
+ r9.w = (r9.w * r10.w);
699
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
700
+ let v_191 = dot(r10.xyz, r2.xyz);
701
+ r10.x = clamp(vec4<f32>(v_191, v_191, v_191, v_191).x, 0.0f, 1.0f);
702
+ r10.x = log2(r10.x);
703
+ r10.x = (r8.w * r10.x);
704
+ r10.x = exp2(r10.x);
705
+ r9.w = (r9.w * r10.x);
706
+ r7.w = (r7.w * r9.w);
707
+ r6.w = (r6.w * r7.w);
708
+ r6.w = (r1.y * r6.w);
709
+ let v_192 = fma(r6.www, cb3_3.tint_symbol_2[22u].xyz, r8.xyz);
710
+ r8 = vec4<f32>(v_192.xyz, r8.w);
711
+ }
712
+ }
713
+ if ((bitcast<u32>(r3.w) != 0u)) {
714
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
715
+ } else {
716
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (4i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
717
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
718
+ if ((bitcast<u32>(r3.w) != 0u)) {
719
+ } else {
720
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f)));
721
+ let v_193 = (v_14.xyz + cb3_3.tint_symbol_2[7u].xyz);
722
+ r10 = vec4<f32>(v_193.xyz, r10.w);
723
+ let v_194 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz);
724
+ r11 = vec4<f32>(v_194.xyz, r11.w);
725
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[15u].xyz);
726
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f);
727
+ r7.w = (r7.w * cb3_3.tint_symbol_2[23u].w);
728
+ let v_195 = fma(cb3_3.tint_symbol_2[15u].xyz, r7.www, cb3_3.tint_symbol_2[7u].xyz);
729
+ r11 = vec4<f32>(v_195.xyz, r11.w);
730
+ let v_196 = (r11.xyz + v_14.xyz);
731
+ r11 = vec4<f32>(v_196.xyz, r11.w);
732
+ let v_197 = bitcast<vec3<u32>>(r6.www);
733
+ let v_198 = r10.xyz;
734
+ let v_199 = select(r11.xyz, v_198, (v_197 != vec3<u32>()));
735
+ r10 = vec4<f32>(v_199.xyz, r10.w);
736
+ r6.w = dot(r10.xyz, r10.xyz);
737
+ let v_200 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
738
+ r10 = vec4<f32>(v_200.xyz, r10.w);
739
+ r7.w = dot(r10.xyz, r10.xyz);
740
+ r7.w = inverseSqrt(r7.w);
741
+ let v_201 = (r7.www * r10.xyz);
742
+ r10 = vec4<f32>(v_201.xyz, r10.w);
743
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[7u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
744
+ r7.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f);
745
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[15u].w);
746
+ r6.w = (r6.w / r7.w);
747
+ let v_202 = -(cb3_3.tint_symbol_2[15u].xyzx);
748
+ r7.w = dot(r10.xyz, v_202.xyz);
749
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f);
750
+ let v_203 = dot(r10.xyz, r2.xyz);
751
+ r9.w = clamp(vec4<f32>(v_203, v_203, v_203, v_203).w, 0.0f, 1.0f);
752
+ r7.w = (r7.w * r9.w);
753
+ r9.w = (r6.w * r7.w);
754
+ let v_204 = (r9.www * cb3_3.tint_symbol_2[23u].xyz);
755
+ r11 = vec4<f32>(v_204.xyz, r11.w);
756
+ let v_205 = fma(r11.xyz, r0.xyz, r9.xyz);
757
+ r9 = vec4<f32>(v_205.xyz, r9.w);
758
+ let v_206 = fma(r4.xyz, r2.www, r10.xyz);
759
+ r10 = vec4<f32>(v_206.xyz, r10.w);
760
+ r9.w = dot(r10.xyz, r10.xyz);
761
+ r9.w = inverseSqrt(r9.w);
762
+ let v_207 = (r9.www * r10.xyz);
763
+ r10 = vec4<f32>(v_207.xyz, r10.w);
764
+ let v_208 = dot(r10.xyz, r5.xyz);
765
+ r9.w = clamp(vec4<f32>(v_208, v_208, v_208, v_208).w, 0.0f, 1.0f);
766
+ r9.w = ((-(r9.wwww)).w + 1.0f);
767
+ r10.w = (r9.w * r9.w);
768
+ r10.w = (r10.w * r10.w);
769
+ r9.w = (r9.w * r10.w);
770
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
771
+ let v_209 = dot(r10.xyz, r2.xyz);
772
+ r10.x = clamp(vec4<f32>(v_209, v_209, v_209, v_209).x, 0.0f, 1.0f);
773
+ r10.x = log2(r10.x);
774
+ r10.x = (r8.w * r10.x);
775
+ r10.x = exp2(r10.x);
776
+ r9.w = (r9.w * r10.x);
777
+ r7.w = (r7.w * r9.w);
778
+ r6.w = (r6.w * r7.w);
779
+ r6.w = (r1.y * r6.w);
780
+ let v_210 = fma(r6.www, cb3_3.tint_symbol_2[23u].xyz, r8.xyz);
781
+ r8 = vec4<f32>(v_210.xyz, r8.w);
782
+ }
783
+ }
784
+ if ((bitcast<u32>(r3.w) != 0u)) {
785
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
786
+ } else {
787
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (5i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
788
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
789
+ if ((bitcast<u32>(r3.w) != 0u)) {
790
+ } else {
791
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f)));
792
+ let v_211 = (v_14.xyz + cb3_3.tint_symbol_2[8u].xyz);
793
+ r10 = vec4<f32>(v_211.xyz, r10.w);
794
+ let v_212 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz);
795
+ r11 = vec4<f32>(v_212.xyz, r11.w);
796
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[16u].xyz);
797
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f);
798
+ r7.w = (r7.w * cb3_3.tint_symbol_2[24u].w);
799
+ let v_213 = fma(cb3_3.tint_symbol_2[16u].xyz, r7.www, cb3_3.tint_symbol_2[8u].xyz);
800
+ r11 = vec4<f32>(v_213.xyz, r11.w);
801
+ let v_214 = (r11.xyz + v_14.xyz);
802
+ r11 = vec4<f32>(v_214.xyz, r11.w);
803
+ let v_215 = bitcast<vec3<u32>>(r6.www);
804
+ let v_216 = r10.xyz;
805
+ let v_217 = select(r11.xyz, v_216, (v_215 != vec3<u32>()));
806
+ r10 = vec4<f32>(v_217.xyz, r10.w);
807
+ r6.w = dot(r10.xyz, r10.xyz);
808
+ let v_218 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
809
+ r10 = vec4<f32>(v_218.xyz, r10.w);
810
+ r7.w = dot(r10.xyz, r10.xyz);
811
+ r7.w = inverseSqrt(r7.w);
812
+ let v_219 = (r7.www * r10.xyz);
813
+ r10 = vec4<f32>(v_219.xyz, r10.w);
814
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[8u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
815
+ r7.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f);
816
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[16u].w);
817
+ r6.w = (r6.w / r7.w);
818
+ let v_220 = -(cb3_3.tint_symbol_2[16u].xyzx);
819
+ r7.w = dot(r10.xyz, v_220.xyz);
820
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f);
821
+ let v_221 = dot(r10.xyz, r2.xyz);
822
+ r9.w = clamp(vec4<f32>(v_221, v_221, v_221, v_221).w, 0.0f, 1.0f);
823
+ r7.w = (r7.w * r9.w);
824
+ r9.w = (r6.w * r7.w);
825
+ let v_222 = (r9.www * cb3_3.tint_symbol_2[24u].xyz);
826
+ r11 = vec4<f32>(v_222.xyz, r11.w);
827
+ let v_223 = fma(r11.xyz, r0.xyz, r9.xyz);
828
+ r9 = vec4<f32>(v_223.xyz, r9.w);
829
+ let v_224 = fma(r4.xyz, r2.www, r10.xyz);
830
+ r10 = vec4<f32>(v_224.xyz, r10.w);
831
+ r9.w = dot(r10.xyz, r10.xyz);
832
+ r9.w = inverseSqrt(r9.w);
833
+ let v_225 = (r9.www * r10.xyz);
834
+ r10 = vec4<f32>(v_225.xyz, r10.w);
835
+ let v_226 = dot(r10.xyz, r5.xyz);
836
+ r9.w = clamp(vec4<f32>(v_226, v_226, v_226, v_226).w, 0.0f, 1.0f);
837
+ r9.w = ((-(r9.wwww)).w + 1.0f);
838
+ r10.w = (r9.w * r9.w);
839
+ r10.w = (r10.w * r10.w);
840
+ r9.w = (r9.w * r10.w);
841
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
842
+ let v_227 = dot(r10.xyz, r2.xyz);
843
+ r10.x = clamp(vec4<f32>(v_227, v_227, v_227, v_227).x, 0.0f, 1.0f);
844
+ r10.x = log2(r10.x);
845
+ r10.x = (r8.w * r10.x);
846
+ r10.x = exp2(r10.x);
847
+ r9.w = (r9.w * r10.x);
848
+ r7.w = (r7.w * r9.w);
849
+ r6.w = (r6.w * r7.w);
850
+ r6.w = (r1.y * r6.w);
851
+ let v_228 = fma(r6.www, cb3_3.tint_symbol_2[24u].xyz, r8.xyz);
852
+ r8 = vec4<f32>(v_228.xyz, r8.w);
853
+ }
854
+ }
855
+ if ((bitcast<u32>(r3.w) != 0u)) {
856
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
857
+ } else {
858
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (6i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
859
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
860
+ if ((bitcast<u32>(r3.w) != 0u)) {
861
+ } else {
862
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f)));
863
+ let v_229 = (v_14.xyz + cb3_3.tint_symbol_2[9u].xyz);
864
+ r10 = vec4<f32>(v_229.xyz, r10.w);
865
+ let v_230 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz);
866
+ r11 = vec4<f32>(v_230.xyz, r11.w);
867
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[17u].xyz);
868
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f);
869
+ r7.w = (r7.w * cb3_3.tint_symbol_2[25u].w);
870
+ let v_231 = fma(cb3_3.tint_symbol_2[17u].xyz, r7.www, cb3_3.tint_symbol_2[9u].xyz);
871
+ r11 = vec4<f32>(v_231.xyz, r11.w);
872
+ let v_232 = (r11.xyz + v_14.xyz);
873
+ r11 = vec4<f32>(v_232.xyz, r11.w);
874
+ let v_233 = bitcast<vec3<u32>>(r6.www);
875
+ let v_234 = r10.xyz;
876
+ let v_235 = select(r11.xyz, v_234, (v_233 != vec3<u32>()));
877
+ r10 = vec4<f32>(v_235.xyz, r10.w);
878
+ r6.w = dot(r10.xyz, r10.xyz);
879
+ let v_236 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
880
+ r10 = vec4<f32>(v_236.xyz, r10.w);
881
+ r7.w = dot(r10.xyz, r10.xyz);
882
+ r7.w = inverseSqrt(r7.w);
883
+ let v_237 = (r7.www * r10.xyz);
884
+ r10 = vec4<f32>(v_237.xyz, r10.w);
885
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[9u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
886
+ r7.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f);
887
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[17u].w);
888
+ r6.w = (r6.w / r7.w);
889
+ let v_238 = -(cb3_3.tint_symbol_2[17u].xyzx);
890
+ r7.w = dot(r10.xyz, v_238.xyz);
891
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f);
892
+ let v_239 = dot(r10.xyz, r2.xyz);
893
+ r9.w = clamp(vec4<f32>(v_239, v_239, v_239, v_239).w, 0.0f, 1.0f);
894
+ r7.w = (r7.w * r9.w);
895
+ r9.w = (r6.w * r7.w);
896
+ let v_240 = (r9.www * cb3_3.tint_symbol_2[25u].xyz);
897
+ r11 = vec4<f32>(v_240.xyz, r11.w);
898
+ let v_241 = fma(r11.xyz, r0.xyz, r9.xyz);
899
+ r9 = vec4<f32>(v_241.xyz, r9.w);
900
+ let v_242 = fma(r4.xyz, r2.www, r10.xyz);
901
+ r10 = vec4<f32>(v_242.xyz, r10.w);
902
+ r9.w = dot(r10.xyz, r10.xyz);
903
+ r9.w = inverseSqrt(r9.w);
904
+ let v_243 = (r9.www * r10.xyz);
905
+ r10 = vec4<f32>(v_243.xyz, r10.w);
906
+ let v_244 = dot(r10.xyz, r5.xyz);
907
+ r9.w = clamp(vec4<f32>(v_244, v_244, v_244, v_244).w, 0.0f, 1.0f);
908
+ r9.w = ((-(r9.wwww)).w + 1.0f);
909
+ r10.w = (r9.w * r9.w);
910
+ r10.w = (r10.w * r10.w);
911
+ r9.w = (r9.w * r10.w);
912
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
913
+ let v_245 = dot(r10.xyz, r2.xyz);
914
+ r10.x = clamp(vec4<f32>(v_245, v_245, v_245, v_245).x, 0.0f, 1.0f);
915
+ r10.x = log2(r10.x);
916
+ r10.x = (r8.w * r10.x);
917
+ r10.x = exp2(r10.x);
918
+ r9.w = (r9.w * r10.x);
919
+ r7.w = (r7.w * r9.w);
920
+ r6.w = (r6.w * r7.w);
921
+ r6.w = (r1.y * r6.w);
922
+ let v_246 = fma(r6.www, cb3_3.tint_symbol_2[25u].xyz, r8.xyz);
923
+ r8 = vec4<f32>(v_246.xyz, r8.w);
924
+ }
925
+ }
926
+ if ((bitcast<u32>(r3.w) != 0u)) {
927
+ } else {
928
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (7i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
929
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
930
+ if ((bitcast<u32>(r3.w) != 0u)) {
931
+ } else {
932
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f)));
933
+ let v_247 = (v_14.xyz + cb3_3.tint_symbol_2[10u].xyz);
934
+ r10 = vec4<f32>(v_247.xyz, r10.w);
935
+ let v_248 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz);
936
+ r11 = vec4<f32>(v_248.xyz, r11.w);
937
+ r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[18u].xyz);
938
+ r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[26u].wwww)).w, 0.0f, 1.0f);
939
+ r6.w = (r6.w * cb3_3.tint_symbol_2[26u].w);
940
+ let v_249 = fma(cb3_3.tint_symbol_2[18u].xyz, r6.www, cb3_3.tint_symbol_2[10u].xyz);
941
+ r11 = vec4<f32>(v_249.xyz, r11.w);
942
+ let v_250 = (r11.xyz + v_14.xyz);
943
+ r11 = vec4<f32>(v_250.xyz, r11.w);
944
+ let v_251 = bitcast<vec3<u32>>(r3.www);
945
+ let v_252 = r10.xyz;
946
+ let v_253 = select(r11.xyz, v_252, (v_251 != vec3<u32>()));
947
+ r10 = vec4<f32>(v_253.xyz, r10.w);
948
+ r3.w = dot(r10.xyz, r10.xyz);
949
+ let v_254 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
950
+ r10 = vec4<f32>(v_254.xyz, r10.w);
951
+ r6.w = dot(r10.xyz, r10.xyz);
952
+ r6.w = inverseSqrt(r6.w);
953
+ let v_255 = (r6.www * r10.xyz);
954
+ r10 = vec4<f32>(v_255.xyz, r10.w);
955
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
956
+ r6.w = ((-(cb3_3.tint_symbol_2[18u].wwww)).w + 1.0f);
957
+ r6.w = fma(r6.w, r3.w, cb3_3.tint_symbol_2[18u].w);
958
+ r3.w = (r3.w / r6.w);
959
+ let v_256 = -(cb3_3.tint_symbol_2[18u].xyzx);
960
+ r6.w = dot(r10.xyz, v_256.xyz);
961
+ r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).w, 0.0f, 1.0f);
962
+ let v_257 = dot(r10.xyz, r2.xyz);
963
+ r7.w = clamp(vec4<f32>(v_257, v_257, v_257, v_257).w, 0.0f, 1.0f);
964
+ r6.w = (r6.w * r7.w);
965
+ r7.w = (r3.w * r6.w);
966
+ let v_258 = (r7.www * cb3_3.tint_symbol_2[26u].xyz);
967
+ r11 = vec4<f32>(v_258.xyz, r11.w);
968
+ let v_259 = fma(r11.xyz, r0.xyz, r9.xyz);
969
+ r9 = vec4<f32>(v_259.xyz, r9.w);
970
+ let v_260 = fma(r4.xyz, r2.www, r10.xyz);
971
+ r4 = vec4<f32>(v_260.xyz, r4.w);
972
+ r2.w = dot(r4.xyz, r4.xyz);
973
+ r2.w = inverseSqrt(r2.w);
974
+ let v_261 = (r2.www * r4.xyz);
975
+ r4 = vec4<f32>(v_261.xyz, r4.w);
976
+ let v_262 = dot(r4.xyz, r5.xyz);
977
+ r2.w = clamp(vec4<f32>(v_262, v_262, v_262, v_262).w, 0.0f, 1.0f);
978
+ r2.w = ((-(r2.wwww)).w + 1.0f);
979
+ r5.x = (r2.w * r2.w);
980
+ r5.x = (r5.x * r5.x);
981
+ r2.w = (r2.w * r5.x);
982
+ r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r4.w);
983
+ let v_263 = dot(r4.xyz, r2.xyz);
984
+ r4.x = clamp(vec4<f32>(v_263, v_263, v_263, v_263).x, 0.0f, 1.0f);
985
+ r4.x = log2(r4.x);
986
+ r4.x = (r4.x * r8.w);
987
+ r4.x = exp2(r4.x);
988
+ r2.w = (r2.w * r4.x);
989
+ r2.w = (r6.w * r2.w);
990
+ r2.w = (r3.w * r2.w);
991
+ r1.y = (r1.y * r2.w);
992
+ let v_264 = fma(r1.yyy, cb3_3.tint_symbol_2[26u].xyz, r8.xyz);
993
+ r8 = vec4<f32>(v_264.xyz, r8.w);
994
+ }
995
+ }
996
+ r1.y = (r5.w * r5.w);
997
+ r1.x = (r1.x * r1.x);
998
+ let v_265 = (r8.xyz * r1.xxx);
999
+ r4 = vec4<f32>(v_265.xyz, r4.w);
1000
+ let v_266 = fma(r1.yyy, r9.xyz, r4.xyz);
1001
+ r4 = vec4<f32>(v_266.xyz, r4.w);
1002
+ let v_267 = fma(r6.xyz, r3.zzz, r4.xyz);
1003
+ r4 = vec4<f32>(v_267.xyz, r4.w);
1004
+ r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w);
1005
+ r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w);
1006
+ r1.x = max(r1.x, 0.0f);
1007
+ let v_268 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz);
1008
+ r1 = vec4<f32>(r1.x, v_268.xyz);
1009
+ r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
1010
+ let v_269 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz);
1011
+ r5 = vec4<f32>(v_269.xyz, r5.w);
1012
+ let v_270 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz);
1013
+ r5 = vec4<f32>(v_270.xyz, r5.w);
1014
+ let v_271 = fma(r1.yzw, r2.www, r5.xyz);
1015
+ r1 = vec4<f32>(r1.x, v_271.xyz);
1016
+ let v_272 = (r3.yyy * r1.yzw);
1017
+ r1 = vec4<f32>(r1.x, v_272.xyz);
1018
+ let v_273 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz);
1019
+ r3 = vec4<f32>(r3.x, v_273.xyz);
1020
+ r5.x = cb3_3.tint_symbol_2[46u].w;
1021
+ r5.y = cb3_3.tint_symbol_2[47u].w;
1022
+ r5.z = cb3_3.tint_symbol_2[48u].w;
1023
+ let v_274 = dot(r5.xyz, r2.xyz);
1024
+ r1.x = clamp(vec4<f32>(v_274, v_274, v_274, v_274).x, 0.0f, 1.0f);
1025
+ let v_275 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r3.yzw);
1026
+ r2 = vec4<f32>(v_275.xyz, r2.w);
1027
+ let v_276 = fma(r2.xyz, r3.xxx, r1.yzw);
1028
+ r1 = vec4<f32>(v_276.xyz, r1.w);
1029
+ let v_277 = (r5.www * r1.xyz);
1030
+ r1 = vec4<f32>(v_277.xyz, r1.w);
1031
+ let v_278 = fma(r1.xyz, r0.xyz, r4.xyz);
1032
+ r0 = vec4<f32>(v_278.xyz, r0.w);
1033
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
1034
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
1035
+ r0.w = dot(r7.xyz, r7.xyz);
1036
+ r1.x = sqrt(r0.w);
1037
+ let v_279 = -(cb3_3.tint_symbol_2[50u].xxxx);
1038
+ r1.y = (r1.x + v_279.y);
1039
+ r1.y = max(r1.y, 0.0f);
1040
+ r1.x = (r1.y / r1.x);
1041
+ r1.x = (r1.x * r7.z);
1042
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
1043
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
1044
+ r1.w = (r1.z * -1.44269502162933349609f);
1045
+ r1.w = exp2(r1.w);
1046
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1047
+ r1.z = (r1.w / r1.z);
1048
+ let v_280 = bitcast<u32>(r1.x);
1049
+ r1.x = select(1.0f, r1.z, (v_280 != 0u));
1050
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
1051
+ r1.x = (r1.x * r1.z);
1052
+ r1.x = min(r1.x, 1.0f);
1053
+ r1.x = (r1.x * 1.44269502162933349609f);
1054
+ r1.x = exp2(r1.x);
1055
+ r1.x = min(r1.x, 1.0f);
1056
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
1057
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
1058
+ r0.w = inverseSqrt(r0.w);
1059
+ let v_281 = (r0.www * r7.xyz);
1060
+ r2 = vec4<f32>(v_281.xyz, r2.w);
1061
+ let v_282 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
1062
+ r0.w = clamp(vec4<f32>(v_282, v_282, v_282, v_282).w, 0.0f, 1.0f);
1063
+ r0.w = log2(r0.w);
1064
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1065
+ r0.w = exp2(r0.w);
1066
+ let v_283 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
1067
+ r1.w = clamp(vec4<f32>(v_283, v_283, v_283, v_283).w, 0.0f, 1.0f);
1068
+ r1.w = log2(r1.w);
1069
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
1070
+ r1.w = exp2(r1.w);
1071
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
1072
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
1073
+ let v_284 = -(cb3_3.tint_symbol_2[52u].xxxx);
1074
+ r2.x = (r1.y + v_284.x);
1075
+ r2.x = max(r2.x, 0.0f);
1076
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
1077
+ r2.x = (r2.x * 1.44269502162933349609f);
1078
+ r2.x = exp2(r2.x);
1079
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1080
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
1081
+ let v_285 = -(cb3_3.tint_symbol_2[51u].zzzz);
1082
+ r1.y = (r1.y * v_285.y);
1083
+ r1.y = (r1.y * 1.44269502162933349609f);
1084
+ r1.y = exp2(r1.y);
1085
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
1086
+ let v_286 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1087
+ r2 = vec4<f32>(v_286.xyz, r2.w);
1088
+ let v_287 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
1089
+ r2 = vec4<f32>(v_287.xyz, r2.w);
1090
+ let v_288 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1091
+ r3 = vec4<f32>(v_288.xyz, r3.w);
1092
+ let v_289 = fma(r1.www, r3.xyz, r2.xyz);
1093
+ r2 = vec4<f32>(v_289.xyz, r2.w);
1094
+ let v_290 = -(cb3_3.tint_symbol_2[57u].xyzx);
1095
+ let v_291 = (r2.xyz + v_290.xyz);
1096
+ r2 = vec4<f32>(v_291.xyz, r2.w);
1097
+ let v_292 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
1098
+ r2 = vec4<f32>(v_292.xyz, r2.w);
1099
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1100
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1101
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1102
+ let v_293 = ((-(r2.xyzx)).xyz + r3.xyz);
1103
+ r3 = vec4<f32>(v_293.xyz, r3.w);
1104
+ let v_294 = fma(r1.xxx, r3.xyz, r2.xyz);
1105
+ r1 = vec4<f32>(v_294.xy, r1.z, v_294.z);
1106
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
1107
+ if ((bitcast<u32>(r0.w) != 0u)) {
1108
+ let v_295 = (v7.xy * cb2_2.tint_symbol_1[18u].zw);
1109
+ r2 = vec4<f32>(v_295.xy, r2.zw);
1110
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
1111
+ r0.w = (r2.x + -1.0f);
1112
+ r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
1113
+ } else {
1114
+ r0.w = 1.0f;
1115
+ }
1116
+ let v_296 = -(r0.xyxz);
1117
+ let v_297 = fma(r1.xyw, r0.www, v_296.xyw);
1118
+ r1 = vec4<f32>(v_297.xy, r1.z, v_297.z);
1119
+ let v_298 = fma(r1.zzz, r1.xyw, r0.xyz);
1120
+ r1 = vec4<f32>(v_298.xyz, r1.w);
1121
+ } else {
1122
+ r0.w = dot(r7.xyz, r7.xyz);
1123
+ r1.w = sqrt(r0.w);
1124
+ let v_299 = -(cb3_3.tint_symbol_2[50u].xxxx);
1125
+ r2.x = (r1.w + v_299.x);
1126
+ r2.x = max(r2.x, 0.0f);
1127
+ r1.w = (r2.x / r1.w);
1128
+ r1.w = (r1.w * r7.z);
1129
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z);
1130
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
1131
+ r2.z = (r2.y * -1.44269502162933349609f);
1132
+ r2.z = exp2(r2.z);
1133
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
1134
+ r2.y = (r2.z / r2.y);
1135
+ let v_300 = bitcast<u32>(r1.w);
1136
+ r1.w = select(1.0f, r2.y, (v_300 != 0u));
1137
+ r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w);
1138
+ r1.w = (r1.w * r2.y);
1139
+ r1.w = min(r1.w, 1.0f);
1140
+ r1.w = (r1.w * 1.44269502162933349609f);
1141
+ r1.w = exp2(r1.w);
1142
+ r1.w = min(r1.w, 1.0f);
1143
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1144
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y);
1145
+ r0.w = inverseSqrt(r0.w);
1146
+ let v_301 = (r0.www * r7.xyz);
1147
+ r3 = vec4<f32>(v_301.xyz, r3.w);
1148
+ let v_302 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
1149
+ r0.w = clamp(vec4<f32>(v_302, v_302, v_302, v_302).w, 0.0f, 1.0f);
1150
+ r0.w = log2(r0.w);
1151
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1152
+ r0.w = exp2(r0.w);
1153
+ let v_303 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
1154
+ r2.z = clamp(vec4<f32>(v_303, v_303, v_303, v_303).z, 0.0f, 1.0f);
1155
+ r2.z = log2(r2.z);
1156
+ r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w);
1157
+ r2.z = exp2(r2.z);
1158
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f);
1159
+ r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y);
1160
+ let v_304 = -(cb3_3.tint_symbol_2[52u].xxxx);
1161
+ r2.w = (r2.x + v_304.w);
1162
+ r2.w = max(r2.w, 0.0f);
1163
+ r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x);
1164
+ r2.w = (r2.w * 1.44269502162933349609f);
1165
+ r2.w = exp2(r2.w);
1166
+ r2.w = ((-(r2.wwww)).w + 1.0f);
1167
+ r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f);
1168
+ let v_305 = -(cb3_3.tint_symbol_2[51u].zzzz);
1169
+ r2.x = (r2.x * v_305.x);
1170
+ r2.x = (r2.x * 1.44269502162933349609f);
1171
+ r2.x = exp2(r2.x);
1172
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1173
+ let v_306 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1174
+ r3 = vec4<f32>(v_306.xyz, r3.w);
1175
+ let v_307 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
1176
+ r3 = vec4<f32>(v_307.xyz, r3.w);
1177
+ let v_308 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1178
+ r4 = vec4<f32>(v_308.xyz, r4.w);
1179
+ let v_309 = fma(r2.zzz, r4.xyz, r3.xyz);
1180
+ r3 = vec4<f32>(v_309.xyz, r3.w);
1181
+ let v_310 = -(cb3_3.tint_symbol_2[57u].xyzx);
1182
+ let v_311 = (r3.xyz + v_310.xyz);
1183
+ r3 = vec4<f32>(v_311.xyz, r3.w);
1184
+ let v_312 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
1185
+ r2 = vec4<f32>(v_312.x, r2.y, v_312.yz);
1186
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1187
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1188
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1189
+ let v_313 = ((-(r2.xzwx)).xyz + r3.xyz);
1190
+ r3 = vec4<f32>(v_313.xyz, r3.w);
1191
+ let v_314 = fma(r1.www, r3.xyz, r2.xzw);
1192
+ r2 = vec4<f32>(v_314.x, r2.y, v_314.yz);
1193
+ let v_315 = ((-(r0.xxyz)).xzw + r2.xzw);
1194
+ r2 = vec4<f32>(v_315.x, r2.y, v_315.yz);
1195
+ let v_316 = fma(r2.yyy, r2.xzw, r0.xyz);
1196
+ r1 = vec4<f32>(v_316.xyz, r1.w);
1197
+ }
1198
+ let v_317 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
1199
+ o0 = vec4<f32>(v_317.xyz, o0.w);
1200
+ }
1201
+
1202
+ fn v_3(v_318 : bool) {
1203
+ if (v_318) {
1204
+ discard;
1205
+ return;
1206
+ }
1207
+ }
1208
+
1209
+ @fragment
1210
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @builtin(position) v_319 : vec4<f32>) -> @location(0u) vec4<f32> {
1211
+ main_inner(v0, v1, v2, v3, v4, v5, v6, v_319);
1212
+ return o0;
1213
+ }
b/8b0b5899ed/shaders/008de4769b557904.wgsl ADDED
@@ -0,0 +1,75 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ struct cb18_struct {
10
+ tint_symbol : array<vec4<f32>, 18u>,
11
+ }
12
+
13
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb18_struct;
14
+
15
+ struct cb4_struct {
16
+ tint_symbol_1 : array<vec4<f32>, 4u>,
17
+ }
18
+
19
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb4_struct;
20
+
21
+ struct cb4_struct_1 {
22
+ tint_symbol_2 : array<vec4<f32>, 4u>,
23
+ }
24
+
25
+ @group(1u) @binding(11u) var<uniform> cb11_11 : cb4_struct_1;
26
+
27
+ @group(1u) @binding(16u) var s0 : sampler;
28
+
29
+ @group(1u) @binding(19u) var s3 : sampler;
30
+
31
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
32
+
33
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
34
+
35
+ var<private> o0 : vec4<f32>;
36
+
37
+ fn main_inner(v1 : vec4<f32>, v2 : vec4<f32>) {
38
+ r0.x = (cb5_5.tint_symbol_1[3u].z * cb11_11.tint_symbol_2[2u].z);
39
+ let v = ((-(cb11_11.tint_symbol_2[2u].zzzz)).yz + vec2<f32>(1.0f, 2.0f));
40
+ let v_1 = r0;
41
+ r0 = vec4<f32>(v_1.x, v.xy, v_1.w);
42
+ let v_2 = (r0.zz * v1.zw);
43
+ r0 = vec4<f32>(r0.xy, v_2.xy);
44
+ r1 = textureSample(t3, s3, r0.zwzz.xy);
45
+ r0.z = ((-(r1.xxxx)).z + r1.z);
46
+ r0.x = fma(r0.x, r0.z, r1.x);
47
+ r0.z = fma(v2.z, r0.y, -1.0f);
48
+ r0.z = fma(r0.y, r0.z, 1.0f);
49
+ r0.y = (r0.y * v2.z);
50
+ let v_3 = (r0.xy * cb11_11.tint_symbol_2[2u].xx);
51
+ r0 = vec4<f32>(v_3.xy, r0.zw);
52
+ r0.x = (r0.z * r0.x);
53
+ r2 = textureSample(t0, s0, v1.xyxx.xy);
54
+ let v_4 = (r2.xyz * cb11_11.tint_symbol_2[0u].xyz);
55
+ r2 = vec4<f32>(v_4.xyz, r2.w);
56
+ r2 = (r2 * v2.xxxw);
57
+ let v_5 = -(r2.xyxz);
58
+ let v_6 = fma(cb11_11.tint_symbol_2[3u].xyz, cb11_11.tint_symbol_2[2u].yyy, v_5.xyw);
59
+ r1 = vec4<f32>(v_6.xy, r1.z, v_6.z);
60
+ let v_7 = fma(r0.xxx, r1.xyw, r2.xyz);
61
+ r0 = vec4<f32>(v_7.x, r0.y, v_7.yz);
62
+ o0.w = (r2.w * cb2_2.tint_symbol[15u].x);
63
+ let v_8 = ((-(r0.xzwx)).xyz + r1.zzz);
64
+ r1 = vec4<f32>(v_8.xyz, r1.w);
65
+ let v_9 = fma(r0.yyy, r1.xyz, r0.xzw);
66
+ r0 = vec4<f32>(v_9.xyz, r0.w);
67
+ let v_10 = (r0.xyz * cb2_2.tint_symbol[17u].zzz);
68
+ o0 = vec4<f32>(v_10.xyz, o0.w);
69
+ }
70
+
71
+ @fragment
72
+ fn main(@location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>) -> @location(0u) vec4<f32> {
73
+ main_inner(v1, v2);
74
+ return o0;
75
+ }
b/8b0b5899ed/shaders/00928753ac46ae0c.wgsl ADDED
@@ -0,0 +1,25 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ struct cb11_struct {
6
+ tint_symbol : array<vec4<f32>, 11u>,
7
+ }
8
+
9
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb11_struct;
10
+
11
+ var<private> o0 : vec4<f32>;
12
+
13
+ fn main_inner(v1 : vec4<f32>) {
14
+ let v = (v1.xyz + (-(cb12_12.tint_symbol[10u].xyzx)).xyz);
15
+ r0 = vec4<f32>(v.xyz, r0.w);
16
+ let v_1 = fma(v1.www, r0.xyz, cb12_12.tint_symbol[10u].xyz);
17
+ o0 = vec4<f32>(v_1.xyz, o0.w);
18
+ o0.w = 1.0f;
19
+ }
20
+
21
+ @fragment
22
+ fn main(@location(1u) v1 : vec4<f32>) -> @location(0u) vec4<f32> {
23
+ main_inner(v1);
24
+ return o0;
25
+ }
b/8b0b5899ed/shaders/00c3781b22af3678.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/00c3781b22af3678.wgsl ADDED
@@ -0,0 +1,957 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ var<private> r25 : vec4<f32>;
54
+
55
+ struct cb16_struct {
56
+ tint_symbol : array<vec4<f32>, 16u>,
57
+ }
58
+
59
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
60
+
61
+ struct cb23_struct {
62
+ tint_symbol_1 : array<vec4<f32>, 23u>,
63
+ }
64
+
65
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
66
+
67
+ struct cb59_struct {
68
+ tint_symbol_2 : array<vec4<f32>, 59u>,
69
+ }
70
+
71
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
72
+
73
+ struct cb8_struct {
74
+ tint_symbol_3 : array<vec4<f32>, 8u>,
75
+ }
76
+
77
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
78
+
79
+ struct cb2_struct {
80
+ tint_symbol_4 : array<vec4<f32>, 2u>,
81
+ }
82
+
83
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
84
+
85
+ struct cb15_struct {
86
+ tint_symbol_5 : array<vec4<f32>, 15u>,
87
+ }
88
+
89
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
90
+
91
+ @group(1u) @binding(16u) var s0 : sampler;
92
+
93
+ @group(1u) @binding(18u) var s2 : sampler;
94
+
95
+ @group(1u) @binding(19u) var s3 : sampler;
96
+
97
+ @group(1u) @binding(27u) var s11 : sampler;
98
+
99
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
100
+
101
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
102
+
103
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
104
+
105
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
108
+
109
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
110
+
111
+ var<private> v5 : vec4<f32>;
112
+
113
+ var<private> v6 : array<f32, 4u>;
114
+
115
+ var<private> o0 : vec4<f32>;
116
+
117
+ var<private> o1 : f32;
118
+
119
+ var<private> o2 : f32;
120
+
121
+ var<private> x0 : array<vec4<f32>, 4u>;
122
+
123
+ var<private> x1 : array<vec4<f32>, 1u>;
124
+
125
+ struct tint_symbol_7 {
126
+ tint_symbol_6 : array<vec4<u32>, 4u>,
127
+ }
128
+
129
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
130
+
131
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v_1 : vec4<f32>) {
132
+ var v_2 : vec4<f32> = v_1;
133
+ v_2.w = (1.0f / v_1.w);
134
+ v5 = v_2;
135
+ x1[0u].x = v6[0u];
136
+ x1[0u].y = v6[1u];
137
+ x1[0u].z = v6[2u];
138
+ x1[0u].w = v6[3u];
139
+ r0 = textureSample(t0, s0, v1.xyz.xyxx.xy);
140
+ r1.x = dot(v2.xyz, v2.xyz);
141
+ r1.x = inverseSqrt(r1.x);
142
+ let v_3 = (r1.xxx * v2.xyz);
143
+ r1 = vec4<f32>(r1.x, v_3.xyz);
144
+ r2 = textureSample(t2, s2, v1.xyz.xyxx.xy);
145
+ let v_4 = (r2.xy * r2.xy);
146
+ r2 = vec4<f32>(v_4.xy, r2.zw);
147
+ r2.x = dot(r2.xyz, cb12_12.tint_symbol_4[1u].xyz);
148
+ r2.x = clamp(((r2.xxxx * cb12_12.tint_symbol_4[0u].zzzz)).x, 0.0f, 1.0f);
149
+ r2.y = dot(v3.xyz, v3.xyz);
150
+ r2.y = inverseSqrt(r2.y);
151
+ let v_5 = (r2.yyy * v3.xyz);
152
+ r3 = vec4<f32>(v_5.xyz, r3.w);
153
+ r2.y = dot((-(r3.xyzx)).xyz, r1.yzw);
154
+ r2.y = (r2.y + r2.y);
155
+ let v_6 = -(r2.yyyy);
156
+ let v_7 = -(r3.xyzx);
157
+ let v_8 = fma(r1.yzw, v_6.xyz, v_7.xyz);
158
+ r3 = vec4<f32>(v_8.xyz, r3.w);
159
+ r2.y = dot(r3.xyz, r3.xyz);
160
+ r2.y = inverseSqrt(r2.y);
161
+ let v_9 = fma(r3.xz, r2.yy, vec2<f32>(1.0f));
162
+ let v_10 = r2;
163
+ r2 = vec4<f32>(v_10.x, v_9.xy, v_10.w);
164
+ let v_11 = (r2.yz * vec2<f32>(-0.5f));
165
+ let v_12 = r2;
166
+ r2 = vec4<f32>(v_12.x, v_11.xy, v_12.w);
167
+ r3 = textureSample(t3, s3, r2.yzyy.xy);
168
+ let v_13 = (r3.xyz * cb12_12.tint_symbol_4[1u].www);
169
+ r3 = vec4<f32>(v_13.xyz, r3.w);
170
+ r0.w = (r0.w * v0.w);
171
+ let v_14 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
172
+ let v_15 = r2;
173
+ r2 = vec4<f32>(v_15.x, v_14.xy, v_15.w);
174
+ let v_16 = (r0.xyz * r0.xyz);
175
+ r0 = vec4<f32>(v_16.xyz, r0.w);
176
+ let v_17 = -(v4.xyzx);
177
+ let v_18 = (v_17.xyz + cb1_1.tint_symbol[15u].xyz);
178
+ r4 = vec4<f32>(v_18.xyz, r4.w);
179
+ r3.w = dot(r4.xyz, r4.xyz);
180
+ r3.w = inverseSqrt(r3.w);
181
+ let v_19 = (r3.www * r4.xyz);
182
+ r5 = vec4<f32>(v_19.xyz, r5.w);
183
+ let v_20 = -(cb3_3.tint_symbol_2[0u].xyzx);
184
+ let v_21 = fma(r4.xyz, r3.www, v_20.xyz);
185
+ r6 = vec4<f32>(v_21.xyz, r6.w);
186
+ r4.w = dot(r6.xyz, r6.xyz);
187
+ r4.w = inverseSqrt(r4.w);
188
+ let v_22 = (r4.www * r6.xyz);
189
+ r6 = vec4<f32>(v_22.xyz, r6.w);
190
+ let v_23 = (r2.yz * r2.yz);
191
+ let v_24 = r2;
192
+ r2 = vec4<f32>(v_24.x, v_23.xy, v_24.w);
193
+ r4.w = fma(r2.w, cb12_12.tint_symbol_4[0u].y, -500.0f);
194
+ r4.w = max(r4.w, 0.0f);
195
+ let v_25 = -(r4.wwww);
196
+ r2.w = fma(r2.w, cb12_12.tint_symbol_4[0u].y, v_25.w);
197
+ r4.w = (r4.w * 558.0f);
198
+ r2.w = fma(r2.w, 3.0f, r4.w);
199
+ r4.w = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz);
200
+ let v_26 = (v4.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
201
+ r7 = vec4<f32>(v_26.xyz, r7.w);
202
+ let v_27 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz);
203
+ r8 = vec4<f32>(v_27.xyz, r8.w);
204
+ let v_28 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz);
205
+ r8 = vec4<f32>(v_28.xyz, r8.w);
206
+ let v_29 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz);
207
+ r8 = vec4<f32>(v_29.xyz, r8.w);
208
+ let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
209
+ r9 = vec4<f32>(v_30.xyz, r9.w);
210
+ let v_31 = &(x0[0u]);
211
+ let v_32 = r9;
212
+ *(v_31) = vec4<f32>(v_32.xyz, (*(v_31)).w);
213
+ let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
214
+ r10 = vec4<f32>(v_33.xyz, r10.w);
215
+ let v_34 = &(x0[1u]);
216
+ let v_35 = r10;
217
+ *(v_34) = vec4<f32>(v_35.xyz, (*(v_34)).w);
218
+ let v_36 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
219
+ r11 = vec4<f32>(v_36.xyz, r11.w);
220
+ let v_37 = &(x0[2u]);
221
+ let v_38 = r11;
222
+ *(v_37) = vec4<f32>(v_38.xyz, (*(v_37)).w);
223
+ let v_39 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
224
+ r8 = vec4<f32>(v_39.xyz, r8.w);
225
+ let v_40 = &(x0[3u]);
226
+ let v_41 = r8;
227
+ *(v_40) = vec4<f32>(v_41.xyz, (*(v_40)).w);
228
+ let v_42 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
229
+ let v_43 = r12;
230
+ r12 = vec4<f32>(v_43.x, v_42.x, v_43.z, v_42.y);
231
+ r5.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
232
+ r5.w = (r5.w * 0.5f);
233
+ let v_44 = abs(r11.yyyy);
234
+ r6.w = max(v_44.w, abs(r11.xxxx).w);
235
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (r6.w < r5.w)));
236
+ let v_45 = (bitcast<u32>(r6.w) != 0u);
237
+ let v_46 = bitcast<f32>(v.tint_symbol_6[0i].x);
238
+ r6.w = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_46, v_45);
239
+ let v_47 = abs(r10.yyyy);
240
+ r7.w = max(v_47.w, abs(r10.xxxx).w);
241
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r5.w)));
242
+ let v_48 = bitcast<u32>(r7.w);
243
+ r6.w = select(r6.w, bitcast<f32>(v.tint_symbol_6[2i].x), (v_48 != 0u));
244
+ let v_49 = abs(r9.yyyy);
245
+ r7.w = max(v_49.w, abs(r9.xxxx).w);
246
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r5.w)));
247
+ let v_50 = bitcast<u32>(r5.w);
248
+ r5.w = select(r6.w, 0.0f, (v_50 != 0u));
249
+ let v_51 = x0[bitcast<i32>(r5.w)];
250
+ r9 = vec4<f32>(v_51.xyz, r9.w);
251
+ r5.w = f32(bitcast<i32>(r5.w));
252
+ r6.w = (r5.w + 0.5f);
253
+ r6.w = (r6.w * 0.25f);
254
+ r10 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r5.wwww)));
255
+ r10 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r10) & vec4<u32>(1065353216u)));
256
+ r5.w = dot(r10, cb6_6.tint_symbol_5[12u]);
257
+ r7.w = dot(r10, cb6_6.tint_symbol_5[13u]);
258
+ r10.x = (r9.x + 0.5f);
259
+ r10.y = fma(r9.y, 0.25f, r6.w);
260
+ r6.w = bitcast<f32>(select(0u, 4294967295u, !((r5.w == 0.0f))));
261
+ r5.w = ((-(r5.wwww)).w + r9.z);
262
+ let v_52 = dpdx(r10.xyy);
263
+ r11 = vec4<f32>(v_52.xy, r11.z, v_52.z);
264
+ r11.z = dpdx(r5.w);
265
+ let v_53 = dpdy(r10.yxy);
266
+ r13 = vec4<f32>(v_53.xyz, r13.w);
267
+ r13.w = dpdy(r5.w);
268
+ let v_54 = (r11.yw * r13.yw);
269
+ r8 = vec4<f32>(r8.xy, v_54.xy);
270
+ let v_55 = -(r8.zwzz);
271
+ let v_56 = fma(r11.xz, r13.xz, v_55.xy);
272
+ r14 = vec4<f32>(v_56.xy, r14.zw);
273
+ r8.z = (1.0f / r14.x);
274
+ r8.w = (r11.z * r13.y);
275
+ let v_57 = -(r8.wwww);
276
+ r14.z = fma(r11.x, r13.w, v_57.z);
277
+ let v_58 = (r8.zz * r14.yz);
278
+ r8 = vec4<f32>(r8.xy, v_58.xy);
279
+ let v_59 = max(r8.zw, vec2<f32>());
280
+ r8 = vec4<f32>(r8.xy, v_59.xy);
281
+ let v_60 = min(r8.zw, vec2<f32>(0.5f));
282
+ r8 = vec4<f32>(r8.xy, v_60.xy);
283
+ r5.w = fma((-(r7.wwww)).w, r8.z, r5.w);
284
+ r5.w = fma((-(r7.wwww)).w, r8.w, r5.w);
285
+ let v_61 = bitcast<u32>(r6.w);
286
+ let v_62 = r5.w;
287
+ r12.z = select(r9.z, v_62, (v_61 != 0u));
288
+ r10.z = 0.0f;
289
+ let v_63 = (r10.xyz + r12.ywz);
290
+ r9 = vec4<f32>(v_63.xyz, r9.w);
291
+ let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
292
+ r12 = vec4<f32>(v_64.xy, r12.zw);
293
+ let v_65 = (r10.xyz + r12.xyz);
294
+ r11 = vec4<f32>(v_65.xyz, r11.w);
295
+ let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
296
+ r12 = vec4<f32>(v_66.xy, r12.zw);
297
+ let v_67 = (r10.xyz + r12.xyz);
298
+ r13 = vec4<f32>(v_67.xyz, r13.w);
299
+ let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
300
+ r12 = vec4<f32>(v_68.xy, r12.zw);
301
+ let v_69 = (r10.xyz + r12.xyz);
302
+ r14 = vec4<f32>(v_69.xyz, r14.w);
303
+ let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
304
+ r12 = vec4<f32>(v_70.xy, r12.zw);
305
+ let v_71 = (r10.xyz + r12.xyz);
306
+ r15 = vec4<f32>(v_71.xyz, r15.w);
307
+ let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
308
+ r12 = vec4<f32>(v_72.xy, r12.zw);
309
+ let v_73 = (r10.xyz + r12.xyz);
310
+ r16 = vec4<f32>(v_73.xyz, r16.w);
311
+ let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
312
+ r12 = vec4<f32>(v_74.xy, r12.zw);
313
+ let v_75 = (r10.xyz + r12.xyz);
314
+ r17 = vec4<f32>(v_75.xyz, r17.w);
315
+ let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
316
+ r12 = vec4<f32>(v_76.xy, r12.zw);
317
+ let v_77 = (r10.xyz + r12.xyz);
318
+ r18 = vec4<f32>(v_77.xyz, r18.w);
319
+ let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
320
+ r12 = vec4<f32>(v_78.xy, r12.zw);
321
+ let v_79 = (r10.xyz + r12.xyz);
322
+ r19 = vec4<f32>(v_79.xyz, r19.w);
323
+ let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
324
+ r12 = vec4<f32>(v_80.xy, r12.zw);
325
+ let v_81 = (r10.xyz + r12.xyz);
326
+ r20 = vec4<f32>(v_81.xyz, r20.w);
327
+ let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
328
+ r12 = vec4<f32>(v_82.xy, r12.zw);
329
+ let v_83 = (r10.xyz + r12.xyz);
330
+ r21 = vec4<f32>(v_83.xyz, r21.w);
331
+ let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
332
+ r12 = vec4<f32>(v_84.xy, r12.zw);
333
+ let v_85 = (r10.xyz + r12.xyz);
334
+ r22 = vec4<f32>(v_85.xyz, r22.w);
335
+ let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
336
+ r12 = vec4<f32>(v_86.xy, r12.zw);
337
+ let v_87 = (r10.xyz + r12.xyz);
338
+ r23 = vec4<f32>(v_87.xyz, r23.w);
339
+ let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
340
+ r12 = vec4<f32>(v_88.xy, r12.zw);
341
+ let v_89 = (r10.xyz + r12.xyz);
342
+ r24 = vec4<f32>(v_89.xyz, r24.w);
343
+ let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
344
+ r12 = vec4<f32>(v_90.xy, r12.zw);
345
+ let v_91 = (r10.xyz + r12.xyz);
346
+ r25 = vec4<f32>(v_91.xyz, r25.w);
347
+ let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
348
+ r12 = vec4<f32>(v_92.xy, r12.zw);
349
+ let v_93 = (r10.xyz + r12.xyz);
350
+ r10 = vec4<f32>(v_93.xyz, r10.w);
351
+ let v_94 = r9.xyxx;
352
+ r9.x = textureSampleCompareLevel(t15, s15, v_94.xy, r9.z);
353
+ let v_95 = r11.xyxx;
354
+ r9.y = textureSampleCompareLevel(t15, s15, v_95.xy, r11.z);
355
+ let v_96 = r13.xyxx;
356
+ r9.z = textureSampleCompareLevel(t15, s15, v_96.xy, r13.z);
357
+ let v_97 = r14.xyxx;
358
+ r9.w = textureSampleCompareLevel(t15, s15, v_97.xy, r14.z);
359
+ let v_98 = r15.xyxx;
360
+ r11.x = textureSampleCompareLevel(t15, s15, v_98.xy, r15.z);
361
+ let v_99 = r16.xyxx;
362
+ r11.y = textureSampleCompareLevel(t15, s15, v_99.xy, r16.z);
363
+ let v_100 = r17.xyxx;
364
+ r11.z = textureSampleCompareLevel(t15, s15, v_100.xy, r17.z);
365
+ let v_101 = r18.xyxx;
366
+ r11.w = textureSampleCompareLevel(t15, s15, v_101.xy, r18.z);
367
+ let v_102 = r19.xyxx;
368
+ r12.x = textureSampleCompareLevel(t15, s15, v_102.xy, r19.z);
369
+ let v_103 = r20.xyxx;
370
+ r12.y = textureSampleCompareLevel(t15, s15, v_103.xy, r20.z);
371
+ let v_104 = r21.xyxx;
372
+ r12.z = textureSampleCompareLevel(t15, s15, v_104.xy, r21.z);
373
+ let v_105 = r22.xyxx;
374
+ r12.w = textureSampleCompareLevel(t15, s15, v_105.xy, r22.z);
375
+ let v_106 = r23.xyxx;
376
+ r13.x = textureSampleCompareLevel(t15, s15, v_106.xy, r23.z);
377
+ let v_107 = r24.xyxx;
378
+ r13.y = textureSampleCompareLevel(t15, s15, v_107.xy, r24.z);
379
+ let v_108 = r25.xyxx;
380
+ r13.z = textureSampleCompareLevel(t15, s15, v_108.xy, r25.z);
381
+ let v_109 = r10.xyxx;
382
+ r13.w = textureSampleCompareLevel(t15, s15, v_109.xy, r10.z);
383
+ r9 = (r9 + r11);
384
+ r9 = (r12 + r9);
385
+ r9 = (r13 + r9);
386
+ r5.w = dot(r9, vec4<f32>(1.0f));
387
+ r4.w = clamp(fma(r4.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f);
388
+ let v_110 = abs(r8.yyyy);
389
+ r6.w = max(v_110.w, abs(r8.xxxx).w);
390
+ r6.w = clamp(fma(r6.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
391
+ r4.w = ((-(r4.wwww)).w + 1.0f);
392
+ r4.w = (r6.w * r4.w);
393
+ r4.w = fma(r5.w, 0.0625f, r4.w);
394
+ r4.w = (r4.w * r4.w);
395
+ r4.w = min(r4.w, 1.0f);
396
+ r5.w = clamp(fma(v4.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
397
+ r5.w = sqrt(r5.w);
398
+ r5.w = (r5.w * cb6_6.tint_symbol_5[3u].z);
399
+ let v_111 = -(r4.wwww);
400
+ r4.w = fma(r5.w, v_111.w, r4.w);
401
+ let v_112 = dot(r1.yzw, v_20.xyz);
402
+ r5.w = clamp(vec4<f32>(v_112, v_112, v_112, v_112).w, 0.0f, 1.0f);
403
+ let v_113 = dot(r5.xyz, r1.yzw);
404
+ r8.x = clamp(vec4<f32>(v_113, v_113, v_113, v_113).x, 0.0f, 1.0f);
405
+ let v_114 = dot(r6.xyz, v_20.xyz);
406
+ r8.y = clamp(vec4<f32>(v_114, v_114, v_114, v_114).y, 0.0f, 1.0f);
407
+ let v_115 = ((-(r8.xyxx)).xy + vec2<f32>(1.0f));
408
+ r8 = vec4<f32>(v_115.xy, r8.zw);
409
+ let v_116 = (r8.xy * r8.xy);
410
+ r8 = vec4<f32>(r8.xy, v_116.xy);
411
+ let v_117 = (r8.zw * r8.zw);
412
+ r8 = vec4<f32>(r8.xy, v_117.xy);
413
+ let v_118 = (r8.xy * r8.zw);
414
+ r8 = vec4<f32>(v_118.xy, r8.zw);
415
+ r6.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f);
416
+ let v_119 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r6.ww);
417
+ r8 = vec4<f32>(v_119.xy, r8.zw);
418
+ let v_120 = (r2.ww + vec2<f32>(2.0f, 0.00000000999999993923f));
419
+ r8 = vec4<f32>(r8.xy, v_120.xy);
420
+ r7.w = (r8.z * 0.125f);
421
+ r8.x = fma((-(r2.xxxx)).x, r8.x, 1.0f);
422
+ r6.x = dot(r1.yzw, r6.xyz);
423
+ r6.x = clamp(((r6.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
424
+ r6.x = log2(r6.x);
425
+ r6.x = (r6.x * r8.w);
426
+ r6.x = exp2(r6.x);
427
+ r6.x = (r8.y * r6.x);
428
+ r6.x = (r7.w * r6.x);
429
+ r6.x = (r2.x * r6.x);
430
+ r6.x = (r5.w * r6.x);
431
+ r5.w = (r5.w * r8.x);
432
+ let v_121 = fma(r0.xyz, r5.www, r6.xxx);
433
+ r6 = vec4<f32>(v_121.xyz, r6.w);
434
+ let v_122 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz);
435
+ r6 = vec4<f32>(v_122.xyz, r6.w);
436
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
437
+ if ((bitcast<u32>(r5.w) != 0u)) {
438
+ r10 = vec4<f32>(vec3<f32>(), r10.w);
439
+ r9 = vec4<f32>(vec3<f32>(), r9.w);
440
+ } else {
441
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
442
+ let v_123 = (v_17.xyz + cb3_3.tint_symbol_2[3u].xyz);
443
+ r9 = vec4<f32>(v_123.xyz, r9.w);
444
+ let v_124 = (v4.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
445
+ r10 = vec4<f32>(v_124.xyz, r10.w);
446
+ r8.z = dot(r10.xyz, cb3_3.tint_symbol_2[11u].xyz);
447
+ r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[19u].wwww)).z, 0.0f, 1.0f);
448
+ r8.z = (r8.z * cb3_3.tint_symbol_2[19u].w);
449
+ let v_125 = fma(cb3_3.tint_symbol_2[11u].xyz, r8.zzz, cb3_3.tint_symbol_2[3u].xyz);
450
+ r10 = vec4<f32>(v_125.xyz, r10.w);
451
+ let v_126 = (r10.xyz + v_17.xyz);
452
+ r10 = vec4<f32>(v_126.xyz, r10.w);
453
+ let v_127 = bitcast<vec3<u32>>(r8.yyy);
454
+ let v_128 = r9.xyz;
455
+ let v_129 = select(r10.xyz, v_128, (v_127 != vec3<u32>()));
456
+ r9 = vec4<f32>(v_129.xyz, r9.w);
457
+ r8.y = dot(r9.xyz, r9.xyz);
458
+ let v_130 = (r9.xyz + vec3<f32>(0.00000099999999747524f));
459
+ r9 = vec4<f32>(v_130.xyz, r9.w);
460
+ r8.z = dot(r9.xyz, r9.xyz);
461
+ r8.z = inverseSqrt(r8.z);
462
+ let v_131 = (r8.zzz * r9.xyz);
463
+ r9 = vec4<f32>(v_131.xyz, r9.w);
464
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
465
+ r8.z = ((-(cb3_3.tint_symbol_2[11u].wwww)).z + 1.0f);
466
+ r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[11u].w);
467
+ r8.y = (r8.y / r8.z);
468
+ let v_132 = -(cb3_3.tint_symbol_2[11u].xyzx);
469
+ r8.z = dot(r9.xyz, v_132.xyz);
470
+ r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).z, 0.0f, 1.0f);
471
+ let v_133 = dot(r9.xyz, r1.yzw);
472
+ r9.w = clamp(vec4<f32>(v_133, v_133, v_133, v_133).w, 0.0f, 1.0f);
473
+ r8.z = (r8.z * r9.w);
474
+ r9.w = (r8.y * r8.z);
475
+ let v_134 = (r9.www * cb3_3.tint_symbol_2[19u].xyz);
476
+ r10 = vec4<f32>(v_134.xyz, r10.w);
477
+ let v_135 = (r0.xyz * r10.xyz);
478
+ r10 = vec4<f32>(v_135.xyz, r10.w);
479
+ let v_136 = fma(r4.xyz, r3.www, r9.xyz);
480
+ r9 = vec4<f32>(v_136.xyz, r9.w);
481
+ r9.w = dot(r9.xyz, r9.xyz);
482
+ r9.w = inverseSqrt(r9.w);
483
+ let v_137 = (r9.www * r9.xyz);
484
+ r9 = vec4<f32>(v_137.xyz, r9.w);
485
+ let v_138 = dot(r9.xyz, r5.xyz);
486
+ r9.w = clamp(vec4<f32>(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f);
487
+ r9.w = ((-(r9.wwww)).w + 1.0f);
488
+ r10.w = (r9.w * r9.w);
489
+ r10.w = (r10.w * r10.w);
490
+ r9.w = (r9.w * r10.w);
491
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w);
492
+ let v_139 = dot(r9.xyz, r1.yzw);
493
+ r9.x = clamp(vec4<f32>(v_139, v_139, v_139, v_139).x, 0.0f, 1.0f);
494
+ r9.x = log2(r9.x);
495
+ r9.x = (r8.w * r9.x);
496
+ r9.x = exp2(r9.x);
497
+ r9.x = (r9.x * r9.w);
498
+ r8.z = (r8.z * r9.x);
499
+ r8.y = (r8.y * r8.z);
500
+ r8.y = (r7.w * r8.y);
501
+ let v_140 = (r8.yyy * cb3_3.tint_symbol_2[19u].xyz);
502
+ r9 = vec4<f32>(v_140.xyz, r9.w);
503
+ }
504
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
505
+ if ((bitcast<u32>(r8.y) != 0u)) {
506
+ r8.z = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
507
+ r8.y = bitcast<f32>((bitcast<u32>(r5.w) | bitcast<u32>(r8.y)));
508
+ let v_141 = bitcast<u32>(r8.z);
509
+ let v_142 = r8.y;
510
+ r5.w = select(r5.w, v_142, (v_141 != 0u));
511
+ if ((bitcast<u32>(r5.w) != 0u)) {
512
+ } else {
513
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
514
+ let v_143 = (v_17.xyz + cb3_3.tint_symbol_2[4u].xyz);
515
+ r11 = vec4<f32>(v_143.xyz, r11.w);
516
+ let v_144 = (v4.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
517
+ r12 = vec4<f32>(v_144.xyz, r12.w);
518
+ r8.z = dot(r12.xyz, cb3_3.tint_symbol_2[12u].xyz);
519
+ r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[20u].wwww)).z, 0.0f, 1.0f);
520
+ r8.z = (r8.z * cb3_3.tint_symbol_2[20u].w);
521
+ let v_145 = fma(cb3_3.tint_symbol_2[12u].xyz, r8.zzz, cb3_3.tint_symbol_2[4u].xyz);
522
+ r12 = vec4<f32>(v_145.xyz, r12.w);
523
+ let v_146 = (r12.xyz + v_17.xyz);
524
+ r12 = vec4<f32>(v_146.xyz, r12.w);
525
+ let v_147 = bitcast<vec3<u32>>(r8.yyy);
526
+ let v_148 = r11.xyz;
527
+ let v_149 = select(r12.xyz, v_148, (v_147 != vec3<u32>()));
528
+ r11 = vec4<f32>(v_149.xyz, r11.w);
529
+ r8.y = dot(r11.xyz, r11.xyz);
530
+ let v_150 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
531
+ r11 = vec4<f32>(v_150.xyz, r11.w);
532
+ r8.z = dot(r11.xyz, r11.xyz);
533
+ r8.z = inverseSqrt(r8.z);
534
+ let v_151 = (r8.zzz * r11.xyz);
535
+ r11 = vec4<f32>(v_151.xyz, r11.w);
536
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
537
+ r8.z = ((-(cb3_3.tint_symbol_2[12u].wwww)).z + 1.0f);
538
+ r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[12u].w);
539
+ r8.y = (r8.y / r8.z);
540
+ let v_152 = -(cb3_3.tint_symbol_2[12u].xyzx);
541
+ r8.z = dot(r11.xyz, v_152.xyz);
542
+ r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).z, 0.0f, 1.0f);
543
+ let v_153 = dot(r11.xyz, r1.yzw);
544
+ r9.w = clamp(vec4<f32>(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f);
545
+ r8.z = (r8.z * r9.w);
546
+ r9.w = (r8.y * r8.z);
547
+ let v_154 = (r9.www * cb3_3.tint_symbol_2[20u].xyz);
548
+ r12 = vec4<f32>(v_154.xyz, r12.w);
549
+ let v_155 = fma(r12.xyz, r0.xyz, r10.xyz);
550
+ r10 = vec4<f32>(v_155.xyz, r10.w);
551
+ let v_156 = fma(r4.xyz, r3.www, r11.xyz);
552
+ r11 = vec4<f32>(v_156.xyz, r11.w);
553
+ r9.w = dot(r11.xyz, r11.xyz);
554
+ r9.w = inverseSqrt(r9.w);
555
+ let v_157 = (r9.www * r11.xyz);
556
+ r11 = vec4<f32>(v_157.xyz, r11.w);
557
+ let v_158 = dot(r11.xyz, r5.xyz);
558
+ r9.w = clamp(vec4<f32>(v_158, v_158, v_158, v_158).w, 0.0f, 1.0f);
559
+ r9.w = ((-(r9.wwww)).w + 1.0f);
560
+ r10.w = (r9.w * r9.w);
561
+ r10.w = (r10.w * r10.w);
562
+ r9.w = (r9.w * r10.w);
563
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w);
564
+ let v_159 = dot(r11.xyz, r1.yzw);
565
+ r10.w = clamp(vec4<f32>(v_159, v_159, v_159, v_159).w, 0.0f, 1.0f);
566
+ r10.w = log2(r10.w);
567
+ r10.w = (r8.w * r10.w);
568
+ r10.w = exp2(r10.w);
569
+ r9.w = (r9.w * r10.w);
570
+ r8.z = (r8.z * r9.w);
571
+ r8.y = (r8.y * r8.z);
572
+ r8.y = (r7.w * r8.y);
573
+ let v_160 = fma(r8.yyy, cb3_3.tint_symbol_2[20u].xyz, r9.xyz);
574
+ r9 = vec4<f32>(v_160.xyz, r9.w);
575
+ }
576
+ } else {
577
+ r5.w = bitcast<f32>(v.tint_symbol_6[3i].x);
578
+ }
579
+ if ((bitcast<u32>(r5.w) != 0u)) {
580
+ r5.w = bitcast<f32>(v.tint_symbol_6[3i].x);
581
+ } else {
582
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
583
+ r5.w = bitcast<f32>((bitcast<u32>(r5.w) | bitcast<u32>(r8.y)));
584
+ if ((bitcast<u32>(r5.w) != 0u)) {
585
+ } else {
586
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
587
+ let v_161 = (v_17.xyz + cb3_3.tint_symbol_2[5u].xyz);
588
+ r11 = vec4<f32>(v_161.xyz, r11.w);
589
+ let v_162 = (v4.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
590
+ r12 = vec4<f32>(v_162.xyz, r12.w);
591
+ r8.z = dot(r12.xyz, cb3_3.tint_symbol_2[13u].xyz);
592
+ r8.z = clamp(((r8.zzzz / cb3_3.tint_symbol_2[21u].wwww)).z, 0.0f, 1.0f);
593
+ r8.z = (r8.z * cb3_3.tint_symbol_2[21u].w);
594
+ let v_163 = fma(cb3_3.tint_symbol_2[13u].xyz, r8.zzz, cb3_3.tint_symbol_2[5u].xyz);
595
+ r12 = vec4<f32>(v_163.xyz, r12.w);
596
+ let v_164 = (r12.xyz + v_17.xyz);
597
+ r12 = vec4<f32>(v_164.xyz, r12.w);
598
+ let v_165 = bitcast<vec3<u32>>(r8.yyy);
599
+ let v_166 = r11.xyz;
600
+ let v_167 = select(r12.xyz, v_166, (v_165 != vec3<u32>()));
601
+ r11 = vec4<f32>(v_167.xyz, r11.w);
602
+ r8.y = dot(r11.xyz, r11.xyz);
603
+ let v_168 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
604
+ r11 = vec4<f32>(v_168.xyz, r11.w);
605
+ r8.z = dot(r11.xyz, r11.xyz);
606
+ r8.z = inverseSqrt(r8.z);
607
+ let v_169 = (r8.zzz * r11.xyz);
608
+ r11 = vec4<f32>(v_169.xyz, r11.w);
609
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
610
+ r8.z = ((-(cb3_3.tint_symbol_2[13u].wwww)).z + 1.0f);
611
+ r8.z = fma(r8.z, r8.y, cb3_3.tint_symbol_2[13u].w);
612
+ r8.y = (r8.y / r8.z);
613
+ let v_170 = -(cb3_3.tint_symbol_2[13u].xyzx);
614
+ r8.z = dot(r11.xyz, v_170.xyz);
615
+ r8.z = clamp(fma(r8.zzzz, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).z, 0.0f, 1.0f);
616
+ let v_171 = dot(r11.xyz, r1.yzw);
617
+ r9.w = clamp(vec4<f32>(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f);
618
+ r8.z = (r8.z * r9.w);
619
+ r9.w = (r8.y * r8.z);
620
+ let v_172 = (r9.www * cb3_3.tint_symbol_2[21u].xyz);
621
+ r12 = vec4<f32>(v_172.xyz, r12.w);
622
+ let v_173 = fma(r12.xyz, r0.xyz, r10.xyz);
623
+ r10 = vec4<f32>(v_173.xyz, r10.w);
624
+ let v_174 = fma(r4.xyz, r3.www, r11.xyz);
625
+ r11 = vec4<f32>(v_174.xyz, r11.w);
626
+ r9.w = dot(r11.xyz, r11.xyz);
627
+ r9.w = inverseSqrt(r9.w);
628
+ let v_175 = (r9.www * r11.xyz);
629
+ r11 = vec4<f32>(v_175.xyz, r11.w);
630
+ let v_176 = dot(r11.xyz, r5.xyz);
631
+ r9.w = clamp(vec4<f32>(v_176, v_176, v_176, v_176).w, 0.0f, 1.0f);
632
+ r9.w = ((-(r9.wwww)).w + 1.0f);
633
+ r10.w = (r9.w * r9.w);
634
+ r10.w = (r10.w * r10.w);
635
+ r9.w = (r9.w * r10.w);
636
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r6.w);
637
+ let v_177 = dot(r11.xyz, r1.yzw);
638
+ r10.w = clamp(vec4<f32>(v_177, v_177, v_177, v_177).w, 0.0f, 1.0f);
639
+ r10.w = log2(r10.w);
640
+ r10.w = (r8.w * r10.w);
641
+ r10.w = exp2(r10.w);
642
+ r9.w = (r9.w * r10.w);
643
+ r8.z = (r8.z * r9.w);
644
+ r8.y = (r8.y * r8.z);
645
+ r8.y = (r7.w * r8.y);
646
+ let v_178 = fma(r8.yyy, cb3_3.tint_symbol_2[21u].xyz, r9.xyz);
647
+ r9 = vec4<f32>(v_178.xyz, r9.w);
648
+ }
649
+ }
650
+ if ((bitcast<u32>(r5.w) != 0u)) {
651
+ } else {
652
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
653
+ r5.w = bitcast<f32>((bitcast<u32>(r5.w) | bitcast<u32>(r8.y)));
654
+ if ((bitcast<u32>(r5.w) != 0u)) {
655
+ } else {
656
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
657
+ let v_179 = (v_17.xyz + cb3_3.tint_symbol_2[6u].xyz);
658
+ r11 = vec4<f32>(v_179.xyz, r11.w);
659
+ let v_180 = (v4.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
660
+ r12 = vec4<f32>(v_180.xyz, r12.w);
661
+ r8.y = dot(r12.xyz, cb3_3.tint_symbol_2[14u].xyz);
662
+ r8.y = clamp(((r8.yyyy / cb3_3.tint_symbol_2[22u].wwww)).y, 0.0f, 1.0f);
663
+ r8.y = (r8.y * cb3_3.tint_symbol_2[22u].w);
664
+ let v_181 = fma(cb3_3.tint_symbol_2[14u].xyz, r8.yyy, cb3_3.tint_symbol_2[6u].xyz);
665
+ r12 = vec4<f32>(v_181.xyz, r12.w);
666
+ let v_182 = (r12.xyz + v_17.xyz);
667
+ r12 = vec4<f32>(v_182.xyz, r12.w);
668
+ let v_183 = bitcast<vec3<u32>>(r5.www);
669
+ let v_184 = r11.xyz;
670
+ let v_185 = select(r12.xyz, v_184, (v_183 != vec3<u32>()));
671
+ r11 = vec4<f32>(v_185.xyz, r11.w);
672
+ r5.w = dot(r11.xyz, r11.xyz);
673
+ let v_186 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
674
+ r11 = vec4<f32>(v_186.xyz, r11.w);
675
+ r8.y = dot(r11.xyz, r11.xyz);
676
+ r8.y = inverseSqrt(r8.y);
677
+ let v_187 = (r8.yyy * r11.xyz);
678
+ r11 = vec4<f32>(v_187.xyz, r11.w);
679
+ r5.w = clamp(fma(-(r5.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
680
+ r8.y = ((-(cb3_3.tint_symbol_2[14u].wwww)).y + 1.0f);
681
+ r8.y = fma(r8.y, r5.w, cb3_3.tint_symbol_2[14u].w);
682
+ r5.w = (r5.w / r8.y);
683
+ let v_188 = -(cb3_3.tint_symbol_2[14u].xyzx);
684
+ r8.y = dot(r11.xyz, v_188.xyz);
685
+ r8.y = clamp(fma(r8.yyyy, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).y, 0.0f, 1.0f);
686
+ let v_189 = dot(r11.xyz, r1.yzw);
687
+ r8.z = clamp(vec4<f32>(v_189, v_189, v_189, v_189).z, 0.0f, 1.0f);
688
+ r8.y = (r8.y * r8.z);
689
+ r8.z = (r5.w * r8.y);
690
+ let v_190 = (r8.zzz * cb3_3.tint_symbol_2[22u].xyz);
691
+ r12 = vec4<f32>(v_190.xyz, r12.w);
692
+ let v_191 = fma(r12.xyz, r0.xyz, r10.xyz);
693
+ r10 = vec4<f32>(v_191.xyz, r10.w);
694
+ let v_192 = fma(r4.xyz, r3.www, r11.xyz);
695
+ r4 = vec4<f32>(v_192.xyz, r4.w);
696
+ r3.w = dot(r4.xyz, r4.xyz);
697
+ r3.w = inverseSqrt(r3.w);
698
+ let v_193 = (r3.www * r4.xyz);
699
+ r4 = vec4<f32>(v_193.xyz, r4.w);
700
+ let v_194 = dot(r4.xyz, r5.xyz);
701
+ r3.w = clamp(vec4<f32>(v_194, v_194, v_194, v_194).w, 0.0f, 1.0f);
702
+ r3.w = ((-(r3.wwww)).w + 1.0f);
703
+ r5.x = (r3.w * r3.w);
704
+ r5.x = (r5.x * r5.x);
705
+ r3.w = (r3.w * r5.x);
706
+ r3.w = fma(cb12_12.tint_symbol_4[0u].x, r3.w, r6.w);
707
+ let v_195 = dot(r4.xyz, r1.yzw);
708
+ r4.x = clamp(vec4<f32>(v_195, v_195, v_195, v_195).x, 0.0f, 1.0f);
709
+ r4.x = log2(r4.x);
710
+ r4.x = (r4.x * r8.w);
711
+ r4.x = exp2(r4.x);
712
+ r3.w = (r3.w * r4.x);
713
+ r3.w = (r8.y * r3.w);
714
+ r3.w = (r5.w * r3.w);
715
+ r3.w = (r7.w * r3.w);
716
+ let v_196 = fma(r3.www, cb3_3.tint_symbol_2[22u].xyz, r9.xyz);
717
+ r9 = vec4<f32>(v_196.xyz, r9.w);
718
+ }
719
+ }
720
+ r3.w = (r8.x * r8.x);
721
+ r2.x = (r2.x * r2.x);
722
+ let v_197 = (r9.xyz * r2.xxx);
723
+ r4 = vec4<f32>(v_197.xyz, r4.w);
724
+ let v_198 = fma(r3.www, r10.xyz, r4.xyz);
725
+ r4 = vec4<f32>(v_198.xyz, r4.w);
726
+ let v_199 = fma(r6.xyz, r4.www, r4.xyz);
727
+ r4 = vec4<f32>(v_199.xyz, r4.w);
728
+ r1.x = fma(v2.z, r1.x, cb3_3.tint_symbol_2[43u].w);
729
+ r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w);
730
+ r1.x = max(r1.x, 0.0f);
731
+ let v_200 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz);
732
+ r5 = vec4<f32>(v_200.xyz, r5.w);
733
+ r2.x = ((-(cb2_2.tint_symbol_1[16u].zzzz)).x + 1.0f);
734
+ let v_201 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz);
735
+ r6 = vec4<f32>(v_201.xyz, r6.w);
736
+ let v_202 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz);
737
+ r6 = vec4<f32>(v_202.xyz, r6.w);
738
+ let v_203 = fma(r5.xyz, r2.xxx, r6.xyz);
739
+ r5 = vec4<f32>(v_203.xyz, r5.w);
740
+ let v_204 = (r2.zzz * r5.xyz);
741
+ r5 = vec4<f32>(v_204.xyz, r5.w);
742
+ let v_205 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz);
743
+ r6 = vec4<f32>(v_205.xyz, r6.w);
744
+ r9.x = cb3_3.tint_symbol_2[46u].w;
745
+ r9.y = cb3_3.tint_symbol_2[47u].w;
746
+ r9.z = cb3_3.tint_symbol_2[48u].w;
747
+ let v_206 = dot(r9.xyz, r1.yzw);
748
+ r1.x = clamp(vec4<f32>(v_206, v_206, v_206, v_206).x, 0.0f, 1.0f);
749
+ let v_207 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r6.xyz);
750
+ r1 = vec4<f32>(v_207.xyz, r1.w);
751
+ let v_208 = fma(r1.xyz, r2.yyy, r5.xyz);
752
+ r1 = vec4<f32>(v_208.xyz, r1.w);
753
+ let v_209 = (r8.xxx * r1.xyz);
754
+ r1 = vec4<f32>(v_209.xyz, r1.w);
755
+ let v_210 = fma(r1.xyz, r0.xyz, r4.xyz);
756
+ r0 = vec4<f32>(v_210.xyz, r0.w);
757
+ r1.x = ((-(r8.xxxx)).x + 1.0f);
758
+ r1.y = max(r2.z, r2.y);
759
+ let v_211 = (r1.yyy * r3.xyz);
760
+ r1 = vec4<f32>(r1.x, v_211.xyz);
761
+ r2.x = clamp(((r2.wwww * vec4<f32>(0.00177619897294789553f))).x, 0.0f, 1.0f);
762
+ let v_212 = (r1.yzw * r2.xxx);
763
+ r2 = vec4<f32>(v_212.xyz, r2.w);
764
+ let v_213 = (r2.xyz * vec3<f32>(0.68169009685516357422f));
765
+ r2 = vec4<f32>(v_213.xyz, r2.w);
766
+ let v_214 = fma(r1.yzw, vec3<f32>(0.31830990314483642578f), r2.xyz);
767
+ r1 = vec4<f32>(r1.x, v_214.xyz);
768
+ let v_215 = fma(r1.yzw, r1.xxx, r0.xyz);
769
+ r0 = vec4<f32>(v_215.xyz, r0.w);
770
+ r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
771
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
772
+ r1.x = dot(r7.xyz, r7.xyz);
773
+ r1.y = sqrt(r1.x);
774
+ let v_216 = -(cb3_3.tint_symbol_2[50u].xxxx);
775
+ r1.z = (r1.y + v_216.z);
776
+ r1.z = max(r1.z, 0.0f);
777
+ r1.y = (r1.z / r1.y);
778
+ r1.y = (r1.y * r7.z);
779
+ r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z);
780
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y)));
781
+ r2.x = (r1.w * -1.44269502162933349609f);
782
+ r2.x = exp2(r2.x);
783
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
784
+ r1.w = (r2.x / r1.w);
785
+ let v_217 = bitcast<u32>(r1.y);
786
+ r1.y = select(1.0f, r1.w, (v_217 != 0u));
787
+ r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w);
788
+ r1.y = (r1.y * r1.w);
789
+ r1.y = min(r1.y, 1.0f);
790
+ r1.y = (r1.y * 1.44269502162933349609f);
791
+ r1.y = exp2(r1.y);
792
+ r1.y = min(r1.y, 1.0f);
793
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
794
+ r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y);
795
+ r1.x = inverseSqrt(r1.x);
796
+ let v_218 = (r1.xxx * r7.xyz);
797
+ r2 = vec4<f32>(v_218.xyz, r2.w);
798
+ let v_219 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
799
+ r1.x = clamp(vec4<f32>(v_219, v_219, v_219, v_219).x, 0.0f, 1.0f);
800
+ r1.x = log2(r1.x);
801
+ r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w);
802
+ r1.x = exp2(r1.x);
803
+ let v_220 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
804
+ r2.x = clamp(vec4<f32>(v_220, v_220, v_220, v_220).x, 0.0f, 1.0f);
805
+ r2.x = log2(r2.x);
806
+ r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w);
807
+ r2.x = exp2(r2.x);
808
+ r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f);
809
+ r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y);
810
+ let v_221 = -(cb3_3.tint_symbol_2[52u].xxxx);
811
+ r2.y = (r1.z + v_221.y);
812
+ r2.y = max(r2.y, 0.0f);
813
+ r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x);
814
+ r2.y = (r2.y * 1.44269502162933349609f);
815
+ r2.y = exp2(r2.y);
816
+ r2.y = ((-(r2.yyyy)).y + 1.0f);
817
+ r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f);
818
+ let v_222 = -(cb3_3.tint_symbol_2[51u].zzzz);
819
+ r1.z = (r1.z * v_222.z);
820
+ r1.z = (r1.z * 1.44269502162933349609f);
821
+ r1.z = exp2(r1.z);
822
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
823
+ let v_223 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz);
824
+ r2 = vec4<f32>(r2.x, v_223.xyz);
825
+ let v_224 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz);
826
+ r2 = vec4<f32>(r2.x, v_224.xyz);
827
+ let v_225 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz);
828
+ r3 = vec4<f32>(v_225.xyz, r3.w);
829
+ let v_226 = fma(r2.xxx, r3.xyz, r2.yzw);
830
+ r2 = vec4<f32>(v_226.xyz, r2.w);
831
+ let v_227 = -(cb3_3.tint_symbol_2[57u].xyzx);
832
+ let v_228 = (r2.xyz + v_227.xyz);
833
+ r2 = vec4<f32>(v_228.xyz, r2.w);
834
+ let v_229 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
835
+ r2 = vec4<f32>(v_229.xyz, r2.w);
836
+ r3.x = cb3_3.tint_symbol_2[55u].w;
837
+ r3.y = cb3_3.tint_symbol_2[56u].w;
838
+ r3.z = cb3_3.tint_symbol_2[57u].w;
839
+ let v_230 = ((-(r2.xyzx)).xyz + r3.xyz);
840
+ r3 = vec4<f32>(v_230.xyz, r3.w);
841
+ let v_231 = fma(r1.yyy, r3.xyz, r2.xyz);
842
+ r1 = vec4<f32>(v_231.xyz, r1.w);
843
+ r2.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
844
+ if ((bitcast<u32>(r2.x) != 0u)) {
845
+ let v_232 = (v5.xy * cb2_2.tint_symbol_1[18u].zw);
846
+ r2 = vec4<f32>(v_232.xy, r2.zw);
847
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
848
+ r2.x = (r2.x + -1.0f);
849
+ r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4<f32>(1.0f)).x, 0.0f, 1.0f);
850
+ } else {
851
+ r2.x = 1.0f;
852
+ }
853
+ let v_233 = -(r0.xyzx);
854
+ let v_234 = fma(r1.xyz, r2.xxx, v_233.xyz);
855
+ r1 = vec4<f32>(v_234.xyz, r1.w);
856
+ let v_235 = fma(r1.www, r1.xyz, r0.xyz);
857
+ r1 = vec4<f32>(v_235.xyz, r1.w);
858
+ } else {
859
+ r1.w = dot(r7.xyz, r7.xyz);
860
+ r2.x = sqrt(r1.w);
861
+ let v_236 = -(cb3_3.tint_symbol_2[50u].xxxx);
862
+ r2.y = (r2.x + v_236.y);
863
+ r2.y = max(r2.y, 0.0f);
864
+ r2.x = (r2.y / r2.x);
865
+ r2.x = (r2.x * r7.z);
866
+ r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z);
867
+ r2.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x)));
868
+ r2.w = (r2.z * -1.44269502162933349609f);
869
+ r2.w = exp2(r2.w);
870
+ r2.w = ((-(r2.wwww)).w + 1.0f);
871
+ r2.z = (r2.w / r2.z);
872
+ let v_237 = bitcast<u32>(r2.x);
873
+ r2.x = select(1.0f, r2.z, (v_237 != 0u));
874
+ r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w);
875
+ r2.x = (r2.x * r2.z);
876
+ r2.x = min(r2.x, 1.0f);
877
+ r2.x = (r2.x * 1.44269502162933349609f);
878
+ r2.x = exp2(r2.x);
879
+ r2.x = min(r2.x, 1.0f);
880
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
881
+ r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y);
882
+ r1.w = inverseSqrt(r1.w);
883
+ let v_238 = (r1.www * r7.xyz);
884
+ r3 = vec4<f32>(v_238.xyz, r3.w);
885
+ let v_239 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
886
+ r1.w = clamp(vec4<f32>(v_239, v_239, v_239, v_239).w, 0.0f, 1.0f);
887
+ r1.w = log2(r1.w);
888
+ r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w);
889
+ r1.w = exp2(r1.w);
890
+ let v_240 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
891
+ r2.w = clamp(vec4<f32>(v_240, v_240, v_240, v_240).w, 0.0f, 1.0f);
892
+ r2.w = log2(r2.w);
893
+ r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w);
894
+ r2.w = exp2(r2.w);
895
+ r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
896
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y);
897
+ let v_241 = -(cb3_3.tint_symbol_2[52u].xxxx);
898
+ r3.x = (r2.y + v_241.x);
899
+ r3.x = max(r3.x, 0.0f);
900
+ r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x);
901
+ r3.x = (r3.x * 1.44269502162933349609f);
902
+ r3.x = exp2(r3.x);
903
+ r3.x = ((-(r3.xxxx)).x + 1.0f);
904
+ r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f);
905
+ let v_242 = -(cb3_3.tint_symbol_2[51u].zzzz);
906
+ r2.y = (r2.y * v_242.y);
907
+ r2.y = (r2.y * 1.44269502162933349609f);
908
+ r2.y = exp2(r2.y);
909
+ r2.y = ((-(r2.yyyy)).y + 1.0f);
910
+ let v_243 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
911
+ r3 = vec4<f32>(v_243.xyz, r3.w);
912
+ let v_244 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
913
+ r3 = vec4<f32>(v_244.xyz, r3.w);
914
+ let v_245 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
915
+ r4 = vec4<f32>(v_245.xyz, r4.w);
916
+ let v_246 = fma(r2.www, r4.xyz, r3.xyz);
917
+ r3 = vec4<f32>(v_246.xyz, r3.w);
918
+ let v_247 = -(cb3_3.tint_symbol_2[57u].xyzx);
919
+ let v_248 = (r3.xyz + v_247.xyz);
920
+ r3 = vec4<f32>(v_248.xyz, r3.w);
921
+ let v_249 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
922
+ r3 = vec4<f32>(v_249.xyz, r3.w);
923
+ r4.x = cb3_3.tint_symbol_2[55u].w;
924
+ r4.y = cb3_3.tint_symbol_2[56u].w;
925
+ r4.z = cb3_3.tint_symbol_2[57u].w;
926
+ let v_250 = ((-(r3.xyzx)).xyz + r4.xyz);
927
+ r4 = vec4<f32>(v_250.xyz, r4.w);
928
+ let v_251 = fma(r2.xxx, r4.xyz, r3.xyz);
929
+ r2 = vec4<f32>(v_251.xy, r2.z, v_251.z);
930
+ let v_252 = ((-(r0.xyxz)).xyw + r2.xyw);
931
+ r2 = vec4<f32>(v_252.xy, r2.z, v_252.z);
932
+ let v_253 = fma(r2.zzz, r2.xyw, r0.xyz);
933
+ r1 = vec4<f32>(v_253.xyz, r1.w);
934
+ }
935
+ let v_254 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
936
+ o0 = vec4<f32>(v_254.xyz, o0.w);
937
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (0.30000001192092895508f < r0.w)));
938
+ r0.x = bitcast<f32>((bitcast<u32>(r0.x) & 1065353216u));
939
+ o1 = (r0.x * v1.z);
940
+ o0.w = r0.w;
941
+ o2 = r0.x;
942
+ }
943
+
944
+ struct tint_symbol_8 {
945
+ @location(0u)
946
+ o0 : vec4<f32>,
947
+ @location(1u)
948
+ o1 : f32,
949
+ @location(2u)
950
+ o2 : f32,
951
+ }
952
+
953
+ @fragment
954
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @builtin(position) v_255 : vec4<f32>) -> tint_symbol_8 {
955
+ main_inner(v0, v1, v2, v3, v4, v_255);
956
+ return tint_symbol_8(o0, o1, o2);
957
+ }
b/8b0b5899ed/shaders/00c5eac137500fba.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [4294967295, 2, 3, 1]
b/8b0b5899ed/shaders/00c5eac137500fba.wgsl ADDED
@@ -0,0 +1,660 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ enable clip_distances;
2
+ diagnostic(off, derivative_uniformity);
3
+
4
+ var<private> r0 : vec4<f32>;
5
+
6
+ var<private> r1 : vec4<f32>;
7
+
8
+ var<private> r2 : vec4<f32>;
9
+
10
+ var<private> r3 : vec4<f32>;
11
+
12
+ var<private> r4 : vec4<f32>;
13
+
14
+ var<private> r5 : vec4<f32>;
15
+
16
+ var<private> r6 : vec4<f32>;
17
+
18
+ var<private> r7 : vec4<f32>;
19
+
20
+ var<private> r8 : vec4<f32>;
21
+
22
+ var<private> r9 : vec4<f32>;
23
+
24
+ struct cb1_struct {
25
+ tint_symbol : array<vec4<f32>, 1u>,
26
+ }
27
+
28
+ @group(0u) @binding(13u) var<uniform> cb13_13 : cb1_struct;
29
+
30
+ struct cb16_struct {
31
+ tint_symbol_1 : array<vec4<f32>, 16u>,
32
+ }
33
+
34
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
35
+
36
+ struct cb1_struct_1 {
37
+ tint_symbol_2 : array<vec4<f32>, 1u>,
38
+ }
39
+
40
+ @group(0u) @binding(0u) var<uniform> cb0_0 : cb1_struct_1;
41
+
42
+ struct cb17_struct {
43
+ tint_symbol_3 : array<vec4<f32>, 17u>,
44
+ }
45
+
46
+ @group(0u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
47
+
48
+ struct cb59_struct {
49
+ tint_symbol_4 : array<vec4<f32>, 59u>,
50
+ }
51
+
52
+ @group(0u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
53
+
54
+ struct cb15_struct {
55
+ tint_symbol_5 : array<vec4<f32>, 15u>,
56
+ }
57
+
58
+ @group(0u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
59
+
60
+ struct cb1_struct_2 {
61
+ tint_symbol_6 : array<vec4<f32>, 1u>,
62
+ }
63
+
64
+ @group(0u) @binding(7u) var<uniform> cb7_7 : cb1_struct_2;
65
+
66
+ struct cb5_struct {
67
+ tint_symbol_7 : array<vec4<f32>, 5u>,
68
+ }
69
+
70
+ @group(0u) @binding(9u) var<uniform> cb9_9 : cb5_struct;
71
+
72
+ struct cb4_struct {
73
+ tint_symbol_8 : array<vec4<f32>, 4u>,
74
+ }
75
+
76
+ @group(0u) @binding(8u) var<uniform> cb8_8 : cb4_struct;
77
+
78
+ @group(0u) @binding(31u) var s15 : sampler_comparison;
79
+
80
+ @group(0u) @binding(47u) var t15 : texture_depth_2d;
81
+
82
+ var<private> o0 : vec4<f32>;
83
+
84
+ var<private> o1 : vec4<f32>;
85
+
86
+ var<private> o2 : vec4<f32>;
87
+
88
+ var<private> o3 : vec4<f32>;
89
+
90
+ var<private> o4 : vec4<f32>;
91
+
92
+ var<private> o5 : vec4<f32>;
93
+
94
+ var<private> o6 : vec4<f32>;
95
+
96
+ var<private> o7 : vec4<f32>;
97
+
98
+ var<private> o8 : vec4<f32>;
99
+
100
+ var<private> o9 : vec4<f32>;
101
+
102
+ var<private> o10 : vec4<f32>;
103
+
104
+ var<private> o11 : vec4<f32>;
105
+
106
+ var<private> o12 : array<f32, 4u>;
107
+
108
+ var<private> v : vec4<f32>;
109
+
110
+ var<private> x0 : array<vec4<f32>, 3u>;
111
+
112
+ var<private> x1 : array<vec4<f32>, 3u>;
113
+
114
+ var<private> x2 : array<vec4<f32>, 3u>;
115
+
116
+ var<private> x3 : array<vec4<f32>, 3u>;
117
+
118
+ var<private> x4 : array<vec4<f32>, 4u>;
119
+
120
+ var<private> x5 : array<vec4<f32>, 1u>;
121
+
122
+ struct tint_symbol_10 {
123
+ tint_symbol_9 : array<vec4<u32>, 4u>,
124
+ }
125
+
126
+ @group(0u) @binding(15u) var<uniform> v_1 : tint_symbol_10;
127
+
128
+ fn main_inner(v0 : vec3<f32>, v1 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v7 : vec4<f32>, v8 : vec4<f32>, v9 : vec4<f32>, v10 : vec4<f32>, v11 : vec4<f32>, v13 : vec3<f32>) {
129
+ r0 = vec4<f32>(((v0.xz + v7.xz)).xy, r0.zw);
130
+ r1.x = v6.w;
131
+ r1.y = v8.w;
132
+ let v_2 = (r0.xy + r1.xy);
133
+ r0 = vec4<f32>(v_2.xy, r0.zw);
134
+ let v_3 = ((-(r1.xxxy)).zw + v8.xz);
135
+ r0 = vec4<f32>(r0.xy, v_3.xy);
136
+ r1 = vec4<f32>(((v6.xz + (-(v7.xzxx)).xy)).xy, r1.zw);
137
+ let v_4 = (r0.zw + r1.xy);
138
+ r1 = vec4<f32>(r1.xy, v_4.xy);
139
+ let v_5 = fma(r1.zw, vec2<f32>(0.5f), r0.xy);
140
+ r2 = vec4<f32>(v_5.xy, r2.zw);
141
+ r1 = vec4<f32>(r1.xy, (((-(v10.xxxw)).zw + v10.yz)).xy);
142
+ r3 = vec4<f32>((((-(v11.xwxx)).xy + v11.yz)).xy, r3.zw);
143
+ x0[0u].x = v9.x;
144
+ x0[1u].x = 0.5f;
145
+ x0[2u].x = v9.y;
146
+ x1[0u].x = v9.z;
147
+ x1[1u].x = 0.5f;
148
+ x1[2u].x = v9.w;
149
+ x2[0u].x = v9.x;
150
+ x2[1u].x = 0.5f;
151
+ x2[2u].x = v9.y;
152
+ x3[0u].x = v9.z;
153
+ x3[1u].x = 0.5f;
154
+ x3[2u].x = v9.w;
155
+ let v_6 = v13.xy;
156
+ let v_7 = max(v_6, vec2<f32>(-2147483648.0f));
157
+ let v_8 = bitcast<vec2<f32>>(select(select(vec2<i32>(v_7), vec2<i32>(2147483647i), (v_7 >= vec2<f32>(2147483648.0f))), vec2<i32>(), !((v_6 == v_6))));
158
+ r3 = vec4<f32>(r3.xy, v_8.xy);
159
+ r2.w = x0[bitcast<i32>(r3.z)].x;
160
+ r4.x = x1[bitcast<i32>(r3.w)].x;
161
+ let v_9 = fma(r0.zw, r2.ww, r0.xy);
162
+ r0 = vec4<f32>(v_9.xy, r0.zw);
163
+ let v_10 = fma(r1.xy, r4.xx, r0.xy);
164
+ r0 = vec4<f32>(v_10.xy, r0.zw);
165
+ o1.x = fma(r2.w, r1.z, v10.x);
166
+ o1.y = fma(r4.x, r1.w, v10.w);
167
+ o1.z = fma(r2.w, r3.x, v11.x);
168
+ o1.w = fma(r4.x, r3.y, v11.w);
169
+ r0.w = x2[bitcast<i32>(r3.z)].x;
170
+ o2.x = fma(r0.w, r1.z, v10.x);
171
+ r0.w = x3[bitcast<i32>(r3.w)].x;
172
+ o2.y = fma(r0.w, r1.w, v10.w);
173
+ o3.x = clamp(v3.x, 0.0f, 1.0f);
174
+ r0.z = 1.0f;
175
+ r1.x = dot(r0.xyz, cb9_9.tint_symbol_7[2u].xyz);
176
+ r1.y = dot(r0.xyz, cb9_9.tint_symbol_7[3u].xyz);
177
+ r1.z = dot(r0.xyz, cb9_9.tint_symbol_7[4u].xyz);
178
+ let v_11 = (r1.xyz * cb7_7.tint_symbol_6[0u].xxx);
179
+ r3 = vec4<f32>(v_11.xyz, r3.w);
180
+ let v_12 = fma(r1.xyz, cb7_7.tint_symbol_6[0u].xxx, cb1_1.tint_symbol_1[15u].xyz);
181
+ r1 = vec4<f32>(v_12.xyz, r1.w);
182
+ r2.z = 1.0f;
183
+ r4.x = dot(r2.xyz, cb9_9.tint_symbol_7[2u].xyz);
184
+ r4.y = dot(r2.xyz, cb9_9.tint_symbol_7[3u].xyz);
185
+ r4.z = dot(r2.xyz, cb9_9.tint_symbol_7[4u].xyz);
186
+ let v_13 = fma(r4.xyz, cb7_7.tint_symbol_6[0u].xxx, cb1_1.tint_symbol_1[15u].xyz);
187
+ r2 = vec4<f32>(v_13.xyz, r2.w);
188
+ let v_14 = -(r2.xyzx);
189
+ let v_15 = (r1.xyz + v_14.xyz);
190
+ r4 = vec4<f32>(v_15.xyz, r4.w);
191
+ r0.w = dot(r4.xyz, r4.xyz);
192
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (r0.w < 0.00100000004749745131f)));
193
+ r0.w = inverseSqrt(r0.w);
194
+ let v_16 = (r0.www * r4.xyz);
195
+ r4 = vec4<f32>(v_16.xyz, r4.w);
196
+ let v_17 = -(cb1_1.tint_symbol_1[14u].xyzx);
197
+ let v_18 = bitcast<vec3<u32>>(r1.www);
198
+ let v_19 = select(r4.xyz, v_17.xyz, (v_18 != vec3<u32>()));
199
+ r4 = vec4<f32>(v_19.xyz, r4.w);
200
+ let v_20 = (r4.xyz + cb1_1.tint_symbol_1[14u].xyz);
201
+ r4 = vec4<f32>(v_20.xyz, r4.w);
202
+ let v_21 = fma(v5.xxx, r4.xyz, v_17.xyz);
203
+ r4 = vec4<f32>(v_21.xyz, r4.w);
204
+ r0.w = dot(r4.xyz, r4.xyz);
205
+ r0.w = inverseSqrt(r0.w);
206
+ let v_22 = (r0.www * r4.xyz);
207
+ r4 = vec4<f32>(v_22.xy, r4.z, v_22.z);
208
+ r5 = vec4<f32>(((v1.xyz * v1.xyz)).xyz, r5.w);
209
+ let v_23 = (cb2_2.tint_symbol_3[15u].zy * cb8_8.tint_symbol_8[2u].zz);
210
+ r6 = vec4<f32>(v_23.xy, r6.zw);
211
+ r1.w = clamp(((cb2_2.tint_symbol_3[16u].zzzz + cb3_3.tint_symbol_4[49u].wwww)).w, 0.0f, 1.0f);
212
+ r1.w = (r1.w * r6.y);
213
+ r2.w = clamp(fma(r1.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
214
+ r2.w = sqrt(r2.w);
215
+ r2.w = fma((-(r2.wwww)).w, cb6_6.tint_symbol_5[3u].z, 1.0f);
216
+ r2.w = (r2.w * cb8_8.tint_symbol_8[2u].y);
217
+ let v_24 = -(cb3_3.tint_symbol_4[0u].xyzx);
218
+ let v_25 = dot(r4.xyw, v_24.xyz);
219
+ r3.w = clamp(vec4<f32>(v_25, v_25, v_25, v_25).w, 0.0f, 1.0f);
220
+ r3.w = (r3.w + cb13_13.tint_symbol[0u].x);
221
+ r5.w = (cb13_13.tint_symbol[0u].x + 1.0f);
222
+ r5.w = (r5.w * r5.w);
223
+ r3.w = clamp(((r3.wwww / r5.wwww)).w, 0.0f, 1.0f);
224
+ let v_26 = (r3.www * r5.xyz);
225
+ r6 = vec4<f32>(r6.x, v_26.xyz);
226
+ let v_27 = (r6.yzw * cb3_3.tint_symbol_4[1u].xyz);
227
+ r6 = vec4<f32>(r6.x, v_27.xyz);
228
+ o9 = ((r2.www * r6.yzw)).xyzx;
229
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_4[2u].x))));
230
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_4[19u].w == 0.0f)));
231
+ let v_28 = ((-(r1.xxyz)).yzw + cb3_3.tint_symbol_4[3u].xyz);
232
+ r6 = vec4<f32>(r6.x, v_28.xyz);
233
+ let v_29 = -(cb3_3.tint_symbol_4[3u].xyzx);
234
+ let v_30 = (r1.xyz + v_29.xyz);
235
+ r7 = vec4<f32>(v_30.xyz, r7.w);
236
+ r7.x = dot(r7.xyz, cb3_3.tint_symbol_4[11u].xyz);
237
+ r7.x = clamp(((r7.xxxx / cb3_3.tint_symbol_4[19u].wwww)).x, 0.0f, 1.0f);
238
+ r7.x = (r7.x * cb3_3.tint_symbol_4[19u].w);
239
+ let v_31 = fma(cb3_3.tint_symbol_4[11u].xyz, r7.xxx, cb3_3.tint_symbol_4[3u].xyz);
240
+ r7 = vec4<f32>(v_31.xyz, r7.w);
241
+ let v_32 = ((-(r1.xyzx)).xyz + r7.xyz);
242
+ r7 = vec4<f32>(v_32.xyz, r7.w);
243
+ let v_33 = bitcast<vec3<u32>>(r3.www);
244
+ let v_34 = r6.yzw;
245
+ let v_35 = select(r7.xyz, v_34, (v_33 != vec3<u32>()));
246
+ r6 = vec4<f32>(r6.x, v_35.xyz);
247
+ r3.w = dot(r6.yzw, r6.yzw);
248
+ let v_36 = (r6.yzw + vec3<f32>(0.00000099999999747524f));
249
+ r6 = vec4<f32>(r6.x, v_36.xyz);
250
+ r7.x = dot(r6.yzw, r6.yzw);
251
+ r7.x = inverseSqrt(r7.x);
252
+ let v_37 = (r6.yzw * r7.xxx);
253
+ r6 = vec4<f32>(r6.x, v_37.xyz);
254
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[3u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
255
+ r7.x = ((-(cb3_3.tint_symbol_4[11u].wwww)).x + 1.0f);
256
+ r7.x = fma(r7.x, r3.w, cb3_3.tint_symbol_4[11u].w);
257
+ r3.w = (r3.w / r7.x);
258
+ let v_38 = -(cb3_3.tint_symbol_4[11u].xyzx);
259
+ r7.x = dot(r6.yzw, v_38.xyz);
260
+ r7.x = clamp(fma(r7.xxxx, cb3_3.tint_symbol_4[27u].xxxx, cb3_3.tint_symbol_4[35u].xxxx).x, 0.0f, 1.0f);
261
+ let v_39 = dot(r6.yzw, r4.xyw);
262
+ r6.y = clamp(vec4<f32>(v_39, v_39, v_39, v_39).y, 0.0f, 1.0f);
263
+ r6.y = (r6.y + cb13_13.tint_symbol[0u].x);
264
+ r6.y = clamp(((r6.yyyy / r5.wwww)).y, 0.0f, 1.0f);
265
+ r6.y = (r7.x * r6.y);
266
+ r3.w = (r3.w * r6.y);
267
+ let v_40 = (r3.www * cb3_3.tint_symbol_4[19u].xyz);
268
+ r6 = vec4<f32>(r6.x, v_40.xyz);
269
+ let v_41 = (r5.xyz * r6.yzw);
270
+ r6 = vec4<f32>(r6.x, v_41.xyz);
271
+ let v_42 = bitcast<vec3<u32>>(r2.www);
272
+ let v_43 = select(r6.yzw, vec3<f32>(), (v_42 != vec3<u32>()));
273
+ r6 = vec4<f32>(r6.x, v_43.xyz);
274
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_4[2u].x))));
275
+ if ((bitcast<u32>(r3.w) != 0u)) {
276
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_4[2u].x))));
277
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
278
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_4[20u].w == 0.0f)));
279
+ let v_44 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[4u].xyz);
280
+ r7 = vec4<f32>(v_44.xyz, r7.w);
281
+ let v_45 = -(cb3_3.tint_symbol_4[4u].xyzx);
282
+ let v_46 = (r1.xyz + v_45.xyz);
283
+ r8 = vec4<f32>(v_46.xyz, r8.w);
284
+ r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[12u].xyz);
285
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[20u].wwww)).w, 0.0f, 1.0f);
286
+ r7.w = (r7.w * cb3_3.tint_symbol_4[20u].w);
287
+ let v_47 = fma(cb3_3.tint_symbol_4[12u].xyz, r7.www, cb3_3.tint_symbol_4[4u].xyz);
288
+ r8 = vec4<f32>(v_47.xyz, r8.w);
289
+ let v_48 = ((-(r1.xyzx)).xyz + r8.xyz);
290
+ r8 = vec4<f32>(v_48.xyz, r8.w);
291
+ let v_49 = bitcast<vec3<u32>>(r3.www);
292
+ let v_50 = r7.xyz;
293
+ let v_51 = select(r8.xyz, v_50, (v_49 != vec3<u32>()));
294
+ r7 = vec4<f32>(v_51.xyz, r7.w);
295
+ r3.w = dot(r7.xyz, r7.xyz);
296
+ let v_52 = (r7.xyz + vec3<f32>(0.00000099999999747524f));
297
+ r7 = vec4<f32>(v_52.xyz, r7.w);
298
+ r7.w = dot(r7.xyz, r7.xyz);
299
+ r7.w = inverseSqrt(r7.w);
300
+ let v_53 = (r7.www * r7.xyz);
301
+ r7 = vec4<f32>(v_53.xyz, r7.w);
302
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[4u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
303
+ r7.w = ((-(cb3_3.tint_symbol_4[12u].wwww)).w + 1.0f);
304
+ r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[12u].w);
305
+ r3.w = (r3.w / r7.w);
306
+ let v_54 = -(cb3_3.tint_symbol_4[12u].xyzx);
307
+ r7.w = dot(r7.xyz, v_54.xyz);
308
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[28u].xxxx, cb3_3.tint_symbol_4[36u].xxxx).w, 0.0f, 1.0f);
309
+ let v_55 = dot(r7.xyz, r4.xyw);
310
+ r7.x = clamp(vec4<f32>(v_55, v_55, v_55, v_55).x, 0.0f, 1.0f);
311
+ r7.x = (r7.x + cb13_13.tint_symbol[0u].x);
312
+ r7.x = clamp(((r7.xxxx / r5.wwww)).x, 0.0f, 1.0f);
313
+ r7.x = (r7.w * r7.x);
314
+ r3.w = (r3.w * r7.x);
315
+ let v_56 = (r3.www * cb3_3.tint_symbol_4[20u].xyz);
316
+ r7 = vec4<f32>(v_56.xyz, r7.w);
317
+ let v_57 = fma(r7.xyz, r5.xyz, r6.yzw);
318
+ r7 = vec4<f32>(v_57.xyz, r7.w);
319
+ let v_58 = bitcast<vec3<u32>>(r2.www);
320
+ let v_59 = r6.yzw;
321
+ let v_60 = select(r7.xyz, v_59, (v_58 != vec3<u32>()));
322
+ r6 = vec4<f32>(r6.x, v_60.xyz);
323
+ } else {
324
+ r2.w = bitcast<f32>(v_1.tint_symbol_9[0i].x);
325
+ }
326
+ if ((bitcast<u32>(r2.w) != 0u)) {
327
+ r2.w = bitcast<f32>(v_1.tint_symbol_9[0i].x);
328
+ } else {
329
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_4[2u].x))));
330
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
331
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_4[21u].w == 0.0f)));
332
+ let v_61 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[5u].xyz);
333
+ r7 = vec4<f32>(v_61.xyz, r7.w);
334
+ let v_62 = -(cb3_3.tint_symbol_4[5u].xyzx);
335
+ let v_63 = (r1.xyz + v_62.xyz);
336
+ r8 = vec4<f32>(v_63.xyz, r8.w);
337
+ r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[13u].xyz);
338
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[21u].wwww)).w, 0.0f, 1.0f);
339
+ r7.w = (r7.w * cb3_3.tint_symbol_4[21u].w);
340
+ let v_64 = fma(cb3_3.tint_symbol_4[13u].xyz, r7.www, cb3_3.tint_symbol_4[5u].xyz);
341
+ r8 = vec4<f32>(v_64.xyz, r8.w);
342
+ let v_65 = ((-(r1.xyzx)).xyz + r8.xyz);
343
+ r8 = vec4<f32>(v_65.xyz, r8.w);
344
+ let v_66 = bitcast<vec3<u32>>(r3.www);
345
+ let v_67 = r7.xyz;
346
+ let v_68 = select(r8.xyz, v_67, (v_66 != vec3<u32>()));
347
+ r7 = vec4<f32>(v_68.xyz, r7.w);
348
+ r3.w = dot(r7.xyz, r7.xyz);
349
+ let v_69 = (r7.xyz + vec3<f32>(0.00000099999999747524f));
350
+ r7 = vec4<f32>(v_69.xyz, r7.w);
351
+ r7.w = dot(r7.xyz, r7.xyz);
352
+ r7.w = inverseSqrt(r7.w);
353
+ let v_70 = (r7.www * r7.xyz);
354
+ r7 = vec4<f32>(v_70.xyz, r7.w);
355
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[5u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
356
+ r7.w = ((-(cb3_3.tint_symbol_4[13u].wwww)).w + 1.0f);
357
+ r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[13u].w);
358
+ r3.w = (r3.w / r7.w);
359
+ let v_71 = -(cb3_3.tint_symbol_4[13u].xyzx);
360
+ r7.w = dot(r7.xyz, v_71.xyz);
361
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[29u].xxxx, cb3_3.tint_symbol_4[37u].xxxx).w, 0.0f, 1.0f);
362
+ let v_72 = dot(r7.xyz, r4.xyw);
363
+ r7.x = clamp(vec4<f32>(v_72, v_72, v_72, v_72).x, 0.0f, 1.0f);
364
+ r7.x = (r7.x + cb13_13.tint_symbol[0u].x);
365
+ r7.x = clamp(((r7.xxxx / r5.wwww)).x, 0.0f, 1.0f);
366
+ r7.x = (r7.w * r7.x);
367
+ r3.w = (r3.w * r7.x);
368
+ let v_73 = (r3.www * cb3_3.tint_symbol_4[21u].xyz);
369
+ r7 = vec4<f32>(v_73.xyz, r7.w);
370
+ let v_74 = fma(r7.xyz, r5.xyz, r6.yzw);
371
+ r7 = vec4<f32>(v_74.xyz, r7.w);
372
+ let v_75 = bitcast<vec3<u32>>(r2.www);
373
+ let v_76 = r6.yzw;
374
+ let v_77 = select(r7.xyz, v_76, (v_75 != vec3<u32>()));
375
+ r6 = vec4<f32>(r6.x, v_77.xyz);
376
+ }
377
+ if ((bitcast<u32>(r2.w) != 0u)) {
378
+ } else {
379
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_4[2u].x))));
380
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
381
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_4[22u].w == 0.0f)));
382
+ let v_78 = ((-(r1.xyzx)).xyz + cb3_3.tint_symbol_4[6u].xyz);
383
+ r7 = vec4<f32>(v_78.xyz, r7.w);
384
+ let v_79 = -(cb3_3.tint_symbol_4[6u].xyzx);
385
+ let v_80 = (r1.xyz + v_79.xyz);
386
+ r8 = vec4<f32>(v_80.xyz, r8.w);
387
+ r7.w = dot(r8.xyz, cb3_3.tint_symbol_4[14u].xyz);
388
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_4[22u].wwww)).w, 0.0f, 1.0f);
389
+ r7.w = (r7.w * cb3_3.tint_symbol_4[22u].w);
390
+ let v_81 = fma(cb3_3.tint_symbol_4[14u].xyz, r7.www, cb3_3.tint_symbol_4[6u].xyz);
391
+ r8 = vec4<f32>(v_81.xyz, r8.w);
392
+ let v_82 = ((-(r1.xyzx)).xyz + r8.xyz);
393
+ r8 = vec4<f32>(v_82.xyz, r8.w);
394
+ let v_83 = bitcast<vec3<u32>>(r3.www);
395
+ let v_84 = r7.xyz;
396
+ let v_85 = select(r8.xyz, v_84, (v_83 != vec3<u32>()));
397
+ r7 = vec4<f32>(v_85.xyz, r7.w);
398
+ r3.w = dot(r7.xyz, r7.xyz);
399
+ let v_86 = (r7.xyz + vec3<f32>(0.00000099999999747524f));
400
+ r7 = vec4<f32>(v_86.xyz, r7.w);
401
+ r7.w = dot(r7.xyz, r7.xyz);
402
+ r7.w = inverseSqrt(r7.w);
403
+ let v_87 = (r7.www * r7.xyz);
404
+ r7 = vec4<f32>(v_87.xyz, r7.w);
405
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_4[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
406
+ r7.w = ((-(cb3_3.tint_symbol_4[14u].wwww)).w + 1.0f);
407
+ r7.w = fma(r7.w, r3.w, cb3_3.tint_symbol_4[14u].w);
408
+ r3.w = (r3.w / r7.w);
409
+ let v_88 = -(cb3_3.tint_symbol_4[14u].xyzx);
410
+ r7.w = dot(r7.xyz, v_88.xyz);
411
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_4[30u].xxxx, cb3_3.tint_symbol_4[38u].xxxx).w, 0.0f, 1.0f);
412
+ let v_89 = dot(r7.xyz, r4.xyw);
413
+ r7.x = clamp(vec4<f32>(v_89, v_89, v_89, v_89).x, 0.0f, 1.0f);
414
+ r7.x = (r7.x + cb13_13.tint_symbol[0u].x);
415
+ r5.w = clamp(((r7.xxxx / r5.wwww)).w, 0.0f, 1.0f);
416
+ r5.w = (r7.w * r5.w);
417
+ r3.w = (r3.w * r5.w);
418
+ let v_90 = (r3.www * cb3_3.tint_symbol_4[22u].xyz);
419
+ r7 = vec4<f32>(v_90.xyz, r7.w);
420
+ let v_91 = fma(r7.xyz, r5.xyz, r6.yzw);
421
+ r7 = vec4<f32>(v_91.xyz, r7.w);
422
+ let v_92 = bitcast<vec3<u32>>(r2.www);
423
+ let v_93 = r6.yzw;
424
+ let v_94 = select(r7.xyz, v_93, (v_92 != vec3<u32>()));
425
+ r6 = vec4<f32>(r6.x, v_94.xyz);
426
+ }
427
+ r0.w = fma(r4.z, r0.w, cb3_3.tint_symbol_4[43u].w);
428
+ r0.w = (r0.w * cb3_3.tint_symbol_4[44u].w);
429
+ r0.w = max(r0.w, 0.0f);
430
+ let v_95 = fma(cb3_3.tint_symbol_4[47u].xyz, r0.www, cb3_3.tint_symbol_4[48u].xyz);
431
+ r7 = vec4<f32>(v_95.xyz, r7.w);
432
+ r2.w = ((-(cb2_2.tint_symbol_3[16u].zzzz)).w + 1.0f);
433
+ let v_96 = fma(cb3_3.tint_symbol_4[45u].xyz, r0.www, cb3_3.tint_symbol_4[46u].xyz);
434
+ r8 = vec4<f32>(v_96.xyz, r8.w);
435
+ let v_97 = (r8.xyz * cb2_2.tint_symbol_3[16u].zzz);
436
+ r8 = vec4<f32>(v_97.xyz, r8.w);
437
+ let v_98 = fma(r7.xyz, r2.www, r8.xyz);
438
+ r7 = vec4<f32>(v_98.xyz, r7.w);
439
+ let v_99 = (r1.www * r7.xyz);
440
+ r7 = vec4<f32>(v_99.xyz, r7.w);
441
+ let v_100 = fma(cb3_3.tint_symbol_4[43u].xyz, r0.www, cb3_3.tint_symbol_4[44u].xyz);
442
+ r8 = vec4<f32>(v_100.xyz, r8.w);
443
+ r9.x = cb3_3.tint_symbol_4[46u].w;
444
+ r9.y = cb3_3.tint_symbol_4[47u].w;
445
+ r9.z = cb3_3.tint_symbol_4[48u].w;
446
+ let v_101 = dot(r9.xyz, r4.xyw);
447
+ r0.w = clamp(vec4<f32>(v_101, v_101, v_101, v_101).w, 0.0f, 1.0f);
448
+ let v_102 = fma(cb3_3.tint_symbol_4[49u].xyz, r0.www, r8.xyz);
449
+ r4 = vec4<f32>(v_102.xyz, r4.w);
450
+ let v_103 = fma(r4.xyz, r6.xxx, r7.xyz);
451
+ r4 = vec4<f32>(v_103.xyz, r4.w);
452
+ let v_104 = (r5.xyz * r4.xyz);
453
+ r4 = vec4<f32>(v_104.xyz, r4.w);
454
+ let v_105 = fma(r6.yzw, cb8_8.tint_symbol_8[3u].xxx, r4.xyz);
455
+ o0 = vec4<f32>(v_105.xyz, o0.w);
456
+ r0.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
457
+ r0.w = (r0.w * 0.5f);
458
+ let v_106 = r2;
459
+ r4 = vec4<f32>(v_106.xyz, r4.w);
460
+ r1.w = 0.0f;
461
+ r2.w = 0.0f;
462
+ loop {
463
+ r3.w = f32(bitcast<i32>(r2.w));
464
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r3.w >= 4.0f)));
465
+ if ((bitcast<u32>(r3.w) != 0u)) {
466
+ break;
467
+ }
468
+ let v_107 = -(cb1_1.tint_symbol_1[15u].xyzx);
469
+ let v_108 = (r4.xyz + v_107.xyz);
470
+ r5 = vec4<f32>(v_108.xyz, r5.w);
471
+ let v_109 = (r5.yyy * cb6_6.tint_symbol_5[1u].xyz);
472
+ r6 = vec4<f32>(v_109.xyz, r6.w);
473
+ let v_110 = fma(r5.xxx, cb6_6.tint_symbol_5[0u].xyz, r6.xyz);
474
+ r5 = vec4<f32>(v_110.xy, r5.z, v_110.z);
475
+ let v_111 = fma(r5.zzz, cb6_6.tint_symbol_5[2u].xyz, r5.xyw);
476
+ r5 = vec4<f32>(v_111.xyz, r5.w);
477
+ let v_112 = fma(r5.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
478
+ r6 = vec4<f32>(v_112.xyz, r6.w);
479
+ let v_113 = &(x4[0u]);
480
+ let v_114 = r6;
481
+ *(v_113) = vec4<f32>(v_114.xyz, (*(v_113)).w);
482
+ let v_115 = fma(r5.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
483
+ r7 = vec4<f32>(v_115.xyz, r7.w);
484
+ let v_116 = &(x4[1u]);
485
+ let v_117 = r7;
486
+ *(v_116) = vec4<f32>(v_117.xyz, (*(v_116)).w);
487
+ let v_118 = fma(r5.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
488
+ r8 = vec4<f32>(v_118.xyz, r8.w);
489
+ let v_119 = &(x4[2u]);
490
+ let v_120 = r8;
491
+ *(v_119) = vec4<f32>(v_120.xyz, (*(v_119)).w);
492
+ let v_121 = fma(r5.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
493
+ r5 = vec4<f32>(v_121.xyz, r5.w);
494
+ let v_122 = &(x4[3u]);
495
+ let v_123 = r5;
496
+ *(v_122) = vec4<f32>(v_123.xyz, (*(v_122)).w);
497
+ let v_124 = abs(r8.yyyy);
498
+ r3.w = max(v_124.w, abs(r8.xxxx).w);
499
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r3.w < r0.w)));
500
+ let v_125 = (bitcast<u32>(r3.w) != 0u);
501
+ let v_126 = bitcast<f32>(v_1.tint_symbol_9[1i].x);
502
+ r3.w = select(bitcast<f32>(v_1.tint_symbol_9[2i].x), v_126, v_125);
503
+ let v_127 = abs(r7.yyyy);
504
+ r4.w = max(v_127.w, abs(r7.xxxx).w);
505
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (r4.w < r0.w)));
506
+ let v_128 = bitcast<u32>(r4.w);
507
+ r3.w = select(r3.w, bitcast<f32>(v_1.tint_symbol_9[3i].x), (v_128 != 0u));
508
+ let v_129 = abs(r6.yyyy);
509
+ r4.w = max(v_129.w, abs(r6.xxxx).w);
510
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (r4.w < r0.w)));
511
+ let v_130 = bitcast<u32>(r4.w);
512
+ r3.w = select(r3.w, 0.0f, (v_130 != 0u));
513
+ let v_131 = x4[bitcast<i32>(r3.w)];
514
+ r5 = vec4<f32>(v_131.xyz, r5.w);
515
+ r3.w = f32(bitcast<i32>(r3.w));
516
+ r3.w = (r3.w + 0.5f);
517
+ r3.w = (r3.w * 0.25f);
518
+ r5.x = (r5.x + cb6_6.tint_symbol_5[14u].z);
519
+ r3.w = fma(r5.y, 0.25f, r3.w);
520
+ let v_132 = (r5.xz + vec2<f32>(0.5f, 0.0f));
521
+ let v_133 = r5;
522
+ r5 = vec4<f32>(v_132.x, v_133.y, v_132.y, v_133.w);
523
+ r5.y = fma(cb6_6.tint_symbol_5[14u].w, 0.25f, r3.w);
524
+ let v_134 = r5.xyxx;
525
+ r3.w = textureSampleCompareLevel(t15, s15, v_134.xy, r5.z);
526
+ r1.w = (r1.w + r3.w);
527
+ r2.w = bitcast<f32>((bitcast<i32>(r2.w) + 1i));
528
+ }
529
+ r0.w = fma(r1.w, 0.25f, -1.0f);
530
+ o7.z = fma(v4.z, r0.w, 1.0f);
531
+ o0.w = (v1.w * v4.y);
532
+ r0.w = dot(r3.xyz, r3.xyz);
533
+ r1.w = sqrt(r0.w);
534
+ let v_135 = -(cb3_3.tint_symbol_4[50u].xxxx);
535
+ r2.x = (r1.w + v_135.x);
536
+ r2.x = max(r2.x, 0.0f);
537
+ r1.w = (r2.x / r1.w);
538
+ r1.w = (r1.w * r3.z);
539
+ r2.y = (r1.w * cb3_3.tint_symbol_4[52u].z);
540
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
541
+ r2.z = (r2.y * -1.44269502162933349609f);
542
+ r2.z = exp2(r2.z);
543
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
544
+ r2.y = (r2.z / r2.y);
545
+ let v_136 = bitcast<u32>(r1.w);
546
+ r1.w = select(1.0f, r2.y, (v_136 != 0u));
547
+ r2.y = (r2.x * cb3_3.tint_symbol_4[51u].w);
548
+ r1.w = (r1.w * r2.y);
549
+ r1.w = min(r1.w, 1.0f);
550
+ r1.w = (r1.w * 1.44269502162933349609f);
551
+ r1.w = exp2(r1.w);
552
+ r1.w = min(r1.w, 1.0f);
553
+ r1.w = ((-(r1.wwww)).w + 1.0f);
554
+ r2.y = (r1.w * cb3_3.tint_symbol_4[52u].y);
555
+ r0.w = inverseSqrt(r0.w);
556
+ let v_137 = (r0.www * r3.xyz);
557
+ r3 = vec4<f32>(v_137.xyz, r3.w);
558
+ let v_138 = dot(r3.xyz, cb3_3.tint_symbol_4[54u].xyz);
559
+ r0.w = clamp(vec4<f32>(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f);
560
+ r0.w = log2(r0.w);
561
+ r0.w = (r0.w * cb3_3.tint_symbol_4[54u].w);
562
+ r0.w = exp2(r0.w);
563
+ let v_139 = dot(r3.xyz, cb3_3.tint_symbol_4[53u].xyz);
564
+ r2.z = clamp(vec4<f32>(v_139, v_139, v_139, v_139).z, 0.0f, 1.0f);
565
+ r2.z = log2(r2.z);
566
+ r2.z = (r2.z * cb3_3.tint_symbol_4[53u].w);
567
+ r2.z = exp2(r2.z);
568
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_4[52u].y, 1.0f);
569
+ r1.w = (r1.w * cb3_3.tint_symbol_4[51u].y);
570
+ let v_140 = -(cb3_3.tint_symbol_4[52u].xxxx);
571
+ r2.w = (r2.x + v_140.w);
572
+ r2.w = max(r2.w, 0.0f);
573
+ r2.w = (r2.w * cb3_3.tint_symbol_4[51u].x);
574
+ r2.w = (r2.w * 1.44269502162933349609f);
575
+ r2.w = exp2(r2.w);
576
+ r2.w = ((-(r2.wwww)).w + 1.0f);
577
+ o4.w = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).w, 0.0f, 1.0f);
578
+ let v_141 = -(cb3_3.tint_symbol_4[51u].zzzz);
579
+ r2.x = (r2.x * v_141.x);
580
+ r2.x = (r2.x * 1.44269502162933349609f);
581
+ r2.x = exp2(r2.x);
582
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
583
+ let v_142 = ((-(cb3_3.tint_symbol_4[56u].xyzx)).xyz + cb3_3.tint_symbol_4[58u].xyz);
584
+ r3 = vec4<f32>(v_142.xyz, r3.w);
585
+ let v_143 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_4[56u].xyz);
586
+ r3 = vec4<f32>(v_143.xyz, r3.w);
587
+ let v_144 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_4[55u].xyz);
588
+ r4 = vec4<f32>(v_144.xyz, r4.w);
589
+ let v_145 = fma(r2.zzz, r4.xyz, r3.xyz);
590
+ r2 = vec4<f32>(r2.x, v_145.xyz);
591
+ let v_146 = -(cb3_3.tint_symbol_4[57u].xxyz);
592
+ let v_147 = (r2.yzw + v_146.yzw);
593
+ r2 = vec4<f32>(r2.x, v_147.xyz);
594
+ let v_148 = fma(r2.xxx, r2.yzw, cb3_3.tint_symbol_4[57u].xyz);
595
+ r2 = vec4<f32>(v_148.xyz, r2.w);
596
+ r3.x = ((-(r2.xxxx)).x + cb3_3.tint_symbol_4[55u].w);
597
+ r3.y = ((-(r2.yyyy)).y + cb3_3.tint_symbol_4[56u].w);
598
+ r3.z = ((-(r2.zzzz)).z + cb3_3.tint_symbol_4[57u].w);
599
+ let v_149 = fma(r1.www, r3.xyz, r2.xyz);
600
+ o4 = vec4<f32>(v_149.xyz, o4.w);
601
+ x5[0u].x = dot(r0.xyz, cb0_0.tint_symbol_2[0u].xyw);
602
+ o2 = vec4<f32>(o2.xy, vec2<f32>());
603
+ o5.x = v4.x;
604
+ o5 = vec4<f32>(o5.x, v1.xyz);
605
+ o6 = vec4<f32>(v5.xy, o6.zw);
606
+ o6 = vec4<f32>(o6.xy, vec2<f32>());
607
+ o7 = vec4<f32>(vec2<f32>(), o7.z, 0.0f);
608
+ let v_150 = r1;
609
+ o8 = vec4<f32>(v_150.xyz, o8.w);
610
+ o8.w = 0.0f;
611
+ o10 = vec4<f32>();
612
+ let v_151 = r0;
613
+ o11 = vec4<f32>(v_151.xy, o11.zw);
614
+ o11 = vec4<f32>(o11.xy, vec2<f32>(0.0f, 1.0f));
615
+ let v_152 = &(x5[0u]);
616
+ *(v_152) = vec4<f32>((*(v_152)).x, vec3<f32>());
617
+ o3.y = v3.y;
618
+ o12[0u] = x5[0u].x;
619
+ o12[1u] = x5[0u].y;
620
+ o12[2u] = x5[0u].z;
621
+ o12[3u] = x5[0u].w;
622
+ v = vec4<f32>(o12[0u], o12[1u], o12[2u], o12[3u]);
623
+ }
624
+
625
+ struct tint_symbol_12 {
626
+ @location(0u)
627
+ o0 : vec4<f32>,
628
+ @location(1u)
629
+ o1 : vec4<f32>,
630
+ @location(2u)
631
+ o2 : vec4<f32>,
632
+ @location(3u)
633
+ o3 : vec4<f32>,
634
+ @location(4u)
635
+ o4 : vec4<f32>,
636
+ @location(5u)
637
+ o5 : vec4<f32>,
638
+ @location(6u)
639
+ o6 : vec4<f32>,
640
+ @location(7u)
641
+ o7 : vec4<f32>,
642
+ @location(8u)
643
+ o8 : vec4<f32>,
644
+ @location(9u)
645
+ o9 : vec4<f32>,
646
+ @location(10u)
647
+ o10 : vec4<f32>,
648
+ @builtin(position)
649
+ o11 : vec4<f32>,
650
+ @builtin(clip_distances)
651
+ o12 : array<f32, 4u>,
652
+ @location(15u)
653
+ tint_symbol_11 : vec4<f32>,
654
+ }
655
+
656
+ @vertex
657
+ fn main(@location(0u) v0 : vec3<f32>, @location(1u) v1 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @location(7u) v7 : vec4<f32>, @location(8u) v8 : vec4<f32>, @location(9u) v9 : vec4<f32>, @location(10u) v10 : vec4<f32>, @location(11u) v11 : vec4<f32>, @location(13u) v13 : vec3<f32>) -> tint_symbol_12 {
658
+ main_inner(v0, v1, v3, v4, v5, v6, v7, v8, v9, v10, v11, v13);
659
+ return tint_symbol_12(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, v);
660
+ }
b/8b0b5899ed/shaders/00dfd3a1331419c1.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/00dfd3a1331419c1.wgsl ADDED
@@ -0,0 +1,957 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ struct cb16_struct {
54
+ tint_symbol : array<vec4<f32>, 16u>,
55
+ }
56
+
57
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
58
+
59
+ struct cb23_struct {
60
+ tint_symbol_1 : array<vec4<f32>, 23u>,
61
+ }
62
+
63
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
64
+
65
+ struct cb59_struct {
66
+ tint_symbol_2 : array<vec4<f32>, 59u>,
67
+ }
68
+
69
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
70
+
71
+ struct cb8_struct {
72
+ tint_symbol_3 : array<vec4<f32>, 8u>,
73
+ }
74
+
75
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
76
+
77
+ struct cb1_struct {
78
+ tint_symbol_4 : array<vec4<f32>, 1u>,
79
+ }
80
+
81
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb1_struct;
82
+
83
+ struct cb15_struct {
84
+ tint_symbol_5 : array<vec4<f32>, 15u>,
85
+ }
86
+
87
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
88
+
89
+ @group(1u) @binding(16u) var s0 : sampler;
90
+
91
+ @group(1u) @binding(17u) var s1 : sampler;
92
+
93
+ @group(1u) @binding(19u) var s3 : sampler;
94
+
95
+ @group(1u) @binding(27u) var s11 : sampler;
96
+
97
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
98
+
99
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
100
+
101
+ @group(1u) @binding(33u) var t1 : texture_2d<f32>;
102
+
103
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
104
+
105
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
108
+
109
+ var<private> v8 : vec4<f32>;
110
+
111
+ var<private> v9 : array<f32, 4u>;
112
+
113
+ var<private> o0 : vec4<f32>;
114
+
115
+ var<private> x0 : array<vec4<f32>, 4u>;
116
+
117
+ var<private> x1 : array<vec4<f32>, 1u>;
118
+
119
+ struct tint_symbol_7 {
120
+ tint_symbol_6 : array<vec4<u32>, 4u>,
121
+ }
122
+
123
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
124
+
125
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v7 : vec4<f32>, v_1 : vec4<f32>) {
126
+ var v_2 : vec4<f32> = v_1;
127
+ v_2.w = (1.0f / v_1.w);
128
+ v8 = v_2;
129
+ x1[0u].x = v9[0u];
130
+ x1[0u].y = v9[1u];
131
+ x1[0u].z = v9[2u];
132
+ x1[0u].w = v9[3u];
133
+ r0 = textureSample(t0, s0, v2.xy.xyxx.xy);
134
+ r1 = textureSample(t3, s3, v2.xy.xyxx.xy);
135
+ let v_3 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
136
+ r1 = vec4<f32>(v_3.xy, r1.zw);
137
+ r1.z = dot(r1.xy, r1.xy);
138
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
139
+ r1.z = sqrt(abs(r1.zzzz).z);
140
+ r1.w = max(cb12_12.tint_symbol_4[0u].w, 0.00100000004749745131f);
141
+ let v_4 = (r1.ww * r1.xy);
142
+ r1 = vec4<f32>(v_4.xy, r1.zw);
143
+ let v_5 = (r1.yyy * v6.xyz);
144
+ r2 = vec4<f32>(v_5.xyz, r2.w);
145
+ let v_6 = fma(r1.xxx, v5.xyz, r2.xyz);
146
+ r1 = vec4<f32>(v_6.xy, r1.z, v_6.z);
147
+ let v_7 = fma(r1.zzz, v3.xyz, r1.xyw);
148
+ r1 = vec4<f32>(v_7.xyz, r1.w);
149
+ r1.w = dot(r1.xyz, r1.xyz);
150
+ r1.w = inverseSqrt(r1.w);
151
+ let v_8 = (r1.www * r1.xyz);
152
+ r2 = vec4<f32>(v_8.xyz, r2.w);
153
+ let v_9 = (r0.xyz * v1.xyz);
154
+ r0 = vec4<f32>(v_9.xyz, r0.w);
155
+ r0.w = (r0.w * v0.w);
156
+ let v_10 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
157
+ r1 = vec4<f32>(v_10.xy, r1.zw);
158
+ let v_11 = (r0.xyz * r0.xyz);
159
+ r0 = vec4<f32>(v_11.xyz, r0.w);
160
+ let v_12 = -(v7.xyzx);
161
+ let v_13 = (v_12.xyz + cb1_1.tint_symbol[15u].xyz);
162
+ r3 = vec4<f32>(v_13.xyz, r3.w);
163
+ r2.w = dot(r3.xyz, r3.xyz);
164
+ r2.w = inverseSqrt(r2.w);
165
+ let v_14 = (r2.www * r3.xyz);
166
+ r4 = vec4<f32>(v_14.xyz, r4.w);
167
+ let v_15 = -(cb3_3.tint_symbol_2[0u].xyzx);
168
+ let v_16 = fma(r3.xyz, r2.www, v_15.xyz);
169
+ r5 = vec4<f32>(v_16.xyz, r5.w);
170
+ r3.w = dot(r5.xyz, r5.xyz);
171
+ r3.w = inverseSqrt(r3.w);
172
+ let v_17 = (r3.www * r5.xyz);
173
+ r5 = vec4<f32>(v_17.xyz, r5.w);
174
+ r3.w = clamp(cb12_12.tint_symbol_4[0u].z, 0.0f, 1.0f);
175
+ let v_18 = (r1.xy * r1.xy);
176
+ r1 = vec4<f32>(v_18.xy, r1.zw);
177
+ r4.w = (cb12_12.tint_symbol_4[0u].y + -500.0f);
178
+ r4.w = max(r4.w, 0.0f);
179
+ r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].y);
180
+ r4.w = (r4.w * 558.0f);
181
+ r4.w = fma(r5.w, 3.0f, r4.w);
182
+ r5.w = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz);
183
+ let v_19 = (v7.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
184
+ r6 = vec4<f32>(v_19.xyz, r6.w);
185
+ let v_20 = (r6.yyy * cb6_6.tint_symbol_5[1u].xyz);
186
+ r7 = vec4<f32>(v_20.xyz, r7.w);
187
+ let v_21 = fma(r6.xxx, cb6_6.tint_symbol_5[0u].xyz, r7.xyz);
188
+ r7 = vec4<f32>(v_21.xyz, r7.w);
189
+ let v_22 = fma(r6.zzz, cb6_6.tint_symbol_5[2u].xyz, r7.xyz);
190
+ r7 = vec4<f32>(v_22.xyz, r7.w);
191
+ let v_23 = fma(r7.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
192
+ r8 = vec4<f32>(v_23.xyz, r8.w);
193
+ let v_24 = &(x0[0u]);
194
+ let v_25 = r8;
195
+ *(v_24) = vec4<f32>(v_25.xyz, (*(v_24)).w);
196
+ let v_26 = fma(r7.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
197
+ r9 = vec4<f32>(v_26.xyz, r9.w);
198
+ let v_27 = &(x0[1u]);
199
+ let v_28 = r9;
200
+ *(v_27) = vec4<f32>(v_28.xyz, (*(v_27)).w);
201
+ let v_29 = fma(r7.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
202
+ r10 = vec4<f32>(v_29.xyz, r10.w);
203
+ let v_30 = &(x0[2u]);
204
+ let v_31 = r10;
205
+ *(v_30) = vec4<f32>(v_31.xyz, (*(v_30)).w);
206
+ let v_32 = fma(r7.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
207
+ r7 = vec4<f32>(v_32.xyz, r7.w);
208
+ let v_33 = &(x0[3u]);
209
+ let v_34 = r7;
210
+ *(v_33) = vec4<f32>(v_34.xyz, (*(v_33)).w);
211
+ let v_35 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
212
+ let v_36 = r11;
213
+ r11 = vec4<f32>(v_36.x, v_35.x, v_36.z, v_35.y);
214
+ r6.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
215
+ r6.w = (r6.w * 0.5f);
216
+ let v_37 = abs(r10.yyyy);
217
+ r7.z = max(v_37.z, abs(r10.xxxx).z);
218
+ r7.z = bitcast<f32>(select(0u, 4294967295u, (r7.z < r6.w)));
219
+ let v_38 = (bitcast<u32>(r7.z) != 0u);
220
+ let v_39 = bitcast<f32>(v.tint_symbol_6[0i].x);
221
+ r7.z = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_39, v_38);
222
+ let v_40 = abs(r9.yyyy);
223
+ r7.w = max(v_40.w, abs(r9.xxxx).w);
224
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r6.w)));
225
+ let v_41 = bitcast<u32>(r7.w);
226
+ r7.z = select(r7.z, bitcast<f32>(v.tint_symbol_6[2i].x), (v_41 != 0u));
227
+ let v_42 = abs(r8.yyyy);
228
+ r7.w = max(v_42.w, abs(r8.xxxx).w);
229
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r6.w)));
230
+ let v_43 = bitcast<u32>(r6.w);
231
+ r6.w = select(r7.z, 0.0f, (v_43 != 0u));
232
+ let v_44 = x0[bitcast<i32>(r6.w)];
233
+ r8 = vec4<f32>(v_44.xyz, r8.w);
234
+ r6.w = f32(bitcast<i32>(r6.w));
235
+ r7.z = (r6.w + 0.5f);
236
+ r7.z = (r7.z * 0.25f);
237
+ r9 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww)));
238
+ r9 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r9) & vec4<u32>(1065353216u)));
239
+ r6.w = dot(r9, cb6_6.tint_symbol_5[12u]);
240
+ r7.w = dot(r9, cb6_6.tint_symbol_5[13u]);
241
+ r9.x = (r8.x + 0.5f);
242
+ r9.y = fma(r8.y, 0.25f, r7.z);
243
+ r7.z = bitcast<f32>(select(0u, 4294967295u, !((r6.w == 0.0f))));
244
+ r6.w = ((-(r6.wwww)).w + r8.z);
245
+ let v_45 = dpdx(r9.xyy);
246
+ r10 = vec4<f32>(v_45.xy, r10.z, v_45.z);
247
+ r10.z = dpdx(r6.w);
248
+ let v_46 = dpdy(r9.yxy);
249
+ r12 = vec4<f32>(v_46.xyz, r12.w);
250
+ r12.w = dpdy(r6.w);
251
+ let v_47 = (r10.yw * r12.yw);
252
+ r8 = vec4<f32>(v_47.xy, r8.zw);
253
+ let v_48 = -(r8.xyxx);
254
+ let v_49 = fma(r10.xz, r12.xz, v_48.xy);
255
+ r13 = vec4<f32>(v_49.xy, r13.zw);
256
+ r8.x = (1.0f / r13.x);
257
+ r8.y = (r10.z * r12.y);
258
+ let v_50 = -(r8.yyyy);
259
+ r13.z = fma(r10.x, r12.w, v_50.z);
260
+ let v_51 = (r8.xx * r13.yz);
261
+ r8 = vec4<f32>(v_51.xy, r8.zw);
262
+ let v_52 = max(r8.xy, vec2<f32>());
263
+ r8 = vec4<f32>(v_52.xy, r8.zw);
264
+ let v_53 = min(r8.xy, vec2<f32>(0.5f));
265
+ r8 = vec4<f32>(v_53.xy, r8.zw);
266
+ r6.w = fma((-(r7.wwww)).w, r8.x, r6.w);
267
+ r6.w = fma((-(r7.wwww)).w, r8.y, r6.w);
268
+ let v_54 = bitcast<u32>(r7.z);
269
+ let v_55 = r6.w;
270
+ r11.z = select(r8.z, v_55, (v_54 != 0u));
271
+ r9.z = 0.0f;
272
+ let v_56 = (r9.xyz + r11.ywz);
273
+ r8 = vec4<f32>(v_56.xyz, r8.w);
274
+ let v_57 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
275
+ r11 = vec4<f32>(v_57.xy, r11.zw);
276
+ let v_58 = (r9.xyz + r11.xyz);
277
+ r10 = vec4<f32>(v_58.xyz, r10.w);
278
+ let v_59 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
279
+ r11 = vec4<f32>(v_59.xy, r11.zw);
280
+ let v_60 = (r9.xyz + r11.xyz);
281
+ r12 = vec4<f32>(v_60.xyz, r12.w);
282
+ let v_61 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
283
+ r11 = vec4<f32>(v_61.xy, r11.zw);
284
+ let v_62 = (r9.xyz + r11.xyz);
285
+ r13 = vec4<f32>(v_62.xyz, r13.w);
286
+ let v_63 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
287
+ r11 = vec4<f32>(v_63.xy, r11.zw);
288
+ let v_64 = (r9.xyz + r11.xyz);
289
+ r14 = vec4<f32>(v_64.xyz, r14.w);
290
+ let v_65 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
291
+ r11 = vec4<f32>(v_65.xy, r11.zw);
292
+ let v_66 = (r9.xyz + r11.xyz);
293
+ r15 = vec4<f32>(v_66.xyz, r15.w);
294
+ let v_67 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
295
+ r11 = vec4<f32>(v_67.xy, r11.zw);
296
+ let v_68 = (r9.xyz + r11.xyz);
297
+ r16 = vec4<f32>(v_68.xyz, r16.w);
298
+ let v_69 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
299
+ r11 = vec4<f32>(v_69.xy, r11.zw);
300
+ let v_70 = (r9.xyz + r11.xyz);
301
+ r17 = vec4<f32>(v_70.xyz, r17.w);
302
+ let v_71 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
303
+ r11 = vec4<f32>(v_71.xy, r11.zw);
304
+ let v_72 = (r9.xyz + r11.xyz);
305
+ r18 = vec4<f32>(v_72.xyz, r18.w);
306
+ let v_73 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
307
+ r11 = vec4<f32>(v_73.xy, r11.zw);
308
+ let v_74 = (r9.xyz + r11.xyz);
309
+ r19 = vec4<f32>(v_74.xyz, r19.w);
310
+ let v_75 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
311
+ r11 = vec4<f32>(v_75.xy, r11.zw);
312
+ let v_76 = (r9.xyz + r11.xyz);
313
+ r20 = vec4<f32>(v_76.xyz, r20.w);
314
+ let v_77 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
315
+ r11 = vec4<f32>(v_77.xy, r11.zw);
316
+ let v_78 = (r9.xyz + r11.xyz);
317
+ r21 = vec4<f32>(v_78.xyz, r21.w);
318
+ let v_79 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
319
+ r11 = vec4<f32>(v_79.xy, r11.zw);
320
+ let v_80 = (r9.xyz + r11.xyz);
321
+ r22 = vec4<f32>(v_80.xyz, r22.w);
322
+ let v_81 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
323
+ r11 = vec4<f32>(v_81.xy, r11.zw);
324
+ let v_82 = (r9.xyz + r11.xyz);
325
+ r23 = vec4<f32>(v_82.xyz, r23.w);
326
+ let v_83 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
327
+ r11 = vec4<f32>(v_83.xy, r11.zw);
328
+ let v_84 = (r9.xyz + r11.xyz);
329
+ r24 = vec4<f32>(v_84.xyz, r24.w);
330
+ let v_85 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
331
+ r11 = vec4<f32>(v_85.xy, r11.zw);
332
+ let v_86 = (r9.xyz + r11.xyz);
333
+ r9 = vec4<f32>(v_86.xyz, r9.w);
334
+ let v_87 = r8.xyxx;
335
+ r8.x = textureSampleCompareLevel(t15, s15, v_87.xy, r8.z);
336
+ let v_88 = r10.xyxx;
337
+ r8.y = textureSampleCompareLevel(t15, s15, v_88.xy, r10.z);
338
+ let v_89 = r12.xyxx;
339
+ r8.z = textureSampleCompareLevel(t15, s15, v_89.xy, r12.z);
340
+ let v_90 = r13.xyxx;
341
+ r8.w = textureSampleCompareLevel(t15, s15, v_90.xy, r13.z);
342
+ let v_91 = r14.xyxx;
343
+ r10.x = textureSampleCompareLevel(t15, s15, v_91.xy, r14.z);
344
+ let v_92 = r15.xyxx;
345
+ r10.y = textureSampleCompareLevel(t15, s15, v_92.xy, r15.z);
346
+ let v_93 = r16.xyxx;
347
+ r10.z = textureSampleCompareLevel(t15, s15, v_93.xy, r16.z);
348
+ let v_94 = r17.xyxx;
349
+ r10.w = textureSampleCompareLevel(t15, s15, v_94.xy, r17.z);
350
+ let v_95 = r18.xyxx;
351
+ r11.x = textureSampleCompareLevel(t15, s15, v_95.xy, r18.z);
352
+ let v_96 = r19.xyxx;
353
+ r11.y = textureSampleCompareLevel(t15, s15, v_96.xy, r19.z);
354
+ let v_97 = r20.xyxx;
355
+ r11.z = textureSampleCompareLevel(t15, s15, v_97.xy, r20.z);
356
+ let v_98 = r21.xyxx;
357
+ r11.w = textureSampleCompareLevel(t15, s15, v_98.xy, r21.z);
358
+ let v_99 = r22.xyxx;
359
+ r12.x = textureSampleCompareLevel(t15, s15, v_99.xy, r22.z);
360
+ let v_100 = r23.xyxx;
361
+ r12.y = textureSampleCompareLevel(t15, s15, v_100.xy, r23.z);
362
+ let v_101 = r24.xyxx;
363
+ r12.z = textureSampleCompareLevel(t15, s15, v_101.xy, r24.z);
364
+ let v_102 = r9.xyxx;
365
+ r12.w = textureSampleCompareLevel(t15, s15, v_102.xy, r9.z);
366
+ r8 = (r8 + r10);
367
+ r8 = (r11 + r8);
368
+ r8 = (r12 + r8);
369
+ r6.w = dot(r8, vec4<f32>(1.0f));
370
+ r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f);
371
+ let v_103 = abs(r7.yyyy);
372
+ r7.x = max(v_103.x, abs(r7.xxxx).x);
373
+ r7.x = clamp(fma(r7.xxxx, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).x, 0.0f, 1.0f);
374
+ r5.w = ((-(r5.wwww)).w + 1.0f);
375
+ r5.w = (r7.x * r5.w);
376
+ r5.w = fma(r6.w, 0.0625f, r5.w);
377
+ r5.w = (r5.w * r5.w);
378
+ r5.w = min(r5.w, 1.0f);
379
+ r6.w = clamp(fma(v7.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
380
+ r6.w = sqrt(r6.w);
381
+ r6.w = (r6.w * cb6_6.tint_symbol_5[3u].z);
382
+ let v_104 = -(r5.wwww);
383
+ r5.w = fma(r6.w, v_104.w, r5.w);
384
+ let v_105 = dot(r2.xyz, v_15.xyz);
385
+ r6.w = clamp(vec4<f32>(v_105, v_105, v_105, v_105).w, 0.0f, 1.0f);
386
+ let v_106 = dot(r4.xyz, r2.xyz);
387
+ r7.x = clamp(vec4<f32>(v_106, v_106, v_106, v_106).x, 0.0f, 1.0f);
388
+ let v_107 = dot(r5.xyz, v_15.xyz);
389
+ r7.y = clamp(vec4<f32>(v_107, v_107, v_107, v_107).y, 0.0f, 1.0f);
390
+ let v_108 = ((-(r7.xyxx)).xy + vec2<f32>(1.0f));
391
+ r7 = vec4<f32>(v_108.xy, r7.zw);
392
+ let v_109 = (r7.xy * r7.xy);
393
+ r7 = vec4<f32>(r7.xy, v_109.xy);
394
+ let v_110 = (r7.zw * r7.zw);
395
+ r7 = vec4<f32>(r7.xy, v_110.xy);
396
+ let v_111 = (r7.xy * r7.zw);
397
+ r7 = vec4<f32>(v_111.xy, r7.zw);
398
+ r7.z = ((-(cb12_12.tint_symbol_4[0u].xxxx)).z + 1.0f);
399
+ let v_112 = fma(cb12_12.tint_symbol_4[0u].xx, r7.xy, r7.zz);
400
+ r7 = vec4<f32>(v_112.xy, r7.zw);
401
+ let v_113 = (r4.ww + vec2<f32>(2.0f, 0.00000000999999993923f));
402
+ r8 = vec4<f32>(v_113.xy, r8.zw);
403
+ r7.w = (r8.x * 0.125f);
404
+ r7.x = fma((-(r3.wwww)).x, r7.x, 1.0f);
405
+ r5.x = dot(r2.xyz, r5.xyz);
406
+ r5.x = clamp(((r5.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
407
+ r5.x = log2(r5.x);
408
+ r5.x = (r5.x * r8.y);
409
+ r5.x = exp2(r5.x);
410
+ r5.x = (r7.y * r5.x);
411
+ r5.x = (r7.w * r5.x);
412
+ r5.x = (r3.w * r5.x);
413
+ r5.x = (r6.w * r5.x);
414
+ r5.y = (r6.w * r7.x);
415
+ let v_114 = fma(r0.xyz, r5.yyy, r5.xxx);
416
+ r5 = vec4<f32>(v_114.xyz, r5.w);
417
+ let v_115 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz);
418
+ r5 = vec4<f32>(v_115.xyz, r5.w);
419
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
420
+ if ((bitcast<u32>(r6.w) != 0u)) {
421
+ r9 = vec4<f32>(r9.x, vec3<f32>());
422
+ r8 = vec4<f32>(0.0f, r8.y, vec2<f32>());
423
+ } else {
424
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
425
+ let v_116 = ((-(v7.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz);
426
+ r8 = vec4<f32>(v_116.x, r8.y, v_116.yz);
427
+ let v_117 = (v7.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
428
+ r9 = vec4<f32>(v_117.xyz, r9.w);
429
+ r9.x = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz);
430
+ r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[19u].wwww)).x, 0.0f, 1.0f);
431
+ r9.x = (r9.x * cb3_3.tint_symbol_2[19u].w);
432
+ let v_118 = fma(cb3_3.tint_symbol_2[11u].xyz, r9.xxx, cb3_3.tint_symbol_2[3u].xyz);
433
+ r9 = vec4<f32>(v_118.xyz, r9.w);
434
+ let v_119 = (r9.xyz + v_12.xyz);
435
+ r9 = vec4<f32>(v_119.xyz, r9.w);
436
+ let v_120 = bitcast<vec3<u32>>(r7.yyy);
437
+ let v_121 = r8.xzw;
438
+ let v_122 = select(r9.xyz, v_121, (v_120 != vec3<u32>()));
439
+ r8 = vec4<f32>(v_122.x, r8.y, v_122.yz);
440
+ r7.y = dot(r8.xzw, r8.xzw);
441
+ let v_123 = (r8.xzw + vec3<f32>(0.00000099999999747524f));
442
+ r8 = vec4<f32>(v_123.x, r8.y, v_123.yz);
443
+ r9.x = dot(r8.xzw, r8.xzw);
444
+ r9.x = inverseSqrt(r9.x);
445
+ let v_124 = (r8.xzw * r9.xxx);
446
+ r8 = vec4<f32>(v_124.x, r8.y, v_124.yz);
447
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
448
+ r9.x = ((-(cb3_3.tint_symbol_2[11u].wwww)).x + 1.0f);
449
+ r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[11u].w);
450
+ r7.y = (r7.y / r9.x);
451
+ let v_125 = -(cb3_3.tint_symbol_2[11u].xyzx);
452
+ r9.x = dot(r8.xzw, v_125.xyz);
453
+ r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).x, 0.0f, 1.0f);
454
+ let v_126 = dot(r8.xzw, r2.xyz);
455
+ r9.y = clamp(vec4<f32>(v_126, v_126, v_126, v_126).y, 0.0f, 1.0f);
456
+ r9.x = (r9.x * r9.y);
457
+ r9.y = (r7.y * r9.x);
458
+ let v_127 = (r9.yyy * cb3_3.tint_symbol_2[19u].xyz);
459
+ r9 = vec4<f32>(r9.x, v_127.xyz);
460
+ let v_128 = (r0.xyz * r9.yzw);
461
+ r9 = vec4<f32>(r9.x, v_128.xyz);
462
+ let v_129 = fma(r3.xyz, r2.www, r8.xzw);
463
+ r8 = vec4<f32>(v_129.x, r8.y, v_129.yz);
464
+ r10.x = dot(r8.xzw, r8.xzw);
465
+ r10.x = inverseSqrt(r10.x);
466
+ let v_130 = (r8.xzw * r10.xxx);
467
+ r8 = vec4<f32>(v_130.x, r8.y, v_130.yz);
468
+ let v_131 = dot(r8.xzw, r4.xyz);
469
+ r10.x = clamp(vec4<f32>(v_131, v_131, v_131, v_131).x, 0.0f, 1.0f);
470
+ r10.x = ((-(r10.xxxx)).x + 1.0f);
471
+ r10.y = (r10.x * r10.x);
472
+ r10.y = (r10.y * r10.y);
473
+ r10.x = (r10.y * r10.x);
474
+ r10.x = fma(cb12_12.tint_symbol_4[0u].x, r10.x, r7.z);
475
+ let v_132 = dot(r8.xzw, r2.xyz);
476
+ r8.x = clamp(vec4<f32>(v_132, v_132, v_132, v_132).x, 0.0f, 1.0f);
477
+ r8.x = log2(r8.x);
478
+ r8.x = (r8.x * r8.y);
479
+ r8.x = exp2(r8.x);
480
+ r8.x = (r8.x * r10.x);
481
+ r8.x = (r9.x * r8.x);
482
+ r7.y = (r7.y * r8.x);
483
+ r7.y = (r7.w * r7.y);
484
+ let v_133 = (r7.yyy * cb3_3.tint_symbol_2[19u].xyz);
485
+ r8 = vec4<f32>(v_133.x, r8.y, v_133.yz);
486
+ }
487
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
488
+ if ((bitcast<u32>(r7.y) != 0u)) {
489
+ r9.x = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
490
+ r7.y = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
491
+ let v_134 = bitcast<u32>(r9.x);
492
+ let v_135 = r7.y;
493
+ r6.w = select(r6.w, v_135, (v_134 != 0u));
494
+ if ((bitcast<u32>(r6.w) != 0u)) {
495
+ } else {
496
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
497
+ let v_136 = (v_12.xyz + cb3_3.tint_symbol_2[4u].xyz);
498
+ r10 = vec4<f32>(v_136.xyz, r10.w);
499
+ let v_137 = (v7.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
500
+ r11 = vec4<f32>(v_137.xyz, r11.w);
501
+ r9.x = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz);
502
+ r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[20u].wwww)).x, 0.0f, 1.0f);
503
+ r9.x = (r9.x * cb3_3.tint_symbol_2[20u].w);
504
+ let v_138 = fma(cb3_3.tint_symbol_2[12u].xyz, r9.xxx, cb3_3.tint_symbol_2[4u].xyz);
505
+ r11 = vec4<f32>(v_138.xyz, r11.w);
506
+ let v_139 = (r11.xyz + v_12.xyz);
507
+ r11 = vec4<f32>(v_139.xyz, r11.w);
508
+ let v_140 = bitcast<vec3<u32>>(r7.yyy);
509
+ let v_141 = r10.xyz;
510
+ let v_142 = select(r11.xyz, v_141, (v_140 != vec3<u32>()));
511
+ r10 = vec4<f32>(v_142.xyz, r10.w);
512
+ r7.y = dot(r10.xyz, r10.xyz);
513
+ let v_143 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
514
+ r10 = vec4<f32>(v_143.xyz, r10.w);
515
+ r9.x = dot(r10.xyz, r10.xyz);
516
+ r9.x = inverseSqrt(r9.x);
517
+ let v_144 = (r9.xxx * r10.xyz);
518
+ r10 = vec4<f32>(v_144.xyz, r10.w);
519
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
520
+ r9.x = ((-(cb3_3.tint_symbol_2[12u].wwww)).x + 1.0f);
521
+ r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[12u].w);
522
+ r7.y = (r7.y / r9.x);
523
+ let v_145 = -(cb3_3.tint_symbol_2[12u].xyzx);
524
+ r9.x = dot(r10.xyz, v_145.xyz);
525
+ r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).x, 0.0f, 1.0f);
526
+ let v_146 = dot(r10.xyz, r2.xyz);
527
+ r10.w = clamp(vec4<f32>(v_146, v_146, v_146, v_146).w, 0.0f, 1.0f);
528
+ r9.x = (r9.x * r10.w);
529
+ r10.w = (r7.y * r9.x);
530
+ let v_147 = (r10.www * cb3_3.tint_symbol_2[20u].xyz);
531
+ r11 = vec4<f32>(v_147.xyz, r11.w);
532
+ let v_148 = fma(r11.xyz, r0.xyz, r9.yzw);
533
+ r9 = vec4<f32>(r9.x, v_148.xyz);
534
+ let v_149 = fma(r3.xyz, r2.www, r10.xyz);
535
+ r10 = vec4<f32>(v_149.xyz, r10.w);
536
+ r10.w = dot(r10.xyz, r10.xyz);
537
+ r10.w = inverseSqrt(r10.w);
538
+ let v_150 = (r10.www * r10.xyz);
539
+ r10 = vec4<f32>(v_150.xyz, r10.w);
540
+ let v_151 = dot(r10.xyz, r4.xyz);
541
+ r10.w = clamp(vec4<f32>(v_151, v_151, v_151, v_151).w, 0.0f, 1.0f);
542
+ r10.w = ((-(r10.wwww)).w + 1.0f);
543
+ r11.x = (r10.w * r10.w);
544
+ r11.x = (r11.x * r11.x);
545
+ r10.w = (r10.w * r11.x);
546
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.z);
547
+ let v_152 = dot(r10.xyz, r2.xyz);
548
+ r10.x = clamp(vec4<f32>(v_152, v_152, v_152, v_152).x, 0.0f, 1.0f);
549
+ r10.x = log2(r10.x);
550
+ r10.x = (r8.y * r10.x);
551
+ r10.x = exp2(r10.x);
552
+ r10.x = (r10.x * r10.w);
553
+ r9.x = (r9.x * r10.x);
554
+ r7.y = (r7.y * r9.x);
555
+ r7.y = (r7.w * r7.y);
556
+ let v_153 = fma(r7.yyy, cb3_3.tint_symbol_2[20u].xyz, r8.xzw);
557
+ r8 = vec4<f32>(v_153.x, r8.y, v_153.yz);
558
+ }
559
+ } else {
560
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
561
+ }
562
+ if ((bitcast<u32>(r6.w) != 0u)) {
563
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
564
+ } else {
565
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
566
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
567
+ if ((bitcast<u32>(r6.w) != 0u)) {
568
+ } else {
569
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
570
+ let v_154 = (v_12.xyz + cb3_3.tint_symbol_2[5u].xyz);
571
+ r10 = vec4<f32>(v_154.xyz, r10.w);
572
+ let v_155 = (v7.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
573
+ r11 = vec4<f32>(v_155.xyz, r11.w);
574
+ r9.x = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz);
575
+ r9.x = clamp(((r9.xxxx / cb3_3.tint_symbol_2[21u].wwww)).x, 0.0f, 1.0f);
576
+ r9.x = (r9.x * cb3_3.tint_symbol_2[21u].w);
577
+ let v_156 = fma(cb3_3.tint_symbol_2[13u].xyz, r9.xxx, cb3_3.tint_symbol_2[5u].xyz);
578
+ r11 = vec4<f32>(v_156.xyz, r11.w);
579
+ let v_157 = (r11.xyz + v_12.xyz);
580
+ r11 = vec4<f32>(v_157.xyz, r11.w);
581
+ let v_158 = bitcast<vec3<u32>>(r7.yyy);
582
+ let v_159 = r10.xyz;
583
+ let v_160 = select(r11.xyz, v_159, (v_158 != vec3<u32>()));
584
+ r10 = vec4<f32>(v_160.xyz, r10.w);
585
+ r7.y = dot(r10.xyz, r10.xyz);
586
+ let v_161 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
587
+ r10 = vec4<f32>(v_161.xyz, r10.w);
588
+ r9.x = dot(r10.xyz, r10.xyz);
589
+ r9.x = inverseSqrt(r9.x);
590
+ let v_162 = (r9.xxx * r10.xyz);
591
+ r10 = vec4<f32>(v_162.xyz, r10.w);
592
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
593
+ r9.x = ((-(cb3_3.tint_symbol_2[13u].wwww)).x + 1.0f);
594
+ r9.x = fma(r9.x, r7.y, cb3_3.tint_symbol_2[13u].w);
595
+ r7.y = (r7.y / r9.x);
596
+ let v_163 = -(cb3_3.tint_symbol_2[13u].xyzx);
597
+ r9.x = dot(r10.xyz, v_163.xyz);
598
+ r9.x = clamp(fma(r9.xxxx, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).x, 0.0f, 1.0f);
599
+ let v_164 = dot(r10.xyz, r2.xyz);
600
+ r10.w = clamp(vec4<f32>(v_164, v_164, v_164, v_164).w, 0.0f, 1.0f);
601
+ r9.x = (r9.x * r10.w);
602
+ r10.w = (r7.y * r9.x);
603
+ let v_165 = (r10.www * cb3_3.tint_symbol_2[21u].xyz);
604
+ r11 = vec4<f32>(v_165.xyz, r11.w);
605
+ let v_166 = fma(r11.xyz, r0.xyz, r9.yzw);
606
+ r9 = vec4<f32>(r9.x, v_166.xyz);
607
+ let v_167 = fma(r3.xyz, r2.www, r10.xyz);
608
+ r10 = vec4<f32>(v_167.xyz, r10.w);
609
+ r10.w = dot(r10.xyz, r10.xyz);
610
+ r10.w = inverseSqrt(r10.w);
611
+ let v_168 = (r10.www * r10.xyz);
612
+ r10 = vec4<f32>(v_168.xyz, r10.w);
613
+ let v_169 = dot(r10.xyz, r4.xyz);
614
+ r10.w = clamp(vec4<f32>(v_169, v_169, v_169, v_169).w, 0.0f, 1.0f);
615
+ r10.w = ((-(r10.wwww)).w + 1.0f);
616
+ r11.x = (r10.w * r10.w);
617
+ r11.x = (r11.x * r11.x);
618
+ r10.w = (r10.w * r11.x);
619
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.z);
620
+ let v_170 = dot(r10.xyz, r2.xyz);
621
+ r10.x = clamp(vec4<f32>(v_170, v_170, v_170, v_170).x, 0.0f, 1.0f);
622
+ r10.x = log2(r10.x);
623
+ r10.x = (r8.y * r10.x);
624
+ r10.x = exp2(r10.x);
625
+ r10.x = (r10.x * r10.w);
626
+ r9.x = (r9.x * r10.x);
627
+ r7.y = (r7.y * r9.x);
628
+ r7.y = (r7.w * r7.y);
629
+ let v_171 = fma(r7.yyy, cb3_3.tint_symbol_2[21u].xyz, r8.xzw);
630
+ r8 = vec4<f32>(v_171.x, r8.y, v_171.yz);
631
+ }
632
+ }
633
+ if ((bitcast<u32>(r6.w) != 0u)) {
634
+ } else {
635
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
636
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
637
+ if ((bitcast<u32>(r6.w) != 0u)) {
638
+ } else {
639
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
640
+ let v_172 = (v_12.xyz + cb3_3.tint_symbol_2[6u].xyz);
641
+ r10 = vec4<f32>(v_172.xyz, r10.w);
642
+ let v_173 = (v7.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
643
+ r11 = vec4<f32>(v_173.xyz, r11.w);
644
+ r7.y = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz);
645
+ r7.y = clamp(((r7.yyyy / cb3_3.tint_symbol_2[22u].wwww)).y, 0.0f, 1.0f);
646
+ r7.y = (r7.y * cb3_3.tint_symbol_2[22u].w);
647
+ let v_174 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.yyy, cb3_3.tint_symbol_2[6u].xyz);
648
+ r11 = vec4<f32>(v_174.xyz, r11.w);
649
+ let v_175 = (r11.xyz + v_12.xyz);
650
+ r11 = vec4<f32>(v_175.xyz, r11.w);
651
+ let v_176 = bitcast<vec3<u32>>(r6.www);
652
+ let v_177 = r10.xyz;
653
+ let v_178 = select(r11.xyz, v_177, (v_176 != vec3<u32>()));
654
+ r10 = vec4<f32>(v_178.xyz, r10.w);
655
+ r6.w = dot(r10.xyz, r10.xyz);
656
+ let v_179 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
657
+ r10 = vec4<f32>(v_179.xyz, r10.w);
658
+ r7.y = dot(r10.xyz, r10.xyz);
659
+ r7.y = inverseSqrt(r7.y);
660
+ let v_180 = (r7.yyy * r10.xyz);
661
+ r10 = vec4<f32>(v_180.xyz, r10.w);
662
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
663
+ r7.y = ((-(cb3_3.tint_symbol_2[14u].wwww)).y + 1.0f);
664
+ r7.y = fma(r7.y, r6.w, cb3_3.tint_symbol_2[14u].w);
665
+ r6.w = (r6.w / r7.y);
666
+ let v_181 = -(cb3_3.tint_symbol_2[14u].xyzx);
667
+ r7.y = dot(r10.xyz, v_181.xyz);
668
+ r7.y = clamp(fma(r7.yyyy, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).y, 0.0f, 1.0f);
669
+ let v_182 = dot(r10.xyz, r2.xyz);
670
+ r9.x = clamp(vec4<f32>(v_182, v_182, v_182, v_182).x, 0.0f, 1.0f);
671
+ r7.y = (r7.y * r9.x);
672
+ r9.x = (r6.w * r7.y);
673
+ let v_183 = (r9.xxx * cb3_3.tint_symbol_2[22u].xyz);
674
+ r11 = vec4<f32>(v_183.xyz, r11.w);
675
+ let v_184 = fma(r11.xyz, r0.xyz, r9.yzw);
676
+ r9 = vec4<f32>(r9.x, v_184.xyz);
677
+ let v_185 = fma(r3.xyz, r2.www, r10.xyz);
678
+ r3 = vec4<f32>(v_185.xyz, r3.w);
679
+ r2.w = dot(r3.xyz, r3.xyz);
680
+ r2.w = inverseSqrt(r2.w);
681
+ let v_186 = (r2.www * r3.xyz);
682
+ r3 = vec4<f32>(v_186.xyz, r3.w);
683
+ let v_187 = dot(r3.xyz, r4.xyz);
684
+ r2.w = clamp(vec4<f32>(v_187, v_187, v_187, v_187).w, 0.0f, 1.0f);
685
+ r2.w = ((-(r2.wwww)).w + 1.0f);
686
+ r9.x = (r2.w * r2.w);
687
+ r9.x = (r9.x * r9.x);
688
+ r2.w = (r2.w * r9.x);
689
+ r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r7.z);
690
+ let v_188 = dot(r3.xyz, r2.xyz);
691
+ r3.x = clamp(vec4<f32>(v_188, v_188, v_188, v_188).x, 0.0f, 1.0f);
692
+ r3.x = log2(r3.x);
693
+ r3.x = (r3.x * r8.y);
694
+ r3.x = exp2(r3.x);
695
+ r2.w = (r2.w * r3.x);
696
+ r2.w = (r7.y * r2.w);
697
+ r2.w = (r6.w * r2.w);
698
+ r2.w = (r7.w * r2.w);
699
+ let v_189 = fma(r2.www, cb3_3.tint_symbol_2[22u].xyz, r8.xzw);
700
+ r8 = vec4<f32>(v_189.x, r8.y, v_189.yz);
701
+ }
702
+ }
703
+ r2.w = (r7.x * r7.x);
704
+ r3.x = (r3.w * r3.w);
705
+ let v_190 = (r8.xzw * r3.xxx);
706
+ r3 = vec4<f32>(v_190.xyz, r3.w);
707
+ let v_191 = fma(r2.www, r9.yzw, r3.xyz);
708
+ r3 = vec4<f32>(v_191.xyz, r3.w);
709
+ let v_192 = fma(r5.xyz, r5.www, r3.xyz);
710
+ r3 = vec4<f32>(v_192.xyz, r3.w);
711
+ r1.z = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w);
712
+ r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w);
713
+ r1.z = max(r1.z, 0.0f);
714
+ let v_193 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz);
715
+ r5 = vec4<f32>(v_193.xyz, r5.w);
716
+ r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
717
+ let v_194 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz);
718
+ r7 = vec4<f32>(r7.x, v_194.xyz);
719
+ let v_195 = (r7.yzw * cb2_2.tint_symbol_1[16u].zzz);
720
+ r7 = vec4<f32>(r7.x, v_195.xyz);
721
+ let v_196 = fma(r5.xyz, r1.www, r7.yzw);
722
+ r5 = vec4<f32>(v_196.xyz, r5.w);
723
+ let v_197 = (r1.yyy * r5.xyz);
724
+ r5 = vec4<f32>(v_197.xyz, r5.w);
725
+ let v_198 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz);
726
+ r7 = vec4<f32>(r7.x, v_198.xyz);
727
+ r8.x = cb3_3.tint_symbol_2[46u].w;
728
+ r8.y = cb3_3.tint_symbol_2[47u].w;
729
+ r8.z = cb3_3.tint_symbol_2[48u].w;
730
+ let v_199 = dot(r8.xyz, r2.xyz);
731
+ r1.z = clamp(vec4<f32>(v_199, v_199, v_199, v_199).z, 0.0f, 1.0f);
732
+ let v_200 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.zzz, r7.yzw);
733
+ r7 = vec4<f32>(r7.x, v_200.xyz);
734
+ let v_201 = fma(r7.yzw, r1.xxx, r5.xyz);
735
+ r5 = vec4<f32>(v_201.xyz, r5.w);
736
+ let v_202 = (r7.xxx * r5.xyz);
737
+ r5 = vec4<f32>(v_202.xyz, r5.w);
738
+ let v_203 = fma(r5.xyz, r0.xyz, r3.xyz);
739
+ r0 = vec4<f32>(v_203.xyz, r0.w);
740
+ r1.z = ((-(r7.xxxx)).z + 1.0f);
741
+ r1.w = dot((-(r4.xyzx)).xyz, r2.xyz);
742
+ r1.w = (r1.w + r1.w);
743
+ let v_204 = -(r1.wwww);
744
+ let v_205 = -(r4.xyzx);
745
+ let v_206 = fma(r2.xyz, v_204.xyz, v_205.xyz);
746
+ r2 = vec4<f32>(v_206.xyz, r2.w);
747
+ let v_207 = clamp(((r4.wwww * vec4<f32>(0.00066666665952652693f, 0.00177619897294789553f, 0.0f, 0.0f))).xy, vec2<f32>(), vec2<f32>(1.0f));
748
+ r3 = vec4<f32>(v_207.xy, r3.zw);
749
+ r1.w = ((-(r3.xxxx)).w + 1.0f);
750
+ r2.w = (cb5_5.tint_symbol_3[6u].z + -5.0f);
751
+ r3.x = (r1.w * cb5_5.tint_symbol_3[6u].z);
752
+ r3.x = bitcast<f32>(select(0u, 4294967295u, (r3.x < r2.w)));
753
+ r3.z = fma(r1.w, cb5_5.tint_symbol_3[6u].z, -5.0f);
754
+ r1.w = (r1.w * r1.w);
755
+ r1.w = fma(r1.w, 5.0f, r2.w);
756
+ let v_208 = bitcast<u32>(r3.x);
757
+ let v_209 = r3.z;
758
+ r1.w = select(r1.w, v_209, (v_208 != 0u));
759
+ let v_210 = (r2.xyx * vec3<f32>(-0.25f, 0.5f, 0.25f));
760
+ r2 = vec4<f32>(v_210.xy, r2.z, v_210.z);
761
+ r3.x = (abs(r2.zzzz).x + 1.0f);
762
+ let v_211 = (r2.xyw / r3.xxx);
763
+ r2 = vec4<f32>(v_211.xy, r2.z, v_211.z);
764
+ let v_212 = ((-(r2.xyxw)).xyw + vec3<f32>(0.75f, 0.5f, 0.25f));
765
+ r2 = vec4<f32>(v_212.xy, r2.z, v_212.z);
766
+ r2.z = bitcast<f32>(select(0u, 4294967295u, (0.0f < r2.z)));
767
+ let v_213 = bitcast<vec2<u32>>(r2.zz);
768
+ let v_214 = r2.xy;
769
+ let v_215 = select(r2.wy, v_214, (v_213 != vec2<u32>()));
770
+ r2 = vec4<f32>(v_215.xy, r2.zw);
771
+ let v_216 = r1.w;
772
+ r2 = textureSampleLevel(t1, s1, r2.xyxx.xy, v_216);
773
+ r1.x = max(r1.y, r1.x);
774
+ let v_217 = (r1.xxx * r2.xyz);
775
+ r1 = vec4<f32>(v_217.xy, r1.z, v_217.z);
776
+ let v_218 = (r3.yyy * r1.xyw);
777
+ r2 = vec4<f32>(v_218.xyz, r2.w);
778
+ let v_219 = (r2.xyz * vec3<f32>(0.68169009685516357422f));
779
+ r2 = vec4<f32>(v_219.xyz, r2.w);
780
+ let v_220 = fma(r1.xyw, vec3<f32>(0.31830990314483642578f), r2.xyz);
781
+ r1 = vec4<f32>(v_220.xy, r1.z, v_220.z);
782
+ let v_221 = fma(r1.xyw, r1.zzz, r0.xyz);
783
+ r0 = vec4<f32>(v_221.xyz, r0.w);
784
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
785
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
786
+ r0.w = dot(r6.xyz, r6.xyz);
787
+ r1.x = sqrt(r0.w);
788
+ let v_222 = -(cb3_3.tint_symbol_2[50u].xxxx);
789
+ r1.y = (r1.x + v_222.y);
790
+ r1.y = max(r1.y, 0.0f);
791
+ r1.x = (r1.y / r1.x);
792
+ r1.x = (r1.x * r6.z);
793
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
794
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
795
+ r1.w = (r1.z * -1.44269502162933349609f);
796
+ r1.w = exp2(r1.w);
797
+ r1.w = ((-(r1.wwww)).w + 1.0f);
798
+ r1.z = (r1.w / r1.z);
799
+ let v_223 = bitcast<u32>(r1.x);
800
+ r1.x = select(1.0f, r1.z, (v_223 != 0u));
801
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
802
+ r1.x = (r1.x * r1.z);
803
+ r1.x = min(r1.x, 1.0f);
804
+ r1.x = (r1.x * 1.44269502162933349609f);
805
+ r1.x = exp2(r1.x);
806
+ r1.x = min(r1.x, 1.0f);
807
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
808
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
809
+ r0.w = inverseSqrt(r0.w);
810
+ let v_224 = (r0.www * r6.xyz);
811
+ r2 = vec4<f32>(v_224.xyz, r2.w);
812
+ let v_225 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
813
+ r0.w = clamp(vec4<f32>(v_225, v_225, v_225, v_225).w, 0.0f, 1.0f);
814
+ r0.w = log2(r0.w);
815
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
816
+ r0.w = exp2(r0.w);
817
+ let v_226 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
818
+ r1.w = clamp(vec4<f32>(v_226, v_226, v_226, v_226).w, 0.0f, 1.0f);
819
+ r1.w = log2(r1.w);
820
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
821
+ r1.w = exp2(r1.w);
822
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
823
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
824
+ let v_227 = -(cb3_3.tint_symbol_2[52u].xxxx);
825
+ r2.x = (r1.y + v_227.x);
826
+ r2.x = max(r2.x, 0.0f);
827
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
828
+ r2.x = (r2.x * 1.44269502162933349609f);
829
+ r2.x = exp2(r2.x);
830
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
831
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
832
+ let v_228 = -(cb3_3.tint_symbol_2[51u].zzzz);
833
+ r1.y = (r1.y * v_228.y);
834
+ r1.y = (r1.y * 1.44269502162933349609f);
835
+ r1.y = exp2(r1.y);
836
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
837
+ let v_229 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
838
+ r2 = vec4<f32>(v_229.xyz, r2.w);
839
+ let v_230 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
840
+ r2 = vec4<f32>(v_230.xyz, r2.w);
841
+ let v_231 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
842
+ r3 = vec4<f32>(v_231.xyz, r3.w);
843
+ let v_232 = fma(r1.www, r3.xyz, r2.xyz);
844
+ r2 = vec4<f32>(v_232.xyz, r2.w);
845
+ let v_233 = -(cb3_3.tint_symbol_2[57u].xyzx);
846
+ let v_234 = (r2.xyz + v_233.xyz);
847
+ r2 = vec4<f32>(v_234.xyz, r2.w);
848
+ let v_235 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
849
+ r2 = vec4<f32>(v_235.xyz, r2.w);
850
+ r3.x = cb3_3.tint_symbol_2[55u].w;
851
+ r3.y = cb3_3.tint_symbol_2[56u].w;
852
+ r3.z = cb3_3.tint_symbol_2[57u].w;
853
+ let v_236 = ((-(r2.xyzx)).xyz + r3.xyz);
854
+ r3 = vec4<f32>(v_236.xyz, r3.w);
855
+ let v_237 = fma(r1.xxx, r3.xyz, r2.xyz);
856
+ r1 = vec4<f32>(v_237.xy, r1.z, v_237.z);
857
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
858
+ if ((bitcast<u32>(r0.w) != 0u)) {
859
+ let v_238 = (v8.xy * cb2_2.tint_symbol_1[18u].zw);
860
+ r2 = vec4<f32>(v_238.xy, r2.zw);
861
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
862
+ r0.w = (r2.x + -1.0f);
863
+ r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
864
+ } else {
865
+ r0.w = 1.0f;
866
+ }
867
+ let v_239 = -(r0.xyxz);
868
+ let v_240 = fma(r1.xyw, r0.www, v_239.xyw);
869
+ r1 = vec4<f32>(v_240.xy, r1.z, v_240.z);
870
+ let v_241 = fma(r1.zzz, r1.xyw, r0.xyz);
871
+ r1 = vec4<f32>(v_241.xyz, r1.w);
872
+ } else {
873
+ r0.w = dot(r6.xyz, r6.xyz);
874
+ r1.w = sqrt(r0.w);
875
+ let v_242 = -(cb3_3.tint_symbol_2[50u].xxxx);
876
+ r2.x = (r1.w + v_242.x);
877
+ r2.x = max(r2.x, 0.0f);
878
+ r1.w = (r2.x / r1.w);
879
+ r1.w = (r1.w * r6.z);
880
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z);
881
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
882
+ r2.z = (r2.y * -1.44269502162933349609f);
883
+ r2.z = exp2(r2.z);
884
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
885
+ r2.y = (r2.z / r2.y);
886
+ let v_243 = bitcast<u32>(r1.w);
887
+ r1.w = select(1.0f, r2.y, (v_243 != 0u));
888
+ r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w);
889
+ r1.w = (r1.w * r2.y);
890
+ r1.w = min(r1.w, 1.0f);
891
+ r1.w = (r1.w * 1.44269502162933349609f);
892
+ r1.w = exp2(r1.w);
893
+ r1.w = min(r1.w, 1.0f);
894
+ r1.w = ((-(r1.wwww)).w + 1.0f);
895
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y);
896
+ r0.w = inverseSqrt(r0.w);
897
+ let v_244 = (r0.www * r6.xyz);
898
+ r3 = vec4<f32>(v_244.xyz, r3.w);
899
+ let v_245 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
900
+ r0.w = clamp(vec4<f32>(v_245, v_245, v_245, v_245).w, 0.0f, 1.0f);
901
+ r0.w = log2(r0.w);
902
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
903
+ r0.w = exp2(r0.w);
904
+ let v_246 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
905
+ r2.z = clamp(vec4<f32>(v_246, v_246, v_246, v_246).z, 0.0f, 1.0f);
906
+ r2.z = log2(r2.z);
907
+ r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w);
908
+ r2.z = exp2(r2.z);
909
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f);
910
+ r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y);
911
+ let v_247 = -(cb3_3.tint_symbol_2[52u].xxxx);
912
+ r2.w = (r2.x + v_247.w);
913
+ r2.w = max(r2.w, 0.0f);
914
+ r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x);
915
+ r2.w = (r2.w * 1.44269502162933349609f);
916
+ r2.w = exp2(r2.w);
917
+ r2.w = ((-(r2.wwww)).w + 1.0f);
918
+ r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f);
919
+ let v_248 = -(cb3_3.tint_symbol_2[51u].zzzz);
920
+ r2.x = (r2.x * v_248.x);
921
+ r2.x = (r2.x * 1.44269502162933349609f);
922
+ r2.x = exp2(r2.x);
923
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
924
+ let v_249 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
925
+ r3 = vec4<f32>(v_249.xyz, r3.w);
926
+ let v_250 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
927
+ r3 = vec4<f32>(v_250.xyz, r3.w);
928
+ let v_251 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
929
+ r4 = vec4<f32>(v_251.xyz, r4.w);
930
+ let v_252 = fma(r2.zzz, r4.xyz, r3.xyz);
931
+ r3 = vec4<f32>(v_252.xyz, r3.w);
932
+ let v_253 = -(cb3_3.tint_symbol_2[57u].xyzx);
933
+ let v_254 = (r3.xyz + v_253.xyz);
934
+ r3 = vec4<f32>(v_254.xyz, r3.w);
935
+ let v_255 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
936
+ r2 = vec4<f32>(v_255.x, r2.y, v_255.yz);
937
+ r3.x = cb3_3.tint_symbol_2[55u].w;
938
+ r3.y = cb3_3.tint_symbol_2[56u].w;
939
+ r3.z = cb3_3.tint_symbol_2[57u].w;
940
+ let v_256 = ((-(r2.xzwx)).xyz + r3.xyz);
941
+ r3 = vec4<f32>(v_256.xyz, r3.w);
942
+ let v_257 = fma(r1.www, r3.xyz, r2.xzw);
943
+ r2 = vec4<f32>(v_257.x, r2.y, v_257.yz);
944
+ let v_258 = ((-(r0.xxyz)).xzw + r2.xzw);
945
+ r2 = vec4<f32>(v_258.x, r2.y, v_258.yz);
946
+ let v_259 = fma(r2.yyy, r2.xzw, r0.xyz);
947
+ r1 = vec4<f32>(v_259.xyz, r1.w);
948
+ }
949
+ let v_260 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
950
+ o0 = vec4<f32>(v_260.xyz, o0.w);
951
+ }
952
+
953
+ @fragment
954
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @location(7u) v7 : vec4<f32>, @builtin(position) v_261 : vec4<f32>) -> @location(0u) vec4<f32> {
955
+ main_inner(v0, v1, v2, v3, v5, v6, v7, v_261);
956
+ return o0;
957
+ }
b/8b0b5899ed/shaders/00e6b4c4b7cbbb2d.wgsl ADDED
@@ -0,0 +1,415 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ enable clip_distances;
2
+ diagnostic(off, derivative_uniformity);
3
+
4
+ var<private> r0 : vec4<f32>;
5
+
6
+ var<private> r1 : vec4<f32>;
7
+
8
+ var<private> r2 : vec4<f32>;
9
+
10
+ var<private> r3 : vec4<f32>;
11
+
12
+ var<private> r4 : vec4<f32>;
13
+
14
+ var<private> r5 : vec4<f32>;
15
+
16
+ var<private> r6 : vec4<f32>;
17
+
18
+ var<private> r7 : vec4<f32>;
19
+
20
+ var<private> r8 : vec4<f32>;
21
+
22
+ struct cb16_struct {
23
+ tint_symbol : array<vec4<f32>, 16u>,
24
+ }
25
+
26
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
27
+
28
+ struct cb1_struct {
29
+ tint_symbol_1 : array<vec4<f32>, 1u>,
30
+ }
31
+
32
+ @group(0u) @binding(0u) var<uniform> cb0_0 : cb1_struct;
33
+
34
+ struct cb1_struct_1 {
35
+ tint_symbol_2 : array<vec4<f32>, 1u>,
36
+ }
37
+
38
+ @group(0u) @binding(7u) var<uniform> cb7_7 : cb1_struct_1;
39
+
40
+ struct cb5_struct {
41
+ tint_symbol_3 : array<vec4<f32>, 5u>,
42
+ }
43
+
44
+ @group(0u) @binding(12u) var<uniform> cb12_12 : cb5_struct;
45
+
46
+ @group(0u) @binding(18u) var s2 : sampler;
47
+
48
+ @group(0u) @binding(34u) var t2 : texture_2d<f32>;
49
+
50
+ var<private> o0 : vec4<f32>;
51
+
52
+ var<private> o1 : vec4<f32>;
53
+
54
+ var<private> o2 : vec4<f32>;
55
+
56
+ var<private> o3 : vec4<f32>;
57
+
58
+ var<private> o4 : vec4<f32>;
59
+
60
+ var<private> o5 : vec4<f32>;
61
+
62
+ var<private> o6 : array<f32, 4u>;
63
+
64
+ var<private> v : vec4<f32>;
65
+
66
+ var<private> x0 : array<vec4<f32>, 1u>;
67
+
68
+ fn main_inner(v0 : vec3<f32>, v1 : vec4<f32>, v2 : vec2<f32>, v3 : vec3<f32>) {
69
+ if ((bitcast<u32>(cb7_7.tint_symbol_2[0u].x) != 0u)) {
70
+ let v_1 = (v0 + cb12_12.tint_symbol_3[1u].xyz);
71
+ r0 = vec4<f32>(v_1.xyz, r0.w);
72
+ r0.w = dot(r0.xyz, r0.xyz);
73
+ r0.w = sqrt(r0.w);
74
+ let v_2 = (r0.xyz / r0.www);
75
+ r0 = vec4<f32>(v_2.xyz, r0.w);
76
+ r0.z = ((-(r0.zzzz)).z + 1.0f);
77
+ r0.z = (r0.z * 0.5f);
78
+ r1.x = dot(r0.xy, r0.xy);
79
+ r1.x = max(r1.x, 0.00000000999999993923f);
80
+ r1.x = sqrt(r1.x);
81
+ r1 = (r0.xyxy / r1.xxxx);
82
+ r1 = (r0.zzzz * r1);
83
+ r1 = fma(r1, vec4<f32>(0.5f), vec4<f32>(0.5f));
84
+ let v_3 = (r1.zw * vec2<f32>(126.73267364501953125f));
85
+ r0 = vec4<f32>(v_3.xy, r0.zw);
86
+ let v_4 = -(r0.xyxx);
87
+ let v_5 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r0.xy >= v_4.xy)));
88
+ r2 = vec4<f32>(v_5.xy, r2.zw);
89
+ let v_6 = fract(abs(r0.xyxx).xy);
90
+ r0 = vec4<f32>(v_6.xy, r0.zw);
91
+ let v_7 = -(r0.xyxx);
92
+ let v_8 = bitcast<vec2<u32>>(r2.xy);
93
+ let v_9 = select(v_7.xy, r0.xy, (v_8 != vec2<u32>()));
94
+ r0 = vec4<f32>(v_9.xy, r0.zw);
95
+ r2 = textureSampleLevel(t2, s2, r1.zwzz.xy, 0.0f);
96
+ r1 = fma(-(r0.xyxy), vec4<f32>(0.00789062492549419403f), r1);
97
+ r3 = (r1.zwzw + vec4<f32>(0.00789062492549419403f, 0.0f, 0.0f, 0.00789062492549419403f));
98
+ r4 = textureSampleLevel(t2, s2, r3.xyxx.xy, 0.0f);
99
+ r3 = textureSampleLevel(t2, s2, r3.zwzz.xy, 0.0f);
100
+ r5 = (r1.zwzw + vec4<f32>(0.00789062492549419403f, 0.00789062492549419403f, -0.5f, -0.5f));
101
+ r6 = textureSampleLevel(t2, s2, r5.xyxx.xy, 0.0f);
102
+ let v_10 = ((-(r0.xyxx)).xy + vec2<f32>(1.0f));
103
+ r5 = vec4<f32>(v_10.xy, r5.zw);
104
+ let v_11 = (r2.xyz * r5.xxx);
105
+ r7 = vec4<f32>(v_11.xyz, r7.w);
106
+ let v_12 = (r0.xxx * r4.xyz);
107
+ r8 = vec4<f32>(v_12.xyz, r8.w);
108
+ let v_13 = (r5.yyy * r8.xyz);
109
+ r8 = vec4<f32>(v_13.xyz, r8.w);
110
+ let v_14 = fma(r7.xyz, r5.yyy, r8.xyz);
111
+ r7 = vec4<f32>(v_14.xyz, r7.w);
112
+ let v_15 = (r3.xyz * r5.xxx);
113
+ r8 = vec4<f32>(v_15.xyz, r8.w);
114
+ let v_16 = fma(r8.xyz, r0.yyy, r7.xyz);
115
+ r7 = vec4<f32>(v_16.xyz, r7.w);
116
+ let v_17 = (r0.xxx * r6.xyz);
117
+ r6 = vec4<f32>(v_17.xyz, r6.w);
118
+ let v_18 = fma(r6.xyz, r0.yyy, r7.xyz);
119
+ r0 = vec4<f32>(v_18.xyz, r0.w);
120
+ r0.w = (r0.w / cb12_12.tint_symbol_3[0u].x);
121
+ r0.w = min(r0.w, 1.0f);
122
+ let v_19 = (r0.www * r0.xyz);
123
+ r0 = vec4<f32>(v_19.xyz, r0.w);
124
+ let v_20 = (r0.xyz * cb12_12.tint_symbol_3[0u].yyy);
125
+ r0 = vec4<f32>(v_20.xyz, r0.w);
126
+ let v_21 = fma(r0.xyz, v1.yyy, v0);
127
+ r6 = vec4<f32>(v_21.xyz, r6.w);
128
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb12_12.tint_symbol_3[2u].w)));
129
+ let v_22 = -(cb12_12.tint_symbol_3[1u].xyzx);
130
+ let v_23 = (v_22.xyz + cb12_12.tint_symbol_3[2u].xyz);
131
+ r7 = vec4<f32>(v_23.xyz, r7.w);
132
+ let v_24 = -(r7.xxyz);
133
+ let v_25 = (r6.xyz + v_24.xzw);
134
+ r7 = vec4<f32>(v_25.x, r7.y, v_25.yz);
135
+ r0.y = dot(r7.xzw, r7.xzw);
136
+ r0.y = sqrt(r0.y);
137
+ r0.z = (cb12_12.tint_symbol_3[2u].w * 1.10000002384185791016f);
138
+ r2.w = clamp(((r0.yyyy / r0.zzzz)).w, 0.0f, 1.0f);
139
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r2.w < 1.0f)));
140
+ r0.y = (r7.z / r0.y);
141
+ r2.w = fma(r2.w, 0.10000000149011611938f, 0.89999997615814208984f);
142
+ r0.y = (r0.y * r2.w);
143
+ r0.y = fma(r0.y, r0.z, r7.y);
144
+ let v_26 = bitcast<u32>(r3.w);
145
+ let v_27 = r0.y;
146
+ r0.y = select(r6.y, v_27, (v_26 != 0u));
147
+ let v_28 = bitcast<u32>(r0.x);
148
+ let v_29 = r0.y;
149
+ r6.w = select(r6.y, v_29, (v_28 != 0u));
150
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb12_12.tint_symbol_3[3u].w)));
151
+ let v_30 = (v_22.xyz + cb12_12.tint_symbol_3[3u].xyz);
152
+ r7 = vec4<f32>(v_30.xyz, r7.w);
153
+ let v_31 = -(r7.xxyz);
154
+ let v_32 = (r6.xwz + v_31.xzw);
155
+ r7 = vec4<f32>(v_32.x, r7.y, v_32.yz);
156
+ r0.y = dot(r7.xzw, r7.xzw);
157
+ r0.y = sqrt(r0.y);
158
+ r0.z = (cb12_12.tint_symbol_3[3u].w * 1.10000002384185791016f);
159
+ r2.w = clamp(((r0.yyyy / r0.zzzz)).w, 0.0f, 1.0f);
160
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r2.w < 1.0f)));
161
+ r0.y = (r7.z / r0.y);
162
+ r2.w = fma(r2.w, 0.10000000149011611938f, 0.89999997615814208984f);
163
+ r0.y = (r0.y * r2.w);
164
+ r0.y = fma(r0.y, r0.z, r7.y);
165
+ let v_33 = bitcast<u32>(r3.w);
166
+ let v_34 = r0.y;
167
+ r0.y = select(r6.w, v_34, (v_33 != 0u));
168
+ let v_35 = bitcast<u32>(r0.x);
169
+ let v_36 = r0.y;
170
+ r0.x = select(r6.w, v_36, (v_35 != 0u));
171
+ let v_37 = (r5.zw + r5.zw);
172
+ let v_38 = r0;
173
+ r0 = vec4<f32>(v_38.x, v_37.xy, v_38.w);
174
+ r2.w = dot(r0.yz, r0.yz);
175
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < r2.w)));
176
+ r2.w = sqrt(r2.w);
177
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) & bitcast<u32>(r3.w)));
178
+ r3.w = fma((-(r2.wwww)).w, 2.0f, 1.0f);
179
+ r5.z = max(r3.w, -1.0f);
180
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r5.z < 1.0f)));
181
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (-1.0f < r5.z)));
182
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) & bitcast<u32>(r4.w)));
183
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < r2.w)));
184
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) & bitcast<u32>(r4.w)));
185
+ r4.w = fma((-(r5.zzzz)).w, r5.z, 1.0f);
186
+ r4.w = sqrt(r4.w);
187
+ r2.w = (r4.w / r2.w);
188
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) & bitcast<u32>(r3.w)));
189
+ let v_39 = (r0.yz * r2.ww);
190
+ r5 = vec4<f32>(v_39.xy, r5.zw);
191
+ let v_40 = (r0.www * r2.xyz);
192
+ r2 = vec4<f32>(v_40.xyz, r2.w);
193
+ let v_41 = (r2.xyz * cb12_12.tint_symbol_3[0u].yyy);
194
+ r2 = vec4<f32>(v_41.xyz, r2.w);
195
+ r1 = (r1 + vec4<f32>(-0.49210938811302185059f, -0.5f, -0.5f, -0.49210938811302185059f));
196
+ r1 = (r1 + r1);
197
+ r0.y = dot(r1.xy, r1.xy);
198
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.y)));
199
+ r0.y = sqrt(r0.y);
200
+ r0.y = bitcast<f32>((bitcast<u32>(r0.y) & bitcast<u32>(r0.z)));
201
+ r0.z = fma((-(r0.yyyy)).z, 2.0f, 1.0f);
202
+ r7.z = max(r0.z, -1.0f);
203
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (r7.z < 1.0f)));
204
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (-1.0f < r7.z)));
205
+ r0.z = bitcast<f32>((bitcast<u32>(r0.z) & bitcast<u32>(r2.w)));
206
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.y)));
207
+ r0.z = bitcast<f32>((bitcast<u32>(r0.z) & bitcast<u32>(r2.w)));
208
+ r2.w = fma((-(r7.zzzz)).w, r7.z, 1.0f);
209
+ r2.w = sqrt(r2.w);
210
+ r0.y = (r2.w / r0.y);
211
+ r0.y = bitcast<f32>((bitcast<u32>(r0.y) & bitcast<u32>(r0.z)));
212
+ let v_42 = (r0.yy * r1.xy);
213
+ r7 = vec4<f32>(v_42.xy, r7.zw);
214
+ let v_43 = (r0.www * r4.xyz);
215
+ r4 = vec4<f32>(v_43.xyz, r4.w);
216
+ let v_44 = ((-(r5.xyzx)).xyz + r7.xyz);
217
+ r7 = vec4<f32>(v_44.xyz, r7.w);
218
+ let v_45 = -(r2.xyzx);
219
+ let v_46 = fma(r4.xyz, cb12_12.tint_symbol_3[0u].yyy, v_45.xyz);
220
+ r4 = vec4<f32>(v_46.xyz, r4.w);
221
+ r0.y = dot(r4.xyz, v3);
222
+ r0.z = dot(r7.xyz, r7.xyz);
223
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.z)));
224
+ r4.x = (r0.y / r0.z);
225
+ r4.y = 1.0f;
226
+ let v_47 = (r7.xyz * r4.xyx);
227
+ r7 = vec4<f32>(v_47.xyz, r7.w);
228
+ r4.z = v1.y;
229
+ let v_48 = (r4.zxz * r7.xyz);
230
+ r4 = vec4<f32>(v_48.xyz, r4.w);
231
+ let v_49 = r7;
232
+ r7 = vec4<f32>(0.10000000149011611938f, v_49.y, 0.33329999446868896484f, v_49.w);
233
+ r7.y = v1.y;
234
+ let v_50 = fma(r4.xyz, r7.xyz, v3);
235
+ r4 = vec4<f32>(v_50.xyz, r4.w);
236
+ let v_51 = bitcast<vec3<u32>>(r1.xxx);
237
+ let v_52 = select(v3, r4.xyz, (v_51 != vec3<u32>()));
238
+ r4 = vec4<f32>(v_52.xyz, r4.w);
239
+ r0.y = dot(r1.zw, r1.zw);
240
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.y)));
241
+ r0.y = sqrt(r0.y);
242
+ r0.y = bitcast<f32>((bitcast<u32>(r0.y) & bitcast<u32>(r0.z)));
243
+ r0.z = fma((-(r0.yyyy)).z, 2.0f, 1.0f);
244
+ r8.z = max(r0.z, -1.0f);
245
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (r8.z < 1.0f)));
246
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (-1.0f < r8.z)));
247
+ r0.z = bitcast<f32>((bitcast<u32>(r0.z) & bitcast<u32>(r1.x)));
248
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.y)));
249
+ r0.z = bitcast<f32>((bitcast<u32>(r0.z) & bitcast<u32>(r1.x)));
250
+ r1.x = fma((-(r8.zzzz)).x, r8.z, 1.0f);
251
+ r1.x = sqrt(r1.x);
252
+ r0.y = (r1.x / r0.y);
253
+ r0.y = bitcast<f32>((bitcast<u32>(r0.y) & bitcast<u32>(r0.z)));
254
+ let v_53 = (r0.yy * r1.zw);
255
+ r8 = vec4<f32>(v_53.xy, r8.zw);
256
+ let v_54 = (r0.www * r3.xyz);
257
+ r0 = vec4<f32>(r0.x, v_54.xyz);
258
+ let v_55 = ((-(r5.xyzx)).xyz + r8.xyz);
259
+ r1 = vec4<f32>(v_55.xyz, r1.w);
260
+ let v_56 = -(r2.xxyz);
261
+ let v_57 = fma(r0.yzw, cb12_12.tint_symbol_3[0u].yyy, v_56.yzw);
262
+ r0 = vec4<f32>(r0.x, v_57.xyz);
263
+ r0.y = dot(r0.yzw, v3);
264
+ r0.z = dot(r1.xyz, r1.xyz);
265
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < r0.z)));
266
+ r2.x = (r0.y / r0.z);
267
+ r2.y = 1.0f;
268
+ let v_58 = (r1.xyz * r2.xyx);
269
+ r1 = vec4<f32>(v_58.xyz, r1.w);
270
+ r2.z = v1.y;
271
+ let v_59 = (r1.xyz * r2.zxz);
272
+ r1 = vec4<f32>(v_59.xyz, r1.w);
273
+ let v_60 = fma(r1.xyz, r7.xyz, r4.xyz);
274
+ r1 = vec4<f32>(v_60.xyz, r1.w);
275
+ let v_61 = bitcast<vec3<u32>>(r0.www);
276
+ let v_62 = r1.xyz;
277
+ let v_63 = select(r4.xyz, v_62, (v_61 != vec3<u32>()));
278
+ r0 = vec4<f32>(r0.x, v_63.xyz);
279
+ let v_64 = (r0.yzw + vec3<f32>(0.00009999999747378752f));
280
+ r0 = vec4<f32>(r0.x, v_64.xyz);
281
+ r1.x = dot(r0.yzw, r0.yzw);
282
+ r1.x = inverseSqrt(r1.x);
283
+ let v_65 = (r0.yzw * r1.xxx);
284
+ r0 = vec4<f32>(r0.x, v_65.xyz);
285
+ } else {
286
+ r0.x = v0.y;
287
+ let v_66 = v0.xz;
288
+ let v_67 = r6;
289
+ r6 = vec4<f32>(v_66.x, v_67.y, v_66.y, v_67.w);
290
+ r0 = vec4<f32>(r0.x, v3.xyz);
291
+ }
292
+ let v_68 = (r0.xxx * cb1_1.tint_symbol[1u].xyz);
293
+ r1 = vec4<f32>(v_68.xyz, r1.w);
294
+ let v_69 = fma(r6.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz);
295
+ r1 = vec4<f32>(v_69.xyz, r1.w);
296
+ let v_70 = fma(r6.zzz, cb1_1.tint_symbol[2u].xyz, r1.xyz);
297
+ r1 = vec4<f32>(v_70.xyz, r1.w);
298
+ let v_71 = (r1.xyz + cb1_1.tint_symbol[3u].xyz);
299
+ r1 = vec4<f32>(v_71.xyz, r1.w);
300
+ o3 = (((-(r1.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz)).xyzx;
301
+ let v_72 = (r0.zzz * cb1_1.tint_symbol[1u].xyz);
302
+ r2 = vec4<f32>(v_72.xyz, r2.w);
303
+ let v_73 = fma(r0.yyy, cb1_1.tint_symbol[0u].xyz, r2.xyz);
304
+ r2 = vec4<f32>(v_73.xyz, r2.w);
305
+ o1 = fma(r0.www, cb1_1.tint_symbol[2u].xyz, r2.xyz).xyzx;
306
+ if ((bitcast<u32>(cb12_12.tint_symbol_3[4u].x) != 0u)) {
307
+ let v_74 = (v0 + cb12_12.tint_symbol_3[1u].xyz);
308
+ r0 = vec4<f32>(r0.x, v_74.xyz);
309
+ r1.w = dot(r0.yzw, r0.yzw);
310
+ r1.w = sqrt(r1.w);
311
+ let v_75 = (r0.yzw / r1.www);
312
+ r0 = vec4<f32>(r0.x, v_75.xyz);
313
+ r0.w = ((-(r0.wwww)).w + 1.0f);
314
+ r0.w = (r0.w * 0.5f);
315
+ r2.x = dot(r0.yz, r0.yz);
316
+ r2.x = max(r2.x, 0.00000000999999993923f);
317
+ r2.x = sqrt(r2.x);
318
+ let v_76 = (r0.yz / r2.xx);
319
+ let v_77 = r0;
320
+ r0 = vec4<f32>(v_77.x, v_76.xy, v_77.w);
321
+ let v_78 = (r0.ww * r0.yz);
322
+ let v_79 = r0;
323
+ r0 = vec4<f32>(v_79.x, v_78.xy, v_79.w);
324
+ let v_80 = fma(r0.yz, vec2<f32>(0.5f), vec2<f32>(0.5f));
325
+ let v_81 = r0;
326
+ r0 = vec4<f32>(v_81.x, v_80.xy, v_81.w);
327
+ let v_82 = (r0.yz * vec2<f32>(126.73267364501953125f));
328
+ r2 = vec4<f32>(v_82.xy, r2.zw);
329
+ let v_83 = -(r2.xxxy);
330
+ let v_84 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (r2.xy >= v_83.zw)));
331
+ r2 = vec4<f32>(r2.xy, v_84.xy);
332
+ let v_85 = fract(abs(r2.xyxx).xy);
333
+ r2 = vec4<f32>(v_85.xy, r2.zw);
334
+ let v_86 = -(r2.xyxx);
335
+ let v_87 = bitcast<vec2<u32>>(r2.zw);
336
+ let v_88 = select(v_86.xy, r2.xy, (v_87 != vec2<u32>()));
337
+ r2 = vec4<f32>(v_88.xy, r2.zw);
338
+ r3 = textureSampleLevel(t2, s2, r0.yzyy.xy, 0.0f);
339
+ let v_89 = fma((-(r2.xxyx)).yz, vec2<f32>(0.00789062492549419403f), r0.yz);
340
+ let v_90 = r0;
341
+ r0 = vec4<f32>(v_90.x, v_89.xy, v_90.w);
342
+ r4 = (r0.yzyz + vec4<f32>(0.00789062492549419403f, 0.0f, 0.0f, 0.00789062492549419403f));
343
+ r5 = textureSampleLevel(t2, s2, r4.xyxx.xy, 0.0f);
344
+ r4 = textureSampleLevel(t2, s2, r4.zwzz.xy, 0.0f);
345
+ let v_91 = (r0.yz + vec2<f32>(0.00789062492549419403f));
346
+ let v_92 = r0;
347
+ r0 = vec4<f32>(v_92.x, v_91.xy, v_92.w);
348
+ r7 = textureSampleLevel(t2, s2, r0.yzyy.xy, 0.0f);
349
+ let v_93 = ((-(r2.xxyx)).yz + vec2<f32>(1.0f));
350
+ let v_94 = r0;
351
+ r0 = vec4<f32>(v_94.x, v_93.xy, v_94.w);
352
+ r3 = (r0.yyyy * r3);
353
+ r5 = (r2.xxxx * r5);
354
+ r5 = (r0.zzzz * r5);
355
+ r3 = fma(r3, r0.zzzz, r5);
356
+ r4 = (r0.yyyy * r4);
357
+ r3 = fma(r4, r2.yyyy, r3);
358
+ r4 = (r2.xxxx * r7);
359
+ r2 = fma(r4, r2.yyyy, r3);
360
+ r0.y = (r1.w / cb12_12.tint_symbol_3[0u].x);
361
+ r0.y = min(r0.y, 1.0f);
362
+ r2 = (r0.yyyy * r2);
363
+ r2 = fma(r2, vec4<f32>(0.5f), vec4<f32>(0.5f));
364
+ } else {
365
+ r2 = v1;
366
+ }
367
+ r3.x = v1.y;
368
+ r3.w = 1.0f;
369
+ let v_95 = bitcast<vec4<u32>>(cb12_12.tint_symbol_3[4u].yyyy);
370
+ let v_96 = r3.xxxw;
371
+ o4 = select(r2, v_96, (v_95 != vec4<u32>()));
372
+ r0 = (r0.xxxx * cb1_1.tint_symbol[9u]);
373
+ r0 = fma(r6.xxxx, cb1_1.tint_symbol[8u], r0);
374
+ r0 = fma(r6.zzzz, cb1_1.tint_symbol[10u], r0);
375
+ r0 = (r0 + cb1_1.tint_symbol[11u]);
376
+ x0[0u].x = dot(r0, cb0_0.tint_symbol_1[0u]);
377
+ let v_97 = r1;
378
+ o2 = vec4<f32>(v_97.xyz, o2.w);
379
+ o2.w = 1.0f;
380
+ o5 = r0;
381
+ let v_98 = &(x0[0u]);
382
+ *(v_98) = vec4<f32>((*(v_98)).x, vec3<f32>());
383
+ o0 = vec3<f32>(v2.xy, o0.xyz.z).xyzx;
384
+ o0.z = r0.w;
385
+ o6[0u] = x0[0u].x;
386
+ o6[1u] = x0[0u].y;
387
+ o6[2u] = x0[0u].z;
388
+ o6[3u] = x0[0u].w;
389
+ v = vec4<f32>(o6[0u], o6[1u], o6[2u], o6[3u]);
390
+ }
391
+
392
+ struct tint_symbol_5 {
393
+ @location(0u)
394
+ o0 : vec4<f32>,
395
+ @location(1u)
396
+ o1 : vec4<f32>,
397
+ @location(2u)
398
+ o2 : vec4<f32>,
399
+ @location(3u)
400
+ o3 : vec4<f32>,
401
+ @location(4u)
402
+ o4 : vec4<f32>,
403
+ @builtin(position)
404
+ o5 : vec4<f32>,
405
+ @builtin(clip_distances)
406
+ o6 : array<f32, 4u>,
407
+ @location(15u)
408
+ tint_symbol_4 : vec4<f32>,
409
+ }
410
+
411
+ @vertex
412
+ fn main(@location(0u) v0 : vec3<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec2<f32>, @location(3u) v3 : vec3<f32>) -> tint_symbol_5 {
413
+ main_inner(v0, v1, v2, v3);
414
+ return tint_symbol_5(o0, o1, o2, o3, o4, o5, o6, v);
415
+ }
b/8b0b5899ed/shaders/00edbec406bcb4a0.wgsl ADDED
@@ -0,0 +1,306 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ struct cb15_struct {
18
+ tint_symbol : array<vec4<f32>, 15u>,
19
+ }
20
+
21
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb15_struct;
22
+
23
+ struct cb17_struct {
24
+ tint_symbol_1 : array<vec4<f32>, 17u>,
25
+ }
26
+
27
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
28
+
29
+ struct cb50_struct {
30
+ tint_symbol_2 : array<vec4<f32>, 50u>,
31
+ }
32
+
33
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb50_struct;
34
+
35
+ struct cb4_struct {
36
+ tint_symbol_3 : array<vec4<f32>, 4u>,
37
+ }
38
+
39
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb4_struct;
40
+
41
+ struct cb18_struct {
42
+ tint_symbol_4 : array<vec4<f32>, 18u>,
43
+ }
44
+
45
+ @group(1u) @binding(13u) var<uniform> cb13_13 : cb18_struct;
46
+
47
+ struct cb4_struct_1 {
48
+ tint_symbol_5 : array<vec4<f32>, 4u>,
49
+ }
50
+
51
+ @group(1u) @binding(10u) var<uniform> cb10_10 : cb4_struct_1;
52
+
53
+ struct cb1_struct {
54
+ tint_symbol_6 : array<vec4<f32>, 1u>,
55
+ }
56
+
57
+ @group(1u) @binding(8u) var<uniform> cb8_8 : cb1_struct;
58
+
59
+ @group(1u) @binding(16u) var s0 : sampler;
60
+
61
+ @group(1u) @binding(19u) var s3 : sampler;
62
+
63
+ @group(1u) @binding(20u) var s4 : sampler;
64
+
65
+ @group(1u) @binding(21u) var s5 : sampler;
66
+
67
+ @group(1u) @binding(22u) var s6 : sampler;
68
+
69
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
70
+
71
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
72
+
73
+ @group(1u) @binding(36u) var t4 : texture_2d<f32>;
74
+
75
+ @group(1u) @binding(37u) var t5 : texture_2d<f32>;
76
+
77
+ @group(1u) @binding(38u) var t6 : texture_2d<f32>;
78
+
79
+ var<private> v0 : vec4<f32>;
80
+
81
+ var<private> o0 : vec4<f32>;
82
+
83
+ var<private> o1 : vec4<f32>;
84
+
85
+ var<private> o2 : vec4<f32>;
86
+
87
+ var<private> o3 : vec4<f32>;
88
+
89
+ fn main_inner(v : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v7 : vec4<f32>) {
90
+ var v_1 : vec4<f32> = v;
91
+ v_1.w = (1.0f / v.w);
92
+ v0 = v_1;
93
+ r0 = textureSample(t0, s0, v1.xyxx.xy);
94
+ r1.x = bitcast<f32>(select(0u, 4294967295u, !((0.0f == v1.w))));
95
+ if ((bitcast<u32>(r1.x) != 0u)) {
96
+ r1 = textureSample(t6, s6, v1.xyxx.xy);
97
+ let v_2 = -(r0.xyzx);
98
+ let v_3 = fma(r1.xyz, cb13_13.tint_symbol_4[9u].xyz, v_2.xyz);
99
+ r1 = vec4<f32>(v_3.xyz, r1.w);
100
+ let v_4 = fma(v1.www, r1.xyz, r0.xyz);
101
+ r0 = vec4<f32>(v_4.xyz, r0.w);
102
+ }
103
+ let v_5 = (v1.xy * cb10_10.tint_symbol_5[2u].xy);
104
+ r1 = vec4<f32>(v_5.xy, r1.zw);
105
+ let v_6 = (r1.xy * vec2<f32>(0.5f));
106
+ r1 = vec4<f32>(v_6.xy, r1.zw);
107
+ r1 = textureSample(t3, s3, r1.xyxx.xy);
108
+ r1.y = clamp(fma(r1.wwww, vec4<f32>(2.0f), cb8_8.tint_symbol_6[0u].xxxx).y, 0.0f, 1.0f);
109
+ r0.w = (r0.w * r1.y);
110
+ r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
111
+ r1.y = dot(v0.xy, vec2<f32>(0.5f));
112
+ r1.y = fract(r1.y);
113
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (r1.y < 0.5f)));
114
+ let v_7 = bitcast<vec2<f32>>(select(vec2<u32>(), vec2<u32>(4294967295u), (vec2<f32>(0.94999998807907104492f, 0.50196081399917602539f) >= r0.ww)));
115
+ r1 = vec4<f32>(r1.xy, v_7.xy);
116
+ r1.y = bitcast<f32>((bitcast<u32>(r1.z) & bitcast<u32>(r1.y)));
117
+ r1.y = bitcast<f32>((bitcast<u32>(r1.w) | bitcast<u32>(r1.y)));
118
+ v_8((bitcast<u32>(r1.y) != 0u));
119
+ r2 = textureSample(t4, s4, v1.xyxx.xy);
120
+ let v_9 = fma(r2.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
121
+ let v_10 = r1;
122
+ r1 = vec4<f32>(v_10.x, v_9.xy, v_10.w);
123
+ r1.w = dot(r1.yz, r1.yz);
124
+ r1.w = ((-(r1.wwww)).w + 1.0f);
125
+ r1.w = sqrt(abs(r1.wwww).w);
126
+ r2.x = max(cb10_10.tint_symbol_5[3u].x, 0.00100000004749745131f);
127
+ let v_11 = (r1.yz * r2.xx);
128
+ let v_12 = r1;
129
+ r1 = vec4<f32>(v_12.x, v_11.xy, v_12.w);
130
+ let v_13 = (r1.zzz * v6.xyz);
131
+ r2 = vec4<f32>(v_13.xyz, r2.w);
132
+ let v_14 = fma(r1.yyy, v5.xyz, r2.xyz);
133
+ r2 = vec4<f32>(v_14.xyz, r2.w);
134
+ let v_15 = fma(r1.www, v2.xyz, r2.xyz);
135
+ r1 = vec4<f32>(r1.x, v_15.xyz);
136
+ r2.x = dot(r1.yzw, r1.yzw);
137
+ r2.x = inverseSqrt(r2.x);
138
+ let v_16 = (r1.yzw * r2.xxx);
139
+ r2 = vec4<f32>(r2.x, v_16.xyz);
140
+ r3 = textureSample(t5, s5, v1.xyxx.xy);
141
+ let v_17 = (r3.yx * r3.yx);
142
+ let v_18 = r1;
143
+ r1 = vec4<f32>(v_18.x, v_17.xy, v_18.w);
144
+ r3.x = bitcast<f32>(select(0u, 4294967295u, (r3.z >= 0.8125f)));
145
+ o1.w = clamp(fma(v2.xyz.zzzz, vec4<f32>(128.0f), vec4<f32>(-127.0f)).w, 0.0f, 1.0f);
146
+ let v_19 = (v3.xx * cb2_2.tint_symbol_1[15u].zy);
147
+ let v_20 = r3;
148
+ r3 = vec4<f32>(v_20.x, v_19.x, v_20.z, v_19.y);
149
+ r4.x = fma(r2.w, 0.5f, 0.5f);
150
+ r4.y = fma(r4.x, cb5_5.tint_symbol_3[3u].y, cb5_5.tint_symbol_3[3u].x);
151
+ r4.x = (r4.x + 0.30000001192092895508f);
152
+ r3.w = (r3.w * r4.x);
153
+ let v_21 = (v1.zz + vec2<f32>(0.0f, -0.75f));
154
+ let v_22 = r4;
155
+ r4 = vec4<f32>(v_21.x, v_22.y, v_21.y, v_22.w);
156
+ let v_23 = clamp(((r4.xxzx * vec4<f32>(4.0f, 0.0f, 4.0f, 0.0f))).xz, vec2<f32>(), vec2<f32>(1.0f));
157
+ let v_24 = r4;
158
+ r4 = vec4<f32>(v_23.x, v_24.y, v_23.y, v_24.w);
159
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r3.x) == 0i)));
160
+ let v_25 = (r0.xyz * cb13_13.tint_symbol_4[17u].xxx);
161
+ r5 = vec4<f32>(v_25.xyz, r5.w);
162
+ let v_26 = (r4.xxx * r5.xyz);
163
+ r5 = vec4<f32>(v_26.xyz, r5.w);
164
+ let v_27 = bitcast<vec3<f32>>((bitcast<vec3<u32>>(r4.www) & bitcast<vec3<u32>>(r5.xyz)));
165
+ r5 = vec4<f32>(v_27.xyz, r5.w);
166
+ let v_28 = -(r5.xyzx);
167
+ let v_29 = (r0.xyz + v_28.xyz);
168
+ r0 = vec4<f32>(v_29.xyz, r0.w);
169
+ let v_30 = (r4.zz * cb13_13.tint_symbol_4[17u].yz);
170
+ let v_31 = r4;
171
+ r4 = vec4<f32>(v_30.x, v_31.y, v_30.y, v_31.w);
172
+ let v_32 = fma(r1.yz, cb10_10.tint_symbol_5[3u].zw, r4.xz);
173
+ let v_33 = r1;
174
+ r1 = vec4<f32>(v_33.x, v_32.xy, v_33.w);
175
+ let v_34 = (r0.xyz * cb13_13.tint_symbol_4[4u].xxx);
176
+ r0 = vec4<f32>(v_34.xyz, r0.w);
177
+ r4.x = bitcast<f32>((bitcast<u32>(r3.x) & 1008981770u));
178
+ r3.x = select(0.0f, -0.00999999977648258209f, (bitcast<u32>(r3.x) != 0u));
179
+ r1.z = (r1.z + r3.x);
180
+ r1.z = fma(cb13_13.tint_symbol_4[4u].z, r1.z, r4.x);
181
+ r3.x = dot(v4.xyz, v4.xyz);
182
+ r3.x = inverseSqrt(r3.x);
183
+ let v_35 = (r3.xxx * v4.xyz);
184
+ r4 = vec4<f32>(v_35.x, r4.y, v_35.yz);
185
+ let v_36 = dot(r4.xzw, r2.yzw);
186
+ r3.x = clamp(vec4<f32>(v_36, v_36, v_36, v_36).x, 0.0f, 1.0f);
187
+ r3.x = ((-(r3.xxxx)).x + 1.0f);
188
+ r3.x = fma(r3.x, 0.40000000596046447754f, 0.5f);
189
+ r1.w = fma(r1.w, r2.x, 1.0f);
190
+ r1.w = clamp(fma(r1.wwww, vec4<f32>(0.5f), vec4<f32>(-0.30000001192092895508f)).w, 0.0f, 1.0f);
191
+ r1.w = (r1.w * 1.42857146263122558594f);
192
+ r2.x = clamp(v7.x, 0.0f, 1.0f);
193
+ r2.x = (r2.x * r3.x);
194
+ r1.w = (r1.w * r2.x);
195
+ let v_37 = (r0.xyz * r1.www);
196
+ r5 = vec4<f32>(v_37.xyz, r5.w);
197
+ let v_38 = fma(r5.xyz, cb13_13.tint_symbol_4[4u].yyy, r0.xyz);
198
+ r0 = vec4<f32>(v_38.xyz, r0.w);
199
+ r1.w = dot(v6.xyz, v6.xyz);
200
+ r1.w = inverseSqrt(r1.w);
201
+ let v_39 = (r1.www * v6.xyz);
202
+ r5 = vec4<f32>(v_39.xyz, r5.w);
203
+ let v_40 = (v1.xy * cb10_10.tint_symbol_5[2u].zw);
204
+ r6 = vec4<f32>(v_40.xy, r6.zw);
205
+ let v_41 = (r6.xy * vec2<f32>(0.5f));
206
+ r6 = vec4<f32>(v_41.xy, r6.zw);
207
+ r6 = textureSample(t3, s3, r6.xyxx.xy);
208
+ let v_42 = fma(r6.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
209
+ r6 = vec4<f32>(v_42.xy, r6.zw);
210
+ let v_43 = (r6.xy * vec2<f32>(0.10000000149011611938f));
211
+ r6 = vec4<f32>(v_43.xy, r6.zw);
212
+ let v_44 = fma(v2.xyz, r6.xxx, r5.xyz);
213
+ r6 = vec4<f32>(v_44.x, r6.y, v_44.yz);
214
+ r1.w = dot(r6.xzw, r6.xzw);
215
+ r1.w = inverseSqrt(r1.w);
216
+ let v_45 = (r1.www * r6.xzw);
217
+ r6 = vec4<f32>(v_45.x, r6.y, v_45.yz);
218
+ r1.w = dot(r4.xzw, r6.xzw);
219
+ r2.x = dot(cb1_1.tint_symbol[14u].xyz, r6.xzw);
220
+ let v_46 = fma(v2.xyz, r6.yyy, r5.xyz);
221
+ r5 = vec4<f32>(v_46.xyz, r5.w);
222
+ r3.x = dot(r5.xyz, r5.xyz);
223
+ r3.x = inverseSqrt(r3.x);
224
+ let v_47 = (r3.xxx * r5.xyz);
225
+ r5 = vec4<f32>(v_47.xyz, r5.w);
226
+ r3.x = dot(r4.xzw, r5.xyz);
227
+ r4.x = dot(cb1_1.tint_symbol[14u].xyz, r5.xyz);
228
+ r4.z = fma((-(r1.wwww)).z, r1.w, 1.0f);
229
+ r4.w = fma((-(r2.xxxx)).w, r2.x, 1.0f);
230
+ let v_48 = sqrt(r4.zw);
231
+ r4 = vec4<f32>(r4.xy, v_48.xy);
232
+ r1.w = (r1.w * r2.x);
233
+ let v_49 = -(r1.wwww);
234
+ r1.w = fma(r4.z, r4.w, v_49.w);
235
+ r2.x = fma((-(r3.xxxx)).x, r3.x, 1.0f);
236
+ r2.x = sqrt(r2.x);
237
+ r4.z = fma((-(r4.xxxx)).z, r4.x, 1.0f);
238
+ r4.z = sqrt(r4.z);
239
+ r3.x = (r3.x * r4.x);
240
+ let v_50 = -(r3.xxxx);
241
+ r2.x = fma(r2.x, r4.z, v_50.x);
242
+ let v_51 = (cb10_10.tint_symbol_5[0u].zw + vec2<f32>(8.0f, 16.0f));
243
+ let v_52 = r4;
244
+ r4 = vec4<f32>(v_51.x, v_52.y, v_51.y, v_52.w);
245
+ r1.w = log2(abs(r1.wwww).w);
246
+ r1.w = (r1.w * r4.x);
247
+ r1.w = exp2(r1.w);
248
+ r2.x = log2(abs(r2.xxxx).x);
249
+ r2.x = (r2.x * r4.z);
250
+ r2.x = exp2(r2.x);
251
+ r3.x = (r2.x * cb10_10.tint_symbol_5[0u].y);
252
+ r1.w = fma(r1.w, cb10_10.tint_symbol_5[0u].x, r3.x);
253
+ r3.x = bitcast<f32>(select(0u, 4294967295u, (r3.z < 0.03125f)));
254
+ r3.z = bitcast<f32>((bitcast<u32>(r3.x) & 1065353216u));
255
+ r1.x = (r1.x * r1.w);
256
+ let v_53 = bitcast<u32>(r3.x);
257
+ r1.x = select(1.0f, r1.x, (v_53 != 0u));
258
+ r1.x = (r1.x * r1.z);
259
+ let v_54 = (r2.xxx * cb10_10.tint_symbol_5[1u].xyz);
260
+ r4 = vec4<f32>(v_54.x, r4.y, v_54.yz);
261
+ let v_55 = (r3.zzz * r4.xzw);
262
+ r4 = vec4<f32>(v_55.x, r4.y, v_55.yz);
263
+ let v_56 = fma(r4.xzw, vec3<f32>(0.5f), r0.xyz);
264
+ o0 = vec4<f32>(v_56.xyz, o0.w);
265
+ r0.x = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).x, 0.0f, 1.0f);
266
+ r0.y = (r0.x * r3.w);
267
+ let v_57 = fma(r2.yzw, vec3<f32>(0.5f), vec3<f32>(0.5f));
268
+ o1 = vec4<f32>(v_57.xyz, o1.w);
269
+ r0.z = (r1.y * 0.001953125f);
270
+ r0.x = fma(r4.y, r3.y, cb3_3.tint_symbol_2[45u].w);
271
+ let v_58 = (r0.xy * vec2<f32>(0.5f));
272
+ r0 = vec4<f32>(v_58.xy, r0.zw);
273
+ let v_59 = sqrt(r0.xy);
274
+ o3 = vec4<f32>(v_59.xy, o3.zw);
275
+ o2.x = sqrt(r1.x);
276
+ o2.y = sqrt(r0.z);
277
+ r0.x = fma(r0.w, 1.33000004291534423828f, -0.50196081399917602539f);
278
+ o0.w = clamp(fma(r0.xxxx, vec4<f32>(2.23194742202758789062f), vec4<f32>(0.0078431377187371254f)).w, 0.0f, 1.0f);
279
+ o2.z = cb10_10.tint_symbol_5[3u].y;
280
+ o2.w = 1.0f;
281
+ o3 = vec4<f32>(o3.xy, vec2<f32>(0.0f, 1.00188386440277099609f));
282
+ }
283
+
284
+ fn v_8(v_60 : bool) {
285
+ if (v_60) {
286
+ discard;
287
+ return;
288
+ }
289
+ }
290
+
291
+ struct tint_symbol_7 {
292
+ @location(0u)
293
+ o0 : vec4<f32>,
294
+ @location(1u)
295
+ o1 : vec4<f32>,
296
+ @location(2u)
297
+ o2 : vec4<f32>,
298
+ @location(3u)
299
+ o3 : vec4<f32>,
300
+ }
301
+
302
+ @fragment
303
+ fn main(@builtin(position) v_61 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @location(7u) v7 : vec4<f32>) -> tint_symbol_7 {
304
+ main_inner(v_61, v1, v2, v3, v4, v5, v6, v7);
305
+ return tint_symbol_7(o0, o1, o2, o3);
306
+ }
b/8b0b5899ed/shaders/010379dc47445f90.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1]
b/8b0b5899ed/shaders/010379dc47445f90.wgsl ADDED
@@ -0,0 +1,276 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ struct cb16_struct {
16
+ tint_symbol : array<vec4<f32>, 16u>,
17
+ }
18
+
19
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
20
+
21
+ struct cb17_struct {
22
+ tint_symbol_1 : array<vec4<f32>, 17u>,
23
+ }
24
+
25
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
26
+
27
+ struct cb60_struct {
28
+ tint_symbol_2 : array<vec4<f32>, 60u>,
29
+ }
30
+
31
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb60_struct;
32
+
33
+ struct cb4_struct {
34
+ tint_symbol_3 : array<vec4<f32>, 4u>,
35
+ }
36
+
37
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb4_struct;
38
+
39
+ struct cb11_struct {
40
+ tint_symbol_4 : array<vec4<f32>, 11u>,
41
+ }
42
+
43
+ @group(1u) @binding(11u) var<uniform> cb11_11 : cb11_struct;
44
+
45
+ struct cb15_struct {
46
+ tint_symbol_5 : array<vec4<f32>, 15u>,
47
+ }
48
+
49
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
50
+
51
+ @group(1u) @binding(16u) var s0 : sampler;
52
+
53
+ @group(1u) @binding(19u) var s3 : sampler;
54
+
55
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
56
+
57
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
58
+
59
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
60
+
61
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
62
+
63
+ var<private> v5 : array<f32, 4u>;
64
+
65
+ var<private> o0 : vec4<f32>;
66
+
67
+ var<private> x0 : array<vec4<f32>, 4u>;
68
+
69
+ var<private> x1 : array<vec4<f32>, 1u>;
70
+
71
+ struct tint_symbol_7 {
72
+ tint_symbol_6 : array<vec4<u32>, 3u>,
73
+ }
74
+
75
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
76
+
77
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>) {
78
+ x1[0u].x = v5[0u];
79
+ x1[0u].y = v5[1u];
80
+ x1[0u].z = v5[2u];
81
+ x1[0u].w = v5[3u];
82
+ let v_1 = (v2.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
83
+ r0 = vec4<f32>(v_1.xyz, r0.w);
84
+ let v_2 = (r0.yyy * cb6_6.tint_symbol_5[1u].xyz);
85
+ r1 = vec4<f32>(v_2.xyz, r1.w);
86
+ let v_3 = fma(r0.xxx, cb6_6.tint_symbol_5[0u].xyz, r1.xyz);
87
+ r0 = vec4<f32>(v_3.xy, r0.z, v_3.z);
88
+ let v_4 = fma(r0.zzz, cb6_6.tint_symbol_5[2u].xyz, r0.xyw);
89
+ r0 = vec4<f32>(v_4.xyz, r0.w);
90
+ let v_5 = fma(r0.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
91
+ r1 = vec4<f32>(v_5.xyz, r1.w);
92
+ let v_6 = &(x0[0u]);
93
+ let v_7 = r1;
94
+ *(v_6) = vec4<f32>(v_7.xyz, (*(v_6)).w);
95
+ let v_8 = abs(r1.yyyy);
96
+ r0.w = max(v_8.w, abs(r1.xxxx).w);
97
+ let v_9 = fma(r0.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
98
+ r1 = vec4<f32>(v_9.xyz, r1.w);
99
+ let v_10 = &(x0[1u]);
100
+ let v_11 = r1;
101
+ *(v_10) = vec4<f32>(v_11.xyz, (*(v_10)).w);
102
+ let v_12 = abs(r1.yyyy);
103
+ r1.x = max(v_12.x, abs(r1.xxxx).x);
104
+ let v_13 = fma(r0.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
105
+ r1 = vec4<f32>(r1.x, v_13.xyz);
106
+ let v_14 = fma(r0.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
107
+ r0 = vec4<f32>(v_14.xyz, r0.w);
108
+ let v_15 = &(x0[2u]);
109
+ let v_16 = r1;
110
+ *(v_15) = vec4<f32>(v_16.yzw, (*(v_15)).w);
111
+ let v_17 = abs(r1.zzzz);
112
+ r1.y = max(v_17.y, abs(r1.yyyy).y);
113
+ let v_18 = &(x0[3u]);
114
+ let v_19 = r0;
115
+ *(v_18) = vec4<f32>(v_19.xyz, (*(v_18)).w);
116
+ let v_20 = abs(r0.yyyy);
117
+ r0.x = max(v_20.x, abs(r0.xxxx).x);
118
+ r0.x = clamp(fma(r0.xxxx, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).x, 0.0f, 1.0f);
119
+ r0.y = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).y, 1.5f, 1.0f);
120
+ r0.y = (r0.y * 0.5f);
121
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (r1.y < r0.y)));
122
+ let v_21 = (bitcast<u32>(r0.z) != 0u);
123
+ let v_22 = bitcast<f32>(v.tint_symbol_6[0i].x);
124
+ r0.z = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_22, v_21);
125
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (r1.x < r0.y)));
126
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (r0.w < r0.y)));
127
+ let v_23 = bitcast<u32>(r1.x);
128
+ r0.z = select(r0.z, bitcast<f32>(v.tint_symbol_6[2i].x), (v_23 != 0u));
129
+ let v_24 = bitcast<u32>(r0.y);
130
+ r0.y = select(r0.z, 0.0f, (v_24 != 0u));
131
+ r0.z = f32(bitcast<i32>(r0.y));
132
+ let v_25 = x0[bitcast<i32>(r0.y)];
133
+ r1 = vec4<f32>(v_25.xyz, r1.w);
134
+ r0.y = (r0.z + 0.5f);
135
+ r2 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r0.zzzz)));
136
+ r2 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r2) & vec4<u32>(1065353216u)));
137
+ r0.y = (r0.y * 0.25f);
138
+ r3.y = fma(r1.y, 0.25f, r0.y);
139
+ r3.x = (r1.x + 0.5f);
140
+ let v_26 = dpdx(r3.xyy);
141
+ r4 = vec4<f32>(v_26.xy, r4.z, v_26.z);
142
+ r0.y = dot(r2, cb6_6.tint_symbol_5[12u]);
143
+ r0.z = dot(r2, cb6_6.tint_symbol_5[13u]);
144
+ r0.w = ((-(r0.yyyy)).w + r1.z);
145
+ r0.y = bitcast<f32>(select(0u, 4294967295u, !((r0.y == 0.0f))));
146
+ r4.z = dpdx(r0.w);
147
+ let v_27 = dpdy(r3.yxy);
148
+ r2 = vec4<f32>(v_27.xyz, r2.w);
149
+ r2.w = dpdy(r0.w);
150
+ let v_28 = (r2.yw * r4.yw);
151
+ r1 = vec4<f32>(v_28.xy, r1.zw);
152
+ let v_29 = -(r1.xyxx);
153
+ let v_30 = fma(r4.xz, r2.xz, v_29.xy);
154
+ r5 = vec4<f32>(v_30.xy, r5.zw);
155
+ r1.x = (r2.y * r4.z);
156
+ let v_31 = -(r1.xxxx);
157
+ r5.z = fma(r4.x, r2.w, v_31.z);
158
+ r1.x = (1.0f / r5.x);
159
+ let v_32 = (r1.xx * r5.yz);
160
+ r1 = vec4<f32>(v_32.xy, r1.zw);
161
+ let v_33 = max(r1.xy, vec2<f32>());
162
+ r1 = vec4<f32>(v_33.xy, r1.zw);
163
+ let v_34 = min(r1.xy, vec2<f32>(0.5f));
164
+ r1 = vec4<f32>(v_34.xy, r1.zw);
165
+ r0.w = fma((-(r0.zzzz)).w, r1.x, r0.w);
166
+ r0.z = fma((-(r0.zzzz)).z, r1.y, r0.w);
167
+ let v_35 = bitcast<u32>(r0.y);
168
+ let v_36 = r0.z;
169
+ r0.y = select(r1.z, v_36, (v_35 != 0u));
170
+ let v_37 = r3.xyxx;
171
+ r0.y = textureSampleCompareLevel(t15, s15, v_37.xy, r0.y);
172
+ let v_38 = ((-(v2.xyz.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz);
173
+ r1 = vec4<f32>(v_38.xyz, r1.w);
174
+ r0.z = dot(r1.xyz, cb1_1.tint_symbol[14u].xyz);
175
+ r0.z = clamp(fma(r0.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f);
176
+ r0.z = ((-(r0.zzzz)).z + 1.0f);
177
+ r0.x = fma(r0.z, r0.x, r0.y);
178
+ r0.x = (r0.x * r0.x);
179
+ r0.x = min(r0.x, 1.0f);
180
+ r0.y = clamp(fma(v2.xyz.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).y, 0.0f, 1.0f);
181
+ r0.y = sqrt(r0.y);
182
+ r0.y = (r0.y * cb6_6.tint_symbol_5[3u].z);
183
+ let v_39 = -(r0.xxxx);
184
+ r0.x = fma(r0.y, v_39.x, r0.x);
185
+ r0.y = clamp(((cb2_2.tint_symbol_1[16u].zzzz + cb3_3.tint_symbol_2[49u].wwww)).y, 0.0f, 1.0f);
186
+ r0.y = (r0.y * cb2_2.tint_symbol_1[15u].y);
187
+ r0.y = (r0.y * r0.y);
188
+ r0.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f);
189
+ r0.w = dot(v1.xyz, v1.xyz);
190
+ r0.w = inverseSqrt(r0.w);
191
+ r1.x = fma(v1.z, r0.w, cb3_3.tint_symbol_2[43u].w);
192
+ let v_40 = (r0.www * v1.xyz);
193
+ r1 = vec4<f32>(r1.x, v_40.xyz);
194
+ r0.w = (r1.x * cb3_3.tint_symbol_2[44u].w);
195
+ r0.w = max(r0.w, 0.0f);
196
+ let v_41 = fma(cb3_3.tint_symbol_2[45u].xyz, r0.www, cb3_3.tint_symbol_2[46u].xyz);
197
+ r2 = vec4<f32>(v_41.xyz, r2.w);
198
+ let v_42 = (r2.xyz * cb2_2.tint_symbol_1[16u].zzz);
199
+ r2 = vec4<f32>(v_42.xyz, r2.w);
200
+ let v_43 = fma(cb3_3.tint_symbol_2[47u].xyz, r0.www, cb3_3.tint_symbol_2[48u].xyz);
201
+ r3 = vec4<f32>(v_43.xyz, r3.w);
202
+ let v_44 = fma(cb3_3.tint_symbol_2[43u].xyz, r0.www, cb3_3.tint_symbol_2[44u].xyz);
203
+ r4 = vec4<f32>(v_44.xyz, r4.w);
204
+ let v_45 = fma(r3.xyz, r0.zzz, r2.xyz);
205
+ r2 = vec4<f32>(v_45.xyz, r2.w);
206
+ let v_46 = (r0.yyy * r2.xyz);
207
+ r0 = vec4<f32>(r0.x, v_46.xyz);
208
+ r2.x = cb3_3.tint_symbol_2[46u].w;
209
+ r2.y = cb3_3.tint_symbol_2[47u].w;
210
+ r2.z = cb3_3.tint_symbol_2[48u].w;
211
+ let v_47 = dot(r2.xyz, r1.yzw);
212
+ r1.x = clamp(vec4<f32>(v_47, v_47, v_47, v_47).x, 0.0f, 1.0f);
213
+ let v_48 = -(cb3_3.tint_symbol_2[0u].xyzx);
214
+ let v_49 = dot(r1.yzw, v_48.xyz);
215
+ r1.y = clamp(vec4<f32>(v_49, v_49, v_49, v_49).y, 0.0f, 1.0f);
216
+ let v_50 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r4.xyz);
217
+ r1 = vec4<f32>(v_50.x, r1.y, v_50.yz);
218
+ r2.x = (cb2_2.tint_symbol_1[15u].z * cb2_2.tint_symbol_1[15u].z);
219
+ let v_51 = fma(r1.xzw, r2.xxx, r0.yzw);
220
+ r0 = vec4<f32>(r0.x, v_51.xyz);
221
+ r1.x = (cb5_5.tint_symbol_3[3u].z * cb11_11.tint_symbol_4[9u].z);
222
+ let v_52 = ((-(cb11_11.tint_symbol_4[9u].zzzz)).zw + vec2<f32>(1.0f, 2.0f));
223
+ r1 = vec4<f32>(r1.xy, v_52.xy);
224
+ let v_53 = (r1.ww * v0.zw);
225
+ r2 = vec4<f32>(v_53.xy, r2.zw);
226
+ r2 = textureSample(t3, s3, r2.xyxx.xy);
227
+ r1.w = ((-(r2.xxxx)).w + r2.z);
228
+ r1.x = fma(r1.x, r1.w, r2.x);
229
+ r1.w = fma(v3.z, r1.z, -1.0f);
230
+ r1.w = fma(r1.z, r1.w, 1.0f);
231
+ r1.z = (r1.z * v3.z);
232
+ let v_54 = (r1.xz * cb11_11.tint_symbol_4[9u].xx);
233
+ let v_55 = r1;
234
+ r1 = vec4<f32>(v_54.x, v_55.y, v_54.y, v_55.w);
235
+ r1.x = (r1.w * r1.x);
236
+ r1.w = fma((-(cb2_2.tint_symbol_1[16u].yyyy)).w, 100.0f, 1.0f);
237
+ r1.x = clamp(((r1.wwww * r1.xxxx)).x, 0.0f, 1.0f);
238
+ r1.w = clamp(((v3.wwww + vec4<f32>(-2.0f))).w, 0.0f, 1.0f);
239
+ r1.w = fma((-(r1.wwww)).w, 0.75f, 1.0f);
240
+ r1.x = (r1.w * r1.x);
241
+ r3 = textureSample(t0, s0, v0.xyxx.xy);
242
+ let v_56 = (r3.xyz * cb11_11.tint_symbol_4[0u].xyz);
243
+ r2 = vec4<f32>(v_56.xy, r2.z, v_56.z);
244
+ r1.w = (r3.w * v3.w);
245
+ o0.w = (r1.w * cb2_2.tint_symbol_1[15u].x);
246
+ let v_57 = (r2.xyw * r2.xyw);
247
+ r2 = vec4<f32>(v_57.xy, r2.z, v_57.z);
248
+ let v_58 = -(r2.xywx);
249
+ let v_59 = fma(cb11_11.tint_symbol_4[10u].xyz, cb11_11.tint_symbol_4[9u].yyy, v_58.xyz);
250
+ r3 = vec4<f32>(v_59.xyz, r3.w);
251
+ let v_60 = fma(r1.xxx, r3.xyz, r2.xyw);
252
+ r2 = vec4<f32>(v_60.xy, r2.z, v_60.z);
253
+ let v_61 = ((-(r2.xywx)).xyz + r2.zzz);
254
+ r3 = vec4<f32>(v_61.xyz, r3.w);
255
+ let v_62 = fma(r1.zzz, r3.xyz, r2.xyw);
256
+ r1 = vec4<f32>(v_62.x, r1.y, v_62.yz);
257
+ let v_63 = (r0.yzw * r1.xzw);
258
+ r0 = vec4<f32>(r0.x, v_63.xyz);
259
+ let v_64 = (r1.yyy * r1.xzw);
260
+ r2 = vec4<f32>(v_64.xyz, r2.w);
261
+ let v_65 = (r2.xyz * cb3_3.tint_symbol_2[1u].xyz);
262
+ r2 = vec4<f32>(v_65.xyz, r2.w);
263
+ let v_66 = fma(r2.xyz, r0.xxx, r0.yzw);
264
+ r0 = vec4<f32>(v_66.xyz, r0.w);
265
+ r0.w = (v3.x * cb11_11.tint_symbol_4[2u].x);
266
+ r0.w = (r0.w * cb11_11.tint_symbol_4[9u].z);
267
+ r0.w = (r0.w * cb3_3.tint_symbol_2[59u].w);
268
+ let v_67 = fma(r1.xzw, r0.www, r0.xyz);
269
+ o0 = vec4<f32>(v_67.xyz, o0.w);
270
+ }
271
+
272
+ @fragment
273
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>) -> @location(0u) vec4<f32> {
274
+ main_inner(v0, v1, v2, v3);
275
+ return o0;
276
+ }
b/8b0b5899ed/shaders/0105421a564158db.wgsl ADDED
@@ -0,0 +1,147 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ struct cb76_struct {
10
+ tint_symbol : array<vec4<f32>, 76u>,
11
+ }
12
+
13
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb76_struct;
14
+
15
+ @group(1u) @binding(16u) var s0 : sampler;
16
+
17
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
18
+
19
+ var<private> o0 : f32;
20
+
21
+ fn main_inner(v1 : vec4<f32>) {
22
+ let v = fma((-(cb5_5.tint_symbol[75u].zwzz)).xy, vec2<f32>(0.5f), v1.xy);
23
+ r0 = vec4<f32>(v.xy, r0.zw);
24
+ let v_1 = fma(cb5_5.tint_symbol[75u].xy, vec2<f32>(0.5f), r0.xy);
25
+ r0 = vec4<f32>(r0.xy, v_1.xy);
26
+ r1 = textureSample(t0, s0, r0.zwzz.xy);
27
+ r0.z = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
28
+ r0.w = bitcast<f32>((bitcast<u32>(r0.z) & 2147483647u));
29
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r0.w) == 2139095040i)));
30
+ r1.x = bitcast<f32>(select(0u, 4294967295u, !((r0.z == r0.z))));
31
+ r0.w = bitcast<f32>((bitcast<u32>(r0.w) | bitcast<u32>(r1.x)));
32
+ let v_2 = bitcast<u32>(r0.w);
33
+ r0.z = select(r0.z, 0.0f, (v_2 != 0u));
34
+ r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4<f32>(1.5f, 0.5f, 2.5f, 0.5f), r0.xyxy);
35
+ r2 = textureSample(t0, s0, r1.xyxx.xy);
36
+ r1 = textureSample(t0, s0, r1.zwzz.xy);
37
+ r0.w = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
38
+ r1.x = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
39
+ r1.y = bitcast<f32>((bitcast<u32>(r1.x) & 2147483647u));
40
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.y) == 2139095040i)));
41
+ r1.z = bitcast<f32>(select(0u, 4294967295u, !((r1.x == r1.x))));
42
+ r1.y = bitcast<f32>((bitcast<u32>(r1.y) | bitcast<u32>(r1.z)));
43
+ let v_3 = bitcast<u32>(r1.y);
44
+ r1.x = select(r1.x, 0.0f, (v_3 != 0u));
45
+ r0.z = (r0.z + r1.x);
46
+ r1.x = bitcast<f32>((bitcast<u32>(r0.w) & 2147483647u));
47
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.x) == 2139095040i)));
48
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r0.w == r0.w))));
49
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r1.y)));
50
+ let v_4 = bitcast<u32>(r1.x);
51
+ r0.w = select(r0.w, 0.0f, (v_4 != 0u));
52
+ r0.z = (r0.w + r0.z);
53
+ r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4<f32>(3.5f, 0.5f, 0.5f, 1.5f), r0.xyxy);
54
+ r2 = textureSample(t0, s0, r1.xyxx.xy);
55
+ r1 = textureSample(t0, s0, r1.zwzz.xy);
56
+ r0.w = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
57
+ r1.x = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
58
+ r1.y = bitcast<f32>((bitcast<u32>(r1.x) & 2147483647u));
59
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.y) == 2139095040i)));
60
+ r1.z = bitcast<f32>(select(0u, 4294967295u, !((r1.x == r1.x))));
61
+ r1.y = bitcast<f32>((bitcast<u32>(r1.y) | bitcast<u32>(r1.z)));
62
+ let v_5 = bitcast<u32>(r1.y);
63
+ r1.x = select(r1.x, 0.0f, (v_5 != 0u));
64
+ r0.z = (r0.z + r1.x);
65
+ r1.x = bitcast<f32>((bitcast<u32>(r0.w) & 2147483647u));
66
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.x) == 2139095040i)));
67
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r0.w == r0.w))));
68
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r1.y)));
69
+ let v_6 = bitcast<u32>(r1.x);
70
+ r0.w = select(r0.w, 0.0f, (v_6 != 0u));
71
+ r0.z = (r0.w + r0.z);
72
+ r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4<f32>(1.5f, 1.5f, 2.5f, 1.5f), r0.xyxy);
73
+ r2 = textureSample(t0, s0, r1.xyxx.xy);
74
+ r1 = textureSample(t0, s0, r1.zwzz.xy);
75
+ r0.w = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
76
+ r1.x = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
77
+ r1.y = bitcast<f32>((bitcast<u32>(r1.x) & 2147483647u));
78
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.y) == 2139095040i)));
79
+ r1.z = bitcast<f32>(select(0u, 4294967295u, !((r1.x == r1.x))));
80
+ r1.y = bitcast<f32>((bitcast<u32>(r1.y) | bitcast<u32>(r1.z)));
81
+ let v_7 = bitcast<u32>(r1.y);
82
+ r1.x = select(r1.x, 0.0f, (v_7 != 0u));
83
+ r0.z = (r0.z + r1.x);
84
+ r1.x = bitcast<f32>((bitcast<u32>(r0.w) & 2147483647u));
85
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.x) == 2139095040i)));
86
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r0.w == r0.w))));
87
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r1.y)));
88
+ let v_8 = bitcast<u32>(r1.x);
89
+ r0.w = select(r0.w, 0.0f, (v_8 != 0u));
90
+ r0.z = (r0.w + r0.z);
91
+ r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4<f32>(3.5f, 1.5f, 0.5f, 2.5f), r0.xyxy);
92
+ r2 = textureSample(t0, s0, r1.xyxx.xy);
93
+ r1 = textureSample(t0, s0, r1.zwzz.xy);
94
+ r0.w = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
95
+ r1.x = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
96
+ r1.y = bitcast<f32>((bitcast<u32>(r1.x) & 2147483647u));
97
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.y) == 2139095040i)));
98
+ r1.z = bitcast<f32>(select(0u, 4294967295u, !((r1.x == r1.x))));
99
+ r1.y = bitcast<f32>((bitcast<u32>(r1.y) | bitcast<u32>(r1.z)));
100
+ let v_9 = bitcast<u32>(r1.y);
101
+ r1.x = select(r1.x, 0.0f, (v_9 != 0u));
102
+ r0.z = (r0.z + r1.x);
103
+ r1.x = bitcast<f32>((bitcast<u32>(r0.w) & 2147483647u));
104
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.x) == 2139095040i)));
105
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r0.w == r0.w))));
106
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r1.y)));
107
+ let v_10 = bitcast<u32>(r1.x);
108
+ r0.w = select(r0.w, 0.0f, (v_10 != 0u));
109
+ r0.z = (r0.w + r0.z);
110
+ r1 = fma(cb5_5.tint_symbol[75u].xyxy, vec4<f32>(1.5f, 2.5f, 2.5f, 2.5f), r0.xyxy);
111
+ let v_11 = fma(cb5_5.tint_symbol[75u].xy, vec2<f32>(3.5f, 2.5f), r0.xy);
112
+ r0 = vec4<f32>(v_11.xy, r0.zw);
113
+ r2 = textureSample(t0, s0, r0.xyxx.xy);
114
+ r0.x = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
115
+ r2 = textureSample(t0, s0, r1.xyxx.xy);
116
+ r1 = textureSample(t0, s0, r1.zwzz.xy);
117
+ r0.y = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
118
+ r0.w = dot(r2.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
119
+ r1.x = bitcast<f32>((bitcast<u32>(r0.w) & 2147483647u));
120
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r1.x) == 2139095040i)));
121
+ r1.y = bitcast<f32>(select(0u, 4294967295u, !((r0.w == r0.w))));
122
+ r1.x = bitcast<f32>((bitcast<u32>(r1.x) | bitcast<u32>(r1.y)));
123
+ let v_12 = bitcast<u32>(r1.x);
124
+ r0.w = select(r0.w, 0.0f, (v_12 != 0u));
125
+ r0.z = (r0.w + r0.z);
126
+ r0.w = bitcast<f32>((bitcast<u32>(r0.y) & 2147483647u));
127
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r0.w) == 2139095040i)));
128
+ r1.x = bitcast<f32>(select(0u, 4294967295u, !((r0.y == r0.y))));
129
+ r0.w = bitcast<f32>((bitcast<u32>(r0.w) | bitcast<u32>(r1.x)));
130
+ let v_13 = bitcast<u32>(r0.w);
131
+ r0.y = select(r0.y, 0.0f, (v_13 != 0u));
132
+ r0.y = (r0.y + r0.z);
133
+ r0.z = bitcast<f32>((bitcast<u32>(r0.x) & 2147483647u));
134
+ r0.z = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r0.z) == 2139095040i)));
135
+ r0.w = bitcast<f32>(select(0u, 4294967295u, !((r0.x == r0.x))));
136
+ r0.z = bitcast<f32>((bitcast<u32>(r0.z) | bitcast<u32>(r0.w)));
137
+ let v_14 = bitcast<u32>(r0.z);
138
+ r0.x = select(r0.x, 0.0f, (v_14 != 0u));
139
+ r0.x = (r0.x + r0.y);
140
+ o0 = (r0.x * 0.08333333581686019897f);
141
+ }
142
+
143
+ @fragment
144
+ fn main(@location(1u) v1 : vec4<f32>) -> @location(0u) f32 {
145
+ main_inner(v1);
146
+ return o0;
147
+ }
b/8b0b5899ed/shaders/010e1159a3a24d20.wgsl ADDED
@@ -0,0 +1,56 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ struct cb16_struct {
6
+ tint_symbol : array<vec4<f32>, 16u>,
7
+ }
8
+
9
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb16_struct;
10
+
11
+ struct cb5_struct {
12
+ tint_symbol_1 : array<vec4<f32>, 5u>,
13
+ }
14
+
15
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb5_struct;
16
+
17
+ struct cb1_struct {
18
+ tint_symbol_2 : array<vec4<f32>, 1u>,
19
+ }
20
+
21
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb1_struct;
22
+
23
+ @group(1u) @binding(16u) var s0 : sampler;
24
+
25
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
26
+
27
+ var<private> o0 : vec4<f32>;
28
+
29
+ fn main_inner(v2 : vec4<f32>) {
30
+ r0 = textureSample(t0, s0, v2.xy.xyxx.xy);
31
+ r0.x = (r0.w * cb2_2.tint_symbol[15u].x);
32
+ let v = -(cb5_5.tint_symbol_1[4u].xxxx);
33
+ r0.y = fma(r0.w, cb2_2.tint_symbol[15u].x, v.y);
34
+ r0.z = (v.z + 1.0f);
35
+ r0.z = (r0.z * 0.10000000149011611938f);
36
+ r0.y = (r0.y / r0.z);
37
+ r0.y = fma((-(r0.wwww)).y, cb2_2.tint_symbol[15u].x, r0.y);
38
+ r0.x = fma(cb12_12.tint_symbol_2[0u].z, r0.y, r0.x);
39
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (0.0039215688593685627f >= r0.x)));
40
+ v_1((bitcast<u32>(r0.y) != 0u));
41
+ o0 = vec4<f32>(vec3<f32>(), o0.w);
42
+ o0.w = r0.x;
43
+ }
44
+
45
+ fn v_1(v_2 : bool) {
46
+ if (v_2) {
47
+ discard;
48
+ return;
49
+ }
50
+ }
51
+
52
+ @fragment
53
+ fn main(@location(2u) v2 : vec4<f32>) -> @location(0u) vec4<f32> {
54
+ main_inner(v2);
55
+ return o0;
56
+ }
b/8b0b5899ed/shaders/01175517e8e0e635.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/01175517e8e0e635.wgsl ADDED
@@ -0,0 +1,927 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ var<private> r25 : vec4<f32>;
54
+
55
+ struct cb16_struct {
56
+ tint_symbol : array<vec4<f32>, 16u>,
57
+ }
58
+
59
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
60
+
61
+ struct cb23_struct {
62
+ tint_symbol_1 : array<vec4<f32>, 23u>,
63
+ }
64
+
65
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
66
+
67
+ struct cb59_struct {
68
+ tint_symbol_2 : array<vec4<f32>, 59u>,
69
+ }
70
+
71
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
72
+
73
+ struct cb8_struct {
74
+ tint_symbol_3 : array<vec4<f32>, 8u>,
75
+ }
76
+
77
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
78
+
79
+ struct cb2_struct {
80
+ tint_symbol_4 : array<vec4<f32>, 2u>,
81
+ }
82
+
83
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
84
+
85
+ struct cb15_struct {
86
+ tint_symbol_5 : array<vec4<f32>, 15u>,
87
+ }
88
+
89
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
90
+
91
+ @group(1u) @binding(16u) var s0 : sampler;
92
+
93
+ @group(1u) @binding(18u) var s2 : sampler;
94
+
95
+ @group(1u) @binding(19u) var s3 : sampler;
96
+
97
+ @group(1u) @binding(27u) var s11 : sampler;
98
+
99
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
100
+
101
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
102
+
103
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
104
+
105
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
108
+
109
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
110
+
111
+ var<private> v6 : vec4<f32>;
112
+
113
+ var<private> v7 : array<f32, 4u>;
114
+
115
+ var<private> o0 : vec4<f32>;
116
+
117
+ var<private> x0 : array<vec4<f32>, 4u>;
118
+
119
+ var<private> x1 : array<vec4<f32>, 1u>;
120
+
121
+ struct tint_symbol_7 {
122
+ tint_symbol_6 : array<vec4<u32>, 4u>,
123
+ }
124
+
125
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
126
+
127
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v_1 : vec4<f32>) {
128
+ var v_2 : vec4<f32> = v_1;
129
+ v_2.w = (1.0f / v_1.w);
130
+ v6 = v_2;
131
+ x1[0u].x = v7[0u];
132
+ x1[0u].y = v7[1u];
133
+ x1[0u].z = v7[2u];
134
+ x1[0u].w = v7[3u];
135
+ r0 = textureSample(t0, s0, v1.xy.xyxx.xy);
136
+ r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x);
137
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x)));
138
+ v_3((bitcast<u32>(r1.x) != 0u));
139
+ r1 = textureSample(t2, s2, v1.xy.xyxx.xy);
140
+ let v_4 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
141
+ r1 = vec4<f32>(v_4.xy, r1.zw);
142
+ r1.z = dot(r1.xy, r1.xy);
143
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
144
+ r1.z = sqrt(abs(r1.zzzz).z);
145
+ r1.w = max(cb12_12.tint_symbol_4[1u].w, 0.00100000004749745131f);
146
+ let v_5 = (r1.ww * r1.xy);
147
+ r1 = vec4<f32>(v_5.xy, r1.zw);
148
+ let v_6 = (r1.yyy * v4.xyz);
149
+ r2 = vec4<f32>(v_6.xyz, r2.w);
150
+ let v_7 = fma(r1.xxx, v3.xyz, r2.xyz);
151
+ r1 = vec4<f32>(v_7.xy, r1.z, v_7.z);
152
+ let v_8 = fma(r1.zzz, v2.xyz, r1.xyw);
153
+ r1 = vec4<f32>(v_8.xyz, r1.w);
154
+ r1.w = dot(r1.xyz, r1.xyz);
155
+ r1.w = inverseSqrt(r1.w);
156
+ let v_9 = (r1.www * r1.xyz);
157
+ r2 = vec4<f32>(v_9.xyz, r2.w);
158
+ r3 = textureSample(t3, s3, v1.xy.xyxx.xy);
159
+ let v_10 = (r3.xy * r3.xy);
160
+ r3 = vec4<f32>(v_10.xy, r3.zw);
161
+ r1.x = dot(r3.xyz, cb12_12.tint_symbol_4[1u].xyz);
162
+ r1.x = clamp(((r1.xxxx * cb12_12.tint_symbol_4[0u].zzzz)).x, 0.0f, 1.0f);
163
+ r0.w = (r0.w * v0.w);
164
+ let v_11 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
165
+ r3 = vec4<f32>(v_11.xy, r3.zw);
166
+ let v_12 = (r0.xyz * r0.xyz);
167
+ r0 = vec4<f32>(v_12.xyz, r0.w);
168
+ let v_13 = -(v5.xyzx);
169
+ let v_14 = (v_13.xyz + cb1_1.tint_symbol[15u].xyz);
170
+ r4 = vec4<f32>(v_14.xyz, r4.w);
171
+ r1.y = dot(r4.xyz, r4.xyz);
172
+ r1.y = inverseSqrt(r1.y);
173
+ let v_15 = (r1.yyy * r4.xyz);
174
+ r5 = vec4<f32>(v_15.xyz, r5.w);
175
+ let v_16 = -(cb3_3.tint_symbol_2[0u].xyzx);
176
+ let v_17 = fma(r4.xyz, r1.yyy, v_16.xyz);
177
+ r6 = vec4<f32>(v_17.xyz, r6.w);
178
+ r2.w = dot(r6.xyz, r6.xyz);
179
+ r2.w = inverseSqrt(r2.w);
180
+ let v_18 = (r2.www * r6.xyz);
181
+ r6 = vec4<f32>(v_18.xyz, r6.w);
182
+ r2.w = fma(r3.w, cb12_12.tint_symbol_4[0u].y, -500.0f);
183
+ r2.w = max(r2.w, 0.0f);
184
+ let v_19 = -(r2.wwww);
185
+ r3.z = fma(r3.w, cb12_12.tint_symbol_4[0u].y, v_19.z);
186
+ r2.w = (r2.w * 558.0f);
187
+ r2.w = fma(r3.z, 3.0f, r2.w);
188
+ r3.z = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz);
189
+ let v_20 = (v5.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
190
+ r7 = vec4<f32>(v_20.xyz, r7.w);
191
+ let v_21 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz);
192
+ r8 = vec4<f32>(v_21.xyz, r8.w);
193
+ let v_22 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz);
194
+ r8 = vec4<f32>(v_22.xyz, r8.w);
195
+ let v_23 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz);
196
+ r8 = vec4<f32>(v_23.xyz, r8.w);
197
+ let v_24 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
198
+ r9 = vec4<f32>(v_24.xyz, r9.w);
199
+ let v_25 = &(x0[0u]);
200
+ let v_26 = r9;
201
+ *(v_25) = vec4<f32>(v_26.xyz, (*(v_25)).w);
202
+ let v_27 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
203
+ r10 = vec4<f32>(v_27.xyz, r10.w);
204
+ let v_28 = &(x0[1u]);
205
+ let v_29 = r10;
206
+ *(v_28) = vec4<f32>(v_29.xyz, (*(v_28)).w);
207
+ let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
208
+ r11 = vec4<f32>(v_30.xyz, r11.w);
209
+ let v_31 = &(x0[2u]);
210
+ let v_32 = r11;
211
+ *(v_31) = vec4<f32>(v_32.xyz, (*(v_31)).w);
212
+ let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
213
+ r8 = vec4<f32>(v_33.xyz, r8.w);
214
+ let v_34 = &(x0[3u]);
215
+ let v_35 = r8;
216
+ *(v_34) = vec4<f32>(v_35.xyz, (*(v_34)).w);
217
+ let v_36 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
218
+ let v_37 = r12;
219
+ r12 = vec4<f32>(v_37.x, v_36.x, v_37.z, v_36.y);
220
+ r3.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
221
+ r3.w = (r3.w * 0.5f);
222
+ let v_38 = abs(r11.yyyy);
223
+ r4.w = max(v_38.w, abs(r11.xxxx).w);
224
+ r4.w = bitcast<f32>(select(0u, 4294967295u, (r4.w < r3.w)));
225
+ let v_39 = (bitcast<u32>(r4.w) != 0u);
226
+ let v_40 = bitcast<f32>(v.tint_symbol_6[0i].x);
227
+ r4.w = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_40, v_39);
228
+ let v_41 = abs(r10.yyyy);
229
+ r5.w = max(v_41.w, abs(r10.xxxx).w);
230
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (r5.w < r3.w)));
231
+ let v_42 = bitcast<u32>(r5.w);
232
+ r4.w = select(r4.w, bitcast<f32>(v.tint_symbol_6[2i].x), (v_42 != 0u));
233
+ let v_43 = abs(r9.yyyy);
234
+ r5.w = max(v_43.w, abs(r9.xxxx).w);
235
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r5.w < r3.w)));
236
+ let v_44 = bitcast<u32>(r3.w);
237
+ r3.w = select(r4.w, 0.0f, (v_44 != 0u));
238
+ let v_45 = x0[bitcast<i32>(r3.w)];
239
+ r9 = vec4<f32>(v_45.xyz, r9.w);
240
+ r3.w = f32(bitcast<i32>(r3.w));
241
+ r4.w = (r3.w + 0.5f);
242
+ r4.w = (r4.w * 0.25f);
243
+ r10 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r3.wwww)));
244
+ r10 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r10) & vec4<u32>(1065353216u)));
245
+ r3.w = dot(r10, cb6_6.tint_symbol_5[12u]);
246
+ r5.w = dot(r10, cb6_6.tint_symbol_5[13u]);
247
+ r10.x = (r9.x + 0.5f);
248
+ r10.y = fma(r9.y, 0.25f, r4.w);
249
+ r4.w = bitcast<f32>(select(0u, 4294967295u, !((r3.w == 0.0f))));
250
+ r3.w = ((-(r3.wwww)).w + r9.z);
251
+ let v_46 = dpdx(r10.xyy);
252
+ r11 = vec4<f32>(v_46.xy, r11.z, v_46.z);
253
+ r11.z = dpdx(r3.w);
254
+ let v_47 = dpdy(r10.yxy);
255
+ r13 = vec4<f32>(v_47.xyz, r13.w);
256
+ r13.w = dpdy(r3.w);
257
+ let v_48 = (r11.yw * r13.yw);
258
+ r8 = vec4<f32>(r8.xy, v_48.xy);
259
+ let v_49 = -(r8.zwzz);
260
+ let v_50 = fma(r11.xz, r13.xz, v_49.xy);
261
+ r14 = vec4<f32>(v_50.xy, r14.zw);
262
+ r6.w = (1.0f / r14.x);
263
+ r7.w = (r11.z * r13.y);
264
+ let v_51 = -(r7.wwww);
265
+ r14.z = fma(r11.x, r13.w, v_51.z);
266
+ let v_52 = (r6.ww * r14.yz);
267
+ r8 = vec4<f32>(r8.xy, v_52.xy);
268
+ let v_53 = max(r8.zw, vec2<f32>());
269
+ r8 = vec4<f32>(r8.xy, v_53.xy);
270
+ let v_54 = min(r8.zw, vec2<f32>(0.5f));
271
+ r8 = vec4<f32>(r8.xy, v_54.xy);
272
+ r3.w = fma((-(r5.wwww)).w, r8.z, r3.w);
273
+ r3.w = fma((-(r5.wwww)).w, r8.w, r3.w);
274
+ let v_55 = bitcast<u32>(r4.w);
275
+ let v_56 = r3.w;
276
+ r12.z = select(r9.z, v_56, (v_55 != 0u));
277
+ r10.z = 0.0f;
278
+ let v_57 = (r10.xyz + r12.ywz);
279
+ r9 = vec4<f32>(v_57.xyz, r9.w);
280
+ let v_58 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
281
+ r12 = vec4<f32>(v_58.xy, r12.zw);
282
+ let v_59 = (r10.xyz + r12.xyz);
283
+ r11 = vec4<f32>(v_59.xyz, r11.w);
284
+ let v_60 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
285
+ r12 = vec4<f32>(v_60.xy, r12.zw);
286
+ let v_61 = (r10.xyz + r12.xyz);
287
+ r13 = vec4<f32>(v_61.xyz, r13.w);
288
+ let v_62 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
289
+ r12 = vec4<f32>(v_62.xy, r12.zw);
290
+ let v_63 = (r10.xyz + r12.xyz);
291
+ r14 = vec4<f32>(v_63.xyz, r14.w);
292
+ let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
293
+ r12 = vec4<f32>(v_64.xy, r12.zw);
294
+ let v_65 = (r10.xyz + r12.xyz);
295
+ r15 = vec4<f32>(v_65.xyz, r15.w);
296
+ let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
297
+ r12 = vec4<f32>(v_66.xy, r12.zw);
298
+ let v_67 = (r10.xyz + r12.xyz);
299
+ r16 = vec4<f32>(v_67.xyz, r16.w);
300
+ let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
301
+ r12 = vec4<f32>(v_68.xy, r12.zw);
302
+ let v_69 = (r10.xyz + r12.xyz);
303
+ r17 = vec4<f32>(v_69.xyz, r17.w);
304
+ let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
305
+ r12 = vec4<f32>(v_70.xy, r12.zw);
306
+ let v_71 = (r10.xyz + r12.xyz);
307
+ r18 = vec4<f32>(v_71.xyz, r18.w);
308
+ let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
309
+ r12 = vec4<f32>(v_72.xy, r12.zw);
310
+ let v_73 = (r10.xyz + r12.xyz);
311
+ r19 = vec4<f32>(v_73.xyz, r19.w);
312
+ let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
313
+ r12 = vec4<f32>(v_74.xy, r12.zw);
314
+ let v_75 = (r10.xyz + r12.xyz);
315
+ r20 = vec4<f32>(v_75.xyz, r20.w);
316
+ let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
317
+ r12 = vec4<f32>(v_76.xy, r12.zw);
318
+ let v_77 = (r10.xyz + r12.xyz);
319
+ r21 = vec4<f32>(v_77.xyz, r21.w);
320
+ let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
321
+ r12 = vec4<f32>(v_78.xy, r12.zw);
322
+ let v_79 = (r10.xyz + r12.xyz);
323
+ r22 = vec4<f32>(v_79.xyz, r22.w);
324
+ let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
325
+ r12 = vec4<f32>(v_80.xy, r12.zw);
326
+ let v_81 = (r10.xyz + r12.xyz);
327
+ r23 = vec4<f32>(v_81.xyz, r23.w);
328
+ let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
329
+ r12 = vec4<f32>(v_82.xy, r12.zw);
330
+ let v_83 = (r10.xyz + r12.xyz);
331
+ r24 = vec4<f32>(v_83.xyz, r24.w);
332
+ let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
333
+ r12 = vec4<f32>(v_84.xy, r12.zw);
334
+ let v_85 = (r10.xyz + r12.xyz);
335
+ r25 = vec4<f32>(v_85.xyz, r25.w);
336
+ let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
337
+ r12 = vec4<f32>(v_86.xy, r12.zw);
338
+ let v_87 = (r10.xyz + r12.xyz);
339
+ r10 = vec4<f32>(v_87.xyz, r10.w);
340
+ let v_88 = r9.xyxx;
341
+ r9.x = textureSampleCompareLevel(t15, s15, v_88.xy, r9.z);
342
+ let v_89 = r11.xyxx;
343
+ r9.y = textureSampleCompareLevel(t15, s15, v_89.xy, r11.z);
344
+ let v_90 = r13.xyxx;
345
+ r9.z = textureSampleCompareLevel(t15, s15, v_90.xy, r13.z);
346
+ let v_91 = r14.xyxx;
347
+ r9.w = textureSampleCompareLevel(t15, s15, v_91.xy, r14.z);
348
+ let v_92 = r15.xyxx;
349
+ r11.x = textureSampleCompareLevel(t15, s15, v_92.xy, r15.z);
350
+ let v_93 = r16.xyxx;
351
+ r11.y = textureSampleCompareLevel(t15, s15, v_93.xy, r16.z);
352
+ let v_94 = r17.xyxx;
353
+ r11.z = textureSampleCompareLevel(t15, s15, v_94.xy, r17.z);
354
+ let v_95 = r18.xyxx;
355
+ r11.w = textureSampleCompareLevel(t15, s15, v_95.xy, r18.z);
356
+ let v_96 = r19.xyxx;
357
+ r12.x = textureSampleCompareLevel(t15, s15, v_96.xy, r19.z);
358
+ let v_97 = r20.xyxx;
359
+ r12.y = textureSampleCompareLevel(t15, s15, v_97.xy, r20.z);
360
+ let v_98 = r21.xyxx;
361
+ r12.z = textureSampleCompareLevel(t15, s15, v_98.xy, r21.z);
362
+ let v_99 = r22.xyxx;
363
+ r12.w = textureSampleCompareLevel(t15, s15, v_99.xy, r22.z);
364
+ let v_100 = r23.xyxx;
365
+ r13.x = textureSampleCompareLevel(t15, s15, v_100.xy, r23.z);
366
+ let v_101 = r24.xyxx;
367
+ r13.y = textureSampleCompareLevel(t15, s15, v_101.xy, r24.z);
368
+ let v_102 = r25.xyxx;
369
+ r13.z = textureSampleCompareLevel(t15, s15, v_102.xy, r25.z);
370
+ let v_103 = r10.xyxx;
371
+ r13.w = textureSampleCompareLevel(t15, s15, v_103.xy, r10.z);
372
+ r9 = (r9 + r11);
373
+ r9 = (r12 + r9);
374
+ r9 = (r13 + r9);
375
+ r3.w = dot(r9, vec4<f32>(1.0f));
376
+ r3.z = clamp(fma(r3.zzzz, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).z, 0.0f, 1.0f);
377
+ let v_104 = abs(r8.yyyy);
378
+ r4.w = max(v_104.w, abs(r8.xxxx).w);
379
+ r4.w = clamp(fma(r4.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
380
+ r3.z = ((-(r3.zzzz)).z + 1.0f);
381
+ r3.z = (r4.w * r3.z);
382
+ r3.z = fma(r3.w, 0.0625f, r3.z);
383
+ let v_105 = (r3.xyz * r3.xyz);
384
+ r3 = vec4<f32>(v_105.xyz, r3.w);
385
+ r3.z = min(r3.z, 1.0f);
386
+ r3.w = clamp(fma(v5.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
387
+ r3.w = sqrt(r3.w);
388
+ r3.w = (r3.w * cb6_6.tint_symbol_5[3u].z);
389
+ let v_106 = -(r3.zzzz);
390
+ r3.z = fma(r3.w, v_106.z, r3.z);
391
+ let v_107 = dot(r2.xyz, v_16.xyz);
392
+ r3.w = clamp(vec4<f32>(v_107, v_107, v_107, v_107).w, 0.0f, 1.0f);
393
+ let v_108 = dot(r5.xyz, r2.xyz);
394
+ r8.x = clamp(vec4<f32>(v_108, v_108, v_108, v_108).x, 0.0f, 1.0f);
395
+ let v_109 = dot(r6.xyz, v_16.xyz);
396
+ r8.y = clamp(vec4<f32>(v_109, v_109, v_109, v_109).y, 0.0f, 1.0f);
397
+ let v_110 = ((-(r8.xyxx)).xy + vec2<f32>(1.0f));
398
+ r8 = vec4<f32>(v_110.xy, r8.zw);
399
+ let v_111 = (r8.xy * r8.xy);
400
+ r8 = vec4<f32>(r8.xy, v_111.xy);
401
+ let v_112 = (r8.zw * r8.zw);
402
+ r8 = vec4<f32>(r8.xy, v_112.xy);
403
+ let v_113 = (r8.xy * r8.zw);
404
+ r8 = vec4<f32>(v_113.xy, r8.zw);
405
+ r4.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f);
406
+ let v_114 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r4.ww);
407
+ r8 = vec4<f32>(v_114.xy, r8.zw);
408
+ let v_115 = (r2.ww + vec2<f32>(2.0f, 0.00000000999999993923f));
409
+ r8 = vec4<f32>(r8.xy, v_115.xy);
410
+ r2.w = (r8.z * 0.125f);
411
+ r5.w = fma((-(r1.xxxx)).w, r8.x, 1.0f);
412
+ r6.x = dot(r2.xyz, r6.xyz);
413
+ r6.x = clamp(((r6.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
414
+ r6.x = log2(r6.x);
415
+ r6.x = (r6.x * r8.w);
416
+ r6.x = exp2(r6.x);
417
+ r6.x = (r8.y * r6.x);
418
+ r6.x = (r2.w * r6.x);
419
+ r6.x = (r1.x * r6.x);
420
+ r6.x = (r3.w * r6.x);
421
+ r3.w = (r3.w * r5.w);
422
+ let v_116 = fma(r0.xyz, r3.www, r6.xxx);
423
+ r6 = vec4<f32>(v_116.xyz, r6.w);
424
+ let v_117 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz);
425
+ r6 = vec4<f32>(v_117.xyz, r6.w);
426
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
427
+ if ((bitcast<u32>(r3.w) != 0u)) {
428
+ r9 = vec4<f32>(vec3<f32>(), r9.w);
429
+ r8 = vec4<f32>(vec3<f32>(), r8.w);
430
+ } else {
431
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
432
+ let v_118 = (v_13.xyz + cb3_3.tint_symbol_2[3u].xyz);
433
+ r8 = vec4<f32>(v_118.xyz, r8.w);
434
+ let v_119 = (v5.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
435
+ r9 = vec4<f32>(v_119.xyz, r9.w);
436
+ r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz);
437
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
438
+ r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w);
439
+ let v_120 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz);
440
+ r9 = vec4<f32>(v_120.xyz, r9.w);
441
+ let v_121 = (r9.xyz + v_13.xyz);
442
+ r9 = vec4<f32>(v_121.xyz, r9.w);
443
+ let v_122 = bitcast<vec3<u32>>(r6.www);
444
+ let v_123 = r8.xyz;
445
+ let v_124 = select(r9.xyz, v_123, (v_122 != vec3<u32>()));
446
+ r8 = vec4<f32>(v_124.xyz, r8.w);
447
+ r6.w = dot(r8.xyz, r8.xyz);
448
+ let v_125 = (r8.xyz + vec3<f32>(0.00000099999999747524f));
449
+ r8 = vec4<f32>(v_125.xyz, r8.w);
450
+ r7.w = dot(r8.xyz, r8.xyz);
451
+ r7.w = inverseSqrt(r7.w);
452
+ let v_126 = (r7.www * r8.xyz);
453
+ r8 = vec4<f32>(v_126.xyz, r8.w);
454
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
455
+ r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
456
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[11u].w);
457
+ r6.w = (r6.w / r7.w);
458
+ let v_127 = -(cb3_3.tint_symbol_2[11u].xyzx);
459
+ r7.w = dot(r8.xyz, v_127.xyz);
460
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
461
+ let v_128 = dot(r8.xyz, r2.xyz);
462
+ r9.x = clamp(vec4<f32>(v_128, v_128, v_128, v_128).x, 0.0f, 1.0f);
463
+ r7.w = (r7.w * r9.x);
464
+ r9.x = (r6.w * r7.w);
465
+ let v_129 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz);
466
+ r9 = vec4<f32>(v_129.xyz, r9.w);
467
+ let v_130 = (r0.xyz * r9.xyz);
468
+ r9 = vec4<f32>(v_130.xyz, r9.w);
469
+ let v_131 = fma(r4.xyz, r1.yyy, r8.xyz);
470
+ r8 = vec4<f32>(v_131.xyz, r8.w);
471
+ r9.w = dot(r8.xyz, r8.xyz);
472
+ r9.w = inverseSqrt(r9.w);
473
+ let v_132 = (r8.xyz * r9.www);
474
+ r8 = vec4<f32>(v_132.xyz, r8.w);
475
+ let v_133 = dot(r8.xyz, r5.xyz);
476
+ r9.w = clamp(vec4<f32>(v_133, v_133, v_133, v_133).w, 0.0f, 1.0f);
477
+ r9.w = ((-(r9.wwww)).w + 1.0f);
478
+ r10.x = (r9.w * r9.w);
479
+ r10.x = (r10.x * r10.x);
480
+ r9.w = (r9.w * r10.x);
481
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
482
+ let v_134 = dot(r8.xyz, r2.xyz);
483
+ r8.x = clamp(vec4<f32>(v_134, v_134, v_134, v_134).x, 0.0f, 1.0f);
484
+ r8.x = log2(r8.x);
485
+ r8.x = (r8.x * r8.w);
486
+ r8.x = exp2(r8.x);
487
+ r8.x = (r8.x * r9.w);
488
+ r7.w = (r7.w * r8.x);
489
+ r6.w = (r6.w * r7.w);
490
+ r6.w = (r2.w * r6.w);
491
+ let v_135 = (r6.www * cb3_3.tint_symbol_2[19u].xyz);
492
+ r8 = vec4<f32>(v_135.xyz, r8.w);
493
+ }
494
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
495
+ if ((bitcast<u32>(r6.w) != 0u)) {
496
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
497
+ r6.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
498
+ let v_136 = bitcast<u32>(r7.w);
499
+ let v_137 = r6.w;
500
+ r3.w = select(r3.w, v_137, (v_136 != 0u));
501
+ if ((bitcast<u32>(r3.w) != 0u)) {
502
+ } else {
503
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
504
+ let v_138 = (v_13.xyz + cb3_3.tint_symbol_2[4u].xyz);
505
+ r10 = vec4<f32>(v_138.xyz, r10.w);
506
+ let v_139 = (v5.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
507
+ r11 = vec4<f32>(v_139.xyz, r11.w);
508
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz);
509
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
510
+ r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w);
511
+ let v_140 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz);
512
+ r11 = vec4<f32>(v_140.xyz, r11.w);
513
+ let v_141 = (r11.xyz + v_13.xyz);
514
+ r11 = vec4<f32>(v_141.xyz, r11.w);
515
+ let v_142 = bitcast<vec3<u32>>(r6.www);
516
+ let v_143 = r10.xyz;
517
+ let v_144 = select(r11.xyz, v_143, (v_142 != vec3<u32>()));
518
+ r10 = vec4<f32>(v_144.xyz, r10.w);
519
+ r6.w = dot(r10.xyz, r10.xyz);
520
+ let v_145 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
521
+ r10 = vec4<f32>(v_145.xyz, r10.w);
522
+ r7.w = dot(r10.xyz, r10.xyz);
523
+ r7.w = inverseSqrt(r7.w);
524
+ let v_146 = (r7.www * r10.xyz);
525
+ r10 = vec4<f32>(v_146.xyz, r10.w);
526
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
527
+ r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
528
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[12u].w);
529
+ r6.w = (r6.w / r7.w);
530
+ let v_147 = -(cb3_3.tint_symbol_2[12u].xyzx);
531
+ r7.w = dot(r10.xyz, v_147.xyz);
532
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
533
+ let v_148 = dot(r10.xyz, r2.xyz);
534
+ r9.w = clamp(vec4<f32>(v_148, v_148, v_148, v_148).w, 0.0f, 1.0f);
535
+ r7.w = (r7.w * r9.w);
536
+ r9.w = (r6.w * r7.w);
537
+ let v_149 = (r9.www * cb3_3.tint_symbol_2[20u].xyz);
538
+ r11 = vec4<f32>(v_149.xyz, r11.w);
539
+ let v_150 = fma(r11.xyz, r0.xyz, r9.xyz);
540
+ r9 = vec4<f32>(v_150.xyz, r9.w);
541
+ let v_151 = fma(r4.xyz, r1.yyy, r10.xyz);
542
+ r10 = vec4<f32>(v_151.xyz, r10.w);
543
+ r9.w = dot(r10.xyz, r10.xyz);
544
+ r9.w = inverseSqrt(r9.w);
545
+ let v_152 = (r9.www * r10.xyz);
546
+ r10 = vec4<f32>(v_152.xyz, r10.w);
547
+ let v_153 = dot(r10.xyz, r5.xyz);
548
+ r9.w = clamp(vec4<f32>(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f);
549
+ r9.w = ((-(r9.wwww)).w + 1.0f);
550
+ r10.w = (r9.w * r9.w);
551
+ r10.w = (r10.w * r10.w);
552
+ r9.w = (r9.w * r10.w);
553
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
554
+ let v_154 = dot(r10.xyz, r2.xyz);
555
+ r10.x = clamp(vec4<f32>(v_154, v_154, v_154, v_154).x, 0.0f, 1.0f);
556
+ r10.x = log2(r10.x);
557
+ r10.x = (r8.w * r10.x);
558
+ r10.x = exp2(r10.x);
559
+ r9.w = (r9.w * r10.x);
560
+ r7.w = (r7.w * r9.w);
561
+ r6.w = (r6.w * r7.w);
562
+ r6.w = (r2.w * r6.w);
563
+ let v_155 = fma(r6.www, cb3_3.tint_symbol_2[20u].xyz, r8.xyz);
564
+ r8 = vec4<f32>(v_155.xyz, r8.w);
565
+ }
566
+ } else {
567
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
568
+ }
569
+ if ((bitcast<u32>(r3.w) != 0u)) {
570
+ r3.w = bitcast<f32>(v.tint_symbol_6[3i].x);
571
+ } else {
572
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
573
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
574
+ if ((bitcast<u32>(r3.w) != 0u)) {
575
+ } else {
576
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
577
+ let v_156 = (v_13.xyz + cb3_3.tint_symbol_2[5u].xyz);
578
+ r10 = vec4<f32>(v_156.xyz, r10.w);
579
+ let v_157 = (v5.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
580
+ r11 = vec4<f32>(v_157.xyz, r11.w);
581
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz);
582
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
583
+ r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w);
584
+ let v_158 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz);
585
+ r11 = vec4<f32>(v_158.xyz, r11.w);
586
+ let v_159 = (r11.xyz + v_13.xyz);
587
+ r11 = vec4<f32>(v_159.xyz, r11.w);
588
+ let v_160 = bitcast<vec3<u32>>(r6.www);
589
+ let v_161 = r10.xyz;
590
+ let v_162 = select(r11.xyz, v_161, (v_160 != vec3<u32>()));
591
+ r10 = vec4<f32>(v_162.xyz, r10.w);
592
+ r6.w = dot(r10.xyz, r10.xyz);
593
+ let v_163 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
594
+ r10 = vec4<f32>(v_163.xyz, r10.w);
595
+ r7.w = dot(r10.xyz, r10.xyz);
596
+ r7.w = inverseSqrt(r7.w);
597
+ let v_164 = (r7.www * r10.xyz);
598
+ r10 = vec4<f32>(v_164.xyz, r10.w);
599
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
600
+ r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
601
+ r7.w = fma(r7.w, r6.w, cb3_3.tint_symbol_2[13u].w);
602
+ r6.w = (r6.w / r7.w);
603
+ let v_165 = -(cb3_3.tint_symbol_2[13u].xyzx);
604
+ r7.w = dot(r10.xyz, v_165.xyz);
605
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
606
+ let v_166 = dot(r10.xyz, r2.xyz);
607
+ r9.w = clamp(vec4<f32>(v_166, v_166, v_166, v_166).w, 0.0f, 1.0f);
608
+ r7.w = (r7.w * r9.w);
609
+ r9.w = (r6.w * r7.w);
610
+ let v_167 = (r9.www * cb3_3.tint_symbol_2[21u].xyz);
611
+ r11 = vec4<f32>(v_167.xyz, r11.w);
612
+ let v_168 = fma(r11.xyz, r0.xyz, r9.xyz);
613
+ r9 = vec4<f32>(v_168.xyz, r9.w);
614
+ let v_169 = fma(r4.xyz, r1.yyy, r10.xyz);
615
+ r10 = vec4<f32>(v_169.xyz, r10.w);
616
+ r9.w = dot(r10.xyz, r10.xyz);
617
+ r9.w = inverseSqrt(r9.w);
618
+ let v_170 = (r9.www * r10.xyz);
619
+ r10 = vec4<f32>(v_170.xyz, r10.w);
620
+ let v_171 = dot(r10.xyz, r5.xyz);
621
+ r9.w = clamp(vec4<f32>(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f);
622
+ r9.w = ((-(r9.wwww)).w + 1.0f);
623
+ r10.w = (r9.w * r9.w);
624
+ r10.w = (r10.w * r10.w);
625
+ r9.w = (r9.w * r10.w);
626
+ r9.w = fma(cb12_12.tint_symbol_4[0u].x, r9.w, r4.w);
627
+ let v_172 = dot(r10.xyz, r2.xyz);
628
+ r10.x = clamp(vec4<f32>(v_172, v_172, v_172, v_172).x, 0.0f, 1.0f);
629
+ r10.x = log2(r10.x);
630
+ r10.x = (r8.w * r10.x);
631
+ r10.x = exp2(r10.x);
632
+ r9.w = (r9.w * r10.x);
633
+ r7.w = (r7.w * r9.w);
634
+ r6.w = (r6.w * r7.w);
635
+ r6.w = (r2.w * r6.w);
636
+ let v_173 = fma(r6.www, cb3_3.tint_symbol_2[21u].xyz, r8.xyz);
637
+ r8 = vec4<f32>(v_173.xyz, r8.w);
638
+ }
639
+ }
640
+ if ((bitcast<u32>(r3.w) != 0u)) {
641
+ } else {
642
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
643
+ r3.w = bitcast<f32>((bitcast<u32>(r3.w) | bitcast<u32>(r6.w)));
644
+ if ((bitcast<u32>(r3.w) != 0u)) {
645
+ } else {
646
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
647
+ let v_174 = (v_13.xyz + cb3_3.tint_symbol_2[6u].xyz);
648
+ r10 = vec4<f32>(v_174.xyz, r10.w);
649
+ let v_175 = (v5.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
650
+ r11 = vec4<f32>(v_175.xyz, r11.w);
651
+ r6.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz);
652
+ r6.w = clamp(((r6.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
653
+ r6.w = (r6.w * cb3_3.tint_symbol_2[22u].w);
654
+ let v_176 = fma(cb3_3.tint_symbol_2[14u].xyz, r6.www, cb3_3.tint_symbol_2[6u].xyz);
655
+ r11 = vec4<f32>(v_176.xyz, r11.w);
656
+ let v_177 = (r11.xyz + v_13.xyz);
657
+ r11 = vec4<f32>(v_177.xyz, r11.w);
658
+ let v_178 = bitcast<vec3<u32>>(r3.www);
659
+ let v_179 = r10.xyz;
660
+ let v_180 = select(r11.xyz, v_179, (v_178 != vec3<u32>()));
661
+ r10 = vec4<f32>(v_180.xyz, r10.w);
662
+ r3.w = dot(r10.xyz, r10.xyz);
663
+ let v_181 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
664
+ r10 = vec4<f32>(v_181.xyz, r10.w);
665
+ r6.w = dot(r10.xyz, r10.xyz);
666
+ r6.w = inverseSqrt(r6.w);
667
+ let v_182 = (r6.www * r10.xyz);
668
+ r10 = vec4<f32>(v_182.xyz, r10.w);
669
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
670
+ r6.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
671
+ r6.w = fma(r6.w, r3.w, cb3_3.tint_symbol_2[14u].w);
672
+ r3.w = (r3.w / r6.w);
673
+ let v_183 = -(cb3_3.tint_symbol_2[14u].xyzx);
674
+ r6.w = dot(r10.xyz, v_183.xyz);
675
+ r6.w = clamp(fma(r6.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
676
+ let v_184 = dot(r10.xyz, r2.xyz);
677
+ r7.w = clamp(vec4<f32>(v_184, v_184, v_184, v_184).w, 0.0f, 1.0f);
678
+ r6.w = (r6.w * r7.w);
679
+ r7.w = (r3.w * r6.w);
680
+ let v_185 = (r7.www * cb3_3.tint_symbol_2[22u].xyz);
681
+ r11 = vec4<f32>(v_185.xyz, r11.w);
682
+ let v_186 = fma(r11.xyz, r0.xyz, r9.xyz);
683
+ r9 = vec4<f32>(v_186.xyz, r9.w);
684
+ let v_187 = fma(r4.xyz, r1.yyy, r10.xyz);
685
+ r4 = vec4<f32>(v_187.xyz, r4.w);
686
+ r1.y = dot(r4.xyz, r4.xyz);
687
+ r1.y = inverseSqrt(r1.y);
688
+ let v_188 = (r1.yyy * r4.xyz);
689
+ r4 = vec4<f32>(v_188.xyz, r4.w);
690
+ let v_189 = dot(r4.xyz, r5.xyz);
691
+ r1.y = clamp(vec4<f32>(v_189, v_189, v_189, v_189).y, 0.0f, 1.0f);
692
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
693
+ r5.x = (r1.y * r1.y);
694
+ r5.x = (r5.x * r5.x);
695
+ r1.y = (r1.y * r5.x);
696
+ r1.y = fma(cb12_12.tint_symbol_4[0u].x, r1.y, r4.w);
697
+ let v_190 = dot(r4.xyz, r2.xyz);
698
+ r4.x = clamp(vec4<f32>(v_190, v_190, v_190, v_190).x, 0.0f, 1.0f);
699
+ r4.x = log2(r4.x);
700
+ r4.x = (r4.x * r8.w);
701
+ r4.x = exp2(r4.x);
702
+ r1.y = (r1.y * r4.x);
703
+ r1.y = (r6.w * r1.y);
704
+ r1.y = (r3.w * r1.y);
705
+ r1.y = (r2.w * r1.y);
706
+ let v_191 = fma(r1.yyy, cb3_3.tint_symbol_2[22u].xyz, r8.xyz);
707
+ r8 = vec4<f32>(v_191.xyz, r8.w);
708
+ }
709
+ }
710
+ r1.y = (r5.w * r5.w);
711
+ r1.x = (r1.x * r1.x);
712
+ let v_192 = (r8.xyz * r1.xxx);
713
+ r4 = vec4<f32>(v_192.xyz, r4.w);
714
+ let v_193 = fma(r1.yyy, r9.xyz, r4.xyz);
715
+ r4 = vec4<f32>(v_193.xyz, r4.w);
716
+ let v_194 = fma(r6.xyz, r3.zzz, r4.xyz);
717
+ r4 = vec4<f32>(v_194.xyz, r4.w);
718
+ r1.x = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w);
719
+ r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w);
720
+ r1.x = max(r1.x, 0.0f);
721
+ let v_195 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz);
722
+ r1 = vec4<f32>(r1.x, v_195.xyz);
723
+ r2.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
724
+ let v_196 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz);
725
+ r5 = vec4<f32>(v_196.xyz, r5.w);
726
+ let v_197 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz);
727
+ r5 = vec4<f32>(v_197.xyz, r5.w);
728
+ let v_198 = fma(r1.yzw, r2.www, r5.xyz);
729
+ r1 = vec4<f32>(r1.x, v_198.xyz);
730
+ let v_199 = (r3.yyy * r1.yzw);
731
+ r1 = vec4<f32>(r1.x, v_199.xyz);
732
+ let v_200 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz);
733
+ r3 = vec4<f32>(r3.x, v_200.xyz);
734
+ r5.x = cb3_3.tint_symbol_2[46u].w;
735
+ r5.y = cb3_3.tint_symbol_2[47u].w;
736
+ r5.z = cb3_3.tint_symbol_2[48u].w;
737
+ let v_201 = dot(r5.xyz, r2.xyz);
738
+ r1.x = clamp(vec4<f32>(v_201, v_201, v_201, v_201).x, 0.0f, 1.0f);
739
+ let v_202 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r3.yzw);
740
+ r2 = vec4<f32>(v_202.xyz, r2.w);
741
+ let v_203 = fma(r2.xyz, r3.xxx, r1.yzw);
742
+ r1 = vec4<f32>(v_203.xyz, r1.w);
743
+ let v_204 = (r5.www * r1.xyz);
744
+ r1 = vec4<f32>(v_204.xyz, r1.w);
745
+ let v_205 = fma(r1.xyz, r0.xyz, r4.xyz);
746
+ r0 = vec4<f32>(v_205.xyz, r0.w);
747
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
748
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
749
+ r0.w = dot(r7.xyz, r7.xyz);
750
+ r1.x = sqrt(r0.w);
751
+ let v_206 = -(cb3_3.tint_symbol_2[50u].xxxx);
752
+ r1.y = (r1.x + v_206.y);
753
+ r1.y = max(r1.y, 0.0f);
754
+ r1.x = (r1.y / r1.x);
755
+ r1.x = (r1.x * r7.z);
756
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
757
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
758
+ r1.w = (r1.z * -1.44269502162933349609f);
759
+ r1.w = exp2(r1.w);
760
+ r1.w = ((-(r1.wwww)).w + 1.0f);
761
+ r1.z = (r1.w / r1.z);
762
+ let v_207 = bitcast<u32>(r1.x);
763
+ r1.x = select(1.0f, r1.z, (v_207 != 0u));
764
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
765
+ r1.x = (r1.x * r1.z);
766
+ r1.x = min(r1.x, 1.0f);
767
+ r1.x = (r1.x * 1.44269502162933349609f);
768
+ r1.x = exp2(r1.x);
769
+ r1.x = min(r1.x, 1.0f);
770
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
771
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
772
+ r0.w = inverseSqrt(r0.w);
773
+ let v_208 = (r0.www * r7.xyz);
774
+ r2 = vec4<f32>(v_208.xyz, r2.w);
775
+ let v_209 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
776
+ r0.w = clamp(vec4<f32>(v_209, v_209, v_209, v_209).w, 0.0f, 1.0f);
777
+ r0.w = log2(r0.w);
778
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
779
+ r0.w = exp2(r0.w);
780
+ let v_210 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
781
+ r1.w = clamp(vec4<f32>(v_210, v_210, v_210, v_210).w, 0.0f, 1.0f);
782
+ r1.w = log2(r1.w);
783
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
784
+ r1.w = exp2(r1.w);
785
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
786
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
787
+ let v_211 = -(cb3_3.tint_symbol_2[52u].xxxx);
788
+ r2.x = (r1.y + v_211.x);
789
+ r2.x = max(r2.x, 0.0f);
790
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
791
+ r2.x = (r2.x * 1.44269502162933349609f);
792
+ r2.x = exp2(r2.x);
793
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
794
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
795
+ let v_212 = -(cb3_3.tint_symbol_2[51u].zzzz);
796
+ r1.y = (r1.y * v_212.y);
797
+ r1.y = (r1.y * 1.44269502162933349609f);
798
+ r1.y = exp2(r1.y);
799
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
800
+ let v_213 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
801
+ r2 = vec4<f32>(v_213.xyz, r2.w);
802
+ let v_214 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
803
+ r2 = vec4<f32>(v_214.xyz, r2.w);
804
+ let v_215 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
805
+ r3 = vec4<f32>(v_215.xyz, r3.w);
806
+ let v_216 = fma(r1.www, r3.xyz, r2.xyz);
807
+ r2 = vec4<f32>(v_216.xyz, r2.w);
808
+ let v_217 = -(cb3_3.tint_symbol_2[57u].xyzx);
809
+ let v_218 = (r2.xyz + v_217.xyz);
810
+ r2 = vec4<f32>(v_218.xyz, r2.w);
811
+ let v_219 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
812
+ r2 = vec4<f32>(v_219.xyz, r2.w);
813
+ r3.x = cb3_3.tint_symbol_2[55u].w;
814
+ r3.y = cb3_3.tint_symbol_2[56u].w;
815
+ r3.z = cb3_3.tint_symbol_2[57u].w;
816
+ let v_220 = ((-(r2.xyzx)).xyz + r3.xyz);
817
+ r3 = vec4<f32>(v_220.xyz, r3.w);
818
+ let v_221 = fma(r1.xxx, r3.xyz, r2.xyz);
819
+ r1 = vec4<f32>(v_221.xy, r1.z, v_221.z);
820
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
821
+ if ((bitcast<u32>(r0.w) != 0u)) {
822
+ let v_222 = (v6.xy * cb2_2.tint_symbol_1[18u].zw);
823
+ r2 = vec4<f32>(v_222.xy, r2.zw);
824
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
825
+ r0.w = (r2.x + -1.0f);
826
+ r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
827
+ } else {
828
+ r0.w = 1.0f;
829
+ }
830
+ let v_223 = -(r0.xyxz);
831
+ let v_224 = fma(r1.xyw, r0.www, v_223.xyw);
832
+ r1 = vec4<f32>(v_224.xy, r1.z, v_224.z);
833
+ let v_225 = fma(r1.zzz, r1.xyw, r0.xyz);
834
+ r1 = vec4<f32>(v_225.xyz, r1.w);
835
+ } else {
836
+ r0.w = dot(r7.xyz, r7.xyz);
837
+ r1.w = sqrt(r0.w);
838
+ let v_226 = -(cb3_3.tint_symbol_2[50u].xxxx);
839
+ r2.x = (r1.w + v_226.x);
840
+ r2.x = max(r2.x, 0.0f);
841
+ r1.w = (r2.x / r1.w);
842
+ r1.w = (r1.w * r7.z);
843
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z);
844
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
845
+ r2.z = (r2.y * -1.44269502162933349609f);
846
+ r2.z = exp2(r2.z);
847
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
848
+ r2.y = (r2.z / r2.y);
849
+ let v_227 = bitcast<u32>(r1.w);
850
+ r1.w = select(1.0f, r2.y, (v_227 != 0u));
851
+ r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w);
852
+ r1.w = (r1.w * r2.y);
853
+ r1.w = min(r1.w, 1.0f);
854
+ r1.w = (r1.w * 1.44269502162933349609f);
855
+ r1.w = exp2(r1.w);
856
+ r1.w = min(r1.w, 1.0f);
857
+ r1.w = ((-(r1.wwww)).w + 1.0f);
858
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y);
859
+ r0.w = inverseSqrt(r0.w);
860
+ let v_228 = (r0.www * r7.xyz);
861
+ r3 = vec4<f32>(v_228.xyz, r3.w);
862
+ let v_229 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
863
+ r0.w = clamp(vec4<f32>(v_229, v_229, v_229, v_229).w, 0.0f, 1.0f);
864
+ r0.w = log2(r0.w);
865
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
866
+ r0.w = exp2(r0.w);
867
+ let v_230 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
868
+ r2.z = clamp(vec4<f32>(v_230, v_230, v_230, v_230).z, 0.0f, 1.0f);
869
+ r2.z = log2(r2.z);
870
+ r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w);
871
+ r2.z = exp2(r2.z);
872
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f);
873
+ r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y);
874
+ let v_231 = -(cb3_3.tint_symbol_2[52u].xxxx);
875
+ r2.w = (r2.x + v_231.w);
876
+ r2.w = max(r2.w, 0.0f);
877
+ r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x);
878
+ r2.w = (r2.w * 1.44269502162933349609f);
879
+ r2.w = exp2(r2.w);
880
+ r2.w = ((-(r2.wwww)).w + 1.0f);
881
+ r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f);
882
+ let v_232 = -(cb3_3.tint_symbol_2[51u].zzzz);
883
+ r2.x = (r2.x * v_232.x);
884
+ r2.x = (r2.x * 1.44269502162933349609f);
885
+ r2.x = exp2(r2.x);
886
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
887
+ let v_233 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
888
+ r3 = vec4<f32>(v_233.xyz, r3.w);
889
+ let v_234 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
890
+ r3 = vec4<f32>(v_234.xyz, r3.w);
891
+ let v_235 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
892
+ r4 = vec4<f32>(v_235.xyz, r4.w);
893
+ let v_236 = fma(r2.zzz, r4.xyz, r3.xyz);
894
+ r3 = vec4<f32>(v_236.xyz, r3.w);
895
+ let v_237 = -(cb3_3.tint_symbol_2[57u].xyzx);
896
+ let v_238 = (r3.xyz + v_237.xyz);
897
+ r3 = vec4<f32>(v_238.xyz, r3.w);
898
+ let v_239 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
899
+ r2 = vec4<f32>(v_239.x, r2.y, v_239.yz);
900
+ r3.x = cb3_3.tint_symbol_2[55u].w;
901
+ r3.y = cb3_3.tint_symbol_2[56u].w;
902
+ r3.z = cb3_3.tint_symbol_2[57u].w;
903
+ let v_240 = ((-(r2.xzwx)).xyz + r3.xyz);
904
+ r3 = vec4<f32>(v_240.xyz, r3.w);
905
+ let v_241 = fma(r1.www, r3.xyz, r2.xzw);
906
+ r2 = vec4<f32>(v_241.x, r2.y, v_241.yz);
907
+ let v_242 = ((-(r0.xxyz)).xzw + r2.xzw);
908
+ r2 = vec4<f32>(v_242.x, r2.y, v_242.yz);
909
+ let v_243 = fma(r2.yyy, r2.xzw, r0.xyz);
910
+ r1 = vec4<f32>(v_243.xyz, r1.w);
911
+ }
912
+ let v_244 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
913
+ o0 = vec4<f32>(v_244.xyz, o0.w);
914
+ }
915
+
916
+ fn v_3(v_245 : bool) {
917
+ if (v_245) {
918
+ discard;
919
+ return;
920
+ }
921
+ }
922
+
923
+ @fragment
924
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @builtin(position) v_246 : vec4<f32>) -> @location(0u) vec4<f32> {
925
+ main_inner(v0, v1, v2, v3, v4, v5, v_246);
926
+ return o0;
927
+ }
b/8b0b5899ed/shaders/01179bc0ec7d3e35.wgsl ADDED
@@ -0,0 +1,132 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ struct cb16_struct {
10
+ tint_symbol : array<vec4<f32>, 16u>,
11
+ }
12
+
13
+ @group(0u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
14
+
15
+ struct cb17_struct {
16
+ tint_symbol_1 : array<vec4<f32>, 17u>,
17
+ }
18
+
19
+ @group(0u) @binding(2u) var<uniform> cb2_2 : cb17_struct;
20
+
21
+ struct cb50_struct {
22
+ tint_symbol_2 : array<vec4<f32>, 50u>,
23
+ }
24
+
25
+ @group(0u) @binding(3u) var<uniform> cb3_3 : cb50_struct;
26
+
27
+ struct cb2_struct {
28
+ tint_symbol_3 : array<vec4<f32>, 2u>,
29
+ }
30
+
31
+ @group(0u) @binding(13u) var<uniform> cb13_13 : cb2_struct;
32
+
33
+ var<private> o0 : vec4<f32>;
34
+
35
+ var<private> o1 : vec4<f32>;
36
+
37
+ var<private> o2 : vec4<f32>;
38
+
39
+ var<private> o3 : vec4<f32>;
40
+
41
+ var<private> o4 : vec4<f32>;
42
+
43
+ var<private> o5 : vec4<f32>;
44
+
45
+ var<private> o6 : vec4<f32>;
46
+
47
+ fn main_inner(v0 : vec3<f32>, v1 : vec4<f32>, v2 : vec2<f32>, v3 : vec2<f32>, v4 : vec3<f32>, v5 : vec4<f32>) {
48
+ r0 = (v0.yyyy * cb1_1.tint_symbol[9u]);
49
+ r0 = fma(v0.xxxx, cb1_1.tint_symbol[8u], r0);
50
+ r0 = fma(v0.zzzz, cb1_1.tint_symbol[10u], r0);
51
+ o0 = (r0 + cb1_1.tint_symbol[11u]);
52
+ let v = (v0.yyy * cb1_1.tint_symbol[1u].xyz);
53
+ r0 = vec4<f32>(v.xyz, r0.w);
54
+ let v_1 = fma(v0.xxx, cb1_1.tint_symbol[0u].xyz, r0.xyz);
55
+ r0 = vec4<f32>(v_1.xyz, r0.w);
56
+ let v_2 = fma(v0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyz);
57
+ r0 = vec4<f32>(v_2.xyz, r0.w);
58
+ let v_3 = (r0.xyz + cb1_1.tint_symbol[3u].xyz);
59
+ r0 = vec4<f32>(v_3.xyz, r0.w);
60
+ let v_4 = ((-(r0.xyzx)).xyz + cb1_1.tint_symbol[15u].xyz);
61
+ r0 = vec4<f32>(v_4.xyz, r0.w);
62
+ r0.w = dot(r0.xyz, r0.xyz);
63
+ o4 = r0.xyz.xyzx;
64
+ r0.x = (r0.w * 0.00000399999998990097f);
65
+ r0.x = min(r0.x, 1.0f);
66
+ r0.y = ((-(r0.xxxx)).y + 1.0f);
67
+ let v_5 = -(cb2_2.tint_symbol_1[16u].zzzz);
68
+ let v_6 = clamp(((r0.xyxx + v_5)).xy, vec2<f32>(), vec2<f32>(1.0f));
69
+ r0 = vec4<f32>(v_6.xy, r0.zw);
70
+ r0.z = (cb3_3.tint_symbol_2[49u].w + -1.0f);
71
+ let v_7 = fma(r0.xy, r0.zz, vec2<f32>(1.0f));
72
+ r0 = vec4<f32>(v_7.xy, r0.zw);
73
+ let v_8 = clamp(((r0.xyxx * v1.xyxx)).xy, vec2<f32>(), vec2<f32>(1.0f));
74
+ o1 = vec4<f32>(v_8.xy, o1.zw);
75
+ o1 = vec4<f32>(o1.xy, v1.zw);
76
+ o2 = vec4<f32>(o2.xy, v3.xy);
77
+ r0 = vec4<f32>(v2.xy, r0.zw);
78
+ r0.z = 1.0f;
79
+ o2.x = dot(cb13_13.tint_symbol_3[0u].xyz, r0.xyz);
80
+ o2.y = dot(cb13_13.tint_symbol_3[1u].xyz, r0.xyz);
81
+ r0.x = dot(v4, v4);
82
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (r0.x < 0.10000000149011611938f)));
83
+ let v_9 = select(v4, vec3<f32>(0.0f, 0.0f, 1.0f), (bitcast<vec3<u32>>(r0.xxx) != vec3<u32>()));
84
+ r0 = vec4<f32>(v_9.xyz, r0.w);
85
+ let v_10 = (r0.yyy * cb1_1.tint_symbol[1u].xyz);
86
+ r1 = vec4<f32>(v_10.xyz, r1.w);
87
+ let v_11 = fma(r0.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz);
88
+ r0 = vec4<f32>(v_11.xy, r0.z, v_11.z);
89
+ let v_12 = fma(r0.zzz, cb1_1.tint_symbol[2u].xyz, r0.xyw);
90
+ r0 = vec4<f32>(v_12.xyz, r0.w);
91
+ r0.w = dot(r0.xyz, r0.xyz);
92
+ r0.w = inverseSqrt(r0.w);
93
+ let v_13 = (r0.www * r0.xyz);
94
+ r0 = vec4<f32>(v_13.xyz, r0.w);
95
+ o3 = r0.xyz.xyzx;
96
+ let v_14 = (v5.yyy * cb1_1.tint_symbol[1u].xyz);
97
+ r1 = vec4<f32>(v_14.xyz, r1.w);
98
+ let v_15 = fma(v5.xxx, cb1_1.tint_symbol[0u].xyz, r1.xyz);
99
+ r1 = vec4<f32>(v_15.xyz, r1.w);
100
+ let v_16 = fma(v5.zzz, cb1_1.tint_symbol[2u].xyz, r1.xyz);
101
+ r1 = vec4<f32>(v_16.xyz, r1.w);
102
+ o5 = r1.xyz.xyzx;
103
+ let v_17 = (r0.yzx * r1.zxy);
104
+ r2 = vec4<f32>(v_17.xyz, r2.w);
105
+ let v_18 = -(r2.xyzx);
106
+ let v_19 = fma(r1.yzx, r0.zxy, v_18.xyz);
107
+ r0 = vec4<f32>(v_19.xyz, r0.w);
108
+ o6 = ((r0.xyz * v5.www)).xyzx;
109
+ }
110
+
111
+ struct tint_symbol_4 {
112
+ @builtin(position)
113
+ o0 : vec4<f32>,
114
+ @location(1u)
115
+ o1 : vec4<f32>,
116
+ @location(2u)
117
+ o2 : vec4<f32>,
118
+ @location(3u)
119
+ o3 : vec4<f32>,
120
+ @location(4u)
121
+ o4 : vec4<f32>,
122
+ @location(5u)
123
+ o5 : vec4<f32>,
124
+ @location(6u)
125
+ o6 : vec4<f32>,
126
+ }
127
+
128
+ @vertex
129
+ fn main(@location(0u) v0 : vec3<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec2<f32>, @location(3u) v3 : vec2<f32>, @location(4u) v4 : vec3<f32>, @location(5u) v5 : vec4<f32>) -> tint_symbol_4 {
130
+ main_inner(v0, v1, v2, v3, v4, v5);
131
+ return tint_symbol_4(o0, o1, o2, o3, o4, o5, o6);
132
+ }
b/8b0b5899ed/shaders/011e02044e8ffb82.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/011e02044e8ffb82.wgsl ADDED
@@ -0,0 +1,1233 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ struct cb16_struct {
54
+ tint_symbol : array<vec4<f32>, 16u>,
55
+ }
56
+
57
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
58
+
59
+ struct cb23_struct {
60
+ tint_symbol_1 : array<vec4<f32>, 23u>,
61
+ }
62
+
63
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
64
+
65
+ struct cb59_struct {
66
+ tint_symbol_2 : array<vec4<f32>, 59u>,
67
+ }
68
+
69
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
70
+
71
+ struct cb8_struct {
72
+ tint_symbol_3 : array<vec4<f32>, 8u>,
73
+ }
74
+
75
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
76
+
77
+ struct cb2_struct {
78
+ tint_symbol_4 : array<vec4<f32>, 2u>,
79
+ }
80
+
81
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
82
+
83
+ struct cb1_struct {
84
+ tint_symbol_5 : array<vec4<f32>, 1u>,
85
+ }
86
+
87
+ @group(1u) @binding(11u) var<uniform> cb11_11 : cb1_struct;
88
+
89
+ struct cb15_struct {
90
+ tint_symbol_6 : array<vec4<f32>, 15u>,
91
+ }
92
+
93
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
94
+
95
+ @group(1u) @binding(16u) var s0 : sampler;
96
+
97
+ @group(1u) @binding(19u) var s3 : sampler;
98
+
99
+ @group(1u) @binding(21u) var s5 : sampler;
100
+
101
+ @group(1u) @binding(27u) var s11 : sampler;
102
+
103
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
104
+
105
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
108
+
109
+ @group(1u) @binding(37u) var t5 : texture_2d<f32>;
110
+
111
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
112
+
113
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
114
+
115
+ var<private> v7 : vec4<f32>;
116
+
117
+ var<private> v8 : array<f32, 4u>;
118
+
119
+ var<private> o0 : vec4<f32>;
120
+
121
+ var<private> x0 : array<vec4<f32>, 4u>;
122
+
123
+ var<private> x1 : array<vec4<f32>, 1u>;
124
+
125
+ struct tint_symbol_8 {
126
+ tint_symbol_7 : array<vec4<u32>, 4u>,
127
+ }
128
+
129
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_8;
130
+
131
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v_1 : vec4<f32>) {
132
+ var v_2 : vec4<f32> = v_1;
133
+ v_2.w = (1.0f / v_1.w);
134
+ v7 = v_2;
135
+ x1[0u].x = v8[0u];
136
+ x1[0u].y = v8[1u];
137
+ x1[0u].z = v8[2u];
138
+ x1[0u].w = v8[3u];
139
+ r0 = textureSample(t0, s0, v2.xy.xyxx.xy);
140
+ r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x);
141
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x)));
142
+ v_3((bitcast<u32>(r1.x) != 0u));
143
+ let v_4 = (v2.xy * cb11_11.tint_symbol_5[0u].zw);
144
+ r1 = vec4<f32>(v_4.xy, r1.zw);
145
+ r2 = textureSample(t3, s3, r1.xyxx.xy);
146
+ let v_5 = fma(r2.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
147
+ r1 = vec4<f32>(r1.xy, v_5.xy);
148
+ let v_6 = (r1.xy * vec2<f32>(3.1700000762939453125f));
149
+ r1 = vec4<f32>(v_6.xy, r1.zw);
150
+ r2 = textureSample(t3, s3, r1.xyxx.xy);
151
+ let v_7 = fma(r2.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
152
+ r1 = vec4<f32>(v_7.xy, r1.zw);
153
+ let v_8 = (r1.xy * vec2<f32>(0.5f));
154
+ r1 = vec4<f32>(v_8.xy, r1.zw);
155
+ let v_9 = fma(r1.zw, vec2<f32>(0.5f), r1.xy);
156
+ r1 = vec4<f32>(v_9.xy, r1.zw);
157
+ r1.z = fma((-(r1.xxxx)).z, cb11_11.tint_symbol_5[0u].x, 1.0f);
158
+ r0 = (r0 * r1.zzzz);
159
+ r2 = textureSample(t5, s5, v2.xy.xyxx.xy);
160
+ let v_10 = fma(r1.xy, cb11_11.tint_symbol_5[0u].yy, r2.xy);
161
+ r1 = vec4<f32>(v_10.xy, r1.zw);
162
+ let v_11 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
163
+ r1 = vec4<f32>(v_11.xy, r1.zw);
164
+ r1.w = dot(r1.xy, r1.xy);
165
+ r1.w = ((-(r1.wwww)).w + 1.0f);
166
+ r1.w = sqrt(abs(r1.wwww).w);
167
+ r2.x = max(cb12_12.tint_symbol_4[1u].x, 0.00100000004749745131f);
168
+ let v_12 = (r1.xy * r2.xx);
169
+ r1 = vec4<f32>(v_12.xy, r1.zw);
170
+ let v_13 = (r1.yyy * v5.xyz);
171
+ r2 = vec4<f32>(v_13.xyz, r2.w);
172
+ let v_14 = fma(r1.xxx, v4.xyz, r2.xyz);
173
+ r2 = vec4<f32>(v_14.xyz, r2.w);
174
+ let v_15 = fma(r1.www, v3.xyz, r2.xyz);
175
+ r1 = vec4<f32>(v_15.xy, r1.z, v_15.z);
176
+ r2.x = dot(r1.xyw, r1.xyw);
177
+ r2.x = inverseSqrt(r2.x);
178
+ let v_16 = (r1.xyw * r2.xxx);
179
+ r2 = vec4<f32>(r2.x, v_16.xyz);
180
+ r1.x = clamp(((r1.zzzz * cb12_12.tint_symbol_4[0u].wwww)).x, 0.0f, 1.0f);
181
+ let v_17 = (r0.xyz * v1.xyz);
182
+ r0 = vec4<f32>(v_17.xyz, r0.w);
183
+ r0.w = (r0.w * v0.w);
184
+ let v_18 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
185
+ let v_19 = r1;
186
+ r1 = vec4<f32>(v_19.x, v_18.xy, v_19.w);
187
+ let v_20 = (r0.xyz * r0.xyz);
188
+ r0 = vec4<f32>(v_20.xyz, r0.w);
189
+ let v_21 = -(v6.xyzx);
190
+ let v_22 = (v_21.xyz + cb1_1.tint_symbol[15u].xyz);
191
+ r3 = vec4<f32>(v_22.xyz, r3.w);
192
+ r3.w = dot(r3.xyz, r3.xyz);
193
+ r3.w = inverseSqrt(r3.w);
194
+ let v_23 = (r3.www * r3.xyz);
195
+ r4 = vec4<f32>(v_23.xyz, r4.w);
196
+ let v_24 = -(cb3_3.tint_symbol_2[0u].xyzx);
197
+ let v_25 = fma(r3.xyz, r3.www, v_24.xyz);
198
+ r5 = vec4<f32>(v_25.xyz, r5.w);
199
+ r4.w = dot(r5.xyz, r5.xyz);
200
+ r4.w = inverseSqrt(r4.w);
201
+ let v_26 = (r4.www * r5.xyz);
202
+ r5 = vec4<f32>(v_26.xyz, r5.w);
203
+ let v_27 = (r1.yz * r1.yz);
204
+ let v_28 = r1;
205
+ r1 = vec4<f32>(v_28.x, v_27.xy, v_28.w);
206
+ r4.w = (cb12_12.tint_symbol_4[0u].z + -500.0f);
207
+ r4.w = max(r4.w, 0.0f);
208
+ r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].z);
209
+ r4.w = (r4.w * 558.0f);
210
+ r4.w = fma(r5.w, 3.0f, r4.w);
211
+ r5.w = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz);
212
+ let v_29 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
213
+ r6 = vec4<f32>(v_29.xyz, r6.w);
214
+ let v_30 = (r6.yyy * cb6_6.tint_symbol_6[1u].xyz);
215
+ r7 = vec4<f32>(v_30.xyz, r7.w);
216
+ let v_31 = fma(r6.xxx, cb6_6.tint_symbol_6[0u].xyz, r7.xyz);
217
+ r7 = vec4<f32>(v_31.xyz, r7.w);
218
+ let v_32 = fma(r6.zzz, cb6_6.tint_symbol_6[2u].xyz, r7.xyz);
219
+ r7 = vec4<f32>(v_32.xyz, r7.w);
220
+ let v_33 = fma(r7.xyz, cb6_6.tint_symbol_6[4u].xyz, cb6_6.tint_symbol_6[8u].xyz);
221
+ r8 = vec4<f32>(v_33.xyz, r8.w);
222
+ let v_34 = &(x0[0u]);
223
+ let v_35 = r8;
224
+ *(v_34) = vec4<f32>(v_35.xyz, (*(v_34)).w);
225
+ let v_36 = fma(r7.xyz, cb6_6.tint_symbol_6[5u].xyz, cb6_6.tint_symbol_6[9u].xyz);
226
+ r9 = vec4<f32>(v_36.xyz, r9.w);
227
+ let v_37 = &(x0[1u]);
228
+ let v_38 = r9;
229
+ *(v_37) = vec4<f32>(v_38.xyz, (*(v_37)).w);
230
+ let v_39 = fma(r7.xyz, cb6_6.tint_symbol_6[6u].xyz, cb6_6.tint_symbol_6[10u].xyz);
231
+ r10 = vec4<f32>(v_39.xyz, r10.w);
232
+ let v_40 = &(x0[2u]);
233
+ let v_41 = r10;
234
+ *(v_40) = vec4<f32>(v_41.xyz, (*(v_40)).w);
235
+ let v_42 = fma(r7.xyz, cb6_6.tint_symbol_6[7u].xyz, cb6_6.tint_symbol_6[11u].xyz);
236
+ r7 = vec4<f32>(v_42.xyz, r7.w);
237
+ let v_43 = &(x0[3u]);
238
+ let v_44 = r7;
239
+ *(v_43) = vec4<f32>(v_44.xyz, (*(v_43)).w);
240
+ let v_45 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
241
+ let v_46 = r11;
242
+ r11 = vec4<f32>(v_46.x, v_45.x, v_46.z, v_45.y);
243
+ r6.w = fma((-(cb6_6.tint_symbol_6[14u].zzzz)).w, 1.5f, 1.0f);
244
+ r6.w = (r6.w * 0.5f);
245
+ let v_47 = abs(r10.yyyy);
246
+ r7.z = max(v_47.z, abs(r10.xxxx).z);
247
+ r7.z = bitcast<f32>(select(0u, 4294967295u, (r7.z < r6.w)));
248
+ let v_48 = (bitcast<u32>(r7.z) != 0u);
249
+ let v_49 = bitcast<f32>(v.tint_symbol_7[0i].x);
250
+ r7.z = select(bitcast<f32>(v.tint_symbol_7[1i].x), v_49, v_48);
251
+ let v_50 = abs(r9.yyyy);
252
+ r7.w = max(v_50.w, abs(r9.xxxx).w);
253
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r6.w)));
254
+ let v_51 = bitcast<u32>(r7.w);
255
+ r7.z = select(r7.z, bitcast<f32>(v.tint_symbol_7[2i].x), (v_51 != 0u));
256
+ let v_52 = abs(r8.yyyy);
257
+ r7.w = max(v_52.w, abs(r8.xxxx).w);
258
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r6.w)));
259
+ let v_53 = bitcast<u32>(r6.w);
260
+ r6.w = select(r7.z, 0.0f, (v_53 != 0u));
261
+ let v_54 = x0[bitcast<i32>(r6.w)];
262
+ r8 = vec4<f32>(v_54.xyz, r8.w);
263
+ r6.w = f32(bitcast<i32>(r6.w));
264
+ r7.z = (r6.w + 0.5f);
265
+ r7.z = (r7.z * 0.25f);
266
+ r9 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww)));
267
+ r9 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r9) & vec4<u32>(1065353216u)));
268
+ r6.w = dot(r9, cb6_6.tint_symbol_6[12u]);
269
+ r7.w = dot(r9, cb6_6.tint_symbol_6[13u]);
270
+ r9.x = (r8.x + 0.5f);
271
+ r9.y = fma(r8.y, 0.25f, r7.z);
272
+ r7.z = bitcast<f32>(select(0u, 4294967295u, !((r6.w == 0.0f))));
273
+ r6.w = ((-(r6.wwww)).w + r8.z);
274
+ let v_55 = dpdx(r9.xyy);
275
+ r10 = vec4<f32>(v_55.xy, r10.z, v_55.z);
276
+ r10.z = dpdx(r6.w);
277
+ let v_56 = dpdy(r9.yxy);
278
+ r12 = vec4<f32>(v_56.xyz, r12.w);
279
+ r12.w = dpdy(r6.w);
280
+ let v_57 = (r10.yw * r12.yw);
281
+ r8 = vec4<f32>(v_57.xy, r8.zw);
282
+ let v_58 = -(r8.xyxx);
283
+ let v_59 = fma(r10.xz, r12.xz, v_58.xy);
284
+ r13 = vec4<f32>(v_59.xy, r13.zw);
285
+ r8.x = (1.0f / r13.x);
286
+ r8.y = (r10.z * r12.y);
287
+ let v_60 = -(r8.yyyy);
288
+ r13.z = fma(r10.x, r12.w, v_60.z);
289
+ let v_61 = (r8.xx * r13.yz);
290
+ r8 = vec4<f32>(v_61.xy, r8.zw);
291
+ let v_62 = max(r8.xy, vec2<f32>());
292
+ r8 = vec4<f32>(v_62.xy, r8.zw);
293
+ let v_63 = min(r8.xy, vec2<f32>(0.5f));
294
+ r8 = vec4<f32>(v_63.xy, r8.zw);
295
+ r6.w = fma((-(r7.wwww)).w, r8.x, r6.w);
296
+ r6.w = fma((-(r7.wwww)).w, r8.y, r6.w);
297
+ let v_64 = bitcast<u32>(r7.z);
298
+ let v_65 = r6.w;
299
+ r11.z = select(r8.z, v_65, (v_64 != 0u));
300
+ r9.z = 0.0f;
301
+ let v_66 = (r9.xyz + r11.ywz);
302
+ r8 = vec4<f32>(v_66.xyz, r8.w);
303
+ let v_67 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
304
+ r11 = vec4<f32>(v_67.xy, r11.zw);
305
+ let v_68 = (r9.xyz + r11.xyz);
306
+ r10 = vec4<f32>(v_68.xyz, r10.w);
307
+ let v_69 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
308
+ r11 = vec4<f32>(v_69.xy, r11.zw);
309
+ let v_70 = (r9.xyz + r11.xyz);
310
+ r12 = vec4<f32>(v_70.xyz, r12.w);
311
+ let v_71 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
312
+ r11 = vec4<f32>(v_71.xy, r11.zw);
313
+ let v_72 = (r9.xyz + r11.xyz);
314
+ r13 = vec4<f32>(v_72.xyz, r13.w);
315
+ let v_73 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
316
+ r11 = vec4<f32>(v_73.xy, r11.zw);
317
+ let v_74 = (r9.xyz + r11.xyz);
318
+ r14 = vec4<f32>(v_74.xyz, r14.w);
319
+ let v_75 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
320
+ r11 = vec4<f32>(v_75.xy, r11.zw);
321
+ let v_76 = (r9.xyz + r11.xyz);
322
+ r15 = vec4<f32>(v_76.xyz, r15.w);
323
+ let v_77 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
324
+ r11 = vec4<f32>(v_77.xy, r11.zw);
325
+ let v_78 = (r9.xyz + r11.xyz);
326
+ r16 = vec4<f32>(v_78.xyz, r16.w);
327
+ let v_79 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
328
+ r11 = vec4<f32>(v_79.xy, r11.zw);
329
+ let v_80 = (r9.xyz + r11.xyz);
330
+ r17 = vec4<f32>(v_80.xyz, r17.w);
331
+ let v_81 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
332
+ r11 = vec4<f32>(v_81.xy, r11.zw);
333
+ let v_82 = (r9.xyz + r11.xyz);
334
+ r18 = vec4<f32>(v_82.xyz, r18.w);
335
+ let v_83 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
336
+ r11 = vec4<f32>(v_83.xy, r11.zw);
337
+ let v_84 = (r9.xyz + r11.xyz);
338
+ r19 = vec4<f32>(v_84.xyz, r19.w);
339
+ let v_85 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
340
+ r11 = vec4<f32>(v_85.xy, r11.zw);
341
+ let v_86 = (r9.xyz + r11.xyz);
342
+ r20 = vec4<f32>(v_86.xyz, r20.w);
343
+ let v_87 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
344
+ r11 = vec4<f32>(v_87.xy, r11.zw);
345
+ let v_88 = (r9.xyz + r11.xyz);
346
+ r21 = vec4<f32>(v_88.xyz, r21.w);
347
+ let v_89 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
348
+ r11 = vec4<f32>(v_89.xy, r11.zw);
349
+ let v_90 = (r9.xyz + r11.xyz);
350
+ r22 = vec4<f32>(v_90.xyz, r22.w);
351
+ let v_91 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
352
+ r11 = vec4<f32>(v_91.xy, r11.zw);
353
+ let v_92 = (r9.xyz + r11.xyz);
354
+ r23 = vec4<f32>(v_92.xyz, r23.w);
355
+ let v_93 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
356
+ r11 = vec4<f32>(v_93.xy, r11.zw);
357
+ let v_94 = (r9.xyz + r11.xyz);
358
+ r24 = vec4<f32>(v_94.xyz, r24.w);
359
+ let v_95 = (cb6_6.tint_symbol_6[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
360
+ r11 = vec4<f32>(v_95.xy, r11.zw);
361
+ let v_96 = (r9.xyz + r11.xyz);
362
+ r9 = vec4<f32>(v_96.xyz, r9.w);
363
+ let v_97 = r8.xyxx;
364
+ r8.x = textureSampleCompareLevel(t15, s15, v_97.xy, r8.z);
365
+ let v_98 = r10.xyxx;
366
+ r8.y = textureSampleCompareLevel(t15, s15, v_98.xy, r10.z);
367
+ let v_99 = r12.xyxx;
368
+ r8.z = textureSampleCompareLevel(t15, s15, v_99.xy, r12.z);
369
+ let v_100 = r13.xyxx;
370
+ r8.w = textureSampleCompareLevel(t15, s15, v_100.xy, r13.z);
371
+ let v_101 = r14.xyxx;
372
+ r10.x = textureSampleCompareLevel(t15, s15, v_101.xy, r14.z);
373
+ let v_102 = r15.xyxx;
374
+ r10.y = textureSampleCompareLevel(t15, s15, v_102.xy, r15.z);
375
+ let v_103 = r16.xyxx;
376
+ r10.z = textureSampleCompareLevel(t15, s15, v_103.xy, r16.z);
377
+ let v_104 = r17.xyxx;
378
+ r10.w = textureSampleCompareLevel(t15, s15, v_104.xy, r17.z);
379
+ let v_105 = r18.xyxx;
380
+ r11.x = textureSampleCompareLevel(t15, s15, v_105.xy, r18.z);
381
+ let v_106 = r19.xyxx;
382
+ r11.y = textureSampleCompareLevel(t15, s15, v_106.xy, r19.z);
383
+ let v_107 = r20.xyxx;
384
+ r11.z = textureSampleCompareLevel(t15, s15, v_107.xy, r20.z);
385
+ let v_108 = r21.xyxx;
386
+ r11.w = textureSampleCompareLevel(t15, s15, v_108.xy, r21.z);
387
+ let v_109 = r22.xyxx;
388
+ r12.x = textureSampleCompareLevel(t15, s15, v_109.xy, r22.z);
389
+ let v_110 = r23.xyxx;
390
+ r12.y = textureSampleCompareLevel(t15, s15, v_110.xy, r23.z);
391
+ let v_111 = r24.xyxx;
392
+ r12.z = textureSampleCompareLevel(t15, s15, v_111.xy, r24.z);
393
+ let v_112 = r9.xyxx;
394
+ r12.w = textureSampleCompareLevel(t15, s15, v_112.xy, r9.z);
395
+ r8 = (r8 + r10);
396
+ r8 = (r11 + r8);
397
+ r8 = (r12 + r8);
398
+ r6.w = dot(r8, vec4<f32>(1.0f));
399
+ r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_6[0u].wwww, cb6_6.tint_symbol_6[1u].wwww).w, 0.0f, 1.0f);
400
+ let v_113 = abs(r7.yyyy);
401
+ r7.x = max(v_113.x, abs(r7.xxxx).x);
402
+ r7.x = clamp(fma(r7.xxxx, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).x, 0.0f, 1.0f);
403
+ r5.w = ((-(r5.wwww)).w + 1.0f);
404
+ r5.w = (r7.x * r5.w);
405
+ r5.w = fma(r6.w, 0.0625f, r5.w);
406
+ r5.w = (r5.w * r5.w);
407
+ r5.w = min(r5.w, 1.0f);
408
+ r6.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_6[3u].xxxx, cb6_6.tint_symbol_6[3u].yyyy).w, 0.0f, 1.0f);
409
+ r6.w = sqrt(r6.w);
410
+ r6.w = (r6.w * cb6_6.tint_symbol_6[3u].z);
411
+ let v_114 = -(r5.wwww);
412
+ r5.w = fma(r6.w, v_114.w, r5.w);
413
+ let v_115 = dot(r2.yzw, v_24.xyz);
414
+ r6.w = clamp(vec4<f32>(v_115, v_115, v_115, v_115).w, 0.0f, 1.0f);
415
+ let v_116 = dot(r4.xyz, r2.yzw);
416
+ r7.x = clamp(vec4<f32>(v_116, v_116, v_116, v_116).x, 0.0f, 1.0f);
417
+ let v_117 = dot(r5.xyz, v_24.xyz);
418
+ r7.y = clamp(vec4<f32>(v_117, v_117, v_117, v_117).y, 0.0f, 1.0f);
419
+ let v_118 = ((-(r7.xyxx)).xy + vec2<f32>(1.0f));
420
+ r7 = vec4<f32>(v_118.xy, r7.zw);
421
+ let v_119 = (r7.xy * r7.xy);
422
+ r7 = vec4<f32>(r7.xy, v_119.xy);
423
+ let v_120 = (r7.zw * r7.zw);
424
+ r7 = vec4<f32>(r7.xy, v_120.xy);
425
+ let v_121 = (r7.xy * r7.zw);
426
+ r7 = vec4<f32>(v_121.xy, r7.zw);
427
+ r7.z = ((-(cb12_12.tint_symbol_4[0u].yyyy)).z + 1.0f);
428
+ let v_122 = fma(cb12_12.tint_symbol_4[0u].yy, r7.xy, r7.zz);
429
+ r7 = vec4<f32>(v_122.xy, r7.zw);
430
+ let v_123 = (r4.ww + vec2<f32>(2.0f, 0.00000000999999993923f));
431
+ r8 = vec4<f32>(v_123.xy, r8.zw);
432
+ r4.w = (r8.x * 0.125f);
433
+ r7.x = fma((-(r1.xxxx)).x, r7.x, 1.0f);
434
+ r5.x = dot(r2.yzw, r5.xyz);
435
+ r5.x = clamp(((r5.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
436
+ r5.x = log2(r5.x);
437
+ r5.x = (r5.x * r8.y);
438
+ r5.x = exp2(r5.x);
439
+ r5.x = (r7.y * r5.x);
440
+ r5.x = (r4.w * r5.x);
441
+ r5.x = (r1.x * r5.x);
442
+ r5.x = (r6.w * r5.x);
443
+ r5.y = (r6.w * r7.x);
444
+ let v_124 = fma(r0.xyz, r5.yyy, r5.xxx);
445
+ r5 = vec4<f32>(v_124.xyz, r5.w);
446
+ let v_125 = (r5.xyz * cb3_3.tint_symbol_2[1u].xyz);
447
+ r5 = vec4<f32>(v_125.xyz, r5.w);
448
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
449
+ if ((bitcast<u32>(r6.w) != 0u)) {
450
+ r9 = vec4<f32>(vec3<f32>(), r9.w);
451
+ r8 = vec4<f32>(0.0f, r8.y, vec2<f32>());
452
+ } else {
453
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
454
+ let v_126 = ((-(v6.xxyz)).xzw + cb3_3.tint_symbol_2[3u].xyz);
455
+ r8 = vec4<f32>(v_126.x, r8.y, v_126.yz);
456
+ let v_127 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
457
+ r9 = vec4<f32>(v_127.xyz, r9.w);
458
+ r7.w = dot(r9.xyz, cb3_3.tint_symbol_2[11u].xyz);
459
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
460
+ r7.w = (r7.w * cb3_3.tint_symbol_2[19u].w);
461
+ let v_128 = fma(cb3_3.tint_symbol_2[11u].xyz, r7.www, cb3_3.tint_symbol_2[3u].xyz);
462
+ r9 = vec4<f32>(v_128.xyz, r9.w);
463
+ let v_129 = (r9.xyz + v_21.xyz);
464
+ r9 = vec4<f32>(v_129.xyz, r9.w);
465
+ let v_130 = bitcast<vec3<u32>>(r7.yyy);
466
+ let v_131 = r8.xzw;
467
+ let v_132 = select(r9.xyz, v_131, (v_130 != vec3<u32>()));
468
+ r8 = vec4<f32>(v_132.x, r8.y, v_132.yz);
469
+ r7.y = dot(r8.xzw, r8.xzw);
470
+ let v_133 = (r8.xzw + vec3<f32>(0.00000099999999747524f));
471
+ r8 = vec4<f32>(v_133.x, r8.y, v_133.yz);
472
+ r7.w = dot(r8.xzw, r8.xzw);
473
+ r7.w = inverseSqrt(r7.w);
474
+ let v_134 = (r7.www * r8.xzw);
475
+ r8 = vec4<f32>(v_134.x, r8.y, v_134.yz);
476
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
477
+ r7.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
478
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[11u].w);
479
+ r7.y = (r7.y / r7.w);
480
+ let v_135 = -(cb3_3.tint_symbol_2[11u].xyzx);
481
+ r7.w = dot(r8.xzw, v_135.xyz);
482
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
483
+ let v_136 = dot(r8.xzw, r2.yzw);
484
+ r9.x = clamp(vec4<f32>(v_136, v_136, v_136, v_136).x, 0.0f, 1.0f);
485
+ r7.w = (r7.w * r9.x);
486
+ r9.x = (r7.y * r7.w);
487
+ let v_137 = (r9.xxx * cb3_3.tint_symbol_2[19u].xyz);
488
+ r9 = vec4<f32>(v_137.xyz, r9.w);
489
+ let v_138 = (r0.xyz * r9.xyz);
490
+ r9 = vec4<f32>(v_138.xyz, r9.w);
491
+ let v_139 = fma(r3.xyz, r3.www, r8.xzw);
492
+ r8 = vec4<f32>(v_139.x, r8.y, v_139.yz);
493
+ r9.w = dot(r8.xzw, r8.xzw);
494
+ r9.w = inverseSqrt(r9.w);
495
+ let v_140 = (r8.xzw * r9.www);
496
+ r8 = vec4<f32>(v_140.x, r8.y, v_140.yz);
497
+ let v_141 = dot(r8.xzw, r4.xyz);
498
+ r9.w = clamp(vec4<f32>(v_141, v_141, v_141, v_141).w, 0.0f, 1.0f);
499
+ r9.w = ((-(r9.wwww)).w + 1.0f);
500
+ r10.x = (r9.w * r9.w);
501
+ r10.x = (r10.x * r10.x);
502
+ r9.w = (r9.w * r10.x);
503
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
504
+ let v_142 = dot(r8.xzw, r2.yzw);
505
+ r8.x = clamp(vec4<f32>(v_142, v_142, v_142, v_142).x, 0.0f, 1.0f);
506
+ r8.x = log2(r8.x);
507
+ r8.x = (r8.x * r8.y);
508
+ r8.x = exp2(r8.x);
509
+ r8.x = (r8.x * r9.w);
510
+ r7.w = (r7.w * r8.x);
511
+ r7.y = (r7.y * r7.w);
512
+ r7.y = (r4.w * r7.y);
513
+ let v_143 = (r7.yyy * cb3_3.tint_symbol_2[19u].xyz);
514
+ r8 = vec4<f32>(v_143.x, r8.y, v_143.yz);
515
+ }
516
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
517
+ if ((bitcast<u32>(r7.y) != 0u)) {
518
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
519
+ r7.y = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
520
+ let v_144 = bitcast<u32>(r7.w);
521
+ let v_145 = r7.y;
522
+ r6.w = select(r6.w, v_145, (v_144 != 0u));
523
+ if ((bitcast<u32>(r6.w) != 0u)) {
524
+ } else {
525
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
526
+ let v_146 = (v_21.xyz + cb3_3.tint_symbol_2[4u].xyz);
527
+ r10 = vec4<f32>(v_146.xyz, r10.w);
528
+ let v_147 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
529
+ r11 = vec4<f32>(v_147.xyz, r11.w);
530
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[12u].xyz);
531
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
532
+ r7.w = (r7.w * cb3_3.tint_symbol_2[20u].w);
533
+ let v_148 = fma(cb3_3.tint_symbol_2[12u].xyz, r7.www, cb3_3.tint_symbol_2[4u].xyz);
534
+ r11 = vec4<f32>(v_148.xyz, r11.w);
535
+ let v_149 = (r11.xyz + v_21.xyz);
536
+ r11 = vec4<f32>(v_149.xyz, r11.w);
537
+ let v_150 = bitcast<vec3<u32>>(r7.yyy);
538
+ let v_151 = r10.xyz;
539
+ let v_152 = select(r11.xyz, v_151, (v_150 != vec3<u32>()));
540
+ r10 = vec4<f32>(v_152.xyz, r10.w);
541
+ r7.y = dot(r10.xyz, r10.xyz);
542
+ let v_153 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
543
+ r10 = vec4<f32>(v_153.xyz, r10.w);
544
+ r7.w = dot(r10.xyz, r10.xyz);
545
+ r7.w = inverseSqrt(r7.w);
546
+ let v_154 = (r7.www * r10.xyz);
547
+ r10 = vec4<f32>(v_154.xyz, r10.w);
548
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
549
+ r7.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
550
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[12u].w);
551
+ r7.y = (r7.y / r7.w);
552
+ let v_155 = -(cb3_3.tint_symbol_2[12u].xyzx);
553
+ r7.w = dot(r10.xyz, v_155.xyz);
554
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
555
+ let v_156 = dot(r10.xyz, r2.yzw);
556
+ r9.w = clamp(vec4<f32>(v_156, v_156, v_156, v_156).w, 0.0f, 1.0f);
557
+ r7.w = (r7.w * r9.w);
558
+ r9.w = (r7.y * r7.w);
559
+ let v_157 = (r9.www * cb3_3.tint_symbol_2[20u].xyz);
560
+ r11 = vec4<f32>(v_157.xyz, r11.w);
561
+ let v_158 = fma(r11.xyz, r0.xyz, r9.xyz);
562
+ r9 = vec4<f32>(v_158.xyz, r9.w);
563
+ let v_159 = fma(r3.xyz, r3.www, r10.xyz);
564
+ r10 = vec4<f32>(v_159.xyz, r10.w);
565
+ r9.w = dot(r10.xyz, r10.xyz);
566
+ r9.w = inverseSqrt(r9.w);
567
+ let v_160 = (r9.www * r10.xyz);
568
+ r10 = vec4<f32>(v_160.xyz, r10.w);
569
+ let v_161 = dot(r10.xyz, r4.xyz);
570
+ r9.w = clamp(vec4<f32>(v_161, v_161, v_161, v_161).w, 0.0f, 1.0f);
571
+ r9.w = ((-(r9.wwww)).w + 1.0f);
572
+ r10.w = (r9.w * r9.w);
573
+ r10.w = (r10.w * r10.w);
574
+ r9.w = (r9.w * r10.w);
575
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
576
+ let v_162 = dot(r10.xyz, r2.yzw);
577
+ r10.x = clamp(vec4<f32>(v_162, v_162, v_162, v_162).x, 0.0f, 1.0f);
578
+ r10.x = log2(r10.x);
579
+ r10.x = (r8.y * r10.x);
580
+ r10.x = exp2(r10.x);
581
+ r9.w = (r9.w * r10.x);
582
+ r7.w = (r7.w * r9.w);
583
+ r7.y = (r7.y * r7.w);
584
+ r7.y = (r4.w * r7.y);
585
+ let v_163 = fma(r7.yyy, cb3_3.tint_symbol_2[20u].xyz, r8.xzw);
586
+ r8 = vec4<f32>(v_163.x, r8.y, v_163.yz);
587
+ }
588
+ } else {
589
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
590
+ }
591
+ if ((bitcast<u32>(r6.w) != 0u)) {
592
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
593
+ } else {
594
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
595
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
596
+ if ((bitcast<u32>(r6.w) != 0u)) {
597
+ } else {
598
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
599
+ let v_164 = (v_21.xyz + cb3_3.tint_symbol_2[5u].xyz);
600
+ r10 = vec4<f32>(v_164.xyz, r10.w);
601
+ let v_165 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
602
+ r11 = vec4<f32>(v_165.xyz, r11.w);
603
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[13u].xyz);
604
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
605
+ r7.w = (r7.w * cb3_3.tint_symbol_2[21u].w);
606
+ let v_166 = fma(cb3_3.tint_symbol_2[13u].xyz, r7.www, cb3_3.tint_symbol_2[5u].xyz);
607
+ r11 = vec4<f32>(v_166.xyz, r11.w);
608
+ let v_167 = (r11.xyz + v_21.xyz);
609
+ r11 = vec4<f32>(v_167.xyz, r11.w);
610
+ let v_168 = bitcast<vec3<u32>>(r7.yyy);
611
+ let v_169 = r10.xyz;
612
+ let v_170 = select(r11.xyz, v_169, (v_168 != vec3<u32>()));
613
+ r10 = vec4<f32>(v_170.xyz, r10.w);
614
+ r7.y = dot(r10.xyz, r10.xyz);
615
+ let v_171 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
616
+ r10 = vec4<f32>(v_171.xyz, r10.w);
617
+ r7.w = dot(r10.xyz, r10.xyz);
618
+ r7.w = inverseSqrt(r7.w);
619
+ let v_172 = (r7.www * r10.xyz);
620
+ r10 = vec4<f32>(v_172.xyz, r10.w);
621
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
622
+ r7.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
623
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[13u].w);
624
+ r7.y = (r7.y / r7.w);
625
+ let v_173 = -(cb3_3.tint_symbol_2[13u].xyzx);
626
+ r7.w = dot(r10.xyz, v_173.xyz);
627
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
628
+ let v_174 = dot(r10.xyz, r2.yzw);
629
+ r9.w = clamp(vec4<f32>(v_174, v_174, v_174, v_174).w, 0.0f, 1.0f);
630
+ r7.w = (r7.w * r9.w);
631
+ r9.w = (r7.y * r7.w);
632
+ let v_175 = (r9.www * cb3_3.tint_symbol_2[21u].xyz);
633
+ r11 = vec4<f32>(v_175.xyz, r11.w);
634
+ let v_176 = fma(r11.xyz, r0.xyz, r9.xyz);
635
+ r9 = vec4<f32>(v_176.xyz, r9.w);
636
+ let v_177 = fma(r3.xyz, r3.www, r10.xyz);
637
+ r10 = vec4<f32>(v_177.xyz, r10.w);
638
+ r9.w = dot(r10.xyz, r10.xyz);
639
+ r9.w = inverseSqrt(r9.w);
640
+ let v_178 = (r9.www * r10.xyz);
641
+ r10 = vec4<f32>(v_178.xyz, r10.w);
642
+ let v_179 = dot(r10.xyz, r4.xyz);
643
+ r9.w = clamp(vec4<f32>(v_179, v_179, v_179, v_179).w, 0.0f, 1.0f);
644
+ r9.w = ((-(r9.wwww)).w + 1.0f);
645
+ r10.w = (r9.w * r9.w);
646
+ r10.w = (r10.w * r10.w);
647
+ r9.w = (r9.w * r10.w);
648
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
649
+ let v_180 = dot(r10.xyz, r2.yzw);
650
+ r10.x = clamp(vec4<f32>(v_180, v_180, v_180, v_180).x, 0.0f, 1.0f);
651
+ r10.x = log2(r10.x);
652
+ r10.x = (r8.y * r10.x);
653
+ r10.x = exp2(r10.x);
654
+ r9.w = (r9.w * r10.x);
655
+ r7.w = (r7.w * r9.w);
656
+ r7.y = (r7.y * r7.w);
657
+ r7.y = (r4.w * r7.y);
658
+ let v_181 = fma(r7.yyy, cb3_3.tint_symbol_2[21u].xyz, r8.xzw);
659
+ r8 = vec4<f32>(v_181.x, r8.y, v_181.yz);
660
+ }
661
+ }
662
+ if ((bitcast<u32>(r6.w) != 0u)) {
663
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
664
+ } else {
665
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
666
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
667
+ if ((bitcast<u32>(r6.w) != 0u)) {
668
+ } else {
669
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
670
+ let v_182 = (v_21.xyz + cb3_3.tint_symbol_2[6u].xyz);
671
+ r10 = vec4<f32>(v_182.xyz, r10.w);
672
+ let v_183 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
673
+ r11 = vec4<f32>(v_183.xyz, r11.w);
674
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[14u].xyz);
675
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
676
+ r7.w = (r7.w * cb3_3.tint_symbol_2[22u].w);
677
+ let v_184 = fma(cb3_3.tint_symbol_2[14u].xyz, r7.www, cb3_3.tint_symbol_2[6u].xyz);
678
+ r11 = vec4<f32>(v_184.xyz, r11.w);
679
+ let v_185 = (r11.xyz + v_21.xyz);
680
+ r11 = vec4<f32>(v_185.xyz, r11.w);
681
+ let v_186 = bitcast<vec3<u32>>(r7.yyy);
682
+ let v_187 = r10.xyz;
683
+ let v_188 = select(r11.xyz, v_187, (v_186 != vec3<u32>()));
684
+ r10 = vec4<f32>(v_188.xyz, r10.w);
685
+ r7.y = dot(r10.xyz, r10.xyz);
686
+ let v_189 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
687
+ r10 = vec4<f32>(v_189.xyz, r10.w);
688
+ r7.w = dot(r10.xyz, r10.xyz);
689
+ r7.w = inverseSqrt(r7.w);
690
+ let v_190 = (r7.www * r10.xyz);
691
+ r10 = vec4<f32>(v_190.xyz, r10.w);
692
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
693
+ r7.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
694
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[14u].w);
695
+ r7.y = (r7.y / r7.w);
696
+ let v_191 = -(cb3_3.tint_symbol_2[14u].xyzx);
697
+ r7.w = dot(r10.xyz, v_191.xyz);
698
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
699
+ let v_192 = dot(r10.xyz, r2.yzw);
700
+ r9.w = clamp(vec4<f32>(v_192, v_192, v_192, v_192).w, 0.0f, 1.0f);
701
+ r7.w = (r7.w * r9.w);
702
+ r9.w = (r7.y * r7.w);
703
+ let v_193 = (r9.www * cb3_3.tint_symbol_2[22u].xyz);
704
+ r11 = vec4<f32>(v_193.xyz, r11.w);
705
+ let v_194 = fma(r11.xyz, r0.xyz, r9.xyz);
706
+ r9 = vec4<f32>(v_194.xyz, r9.w);
707
+ let v_195 = fma(r3.xyz, r3.www, r10.xyz);
708
+ r10 = vec4<f32>(v_195.xyz, r10.w);
709
+ r9.w = dot(r10.xyz, r10.xyz);
710
+ r9.w = inverseSqrt(r9.w);
711
+ let v_196 = (r9.www * r10.xyz);
712
+ r10 = vec4<f32>(v_196.xyz, r10.w);
713
+ let v_197 = dot(r10.xyz, r4.xyz);
714
+ r9.w = clamp(vec4<f32>(v_197, v_197, v_197, v_197).w, 0.0f, 1.0f);
715
+ r9.w = ((-(r9.wwww)).w + 1.0f);
716
+ r10.w = (r9.w * r9.w);
717
+ r10.w = (r10.w * r10.w);
718
+ r9.w = (r9.w * r10.w);
719
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
720
+ let v_198 = dot(r10.xyz, r2.yzw);
721
+ r10.x = clamp(vec4<f32>(v_198, v_198, v_198, v_198).x, 0.0f, 1.0f);
722
+ r10.x = log2(r10.x);
723
+ r10.x = (r8.y * r10.x);
724
+ r10.x = exp2(r10.x);
725
+ r9.w = (r9.w * r10.x);
726
+ r7.w = (r7.w * r9.w);
727
+ r7.y = (r7.y * r7.w);
728
+ r7.y = (r4.w * r7.y);
729
+ let v_199 = fma(r7.yyy, cb3_3.tint_symbol_2[22u].xyz, r8.xzw);
730
+ r8 = vec4<f32>(v_199.x, r8.y, v_199.yz);
731
+ }
732
+ }
733
+ if ((bitcast<u32>(r6.w) != 0u)) {
734
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
735
+ } else {
736
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (4i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
737
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
738
+ if ((bitcast<u32>(r6.w) != 0u)) {
739
+ } else {
740
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f)));
741
+ let v_200 = (v_21.xyz + cb3_3.tint_symbol_2[7u].xyz);
742
+ r10 = vec4<f32>(v_200.xyz, r10.w);
743
+ let v_201 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz);
744
+ r11 = vec4<f32>(v_201.xyz, r11.w);
745
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[15u].xyz);
746
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f);
747
+ r7.w = (r7.w * cb3_3.tint_symbol_2[23u].w);
748
+ let v_202 = fma(cb3_3.tint_symbol_2[15u].xyz, r7.www, cb3_3.tint_symbol_2[7u].xyz);
749
+ r11 = vec4<f32>(v_202.xyz, r11.w);
750
+ let v_203 = (r11.xyz + v_21.xyz);
751
+ r11 = vec4<f32>(v_203.xyz, r11.w);
752
+ let v_204 = bitcast<vec3<u32>>(r7.yyy);
753
+ let v_205 = r10.xyz;
754
+ let v_206 = select(r11.xyz, v_205, (v_204 != vec3<u32>()));
755
+ r10 = vec4<f32>(v_206.xyz, r10.w);
756
+ r7.y = dot(r10.xyz, r10.xyz);
757
+ let v_207 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
758
+ r10 = vec4<f32>(v_207.xyz, r10.w);
759
+ r7.w = dot(r10.xyz, r10.xyz);
760
+ r7.w = inverseSqrt(r7.w);
761
+ let v_208 = (r7.www * r10.xyz);
762
+ r10 = vec4<f32>(v_208.xyz, r10.w);
763
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[7u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
764
+ r7.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f);
765
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[15u].w);
766
+ r7.y = (r7.y / r7.w);
767
+ let v_209 = -(cb3_3.tint_symbol_2[15u].xyzx);
768
+ r7.w = dot(r10.xyz, v_209.xyz);
769
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f);
770
+ let v_210 = dot(r10.xyz, r2.yzw);
771
+ r9.w = clamp(vec4<f32>(v_210, v_210, v_210, v_210).w, 0.0f, 1.0f);
772
+ r7.w = (r7.w * r9.w);
773
+ r9.w = (r7.y * r7.w);
774
+ let v_211 = (r9.www * cb3_3.tint_symbol_2[23u].xyz);
775
+ r11 = vec4<f32>(v_211.xyz, r11.w);
776
+ let v_212 = fma(r11.xyz, r0.xyz, r9.xyz);
777
+ r9 = vec4<f32>(v_212.xyz, r9.w);
778
+ let v_213 = fma(r3.xyz, r3.www, r10.xyz);
779
+ r10 = vec4<f32>(v_213.xyz, r10.w);
780
+ r9.w = dot(r10.xyz, r10.xyz);
781
+ r9.w = inverseSqrt(r9.w);
782
+ let v_214 = (r9.www * r10.xyz);
783
+ r10 = vec4<f32>(v_214.xyz, r10.w);
784
+ let v_215 = dot(r10.xyz, r4.xyz);
785
+ r9.w = clamp(vec4<f32>(v_215, v_215, v_215, v_215).w, 0.0f, 1.0f);
786
+ r9.w = ((-(r9.wwww)).w + 1.0f);
787
+ r10.w = (r9.w * r9.w);
788
+ r10.w = (r10.w * r10.w);
789
+ r9.w = (r9.w * r10.w);
790
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
791
+ let v_216 = dot(r10.xyz, r2.yzw);
792
+ r10.x = clamp(vec4<f32>(v_216, v_216, v_216, v_216).x, 0.0f, 1.0f);
793
+ r10.x = log2(r10.x);
794
+ r10.x = (r8.y * r10.x);
795
+ r10.x = exp2(r10.x);
796
+ r9.w = (r9.w * r10.x);
797
+ r7.w = (r7.w * r9.w);
798
+ r7.y = (r7.y * r7.w);
799
+ r7.y = (r4.w * r7.y);
800
+ let v_217 = fma(r7.yyy, cb3_3.tint_symbol_2[23u].xyz, r8.xzw);
801
+ r8 = vec4<f32>(v_217.x, r8.y, v_217.yz);
802
+ }
803
+ }
804
+ if ((bitcast<u32>(r6.w) != 0u)) {
805
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
806
+ } else {
807
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (5i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
808
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
809
+ if ((bitcast<u32>(r6.w) != 0u)) {
810
+ } else {
811
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f)));
812
+ let v_218 = (v_21.xyz + cb3_3.tint_symbol_2[8u].xyz);
813
+ r10 = vec4<f32>(v_218.xyz, r10.w);
814
+ let v_219 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz);
815
+ r11 = vec4<f32>(v_219.xyz, r11.w);
816
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[16u].xyz);
817
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f);
818
+ r7.w = (r7.w * cb3_3.tint_symbol_2[24u].w);
819
+ let v_220 = fma(cb3_3.tint_symbol_2[16u].xyz, r7.www, cb3_3.tint_symbol_2[8u].xyz);
820
+ r11 = vec4<f32>(v_220.xyz, r11.w);
821
+ let v_221 = (r11.xyz + v_21.xyz);
822
+ r11 = vec4<f32>(v_221.xyz, r11.w);
823
+ let v_222 = bitcast<vec3<u32>>(r7.yyy);
824
+ let v_223 = r10.xyz;
825
+ let v_224 = select(r11.xyz, v_223, (v_222 != vec3<u32>()));
826
+ r10 = vec4<f32>(v_224.xyz, r10.w);
827
+ r7.y = dot(r10.xyz, r10.xyz);
828
+ let v_225 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
829
+ r10 = vec4<f32>(v_225.xyz, r10.w);
830
+ r7.w = dot(r10.xyz, r10.xyz);
831
+ r7.w = inverseSqrt(r7.w);
832
+ let v_226 = (r7.www * r10.xyz);
833
+ r10 = vec4<f32>(v_226.xyz, r10.w);
834
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[8u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
835
+ r7.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f);
836
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[16u].w);
837
+ r7.y = (r7.y / r7.w);
838
+ let v_227 = -(cb3_3.tint_symbol_2[16u].xyzx);
839
+ r7.w = dot(r10.xyz, v_227.xyz);
840
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f);
841
+ let v_228 = dot(r10.xyz, r2.yzw);
842
+ r9.w = clamp(vec4<f32>(v_228, v_228, v_228, v_228).w, 0.0f, 1.0f);
843
+ r7.w = (r7.w * r9.w);
844
+ r9.w = (r7.y * r7.w);
845
+ let v_229 = (r9.www * cb3_3.tint_symbol_2[24u].xyz);
846
+ r11 = vec4<f32>(v_229.xyz, r11.w);
847
+ let v_230 = fma(r11.xyz, r0.xyz, r9.xyz);
848
+ r9 = vec4<f32>(v_230.xyz, r9.w);
849
+ let v_231 = fma(r3.xyz, r3.www, r10.xyz);
850
+ r10 = vec4<f32>(v_231.xyz, r10.w);
851
+ r9.w = dot(r10.xyz, r10.xyz);
852
+ r9.w = inverseSqrt(r9.w);
853
+ let v_232 = (r9.www * r10.xyz);
854
+ r10 = vec4<f32>(v_232.xyz, r10.w);
855
+ let v_233 = dot(r10.xyz, r4.xyz);
856
+ r9.w = clamp(vec4<f32>(v_233, v_233, v_233, v_233).w, 0.0f, 1.0f);
857
+ r9.w = ((-(r9.wwww)).w + 1.0f);
858
+ r10.w = (r9.w * r9.w);
859
+ r10.w = (r10.w * r10.w);
860
+ r9.w = (r9.w * r10.w);
861
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
862
+ let v_234 = dot(r10.xyz, r2.yzw);
863
+ r10.x = clamp(vec4<f32>(v_234, v_234, v_234, v_234).x, 0.0f, 1.0f);
864
+ r10.x = log2(r10.x);
865
+ r10.x = (r8.y * r10.x);
866
+ r10.x = exp2(r10.x);
867
+ r9.w = (r9.w * r10.x);
868
+ r7.w = (r7.w * r9.w);
869
+ r7.y = (r7.y * r7.w);
870
+ r7.y = (r4.w * r7.y);
871
+ let v_235 = fma(r7.yyy, cb3_3.tint_symbol_2[24u].xyz, r8.xzw);
872
+ r8 = vec4<f32>(v_235.x, r8.y, v_235.yz);
873
+ }
874
+ }
875
+ if ((bitcast<u32>(r6.w) != 0u)) {
876
+ r6.w = bitcast<f32>(v.tint_symbol_7[3i].x);
877
+ } else {
878
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (6i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
879
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
880
+ if ((bitcast<u32>(r6.w) != 0u)) {
881
+ } else {
882
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f)));
883
+ let v_236 = (v_21.xyz + cb3_3.tint_symbol_2[9u].xyz);
884
+ r10 = vec4<f32>(v_236.xyz, r10.w);
885
+ let v_237 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz);
886
+ r11 = vec4<f32>(v_237.xyz, r11.w);
887
+ r7.w = dot(r11.xyz, cb3_3.tint_symbol_2[17u].xyz);
888
+ r7.w = clamp(((r7.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f);
889
+ r7.w = (r7.w * cb3_3.tint_symbol_2[25u].w);
890
+ let v_238 = fma(cb3_3.tint_symbol_2[17u].xyz, r7.www, cb3_3.tint_symbol_2[9u].xyz);
891
+ r11 = vec4<f32>(v_238.xyz, r11.w);
892
+ let v_239 = (r11.xyz + v_21.xyz);
893
+ r11 = vec4<f32>(v_239.xyz, r11.w);
894
+ let v_240 = bitcast<vec3<u32>>(r7.yyy);
895
+ let v_241 = r10.xyz;
896
+ let v_242 = select(r11.xyz, v_241, (v_240 != vec3<u32>()));
897
+ r10 = vec4<f32>(v_242.xyz, r10.w);
898
+ r7.y = dot(r10.xyz, r10.xyz);
899
+ let v_243 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
900
+ r10 = vec4<f32>(v_243.xyz, r10.w);
901
+ r7.w = dot(r10.xyz, r10.xyz);
902
+ r7.w = inverseSqrt(r7.w);
903
+ let v_244 = (r7.www * r10.xyz);
904
+ r10 = vec4<f32>(v_244.xyz, r10.w);
905
+ r7.y = clamp(fma(-(r7.yyyy), cb3_3.tint_symbol_2[9u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
906
+ r7.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f);
907
+ r7.w = fma(r7.w, r7.y, cb3_3.tint_symbol_2[17u].w);
908
+ r7.y = (r7.y / r7.w);
909
+ let v_245 = -(cb3_3.tint_symbol_2[17u].xyzx);
910
+ r7.w = dot(r10.xyz, v_245.xyz);
911
+ r7.w = clamp(fma(r7.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f);
912
+ let v_246 = dot(r10.xyz, r2.yzw);
913
+ r9.w = clamp(vec4<f32>(v_246, v_246, v_246, v_246).w, 0.0f, 1.0f);
914
+ r7.w = (r7.w * r9.w);
915
+ r9.w = (r7.y * r7.w);
916
+ let v_247 = (r9.www * cb3_3.tint_symbol_2[25u].xyz);
917
+ r11 = vec4<f32>(v_247.xyz, r11.w);
918
+ let v_248 = fma(r11.xyz, r0.xyz, r9.xyz);
919
+ r9 = vec4<f32>(v_248.xyz, r9.w);
920
+ let v_249 = fma(r3.xyz, r3.www, r10.xyz);
921
+ r10 = vec4<f32>(v_249.xyz, r10.w);
922
+ r9.w = dot(r10.xyz, r10.xyz);
923
+ r9.w = inverseSqrt(r9.w);
924
+ let v_250 = (r9.www * r10.xyz);
925
+ r10 = vec4<f32>(v_250.xyz, r10.w);
926
+ let v_251 = dot(r10.xyz, r4.xyz);
927
+ r9.w = clamp(vec4<f32>(v_251, v_251, v_251, v_251).w, 0.0f, 1.0f);
928
+ r9.w = ((-(r9.wwww)).w + 1.0f);
929
+ r10.w = (r9.w * r9.w);
930
+ r10.w = (r10.w * r10.w);
931
+ r9.w = (r9.w * r10.w);
932
+ r9.w = fma(cb12_12.tint_symbol_4[0u].y, r9.w, r7.z);
933
+ let v_252 = dot(r10.xyz, r2.yzw);
934
+ r10.x = clamp(vec4<f32>(v_252, v_252, v_252, v_252).x, 0.0f, 1.0f);
935
+ r10.x = log2(r10.x);
936
+ r10.x = (r8.y * r10.x);
937
+ r10.x = exp2(r10.x);
938
+ r9.w = (r9.w * r10.x);
939
+ r7.w = (r7.w * r9.w);
940
+ r7.y = (r7.y * r7.w);
941
+ r7.y = (r4.w * r7.y);
942
+ let v_253 = fma(r7.yyy, cb3_3.tint_symbol_2[25u].xyz, r8.xzw);
943
+ r8 = vec4<f32>(v_253.x, r8.y, v_253.yz);
944
+ }
945
+ }
946
+ if ((bitcast<u32>(r6.w) != 0u)) {
947
+ } else {
948
+ r7.y = bitcast<f32>(select(0u, 4294967295u, (7i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
949
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r7.y)));
950
+ if ((bitcast<u32>(r6.w) != 0u)) {
951
+ } else {
952
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f)));
953
+ let v_254 = (v_21.xyz + cb3_3.tint_symbol_2[10u].xyz);
954
+ r10 = vec4<f32>(v_254.xyz, r10.w);
955
+ let v_255 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz);
956
+ r11 = vec4<f32>(v_255.xyz, r11.w);
957
+ r7.y = dot(r11.xyz, cb3_3.tint_symbol_2[18u].xyz);
958
+ r7.y = clamp(((r7.yyyy / cb3_3.tint_symbol_2[26u].wwww)).y, 0.0f, 1.0f);
959
+ r7.y = (r7.y * cb3_3.tint_symbol_2[26u].w);
960
+ let v_256 = fma(cb3_3.tint_symbol_2[18u].xyz, r7.yyy, cb3_3.tint_symbol_2[10u].xyz);
961
+ r11 = vec4<f32>(v_256.xyz, r11.w);
962
+ let v_257 = (r11.xyz + v_21.xyz);
963
+ r11 = vec4<f32>(v_257.xyz, r11.w);
964
+ let v_258 = bitcast<vec3<u32>>(r6.www);
965
+ let v_259 = r10.xyz;
966
+ let v_260 = select(r11.xyz, v_259, (v_258 != vec3<u32>()));
967
+ r10 = vec4<f32>(v_260.xyz, r10.w);
968
+ r6.w = dot(r10.xyz, r10.xyz);
969
+ let v_261 = (r10.xyz + vec3<f32>(0.00000099999999747524f));
970
+ r10 = vec4<f32>(v_261.xyz, r10.w);
971
+ r7.y = dot(r10.xyz, r10.xyz);
972
+ r7.y = inverseSqrt(r7.y);
973
+ let v_262 = (r7.yyy * r10.xyz);
974
+ r10 = vec4<f32>(v_262.xyz, r10.w);
975
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
976
+ r7.y = ((-(cb3_3.tint_symbol_2[18u].wwww)).y + 1.0f);
977
+ r7.y = fma(r7.y, r6.w, cb3_3.tint_symbol_2[18u].w);
978
+ r6.w = (r6.w / r7.y);
979
+ let v_263 = -(cb3_3.tint_symbol_2[18u].xyzx);
980
+ r7.y = dot(r10.xyz, v_263.xyz);
981
+ r7.y = clamp(fma(r7.yyyy, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).y, 0.0f, 1.0f);
982
+ let v_264 = dot(r10.xyz, r2.yzw);
983
+ r7.w = clamp(vec4<f32>(v_264, v_264, v_264, v_264).w, 0.0f, 1.0f);
984
+ r7.y = (r7.y * r7.w);
985
+ r7.w = (r6.w * r7.y);
986
+ let v_265 = (r7.www * cb3_3.tint_symbol_2[26u].xyz);
987
+ r11 = vec4<f32>(v_265.xyz, r11.w);
988
+ let v_266 = fma(r11.xyz, r0.xyz, r9.xyz);
989
+ r9 = vec4<f32>(v_266.xyz, r9.w);
990
+ let v_267 = fma(r3.xyz, r3.www, r10.xyz);
991
+ r3 = vec4<f32>(v_267.xyz, r3.w);
992
+ r3.w = dot(r3.xyz, r3.xyz);
993
+ r3.w = inverseSqrt(r3.w);
994
+ let v_268 = (r3.www * r3.xyz);
995
+ r3 = vec4<f32>(v_268.xyz, r3.w);
996
+ let v_269 = dot(r3.xyz, r4.xyz);
997
+ r3.w = clamp(vec4<f32>(v_269, v_269, v_269, v_269).w, 0.0f, 1.0f);
998
+ r3.w = ((-(r3.wwww)).w + 1.0f);
999
+ r4.x = (r3.w * r3.w);
1000
+ r4.x = (r4.x * r4.x);
1001
+ r3.w = (r3.w * r4.x);
1002
+ r3.w = fma(cb12_12.tint_symbol_4[0u].y, r3.w, r7.z);
1003
+ let v_270 = dot(r3.xyz, r2.yzw);
1004
+ r3.x = clamp(vec4<f32>(v_270, v_270, v_270, v_270).x, 0.0f, 1.0f);
1005
+ r3.x = log2(r3.x);
1006
+ r3.x = (r3.x * r8.y);
1007
+ r3.x = exp2(r3.x);
1008
+ r3.x = (r3.x * r3.w);
1009
+ r3.x = (r7.y * r3.x);
1010
+ r3.x = (r6.w * r3.x);
1011
+ r3.x = (r4.w * r3.x);
1012
+ let v_271 = fma(r3.xxx, cb3_3.tint_symbol_2[26u].xyz, r8.xzw);
1013
+ r8 = vec4<f32>(v_271.x, r8.y, v_271.yz);
1014
+ }
1015
+ }
1016
+ r3.x = (r7.x * r7.x);
1017
+ r1.x = (r1.x * r1.x);
1018
+ let v_272 = (r8.xzw * r1.xxx);
1019
+ r3 = vec4<f32>(r3.x, v_272.xyz);
1020
+ let v_273 = fma(r3.xxx, r9.xyz, r3.yzw);
1021
+ r3 = vec4<f32>(v_273.xyz, r3.w);
1022
+ let v_274 = fma(r5.xyz, r5.www, r3.xyz);
1023
+ r3 = vec4<f32>(v_274.xyz, r3.w);
1024
+ r1.x = fma(r1.w, r2.x, cb3_3.tint_symbol_2[43u].w);
1025
+ r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w);
1026
+ r1.x = max(r1.x, 0.0f);
1027
+ let v_275 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz);
1028
+ r4 = vec4<f32>(v_275.xyz, r4.w);
1029
+ r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
1030
+ let v_276 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz);
1031
+ r5 = vec4<f32>(v_276.xyz, r5.w);
1032
+ let v_277 = (r5.xyz * cb2_2.tint_symbol_1[16u].zzz);
1033
+ r5 = vec4<f32>(v_277.xyz, r5.w);
1034
+ let v_278 = fma(r4.xyz, r1.www, r5.xyz);
1035
+ r4 = vec4<f32>(v_278.xyz, r4.w);
1036
+ let v_279 = (r1.zzz * r4.xyz);
1037
+ r4 = vec4<f32>(v_279.xyz, r4.w);
1038
+ let v_280 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz);
1039
+ r1 = vec4<f32>(v_280.x, r1.y, v_280.yz);
1040
+ r5.x = cb3_3.tint_symbol_2[46u].w;
1041
+ r5.y = cb3_3.tint_symbol_2[47u].w;
1042
+ r5.z = cb3_3.tint_symbol_2[48u].w;
1043
+ let v_281 = dot(r5.xyz, r2.yzw);
1044
+ r2.x = clamp(vec4<f32>(v_281, v_281, v_281, v_281).x, 0.0f, 1.0f);
1045
+ let v_282 = fma(cb3_3.tint_symbol_2[49u].xyz, r2.xxx, r1.xzw);
1046
+ r1 = vec4<f32>(v_282.x, r1.y, v_282.yz);
1047
+ let v_283 = fma(r1.xzw, r1.yyy, r4.xyz);
1048
+ r1 = vec4<f32>(v_283.xyz, r1.w);
1049
+ let v_284 = (r7.xxx * r1.xyz);
1050
+ r1 = vec4<f32>(v_284.xyz, r1.w);
1051
+ let v_285 = fma(r1.xyz, r0.xyz, r3.xyz);
1052
+ r0 = vec4<f32>(v_285.xyz, r0.w);
1053
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
1054
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
1055
+ r0.w = dot(r6.xyz, r6.xyz);
1056
+ r1.x = sqrt(r0.w);
1057
+ let v_286 = -(cb3_3.tint_symbol_2[50u].xxxx);
1058
+ r1.y = (r1.x + v_286.y);
1059
+ r1.y = max(r1.y, 0.0f);
1060
+ r1.x = (r1.y / r1.x);
1061
+ r1.x = (r1.x * r6.z);
1062
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
1063
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
1064
+ r1.w = (r1.z * -1.44269502162933349609f);
1065
+ r1.w = exp2(r1.w);
1066
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1067
+ r1.z = (r1.w / r1.z);
1068
+ let v_287 = bitcast<u32>(r1.x);
1069
+ r1.x = select(1.0f, r1.z, (v_287 != 0u));
1070
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
1071
+ r1.x = (r1.x * r1.z);
1072
+ r1.x = min(r1.x, 1.0f);
1073
+ r1.x = (r1.x * 1.44269502162933349609f);
1074
+ r1.x = exp2(r1.x);
1075
+ r1.x = min(r1.x, 1.0f);
1076
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
1077
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
1078
+ r0.w = inverseSqrt(r0.w);
1079
+ let v_288 = (r0.www * r6.xyz);
1080
+ r2 = vec4<f32>(v_288.xyz, r2.w);
1081
+ let v_289 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
1082
+ r0.w = clamp(vec4<f32>(v_289, v_289, v_289, v_289).w, 0.0f, 1.0f);
1083
+ r0.w = log2(r0.w);
1084
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1085
+ r0.w = exp2(r0.w);
1086
+ let v_290 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
1087
+ r1.w = clamp(vec4<f32>(v_290, v_290, v_290, v_290).w, 0.0f, 1.0f);
1088
+ r1.w = log2(r1.w);
1089
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
1090
+ r1.w = exp2(r1.w);
1091
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
1092
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
1093
+ let v_291 = -(cb3_3.tint_symbol_2[52u].xxxx);
1094
+ r2.x = (r1.y + v_291.x);
1095
+ r2.x = max(r2.x, 0.0f);
1096
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
1097
+ r2.x = (r2.x * 1.44269502162933349609f);
1098
+ r2.x = exp2(r2.x);
1099
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1100
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
1101
+ let v_292 = -(cb3_3.tint_symbol_2[51u].zzzz);
1102
+ r1.y = (r1.y * v_292.y);
1103
+ r1.y = (r1.y * 1.44269502162933349609f);
1104
+ r1.y = exp2(r1.y);
1105
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
1106
+ let v_293 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1107
+ r2 = vec4<f32>(v_293.xyz, r2.w);
1108
+ let v_294 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
1109
+ r2 = vec4<f32>(v_294.xyz, r2.w);
1110
+ let v_295 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1111
+ r3 = vec4<f32>(v_295.xyz, r3.w);
1112
+ let v_296 = fma(r1.www, r3.xyz, r2.xyz);
1113
+ r2 = vec4<f32>(v_296.xyz, r2.w);
1114
+ let v_297 = -(cb3_3.tint_symbol_2[57u].xyzx);
1115
+ let v_298 = (r2.xyz + v_297.xyz);
1116
+ r2 = vec4<f32>(v_298.xyz, r2.w);
1117
+ let v_299 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
1118
+ r2 = vec4<f32>(v_299.xyz, r2.w);
1119
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1120
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1121
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1122
+ let v_300 = ((-(r2.xyzx)).xyz + r3.xyz);
1123
+ r3 = vec4<f32>(v_300.xyz, r3.w);
1124
+ let v_301 = fma(r1.xxx, r3.xyz, r2.xyz);
1125
+ r1 = vec4<f32>(v_301.xy, r1.z, v_301.z);
1126
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
1127
+ if ((bitcast<u32>(r0.w) != 0u)) {
1128
+ let v_302 = (v7.xy * cb2_2.tint_symbol_1[18u].zw);
1129
+ r2 = vec4<f32>(v_302.xy, r2.zw);
1130
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
1131
+ r0.w = (r2.x + -1.0f);
1132
+ r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
1133
+ } else {
1134
+ r0.w = 1.0f;
1135
+ }
1136
+ let v_303 = -(r0.xyxz);
1137
+ let v_304 = fma(r1.xyw, r0.www, v_303.xyw);
1138
+ r1 = vec4<f32>(v_304.xy, r1.z, v_304.z);
1139
+ let v_305 = fma(r1.zzz, r1.xyw, r0.xyz);
1140
+ r1 = vec4<f32>(v_305.xyz, r1.w);
1141
+ } else {
1142
+ r0.w = dot(r6.xyz, r6.xyz);
1143
+ r1.w = sqrt(r0.w);
1144
+ let v_306 = -(cb3_3.tint_symbol_2[50u].xxxx);
1145
+ r2.x = (r1.w + v_306.x);
1146
+ r2.x = max(r2.x, 0.0f);
1147
+ r1.w = (r2.x / r1.w);
1148
+ r1.w = (r1.w * r6.z);
1149
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z);
1150
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
1151
+ r2.z = (r2.y * -1.44269502162933349609f);
1152
+ r2.z = exp2(r2.z);
1153
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
1154
+ r2.y = (r2.z / r2.y);
1155
+ let v_307 = bitcast<u32>(r1.w);
1156
+ r1.w = select(1.0f, r2.y, (v_307 != 0u));
1157
+ r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w);
1158
+ r1.w = (r1.w * r2.y);
1159
+ r1.w = min(r1.w, 1.0f);
1160
+ r1.w = (r1.w * 1.44269502162933349609f);
1161
+ r1.w = exp2(r1.w);
1162
+ r1.w = min(r1.w, 1.0f);
1163
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1164
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y);
1165
+ r0.w = inverseSqrt(r0.w);
1166
+ let v_308 = (r0.www * r6.xyz);
1167
+ r3 = vec4<f32>(v_308.xyz, r3.w);
1168
+ let v_309 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
1169
+ r0.w = clamp(vec4<f32>(v_309, v_309, v_309, v_309).w, 0.0f, 1.0f);
1170
+ r0.w = log2(r0.w);
1171
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1172
+ r0.w = exp2(r0.w);
1173
+ let v_310 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
1174
+ r2.z = clamp(vec4<f32>(v_310, v_310, v_310, v_310).z, 0.0f, 1.0f);
1175
+ r2.z = log2(r2.z);
1176
+ r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w);
1177
+ r2.z = exp2(r2.z);
1178
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f);
1179
+ r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y);
1180
+ let v_311 = -(cb3_3.tint_symbol_2[52u].xxxx);
1181
+ r2.w = (r2.x + v_311.w);
1182
+ r2.w = max(r2.w, 0.0f);
1183
+ r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x);
1184
+ r2.w = (r2.w * 1.44269502162933349609f);
1185
+ r2.w = exp2(r2.w);
1186
+ r2.w = ((-(r2.wwww)).w + 1.0f);
1187
+ r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f);
1188
+ let v_312 = -(cb3_3.tint_symbol_2[51u].zzzz);
1189
+ r2.x = (r2.x * v_312.x);
1190
+ r2.x = (r2.x * 1.44269502162933349609f);
1191
+ r2.x = exp2(r2.x);
1192
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1193
+ let v_313 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1194
+ r3 = vec4<f32>(v_313.xyz, r3.w);
1195
+ let v_314 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
1196
+ r3 = vec4<f32>(v_314.xyz, r3.w);
1197
+ let v_315 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1198
+ r4 = vec4<f32>(v_315.xyz, r4.w);
1199
+ let v_316 = fma(r2.zzz, r4.xyz, r3.xyz);
1200
+ r3 = vec4<f32>(v_316.xyz, r3.w);
1201
+ let v_317 = -(cb3_3.tint_symbol_2[57u].xyzx);
1202
+ let v_318 = (r3.xyz + v_317.xyz);
1203
+ r3 = vec4<f32>(v_318.xyz, r3.w);
1204
+ let v_319 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
1205
+ r2 = vec4<f32>(v_319.x, r2.y, v_319.yz);
1206
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1207
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1208
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1209
+ let v_320 = ((-(r2.xzwx)).xyz + r3.xyz);
1210
+ r3 = vec4<f32>(v_320.xyz, r3.w);
1211
+ let v_321 = fma(r1.www, r3.xyz, r2.xzw);
1212
+ r2 = vec4<f32>(v_321.x, r2.y, v_321.yz);
1213
+ let v_322 = ((-(r0.xxyz)).xzw + r2.xzw);
1214
+ r2 = vec4<f32>(v_322.x, r2.y, v_322.yz);
1215
+ let v_323 = fma(r2.yyy, r2.xzw, r0.xyz);
1216
+ r1 = vec4<f32>(v_323.xyz, r1.w);
1217
+ }
1218
+ let v_324 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
1219
+ o0 = vec4<f32>(v_324.xyz, o0.w);
1220
+ }
1221
+
1222
+ fn v_3(v_325 : bool) {
1223
+ if (v_325) {
1224
+ discard;
1225
+ return;
1226
+ }
1227
+ }
1228
+
1229
+ @fragment
1230
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @builtin(position) v_326 : vec4<f32>) -> @location(0u) vec4<f32> {
1231
+ main_inner(v0, v1, v2, v3, v4, v5, v6, v_326);
1232
+ return o0;
1233
+ }
b/8b0b5899ed/shaders/011f3f3fcac784b6.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [1]
b/8b0b5899ed/shaders/011f3f3fcac784b6.wgsl ADDED
@@ -0,0 +1,428 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ struct cb16_struct {
20
+ tint_symbol : array<vec4<f32>, 16u>,
21
+ }
22
+
23
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
24
+
25
+ struct cb19_struct {
26
+ tint_symbol_1 : array<vec4<f32>, 19u>,
27
+ }
28
+
29
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb19_struct;
30
+
31
+ struct cb92_struct {
32
+ tint_symbol_2 : array<vec4<f32>, 92u>,
33
+ }
34
+
35
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb92_struct;
36
+
37
+ @group(1u) @binding(19u) var s3 : sampler;
38
+
39
+ @group(1u) @binding(20u) var s4 : sampler;
40
+
41
+ @group(1u) @binding(21u) var s5 : sampler;
42
+
43
+ @group(1u) @binding(23u) var s7 : sampler;
44
+
45
+ @group(1u) @binding(25u) var s9 : sampler;
46
+
47
+ @group(1u) @binding(26u) var s10 : sampler;
48
+
49
+ @group(1u) @binding(27u) var s11 : sampler;
50
+
51
+ @group(1u) @binding(28u) var s12 : sampler;
52
+
53
+ @group(1u) @binding(31u) var s15 : sampler;
54
+
55
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
56
+
57
+ @group(1u) @binding(36u) var t4 : texture_2d<f32>;
58
+
59
+ @group(1u) @binding(37u) var t5 : texture_2d<f32>;
60
+
61
+ @group(1u) @binding(39u) var t7 : texture_2d<f32>;
62
+
63
+ @group(1u) @binding(40u) var t8 : texture_2d<u32>;
64
+
65
+ @group(1u) @binding(41u) var t9 : texture_2d<f32>;
66
+
67
+ @group(1u) @binding(42u) var t10 : texture_2d<f32>;
68
+
69
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
70
+
71
+ @group(1u) @binding(44u) var t12 : texture_2d<f32>;
72
+
73
+ @group(1u) @binding(47u) var t15 : texture_2d<f32>;
74
+
75
+ var<private> o0 : vec4<f32>;
76
+
77
+ struct tint_symbol_4 {
78
+ tint_symbol_3 : array<vec4<u32>, 1u>,
79
+ }
80
+
81
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_4;
82
+
83
+ fn main_inner(v1 : vec4<f32>, v2 : vec4<f32>) {
84
+ r0 = textureSample(t3, s3, v1.xyxx.xy);
85
+ r0.x = ((-(r0.xxxx)).x + cb5_5.tint_symbol_2[0u].w);
86
+ r0.x = (r0.x + 1.0f);
87
+ r0.x = (cb5_5.tint_symbol_2[0u].z / r0.x);
88
+ r1 = textureSample(t5, s5, v1.xyxx.xy);
89
+ let v_1 = (r1.xyz * cb2_2.tint_symbol_1[17u].www);
90
+ r0 = vec4<f32>(r0.x, v_1.xyz);
91
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb5_5.tint_symbol_2[91u].w)));
92
+ if ((bitcast<u32>(r1.x) != 0u)) {
93
+ } else {
94
+ r1 = fma(cb5_5.tint_symbol_2[72u].xyxy, vec4<f32>(-1.0f, -0.5f, 0.5f, -1.0f), v1.xyxy);
95
+ r2 = textureSample(t4, s4, r1.xyxx.xy);
96
+ r3 = textureSample(t4, s4, r1.zwzz.xy);
97
+ r4 = fma(cb5_5.tint_symbol_2[72u].xyxy, vec4<f32>(-0.5f, 1.0f, 1.0f, 0.5f), v1.xyxy);
98
+ r5 = textureSample(t4, s4, r4.xyxx.xy);
99
+ r6 = textureSample(t4, s4, r4.zwzz.xy);
100
+ r7 = textureSample(t4, s4, v1.xyxx.xy);
101
+ let v_2 = (r2.xyz + r3.xyz);
102
+ r2 = vec4<f32>(v_2.xyz, r2.w);
103
+ let v_3 = (r5.xyz + r2.xyz);
104
+ r2 = vec4<f32>(v_3.xyz, r2.w);
105
+ let v_4 = (r6.xyz + r2.xyz);
106
+ r2 = vec4<f32>(v_4.xyz, r2.w);
107
+ let v_5 = (r7.xyz * vec3<f32>(0.5f));
108
+ r3 = vec4<f32>(v_5.xyz, r3.w);
109
+ let v_6 = fma(r7.xyz, vec3<f32>(0.5f), r2.xyz);
110
+ r2 = vec4<f32>(v_6.xyz, r2.w);
111
+ r5 = textureSample(t9, s9, r1.xyxx.xy);
112
+ r1 = textureSample(t9, s9, r1.zwzz.xy);
113
+ r6 = textureSample(t9, s9, r4.xyxx.xy);
114
+ r4 = textureSample(t9, s9, r4.zwzz.xy);
115
+ r7 = textureSample(t9, s9, v1.xyxx.xy);
116
+ let v_7 = (r1.xyz + r5.xyz);
117
+ r1 = vec4<f32>(v_7.xyz, r1.w);
118
+ let v_8 = (r6.xyz + r1.xyz);
119
+ r1 = vec4<f32>(v_8.xyz, r1.w);
120
+ let v_9 = (r4.xyz + r1.xyz);
121
+ r1 = vec4<f32>(v_9.xyz, r1.w);
122
+ let v_10 = fma(r7.xyz, vec3<f32>(0.5f), r1.xyz);
123
+ r1 = vec4<f32>(v_10.xyz, r1.w);
124
+ let v_11 = fma(r7.xyz, vec3<f32>(0.5f), r3.xyz);
125
+ r3 = vec4<f32>(v_11.xyz, r3.w);
126
+ let v_12 = (r2.xyz * vec3<f32>(0.11111111193895339966f));
127
+ r2 = vec4<f32>(v_12.xyz, r2.w);
128
+ let v_13 = fma(r1.xyz, vec3<f32>(0.11111111193895339966f), r2.xyz);
129
+ r1 = vec4<f32>(v_13.xyz, r1.w);
130
+ r1.w = bitcast<f32>(select(0u, 4294967295u, !((cb5_5.tint_symbol_2[4u].x == 0.0f))));
131
+ let v_14 = bitcast<vec3<u32>>(r1.www);
132
+ let v_15 = r7.xyz;
133
+ let v_16 = select(r3.xyz, v_15, (v_14 != vec3<u32>()));
134
+ r2 = vec4<f32>(v_16.xyz, r2.w);
135
+ let v_17 = bitcast<vec3<u32>>(r1.www);
136
+ let v_18 = r7.xyz;
137
+ let v_19 = select(r1.xyz, v_18, (v_17 != vec3<u32>()));
138
+ r1 = vec4<f32>(v_19.xyz, r1.w);
139
+ let v_20 = -(cb5_5.tint_symbol_2[3u].xzxx);
140
+ let v_21 = (r0.xx + v_20.xy);
141
+ r3 = vec4<f32>(v_21.xy, r3.zw);
142
+ r4.x = (r3.y * cb5_5.tint_symbol_2[3u].w);
143
+ r1.w = clamp(fma(-(r3.xxxx), cb5_5.tint_symbol_2[3u].yyyy, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
144
+ r4.x = clamp(r4.xxxx.x, 0.0f, 1.0f);
145
+ r1.w = max(r1.w, r4.x);
146
+ let v_22 = clamp(fma(r1.wwww, vec4<f32>(-2.00400805473327636719f, -2.00400805473327636719f, -1000.0f, 0.0f), vec4<f32>(1.0f, 2.00200390815734863281f, 1000.0f, 0.0f)).xyz, vec3<f32>(), vec3<f32>(1.0f));
147
+ r3 = vec4<f32>(v_22.xyz, r3.w);
148
+ r1.w = ((-(r3.xxxx)).w + 1.0f);
149
+ r1.w = min(r1.w, r3.y);
150
+ r2.w = (r1.w + r3.x);
151
+ r3.y = ((-(r2.wwww)).y + 1.0f);
152
+ r3.y = min(r3.y, r3.z);
153
+ r2.w = (r2.w + r3.y);
154
+ r2.w = ((-(r2.wwww)).w + 1.0f);
155
+ let v_23 = (r1.www * r7.xyz);
156
+ r4 = vec4<f32>(v_23.xyz, r4.w);
157
+ let v_24 = fma(r0.yzw, r3.xxx, r4.xyz);
158
+ r3 = vec4<f32>(v_24.x, r3.y, v_24.yz);
159
+ let v_25 = fma(r2.xyz, r3.yyy, r3.xzw);
160
+ r2 = vec4<f32>(v_25.xyz, r2.w);
161
+ let v_26 = fma(r1.xyz, r2.www, r2.xyz);
162
+ r0 = vec4<f32>(r0.x, v_26.xyz);
163
+ }
164
+ if ((bitcast<u32>(cb5_5.tint_symbol_2[90u].z) != 0u)) {
165
+ r1 = textureSample(t11, s11, v1.xyxx.xy);
166
+ let v_27 = ((-(r0.yzwy)).xyz + r1.xyz);
167
+ r1 = vec4<f32>(v_27.xyz, r1.w);
168
+ let v_28 = fma(r1.www, r1.xyz, r0.yzw);
169
+ r0 = vec4<f32>(r0.x, v_28.xyz);
170
+ }
171
+ let v_29 = (v1.xy * cb2_2.tint_symbol_1[18u].xy);
172
+ r1 = vec4<f32>(v_29.xy, r1.zw);
173
+ let v_30 = r1.xy;
174
+ let v_31 = max(v_30, vec2<f32>(-2147483648.0f));
175
+ let v_32 = bitcast<vec2<f32>>(select(select(vec2<i32>(v_31), vec2<i32>(2147483647i), (v_31 >= vec2<f32>(2147483648.0f))), vec2<i32>(), !((v_30 == v_30))));
176
+ r1 = vec4<f32>(v_32.xy, r1.zw);
177
+ r1 = vec4<f32>(r1.xy, vec2<f32>());
178
+ r1 = bitcast<vec4<f32>>(textureLoad(t8, bitcast<vec2<i32>>(r1.xy), bitcast<i32>(r1.w)));
179
+ r1.x = f32(bitcast<u32>(r1.y));
180
+ r1.x = (r1.x * 0.0039215688593685627f);
181
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_2[56u].x < r1.x)));
182
+ r1.x = select(1.0f, 0.0f, (bitcast<u32>(r1.x) != 0u));
183
+ let v_33 = r1;
184
+ r1 = vec4<f32>(v_33.x, ((v1.xy * vec2<f32>(58.16400146484375f, 47.130001068115234375f))).xy, v_33.w);
185
+ let v_34 = fma(v1.xy, vec2<f32>(2.0f, -2.0f), vec2<f32>(-1.0f, 1.0f));
186
+ r2 = vec4<f32>(v_34.xy, r2.zw);
187
+ let v_35 = fma(v1.xy, vec2<f32>(2.0f, -2.0f), vec2<f32>(-1.0f, 1.0f));
188
+ r3 = vec4<f32>(v_35.xy, r3.zw);
189
+ r3 = vec4<f32>(r3.xy, vec2<f32>(1.0f));
190
+ r4.x = dot(r3.xyz, cb5_5.tint_symbol_2[21u].xyz);
191
+ r4.y = dot(r3.xyz, cb5_5.tint_symbol_2[22u].xyz);
192
+ r4.z = dot(r3.xyz, cb5_5.tint_symbol_2[23u].xyz);
193
+ let v_36 = fma(r4.xyz, r0.xxx, cb1_1.tint_symbol[15u].xyz);
194
+ r3 = vec4<f32>(v_36.xyz, r3.w);
195
+ r4.x = dot(r3, cb5_5.tint_symbol_2[18u]);
196
+ r4.y = dot(r3, cb5_5.tint_symbol_2[19u]);
197
+ r0.x = dot(r3, cb5_5.tint_symbol_2[20u]);
198
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (r0.x == 0.0f)));
199
+ let v_37 = bitcast<u32>(r1.w);
200
+ r0.x = select(r0.x, 0.00000999999974737875f, (v_37 != 0u));
201
+ let v_38 = (r4.xy / r0.xx);
202
+ r2 = vec4<f32>(r2.xy, v_38.xy);
203
+ let v_39 = ((-(r2.zwzz)).xy + r2.xy);
204
+ r2 = vec4<f32>(v_39.xy, r2.zw);
205
+ let v_40 = (r2.xy * vec2<f32>(40.0f, -22.5f));
206
+ r2 = vec4<f32>(v_40.xy, r2.zw);
207
+ r0.x = dot(r2.xy, r2.xy);
208
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (1.0f < r0.x)));
209
+ r0.x = inverseSqrt(r0.x);
210
+ let v_41 = (r0.xx * r2.xy);
211
+ r2 = vec4<f32>(r2.xy, v_41.xy);
212
+ let v_42 = bitcast<vec2<u32>>(r1.ww);
213
+ let v_43 = r2.zw;
214
+ let v_44 = select(r2.xy, v_43, (v_42 != vec2<u32>()));
215
+ r2 = vec4<f32>(v_44.xy, r2.zw);
216
+ let v_45 = (r2.xy * cb5_5.tint_symbol_2[16u].xx);
217
+ r2 = vec4<f32>(v_45.xy, r2.zw);
218
+ let v_46 = (r2.xy * vec2<f32>(0.01250000018626451492f, 0.02222222276031970978f));
219
+ r2 = vec4<f32>(v_46.xy, r2.zw);
220
+ let v_47 = (r0.yzw * r1.xxx);
221
+ r3 = vec4<f32>(v_47.xyz, r3.w);
222
+ let v_48 = (r2.xy * cb5_5.tint_symbol_2[17u].yy);
223
+ r2 = vec4<f32>(r2.xy, v_48.xy);
224
+ let v_49 = fma(r0.yz, vec2<f32>(8.0f), r1.yz);
225
+ let v_50 = r1;
226
+ r1 = vec4<f32>(v_50.x, v_49.xy, v_50.w);
227
+ r4 = textureSample(t12, s12, r1.yzyy.xy);
228
+ r0.x = (r4.x + -0.5f);
229
+ let v_51 = (r0.xx * r2.zw);
230
+ let v_52 = r1;
231
+ r1 = vec4<f32>(v_52.x, v_51.xy, v_52.w);
232
+ let v_53 = fma(r1.yz, vec2<f32>(0.5f), v1.xy);
233
+ let v_54 = r1;
234
+ r1 = vec4<f32>(v_54.x, v_53.xy, v_54.w);
235
+ let v_55 = cb5_5.tint_symbol_2[17u].x;
236
+ let v_56 = max(v_55, -2147483648.0f);
237
+ r0.x = bitcast<f32>(select(select(i32(v_56), 2147483647i, (v_56 >= 2147483648.0f)), 0i, !((v_55 == v_55))));
238
+ r4 = vec4<f32>(r4.xy, vec2<f32>());
239
+ let v_57 = r3;
240
+ r5 = vec4<f32>(v_57.xyz, r5.w);
241
+ r1.w = r1.x;
242
+ r3.w = bitcast<f32>(v.tint_symbol_3[0i].x);
243
+ loop {
244
+ r5.w = bitcast<f32>(select(0u, 4294967295u, (bitcast<i32>(r3.w) >= bitcast<i32>(r0.x))));
245
+ if ((bitcast<u32>(r5.w) != 0u)) {
246
+ break;
247
+ }
248
+ r5.w = f32(bitcast<i32>(r3.w));
249
+ let v_58 = fma(r2.zw, r5.ww, r1.yz);
250
+ r6 = vec4<f32>(v_58.xy, r6.zw);
251
+ let v_59 = (r6.xy * cb2_2.tint_symbol_1[18u].xy);
252
+ r6 = vec4<f32>(v_59.xy, r6.zw);
253
+ let v_60 = round(r6.xy);
254
+ r6 = vec4<f32>(v_60.xy, r6.zw);
255
+ let v_61 = (r6.xy + vec2<f32>(0.5f));
256
+ r6 = vec4<f32>(v_61.xy, r6.zw);
257
+ let v_62 = (r6.xy / cb2_2.tint_symbol_1[18u].xy);
258
+ r6 = vec4<f32>(r6.xy, v_62.xy);
259
+ let v_63 = r6.xy;
260
+ let v_64 = max(v_63, vec2<f32>(-2147483648.0f));
261
+ let v_65 = bitcast<vec2<f32>>(select(select(vec2<i32>(v_64), vec2<i32>(2147483647i), (v_64 >= vec2<f32>(2147483648.0f))), vec2<i32>(), !((v_63 == v_63))));
262
+ r4 = vec4<f32>(v_65.xy, r4.zw);
263
+ r7 = bitcast<vec4<f32>>(textureLoad(t8, bitcast<vec2<i32>>(r4.xy), bitcast<i32>(r4.w)));
264
+ r4.x = f32(bitcast<u32>(r7.y));
265
+ r4.x = (r4.x * 0.0039215688593685627f);
266
+ r4.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_2[56u].x < r4.x)));
267
+ r4.x = select(1.0f, 0.0f, (bitcast<u32>(r4.x) != 0u));
268
+ r6 = textureSampleLevel(t9, s9, r6.zwzz.xy, 0.0f);
269
+ let v_66 = fma(r6.xyz, r4.xxx, r5.xyz);
270
+ r5 = vec4<f32>(v_66.xyz, r5.w);
271
+ r1.w = (r1.w + r4.x);
272
+ r3.w = bitcast<f32>((bitcast<i32>(r3.w) + 1i));
273
+ }
274
+ r0.x = max(r1.w, 0.10000000149011611938f);
275
+ let v_67 = (r5.xyz / r0.xxx);
276
+ r1 = vec4<f32>(r1.x, v_67.xyz);
277
+ r0.x = dot(r2.xy, r2.xy);
278
+ r0.x = (r0.x * 100000.0f);
279
+ r0.x = min(r0.x, 1.0f);
280
+ r0.x = (r0.x * r1.x);
281
+ let v_68 = ((-(r0.yzwy)).xyz + r1.yzw);
282
+ r1 = vec4<f32>(v_68.xyz, r1.w);
283
+ let v_69 = fma(r0.xxx, r1.xyz, r0.yzw);
284
+ r0 = vec4<f32>(v_69.xyz, r0.w);
285
+ r1 = textureSample(t10, s10, v1.xyxx.xy);
286
+ let v_70 = (r1.xyz * v1.www);
287
+ r1 = vec4<f32>(v_70.xyz, r1.w);
288
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb5_5.tint_symbol_2[75u].z)));
289
+ if ((bitcast<u32>(r0.w) != 0u)) {
290
+ r2 = textureSample(t15, s15, v1.xyxx.xy);
291
+ r0.w = (r2.x * r2.x);
292
+ r0.w = (r0.w * r0.w);
293
+ r0.w = (r0.w * r0.w);
294
+ let v_71 = fma(cb5_5.tint_symbol_2[46u].xyz, r0.www, r0.xyz);
295
+ r0 = vec4<f32>(v_71.xyz, r0.w);
296
+ }
297
+ let v_72 = min(r0.xyz, vec3<f32>(65504.0f));
298
+ r0 = vec4<f32>(v_72.xyz, r0.w);
299
+ let v_73 = v2.x;
300
+ r0.w = clamp(fma(vec4<f32>(v_73, v_73, v_73, v_73), cb5_5.tint_symbol_2[14u].xxxx, cb5_5.tint_symbol_2[14u].yyyy).w, 0.0f, 1.0f);
301
+ r2 = (-(cb5_5.tint_symbol_2[10u]) + cb5_5.tint_symbol_2[12u]);
302
+ r2 = fma(r0.wwww, r2, cb5_5.tint_symbol_2[10u]);
303
+ let v_74 = ((-(cb5_5.tint_symbol_2[11u].zxyz)).xyz + cb5_5.tint_symbol_2[13u].zxy);
304
+ r3 = vec4<f32>(v_74.xyz, r3.w);
305
+ let v_75 = fma(r0.www, r3.xyz, cb5_5.tint_symbol_2[11u].zxy);
306
+ r3 = vec4<f32>(v_75.xyz, r3.w);
307
+ let v_76 = (r2.ww * r3.yz);
308
+ r4 = vec4<f32>(v_76.xy, r4.zw);
309
+ r0.w = (r2.y * r2.z);
310
+ r1.w = fma(r2.x, r3.x, r0.w);
311
+ r1.w = fma(r3.x, r1.w, r4.x);
312
+ r2.z = fma(r2.x, r3.x, r2.y);
313
+ r2.z = fma(r3.x, r2.z, r4.y);
314
+ r1.w = (r1.w / r2.z);
315
+ r2.z = (r3.y / r3.z);
316
+ let v_77 = -(r2.zzzz);
317
+ r1.w = (r1.w + v_77.w);
318
+ r1.w = (1.0f / r1.w);
319
+ let v_78 = (r0.xyz * v1.zzz);
320
+ r0 = vec4<f32>(v_78.xyz, r0.w);
321
+ let v_79 = max(r0.xyz, vec3<f32>());
322
+ r0 = vec4<f32>(v_79.xyz, r0.w);
323
+ let v_80 = fma(r2.xxx, r0.xyz, r0.www);
324
+ r3 = vec4<f32>(v_80.xyz, r3.w);
325
+ let v_81 = fma(r0.xyz, r3.xyz, r4.xxx);
326
+ r3 = vec4<f32>(v_81.xyz, r3.w);
327
+ let v_82 = fma(r2.xxx, r0.xyz, r2.yyy);
328
+ r5 = vec4<f32>(v_82.xyz, r5.w);
329
+ let v_83 = fma(r0.xyz, r5.xyz, r4.yyy);
330
+ r0 = vec4<f32>(v_83.xyz, r0.w);
331
+ let v_84 = (r3.xyz / r0.xyz);
332
+ r0 = vec4<f32>(v_84.xyz, r0.w);
333
+ let v_85 = ((-(r2.zzzz)).xyz + r0.xyz);
334
+ r0 = vec4<f32>(v_85.xyz, r0.w);
335
+ let v_86 = clamp(((r1.wwww * r0.xyzx)).xyz, vec3<f32>(), vec3<f32>(1.0f));
336
+ r0 = vec4<f32>(v_86.xyz, r0.w);
337
+ r2.w = dot(r0.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
338
+ let v_87 = -(r2.wwww);
339
+ let v_88 = (r0.xyz + v_87.xyz);
340
+ r0 = vec4<f32>(v_88.xyz, r0.w);
341
+ let v_89 = fma(cb5_5.tint_symbol_2[67u].xxx, r0.xyz, r2.www);
342
+ r0 = vec4<f32>(v_89.xyz, r0.w);
343
+ r3.x = clamp(((r2.wwww / cb5_5.tint_symbol_2[66u].wwww)).x, 0.0f, 1.0f);
344
+ let v_90 = -(cb5_5.tint_symbol_2[66u].xxyz);
345
+ let v_91 = (cb5_5.tint_symbol_2[65u].xyz + v_90.yzw);
346
+ r3 = vec4<f32>(r3.x, v_91.xyz);
347
+ let v_92 = fma(r3.xxx, r3.yzw, cb5_5.tint_symbol_2[66u].xyz);
348
+ r3 = vec4<f32>(v_92.xyz, r3.w);
349
+ let v_93 = (r0.xyz * r3.xyz);
350
+ r5 = vec4<f32>(v_93.xyz, r5.w);
351
+ r3.w = ((-(cb5_5.tint_symbol_2[65u].wwww)).w + 1.0f);
352
+ let v_94 = -(r3.wwww);
353
+ r2.w = (r2.w + v_94.w);
354
+ r3.w = ((-(r3.wwww)).w + 1.0f);
355
+ r3.w = max(r3.w, 0.00999999977648258209f);
356
+ r2.w = clamp(((r2.wwww / r3.wwww)).w, 0.0f, 1.0f);
357
+ let v_95 = fma((-(r0.xyzx)).xyz, r3.xyz, r0.xyz);
358
+ r0 = vec4<f32>(v_95.xyz, r0.w);
359
+ let v_96 = clamp(fma(r2.wwww, r0.xyzx, r5.xyzx).xyz, vec3<f32>(), vec3<f32>(1.0f));
360
+ r0 = vec4<f32>(v_96.xyz, r0.w);
361
+ r0.x = dot(r0.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
362
+ r0.y = (r0.x * cb5_5.tint_symbol_2[24u].z);
363
+ r0.y = clamp(((r0.yyyy / cb5_5.tint_symbol_2[23u].wwww)).y, 0.0f, 1.0f);
364
+ r0.y = ((-(r0.yyyy)).y + 1.0f);
365
+ let v_97 = -(cb5_5.tint_symbol_2[24u].xxxx);
366
+ r0.z = fma(r0.x, cb5_5.tint_symbol_2[24u].z, v_97.z);
367
+ r2.w = (v_97.w + cb5_5.tint_symbol_2[24u].y);
368
+ r0.z = clamp(((r0.zzzz / r2.wwww)).z, 0.0f, 1.0f);
369
+ r2.w = (r0.z + r0.y);
370
+ r2.w = ((-(r2.wwww)).w + 1.0f);
371
+ let v_98 = (r0.yy * cb5_5.tint_symbol_2[25u].xw);
372
+ r3 = vec4<f32>(v_98.xy, r3.zw);
373
+ r3.x = fma(r0.z, cb5_5.tint_symbol_2[25u].y, r3.x);
374
+ r3.x = fma(r2.w, cb5_5.tint_symbol_2[24u].w, r3.x);
375
+ r0.x = fma(r0.x, cb5_5.tint_symbol_2[24u].z, r3.x);
376
+ let v_99 = fma(v1.xy, vec2<f32>(2.40000009536743164062f, 1.35000002384185791016f), cb5_5.tint_symbol_2[15u].xy);
377
+ r3 = vec4<f32>(r3.xy, v_99.xy);
378
+ let v_100 = fract(r3.zw);
379
+ r3 = vec4<f32>(r3.xy, v_100.xy);
380
+ r5 = textureSample(t7, s7, r3.zwzz.xy);
381
+ r3.y = fma(r2.w, cb5_5.tint_symbol_2[25u].z, r3.y);
382
+ r3.z = (r5.y + -0.5f);
383
+ r0.x = fma(r3.z, r3.y, r0.x);
384
+ r3.y = (r0.z * cb5_5.tint_symbol_2[26u].x);
385
+ r3.y = (r3.y * r3.z);
386
+ r3.y = max(r3.y, 0.0f);
387
+ r0.x = (r0.x + r3.y);
388
+ let v_101 = (r1.xyz * v1.zzz);
389
+ r1 = vec4<f32>(v_101.xyz, r1.w);
390
+ let v_102 = max(r1.xyz, vec3<f32>());
391
+ r1 = vec4<f32>(v_102.xyz, r1.w);
392
+ let v_103 = fma(r2.xxx, r1.xyz, r0.www);
393
+ r3 = vec4<f32>(r3.x, v_103.xyz);
394
+ let v_104 = fma(r1.xyz, r3.yzw, r4.xxx);
395
+ r3 = vec4<f32>(r3.x, v_104.xyz);
396
+ let v_105 = fma(r2.xxx, r1.xyz, r2.yyy);
397
+ r4 = vec4<f32>(v_105.x, r4.y, v_105.yz);
398
+ let v_106 = fma(r1.xyz, r4.xzw, r4.yyy);
399
+ r1 = vec4<f32>(v_106.xyz, r1.w);
400
+ let v_107 = (r3.yzw / r1.xyz);
401
+ r1 = vec4<f32>(v_107.xyz, r1.w);
402
+ let v_108 = ((-(r2.zzzz)).xyz + r1.xyz);
403
+ r1 = vec4<f32>(v_108.xyz, r1.w);
404
+ let v_109 = clamp(((r1.wwww * r1.xyzx)).xyz, vec3<f32>(), vec3<f32>(1.0f));
405
+ r1 = vec4<f32>(v_109.xyz, r1.w);
406
+ r0.w = dot(r1.xyz, vec3<f32>(0.21250000596046447754f, 0.71539998054504394531f, 0.0720999985933303833f));
407
+ r0.w = fma(r0.w, cb5_5.tint_symbol_2[24u].z, r3.x);
408
+ r0.w = ((-(r0.zzzz)).w + r0.w);
409
+ r0.w = max(r0.w, 0.0f);
410
+ r0.x = fma(r0.w, cb5_5.tint_symbol_2[26u].y, r0.x);
411
+ let v_110 = (r0.zzz * cb5_5.tint_symbol_2[29u].xyz);
412
+ r1 = vec4<f32>(v_110.xyz, r1.w);
413
+ let v_111 = fma(r0.yyy, cb5_5.tint_symbol_2[28u].xyz, r1.xyz);
414
+ r0 = vec4<f32>(r0.x, v_111.xyz);
415
+ let v_112 = fma(r2.www, cb5_5.tint_symbol_2[27u].xyz, r0.yzw);
416
+ r0 = vec4<f32>(r0.x, v_112.xyz);
417
+ let v_113 = clamp(((r0.xxxx * r0.yzwy)).xyz, vec3<f32>(), vec3<f32>(1.0f));
418
+ r0 = vec4<f32>(v_113.xyz, r0.w);
419
+ o0.w = dot(r0.xyz, vec3<f32>(0.29899999499320983887f, 0.58700001239776611328f, 0.11400000005960464478f));
420
+ let v_114 = r0;
421
+ o0 = vec4<f32>(v_114.xyz, o0.w);
422
+ }
423
+
424
+ @fragment
425
+ fn main(@location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>) -> @location(0u) vec4<f32> {
426
+ main_inner(v1, v2);
427
+ return o0;
428
+ }
b/8b0b5899ed/shaders/0138abd67681916a.wgsl ADDED
@@ -0,0 +1,56 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ struct cb16_struct {
6
+ tint_symbol : array<vec4<f32>, 16u>,
7
+ }
8
+
9
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb16_struct;
10
+
11
+ struct cb5_struct {
12
+ tint_symbol_1 : array<vec4<f32>, 5u>,
13
+ }
14
+
15
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb5_struct;
16
+
17
+ struct cb3_struct {
18
+ tint_symbol_2 : array<vec4<f32>, 3u>,
19
+ }
20
+
21
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb3_struct;
22
+
23
+ @group(1u) @binding(16u) var s0 : sampler;
24
+
25
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
26
+
27
+ var<private> o0 : vec4<f32>;
28
+
29
+ fn main_inner(v3 : vec4<f32>) {
30
+ r0 = textureSample(t0, s0, v3.xy.xyxx.xy);
31
+ r0.x = (r0.w * cb2_2.tint_symbol[15u].x);
32
+ let v = -(cb5_5.tint_symbol_1[4u].xxxx);
33
+ r0.y = fma(r0.w, cb2_2.tint_symbol[15u].x, v.y);
34
+ r0.z = (v.z + 1.0f);
35
+ r0.z = (r0.z * 0.10000000149011611938f);
36
+ r0.y = (r0.y / r0.z);
37
+ r0.y = fma((-(r0.wwww)).y, cb2_2.tint_symbol[15u].x, r0.y);
38
+ r0.x = fma(cb12_12.tint_symbol_2[2u].y, r0.y, r0.x);
39
+ r0.y = bitcast<f32>(select(0u, 4294967295u, (0.0039215688593685627f >= r0.x)));
40
+ v_1((bitcast<u32>(r0.y) != 0u));
41
+ o0 = vec4<f32>(vec3<f32>(), o0.w);
42
+ o0.w = r0.x;
43
+ }
44
+
45
+ fn v_1(v_2 : bool) {
46
+ if (v_2) {
47
+ discard;
48
+ return;
49
+ }
50
+ }
51
+
52
+ @fragment
53
+ fn main(@location(3u) v3 : vec4<f32>) -> @location(0u) vec4<f32> {
54
+ main_inner(v3);
55
+ return o0;
56
+ }
b/8b0b5899ed/shaders/0139fe33bda035a7.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/0139fe33bda035a7.wgsl ADDED
@@ -0,0 +1,742 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ struct cb16_struct {
48
+ tint_symbol : array<vec4<f32>, 16u>,
49
+ }
50
+
51
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
52
+
53
+ struct cb23_struct {
54
+ tint_symbol_1 : array<vec4<f32>, 23u>,
55
+ }
56
+
57
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
58
+
59
+ struct cb59_struct {
60
+ tint_symbol_2 : array<vec4<f32>, 59u>,
61
+ }
62
+
63
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
64
+
65
+ struct cb8_struct {
66
+ tint_symbol_3 : array<vec4<f32>, 8u>,
67
+ }
68
+
69
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
70
+
71
+ struct cb15_struct {
72
+ tint_symbol_4 : array<vec4<f32>, 15u>,
73
+ }
74
+
75
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
76
+
77
+ @group(1u) @binding(16u) var s0 : sampler;
78
+
79
+ @group(1u) @binding(27u) var s11 : sampler;
80
+
81
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
82
+
83
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
84
+
85
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
86
+
87
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
88
+
89
+ var<private> v4 : vec4<f32>;
90
+
91
+ var<private> v5 : array<f32, 4u>;
92
+
93
+ var<private> o0 : vec4<f32>;
94
+
95
+ var<private> o1 : f32;
96
+
97
+ var<private> o2 : f32;
98
+
99
+ var<private> x0 : array<vec4<f32>, 4u>;
100
+
101
+ var<private> x1 : array<vec4<f32>, 1u>;
102
+
103
+ struct tint_symbol_6 {
104
+ tint_symbol_5 : array<vec4<u32>, 4u>,
105
+ }
106
+
107
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_6;
108
+
109
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v_1 : vec4<f32>) {
110
+ var v_2 : vec4<f32> = v_1;
111
+ v_2.w = (1.0f / v_1.w);
112
+ v4 = v_2;
113
+ x1[0u].x = v5[0u];
114
+ x1[0u].y = v5[1u];
115
+ x1[0u].z = v5[2u];
116
+ x1[0u].w = v5[3u];
117
+ r0 = textureSample(t0, s0, v1.xyz.xyxx.xy);
118
+ r1.x = dot(v2.xyz, v2.xyz);
119
+ r1.x = inverseSqrt(r1.x);
120
+ let v_3 = (r1.xxx * v2.xyz);
121
+ r1 = vec4<f32>(r1.x, v_3.xyz);
122
+ r0.w = (r0.w * v0.w);
123
+ let v_4 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
124
+ r2 = vec4<f32>(v_4.xy, r2.zw);
125
+ let v_5 = (r0.xyz * r0.xyz);
126
+ r0 = vec4<f32>(v_5.xyz, r0.w);
127
+ let v_6 = -(v3.xyzx);
128
+ let v_7 = (v_6.xyz + cb1_1.tint_symbol[15u].xyz);
129
+ r3 = vec4<f32>(v_7.xyz, r3.w);
130
+ r2.z = dot(r3.xyz, cb1_1.tint_symbol[14u].xyz);
131
+ let v_8 = (v3.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
132
+ r3 = vec4<f32>(v_8.xyz, r3.w);
133
+ let v_9 = (r3.yyy * cb6_6.tint_symbol_4[1u].xyz);
134
+ r4 = vec4<f32>(v_9.xyz, r4.w);
135
+ let v_10 = fma(r3.xxx, cb6_6.tint_symbol_4[0u].xyz, r4.xyz);
136
+ r4 = vec4<f32>(v_10.xyz, r4.w);
137
+ let v_11 = fma(r3.zzz, cb6_6.tint_symbol_4[2u].xyz, r4.xyz);
138
+ r4 = vec4<f32>(v_11.xyz, r4.w);
139
+ let v_12 = fma(r4.xyz, cb6_6.tint_symbol_4[4u].xyz, cb6_6.tint_symbol_4[8u].xyz);
140
+ r5 = vec4<f32>(v_12.xyz, r5.w);
141
+ let v_13 = &(x0[0u]);
142
+ let v_14 = r5;
143
+ *(v_13) = vec4<f32>(v_14.xyz, (*(v_13)).w);
144
+ let v_15 = fma(r4.xyz, cb6_6.tint_symbol_4[5u].xyz, cb6_6.tint_symbol_4[9u].xyz);
145
+ r6 = vec4<f32>(v_15.xyz, r6.w);
146
+ let v_16 = &(x0[1u]);
147
+ let v_17 = r6;
148
+ *(v_16) = vec4<f32>(v_17.xyz, (*(v_16)).w);
149
+ let v_18 = fma(r4.xyz, cb6_6.tint_symbol_4[6u].xyz, cb6_6.tint_symbol_4[10u].xyz);
150
+ r7 = vec4<f32>(v_18.xyz, r7.w);
151
+ let v_19 = &(x0[2u]);
152
+ let v_20 = r7;
153
+ *(v_19) = vec4<f32>(v_20.xyz, (*(v_19)).w);
154
+ let v_21 = fma(r4.xyz, cb6_6.tint_symbol_4[7u].xyz, cb6_6.tint_symbol_4[11u].xyz);
155
+ r4 = vec4<f32>(v_21.xyz, r4.w);
156
+ let v_22 = &(x0[3u]);
157
+ let v_23 = r4;
158
+ *(v_22) = vec4<f32>(v_23.xyz, (*(v_22)).w);
159
+ let v_24 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
160
+ let v_25 = r8;
161
+ r8 = vec4<f32>(v_25.x, v_24.x, v_25.z, v_24.y);
162
+ r2.w = fma((-(cb6_6.tint_symbol_4[14u].zzzz)).w, 1.5f, 1.0f);
163
+ r2.w = (r2.w * 0.5f);
164
+ let v_26 = abs(r7.yyyy);
165
+ r3.w = max(v_26.w, abs(r7.xxxx).w);
166
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (r3.w < r2.w)));
167
+ let v_27 = (bitcast<u32>(r3.w) != 0u);
168
+ let v_28 = bitcast<f32>(v.tint_symbol_5[0i].x);
169
+ r3.w = select(bitcast<f32>(v.tint_symbol_5[1i].x), v_28, v_27);
170
+ let v_29 = abs(r6.yyyy);
171
+ r4.z = max(v_29.z, abs(r6.xxxx).z);
172
+ r4.z = bitcast<f32>(select(0u, 4294967295u, (r4.z < r2.w)));
173
+ let v_30 = bitcast<u32>(r4.z);
174
+ r3.w = select(r3.w, bitcast<f32>(v.tint_symbol_5[2i].x), (v_30 != 0u));
175
+ let v_31 = abs(r5.yyyy);
176
+ r4.z = max(v_31.z, abs(r5.xxxx).z);
177
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (r4.z < r2.w)));
178
+ let v_32 = bitcast<u32>(r2.w);
179
+ r2.w = select(r3.w, 0.0f, (v_32 != 0u));
180
+ let v_33 = x0[bitcast<i32>(r2.w)];
181
+ r5 = vec4<f32>(v_33.xyz, r5.w);
182
+ r2.w = f32(bitcast<i32>(r2.w));
183
+ r3.w = (r2.w + 0.5f);
184
+ r3.w = (r3.w * 0.25f);
185
+ r6 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r2.wwww)));
186
+ r6 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r6) & vec4<u32>(1065353216u)));
187
+ r2.w = dot(r6, cb6_6.tint_symbol_4[12u]);
188
+ r4.z = dot(r6, cb6_6.tint_symbol_4[13u]);
189
+ r6.x = (r5.x + 0.5f);
190
+ r6.y = fma(r5.y, 0.25f, r3.w);
191
+ r3.w = bitcast<f32>(select(0u, 4294967295u, !((r2.w == 0.0f))));
192
+ r2.w = ((-(r2.wwww)).w + r5.z);
193
+ let v_34 = dpdx(r6.xyy);
194
+ r7 = vec4<f32>(v_34.xy, r7.z, v_34.z);
195
+ r7.z = dpdx(r2.w);
196
+ let v_35 = dpdy(r6.yxy);
197
+ r9 = vec4<f32>(v_35.xyz, r9.w);
198
+ r9.w = dpdy(r2.w);
199
+ let v_36 = (r7.yw * r9.yw);
200
+ r5 = vec4<f32>(v_36.xy, r5.zw);
201
+ let v_37 = -(r5.xyxx);
202
+ let v_38 = fma(r7.xz, r9.xz, v_37.xy);
203
+ r10 = vec4<f32>(v_38.xy, r10.zw);
204
+ r4.w = (1.0f / r10.x);
205
+ r5.x = (r7.z * r9.y);
206
+ let v_39 = -(r5.xxxx);
207
+ r10.z = fma(r7.x, r9.w, v_39.z);
208
+ let v_40 = (r4.ww * r10.yz);
209
+ r5 = vec4<f32>(v_40.xy, r5.zw);
210
+ let v_41 = max(r5.xy, vec2<f32>());
211
+ r5 = vec4<f32>(v_41.xy, r5.zw);
212
+ let v_42 = min(r5.xy, vec2<f32>(0.5f));
213
+ r5 = vec4<f32>(v_42.xy, r5.zw);
214
+ r2.w = fma((-(r4.zzzz)).w, r5.x, r2.w);
215
+ r2.w = fma((-(r4.zzzz)).w, r5.y, r2.w);
216
+ let v_43 = bitcast<u32>(r3.w);
217
+ let v_44 = r2.w;
218
+ r8.z = select(r5.z, v_44, (v_43 != 0u));
219
+ r6.z = 0.0f;
220
+ let v_45 = (r6.xyz + r8.ywz);
221
+ r5 = vec4<f32>(v_45.xyz, r5.w);
222
+ let v_46 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
223
+ r8 = vec4<f32>(v_46.xy, r8.zw);
224
+ let v_47 = (r6.xyz + r8.xyz);
225
+ r7 = vec4<f32>(v_47.xyz, r7.w);
226
+ let v_48 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
227
+ r8 = vec4<f32>(v_48.xy, r8.zw);
228
+ let v_49 = (r6.xyz + r8.xyz);
229
+ r9 = vec4<f32>(v_49.xyz, r9.w);
230
+ let v_50 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
231
+ r8 = vec4<f32>(v_50.xy, r8.zw);
232
+ let v_51 = (r6.xyz + r8.xyz);
233
+ r10 = vec4<f32>(v_51.xyz, r10.w);
234
+ let v_52 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
235
+ r8 = vec4<f32>(v_52.xy, r8.zw);
236
+ let v_53 = (r6.xyz + r8.xyz);
237
+ r11 = vec4<f32>(v_53.xyz, r11.w);
238
+ let v_54 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
239
+ r8 = vec4<f32>(v_54.xy, r8.zw);
240
+ let v_55 = (r6.xyz + r8.xyz);
241
+ r12 = vec4<f32>(v_55.xyz, r12.w);
242
+ let v_56 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
243
+ r8 = vec4<f32>(v_56.xy, r8.zw);
244
+ let v_57 = (r6.xyz + r8.xyz);
245
+ r13 = vec4<f32>(v_57.xyz, r13.w);
246
+ let v_58 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
247
+ r8 = vec4<f32>(v_58.xy, r8.zw);
248
+ let v_59 = (r6.xyz + r8.xyz);
249
+ r14 = vec4<f32>(v_59.xyz, r14.w);
250
+ let v_60 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
251
+ r8 = vec4<f32>(v_60.xy, r8.zw);
252
+ let v_61 = (r6.xyz + r8.xyz);
253
+ r15 = vec4<f32>(v_61.xyz, r15.w);
254
+ let v_62 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
255
+ r8 = vec4<f32>(v_62.xy, r8.zw);
256
+ let v_63 = (r6.xyz + r8.xyz);
257
+ r16 = vec4<f32>(v_63.xyz, r16.w);
258
+ let v_64 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
259
+ r8 = vec4<f32>(v_64.xy, r8.zw);
260
+ let v_65 = (r6.xyz + r8.xyz);
261
+ r17 = vec4<f32>(v_65.xyz, r17.w);
262
+ let v_66 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
263
+ r8 = vec4<f32>(v_66.xy, r8.zw);
264
+ let v_67 = (r6.xyz + r8.xyz);
265
+ r18 = vec4<f32>(v_67.xyz, r18.w);
266
+ let v_68 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
267
+ r8 = vec4<f32>(v_68.xy, r8.zw);
268
+ let v_69 = (r6.xyz + r8.xyz);
269
+ r19 = vec4<f32>(v_69.xyz, r19.w);
270
+ let v_70 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
271
+ r8 = vec4<f32>(v_70.xy, r8.zw);
272
+ let v_71 = (r6.xyz + r8.xyz);
273
+ r20 = vec4<f32>(v_71.xyz, r20.w);
274
+ let v_72 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
275
+ r8 = vec4<f32>(v_72.xy, r8.zw);
276
+ let v_73 = (r6.xyz + r8.xyz);
277
+ r21 = vec4<f32>(v_73.xyz, r21.w);
278
+ let v_74 = (cb6_6.tint_symbol_4[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
279
+ r8 = vec4<f32>(v_74.xy, r8.zw);
280
+ let v_75 = (r6.xyz + r8.xyz);
281
+ r6 = vec4<f32>(v_75.xyz, r6.w);
282
+ let v_76 = r5.xyxx;
283
+ r5.x = textureSampleCompareLevel(t15, s15, v_76.xy, r5.z);
284
+ let v_77 = r7.xyxx;
285
+ r5.y = textureSampleCompareLevel(t15, s15, v_77.xy, r7.z);
286
+ let v_78 = r9.xyxx;
287
+ r5.z = textureSampleCompareLevel(t15, s15, v_78.xy, r9.z);
288
+ let v_79 = r10.xyxx;
289
+ r5.w = textureSampleCompareLevel(t15, s15, v_79.xy, r10.z);
290
+ let v_80 = r11.xyxx;
291
+ r7.x = textureSampleCompareLevel(t15, s15, v_80.xy, r11.z);
292
+ let v_81 = r12.xyxx;
293
+ r7.y = textureSampleCompareLevel(t15, s15, v_81.xy, r12.z);
294
+ let v_82 = r13.xyxx;
295
+ r7.z = textureSampleCompareLevel(t15, s15, v_82.xy, r13.z);
296
+ let v_83 = r14.xyxx;
297
+ r7.w = textureSampleCompareLevel(t15, s15, v_83.xy, r14.z);
298
+ let v_84 = r15.xyxx;
299
+ r8.x = textureSampleCompareLevel(t15, s15, v_84.xy, r15.z);
300
+ let v_85 = r16.xyxx;
301
+ r8.y = textureSampleCompareLevel(t15, s15, v_85.xy, r16.z);
302
+ let v_86 = r17.xyxx;
303
+ r8.z = textureSampleCompareLevel(t15, s15, v_86.xy, r17.z);
304
+ let v_87 = r18.xyxx;
305
+ r8.w = textureSampleCompareLevel(t15, s15, v_87.xy, r18.z);
306
+ let v_88 = r19.xyxx;
307
+ r9.x = textureSampleCompareLevel(t15, s15, v_88.xy, r19.z);
308
+ let v_89 = r20.xyxx;
309
+ r9.y = textureSampleCompareLevel(t15, s15, v_89.xy, r20.z);
310
+ let v_90 = r21.xyxx;
311
+ r9.z = textureSampleCompareLevel(t15, s15, v_90.xy, r21.z);
312
+ let v_91 = r6.xyxx;
313
+ r9.w = textureSampleCompareLevel(t15, s15, v_91.xy, r6.z);
314
+ r5 = (r5 + r7);
315
+ r5 = (r8 + r5);
316
+ r5 = (r9 + r5);
317
+ r2.w = dot(r5, vec4<f32>(1.0f));
318
+ r2.z = clamp(fma(r2.zzzz, cb6_6.tint_symbol_4[0u].wwww, cb6_6.tint_symbol_4[1u].wwww).z, 0.0f, 1.0f);
319
+ let v_92 = abs(r4.yyyy);
320
+ r3.w = max(v_92.w, abs(r4.xxxx).w);
321
+ r3.w = clamp(fma(r3.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
322
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
323
+ r2.z = (r3.w * r2.z);
324
+ r2.z = fma(r2.w, 0.0625f, r2.z);
325
+ let v_93 = (r2.xyz * r2.xyz);
326
+ r2 = vec4<f32>(v_93.xyz, r2.w);
327
+ r2.z = min(r2.z, 1.0f);
328
+ r2.w = clamp(fma(v3.zzzz, cb6_6.tint_symbol_4[3u].xxxx, cb6_6.tint_symbol_4[3u].yyyy).w, 0.0f, 1.0f);
329
+ r2.w = sqrt(r2.w);
330
+ r2.w = (r2.w * cb6_6.tint_symbol_4[3u].z);
331
+ let v_94 = -(r2.zzzz);
332
+ r2.z = fma(r2.w, v_94.z, r2.z);
333
+ let v_95 = -(cb3_3.tint_symbol_2[0u].xyzx);
334
+ let v_96 = dot(r1.yzw, v_95.xyz);
335
+ r2.w = clamp(vec4<f32>(v_96, v_96, v_96, v_96).w, 0.0f, 1.0f);
336
+ let v_97 = (r0.xyz * r2.www);
337
+ r4 = vec4<f32>(v_97.xyz, r4.w);
338
+ let v_98 = (r4.xyz * cb3_3.tint_symbol_2[1u].xyz);
339
+ r4 = vec4<f32>(v_98.xyz, r4.w);
340
+ r2.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
341
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
342
+ let v_99 = (v_6.xyz + cb3_3.tint_symbol_2[3u].xyz);
343
+ r5 = vec4<f32>(v_99.xyz, r5.w);
344
+ let v_100 = (v3.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
345
+ r6 = vec4<f32>(v_100.xyz, r6.w);
346
+ r4.w = dot(r6.xyz, cb3_3.tint_symbol_2[11u].xyz);
347
+ r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
348
+ r4.w = (r4.w * cb3_3.tint_symbol_2[19u].w);
349
+ let v_101 = fma(cb3_3.tint_symbol_2[11u].xyz, r4.www, cb3_3.tint_symbol_2[3u].xyz);
350
+ r6 = vec4<f32>(v_101.xyz, r6.w);
351
+ let v_102 = (r6.xyz + v_6.xyz);
352
+ r6 = vec4<f32>(v_102.xyz, r6.w);
353
+ let v_103 = bitcast<vec3<u32>>(r3.www);
354
+ let v_104 = r5.xyz;
355
+ let v_105 = select(r6.xyz, v_104, (v_103 != vec3<u32>()));
356
+ r5 = vec4<f32>(v_105.xyz, r5.w);
357
+ r3.w = dot(r5.xyz, r5.xyz);
358
+ let v_106 = (r5.xyz + vec3<f32>(0.00000099999999747524f));
359
+ r5 = vec4<f32>(v_106.xyz, r5.w);
360
+ r4.w = dot(r5.xyz, r5.xyz);
361
+ r4.w = inverseSqrt(r4.w);
362
+ let v_107 = (r4.www * r5.xyz);
363
+ r5 = vec4<f32>(v_107.xyz, r5.w);
364
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
365
+ r4.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
366
+ r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[11u].w);
367
+ r3.w = (r3.w / r4.w);
368
+ let v_108 = -(cb3_3.tint_symbol_2[11u].xyzx);
369
+ r4.w = dot(r5.xyz, v_108.xyz);
370
+ r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
371
+ let v_109 = dot(r5.xyz, r1.yzw);
372
+ r5.x = clamp(vec4<f32>(v_109, v_109, v_109, v_109).x, 0.0f, 1.0f);
373
+ r4.w = (r4.w * r5.x);
374
+ r3.w = (r3.w * r4.w);
375
+ let v_110 = (r3.www * cb3_3.tint_symbol_2[19u].xyz);
376
+ r5 = vec4<f32>(v_110.xyz, r5.w);
377
+ let v_111 = (r0.xyz * r5.xyz);
378
+ r5 = vec4<f32>(v_111.xyz, r5.w);
379
+ let v_112 = bitcast<vec3<u32>>(r2.www);
380
+ let v_113 = select(r5.xyz, vec3<f32>(), (v_112 != vec3<u32>()));
381
+ r5 = vec4<f32>(v_113.xyz, r5.w);
382
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
383
+ if ((bitcast<u32>(r3.w) != 0u)) {
384
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
385
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
386
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
387
+ let v_114 = (v_6.xyz + cb3_3.tint_symbol_2[4u].xyz);
388
+ r6 = vec4<f32>(v_114.xyz, r6.w);
389
+ let v_115 = (v3.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
390
+ r7 = vec4<f32>(v_115.xyz, r7.w);
391
+ r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[12u].xyz);
392
+ r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
393
+ r4.w = (r4.w * cb3_3.tint_symbol_2[20u].w);
394
+ let v_116 = fma(cb3_3.tint_symbol_2[12u].xyz, r4.www, cb3_3.tint_symbol_2[4u].xyz);
395
+ r7 = vec4<f32>(v_116.xyz, r7.w);
396
+ let v_117 = (r7.xyz + v_6.xyz);
397
+ r7 = vec4<f32>(v_117.xyz, r7.w);
398
+ let v_118 = bitcast<vec3<u32>>(r3.www);
399
+ let v_119 = r6.xyz;
400
+ let v_120 = select(r7.xyz, v_119, (v_118 != vec3<u32>()));
401
+ r6 = vec4<f32>(v_120.xyz, r6.w);
402
+ r3.w = dot(r6.xyz, r6.xyz);
403
+ let v_121 = (r6.xyz + vec3<f32>(0.00000099999999747524f));
404
+ r6 = vec4<f32>(v_121.xyz, r6.w);
405
+ r4.w = dot(r6.xyz, r6.xyz);
406
+ r4.w = inverseSqrt(r4.w);
407
+ let v_122 = (r4.www * r6.xyz);
408
+ r6 = vec4<f32>(v_122.xyz, r6.w);
409
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
410
+ r4.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
411
+ r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[12u].w);
412
+ r3.w = (r3.w / r4.w);
413
+ let v_123 = -(cb3_3.tint_symbol_2[12u].xyzx);
414
+ r4.w = dot(r6.xyz, v_123.xyz);
415
+ r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
416
+ let v_124 = dot(r6.xyz, r1.yzw);
417
+ r5.w = clamp(vec4<f32>(v_124, v_124, v_124, v_124).w, 0.0f, 1.0f);
418
+ r4.w = (r4.w * r5.w);
419
+ r3.w = (r3.w * r4.w);
420
+ let v_125 = (r3.www * cb3_3.tint_symbol_2[20u].xyz);
421
+ r6 = vec4<f32>(v_125.xyz, r6.w);
422
+ let v_126 = fma(r6.xyz, r0.xyz, r5.xyz);
423
+ r6 = vec4<f32>(v_126.xyz, r6.w);
424
+ let v_127 = bitcast<vec3<u32>>(r2.www);
425
+ let v_128 = r5.xyz;
426
+ let v_129 = select(r6.xyz, v_128, (v_127 != vec3<u32>()));
427
+ r5 = vec4<f32>(v_129.xyz, r5.w);
428
+ } else {
429
+ r2.w = bitcast<f32>(v.tint_symbol_5[3i].x);
430
+ }
431
+ if ((bitcast<u32>(r2.w) != 0u)) {
432
+ r2.w = bitcast<f32>(v.tint_symbol_5[3i].x);
433
+ } else {
434
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
435
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
436
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
437
+ let v_130 = (v_6.xyz + cb3_3.tint_symbol_2[5u].xyz);
438
+ r6 = vec4<f32>(v_130.xyz, r6.w);
439
+ let v_131 = (v3.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
440
+ r7 = vec4<f32>(v_131.xyz, r7.w);
441
+ r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[13u].xyz);
442
+ r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
443
+ r4.w = (r4.w * cb3_3.tint_symbol_2[21u].w);
444
+ let v_132 = fma(cb3_3.tint_symbol_2[13u].xyz, r4.www, cb3_3.tint_symbol_2[5u].xyz);
445
+ r7 = vec4<f32>(v_132.xyz, r7.w);
446
+ let v_133 = (r7.xyz + v_6.xyz);
447
+ r7 = vec4<f32>(v_133.xyz, r7.w);
448
+ let v_134 = bitcast<vec3<u32>>(r3.www);
449
+ let v_135 = r6.xyz;
450
+ let v_136 = select(r7.xyz, v_135, (v_134 != vec3<u32>()));
451
+ r6 = vec4<f32>(v_136.xyz, r6.w);
452
+ r3.w = dot(r6.xyz, r6.xyz);
453
+ let v_137 = (r6.xyz + vec3<f32>(0.00000099999999747524f));
454
+ r6 = vec4<f32>(v_137.xyz, r6.w);
455
+ r4.w = dot(r6.xyz, r6.xyz);
456
+ r4.w = inverseSqrt(r4.w);
457
+ let v_138 = (r4.www * r6.xyz);
458
+ r6 = vec4<f32>(v_138.xyz, r6.w);
459
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
460
+ r4.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
461
+ r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[13u].w);
462
+ r3.w = (r3.w / r4.w);
463
+ let v_139 = -(cb3_3.tint_symbol_2[13u].xyzx);
464
+ r4.w = dot(r6.xyz, v_139.xyz);
465
+ r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
466
+ let v_140 = dot(r6.xyz, r1.yzw);
467
+ r5.w = clamp(vec4<f32>(v_140, v_140, v_140, v_140).w, 0.0f, 1.0f);
468
+ r4.w = (r4.w * r5.w);
469
+ r3.w = (r3.w * r4.w);
470
+ let v_141 = (r3.www * cb3_3.tint_symbol_2[21u].xyz);
471
+ r6 = vec4<f32>(v_141.xyz, r6.w);
472
+ let v_142 = fma(r6.xyz, r0.xyz, r5.xyz);
473
+ r6 = vec4<f32>(v_142.xyz, r6.w);
474
+ let v_143 = bitcast<vec3<u32>>(r2.www);
475
+ let v_144 = r5.xyz;
476
+ let v_145 = select(r6.xyz, v_144, (v_143 != vec3<u32>()));
477
+ r5 = vec4<f32>(v_145.xyz, r5.w);
478
+ }
479
+ if ((bitcast<u32>(r2.w) != 0u)) {
480
+ } else {
481
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
482
+ r2.w = bitcast<f32>((bitcast<u32>(r2.w) | bitcast<u32>(r3.w)));
483
+ r3.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
484
+ let v_146 = (v_6.xyz + cb3_3.tint_symbol_2[6u].xyz);
485
+ r6 = vec4<f32>(v_146.xyz, r6.w);
486
+ let v_147 = (v3.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
487
+ r7 = vec4<f32>(v_147.xyz, r7.w);
488
+ r4.w = dot(r7.xyz, cb3_3.tint_symbol_2[14u].xyz);
489
+ r4.w = clamp(((r4.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
490
+ r4.w = (r4.w * cb3_3.tint_symbol_2[22u].w);
491
+ let v_148 = fma(cb3_3.tint_symbol_2[14u].xyz, r4.www, cb3_3.tint_symbol_2[6u].xyz);
492
+ r7 = vec4<f32>(v_148.xyz, r7.w);
493
+ let v_149 = (r7.xyz + v_6.xyz);
494
+ r7 = vec4<f32>(v_149.xyz, r7.w);
495
+ let v_150 = bitcast<vec3<u32>>(r3.www);
496
+ let v_151 = r6.xyz;
497
+ let v_152 = select(r7.xyz, v_151, (v_150 != vec3<u32>()));
498
+ r6 = vec4<f32>(v_152.xyz, r6.w);
499
+ r3.w = dot(r6.xyz, r6.xyz);
500
+ let v_153 = (r6.xyz + vec3<f32>(0.00000099999999747524f));
501
+ r6 = vec4<f32>(v_153.xyz, r6.w);
502
+ r4.w = dot(r6.xyz, r6.xyz);
503
+ r4.w = inverseSqrt(r4.w);
504
+ let v_154 = (r4.www * r6.xyz);
505
+ r6 = vec4<f32>(v_154.xyz, r6.w);
506
+ r3.w = clamp(fma(-(r3.wwww), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
507
+ r4.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
508
+ r4.w = fma(r4.w, r3.w, cb3_3.tint_symbol_2[14u].w);
509
+ r3.w = (r3.w / r4.w);
510
+ let v_155 = -(cb3_3.tint_symbol_2[14u].xyzx);
511
+ r4.w = dot(r6.xyz, v_155.xyz);
512
+ r4.w = clamp(fma(r4.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
513
+ let v_156 = dot(r6.xyz, r1.yzw);
514
+ r5.w = clamp(vec4<f32>(v_156, v_156, v_156, v_156).w, 0.0f, 1.0f);
515
+ r4.w = (r4.w * r5.w);
516
+ r3.w = (r3.w * r4.w);
517
+ let v_157 = (r3.www * cb3_3.tint_symbol_2[22u].xyz);
518
+ r6 = vec4<f32>(v_157.xyz, r6.w);
519
+ let v_158 = fma(r6.xyz, r0.xyz, r5.xyz);
520
+ r6 = vec4<f32>(v_158.xyz, r6.w);
521
+ let v_159 = bitcast<vec3<u32>>(r2.www);
522
+ let v_160 = r5.xyz;
523
+ let v_161 = select(r6.xyz, v_160, (v_159 != vec3<u32>()));
524
+ r5 = vec4<f32>(v_161.xyz, r5.w);
525
+ }
526
+ let v_162 = fma(r4.xyz, r2.zzz, r5.xyz);
527
+ r4 = vec4<f32>(v_162.xyz, r4.w);
528
+ r1.x = fma(v2.z, r1.x, cb3_3.tint_symbol_2[43u].w);
529
+ r1.x = (r1.x * cb3_3.tint_symbol_2[44u].w);
530
+ r1.x = max(r1.x, 0.0f);
531
+ let v_163 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.xxx, cb3_3.tint_symbol_2[48u].xyz);
532
+ r5 = vec4<f32>(v_163.xyz, r5.w);
533
+ r2.z = ((-(cb2_2.tint_symbol_1[16u].zzzz)).z + 1.0f);
534
+ let v_164 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.xxx, cb3_3.tint_symbol_2[46u].xyz);
535
+ r6 = vec4<f32>(v_164.xyz, r6.w);
536
+ let v_165 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz);
537
+ r6 = vec4<f32>(v_165.xyz, r6.w);
538
+ let v_166 = fma(r5.xyz, r2.zzz, r6.xyz);
539
+ r5 = vec4<f32>(v_166.xyz, r5.w);
540
+ let v_167 = (r2.yyy * r5.xyz);
541
+ r2 = vec4<f32>(r2.x, v_167.xyz);
542
+ let v_168 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.xxx, cb3_3.tint_symbol_2[44u].xyz);
543
+ r5 = vec4<f32>(v_168.xyz, r5.w);
544
+ r6.x = cb3_3.tint_symbol_2[46u].w;
545
+ r6.y = cb3_3.tint_symbol_2[47u].w;
546
+ r6.z = cb3_3.tint_symbol_2[48u].w;
547
+ let v_169 = dot(r6.xyz, r1.yzw);
548
+ r1.x = clamp(vec4<f32>(v_169, v_169, v_169, v_169).x, 0.0f, 1.0f);
549
+ let v_170 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.xxx, r5.xyz);
550
+ r1 = vec4<f32>(v_170.xyz, r1.w);
551
+ let v_171 = fma(r1.xyz, r2.xxx, r2.yzw);
552
+ r1 = vec4<f32>(v_171.xyz, r1.w);
553
+ let v_172 = fma(r1.xyz, r0.xyz, r4.xyz);
554
+ r0 = vec4<f32>(v_172.xyz, r0.w);
555
+ r0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
556
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
557
+ r1.x = dot(r3.xyz, r3.xyz);
558
+ r1.y = sqrt(r1.x);
559
+ let v_173 = -(cb3_3.tint_symbol_2[50u].xxxx);
560
+ r1.z = (r1.y + v_173.z);
561
+ r1.z = max(r1.z, 0.0f);
562
+ r1.y = (r1.z / r1.y);
563
+ r1.y = (r1.y * r3.z);
564
+ r1.w = (r1.y * cb3_3.tint_symbol_2[52u].z);
565
+ r1.y = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.yyyy).y)));
566
+ r2.x = (r1.w * -1.44269502162933349609f);
567
+ r2.x = exp2(r2.x);
568
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
569
+ r1.w = (r2.x / r1.w);
570
+ let v_174 = bitcast<u32>(r1.y);
571
+ r1.y = select(1.0f, r1.w, (v_174 != 0u));
572
+ r1.w = (r1.z * cb3_3.tint_symbol_2[51u].w);
573
+ r1.y = (r1.y * r1.w);
574
+ r1.y = min(r1.y, 1.0f);
575
+ r1.y = (r1.y * 1.44269502162933349609f);
576
+ r1.y = exp2(r1.y);
577
+ r1.y = min(r1.y, 1.0f);
578
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
579
+ r1.w = (r1.y * cb3_3.tint_symbol_2[52u].y);
580
+ r1.x = inverseSqrt(r1.x);
581
+ let v_175 = (r1.xxx * r3.xyz);
582
+ r2 = vec4<f32>(v_175.xyz, r2.w);
583
+ let v_176 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
584
+ r1.x = clamp(vec4<f32>(v_176, v_176, v_176, v_176).x, 0.0f, 1.0f);
585
+ r1.x = log2(r1.x);
586
+ r1.x = (r1.x * cb3_3.tint_symbol_2[54u].w);
587
+ r1.x = exp2(r1.x);
588
+ let v_177 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
589
+ r2.x = clamp(vec4<f32>(v_177, v_177, v_177, v_177).x, 0.0f, 1.0f);
590
+ r2.x = log2(r2.x);
591
+ r2.x = (r2.x * cb3_3.tint_symbol_2[53u].w);
592
+ r2.x = exp2(r2.x);
593
+ r1.y = fma((-(r1.yyyy)).y, cb3_3.tint_symbol_2[52u].y, 1.0f);
594
+ r1.y = (r1.y * cb3_3.tint_symbol_2[51u].y);
595
+ let v_178 = -(cb3_3.tint_symbol_2[52u].xxxx);
596
+ r2.y = (r1.z + v_178.y);
597
+ r2.y = max(r2.y, 0.0f);
598
+ r2.y = (r2.y * cb3_3.tint_symbol_2[51u].x);
599
+ r2.y = (r2.y * 1.44269502162933349609f);
600
+ r2.y = exp2(r2.y);
601
+ r2.y = ((-(r2.yyyy)).y + 1.0f);
602
+ r1.w = clamp(fma(r1.yyyy, r2.yyyy, r1.wwww).w, 0.0f, 1.0f);
603
+ let v_179 = -(cb3_3.tint_symbol_2[51u].zzzz);
604
+ r1.z = (r1.z * v_179.z);
605
+ r1.z = (r1.z * 1.44269502162933349609f);
606
+ r1.z = exp2(r1.z);
607
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
608
+ let v_180 = ((-(cb3_3.tint_symbol_2[56u].xxyz)).yzw + cb3_3.tint_symbol_2[58u].xyz);
609
+ r2 = vec4<f32>(r2.x, v_180.xyz);
610
+ let v_181 = fma(r1.xxx, r2.yzw, cb3_3.tint_symbol_2[56u].xyz);
611
+ r2 = vec4<f32>(r2.x, v_181.xyz);
612
+ let v_182 = ((-(r2.yzwy)).xyz + cb3_3.tint_symbol_2[55u].xyz);
613
+ r4 = vec4<f32>(v_182.xyz, r4.w);
614
+ let v_183 = fma(r2.xxx, r4.xyz, r2.yzw);
615
+ r2 = vec4<f32>(v_183.xyz, r2.w);
616
+ let v_184 = -(cb3_3.tint_symbol_2[57u].xyzx);
617
+ let v_185 = (r2.xyz + v_184.xyz);
618
+ r2 = vec4<f32>(v_185.xyz, r2.w);
619
+ let v_186 = fma(r1.zzz, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
620
+ r2 = vec4<f32>(v_186.xyz, r2.w);
621
+ r4.x = cb3_3.tint_symbol_2[55u].w;
622
+ r4.y = cb3_3.tint_symbol_2[56u].w;
623
+ r4.z = cb3_3.tint_symbol_2[57u].w;
624
+ let v_187 = ((-(r2.xyzx)).xyz + r4.xyz);
625
+ r4 = vec4<f32>(v_187.xyz, r4.w);
626
+ let v_188 = fma(r1.yyy, r4.xyz, r2.xyz);
627
+ r1 = vec4<f32>(v_188.xyz, r1.w);
628
+ r2.x = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
629
+ if ((bitcast<u32>(r2.x) != 0u)) {
630
+ let v_189 = (v4.xy * cb2_2.tint_symbol_1[18u].zw);
631
+ r2 = vec4<f32>(v_189.xy, r2.zw);
632
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
633
+ r2.x = (r2.x + -1.0f);
634
+ r2.x = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r2.xxxx, vec4<f32>(1.0f)).x, 0.0f, 1.0f);
635
+ } else {
636
+ r2.x = 1.0f;
637
+ }
638
+ let v_190 = -(r0.xyzx);
639
+ let v_191 = fma(r1.xyz, r2.xxx, v_190.xyz);
640
+ r1 = vec4<f32>(v_191.xyz, r1.w);
641
+ let v_192 = fma(r1.www, r1.xyz, r0.xyz);
642
+ r1 = vec4<f32>(v_192.xyz, r1.w);
643
+ } else {
644
+ r1.w = dot(r3.xyz, r3.xyz);
645
+ r2.x = sqrt(r1.w);
646
+ let v_193 = -(cb3_3.tint_symbol_2[50u].xxxx);
647
+ r2.y = (r2.x + v_193.y);
648
+ r2.y = max(r2.y, 0.0f);
649
+ r2.x = (r2.y / r2.x);
650
+ r2.x = (r2.x * r3.z);
651
+ r2.z = (r2.x * cb3_3.tint_symbol_2[52u].z);
652
+ r2.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r2.xxxx).x)));
653
+ r2.w = (r2.z * -1.44269502162933349609f);
654
+ r2.w = exp2(r2.w);
655
+ r2.w = ((-(r2.wwww)).w + 1.0f);
656
+ r2.z = (r2.w / r2.z);
657
+ let v_194 = bitcast<u32>(r2.x);
658
+ r2.x = select(1.0f, r2.z, (v_194 != 0u));
659
+ r2.z = (r2.y * cb3_3.tint_symbol_2[51u].w);
660
+ r2.x = (r2.x * r2.z);
661
+ r2.x = min(r2.x, 1.0f);
662
+ r2.x = (r2.x * 1.44269502162933349609f);
663
+ r2.x = exp2(r2.x);
664
+ r2.x = min(r2.x, 1.0f);
665
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
666
+ r2.z = (r2.x * cb3_3.tint_symbol_2[52u].y);
667
+ r1.w = inverseSqrt(r1.w);
668
+ let v_195 = (r1.www * r3.xyz);
669
+ r3 = vec4<f32>(v_195.xyz, r3.w);
670
+ let v_196 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
671
+ r1.w = clamp(vec4<f32>(v_196, v_196, v_196, v_196).w, 0.0f, 1.0f);
672
+ r1.w = log2(r1.w);
673
+ r1.w = (r1.w * cb3_3.tint_symbol_2[54u].w);
674
+ r1.w = exp2(r1.w);
675
+ let v_197 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
676
+ r2.w = clamp(vec4<f32>(v_197, v_197, v_197, v_197).w, 0.0f, 1.0f);
677
+ r2.w = log2(r2.w);
678
+ r2.w = (r2.w * cb3_3.tint_symbol_2[53u].w);
679
+ r2.w = exp2(r2.w);
680
+ r2.x = fma((-(r2.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
681
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].y);
682
+ let v_198 = -(cb3_3.tint_symbol_2[52u].xxxx);
683
+ r3.x = (r2.y + v_198.x);
684
+ r3.x = max(r3.x, 0.0f);
685
+ r3.x = (r3.x * cb3_3.tint_symbol_2[51u].x);
686
+ r3.x = (r3.x * 1.44269502162933349609f);
687
+ r3.x = exp2(r3.x);
688
+ r3.x = ((-(r3.xxxx)).x + 1.0f);
689
+ r2.z = clamp(fma(r2.xxxx, r3.xxxx, r2.zzzz).z, 0.0f, 1.0f);
690
+ let v_199 = -(cb3_3.tint_symbol_2[51u].zzzz);
691
+ r2.y = (r2.y * v_199.y);
692
+ r2.y = (r2.y * 1.44269502162933349609f);
693
+ r2.y = exp2(r2.y);
694
+ r2.y = ((-(r2.yyyy)).y + 1.0f);
695
+ let v_200 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
696
+ r3 = vec4<f32>(v_200.xyz, r3.w);
697
+ let v_201 = fma(r1.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
698
+ r3 = vec4<f32>(v_201.xyz, r3.w);
699
+ let v_202 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
700
+ r4 = vec4<f32>(v_202.xyz, r4.w);
701
+ let v_203 = fma(r2.www, r4.xyz, r3.xyz);
702
+ r3 = vec4<f32>(v_203.xyz, r3.w);
703
+ let v_204 = -(cb3_3.tint_symbol_2[57u].xyzx);
704
+ let v_205 = (r3.xyz + v_204.xyz);
705
+ r3 = vec4<f32>(v_205.xyz, r3.w);
706
+ let v_206 = fma(r2.yyy, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
707
+ r3 = vec4<f32>(v_206.xyz, r3.w);
708
+ r4.x = cb3_3.tint_symbol_2[55u].w;
709
+ r4.y = cb3_3.tint_symbol_2[56u].w;
710
+ r4.z = cb3_3.tint_symbol_2[57u].w;
711
+ let v_207 = ((-(r3.xyzx)).xyz + r4.xyz);
712
+ r4 = vec4<f32>(v_207.xyz, r4.w);
713
+ let v_208 = fma(r2.xxx, r4.xyz, r3.xyz);
714
+ r2 = vec4<f32>(v_208.xy, r2.z, v_208.z);
715
+ let v_209 = ((-(r0.xyxz)).xyw + r2.xyw);
716
+ r2 = vec4<f32>(v_209.xy, r2.z, v_209.z);
717
+ let v_210 = fma(r2.zzz, r2.xyw, r0.xyz);
718
+ r1 = vec4<f32>(v_210.xyz, r1.w);
719
+ }
720
+ let v_211 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
721
+ o0 = vec4<f32>(v_211.xyz, o0.w);
722
+ r0.x = bitcast<f32>(select(0u, 4294967295u, (0.30000001192092895508f < r0.w)));
723
+ r0.x = bitcast<f32>((bitcast<u32>(r0.x) & 1065353216u));
724
+ o1 = (r0.x * v1.z);
725
+ o0.w = r0.w;
726
+ o2 = r0.x;
727
+ }
728
+
729
+ struct tint_symbol_7 {
730
+ @location(0u)
731
+ o0 : vec4<f32>,
732
+ @location(1u)
733
+ o1 : f32,
734
+ @location(2u)
735
+ o2 : f32,
736
+ }
737
+
738
+ @fragment
739
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @builtin(position) v_212 : vec4<f32>) -> tint_symbol_7 {
740
+ main_inner(v0, v1, v2, v3, v_212);
741
+ return tint_symbol_7(o0, o1, o2);
742
+ }
b/8b0b5899ed/shaders/013d56caa6391a99.consts.json ADDED
@@ -0,0 +1 @@
 
 
1
+ [2, 3, 1, 4294967295]
b/8b0b5899ed/shaders/013d56caa6391a99.wgsl ADDED
@@ -0,0 +1,1239 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ diagnostic(off, derivative_uniformity);
2
+
3
+ var<private> r0 : vec4<f32>;
4
+
5
+ var<private> r1 : vec4<f32>;
6
+
7
+ var<private> r2 : vec4<f32>;
8
+
9
+ var<private> r3 : vec4<f32>;
10
+
11
+ var<private> r4 : vec4<f32>;
12
+
13
+ var<private> r5 : vec4<f32>;
14
+
15
+ var<private> r6 : vec4<f32>;
16
+
17
+ var<private> r7 : vec4<f32>;
18
+
19
+ var<private> r8 : vec4<f32>;
20
+
21
+ var<private> r9 : vec4<f32>;
22
+
23
+ var<private> r10 : vec4<f32>;
24
+
25
+ var<private> r11 : vec4<f32>;
26
+
27
+ var<private> r12 : vec4<f32>;
28
+
29
+ var<private> r13 : vec4<f32>;
30
+
31
+ var<private> r14 : vec4<f32>;
32
+
33
+ var<private> r15 : vec4<f32>;
34
+
35
+ var<private> r16 : vec4<f32>;
36
+
37
+ var<private> r17 : vec4<f32>;
38
+
39
+ var<private> r18 : vec4<f32>;
40
+
41
+ var<private> r19 : vec4<f32>;
42
+
43
+ var<private> r20 : vec4<f32>;
44
+
45
+ var<private> r21 : vec4<f32>;
46
+
47
+ var<private> r22 : vec4<f32>;
48
+
49
+ var<private> r23 : vec4<f32>;
50
+
51
+ var<private> r24 : vec4<f32>;
52
+
53
+ var<private> r25 : vec4<f32>;
54
+
55
+ struct cb16_struct {
56
+ tint_symbol : array<vec4<f32>, 16u>,
57
+ }
58
+
59
+ @group(1u) @binding(1u) var<uniform> cb1_1 : cb16_struct;
60
+
61
+ struct cb23_struct {
62
+ tint_symbol_1 : array<vec4<f32>, 23u>,
63
+ }
64
+
65
+ @group(1u) @binding(2u) var<uniform> cb2_2 : cb23_struct;
66
+
67
+ struct cb59_struct {
68
+ tint_symbol_2 : array<vec4<f32>, 59u>,
69
+ }
70
+
71
+ @group(1u) @binding(3u) var<uniform> cb3_3 : cb59_struct;
72
+
73
+ struct cb8_struct {
74
+ tint_symbol_3 : array<vec4<f32>, 8u>,
75
+ }
76
+
77
+ @group(1u) @binding(5u) var<uniform> cb5_5 : cb8_struct;
78
+
79
+ struct cb2_struct {
80
+ tint_symbol_4 : array<vec4<f32>, 2u>,
81
+ }
82
+
83
+ @group(1u) @binding(12u) var<uniform> cb12_12 : cb2_struct;
84
+
85
+ struct cb15_struct {
86
+ tint_symbol_5 : array<vec4<f32>, 15u>,
87
+ }
88
+
89
+ @group(1u) @binding(6u) var<uniform> cb6_6 : cb15_struct;
90
+
91
+ @group(1u) @binding(16u) var s0 : sampler;
92
+
93
+ @group(1u) @binding(18u) var s2 : sampler;
94
+
95
+ @group(1u) @binding(19u) var s3 : sampler;
96
+
97
+ @group(1u) @binding(27u) var s11 : sampler;
98
+
99
+ @group(1u) @binding(31u) var s15 : sampler_comparison;
100
+
101
+ @group(1u) @binding(32u) var t0 : texture_2d<f32>;
102
+
103
+ @group(1u) @binding(34u) var t2 : texture_2d<f32>;
104
+
105
+ @group(1u) @binding(35u) var t3 : texture_2d<f32>;
106
+
107
+ @group(1u) @binding(43u) var t11 : texture_2d<f32>;
108
+
109
+ @group(1u) @binding(47u) var t15 : texture_depth_2d;
110
+
111
+ var<private> v7 : vec4<f32>;
112
+
113
+ var<private> v8 : array<f32, 4u>;
114
+
115
+ var<private> o0 : vec4<f32>;
116
+
117
+ var<private> x0 : array<vec4<f32>, 4u>;
118
+
119
+ var<private> x1 : array<vec4<f32>, 1u>;
120
+
121
+ struct tint_symbol_7 {
122
+ tint_symbol_6 : array<vec4<u32>, 4u>,
123
+ }
124
+
125
+ @group(1u) @binding(15u) var<uniform> v : tint_symbol_7;
126
+
127
+ fn main_inner(v0 : vec4<f32>, v1 : vec4<f32>, v2 : vec4<f32>, v3 : vec4<f32>, v4 : vec4<f32>, v5 : vec4<f32>, v6 : vec4<f32>, v_1 : vec4<f32>) {
128
+ var v_2 : vec4<f32> = v_1;
129
+ v_2.w = (1.0f / v_1.w);
130
+ v7 = v_2;
131
+ x1[0u].x = v8[0u];
132
+ x1[0u].y = v8[1u];
133
+ x1[0u].z = v8[2u];
134
+ x1[0u].w = v8[3u];
135
+ r0 = textureSample(t0, s0, v1.xy.xyxx.xy);
136
+ r1.x = (r0.w * cb2_2.tint_symbol_1[15u].x);
137
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (cb5_5.tint_symbol_3[4u].x >= r1.x)));
138
+ v_3((bitcast<u32>(r1.x) != 0u));
139
+ r1 = textureSample(t2, s2, v1.xy.xyxx.xy);
140
+ let v_4 = fma(r1.xy, vec2<f32>(2.0f), vec2<f32>(-1.0f));
141
+ r1 = vec4<f32>(v_4.xy, r1.zw);
142
+ r1.z = dot(r1.xy, r1.xy);
143
+ r1.z = ((-(r1.zzzz)).z + 1.0f);
144
+ r1.z = sqrt(abs(r1.zzzz).z);
145
+ r1.w = max(cb12_12.tint_symbol_4[0u].w, 0.00100000004749745131f);
146
+ let v_5 = (r1.ww * r1.xy);
147
+ r1 = vec4<f32>(v_5.xy, r1.zw);
148
+ let v_6 = (r1.yyy * v5.xyz);
149
+ r2 = vec4<f32>(v_6.xyz, r2.w);
150
+ let v_7 = fma(r1.xxx, v4.xyz, r2.xyz);
151
+ r1 = vec4<f32>(v_7.xy, r1.z, v_7.z);
152
+ let v_8 = fma(r1.zzz, v2.xyz, r1.xyw);
153
+ r1 = vec4<f32>(v_8.xyz, r1.w);
154
+ r1.w = dot(r1.xyz, r1.xyz);
155
+ r1.w = inverseSqrt(r1.w);
156
+ let v_9 = (r1.www * r1.xyz);
157
+ r2 = vec4<f32>(v_9.xyz, r2.w);
158
+ r1.x = dot(v3.xyz, v3.xyz);
159
+ r1.x = inverseSqrt(r1.x);
160
+ let v_10 = (r1.xxx * v3.xyz);
161
+ r3 = vec4<f32>(v_10.xyz, r3.w);
162
+ r1.x = dot((-(r3.xyzx)).xyz, r2.xyz);
163
+ r1.x = (r1.x + r1.x);
164
+ let v_11 = -(r1.xxxx);
165
+ let v_12 = -(r3.xyzx);
166
+ let v_13 = fma(r2.xyz, v_11.xyz, v_12.xyz);
167
+ r3 = vec4<f32>(v_13.xyz, r3.w);
168
+ r1.x = dot(r3.xyz, r3.xyz);
169
+ r1.x = inverseSqrt(r1.x);
170
+ let v_14 = fma(r3.xz, r1.xx, vec2<f32>(1.0f));
171
+ r1 = vec4<f32>(v_14.xy, r1.zw);
172
+ let v_15 = (r1.xy * vec2<f32>(-0.5f));
173
+ r1 = vec4<f32>(v_15.xy, r1.zw);
174
+ r3 = textureSample(t3, s3, r1.xyxx.xy);
175
+ let v_16 = (r3.xyz * cb12_12.tint_symbol_4[1u].xxx);
176
+ r3 = vec4<f32>(v_16.xyz, r3.w);
177
+ r0.w = (r0.w * v0.w);
178
+ let v_17 = (v0.xy * cb2_2.tint_symbol_1[15u].zy);
179
+ r1 = vec4<f32>(v_17.xy, r1.zw);
180
+ let v_18 = (r0.xyz * r0.xyz);
181
+ r0 = vec4<f32>(v_18.xyz, r0.w);
182
+ let v_19 = -(v6.xyzx);
183
+ let v_20 = (v_19.xyz + cb1_1.tint_symbol[15u].xyz);
184
+ r4 = vec4<f32>(v_20.xyz, r4.w);
185
+ r2.w = dot(r4.xyz, r4.xyz);
186
+ r2.w = inverseSqrt(r2.w);
187
+ let v_21 = (r2.www * r4.xyz);
188
+ r5 = vec4<f32>(v_21.xyz, r5.w);
189
+ let v_22 = -(cb3_3.tint_symbol_2[0u].xyzx);
190
+ let v_23 = fma(r4.xyz, r2.www, v_22.xyz);
191
+ r6 = vec4<f32>(v_23.xyz, r6.w);
192
+ r3.w = dot(r6.xyz, r6.xyz);
193
+ r3.w = inverseSqrt(r3.w);
194
+ let v_24 = (r3.www * r6.xyz);
195
+ r6 = vec4<f32>(v_24.xyz, r6.w);
196
+ r3.w = clamp(cb12_12.tint_symbol_4[0u].z, 0.0f, 1.0f);
197
+ let v_25 = (r1.xy * r1.xy);
198
+ r1 = vec4<f32>(v_25.xy, r1.zw);
199
+ r4.w = (cb12_12.tint_symbol_4[0u].y + -500.0f);
200
+ r4.w = max(r4.w, 0.0f);
201
+ r5.w = ((-(r4.wwww)).w + cb12_12.tint_symbol_4[0u].y);
202
+ r4.w = (r4.w * 558.0f);
203
+ r4.w = fma(r5.w, 3.0f, r4.w);
204
+ r5.w = dot(r4.xyz, cb1_1.tint_symbol[14u].xyz);
205
+ let v_26 = (v6.xyz + (-(cb1_1.tint_symbol[15u].xyzx)).xyz);
206
+ r7 = vec4<f32>(v_26.xyz, r7.w);
207
+ let v_27 = (r7.yyy * cb6_6.tint_symbol_5[1u].xyz);
208
+ r8 = vec4<f32>(v_27.xyz, r8.w);
209
+ let v_28 = fma(r7.xxx, cb6_6.tint_symbol_5[0u].xyz, r8.xyz);
210
+ r8 = vec4<f32>(v_28.xyz, r8.w);
211
+ let v_29 = fma(r7.zzz, cb6_6.tint_symbol_5[2u].xyz, r8.xyz);
212
+ r8 = vec4<f32>(v_29.xyz, r8.w);
213
+ let v_30 = fma(r8.xyz, cb6_6.tint_symbol_5[4u].xyz, cb6_6.tint_symbol_5[8u].xyz);
214
+ r9 = vec4<f32>(v_30.xyz, r9.w);
215
+ let v_31 = &(x0[0u]);
216
+ let v_32 = r9;
217
+ *(v_31) = vec4<f32>(v_32.xyz, (*(v_31)).w);
218
+ let v_33 = fma(r8.xyz, cb6_6.tint_symbol_5[5u].xyz, cb6_6.tint_symbol_5[9u].xyz);
219
+ r10 = vec4<f32>(v_33.xyz, r10.w);
220
+ let v_34 = &(x0[1u]);
221
+ let v_35 = r10;
222
+ *(v_34) = vec4<f32>(v_35.xyz, (*(v_34)).w);
223
+ let v_36 = fma(r8.xyz, cb6_6.tint_symbol_5[6u].xyz, cb6_6.tint_symbol_5[10u].xyz);
224
+ r11 = vec4<f32>(v_36.xyz, r11.w);
225
+ let v_37 = &(x0[2u]);
226
+ let v_38 = r11;
227
+ *(v_37) = vec4<f32>(v_38.xyz, (*(v_37)).w);
228
+ let v_39 = fma(r8.xyz, cb6_6.tint_symbol_5[7u].xyz, cb6_6.tint_symbol_5[11u].xyz);
229
+ r8 = vec4<f32>(v_39.xyz, r8.w);
230
+ let v_40 = &(x0[3u]);
231
+ let v_41 = r8;
232
+ *(v_40) = vec4<f32>(v_41.xyz, (*(v_40)).w);
233
+ let v_42 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.34609651565551757812f, 0.32848981022834777832f));
234
+ let v_43 = r12;
235
+ r12 = vec4<f32>(v_43.x, v_42.x, v_43.z, v_42.y);
236
+ r6.w = fma((-(cb6_6.tint_symbol_5[14u].zzzz)).w, 1.5f, 1.0f);
237
+ r6.w = (r6.w * 0.5f);
238
+ let v_44 = abs(r11.yyyy);
239
+ r7.w = max(v_44.w, abs(r11.xxxx).w);
240
+ r7.w = bitcast<f32>(select(0u, 4294967295u, (r7.w < r6.w)));
241
+ let v_45 = (bitcast<u32>(r7.w) != 0u);
242
+ let v_46 = bitcast<f32>(v.tint_symbol_6[0i].x);
243
+ r7.w = select(bitcast<f32>(v.tint_symbol_6[1i].x), v_46, v_45);
244
+ let v_47 = abs(r10.yyyy);
245
+ r8.z = max(v_47.z, abs(r10.xxxx).z);
246
+ r8.z = bitcast<f32>(select(0u, 4294967295u, (r8.z < r6.w)));
247
+ let v_48 = bitcast<u32>(r8.z);
248
+ r7.w = select(r7.w, bitcast<f32>(v.tint_symbol_6[2i].x), (v_48 != 0u));
249
+ let v_49 = abs(r9.yyyy);
250
+ r8.z = max(v_49.z, abs(r9.xxxx).z);
251
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (r8.z < r6.w)));
252
+ let v_50 = bitcast<u32>(r6.w);
253
+ r6.w = select(r7.w, 0.0f, (v_50 != 0u));
254
+ let v_51 = x0[bitcast<i32>(r6.w)];
255
+ r9 = vec4<f32>(v_51.xyz, r9.w);
256
+ r6.w = f32(bitcast<i32>(r6.w));
257
+ r7.w = (r6.w + 0.5f);
258
+ r7.w = (r7.w * 0.25f);
259
+ r10 = bitcast<vec4<f32>>(select(vec4<u32>(), vec4<u32>(4294967295u), (vec4<f32>(0.0f, 1.0f, 2.0f, 3.0f) == r6.wwww)));
260
+ r10 = bitcast<vec4<f32>>((bitcast<vec4<u32>>(r10) & vec4<u32>(1065353216u)));
261
+ r6.w = dot(r10, cb6_6.tint_symbol_5[12u]);
262
+ r8.z = dot(r10, cb6_6.tint_symbol_5[13u]);
263
+ r10.x = (r9.x + 0.5f);
264
+ r10.y = fma(r9.y, 0.25f, r7.w);
265
+ r7.w = bitcast<f32>(select(0u, 4294967295u, !((r6.w == 0.0f))));
266
+ r6.w = ((-(r6.wwww)).w + r9.z);
267
+ let v_52 = dpdx(r10.xyy);
268
+ r11 = vec4<f32>(v_52.xy, r11.z, v_52.z);
269
+ r11.z = dpdx(r6.w);
270
+ let v_53 = dpdy(r10.yxy);
271
+ r13 = vec4<f32>(v_53.xyz, r13.w);
272
+ r13.w = dpdy(r6.w);
273
+ let v_54 = (r11.yw * r13.yw);
274
+ r9 = vec4<f32>(v_54.xy, r9.zw);
275
+ let v_55 = -(r9.xyxx);
276
+ let v_56 = fma(r11.xz, r13.xz, v_55.xy);
277
+ r14 = vec4<f32>(v_56.xy, r14.zw);
278
+ r8.w = (1.0f / r14.x);
279
+ r9.x = (r11.z * r13.y);
280
+ let v_57 = -(r9.xxxx);
281
+ r14.z = fma(r11.x, r13.w, v_57.z);
282
+ let v_58 = (r8.ww * r14.yz);
283
+ r9 = vec4<f32>(v_58.xy, r9.zw);
284
+ let v_59 = max(r9.xy, vec2<f32>());
285
+ r9 = vec4<f32>(v_59.xy, r9.zw);
286
+ let v_60 = min(r9.xy, vec2<f32>(0.5f));
287
+ r9 = vec4<f32>(v_60.xy, r9.zw);
288
+ r6.w = fma((-(r8.zzzz)).w, r9.x, r6.w);
289
+ r6.w = fma((-(r8.zzzz)).w, r9.y, r6.w);
290
+ let v_61 = bitcast<u32>(r7.w);
291
+ let v_62 = r6.w;
292
+ r12.z = select(r9.z, v_62, (v_61 != 0u));
293
+ r10.z = 0.0f;
294
+ let v_63 = (r10.xyz + r12.ywz);
295
+ r9 = vec4<f32>(v_63.xyz, r9.w);
296
+ let v_64 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.79929149150848388672f, 0.20174059271812438965f));
297
+ r12 = vec4<f32>(v_64.xy, r12.zw);
298
+ let v_65 = (r10.xyz + r12.xyz);
299
+ r11 = vec4<f32>(v_65.xyz, r11.w);
300
+ let v_66 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.03117550723254680634f, 0.17933775484561920166f));
301
+ r12 = vec4<f32>(v_66.xy, r12.zw);
302
+ let v_67 = (r10.xyz + r12.xyz);
303
+ r13 = vec4<f32>(v_67.xyz, r13.w);
304
+ let v_68 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.51474946737289428711f, 0.25350245833396911621f));
305
+ r12 = vec4<f32>(v_68.xy, r12.zw);
306
+ let v_69 = (r10.xyz + r12.xyz);
307
+ r14 = vec4<f32>(v_69.xyz, r14.w);
308
+ let v_70 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.07286971807479858398f, 0.00809734128415584564f));
309
+ r12 = vec4<f32>(v_70.xy, r12.zw);
310
+ let v_71 = (r10.xyz + r12.xyz);
311
+ r15 = vec4<f32>(v_71.xyz, r15.w);
312
+ let v_72 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.96978127956390380859f, 0.03452160954475402832f));
313
+ r12 = vec4<f32>(v_72.xy, r12.zw);
314
+ let v_73 = (r10.xyz + r12.xyz);
315
+ r16 = vec4<f32>(v_73.xyz, r16.w);
316
+ let v_74 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.54554665088653564453f, 0.02412854135036468506f));
317
+ r12 = vec4<f32>(v_74.xy, r12.zw);
318
+ let v_75 = (r10.xyz + r12.xyz);
319
+ r17 = vec4<f32>(v_75.xyz, r17.w);
320
+ let v_76 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.02890610881149768829f, -0.13678458333015441895f));
321
+ r12 = vec4<f32>(v_76.xy, r12.zw);
322
+ let v_77 = (r10.xyz + r12.xyz);
323
+ r18 = vec4<f32>(v_77.xyz, r18.w);
324
+ let v_78 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.47951146960258483887f, -0.24483287334442138672f));
325
+ r12 = vec4<f32>(v_78.xy, r12.zw);
326
+ let v_79 = (r10.xyz + r12.xyz);
327
+ r19 = vec4<f32>(v_79.xyz, r19.w);
328
+ let v_80 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.7587884068489074707f, -0.1121091991662979126f));
329
+ r12 = vec4<f32>(v_80.xy, r12.zw);
330
+ let v_81 = (r10.xyz + r12.xyz);
331
+ r20 = vec4<f32>(v_81.xyz, r20.w);
332
+ let v_82 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.33935257792472839355f, -0.24932782351970672607f));
333
+ r12 = vec4<f32>(v_82.xy, r12.zw);
334
+ let v_83 = (r10.xyz + r12.xyz);
335
+ r21 = vec4<f32>(v_83.xyz, r21.w);
336
+ let v_84 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.07059764862060546875f, 0.2081225961446762085f));
337
+ r12 = vec4<f32>(v_84.xy, r12.zw);
338
+ let v_85 = (r10.xyz + r12.xyz);
339
+ r22 = vec4<f32>(v_85.xyz, r22.w);
340
+ let v_86 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(1.29403817653656005859f, -0.01807767525315284729f));
341
+ r12 = vec4<f32>(v_86.xy, r12.zw);
342
+ let v_87 = (r10.xyz + r12.xyz);
343
+ r23 = vec4<f32>(v_87.xyz, r23.w);
344
+ let v_88 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-0.7475630640983581543f, -0.11397434771060943604f));
345
+ r12 = vec4<f32>(v_88.xy, r12.zw);
346
+ let v_89 = (r10.xyz + r12.xyz);
347
+ r24 = vec4<f32>(v_89.xyz, r24.w);
348
+ let v_90 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(0.94772171974182128906f, -0.24876354634761810303f));
349
+ r12 = vec4<f32>(v_90.xy, r12.zw);
350
+ let v_91 = (r10.xyz + r12.xyz);
351
+ r25 = vec4<f32>(v_91.xyz, r25.w);
352
+ let v_92 = (cb6_6.tint_symbol_5[14u].zw * vec2<f32>(-1.34315288066864013672f, -0.08858405798673629761f));
353
+ r12 = vec4<f32>(v_92.xy, r12.zw);
354
+ let v_93 = (r10.xyz + r12.xyz);
355
+ r10 = vec4<f32>(v_93.xyz, r10.w);
356
+ let v_94 = r9.xyxx;
357
+ r9.x = textureSampleCompareLevel(t15, s15, v_94.xy, r9.z);
358
+ let v_95 = r11.xyxx;
359
+ r9.y = textureSampleCompareLevel(t15, s15, v_95.xy, r11.z);
360
+ let v_96 = r13.xyxx;
361
+ r9.z = textureSampleCompareLevel(t15, s15, v_96.xy, r13.z);
362
+ let v_97 = r14.xyxx;
363
+ r9.w = textureSampleCompareLevel(t15, s15, v_97.xy, r14.z);
364
+ let v_98 = r15.xyxx;
365
+ r11.x = textureSampleCompareLevel(t15, s15, v_98.xy, r15.z);
366
+ let v_99 = r16.xyxx;
367
+ r11.y = textureSampleCompareLevel(t15, s15, v_99.xy, r16.z);
368
+ let v_100 = r17.xyxx;
369
+ r11.z = textureSampleCompareLevel(t15, s15, v_100.xy, r17.z);
370
+ let v_101 = r18.xyxx;
371
+ r11.w = textureSampleCompareLevel(t15, s15, v_101.xy, r18.z);
372
+ let v_102 = r19.xyxx;
373
+ r12.x = textureSampleCompareLevel(t15, s15, v_102.xy, r19.z);
374
+ let v_103 = r20.xyxx;
375
+ r12.y = textureSampleCompareLevel(t15, s15, v_103.xy, r20.z);
376
+ let v_104 = r21.xyxx;
377
+ r12.z = textureSampleCompareLevel(t15, s15, v_104.xy, r21.z);
378
+ let v_105 = r22.xyxx;
379
+ r12.w = textureSampleCompareLevel(t15, s15, v_105.xy, r22.z);
380
+ let v_106 = r23.xyxx;
381
+ r13.x = textureSampleCompareLevel(t15, s15, v_106.xy, r23.z);
382
+ let v_107 = r24.xyxx;
383
+ r13.y = textureSampleCompareLevel(t15, s15, v_107.xy, r24.z);
384
+ let v_108 = r25.xyxx;
385
+ r13.z = textureSampleCompareLevel(t15, s15, v_108.xy, r25.z);
386
+ let v_109 = r10.xyxx;
387
+ r13.w = textureSampleCompareLevel(t15, s15, v_109.xy, r10.z);
388
+ r9 = (r9 + r11);
389
+ r9 = (r12 + r9);
390
+ r9 = (r13 + r9);
391
+ r6.w = dot(r9, vec4<f32>(1.0f));
392
+ r5.w = clamp(fma(r5.wwww, cb6_6.tint_symbol_5[0u].wwww, cb6_6.tint_symbol_5[1u].wwww).w, 0.0f, 1.0f);
393
+ let v_110 = abs(r8.yyyy);
394
+ r7.w = max(v_110.w, abs(r8.xxxx).w);
395
+ r7.w = clamp(fma(r7.wwww, vec4<f32>(15.0f), vec4<f32>(-6.30000019073486328125f)).w, 0.0f, 1.0f);
396
+ r5.w = ((-(r5.wwww)).w + 1.0f);
397
+ r5.w = (r7.w * r5.w);
398
+ r5.w = fma(r6.w, 0.0625f, r5.w);
399
+ r5.w = (r5.w * r5.w);
400
+ r5.w = min(r5.w, 1.0f);
401
+ r6.w = clamp(fma(v6.zzzz, cb6_6.tint_symbol_5[3u].xxxx, cb6_6.tint_symbol_5[3u].yyyy).w, 0.0f, 1.0f);
402
+ r6.w = sqrt(r6.w);
403
+ r6.w = (r6.w * cb6_6.tint_symbol_5[3u].z);
404
+ let v_111 = -(r5.wwww);
405
+ r5.w = fma(r6.w, v_111.w, r5.w);
406
+ let v_112 = dot(r2.xyz, v_22.xyz);
407
+ r6.w = clamp(vec4<f32>(v_112, v_112, v_112, v_112).w, 0.0f, 1.0f);
408
+ let v_113 = dot(r5.xyz, r2.xyz);
409
+ r8.x = clamp(vec4<f32>(v_113, v_113, v_113, v_113).x, 0.0f, 1.0f);
410
+ let v_114 = dot(r6.xyz, v_22.xyz);
411
+ r8.y = clamp(vec4<f32>(v_114, v_114, v_114, v_114).y, 0.0f, 1.0f);
412
+ let v_115 = ((-(r8.xyxx)).xy + vec2<f32>(1.0f));
413
+ r8 = vec4<f32>(v_115.xy, r8.zw);
414
+ let v_116 = (r8.xy * r8.xy);
415
+ r8 = vec4<f32>(r8.xy, v_116.xy);
416
+ let v_117 = (r8.zw * r8.zw);
417
+ r8 = vec4<f32>(r8.xy, v_117.xy);
418
+ let v_118 = (r8.xy * r8.zw);
419
+ r8 = vec4<f32>(v_118.xy, r8.zw);
420
+ r7.w = ((-(cb12_12.tint_symbol_4[0u].xxxx)).w + 1.0f);
421
+ let v_119 = fma(cb12_12.tint_symbol_4[0u].xx, r8.xy, r7.ww);
422
+ r8 = vec4<f32>(v_119.xy, r8.zw);
423
+ let v_120 = (r4.ww + vec2<f32>(2.0f, 0.00000000999999993923f));
424
+ r8 = vec4<f32>(r8.xy, v_120.xy);
425
+ r8.z = (r8.z * 0.125f);
426
+ r8.x = fma((-(r3.wwww)).x, r8.x, 1.0f);
427
+ r6.x = dot(r2.xyz, r6.xyz);
428
+ r6.x = clamp(((r6.xxxx + vec4<f32>(0.00000000999999993923f))).x, 0.0f, 1.0f);
429
+ r6.x = log2(r6.x);
430
+ r6.x = (r6.x * r8.w);
431
+ r6.x = exp2(r6.x);
432
+ r6.x = (r8.y * r6.x);
433
+ r6.x = (r8.z * r6.x);
434
+ r6.x = (r3.w * r6.x);
435
+ r6.x = (r6.w * r6.x);
436
+ r6.y = (r6.w * r8.x);
437
+ let v_121 = fma(r0.xyz, r6.yyy, r6.xxx);
438
+ r6 = vec4<f32>(v_121.xyz, r6.w);
439
+ let v_122 = (r6.xyz * cb3_3.tint_symbol_2[1u].xyz);
440
+ r6 = vec4<f32>(v_122.xyz, r6.w);
441
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (0i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
442
+ if ((bitcast<u32>(r6.w) != 0u)) {
443
+ r10 = vec4<f32>(vec3<f32>(), r10.w);
444
+ r9 = vec4<f32>(vec3<f32>(), r9.w);
445
+ } else {
446
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[19u].w == 0.0f)));
447
+ let v_123 = (v_19.xyz + cb3_3.tint_symbol_2[3u].xyz);
448
+ r9 = vec4<f32>(v_123.xyz, r9.w);
449
+ let v_124 = (v6.xyz + (-(cb3_3.tint_symbol_2[3u].xyzx)).xyz);
450
+ r10 = vec4<f32>(v_124.xyz, r10.w);
451
+ r9.w = dot(r10.xyz, cb3_3.tint_symbol_2[11u].xyz);
452
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[19u].wwww)).w, 0.0f, 1.0f);
453
+ r9.w = (r9.w * cb3_3.tint_symbol_2[19u].w);
454
+ let v_125 = fma(cb3_3.tint_symbol_2[11u].xyz, r9.www, cb3_3.tint_symbol_2[3u].xyz);
455
+ r10 = vec4<f32>(v_125.xyz, r10.w);
456
+ let v_126 = (r10.xyz + v_19.xyz);
457
+ r10 = vec4<f32>(v_126.xyz, r10.w);
458
+ let v_127 = bitcast<vec3<u32>>(r8.yyy);
459
+ let v_128 = r9.xyz;
460
+ let v_129 = select(r10.xyz, v_128, (v_127 != vec3<u32>()));
461
+ r9 = vec4<f32>(v_129.xyz, r9.w);
462
+ r8.y = dot(r9.xyz, r9.xyz);
463
+ let v_130 = (r9.xyz + vec3<f32>(0.00000099999999747524f));
464
+ r9 = vec4<f32>(v_130.xyz, r9.w);
465
+ r9.w = dot(r9.xyz, r9.xyz);
466
+ r9.w = inverseSqrt(r9.w);
467
+ let v_131 = (r9.www * r9.xyz);
468
+ r9 = vec4<f32>(v_131.xyz, r9.w);
469
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[3u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
470
+ r9.w = ((-(cb3_3.tint_symbol_2[11u].wwww)).w + 1.0f);
471
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[11u].w);
472
+ r8.y = (r8.y / r9.w);
473
+ let v_132 = -(cb3_3.tint_symbol_2[11u].xyzx);
474
+ r9.w = dot(r9.xyz, v_132.xyz);
475
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[27u].xxxx, cb3_3.tint_symbol_2[35u].xxxx).w, 0.0f, 1.0f);
476
+ let v_133 = dot(r9.xyz, r2.xyz);
477
+ r10.x = clamp(vec4<f32>(v_133, v_133, v_133, v_133).x, 0.0f, 1.0f);
478
+ r9.w = (r9.w * r10.x);
479
+ r10.x = (r8.y * r9.w);
480
+ let v_134 = (r10.xxx * cb3_3.tint_symbol_2[19u].xyz);
481
+ r10 = vec4<f32>(v_134.xyz, r10.w);
482
+ let v_135 = (r0.xyz * r10.xyz);
483
+ r10 = vec4<f32>(v_135.xyz, r10.w);
484
+ let v_136 = fma(r4.xyz, r2.www, r9.xyz);
485
+ r9 = vec4<f32>(v_136.xyz, r9.w);
486
+ r10.w = dot(r9.xyz, r9.xyz);
487
+ r10.w = inverseSqrt(r10.w);
488
+ let v_137 = (r9.xyz * r10.www);
489
+ r9 = vec4<f32>(v_137.xyz, r9.w);
490
+ let v_138 = dot(r9.xyz, r5.xyz);
491
+ r10.w = clamp(vec4<f32>(v_138, v_138, v_138, v_138).w, 0.0f, 1.0f);
492
+ r10.w = ((-(r10.wwww)).w + 1.0f);
493
+ r11.x = (r10.w * r10.w);
494
+ r11.x = (r11.x * r11.x);
495
+ r10.w = (r10.w * r11.x);
496
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
497
+ let v_139 = dot(r9.xyz, r2.xyz);
498
+ r9.x = clamp(vec4<f32>(v_139, v_139, v_139, v_139).x, 0.0f, 1.0f);
499
+ r9.x = log2(r9.x);
500
+ r9.x = (r8.w * r9.x);
501
+ r9.x = exp2(r9.x);
502
+ r9.x = (r9.x * r10.w);
503
+ r9.x = (r9.w * r9.x);
504
+ r8.y = (r8.y * r9.x);
505
+ r8.y = (r8.z * r8.y);
506
+ let v_140 = (r8.yyy * cb3_3.tint_symbol_2[19u].xyz);
507
+ r9 = vec4<f32>(v_140.xyz, r9.w);
508
+ }
509
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (0i < bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
510
+ if ((bitcast<u32>(r8.y) != 0u)) {
511
+ r9.w = bitcast<f32>(select(0u, 4294967295u, (1i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
512
+ r8.y = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
513
+ let v_141 = bitcast<u32>(r9.w);
514
+ let v_142 = r8.y;
515
+ r6.w = select(r6.w, v_142, (v_141 != 0u));
516
+ if ((bitcast<u32>(r6.w) != 0u)) {
517
+ } else {
518
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[20u].w == 0.0f)));
519
+ let v_143 = (v_19.xyz + cb3_3.tint_symbol_2[4u].xyz);
520
+ r11 = vec4<f32>(v_143.xyz, r11.w);
521
+ let v_144 = (v6.xyz + (-(cb3_3.tint_symbol_2[4u].xyzx)).xyz);
522
+ r12 = vec4<f32>(v_144.xyz, r12.w);
523
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[12u].xyz);
524
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[20u].wwww)).w, 0.0f, 1.0f);
525
+ r9.w = (r9.w * cb3_3.tint_symbol_2[20u].w);
526
+ let v_145 = fma(cb3_3.tint_symbol_2[12u].xyz, r9.www, cb3_3.tint_symbol_2[4u].xyz);
527
+ r12 = vec4<f32>(v_145.xyz, r12.w);
528
+ let v_146 = (r12.xyz + v_19.xyz);
529
+ r12 = vec4<f32>(v_146.xyz, r12.w);
530
+ let v_147 = bitcast<vec3<u32>>(r8.yyy);
531
+ let v_148 = r11.xyz;
532
+ let v_149 = select(r12.xyz, v_148, (v_147 != vec3<u32>()));
533
+ r11 = vec4<f32>(v_149.xyz, r11.w);
534
+ r8.y = dot(r11.xyz, r11.xyz);
535
+ let v_150 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
536
+ r11 = vec4<f32>(v_150.xyz, r11.w);
537
+ r9.w = dot(r11.xyz, r11.xyz);
538
+ r9.w = inverseSqrt(r9.w);
539
+ let v_151 = (r9.www * r11.xyz);
540
+ r11 = vec4<f32>(v_151.xyz, r11.w);
541
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[4u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
542
+ r9.w = ((-(cb3_3.tint_symbol_2[12u].wwww)).w + 1.0f);
543
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[12u].w);
544
+ r8.y = (r8.y / r9.w);
545
+ let v_152 = -(cb3_3.tint_symbol_2[12u].xyzx);
546
+ r9.w = dot(r11.xyz, v_152.xyz);
547
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[28u].xxxx, cb3_3.tint_symbol_2[36u].xxxx).w, 0.0f, 1.0f);
548
+ let v_153 = dot(r11.xyz, r2.xyz);
549
+ r10.w = clamp(vec4<f32>(v_153, v_153, v_153, v_153).w, 0.0f, 1.0f);
550
+ r9.w = (r9.w * r10.w);
551
+ r10.w = (r8.y * r9.w);
552
+ let v_154 = (r10.www * cb3_3.tint_symbol_2[20u].xyz);
553
+ r12 = vec4<f32>(v_154.xyz, r12.w);
554
+ let v_155 = fma(r12.xyz, r0.xyz, r10.xyz);
555
+ r10 = vec4<f32>(v_155.xyz, r10.w);
556
+ let v_156 = fma(r4.xyz, r2.www, r11.xyz);
557
+ r11 = vec4<f32>(v_156.xyz, r11.w);
558
+ r10.w = dot(r11.xyz, r11.xyz);
559
+ r10.w = inverseSqrt(r10.w);
560
+ let v_157 = (r10.www * r11.xyz);
561
+ r11 = vec4<f32>(v_157.xyz, r11.w);
562
+ let v_158 = dot(r11.xyz, r5.xyz);
563
+ r10.w = clamp(vec4<f32>(v_158, v_158, v_158, v_158).w, 0.0f, 1.0f);
564
+ r10.w = ((-(r10.wwww)).w + 1.0f);
565
+ r11.w = (r10.w * r10.w);
566
+ r11.w = (r11.w * r11.w);
567
+ r10.w = (r10.w * r11.w);
568
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
569
+ let v_159 = dot(r11.xyz, r2.xyz);
570
+ r11.x = clamp(vec4<f32>(v_159, v_159, v_159, v_159).x, 0.0f, 1.0f);
571
+ r11.x = log2(r11.x);
572
+ r11.x = (r8.w * r11.x);
573
+ r11.x = exp2(r11.x);
574
+ r10.w = (r10.w * r11.x);
575
+ r9.w = (r9.w * r10.w);
576
+ r8.y = (r8.y * r9.w);
577
+ r8.y = (r8.z * r8.y);
578
+ let v_160 = fma(r8.yyy, cb3_3.tint_symbol_2[20u].xyz, r9.xyz);
579
+ r9 = vec4<f32>(v_160.xyz, r9.w);
580
+ }
581
+ } else {
582
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
583
+ }
584
+ if ((bitcast<u32>(r6.w) != 0u)) {
585
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
586
+ } else {
587
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (2i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
588
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
589
+ if ((bitcast<u32>(r6.w) != 0u)) {
590
+ } else {
591
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[21u].w == 0.0f)));
592
+ let v_161 = (v_19.xyz + cb3_3.tint_symbol_2[5u].xyz);
593
+ r11 = vec4<f32>(v_161.xyz, r11.w);
594
+ let v_162 = (v6.xyz + (-(cb3_3.tint_symbol_2[5u].xyzx)).xyz);
595
+ r12 = vec4<f32>(v_162.xyz, r12.w);
596
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[13u].xyz);
597
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[21u].wwww)).w, 0.0f, 1.0f);
598
+ r9.w = (r9.w * cb3_3.tint_symbol_2[21u].w);
599
+ let v_163 = fma(cb3_3.tint_symbol_2[13u].xyz, r9.www, cb3_3.tint_symbol_2[5u].xyz);
600
+ r12 = vec4<f32>(v_163.xyz, r12.w);
601
+ let v_164 = (r12.xyz + v_19.xyz);
602
+ r12 = vec4<f32>(v_164.xyz, r12.w);
603
+ let v_165 = bitcast<vec3<u32>>(r8.yyy);
604
+ let v_166 = r11.xyz;
605
+ let v_167 = select(r12.xyz, v_166, (v_165 != vec3<u32>()));
606
+ r11 = vec4<f32>(v_167.xyz, r11.w);
607
+ r8.y = dot(r11.xyz, r11.xyz);
608
+ let v_168 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
609
+ r11 = vec4<f32>(v_168.xyz, r11.w);
610
+ r9.w = dot(r11.xyz, r11.xyz);
611
+ r9.w = inverseSqrt(r9.w);
612
+ let v_169 = (r9.www * r11.xyz);
613
+ r11 = vec4<f32>(v_169.xyz, r11.w);
614
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[5u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
615
+ r9.w = ((-(cb3_3.tint_symbol_2[13u].wwww)).w + 1.0f);
616
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[13u].w);
617
+ r8.y = (r8.y / r9.w);
618
+ let v_170 = -(cb3_3.tint_symbol_2[13u].xyzx);
619
+ r9.w = dot(r11.xyz, v_170.xyz);
620
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[29u].xxxx, cb3_3.tint_symbol_2[37u].xxxx).w, 0.0f, 1.0f);
621
+ let v_171 = dot(r11.xyz, r2.xyz);
622
+ r10.w = clamp(vec4<f32>(v_171, v_171, v_171, v_171).w, 0.0f, 1.0f);
623
+ r9.w = (r9.w * r10.w);
624
+ r10.w = (r8.y * r9.w);
625
+ let v_172 = (r10.www * cb3_3.tint_symbol_2[21u].xyz);
626
+ r12 = vec4<f32>(v_172.xyz, r12.w);
627
+ let v_173 = fma(r12.xyz, r0.xyz, r10.xyz);
628
+ r10 = vec4<f32>(v_173.xyz, r10.w);
629
+ let v_174 = fma(r4.xyz, r2.www, r11.xyz);
630
+ r11 = vec4<f32>(v_174.xyz, r11.w);
631
+ r10.w = dot(r11.xyz, r11.xyz);
632
+ r10.w = inverseSqrt(r10.w);
633
+ let v_175 = (r10.www * r11.xyz);
634
+ r11 = vec4<f32>(v_175.xyz, r11.w);
635
+ let v_176 = dot(r11.xyz, r5.xyz);
636
+ r10.w = clamp(vec4<f32>(v_176, v_176, v_176, v_176).w, 0.0f, 1.0f);
637
+ r10.w = ((-(r10.wwww)).w + 1.0f);
638
+ r11.w = (r10.w * r10.w);
639
+ r11.w = (r11.w * r11.w);
640
+ r10.w = (r10.w * r11.w);
641
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
642
+ let v_177 = dot(r11.xyz, r2.xyz);
643
+ r11.x = clamp(vec4<f32>(v_177, v_177, v_177, v_177).x, 0.0f, 1.0f);
644
+ r11.x = log2(r11.x);
645
+ r11.x = (r8.w * r11.x);
646
+ r11.x = exp2(r11.x);
647
+ r10.w = (r10.w * r11.x);
648
+ r9.w = (r9.w * r10.w);
649
+ r8.y = (r8.y * r9.w);
650
+ r8.y = (r8.z * r8.y);
651
+ let v_178 = fma(r8.yyy, cb3_3.tint_symbol_2[21u].xyz, r9.xyz);
652
+ r9 = vec4<f32>(v_178.xyz, r9.w);
653
+ }
654
+ }
655
+ if ((bitcast<u32>(r6.w) != 0u)) {
656
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
657
+ } else {
658
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (3i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
659
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
660
+ if ((bitcast<u32>(r6.w) != 0u)) {
661
+ } else {
662
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[22u].w == 0.0f)));
663
+ let v_179 = (v_19.xyz + cb3_3.tint_symbol_2[6u].xyz);
664
+ r11 = vec4<f32>(v_179.xyz, r11.w);
665
+ let v_180 = (v6.xyz + (-(cb3_3.tint_symbol_2[6u].xyzx)).xyz);
666
+ r12 = vec4<f32>(v_180.xyz, r12.w);
667
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[14u].xyz);
668
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[22u].wwww)).w, 0.0f, 1.0f);
669
+ r9.w = (r9.w * cb3_3.tint_symbol_2[22u].w);
670
+ let v_181 = fma(cb3_3.tint_symbol_2[14u].xyz, r9.www, cb3_3.tint_symbol_2[6u].xyz);
671
+ r12 = vec4<f32>(v_181.xyz, r12.w);
672
+ let v_182 = (r12.xyz + v_19.xyz);
673
+ r12 = vec4<f32>(v_182.xyz, r12.w);
674
+ let v_183 = bitcast<vec3<u32>>(r8.yyy);
675
+ let v_184 = r11.xyz;
676
+ let v_185 = select(r12.xyz, v_184, (v_183 != vec3<u32>()));
677
+ r11 = vec4<f32>(v_185.xyz, r11.w);
678
+ r8.y = dot(r11.xyz, r11.xyz);
679
+ let v_186 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
680
+ r11 = vec4<f32>(v_186.xyz, r11.w);
681
+ r9.w = dot(r11.xyz, r11.xyz);
682
+ r9.w = inverseSqrt(r9.w);
683
+ let v_187 = (r9.www * r11.xyz);
684
+ r11 = vec4<f32>(v_187.xyz, r11.w);
685
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[6u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
686
+ r9.w = ((-(cb3_3.tint_symbol_2[14u].wwww)).w + 1.0f);
687
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[14u].w);
688
+ r8.y = (r8.y / r9.w);
689
+ let v_188 = -(cb3_3.tint_symbol_2[14u].xyzx);
690
+ r9.w = dot(r11.xyz, v_188.xyz);
691
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[30u].xxxx, cb3_3.tint_symbol_2[38u].xxxx).w, 0.0f, 1.0f);
692
+ let v_189 = dot(r11.xyz, r2.xyz);
693
+ r10.w = clamp(vec4<f32>(v_189, v_189, v_189, v_189).w, 0.0f, 1.0f);
694
+ r9.w = (r9.w * r10.w);
695
+ r10.w = (r8.y * r9.w);
696
+ let v_190 = (r10.www * cb3_3.tint_symbol_2[22u].xyz);
697
+ r12 = vec4<f32>(v_190.xyz, r12.w);
698
+ let v_191 = fma(r12.xyz, r0.xyz, r10.xyz);
699
+ r10 = vec4<f32>(v_191.xyz, r10.w);
700
+ let v_192 = fma(r4.xyz, r2.www, r11.xyz);
701
+ r11 = vec4<f32>(v_192.xyz, r11.w);
702
+ r10.w = dot(r11.xyz, r11.xyz);
703
+ r10.w = inverseSqrt(r10.w);
704
+ let v_193 = (r10.www * r11.xyz);
705
+ r11 = vec4<f32>(v_193.xyz, r11.w);
706
+ let v_194 = dot(r11.xyz, r5.xyz);
707
+ r10.w = clamp(vec4<f32>(v_194, v_194, v_194, v_194).w, 0.0f, 1.0f);
708
+ r10.w = ((-(r10.wwww)).w + 1.0f);
709
+ r11.w = (r10.w * r10.w);
710
+ r11.w = (r11.w * r11.w);
711
+ r10.w = (r10.w * r11.w);
712
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
713
+ let v_195 = dot(r11.xyz, r2.xyz);
714
+ r11.x = clamp(vec4<f32>(v_195, v_195, v_195, v_195).x, 0.0f, 1.0f);
715
+ r11.x = log2(r11.x);
716
+ r11.x = (r8.w * r11.x);
717
+ r11.x = exp2(r11.x);
718
+ r10.w = (r10.w * r11.x);
719
+ r9.w = (r9.w * r10.w);
720
+ r8.y = (r8.y * r9.w);
721
+ r8.y = (r8.z * r8.y);
722
+ let v_196 = fma(r8.yyy, cb3_3.tint_symbol_2[22u].xyz, r9.xyz);
723
+ r9 = vec4<f32>(v_196.xyz, r9.w);
724
+ }
725
+ }
726
+ if ((bitcast<u32>(r6.w) != 0u)) {
727
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
728
+ } else {
729
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (4i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
730
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
731
+ if ((bitcast<u32>(r6.w) != 0u)) {
732
+ } else {
733
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[23u].w == 0.0f)));
734
+ let v_197 = (v_19.xyz + cb3_3.tint_symbol_2[7u].xyz);
735
+ r11 = vec4<f32>(v_197.xyz, r11.w);
736
+ let v_198 = (v6.xyz + (-(cb3_3.tint_symbol_2[7u].xyzx)).xyz);
737
+ r12 = vec4<f32>(v_198.xyz, r12.w);
738
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[15u].xyz);
739
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[23u].wwww)).w, 0.0f, 1.0f);
740
+ r9.w = (r9.w * cb3_3.tint_symbol_2[23u].w);
741
+ let v_199 = fma(cb3_3.tint_symbol_2[15u].xyz, r9.www, cb3_3.tint_symbol_2[7u].xyz);
742
+ r12 = vec4<f32>(v_199.xyz, r12.w);
743
+ let v_200 = (r12.xyz + v_19.xyz);
744
+ r12 = vec4<f32>(v_200.xyz, r12.w);
745
+ let v_201 = bitcast<vec3<u32>>(r8.yyy);
746
+ let v_202 = r11.xyz;
747
+ let v_203 = select(r12.xyz, v_202, (v_201 != vec3<u32>()));
748
+ r11 = vec4<f32>(v_203.xyz, r11.w);
749
+ r8.y = dot(r11.xyz, r11.xyz);
750
+ let v_204 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
751
+ r11 = vec4<f32>(v_204.xyz, r11.w);
752
+ r9.w = dot(r11.xyz, r11.xyz);
753
+ r9.w = inverseSqrt(r9.w);
754
+ let v_205 = (r9.www * r11.xyz);
755
+ r11 = vec4<f32>(v_205.xyz, r11.w);
756
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[7u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
757
+ r9.w = ((-(cb3_3.tint_symbol_2[15u].wwww)).w + 1.0f);
758
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[15u].w);
759
+ r8.y = (r8.y / r9.w);
760
+ let v_206 = -(cb3_3.tint_symbol_2[15u].xyzx);
761
+ r9.w = dot(r11.xyz, v_206.xyz);
762
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[31u].xxxx, cb3_3.tint_symbol_2[39u].xxxx).w, 0.0f, 1.0f);
763
+ let v_207 = dot(r11.xyz, r2.xyz);
764
+ r10.w = clamp(vec4<f32>(v_207, v_207, v_207, v_207).w, 0.0f, 1.0f);
765
+ r9.w = (r9.w * r10.w);
766
+ r10.w = (r8.y * r9.w);
767
+ let v_208 = (r10.www * cb3_3.tint_symbol_2[23u].xyz);
768
+ r12 = vec4<f32>(v_208.xyz, r12.w);
769
+ let v_209 = fma(r12.xyz, r0.xyz, r10.xyz);
770
+ r10 = vec4<f32>(v_209.xyz, r10.w);
771
+ let v_210 = fma(r4.xyz, r2.www, r11.xyz);
772
+ r11 = vec4<f32>(v_210.xyz, r11.w);
773
+ r10.w = dot(r11.xyz, r11.xyz);
774
+ r10.w = inverseSqrt(r10.w);
775
+ let v_211 = (r10.www * r11.xyz);
776
+ r11 = vec4<f32>(v_211.xyz, r11.w);
777
+ let v_212 = dot(r11.xyz, r5.xyz);
778
+ r10.w = clamp(vec4<f32>(v_212, v_212, v_212, v_212).w, 0.0f, 1.0f);
779
+ r10.w = ((-(r10.wwww)).w + 1.0f);
780
+ r11.w = (r10.w * r10.w);
781
+ r11.w = (r11.w * r11.w);
782
+ r10.w = (r10.w * r11.w);
783
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
784
+ let v_213 = dot(r11.xyz, r2.xyz);
785
+ r11.x = clamp(vec4<f32>(v_213, v_213, v_213, v_213).x, 0.0f, 1.0f);
786
+ r11.x = log2(r11.x);
787
+ r11.x = (r8.w * r11.x);
788
+ r11.x = exp2(r11.x);
789
+ r10.w = (r10.w * r11.x);
790
+ r9.w = (r9.w * r10.w);
791
+ r8.y = (r8.y * r9.w);
792
+ r8.y = (r8.z * r8.y);
793
+ let v_214 = fma(r8.yyy, cb3_3.tint_symbol_2[23u].xyz, r9.xyz);
794
+ r9 = vec4<f32>(v_214.xyz, r9.w);
795
+ }
796
+ }
797
+ if ((bitcast<u32>(r6.w) != 0u)) {
798
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
799
+ } else {
800
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (5i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
801
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
802
+ if ((bitcast<u32>(r6.w) != 0u)) {
803
+ } else {
804
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[24u].w == 0.0f)));
805
+ let v_215 = (v_19.xyz + cb3_3.tint_symbol_2[8u].xyz);
806
+ r11 = vec4<f32>(v_215.xyz, r11.w);
807
+ let v_216 = (v6.xyz + (-(cb3_3.tint_symbol_2[8u].xyzx)).xyz);
808
+ r12 = vec4<f32>(v_216.xyz, r12.w);
809
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[16u].xyz);
810
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[24u].wwww)).w, 0.0f, 1.0f);
811
+ r9.w = (r9.w * cb3_3.tint_symbol_2[24u].w);
812
+ let v_217 = fma(cb3_3.tint_symbol_2[16u].xyz, r9.www, cb3_3.tint_symbol_2[8u].xyz);
813
+ r12 = vec4<f32>(v_217.xyz, r12.w);
814
+ let v_218 = (r12.xyz + v_19.xyz);
815
+ r12 = vec4<f32>(v_218.xyz, r12.w);
816
+ let v_219 = bitcast<vec3<u32>>(r8.yyy);
817
+ let v_220 = r11.xyz;
818
+ let v_221 = select(r12.xyz, v_220, (v_219 != vec3<u32>()));
819
+ r11 = vec4<f32>(v_221.xyz, r11.w);
820
+ r8.y = dot(r11.xyz, r11.xyz);
821
+ let v_222 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
822
+ r11 = vec4<f32>(v_222.xyz, r11.w);
823
+ r9.w = dot(r11.xyz, r11.xyz);
824
+ r9.w = inverseSqrt(r9.w);
825
+ let v_223 = (r9.www * r11.xyz);
826
+ r11 = vec4<f32>(v_223.xyz, r11.w);
827
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[8u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
828
+ r9.w = ((-(cb3_3.tint_symbol_2[16u].wwww)).w + 1.0f);
829
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[16u].w);
830
+ r8.y = (r8.y / r9.w);
831
+ let v_224 = -(cb3_3.tint_symbol_2[16u].xyzx);
832
+ r9.w = dot(r11.xyz, v_224.xyz);
833
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[32u].xxxx, cb3_3.tint_symbol_2[40u].xxxx).w, 0.0f, 1.0f);
834
+ let v_225 = dot(r11.xyz, r2.xyz);
835
+ r10.w = clamp(vec4<f32>(v_225, v_225, v_225, v_225).w, 0.0f, 1.0f);
836
+ r9.w = (r9.w * r10.w);
837
+ r10.w = (r8.y * r9.w);
838
+ let v_226 = (r10.www * cb3_3.tint_symbol_2[24u].xyz);
839
+ r12 = vec4<f32>(v_226.xyz, r12.w);
840
+ let v_227 = fma(r12.xyz, r0.xyz, r10.xyz);
841
+ r10 = vec4<f32>(v_227.xyz, r10.w);
842
+ let v_228 = fma(r4.xyz, r2.www, r11.xyz);
843
+ r11 = vec4<f32>(v_228.xyz, r11.w);
844
+ r10.w = dot(r11.xyz, r11.xyz);
845
+ r10.w = inverseSqrt(r10.w);
846
+ let v_229 = (r10.www * r11.xyz);
847
+ r11 = vec4<f32>(v_229.xyz, r11.w);
848
+ let v_230 = dot(r11.xyz, r5.xyz);
849
+ r10.w = clamp(vec4<f32>(v_230, v_230, v_230, v_230).w, 0.0f, 1.0f);
850
+ r10.w = ((-(r10.wwww)).w + 1.0f);
851
+ r11.w = (r10.w * r10.w);
852
+ r11.w = (r11.w * r11.w);
853
+ r10.w = (r10.w * r11.w);
854
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
855
+ let v_231 = dot(r11.xyz, r2.xyz);
856
+ r11.x = clamp(vec4<f32>(v_231, v_231, v_231, v_231).x, 0.0f, 1.0f);
857
+ r11.x = log2(r11.x);
858
+ r11.x = (r8.w * r11.x);
859
+ r11.x = exp2(r11.x);
860
+ r10.w = (r10.w * r11.x);
861
+ r9.w = (r9.w * r10.w);
862
+ r8.y = (r8.y * r9.w);
863
+ r8.y = (r8.z * r8.y);
864
+ let v_232 = fma(r8.yyy, cb3_3.tint_symbol_2[24u].xyz, r9.xyz);
865
+ r9 = vec4<f32>(v_232.xyz, r9.w);
866
+ }
867
+ }
868
+ if ((bitcast<u32>(r6.w) != 0u)) {
869
+ r6.w = bitcast<f32>(v.tint_symbol_6[3i].x);
870
+ } else {
871
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (6i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
872
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
873
+ if ((bitcast<u32>(r6.w) != 0u)) {
874
+ } else {
875
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[25u].w == 0.0f)));
876
+ let v_233 = (v_19.xyz + cb3_3.tint_symbol_2[9u].xyz);
877
+ r11 = vec4<f32>(v_233.xyz, r11.w);
878
+ let v_234 = (v6.xyz + (-(cb3_3.tint_symbol_2[9u].xyzx)).xyz);
879
+ r12 = vec4<f32>(v_234.xyz, r12.w);
880
+ r9.w = dot(r12.xyz, cb3_3.tint_symbol_2[17u].xyz);
881
+ r9.w = clamp(((r9.wwww / cb3_3.tint_symbol_2[25u].wwww)).w, 0.0f, 1.0f);
882
+ r9.w = (r9.w * cb3_3.tint_symbol_2[25u].w);
883
+ let v_235 = fma(cb3_3.tint_symbol_2[17u].xyz, r9.www, cb3_3.tint_symbol_2[9u].xyz);
884
+ r12 = vec4<f32>(v_235.xyz, r12.w);
885
+ let v_236 = (r12.xyz + v_19.xyz);
886
+ r12 = vec4<f32>(v_236.xyz, r12.w);
887
+ let v_237 = bitcast<vec3<u32>>(r8.yyy);
888
+ let v_238 = r11.xyz;
889
+ let v_239 = select(r12.xyz, v_238, (v_237 != vec3<u32>()));
890
+ r11 = vec4<f32>(v_239.xyz, r11.w);
891
+ r8.y = dot(r11.xyz, r11.xyz);
892
+ let v_240 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
893
+ r11 = vec4<f32>(v_240.xyz, r11.w);
894
+ r9.w = dot(r11.xyz, r11.xyz);
895
+ r9.w = inverseSqrt(r9.w);
896
+ let v_241 = (r9.www * r11.xyz);
897
+ r11 = vec4<f32>(v_241.xyz, r11.w);
898
+ r8.y = clamp(fma(-(r8.yyyy), cb3_3.tint_symbol_2[9u].wwww, vec4<f32>(1.0f)).y, 0.0f, 1.0f);
899
+ r9.w = ((-(cb3_3.tint_symbol_2[17u].wwww)).w + 1.0f);
900
+ r9.w = fma(r9.w, r8.y, cb3_3.tint_symbol_2[17u].w);
901
+ r8.y = (r8.y / r9.w);
902
+ let v_242 = -(cb3_3.tint_symbol_2[17u].xyzx);
903
+ r9.w = dot(r11.xyz, v_242.xyz);
904
+ r9.w = clamp(fma(r9.wwww, cb3_3.tint_symbol_2[33u].xxxx, cb3_3.tint_symbol_2[41u].xxxx).w, 0.0f, 1.0f);
905
+ let v_243 = dot(r11.xyz, r2.xyz);
906
+ r10.w = clamp(vec4<f32>(v_243, v_243, v_243, v_243).w, 0.0f, 1.0f);
907
+ r9.w = (r9.w * r10.w);
908
+ r10.w = (r8.y * r9.w);
909
+ let v_244 = (r10.www * cb3_3.tint_symbol_2[25u].xyz);
910
+ r12 = vec4<f32>(v_244.xyz, r12.w);
911
+ let v_245 = fma(r12.xyz, r0.xyz, r10.xyz);
912
+ r10 = vec4<f32>(v_245.xyz, r10.w);
913
+ let v_246 = fma(r4.xyz, r2.www, r11.xyz);
914
+ r11 = vec4<f32>(v_246.xyz, r11.w);
915
+ r10.w = dot(r11.xyz, r11.xyz);
916
+ r10.w = inverseSqrt(r10.w);
917
+ let v_247 = (r10.www * r11.xyz);
918
+ r11 = vec4<f32>(v_247.xyz, r11.w);
919
+ let v_248 = dot(r11.xyz, r5.xyz);
920
+ r10.w = clamp(vec4<f32>(v_248, v_248, v_248, v_248).w, 0.0f, 1.0f);
921
+ r10.w = ((-(r10.wwww)).w + 1.0f);
922
+ r11.w = (r10.w * r10.w);
923
+ r11.w = (r11.w * r11.w);
924
+ r10.w = (r10.w * r11.w);
925
+ r10.w = fma(cb12_12.tint_symbol_4[0u].x, r10.w, r7.w);
926
+ let v_249 = dot(r11.xyz, r2.xyz);
927
+ r11.x = clamp(vec4<f32>(v_249, v_249, v_249, v_249).x, 0.0f, 1.0f);
928
+ r11.x = log2(r11.x);
929
+ r11.x = (r8.w * r11.x);
930
+ r11.x = exp2(r11.x);
931
+ r10.w = (r10.w * r11.x);
932
+ r9.w = (r9.w * r10.w);
933
+ r8.y = (r8.y * r9.w);
934
+ r8.y = (r8.z * r8.y);
935
+ let v_250 = fma(r8.yyy, cb3_3.tint_symbol_2[25u].xyz, r9.xyz);
936
+ r9 = vec4<f32>(v_250.xyz, r9.w);
937
+ }
938
+ }
939
+ if ((bitcast<u32>(r6.w) != 0u)) {
940
+ } else {
941
+ r8.y = bitcast<f32>(select(0u, 4294967295u, (7i >= bitcast<i32>(cb3_3.tint_symbol_2[2u].x))));
942
+ r6.w = bitcast<f32>((bitcast<u32>(r6.w) | bitcast<u32>(r8.y)));
943
+ if ((bitcast<u32>(r6.w) != 0u)) {
944
+ } else {
945
+ r6.w = bitcast<f32>(select(0u, 4294967295u, (cb3_3.tint_symbol_2[26u].w == 0.0f)));
946
+ let v_251 = (v_19.xyz + cb3_3.tint_symbol_2[10u].xyz);
947
+ r11 = vec4<f32>(v_251.xyz, r11.w);
948
+ let v_252 = (v6.xyz + (-(cb3_3.tint_symbol_2[10u].xyzx)).xyz);
949
+ r12 = vec4<f32>(v_252.xyz, r12.w);
950
+ r8.y = dot(r12.xyz, cb3_3.tint_symbol_2[18u].xyz);
951
+ r8.y = clamp(((r8.yyyy / cb3_3.tint_symbol_2[26u].wwww)).y, 0.0f, 1.0f);
952
+ r8.y = (r8.y * cb3_3.tint_symbol_2[26u].w);
953
+ let v_253 = fma(cb3_3.tint_symbol_2[18u].xyz, r8.yyy, cb3_3.tint_symbol_2[10u].xyz);
954
+ r12 = vec4<f32>(v_253.xyz, r12.w);
955
+ let v_254 = (r12.xyz + v_19.xyz);
956
+ r12 = vec4<f32>(v_254.xyz, r12.w);
957
+ let v_255 = bitcast<vec3<u32>>(r6.www);
958
+ let v_256 = r11.xyz;
959
+ let v_257 = select(r12.xyz, v_256, (v_255 != vec3<u32>()));
960
+ r11 = vec4<f32>(v_257.xyz, r11.w);
961
+ r6.w = dot(r11.xyz, r11.xyz);
962
+ let v_258 = (r11.xyz + vec3<f32>(0.00000099999999747524f));
963
+ r11 = vec4<f32>(v_258.xyz, r11.w);
964
+ r8.y = dot(r11.xyz, r11.xyz);
965
+ r8.y = inverseSqrt(r8.y);
966
+ let v_259 = (r8.yyy * r11.xyz);
967
+ r11 = vec4<f32>(v_259.xyz, r11.w);
968
+ r6.w = clamp(fma(-(r6.wwww), cb3_3.tint_symbol_2[10u].wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
969
+ r8.y = ((-(cb3_3.tint_symbol_2[18u].wwww)).y + 1.0f);
970
+ r8.y = fma(r8.y, r6.w, cb3_3.tint_symbol_2[18u].w);
971
+ r6.w = (r6.w / r8.y);
972
+ let v_260 = -(cb3_3.tint_symbol_2[18u].xyzx);
973
+ r8.y = dot(r11.xyz, v_260.xyz);
974
+ r8.y = clamp(fma(r8.yyyy, cb3_3.tint_symbol_2[34u].xxxx, cb3_3.tint_symbol_2[42u].xxxx).y, 0.0f, 1.0f);
975
+ let v_261 = dot(r11.xyz, r2.xyz);
976
+ r9.w = clamp(vec4<f32>(v_261, v_261, v_261, v_261).w, 0.0f, 1.0f);
977
+ r8.y = (r8.y * r9.w);
978
+ r9.w = (r6.w * r8.y);
979
+ let v_262 = (r9.www * cb3_3.tint_symbol_2[26u].xyz);
980
+ r12 = vec4<f32>(v_262.xyz, r12.w);
981
+ let v_263 = fma(r12.xyz, r0.xyz, r10.xyz);
982
+ r10 = vec4<f32>(v_263.xyz, r10.w);
983
+ let v_264 = fma(r4.xyz, r2.www, r11.xyz);
984
+ r4 = vec4<f32>(v_264.xyz, r4.w);
985
+ r2.w = dot(r4.xyz, r4.xyz);
986
+ r2.w = inverseSqrt(r2.w);
987
+ let v_265 = (r2.www * r4.xyz);
988
+ r4 = vec4<f32>(v_265.xyz, r4.w);
989
+ let v_266 = dot(r4.xyz, r5.xyz);
990
+ r2.w = clamp(vec4<f32>(v_266, v_266, v_266, v_266).w, 0.0f, 1.0f);
991
+ r2.w = ((-(r2.wwww)).w + 1.0f);
992
+ r5.x = (r2.w * r2.w);
993
+ r5.x = (r5.x * r5.x);
994
+ r2.w = (r2.w * r5.x);
995
+ r2.w = fma(cb12_12.tint_symbol_4[0u].x, r2.w, r7.w);
996
+ let v_267 = dot(r4.xyz, r2.xyz);
997
+ r4.x = clamp(vec4<f32>(v_267, v_267, v_267, v_267).x, 0.0f, 1.0f);
998
+ r4.x = log2(r4.x);
999
+ r4.x = (r4.x * r8.w);
1000
+ r4.x = exp2(r4.x);
1001
+ r2.w = (r2.w * r4.x);
1002
+ r2.w = (r8.y * r2.w);
1003
+ r2.w = (r6.w * r2.w);
1004
+ r2.w = (r8.z * r2.w);
1005
+ let v_268 = fma(r2.www, cb3_3.tint_symbol_2[26u].xyz, r9.xyz);
1006
+ r9 = vec4<f32>(v_268.xyz, r9.w);
1007
+ }
1008
+ }
1009
+ r2.w = (r8.x * r8.x);
1010
+ r3.w = (r3.w * r3.w);
1011
+ let v_269 = (r9.xyz * r3.www);
1012
+ r4 = vec4<f32>(v_269.xyz, r4.w);
1013
+ let v_270 = fma(r2.www, r10.xyz, r4.xyz);
1014
+ r4 = vec4<f32>(v_270.xyz, r4.w);
1015
+ let v_271 = fma(r6.xyz, r5.www, r4.xyz);
1016
+ r4 = vec4<f32>(v_271.xyz, r4.w);
1017
+ r1.z = fma(r1.z, r1.w, cb3_3.tint_symbol_2[43u].w);
1018
+ r1.z = (r1.z * cb3_3.tint_symbol_2[44u].w);
1019
+ r1.z = max(r1.z, 0.0f);
1020
+ let v_272 = fma(cb3_3.tint_symbol_2[47u].xyz, r1.zzz, cb3_3.tint_symbol_2[48u].xyz);
1021
+ r5 = vec4<f32>(v_272.xyz, r5.w);
1022
+ r1.w = ((-(cb2_2.tint_symbol_1[16u].zzzz)).w + 1.0f);
1023
+ let v_273 = fma(cb3_3.tint_symbol_2[45u].xyz, r1.zzz, cb3_3.tint_symbol_2[46u].xyz);
1024
+ r6 = vec4<f32>(v_273.xyz, r6.w);
1025
+ let v_274 = (r6.xyz * cb2_2.tint_symbol_1[16u].zzz);
1026
+ r6 = vec4<f32>(v_274.xyz, r6.w);
1027
+ let v_275 = fma(r5.xyz, r1.www, r6.xyz);
1028
+ r5 = vec4<f32>(v_275.xyz, r5.w);
1029
+ let v_276 = (r1.yyy * r5.xyz);
1030
+ r5 = vec4<f32>(v_276.xyz, r5.w);
1031
+ let v_277 = fma(cb3_3.tint_symbol_2[43u].xyz, r1.zzz, cb3_3.tint_symbol_2[44u].xyz);
1032
+ r6 = vec4<f32>(v_277.xyz, r6.w);
1033
+ r9.x = cb3_3.tint_symbol_2[46u].w;
1034
+ r9.y = cb3_3.tint_symbol_2[47u].w;
1035
+ r9.z = cb3_3.tint_symbol_2[48u].w;
1036
+ let v_278 = dot(r9.xyz, r2.xyz);
1037
+ r1.z = clamp(vec4<f32>(v_278, v_278, v_278, v_278).z, 0.0f, 1.0f);
1038
+ let v_279 = fma(cb3_3.tint_symbol_2[49u].xyz, r1.zzz, r6.xyz);
1039
+ r2 = vec4<f32>(v_279.xyz, r2.w);
1040
+ let v_280 = fma(r2.xyz, r1.xxx, r5.xyz);
1041
+ r2 = vec4<f32>(v_280.xyz, r2.w);
1042
+ let v_281 = (r8.xxx * r2.xyz);
1043
+ r2 = vec4<f32>(v_281.xyz, r2.w);
1044
+ let v_282 = fma(r2.xyz, r0.xyz, r4.xyz);
1045
+ r0 = vec4<f32>(v_282.xyz, r0.w);
1046
+ r1.z = ((-(r8.xxxx)).z + 1.0f);
1047
+ r1.x = max(r1.y, r1.x);
1048
+ let v_283 = (r1.xxx * r3.xyz);
1049
+ r1 = vec4<f32>(v_283.xy, r1.z, v_283.z);
1050
+ r2.x = clamp(((r4.wwww * vec4<f32>(0.00177619897294789553f))).x, 0.0f, 1.0f);
1051
+ let v_284 = (r1.xyw * r2.xxx);
1052
+ r2 = vec4<f32>(v_284.xyz, r2.w);
1053
+ let v_285 = (r2.xyz * vec3<f32>(0.68169009685516357422f));
1054
+ r2 = vec4<f32>(v_285.xyz, r2.w);
1055
+ let v_286 = fma(r1.xyw, vec3<f32>(0.31830990314483642578f), r2.xyz);
1056
+ r1 = vec4<f32>(v_286.xy, r1.z, v_286.z);
1057
+ let v_287 = fma(r1.xyw, r1.zzz, r0.xyz);
1058
+ r0 = vec4<f32>(v_287.xyz, r0.w);
1059
+ o0.w = (r0.w * cb2_2.tint_symbol_1[15u].x);
1060
+ if ((bitcast<u32>(cb5_5.tint_symbol_3[7u].x) != 0u)) {
1061
+ r0.w = dot(r7.xyz, r7.xyz);
1062
+ r1.x = sqrt(r0.w);
1063
+ let v_288 = -(cb3_3.tint_symbol_2[50u].xxxx);
1064
+ r1.y = (r1.x + v_288.y);
1065
+ r1.y = max(r1.y, 0.0f);
1066
+ r1.x = (r1.y / r1.x);
1067
+ r1.x = (r1.x * r7.z);
1068
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].z);
1069
+ r1.x = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.xxxx).x)));
1070
+ r1.w = (r1.z * -1.44269502162933349609f);
1071
+ r1.w = exp2(r1.w);
1072
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1073
+ r1.z = (r1.w / r1.z);
1074
+ let v_289 = bitcast<u32>(r1.x);
1075
+ r1.x = select(1.0f, r1.z, (v_289 != 0u));
1076
+ r1.z = (r1.y * cb3_3.tint_symbol_2[51u].w);
1077
+ r1.x = (r1.x * r1.z);
1078
+ r1.x = min(r1.x, 1.0f);
1079
+ r1.x = (r1.x * 1.44269502162933349609f);
1080
+ r1.x = exp2(r1.x);
1081
+ r1.x = min(r1.x, 1.0f);
1082
+ r1.x = ((-(r1.xxxx)).x + 1.0f);
1083
+ r1.z = (r1.x * cb3_3.tint_symbol_2[52u].y);
1084
+ r0.w = inverseSqrt(r0.w);
1085
+ let v_290 = (r0.www * r7.xyz);
1086
+ r2 = vec4<f32>(v_290.xyz, r2.w);
1087
+ let v_291 = dot(r2.xyz, cb3_3.tint_symbol_2[54u].xyz);
1088
+ r0.w = clamp(vec4<f32>(v_291, v_291, v_291, v_291).w, 0.0f, 1.0f);
1089
+ r0.w = log2(r0.w);
1090
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1091
+ r0.w = exp2(r0.w);
1092
+ let v_292 = dot(r2.xyz, cb3_3.tint_symbol_2[53u].xyz);
1093
+ r1.w = clamp(vec4<f32>(v_292, v_292, v_292, v_292).w, 0.0f, 1.0f);
1094
+ r1.w = log2(r1.w);
1095
+ r1.w = (r1.w * cb3_3.tint_symbol_2[53u].w);
1096
+ r1.w = exp2(r1.w);
1097
+ r1.x = fma((-(r1.xxxx)).x, cb3_3.tint_symbol_2[52u].y, 1.0f);
1098
+ r1.x = (r1.x * cb3_3.tint_symbol_2[51u].y);
1099
+ let v_293 = -(cb3_3.tint_symbol_2[52u].xxxx);
1100
+ r2.x = (r1.y + v_293.x);
1101
+ r2.x = max(r2.x, 0.0f);
1102
+ r2.x = (r2.x * cb3_3.tint_symbol_2[51u].x);
1103
+ r2.x = (r2.x * 1.44269502162933349609f);
1104
+ r2.x = exp2(r2.x);
1105
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1106
+ r1.z = clamp(fma(r1.xxxx, r2.xxxx, r1.zzzz).z, 0.0f, 1.0f);
1107
+ let v_294 = -(cb3_3.tint_symbol_2[51u].zzzz);
1108
+ r1.y = (r1.y * v_294.y);
1109
+ r1.y = (r1.y * 1.44269502162933349609f);
1110
+ r1.y = exp2(r1.y);
1111
+ r1.y = ((-(r1.yyyy)).y + 1.0f);
1112
+ let v_295 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1113
+ r2 = vec4<f32>(v_295.xyz, r2.w);
1114
+ let v_296 = fma(r0.www, r2.xyz, cb3_3.tint_symbol_2[56u].xyz);
1115
+ r2 = vec4<f32>(v_296.xyz, r2.w);
1116
+ let v_297 = ((-(r2.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1117
+ r3 = vec4<f32>(v_297.xyz, r3.w);
1118
+ let v_298 = fma(r1.www, r3.xyz, r2.xyz);
1119
+ r2 = vec4<f32>(v_298.xyz, r2.w);
1120
+ let v_299 = -(cb3_3.tint_symbol_2[57u].xyzx);
1121
+ let v_300 = (r2.xyz + v_299.xyz);
1122
+ r2 = vec4<f32>(v_300.xyz, r2.w);
1123
+ let v_301 = fma(r1.yyy, r2.xyz, cb3_3.tint_symbol_2[57u].xyz);
1124
+ r2 = vec4<f32>(v_301.xyz, r2.w);
1125
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1126
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1127
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1128
+ let v_302 = ((-(r2.xyzx)).xyz + r3.xyz);
1129
+ r3 = vec4<f32>(v_302.xyz, r3.w);
1130
+ let v_303 = fma(r1.xxx, r3.xyz, r2.xyz);
1131
+ r1 = vec4<f32>(v_303.xy, r1.z, v_303.z);
1132
+ r0.w = bitcast<f32>(select(0u, 4294967295u, (0.0f < cb2_2.tint_symbol_1[22u].y)));
1133
+ if ((bitcast<u32>(r0.w) != 0u)) {
1134
+ let v_304 = (v7.xy * cb2_2.tint_symbol_1[18u].zw);
1135
+ r2 = vec4<f32>(v_304.xy, r2.zw);
1136
+ r2 = textureSample(t11, s11, r2.xyxx.xy);
1137
+ r0.w = (r2.x + -1.0f);
1138
+ r0.w = clamp(fma(cb2_2.tint_symbol_1[22u].yyyy, r0.wwww, vec4<f32>(1.0f)).w, 0.0f, 1.0f);
1139
+ } else {
1140
+ r0.w = 1.0f;
1141
+ }
1142
+ let v_305 = -(r0.xyxz);
1143
+ let v_306 = fma(r1.xyw, r0.www, v_305.xyw);
1144
+ r1 = vec4<f32>(v_306.xy, r1.z, v_306.z);
1145
+ let v_307 = fma(r1.zzz, r1.xyw, r0.xyz);
1146
+ r1 = vec4<f32>(v_307.xyz, r1.w);
1147
+ } else {
1148
+ r0.w = dot(r7.xyz, r7.xyz);
1149
+ r1.w = sqrt(r0.w);
1150
+ let v_308 = -(cb3_3.tint_symbol_2[50u].xxxx);
1151
+ r2.x = (r1.w + v_308.x);
1152
+ r2.x = max(r2.x, 0.0f);
1153
+ r1.w = (r2.x / r1.w);
1154
+ r1.w = (r1.w * r7.z);
1155
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].z);
1156
+ r1.w = bitcast<f32>(select(0u, 4294967295u, (0.00999999977648258209f < abs(r1.wwww).w)));
1157
+ r2.z = (r2.y * -1.44269502162933349609f);
1158
+ r2.z = exp2(r2.z);
1159
+ r2.z = ((-(r2.zzzz)).z + 1.0f);
1160
+ r2.y = (r2.z / r2.y);
1161
+ let v_309 = bitcast<u32>(r1.w);
1162
+ r1.w = select(1.0f, r2.y, (v_309 != 0u));
1163
+ r2.y = (r2.x * cb3_3.tint_symbol_2[51u].w);
1164
+ r1.w = (r1.w * r2.y);
1165
+ r1.w = min(r1.w, 1.0f);
1166
+ r1.w = (r1.w * 1.44269502162933349609f);
1167
+ r1.w = exp2(r1.w);
1168
+ r1.w = min(r1.w, 1.0f);
1169
+ r1.w = ((-(r1.wwww)).w + 1.0f);
1170
+ r2.y = (r1.w * cb3_3.tint_symbol_2[52u].y);
1171
+ r0.w = inverseSqrt(r0.w);
1172
+ let v_310 = (r0.www * r7.xyz);
1173
+ r3 = vec4<f32>(v_310.xyz, r3.w);
1174
+ let v_311 = dot(r3.xyz, cb3_3.tint_symbol_2[54u].xyz);
1175
+ r0.w = clamp(vec4<f32>(v_311, v_311, v_311, v_311).w, 0.0f, 1.0f);
1176
+ r0.w = log2(r0.w);
1177
+ r0.w = (r0.w * cb3_3.tint_symbol_2[54u].w);
1178
+ r0.w = exp2(r0.w);
1179
+ let v_312 = dot(r3.xyz, cb3_3.tint_symbol_2[53u].xyz);
1180
+ r2.z = clamp(vec4<f32>(v_312, v_312, v_312, v_312).z, 0.0f, 1.0f);
1181
+ r2.z = log2(r2.z);
1182
+ r2.z = (r2.z * cb3_3.tint_symbol_2[53u].w);
1183
+ r2.z = exp2(r2.z);
1184
+ r1.w = fma((-(r1.wwww)).w, cb3_3.tint_symbol_2[52u].y, 1.0f);
1185
+ r1.w = (r1.w * cb3_3.tint_symbol_2[51u].y);
1186
+ let v_313 = -(cb3_3.tint_symbol_2[52u].xxxx);
1187
+ r2.w = (r2.x + v_313.w);
1188
+ r2.w = max(r2.w, 0.0f);
1189
+ r2.w = (r2.w * cb3_3.tint_symbol_2[51u].x);
1190
+ r2.w = (r2.w * 1.44269502162933349609f);
1191
+ r2.w = exp2(r2.w);
1192
+ r2.w = ((-(r2.wwww)).w + 1.0f);
1193
+ r2.y = clamp(fma(r1.wwww, r2.wwww, r2.yyyy).y, 0.0f, 1.0f);
1194
+ let v_314 = -(cb3_3.tint_symbol_2[51u].zzzz);
1195
+ r2.x = (r2.x * v_314.x);
1196
+ r2.x = (r2.x * 1.44269502162933349609f);
1197
+ r2.x = exp2(r2.x);
1198
+ r2.x = ((-(r2.xxxx)).x + 1.0f);
1199
+ let v_315 = ((-(cb3_3.tint_symbol_2[56u].xyzx)).xyz + cb3_3.tint_symbol_2[58u].xyz);
1200
+ r3 = vec4<f32>(v_315.xyz, r3.w);
1201
+ let v_316 = fma(r0.www, r3.xyz, cb3_3.tint_symbol_2[56u].xyz);
1202
+ r3 = vec4<f32>(v_316.xyz, r3.w);
1203
+ let v_317 = ((-(r3.xyzx)).xyz + cb3_3.tint_symbol_2[55u].xyz);
1204
+ r4 = vec4<f32>(v_317.xyz, r4.w);
1205
+ let v_318 = fma(r2.zzz, r4.xyz, r3.xyz);
1206
+ r3 = vec4<f32>(v_318.xyz, r3.w);
1207
+ let v_319 = -(cb3_3.tint_symbol_2[57u].xyzx);
1208
+ let v_320 = (r3.xyz + v_319.xyz);
1209
+ r3 = vec4<f32>(v_320.xyz, r3.w);
1210
+ let v_321 = fma(r2.xxx, r3.xyz, cb3_3.tint_symbol_2[57u].xyz);
1211
+ r2 = vec4<f32>(v_321.x, r2.y, v_321.yz);
1212
+ r3.x = cb3_3.tint_symbol_2[55u].w;
1213
+ r3.y = cb3_3.tint_symbol_2[56u].w;
1214
+ r3.z = cb3_3.tint_symbol_2[57u].w;
1215
+ let v_322 = ((-(r2.xzwx)).xyz + r3.xyz);
1216
+ r3 = vec4<f32>(v_322.xyz, r3.w);
1217
+ let v_323 = fma(r1.www, r3.xyz, r2.xzw);
1218
+ r2 = vec4<f32>(v_323.x, r2.y, v_323.yz);
1219
+ let v_324 = ((-(r0.xxyz)).xzw + r2.xzw);
1220
+ r2 = vec4<f32>(v_324.x, r2.y, v_324.yz);
1221
+ let v_325 = fma(r2.yyy, r2.xzw, r0.xyz);
1222
+ r1 = vec4<f32>(v_325.xyz, r1.w);
1223
+ }
1224
+ let v_326 = (r1.xyz * cb2_2.tint_symbol_1[17u].zzz);
1225
+ o0 = vec4<f32>(v_326.xyz, o0.w);
1226
+ }
1227
+
1228
+ fn v_3(v_327 : bool) {
1229
+ if (v_327) {
1230
+ discard;
1231
+ return;
1232
+ }
1233
+ }
1234
+
1235
+ @fragment
1236
+ fn main(@location(0u) v0 : vec4<f32>, @location(1u) v1 : vec4<f32>, @location(2u) v2 : vec4<f32>, @location(3u) v3 : vec4<f32>, @location(4u) v4 : vec4<f32>, @location(5u) v5 : vec4<f32>, @location(6u) v6 : vec4<f32>, @builtin(position) v_328 : vec4<f32>) -> @location(0u) vec4<f32> {
1237
+ main_inner(v0, v1, v2, v3, v4, v5, v6, v_328);
1238
+ return o0;
1239
+ }