From e15c13b6caffca910a8fddd6d9ec59ab405083bb Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Fri, 31 Jul 2026 23:29:22 +0000 Subject: [PATCH 1/7] Clear every @UF table at the end of each maintenance run The union-find's only readers are the maintenance rules: path compression, the rebuild rules driven by a @UF delta, and the container rebuild primitive. Once the rebuild loop saturates, every row a query, delete, or subsume can reach is canonical, so the edges that got it there are dead. Drop them, so the next iteration's rebuild reads only its own unions. A @uf_clear ruleset holds one :naive delete-everything rule per eq-sort and runs last in the maintenance schedule. Set EGGLOG_UF_CLEAR=0 to keep every edge, which restores the previous encoding byte for byte. Co-Authored-By: Claude Opus 5 --- egglog/src/proofs/proof_encoding.rs | 30 +++++++++++++++++++-- egglog/src/proofs/proof_encoding_helpers.rs | 21 +++++++++++++-- 2 files changed, 47 insertions(+), 4 deletions(-) diff --git a/egglog/src/proofs/proof_encoding.rs b/egglog/src/proofs/proof_encoding.rs index 4c674fb8..07bbcf00 100644 --- a/egglog/src/proofs/proof_encoding.rs +++ b/egglog/src/proofs/proof_encoding.rs @@ -1,6 +1,6 @@ #[doc = include_str!("proof_encoding.md")] use crate::proofs::proof_encoding_helpers::{ - Composition, EncodingNames, HeadColumn, Justification, Skeleton, + Composition, EncodingNames, HeadColumn, Justification, Skeleton, uf_clear_enabled, }; use crate::proofs::proof_head::{ HeadPlan, HeadPosition, HeadProof, HeadRun, ProofAlgebra, ProofSite, constructor_operand, @@ -736,6 +736,22 @@ impl<'a> ProofInstrumentor<'a> { (String::new(), "()".to_string()) }; + // Under the clear knob, every edge of this table is dropped once maintenance + // has finished consuming it. `:naive` because the ruleset's own delta is + // empty on the run that must see the whole table. + let clear_rule = if uf_clear_enabled() { + let clear_name = self.egraph.parser.symbol_gen.fresh("uf_clear_rule"); + let clear_ruleset = self.proof_names().uf_clear_ruleset_name.clone(); + format!( + "(rule ((= (values {b} {pb}) ({uf_name} {a}))) + ((delete ({uf_name} {a}))) + :ruleset {clear_ruleset} :naive :name \"{clear_name}\") + " + ) + } else { + String::new() + }; + let code = format!( "{packed_decl}{proof_tables} (function {uf_name} ({sort_name}) ({sort_name} {proof_type}) :merge {uf_merge} :unextractable :internal-hidden :internal-identity-vals 1) @@ -746,6 +762,7 @@ impl<'a> ProofInstrumentor<'a> { (set ({uf_name} {a}) (values {c} {compressed_proof}))) :ruleset {path_compress_ruleset_name} :name \"{fresh_name}\") + {clear_rule} " ); @@ -2033,13 +2050,22 @@ impl<'a> ProofInstrumentor<'a> { let delete_ruleset = self.proof_names().delete_subsume_ruleset_name.clone(); // The `@UF` `:merge` resolves conflicting parents itself, so only // `path_compress` (flattening chains) remains as UF maintenance. + // + // The clear runs last, once the saturated rebuild has canonicalized every + // row that any later query, `delete`, or `subsume` can reach — so the edges + // it drops are ones nothing reads again. + let clear_step = if uf_clear_enabled() { + format!(" {}", self.proof_names().uf_clear_ruleset_name) + } else { + String::new() + }; self.parse_schedule(format!( "(seq (saturate {rebuilding_cleanup_ruleset} (saturate {path_compress_ruleset}) {rebuilding_ruleset}) - {delete_ruleset})" + {delete_ruleset}{clear_step})" )) } diff --git a/egglog/src/proofs/proof_encoding_helpers.rs b/egglog/src/proofs/proof_encoding_helpers.rs index 6f121736..c43cf8df 100644 --- a/egglog/src/proofs/proof_encoding_helpers.rs +++ b/egglog/src/proofs/proof_encoding_helpers.rs @@ -56,6 +56,7 @@ pub(crate) struct EncodingNames { pub(crate) rebuilding_ruleset_name: String, pub(crate) rebuilding_cleanup_ruleset_name: String, pub(crate) delete_subsume_ruleset_name: String, + pub(crate) uf_clear_ruleset_name: String, // Per-function fresh names pub(crate) view_name: HashMap, pub(crate) to_delete_name: HashMap, @@ -368,6 +369,7 @@ impl EncodingNames { rebuilding_ruleset_name: symbol_gen.fresh("rebuilding"), rebuilding_cleanup_ruleset_name: symbol_gen.fresh("rebuilding_cleanup"), delete_subsume_ruleset_name: symbol_gen.fresh("delete_subsume_ruleset"), + uf_clear_ruleset_name: symbol_gen.fresh("uf_clear"), view_name: HashMap::default(), to_delete_name: HashMap::default(), subsumed_name: HashMap::default(), @@ -376,6 +378,13 @@ impl EncodingNames { } } +/// Whether maintenance empties every `@UF_` table at the end of each run, +/// keeping only the edges a later iteration's rebuild will read. Set +/// `EGGLOG_UF_CLEAR=0` to keep every edge instead. +pub(crate) fn uf_clear_enabled() -> bool { + !matches!(std::env::var("EGGLOG_UF_CLEAR").as_deref(), Ok("0")) +} + impl ProofInstrumentor<'_> { pub(crate) fn uf_name(&mut self, sort: &str) -> String { if let Some(name) = self.egraph.proof_state.uf_parent.get(sort) { @@ -498,15 +507,23 @@ impl ProofInstrumentor<'_> { /// Header commands for term encoding, setting up rulesets. pub(crate) fn term_header(&mut self) -> Vec { + let uf_clear = if uf_clear_enabled() { + format!( + "\n (ruleset {})", + self.proof_names().uf_clear_ruleset_name + ) + } else { + String::new() + }; let str = format!( "(ruleset {}) (ruleset {}) (ruleset {}) - (ruleset {})", + (ruleset {}){uf_clear}", self.proof_names().path_compress_ruleset_name, self.proof_names().rebuilding_ruleset_name, self.proof_names().rebuilding_cleanup_ruleset_name, - self.proof_names().delete_subsume_ruleset_name + self.proof_names().delete_subsume_ruleset_name, ); self.parse_program(&str) } From f498e73663d67b2e8941fe32eb39f23033af8dab Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Fri, 31 Jul 2026 23:53:29 +0000 Subject: [PATCH 2/7] Measure the encoding's rebuild and search cost; make the @UF clear opt-in MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Clearing @UF each iteration is sound — 801 file tests pass with proof snapshots byte-identical — but it is not faster. The rebuild rule is :unsafe-seminaive, so its driving @UF atom already reads only the delta and the rows a clear drops are ones its join never visits. At 6 rounds it is 1.006x on math-microbenchmark and 1.027x with +43 MiB on eggcc-2mm-pass1: the clear costs +134 ms while @parent saves 27 ms. Time in @parent is 0.2-3% of wall, so a free clear could not win more. It also loses stale-value canonicalization, which find_canonical needs, and lets a rule re-deriving one union per iteration keep saturate from terminating. Now off unless EGGLOG_UF_CLEAR=1; the default encoding is unchanged byte for byte. rebuild_cost.md records that and what the search time is actually made of: the encoded rebuild is ~4.5x native's, native chooses its full-table-scan branch on 93-99.8% of rebuilds where the encoding can never scan, and the larger share of the gap on most files is in user rules rather than maintenance -- for reasons that are not join width, contrary to what the two desugared programs suggest. EGGLOG_REBUILD_TRACE=1 logs native's per-table rebuild branch and its inputs. Co-Authored-By: Claude Opus 5 --- egglog/core-relations/src/table/rebuild.rs | 16 ++ egglog/src/proofs/proof_encoding.md | 5 + egglog/src/proofs/proof_encoding_helpers.rs | 10 +- egglog/src/proofs/rebuild_cost.md | 159 ++++++++++++++++++++ 4 files changed, 188 insertions(+), 2 deletions(-) create mode 100644 egglog/src/proofs/rebuild_cost.md diff --git a/egglog/core-relations/src/table/rebuild.rs b/egglog/core-relations/src/table/rebuild.rs index e274c0ba..d1419807 100644 --- a/egglog/core-relations/src/table/rebuild.rs +++ b/egglog/core-relations/src/table/rebuild.rs @@ -60,6 +60,22 @@ impl SortedWritesTable { // Incremental rebuilds are possible if we can scan the subset of the columns that are // relevant. let to_scan = self.subset_tracker.recent_updates(table_id, table); + if std::env::var_os("EGGLOG_REBUILD_TRACE").is_some() { + log::info!( + "REBUILD_TRACE branch={} diff={} table_size={}", + if incremental_rebuild( + to_scan.size(), + self.data.next_row().index(), + parallelize_rebuild(to_scan.size()) + ) { + "incremental" + } else { + "fullscan" + }, + to_scan.size(), + self.data.next_row().index() + ); + } if incremental_rebuild( to_scan.size(), self.data.next_row().index(), diff --git a/egglog/src/proofs/proof_encoding.md b/egglog/src/proofs/proof_encoding.md index 378fe0a7..2bead2e5 100644 --- a/egglog/src/proofs/proof_encoding.md +++ b/egglog/src/proofs/proof_encoding.md @@ -290,6 +290,11 @@ lookup — and keep the `:naive` rule in [Containers](#containers). Subsumption markers (`@to_subsume_`) are re-keyed to their leaders by their own per-column rules, so a subsumed row stays subsumed after its children move. +This rule is always the incremental shape. Native instead picks per table, per +round, between that and scanning the whole table, and on the benchmark suite it +almost always scans. What that costs, and why emptying `@UF` each iteration does +not recover it, is measured in `rebuild_cost.md`. + # Globals *Before the term encoding*, [`crate::ast::remove_globals`] desugars every global diff --git a/egglog/src/proofs/proof_encoding_helpers.rs b/egglog/src/proofs/proof_encoding_helpers.rs index c43cf8df..06f4525c 100644 --- a/egglog/src/proofs/proof_encoding_helpers.rs +++ b/egglog/src/proofs/proof_encoding_helpers.rs @@ -380,9 +380,15 @@ impl EncodingNames { /// Whether maintenance empties every `@UF_` table at the end of each run, /// keeping only the edges a later iteration's rebuild will read. Set -/// `EGGLOG_UF_CLEAR=0` to keep every edge instead. +/// `EGGLOG_UF_CLEAR=1` to enable. +/// +/// Off by default because it does not pay: the rebuild rule already reads only +/// the `@UF` delta, so the rows this drops are ones its join never visits. It +/// also loses the ability to canonicalize a value from an earlier iteration, +/// which [`crate::extract::find_canonical`] needs, and lets a rule that +/// re-derives one union per iteration keep `saturate` from terminating. pub(crate) fn uf_clear_enabled() -> bool { - !matches!(std::env::var("EGGLOG_UF_CLEAR").as_deref(), Ok("0")) + matches!(std::env::var("EGGLOG_UF_CLEAR").as_deref(), Ok("1")) } impl ProofInstrumentor<'_> { diff --git a/egglog/src/proofs/rebuild_cost.md b/egglog/src/proofs/rebuild_cost.md new file mode 100644 index 00000000..17d66b47 --- /dev/null +++ b/egglog/src/proofs/rebuild_cost.md @@ -0,0 +1,159 @@ +# Where the encoding's rebuild time goes + +Measurements against `5cc4dc1` (PR #39's head), serial (`--threads 1`), release, +`bench.py` with 3–6 rounds per endpoint. Two questions: is clearing `@UF` every +iteration worth it, and what makes the encoded rebuild slower than native's. + +## Clearing `@UF` every iteration does not pay + +The union-find's only readers are the maintenance rules, so once the rebuild loop +saturates every row a query, `delete`, or `subsume` can reach is canonical and the +edges that got it there are dead. Deleting them is *sound* — with a +delete-everything ruleset running last in the maintenance schedule, all 801 +`--test files` cases pass and every proof snapshot is byte-identical. + +It is not *faster*, at 6 rounds: + +| | baseline | clear | ratio | +| --- | ---: | ---: | ---: | +| `math-microbenchmark` wall | 4483 ms | 4511 ms | 1.006 | +| `eggcc-2mm-pass1` wall | 9709 ms | 9971 ms | 1.027 | +| `eggcc-2mm-pass1` peak RSS | 525 MiB | 568 MiB | 1.082 | + +Per ruleset, the clear costs `+134 ms` while `@parent` saves `-27 ms`, and +`@rebuilding` does not move outside noise. The reason is that the rebuild rule is +`:unsafe-seminaive` and its driving `@UF` atom is therefore already restricted to +the delta: the rows a clear removes are ones the join never visits. `@parent` +joins `@UF` against itself, so its full side does shrink — which is the whole of +the measured win, and it is 0.6% of one benchmark. + +The ceiling is low regardless. Time in `@parent` on the baseline is 3.0% of wall +on `math-microbenchmark`, 1.2% on `herbie`, and 0.2% on `eggcc-2mm-pass1`, so a +clear that cost nothing could not win more than that. + +Two things also break, which is why the knob is off by default: + +- **Canonicalizing a value from an earlier iteration stops working.** + `find_canonical` and proof extraction's fall-back read `@UF` outside rebuilding + to resolve a value that predates this iteration. Surface syntax never needs it + (queries read views, which are canonical, and `(extract e)` interns `e` first), + but a Rust-API caller holding a `Value` across a union does, and native + resolves those. +- **`saturate` can stop terminating.** `(rule ((Same x y)) ((union x y)) :naive)` + under `(saturate ...)` terminates normally and hangs with the clear on: once + `x` and `y` are canonically equal the re-firing rule writes the self-edge + `v -> v`, which `:internal-identity-vals 1` normally makes an idempotent + no-op. After a clear the row is absent, so the re-`set` is a fresh insert and + the loop always reports a change. Adding `(!= x y)` fixes that program, and + suppressing self-edges at the source would fix the class — a `@UF` row whose + key is its own parent carries no information, since a term with no row is + already its own representative. + +A whole-table `clear_table` fast path (already present end to end, from +`Database::clear_table` through `EGraph::clear_function`) would remove the +`+134 ms` but not the reason there is nothing to win, and would not help the +termination case at all, where the change is reported by the re-*insert*. + +## The encoded rebuild is ~4.5x native's, and always takes the incremental branch + +Encoded proofs against native (`--treatment proofs` vs `off`), fastest of 3: + +| file | native | proofs | ratio | native rebuild | `@rebuilding`+`@parent` | +| --- | ---: | ---: | ---: | ---: | ---: | +| `math-microbenchmark` | 1035 ms | 4502 ms | 4.35x | 386 ms | 1679 ms | +| `eggcc-2mm-pass1` | 2717 ms | 9783 ms | 3.60x | 581 ms | 2682 ms | +| `herbie` | 130 ms | 564 ms | 4.34x | 5 ms | 47 ms | +| `hardboiled_conv1d_32` | 323 ms | 1127 ms | 3.49x | 0 ms | 33 ms | +| `luminal-llama` | 1120 ms | 8238 ms | 7.35x | 6 ms | 13 ms | + +Rebuild excess is 30–37% of the encoding's total overhead on the two files where +rebuilding matters, and search is the larger half of it: rebuild search on +`math-microbenchmark` is 890 ms, itself 2.3x native's entire rebuild. As a share +of all search time, maintenance is 79% on `math-microbenchmark`, 55% on `herbie`, +21% on `eggcc-2mm-pass1` — and 0.5% on `luminal-llama`, whose 7.35x is the worst +of the set and has nothing to do with rebuilding. + +Rebuild is not the whole of the search gap, and on most files it is not even the +larger part. Search time only, native against encoded: + +| file | native | encoded | of which user rules | of which maintenance | +| --- | ---: | ---: | ---: | ---: | +| `luminal-llama` | 28 ms | 1683 ms | **1674 ms** | 9 ms | +| `eggcc-2mm-pass1` | 1659 ms | 2933 ms | **2323 ms** | 609 ms | +| `hardboiled_conv1d_32` | ~0 ms | 317 ms | **300 ms** | 16 ms | +| `math-microbenchmark` | 221 ms | 1129 ms | 240 ms | **890 ms** | +| `herbie` | 16 ms | 42 ms | 19 ms | 23 ms | + +Maintenance dominates search on `math-microbenchmark` and `herbie` only. Elsewhere +the cost is in the rewritten *user* queries — most sharply on `luminal-llama`, +where encoded user-rule search is 60x native's entire search while its rebuild is +9 ms. Whatever the encoded rebuild is made to cost, that file does not improve. +The two are separate problems and the rest of this note is about the smaller one. + +The user-rule cost is **not** join width. Comparing the two desugared programs +suggests it is — `matmul_backend`'s bodies go from a median of 13 top-level forms +to 38 — but that comparison is invalid. `GenericExprExt::to_query` in `core.rs` +flattens every nested `Call` into one atom per subterm, so native's + +```text +(= ?cast (Op (Cast ?size (F32)) (ICons ?matmul (INil)))) +``` + +compiles to the same four atoms the encoding writes out longhand. Native's +desugared *text* keeps the nesting; the encoding's does not. On the rule +`"cublaslt bf16 matmul cast f32 output"` both come to eleven real atoms — +`Op`, `cublaslt`, four `Bf16`, `Op`, `Cast`, `F32`, `ICons`, `INil` — and the +encoding adds two `(= ?matmul )` aliases a compiler substitutes away. +Body shape and atom count therefore match, and the 60x is elsewhere. + +What differs per atom is that a view read binds a proof column as well as the +e-class, so every tuple is one column wider. That is not obviously a 60x. + +The leading untested explanation is rebuild churn feeding seminaive. The rebuild +rule `delete`s and re-`set`s a view row, and it does so per +`@UF`-delta-times-occurrence match rather than per row that actually moved, so one +firing rewrites a row whose canonical form may equal what was already there. Each +re-inserted row is a fresh delta for *every user rule reading that view*, so +user-rule search would scale with how much the rebuild rewrites rather than with +the rules' own selectivity. That would also explain why the effect is worst on the +file with the most view rows. Measuring view-row re-insertions per round against +native's is the next step. + +Native picks per table, per round, between scanning only the recently-updated +subset and scanning the whole table, at `diff > table_size / 8` +(`core-relations/src/table/rebuild.rs`). Tracing that choice: + +| workload | decisions | fullscan | median `diff/table_size` | +| --- | ---: | ---: | ---: | +| `math-microbenchmark` | 429 | **93.2%** | 1.000 | +| `eggcc-2mm-pass1` | 336340 | **99.8%** | 0.800 | + +So native almost always scans, and the encoding has no way to: its rebuild rule +is driven by the `@UF` delta joined against a declared occurrence index, and an +index atom is probed rather than scanned by construction. On these workloads the +encoding therefore pays twice — maintaining an index native would not consult, +then probing it per delta row instead of making one sequential pass. + +Scanning the index is not the fix: `(any 0 1 2)` holds one entry per row *per +listed column*, so scanning it visits each row three times. The scan has to be +over the view, which makes it a different rule body rather than a different plan +for the same rule — no cost-based planner change can reach it. + +The shape that scan wants already exists in the encoding, as the container +rebuild rule: `:naive`, canonicalize in the body, guard on the column having +moved. Two ways to choose between the shapes, neither needing the backend to +recognize a rule: + +- A body guard that is cheap and fails fast — a primitive comparing the `@UF` + delta against the view's size, ordered first so a losing round never reaches + the scan. +- A per-view scan rule per column (which is what the index-driven rule replaced), + costing one scan per column rather than one per view. + +The higher-ceiling option is a bulk view-rebuild primitive that does the scan and +the canonicalization in Rust and mints the proof rows itself, which is what +`proof_container_rebuild.rs` already does for containers. That is the only option +that also removes the interpreted-join overhead, rather than trading one join +shape for another. + +`EGGLOG_REBUILD_TRACE=1` prints native's per-table branch and its two inputs. From 0383be6b9d2cf8251fb0eb2a2ebde36b63e36666 Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Sat, 1 Aug 2026 00:04:22 +0000 Subject: [PATCH 3/7] Squashed 'egglog/' changes from 6f0d26e3..53b9721b 53b9721b Merge pull request #961 from oflatt-claude/fix/add-primitive-syn-full 5af563c8 Merge pull request #952 from egraphs-good/specialize-scan-and-refine ead49f80 Merge remote-tracking branch 'origin/main' into specialize-scan-and-refine c601b68f Merge pull request #955 from egraphs-good/perf-rebuild-patch-in-place 2630f5a9 add_primitive: depend on syn with the "full" feature 6575930c Merge pull request #917 from saulshanabrook/debug-assertions-release-tests 931a7558 Merge pull request #920 from egraphs-good/no-panic 60aa0844 Merge pull request #5 from egraphs-good/main 45866518 Merge branch 'main' into no-panic 0e1925eb don't sort if already sorted 572d154c Patch canonicalized rows in place in the rebuild output buffer 30eedcc1 Merge pull request #949 from egraphs-good/perf-shared-trie-nodes e40dd754 fix nits 7971cb79 Monomorphize the column-gather loop used to build sorted column indexes 93e43d9d cherry-pick 225ad44d add a comment 9a84b92b Share trie roots across query plans within a rule-set run 56b84600 Merge pull request #948 from egraphs-good/perf-sorted-column-index 383b2bfa Exclude tests/header/ from test discovery e67fb1c4 Bypass luminal transformer benchmarks in the test suite 14a81499 add more luminal benchmarks 1b5dea21 Build per-subset join indexes as sorted arrays instead of hash maps 6f0d696d bench: point harness at tests-bench and add transformer benchmarks 60eed0d8 Merge pull request #914 from egraphs-good/yihozhang-better-index-order-fix 4e7c8812 Only dedup the stdlib sort baseline for multi-column inputs 45ba1906 Unify unstable-fn primitive resolution errors with direct calls 7b4f81c3 Add microbenchmarks and random test 3bce29bc Fix issues from #898 a1918259 Merge remote-tracking branch 'origin/main' into no-panic ced62ccc Merge remote-tracking branch 'origin/main' into yihozhang-better-index-order-fix 07ae68ea Replace Rayon with our own, non-workstealing thread pool (#910) 7bdf0465 Address review: keep internal prove-exists failures as invariants a3ace918 Merge index-rebuild blocks with ping-pong buffers 53869105 Address review: keep proof-encoding internal parses as invariants a66a4231 Add committed no-panic regression tests d9783e0a Return errors instead of panicking for reachable failures 894b9ba5 Scope debug assertions to release tests 49d8020a Enable debug assertions in release builds 8ed30f98 Use balanced tournament merge for multi-column index rebuild f895dfdb Rebuild ColumnIndex via per-column radix sort + merge 201579af Fix multi-column column index rebuild ordering git-subtree-dir: egglog git-subtree-split: 53b9721b9706741edff2b7c1e379fc37137184d9 --- .github/workflows/build.yml | 12 + CHANGELOG.md | 8 + Cargo.lock | 7 +- Cargo.toml | 1 - Makefile | 10 +- benches/common.rs | 19 +- benches/rust_api_benchmarking.rs | 14 +- concurrency/Cargo.toml | 6 +- concurrency/benches/sum_vector.rs | 128 + concurrency/src/lib.rs | 2 + concurrency/src/threadpool/mod.rs | 983 +++ concurrency/src/threadpool/tests.rs | 603 ++ core-relations/Cargo.toml | 6 +- core-relations/benches/build_index.rs | 88 + core-relations/src/containers/mod.rs | 221 +- core-relations/src/free_join/execute.rs | 531 +- core-relations/src/free_join/mod.rs | 27 +- .../src/hash_index/bench_support.rs | 138 + core-relations/src/hash_index/mod.rs | 388 +- core-relations/src/hash_index/tests.rs | 141 +- core-relations/src/lib.rs | 3 + core-relations/src/parallel.rs | 172 + core-relations/src/parallel_heuristics.rs | 91 +- core-relations/src/pool/mod.rs | 7 +- core-relations/src/row_buffer/mod.rs | 52 +- core-relations/src/table/mod.rs | 284 +- core-relations/src/table/rebuild.rs | 118 +- .../src/table/sharded_hash_table.rs | 2 +- core-relations/src/table_spec.rs | 81 +- core-relations/src/tests.rs | 11 +- core-relations/src/uf/mod.rs | 42 +- egglog-ast/src/generic_ast_helpers.rs | 25 +- egglog-bridge/Cargo.toml | 2 +- egglog-bridge/src/lib.rs | 151 +- numeric-id/Cargo.toml | 3 - numeric-id/src/lib.rs | 36 +- scripts/bench.py | 7 + src/ast/desugar.rs | 38 +- src/ast/parse.rs | 5 +- src/cli.rs | 63 +- src/constraint.rs | 54 +- src/core.rs | 27 +- src/extract.rs | 18 +- src/lib.rs | 303 +- src/proofs/proof_encoding.rs | 6 +- src/proofs/proof_encoding_helpers.rs | 21 +- src/proofs/proof_extraction.rs | 13 +- src/scheduler.rs | 311 +- src/serialize.rs | 9 +- src/sort/add_primitive/Cargo.toml | 5 +- src/sort/add_primitive/src/lib.rs | 6 +- src/sort/bigint.rs | 4 +- src/sort/bigrat.rs | 2 +- src/sort/fn.rs | 37 +- src/sort/i64.rs | 2 +- src/sort/map.rs | 6 +- src/sort/mod.rs | 3 +- src/sort/multiset.rs | 30 +- src/sort/pair.rs | 6 +- src/sort/set.rs | 10 +- src/sort/vec.rs | 14 +- src/typechecking.rs | 22 +- tests/cykjson.egg | 2 +- tests/files.rs | 49 +- tests/gemma.egg | 4261 ++++++++++ tests/gemma4_moe.egg | 7030 +++++++++++++++++ tests/header/luminal-header.egg | 6658 ++++++++++++++++ tests/integration_test.rs | 29 + tests/llama.egg | 1661 ++++ tests/no_panic.rs | 140 + tests/paged_llama.egg | 1540 ++++ tests/qwen.egg | 2080 +++++ tests/qwen3_moe.egg | 2715 +++++++ .../files__shared_snapshot_eggcc_2mm.snap | 6 +- .../files__shared_snapshot_llama.snap | 133 + .../files__shared_snapshot_paged_llama.snap | 133 + .../files__shared_snapshot_qwen.snap | 133 + .../files__shared_snapshot_qwen3_moe.snap | 133 + .../files__shared_snapshot_whisper.snap | 133 + tests/typed_primitive.rs | 117 +- tests/whisper.egg | 1268 +++ 81 files changed, 32490 insertions(+), 1166 deletions(-) create mode 100644 concurrency/benches/sum_vector.rs create mode 100644 concurrency/src/threadpool/mod.rs create mode 100644 concurrency/src/threadpool/tests.rs create mode 100644 core-relations/benches/build_index.rs create mode 100644 core-relations/src/hash_index/bench_support.rs create mode 100644 core-relations/src/parallel.rs create mode 100644 tests/gemma.egg create mode 100644 tests/gemma4_moe.egg create mode 100644 tests/header/luminal-header.egg create mode 100644 tests/llama.egg create mode 100644 tests/no_panic.rs create mode 100644 tests/paged_llama.egg create mode 100644 tests/qwen.egg create mode 100644 tests/qwen3_moe.egg create mode 100644 tests/snapshots/files__shared_snapshot_llama.snap create mode 100644 tests/snapshots/files__shared_snapshot_paged_llama.snap create mode 100644 tests/snapshots/files__shared_snapshot_qwen.snap create mode 100644 tests/snapshots/files__shared_snapshot_qwen3_moe.snap create mode 100644 tests/snapshots/files__shared_snapshot_whisper.snap create mode 100644 tests/whisper.egg diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 86b9c8fe..334b8737 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -20,6 +20,18 @@ jobs: tool: nextest,cargo-insta - uses: Swatinem/rust-cache@v2 - run: make test + # Build the library the way downstream crates consume it: no default + # features (so `clap`/`clap_derive` are absent). This guards against + # relying on another crate to unify a `syn` feature onto ours — the bug + # that broke downstream builds when clap_derive moved to syn 3.x. + no-default-features: + if: github.event_name != 'issue_comment' + runs-on: ubuntu-latest + steps: + - run: echo "CARGO_INCREMENTAL=0" >> "$GITHUB_ENV" + - uses: actions/checkout@v3 + - uses: Swatinem/rust-cache@v2 + - run: cargo check -p egglog --no-default-features --lib coverage: if: github.event_name != 'issue_comment' runs-on: ubuntu-latest diff --git a/CHANGELOG.md b/CHANGELOG.md index dff0897c..171150eb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,12 +2,20 @@ ## [Unreleased] - ReleaseDate +- Fix a build failure when egglog is compiled without default features (as a library dependency). The `egglog-add-primitive` proc macro parses full Rust expressions and now declares `syn`'s `full` feature directly, instead of relying on another crate (`clap_derive`, via the `bin` feature) to unify it onto our `syn`. This surfaced when `clap_derive` moved to `syn` 3.x. A CI job now builds `-p egglog --no-default-features` to catch regressions. +- Convert many reachable `panic!`/`unwrap`/`expect`/`todo!` sites into recoverable errors, so malformed or edge-case programs report an error instead of aborting the process. Examples now returning `Error`/`TypeError`/`ParseError`/`ProveExistsError`: malformed sort-constructor declarations like `(sort S (Vec))` or `(sort S (UnstableFn))`; negative `extract` variant counts; duplicate rule names; `unstable-fn` referencing an unknown, non-literal, or mis-typed target; `(fail ...)` wrapping `include` or an empty expansion; subsuming a non-call rewrite; running `prove`/`prove-exists` without proofs enabled; and missing/unreadable files for `input`, `print-function`, `print-overall-statistics`, and the CLI. Several primitives became partial (returning no result instead of panicking) on out-of-range input: `vec-set`/`vec-remove` indices, `multiset-pick` on an empty multiset, count overflow in `multiset` operations, and the numeric primitives `bigint <<`/`>>`, `bigrat`, and `log2`. A few scheduler edge cases (unknown ruleset, rules with no free variables) no longer panic; variable-free rules now correctly apply their actions when scheduled. Primitive resolution now returns `TypeError::AmbiguousPrimitive`/`TypeError::UnresolvedPrimitive` instead of panicking when duplicate same-signature registrations are indistinguishable or nothing resolves; both direct calls and `unstable-fn` primitive targets report the same variants. `step_rules_with_scheduler` now restores its `rulesets`/`schedulers` on every fallible path, so an error during scheduled rule compilation no longer leaves the `EGraph` in a corrupted state. +- **Breaking:** `EGraph::print_function` now takes its output sink as `Option<(File, PathBuf)>` plus a `Span`, so write failures return `Error::IoError` instead of panicking. +- Speed up query evaluation by building on-the-fly per-subset column indexes as sorted arrays (`SortedColumnIndex`) instead of hash maps. These indexes are typically iterated once and probed a bounded number of times over high-cardinality columns, so skipping hash-table construction is a large win (e.g. ~33% faster on the `gemma` benchmark). +- Share trie roots (and their cached sub-indexes and child nodes) across query plans within a single `run_rule_set` instead of rebuilding a fresh trie per plan. Plans that scan the same table under the same header (fast) constraints reuse one root, so on-the-fly per-subset index builds happen once rather than per plan; only roots that more than one plan uses are shared, so workloads that would not benefit keep the per-plan behavior. Large speedups on transformer workloads (e.g. ~15% faster on `whisper`, ~12% on `gemma`, ~8% on `qwen3_moe`). - Add `make nightly` and `scripts/nightly_bench.py`, a hyperfine-based benchmark harness that measures every `tests/**/*.egg` program at 1/2/4/8 threads and (where supported) in proof-testing mode, caps each run at a 2-minute timeout, skips sub-50ms programs, and emits an HTML dashboard (one row per benchmark, one column per configuration) for nightly.cs.washington.edu. The dashboard uses [eval-live](https://github.com/oflatt/eval-live) for interactive filtering and sorting. - Add typed `EGraph` extension state that clones with `EGraph` and is restored by `push`/`pop`. - Fix custom scheduler queries so subsumed rows are not offered as fresh matches. +- Replace the global Rayon thread pool with an `egglog-concurrency` scoped `ThreadPool`; configure parallelism per `EGraph` via `with_num_threads` / `set_num_threads`. - Report full source file paths in egglog span and error messages. - Fix seminaive matching after nested containers rebuild in place by propagating dirty container ids through parent containers. +- Fix multi-column secondary index rebuilds so each value's rows come back sorted by row id, and make all rebuild paths (serial, parallel, and bulk) record a row once even when its value repeats across covered columns (#914). - Render nullary AST calls without a trailing space, e.g. (foo) instead of (foo ). +- Escape `"` and `\` when displaying string literals so printed/serialized programs round-trip through the parser. - Add a BigRat to-i64 primitive for integral rationals. - Add f64 exp, log, and sqrt primitives. - Add `RunReport::can_stop` so scheduler progress can be reported separately from database updates. diff --git a/Cargo.lock b/Cargo.lock index 20a11e10..58ef578b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -485,7 +485,6 @@ dependencies = [ "mimalloc", "num", "ordered-float", - "rayon", "rustc-hash", "serde_json", "serial_test", @@ -516,6 +515,7 @@ version = "2.0.0" dependencies = [ "anyhow", "dyn-clone", + "egglog-concurrency", "egglog-core-relations", "egglog-numeric-id", "egglog-reports", @@ -529,7 +529,6 @@ dependencies = [ "once_cell", "ordered-float", "rand 0.9.2", - "rayon", "smallvec", "thiserror", "web-time", @@ -542,6 +541,7 @@ dependencies = [ "arc-swap", "bumpalo", "codspeed-divan-compat", + "crossbeam", "egglog-numeric-id", "proptest", "rayon", @@ -581,9 +581,6 @@ dependencies = [ [[package]] name = "egglog-numeric-id" version = "2.0.0" -dependencies = [ - "rayon", -] [[package]] name = "egglog-reports" diff --git a/Cargo.toml b/Cargo.toml index 04305e06..7df6396e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -155,7 +155,6 @@ egglog-bridge = { workspace = true } egglog-numeric-id = { workspace = true } egglog-add-primitive = { workspace = true } egglog-reports = { workspace = true } -rayon = { workspace = true } serde_json = { workspace = true } [build-dependencies] diff --git a/Makefile b/Makefile index 9a26a505..7d544a3a 100644 --- a/Makefile +++ b/Makefile @@ -5,6 +5,10 @@ TESTS=$(shell find tests/ -type f -name '*.egg' -not -name '*repro-*') WWW=${PWD}/target/www +# Keep release-mode test builds checking debug assertions without changing the +# normal release profile used by CodSpeed benchmarks and production binaries. +TEST_PROFILE_ENV=CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS=true + all: test nits docs # Build egglog and benchmark every tests/*.egg file with hyperfine, writing an @@ -18,14 +22,14 @@ nightly: nightly/.venv/bin/python scripts/nightly_bench.py test: doctest - cargo insta test --test-runner nextest --release --workspace --unreferenced reject + $(TEST_PROFILE_ENV) cargo insta test --test-runner nextest --release --workspace --unreferenced reject coverage: - cargo llvm-cov nextest --release --workspace --lcov --output-path lcov.info + $(TEST_PROFILE_ENV) cargo llvm-cov nextest --release --workspace --lcov --output-path lcov.info # Note: doctests are not included in coverage reports doctest: - cargo test --doc --release --workspace + $(TEST_PROFILE_ENV) cargo test --doc --release --workspace nits: diff --git a/benches/common.rs b/benches/common.rs index 9c8b7f39..f1a4ceb7 100644 --- a/benches/common.rs +++ b/benches/common.rs @@ -1,11 +1,9 @@ use egglog::EGraph; -use std::{fmt, sync::Once}; +use std::fmt; #[global_allocator] static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; -static CONFIGURE_RAYON: Once = Once::new(); - pub fn run_example(filename: &str, program: &str, proof_testing: bool) { let mut egraph = if proof_testing { EGraph::new_with_proofs().with_proof_testing() @@ -36,8 +34,6 @@ impl fmt::Display for BenchCase { } pub fn bench_cases(glob: &str) -> Vec { - configure_rayon_once(); - let mut cases = Vec::new(); // Add regular test cases @@ -81,8 +77,6 @@ const PROOF_UNSUPPORTED_FILES: &[&str] = &[ ]; pub fn bench_cases_proof_testing(glob: &str) -> Vec { - configure_rayon_once(); - glob::glob(glob) .unwrap() .filter_map(Result::ok) @@ -112,16 +106,5 @@ fn proof_benchmark_supported(path: &std::path::Path) -> bool { } pub fn bench_case(case: &BenchCase) { - configure_rayon_once(); - run_example(&case.filename, &case.program, case.proof_testing); } - -pub fn configure_rayon_once() { - CONFIGURE_RAYON.call_once(|| { - rayon::ThreadPoolBuilder::new() - .num_threads(1) - .build_global() - .unwrap(); - }); -} diff --git a/benches/rust_api_benchmarking.rs b/benches/rust_api_benchmarking.rs index 3afc4665..b05293a2 100644 --- a/benches/rust_api_benchmarking.rs +++ b/benches/rust_api_benchmarking.rs @@ -1,5 +1,3 @@ -mod common; - #[derive(Clone, Copy)] struct RustRuleBenchCase { n_facts_input: Option, @@ -23,8 +21,6 @@ struct RustRuleBenchInput { fn match_only_rust_rule_setup(case: RustRuleBenchCase) -> RustRuleBenchInput { use egglog::prelude::*; - common::configure_rayon_once(); - let mut program = String::new(); program.push_str("(relation R (i64))\n"); @@ -120,8 +116,6 @@ fn rust_rule_match_with_serialize(bencher: divan::Bencher, case: RustRuleBenchCa fn insert_loop_setup(case: RustRuleInsertLoopBenchCase) -> RustRuleBenchInput { use egglog::prelude::*; - common::configure_rayon_once(); - let mut program = String::new(); program.push_str("(relation R (i64))\n"); program.push_str("(function f (i64) i64 :no-merge)\n"); @@ -162,8 +156,6 @@ fn insert_loop_setup(case: RustRuleInsertLoopBenchCase) -> RustRuleBenchInput { fn tableaction_hot_path_setup(case: RustRuleTableActionBenchCase) -> RustRuleBenchInput { use egglog::prelude::*; - common::configure_rayon_once(); - let mut program = String::new(); program.push_str("(relation R (i64))\n"); program.push_str("(function f (i64) i64 :no-merge)\n"); @@ -299,14 +291,12 @@ impl std::fmt::Display for ReadScanBenchCase { fn read_scan_setup(case: ReadScanBenchCase) -> egglog::EGraph { use std::fmt::Write; - common::configure_rayon_once(); - let mut program = String::from("(sort Math)\n(constructor Add (i64 i64) Math)\n"); for i in 0..case.n_enodes { let _ = writeln!(&mut program, "(Add {} {})", i as i64, (i + 1) as i64); } - let mut egraph = egglog::EGraph::default(); + let mut egraph = egglog::EGraph::new(1); egraph.parse_and_run_program(None, &program).unwrap(); egraph } @@ -340,8 +330,6 @@ fn main() { fn fib_setup() -> RustRuleBenchInput { use egglog::prelude::*; - common::configure_rayon_once(); - let mut program = String::new(); program.push_str("(function fib (i64) i64 :no-merge)"); program.push_str("(set (fib 0) 0)\n"); diff --git a/concurrency/Cargo.toml b/concurrency/Cargo.toml index c2d7a00e..3b1b5682 100644 --- a/concurrency/Cargo.toml +++ b/concurrency/Cargo.toml @@ -11,7 +11,7 @@ readme = { workspace = true } [dependencies] arc-swap = { workspace = true} bumpalo = { workspace = true} -rayon = { workspace = true} +crossbeam = { workspace = true} egglog-numeric-id = { workspace = true } smallvec = { workspace = true } @@ -23,3 +23,7 @@ rayon = { workspace = true} [[bench]] name = "simple_read" harness = false + +[[bench]] +name = "sum_vector" +harness = false diff --git a/concurrency/benches/sum_vector.rs b/concurrency/benches/sum_vector.rs new file mode 100644 index 00000000..476ab3fe --- /dev/null +++ b/concurrency/benches/sum_vector.rs @@ -0,0 +1,128 @@ +use std::{env, sync::OnceLock, thread}; + +use divan::{Bencher, counter::ItemsCount}; +use egglog_concurrency::ThreadPool; +use rayon::prelude::*; + +const DEFAULT_ITEMS: usize = 256_000_000; +const DEFAULT_SAMPLE_COUNT: u32 = 5; + +fn main() { + divan::main() +} + +#[divan::bench(sample_count = DEFAULT_SAMPLE_COUNT)] +fn single_threaded_sum(bencher: Bencher) { + let data = data(); + let expected = expected_sum(); + + bencher + .with_inputs(|| data) + .input_counter(|data| ItemsCount::new(data.len())) + .bench_values(|data| { + let sum = sum_slice(divan::black_box(data)); + assert_eq!(sum, expected); + divan::black_box(sum) + }); +} + +#[divan::bench(sample_count = DEFAULT_SAMPLE_COUNT)] +fn rayon_sum(bencher: Bencher) { + let data = data(); + let expected = expected_sum(); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(thread_count()) + .build() + .unwrap(); + + bencher + .with_inputs(|| data) + .input_counter(|data| ItemsCount::new(data.len())) + .bench_values(|data| { + let sum = pool.install(|| { + divan::black_box(data) + .par_iter() + .map(|&value| value as u64) + .sum::() + }); + assert_eq!(sum, expected); + divan::black_box(sum) + }); +} + +#[divan::bench( + consts = [ + 1024, + 4096, + 16384, + 65536, + 262144, + 1048576, + 4194304, + 16777216, + ], + sample_count = DEFAULT_SAMPLE_COUNT, +)] +fn threadpool_chunked_sum(bencher: Bencher) { + let data = data(); + let expected = expected_sum(); + let pool = ThreadPool::new(thread_count()); + + bencher + .with_inputs(|| data) + .input_counter(|data| ItemsCount::new(data.len())) + .bench_values(|data| { + let mut partials = vec![0_u64; data.len().div_ceil(CHUNK)]; + pool.scope(|scope| { + for (slot, chunk) in partials + .iter_mut() + .zip(divan::black_box(data).chunks(CHUNK)) + { + scope.spawn(move |_| { + *slot = sum_slice(chunk); + }); + } + }); + + let sum: u64 = partials.into_iter().sum(); + assert_eq!(sum, expected); + divan::black_box(sum) + }); +} + +fn data() -> &'static [u32] { + static DATA: OnceLock> = OnceLock::new(); + DATA.get_or_init(|| { + (0..data_len()) + .map(|i| { + let value = i as u32; + value.wrapping_mul(1_664_525).wrapping_add(1_013_904_223) + }) + .collect() + }) +} + +fn expected_sum() -> u64 { + static EXPECTED: OnceLock = OnceLock::new(); + *EXPECTED.get_or_init(|| sum_slice(data())) +} + +fn sum_slice(data: &[u32]) -> u64 { + data.iter().map(|&value| value as u64).sum() +} + +fn data_len() -> usize { + env_usize("EGGLOG_SUM_BENCH_LEN").unwrap_or(DEFAULT_ITEMS) +} + +fn thread_count() -> usize { + env_usize("EGGLOG_SUM_BENCH_THREADS") + .unwrap_or_else(|| thread::available_parallelism().map_or(1, usize::from)) +} + +fn env_usize(name: &str) -> Option { + env::var(name) + .ok() + .and_then(|value| value.replace('_', "").parse().ok()) + .filter(|&value| value > 0) +} diff --git a/concurrency/src/lib.rs b/concurrency/src/lib.rs index 0b3c3550..322d2d67 100644 --- a/concurrency/src/lib.rs +++ b/concurrency/src/lib.rs @@ -7,6 +7,7 @@ pub(crate) mod notification_list; pub mod parallel_writer; pub(crate) mod resettable_oncelock; mod shared_arena; +pub mod threadpool; use arc_swap::{ArcSwap, Guard}; pub use bitset::BitSet; @@ -16,6 +17,7 @@ pub use notification_list::NotificationList; pub use parallel_writer::ParallelVecWriter; pub use resettable_oncelock::ResettableOnceLock; pub use shared_arena::{Handle, SharedArena, SharedRef}; +pub use threadpool::{Scope, ThreadPool, current_num_threads, scope, without_current_pool}; #[cfg(test)] mod tests; diff --git a/concurrency/src/threadpool/mod.rs b/concurrency/src/threadpool/mod.rs new file mode 100644 index 00000000..427b7a55 --- /dev/null +++ b/concurrency/src/threadpool/mod.rs @@ -0,0 +1,983 @@ +//! A small scoped thread pool backed by a shared crossbeam channel. +//! +//! [`ThreadPool`] owns a fixed set of primary worker threads. Each worker +//! receives boxed `'static` jobs from a shared channel and exits when the +//! channel is closed. A primary worker that blocks waiting for nested scoped +//! work helps drain queued jobs until that nested scope completes, so the pool +//! does not lose a worker while work it needs may still be queued. [`Scope`] +//! provides the safe scoped API on top of those `'static` jobs by erasing task +//! lifetimes when work is sent to the channel, then waiting for all work in the +//! scope before returning to the caller. +//! +//! The root callback runs on the caller thread, and spawned callbacks run on +//! worker threads. Spawned callbacks receive the same scope reference as the +//! root callback, so they can add nested work. The high half of the scope +//! counter tracks expected work and is incremented before each task is +//! enqueued; the low half tracks completed work. The root callback is counted +//! as one expected item, so the scope is complete once the callback and every +//! spawned task have completed. +//! +//! # Examples +//! +//! ``` +//! use std::sync::atomic::{AtomicUsize, Ordering}; +//! use egglog_concurrency::ThreadPool; +//! +//! let pool = ThreadPool::new(4); +//! let values = [1, 2, 3, 4]; +//! let sum = AtomicUsize::new(0); +//! +//! pool.scope(|scope| { +//! for value in &values { +//! scope.spawn(|_| { +//! sum.fetch_add(*value, Ordering::Relaxed); +//! }); +//! } +//! }); +//! +//! assert_eq!(sum.load(Ordering::Relaxed), 10); +//! ``` +//! +//! A spawned callback cannot store references that would outlive the borrowed +//! data, even though the implementation erases the callback's lifetime before +//! sending it to a worker: +//! +//! ```compile_fail +//! use egglog_concurrency::ThreadPool; +//! +//! let pool = ThreadPool::new(1); +//! let mut escaped = None; +//! +//! pool.scope(|scope| { +//! let local = 10; +//! scope.spawn(|_| { +//! escaped = Some(&local); +//! }); +//! }); +//! +//! assert_eq!(escaped, Some(&10)); +//! ``` +//! +//! Nested spawned callbacks cannot borrow data owned by the parent spawned +//! callback, because the parent callback may return before its nested work runs: +//! +//! ```compile_fail +//! use egglog_concurrency::ThreadPool; +//! +//! let pool = ThreadPool::new(1); +//! pool.scope(|scope| { +//! scope.spawn(|scope| { +//! let local = 10; +//! scope.spawn(|_| { +//! println!("{local}"); +//! }); +//! }); +//! }); +//! ``` +//! +//! The scope itself also cannot be stored outside the call to +//! [`ThreadPool::scope`]: +//! +//! ```compile_fail +//! use egglog_concurrency::{Scope, ThreadPool}; +//! +//! let pool = ThreadPool::new(1); +//! let mut escaped: Option<&Scope<'_>> = None; +//! +//! pool.scope(|scope| { +//! scope.spawn(|scope| { +//! escaped = Some(scope); +//! }); +//! }); +//! +//! escaped.unwrap().spawn(|_| {}); +//! ``` + +use std::{ + any::Any, + cell::Cell, + marker::PhantomData, + mem, + panic::{self, AssertUnwindSafe}, + ptr::{self, NonNull}, + sync::{ + Mutex, + atomic::{AtomicU64, Ordering}, + }, + thread::{self, JoinHandle}, +}; + +#[cfg(test)] +use std::sync::atomic::AtomicUsize; + +use crossbeam::channel::{Receiver, Sender, bounded, select_biased, unbounded}; + +const EXPECTED_SHIFT: u32 = 32; +const COMPLETED_MASK: u64 = u32::MAX as u64; +// Keep inline helping bounded so pathological nested scopes move onto a fresh +// stack before exhausting the current worker stack. +const MAX_INLINE_SCOPE_HELP_DEPTH: usize = 64; + +type Job = Box; +type ScopedJob<'scope> = Box; +type PanicPayload = Box; + +thread_local! { + static CURRENT_POOL: Cell<*const ThreadPoolState> = const { Cell::new(ptr::null()) }; + static IS_BACKGROUND_WORKER: Cell = const { Cell::new(false) }; + static INLINE_SCOPE_HELP_DEPTH: Cell = const { Cell::new(0) }; +} + +/// Return the number of threads in the currently installed thread pool. +/// +/// Returns `1` when called outside [`ThreadPool::install`], [`ThreadPool::scope`], +/// a free [`scope`] callback, or a worker callback spawned from an installed +/// pool. +/// +/// # Examples +/// +/// ``` +/// use egglog_concurrency::{ThreadPool, current_num_threads}; +/// +/// assert_eq!(current_num_threads(), 1); +/// +/// let pool = ThreadPool::new(2); +/// pool.install(|| { +/// assert_eq!(current_num_threads(), 2); +/// }); +/// +/// assert_eq!(current_num_threads(), 1); +/// ``` +pub fn current_num_threads() -> usize { + with_current_pool(|pool| pool.map_or(1, ThreadPoolState::thread_count)) +} + +/// Run `f` with no current thread pool installed on this thread. +/// +/// This is useful for serial operations that must not inherit an ambient pool. +/// The previous current pool, if any, is restored before this function returns +/// or unwinds. +/// +/// # Examples +/// +/// ``` +/// use egglog_concurrency::{ThreadPool, current_num_threads, without_current_pool}; +/// +/// let pool = ThreadPool::new(2); +/// pool.install(|| { +/// assert_eq!(current_num_threads(), 2); +/// without_current_pool(|| { +/// assert_eq!(current_num_threads(), 1); +/// }); +/// assert_eq!(current_num_threads(), 2); +/// }); +/// ``` +pub fn without_current_pool(f: F) -> R +where + F: FnOnce() -> R, +{ + install_pool_ptr(ptr::null(), f) +} + +/// Run `f` in a scope on the currently installed thread pool. +/// +/// This is the free-function counterpart to [`ThreadPool::scope`]. It keeps the +/// same in-place semantics: the root callback runs on the caller thread, and +/// spawned work runs on the installed pool's workers. +/// +/// # Panics +/// +/// Panics if no thread pool is currently installed. +/// +/// # Examples +/// +/// ``` +/// use std::sync::atomic::{AtomicUsize, Ordering}; +/// use egglog_concurrency::{ThreadPool, scope}; +/// +/// let pool = ThreadPool::new(2); +/// let counter = AtomicUsize::new(0); +/// +/// pool.install(|| { +/// scope(|scope| { +/// scope.spawn(|_| { +/// counter.fetch_add(1, Ordering::Relaxed); +/// }); +/// }); +/// }); +/// +/// assert_eq!(counter.load(Ordering::Relaxed), 1); +/// ``` +/// +/// ```should_panic +/// egglog_concurrency::scope(|_| {}); +/// ``` +pub fn scope<'scope, F, R>(f: F) -> R +where + F: FnOnce(&Scope<'scope>) -> R, +{ + with_current_pool(|pool| match pool { + Some(pool) => pool.scope(f), + None => panic!("no egglog thread pool is currently installed"), + }) +} + +/// A thread pool using a single shared work queue. +/// +/// The pool owns a fixed number of primary workers. A primary worker that +/// blocks waiting for nested scoped work helps drain the shared queue until the +/// nested scope completes. +/// +/// # Examples +/// +/// ``` +/// use egglog_concurrency::ThreadPool; +/// +/// let pool = ThreadPool::new(2); +/// pool.scope(|scope| { +/// scope.spawn(|_| {}); +/// }); +/// ``` +pub struct ThreadPool { + state: Box, + workers: Vec>, +} + +impl ThreadPool { + /// Create a thread pool with `thread_count` worker threads. + /// + /// # Panics + /// + /// Panics when `thread_count` is zero. + /// + /// # Examples + /// + /// ``` + /// use egglog_concurrency::ThreadPool; + /// + /// let pool = ThreadPool::new(2); + /// assert_eq!(pool.thread_count(), 2); + /// ``` + pub fn new(thread_count: usize) -> Self { + assert!( + thread_count > 0, + "thread pool must have at least one worker" + ); + + let (sender, receiver) = unbounded(); + let state = Box::new(ThreadPoolState::new(sender, receiver.clone(), thread_count)); + let state_ptr = ThreadPoolStatePtr::new(&state); + let workers = (0..thread_count) + .map(|_| spawn_worker(receiver.clone(), state_ptr)) + .collect(); + + Self { state, workers } + } + + /// Return the number of primary worker threads owned by this pool. + /// + /// # Examples + /// + /// ``` + /// use egglog_concurrency::ThreadPool; + /// + /// let pool = ThreadPool::new(3); + /// assert_eq!(pool.thread_count(), 3); + /// ``` + pub fn thread_count(&self) -> usize { + self.state.thread_count() + } + + /// Run `f` with this thread pool installed as the current pool. + /// + /// The callback runs on the caller thread. While it is running, + /// [`current_num_threads`] reports this pool's thread count, the free + /// [`scope`] function uses this pool, and worker callbacks spawned from this + /// pool also see this pool as current. If another pool was already + /// installed on the current thread, it is restored before this method + /// returns or unwinds. + /// + /// # Examples + /// + /// ``` + /// use egglog_concurrency::{ThreadPool, current_num_threads}; + /// + /// let pool = ThreadPool::new(2); + /// assert_eq!(current_num_threads(), 1); + /// + /// let value = pool.install(|| current_num_threads()); + /// + /// assert_eq!(value, 2); + /// assert_eq!(current_num_threads(), 1); + /// ``` + pub fn install(&self, f: F) -> R + where + F: FnOnce() -> R, + { + install_pool(&self.state, f) + } + + /// Run `f` in a scope and wait for all work spawned in that scope. + /// + /// The root callback runs on the caller thread. Tasks spawned from `f` may + /// borrow stack data owned by the caller. If a spawned task panics, this + /// method waits for all previously spawned work and then resumes unwinding + /// with one of the worker panic payloads. If `f` itself panics, the outer + /// panic is resumed after spawned work has completed. + /// + /// # Examples + /// + /// ``` + /// use std::sync::atomic::{AtomicUsize, Ordering}; + /// use egglog_concurrency::ThreadPool; + /// + /// let pool = ThreadPool::new(2); + /// let value = AtomicUsize::new(0); + /// + /// let result = pool.scope(|scope| { + /// scope.spawn(|_| { + /// value.store(7, Ordering::Relaxed); + /// }); + /// 11 + /// }); + /// + /// assert_eq!(result, 11); + /// assert_eq!(value.load(Ordering::Relaxed), 7); + /// ``` + pub fn scope<'scope, F, R>(&self, f: F) -> R + where + F: FnOnce(&Scope<'scope>) -> R, + { + self.install(|| self.state.scope(f)) + } + + /// Apply `f` to each item in `iter` in parallel. + /// + /// Items are pulled from the iterator by the calling thread and enqueued + /// one by one. The method returns only after every enqueued callback has + /// completed. + /// + /// # Examples + /// + /// ``` + /// use std::sync::atomic::{AtomicUsize, Ordering}; + /// use egglog_concurrency::ThreadPool; + /// + /// let pool = ThreadPool::new(2); + /// let sum = AtomicUsize::new(0); + /// + /// pool.parallel_for_each(0..4, |value| { + /// sum.fetch_add(value, Ordering::Relaxed); + /// }); + /// + /// assert_eq!(sum.load(Ordering::Relaxed), 6); + /// ``` + pub fn parallel_for_each<'scope, I, F>(&self, iter: I, f: F) + where + I: IntoIterator, + I::Item: Send + 'scope, + F: Fn(I::Item) + Sync + 'scope, + { + self.scope(|scope| { + let f = &f; + for item in iter { + scope.spawn(move |_| f(item)); + } + }); + } +} + +impl Drop for ThreadPool { + fn drop(&mut self) { + self.state.sender.take(); + for worker in self.workers.drain(..) { + let _ = worker.join(); + } + } +} + +struct ThreadPoolState { + sender: Option>, + receiver: Receiver, + thread_count: usize, + #[cfg(test)] + backup_workers_spawned: AtomicUsize, + #[cfg(test)] + backup_workers_live: AtomicUsize, +} + +impl ThreadPoolState { + fn new(sender: Sender, receiver: Receiver, thread_count: usize) -> Self { + Self { + sender: Some(sender), + receiver, + thread_count, + #[cfg(test)] + backup_workers_spawned: AtomicUsize::new(0), + #[cfg(test)] + backup_workers_live: AtomicUsize::new(0), + } + } + + fn thread_count(&self) -> usize { + self.thread_count + } + + fn scope<'scope, F, R>(&self, f: F) -> R + where + F: FnOnce(&Scope<'scope>) -> R, + { + let scope = Scope::new(self); + let result = panic::catch_unwind(AssertUnwindSafe(|| f(&scope))); + scope.complete_root_and_wait(); + let worker_panic = scope.state.take_panic(); + + match result { + Ok(value) => { + if let Some(payload) = worker_panic { + panic::resume_unwind(payload); + } + value + } + Err(payload) => panic::resume_unwind(payload), + } + } + + fn wait_for_scope_completion(&self, done: &Receiver<()>) { + if !is_background_worker_thread() { + receive_scope_completion(done); + return; + } + + let Some(_guard) = InlineScopeHelpGuard::try_enter() else { + let _backup = BackupWorker::spawn(self); + receive_scope_completion(done); + return; + }; + + let receiver = self.receiver.clone(); + loop { + match done.try_recv() { + Ok(()) => break, + Err(crossbeam::channel::TryRecvError::Empty) => {} + Err(crossbeam::channel::TryRecvError::Disconnected) => { + panic!("scope completion sender dropped before the scope completed"); + } + } + + match receiver.try_recv() { + Ok(job) => { + job(); + continue; + } + Err(crossbeam::channel::TryRecvError::Empty) => {} + Err(crossbeam::channel::TryRecvError::Disconnected) => { + receive_scope_completion(done); + break; + } + } + + select_biased! { + recv(done) -> message => { + expect_scope_completion(message); + break; + } + recv(receiver) -> message => match message { + Ok(job) => job(), + Err(_) => { + receive_scope_completion(done); + break; + } + }, + } + } + } + + #[cfg(test)] + fn backup_workers_spawned(&self) -> usize { + self.backup_workers_spawned.load(Ordering::Acquire) + } + + #[cfg(test)] + fn backup_workers_live(&self) -> usize { + self.backup_workers_live.load(Ordering::Acquire) + } +} + +#[derive(Clone, Copy)] +struct ThreadPoolStatePtr(*const ThreadPoolState); + +impl ThreadPoolStatePtr { + fn new(state: &ThreadPoolState) -> Self { + Self(state) + } + + unsafe fn as_ref(&self) -> &ThreadPoolState { + // SAFETY: callers only use this pointer while the owning `ThreadPool` + // is alive. Worker threads that hold this pointer are joined before the + // boxed state is dropped. + unsafe { &*self.0 } + } +} + +// SAFETY: the pointer targets the boxed `ThreadPoolState` owned by +// `ThreadPool`. `ThreadPool::drop` closes the work channel, joins all workers +// holding this pointer, and only then drops the boxed state. +unsafe impl Send for ThreadPoolStatePtr {} + +// SAFETY: shared access through this pointer only reads immutable pool state or +// uses internally synchronized channel and atomic operations. The pointed-to +// boxed state remains alive until all worker threads have been joined. +unsafe impl Sync for ThreadPoolStatePtr {} + +fn install_pool(pool: &ThreadPoolState, f: F) -> R +where + F: FnOnce() -> R, +{ + install_pool_ptr(pool as *const ThreadPoolState, f) +} + +fn install_pool_ptr(pool: *const ThreadPoolState, f: F) -> R +where + F: FnOnce() -> R, +{ + CURRENT_POOL.with(|current| { + let previous = current.replace(pool); + let _guard = CurrentPoolGuard { current, previous }; + f() + }) +} + +struct CurrentPoolGuard<'a> { + current: &'a Cell<*const ThreadPoolState>, + previous: *const ThreadPoolState, +} + +impl Drop for CurrentPoolGuard<'_> { + fn drop(&mut self) { + self.current.set(self.previous); + } +} + +fn install_background_worker(f: F) -> R +where + F: FnOnce() -> R, +{ + IS_BACKGROUND_WORKER.with(|current| { + let previous = current.replace(true); + let _guard = BackgroundWorkerGuard { current, previous }; + f() + }) +} + +struct BackgroundWorkerGuard<'a> { + current: &'a Cell, + previous: bool, +} + +impl Drop for BackgroundWorkerGuard<'_> { + fn drop(&mut self) { + self.current.set(self.previous); + } +} + +fn is_background_worker_thread() -> bool { + IS_BACKGROUND_WORKER.with(Cell::get) +} + +struct InlineScopeHelpGuard { + previous: usize, +} + +impl InlineScopeHelpGuard { + fn try_enter() -> Option { + INLINE_SCOPE_HELP_DEPTH.with(|depth| { + let previous = depth.get(); + if previous >= MAX_INLINE_SCOPE_HELP_DEPTH { + return None; + } + + depth.set(previous + 1); + Some(Self { previous }) + }) + } +} + +impl Drop for InlineScopeHelpGuard { + fn drop(&mut self) { + INLINE_SCOPE_HELP_DEPTH.with(|depth| depth.set(self.previous)); + } +} + +fn with_current_pool(f: F) -> R +where + F: FnOnce(Option<&ThreadPoolState>) -> R, +{ + CURRENT_POOL.with(|current| { + let pool = current.get(); + // SAFETY: installed pointers are set only by `install_pool` for a + // borrowed `ThreadPoolState`, or by worker threads whose owning + // `ThreadPool` joins them before dropping the boxed state. The returned + // reference is only exposed for the duration of this closure. + let pool = unsafe { pool.as_ref() }; + f(pool) + }) +} + +/// A scoped handle for spawning non-`'static` work onto a [`ThreadPool`]. +/// +/// `Scope` has an invariant lifetime. This permits spawned callbacks to borrow +/// local data while preventing nested callbacks from smuggling shorter-lived +/// borrows into work that may outlive them. +/// +/// # Examples +/// +/// ``` +/// use std::sync::atomic::{AtomicUsize, Ordering}; +/// use egglog_concurrency::ThreadPool; +/// +/// let pool = ThreadPool::new(2); +/// let counter = AtomicUsize::new(0); +/// +/// pool.scope(|scope| { +/// scope.spawn(|_| { +/// counter.fetch_add(1, Ordering::Relaxed); +/// }); +/// }); +/// +/// assert_eq!(counter.load(Ordering::Relaxed), 1); +/// ``` +pub struct Scope<'scope> { + sender: Sender, + pool: ThreadPoolStatePtr, + state: ScopeState, + _scope: PhantomData &'scope ()>, +} + +impl<'scope> Scope<'scope> { + fn new(pool: &ThreadPoolState) -> Self { + Self { + sender: pool.sender.as_ref().unwrap().clone(), + pool: ThreadPoolStatePtr::new(pool), + state: ScopeState::new(), + _scope: PhantomData, + } + } + + /// Spawn a callback onto the pool. + /// + /// The callback receives the current scope and may add nested work. It may + /// borrow values with the scope lifetime. The scope waits for the callback + /// before returning, so those borrows cannot outlive their owners. + /// + /// # Examples + /// + /// ``` + /// use std::sync::atomic::{AtomicUsize, Ordering}; + /// use egglog_concurrency::ThreadPool; + /// + /// let pool = ThreadPool::new(2); + /// let counter = AtomicUsize::new(0); + /// + /// pool.scope(|scope| { + /// scope.spawn(|scope| { + /// counter.fetch_add(1, Ordering::Relaxed); + /// scope.spawn(|_| { + /// counter.fetch_add(1, Ordering::Relaxed); + /// }); + /// }); + /// }); + /// + /// assert_eq!(counter.load(Ordering::Relaxed), 2); + /// ``` + pub fn spawn(&self, f: F) + where + F: FnOnce(&Scope<'scope>) + Send + 'scope, + { + let scope = ScopePtr::new(self); + let job: ScopedJob<'scope> = Box::new(move || { + let result = panic::catch_unwind(AssertUnwindSafe(|| { + // SAFETY: `Scope::complete_root_and_wait` waits for this job + // to call `complete_one` before the stack-allocated scope can + // be destroyed. + let scope = unsafe { scope.as_ref() }; + f(scope); + })); + // SAFETY: `Scope::complete_root_and_wait` waits for this job to call + // `complete_one` before the stack-allocated scope state can be + // destroyed. + let scope = unsafe { scope.as_ref() }; + if let Err(payload) = result { + scope.state.record_panic(payload); + } + scope.state.complete_one(); + }); + + self.state.expect_one(); + // SAFETY: every erased job records completion in the scope state, and + // `Scope::complete_root_and_wait` waits for all expected completions + // before `ThreadPool::scope` returns. + enqueue(&self.sender, unsafe { erase_job_lifetime(job) }); + } + + fn complete_root_and_wait(&self) { + if !self.state.complete_one() { + // SAFETY: the scope is created from a live `ThreadPoolState`, and + // `ThreadPool::drop` joins all workers before dropping that boxed + // state. Scopes cannot outlive the `ThreadPool::scope` call that + // created them. + let pool = unsafe { self.pool.as_ref() }; + self.state.wait(pool); + } + } +} + +struct ScopeState { + completion: AtomicCounts, + done_sender: Sender<()>, + done_receiver: Receiver<()>, + panic: Mutex>, +} + +impl ScopeState { + fn new() -> Self { + let (done_sender, done_receiver) = bounded(1); + Self { + completion: AtomicCounts::with_root_callback(), + done_sender, + done_receiver, + panic: Mutex::new(None), + } + } + + fn expect_one(&self) { + self.completion.expect_one(); + } + + fn complete_one(&self) -> bool { + let previous = self.completion.complete_one(); + let completed = completed(previous) + 1; + let expected = expected(previous); + debug_assert!(completed <= expected); + + if completed == expected { + // Keep the channel alive while signaling completion. Once the + // message is visible, the waiting root may receive it and drop the + // `ScopeState` before `try_send` returns on this worker. + let done_sender = self.done_sender.clone(); + done_sender + .try_send(()) + .expect("scope completion should only be signaled once"); + true + } else { + false + } + } + + fn wait(&self, pool: &ThreadPoolState) { + pool.wait_for_scope_completion(&self.done_receiver); + } + + fn record_panic(&self, payload: PanicPayload) { + let mut slot = self.panic.lock().unwrap_or_else(|err| err.into_inner()); + if slot.is_none() { + *slot = Some(payload); + } + } + + fn take_panic(&self) -> Option { + self.panic + .lock() + .unwrap_or_else(|err| err.into_inner()) + .take() + } +} + +struct AtomicCounts(AtomicU64); + +impl AtomicCounts { + fn with_root_callback() -> Self { + Self(AtomicU64::new(1 << EXPECTED_SHIFT)) + } + + fn expect_one(&self) { + loop { + let current = self.0.load(Ordering::Acquire); + let expected = expected(current); + assert!( + expected < u32::MAX, + "thread pool scope launched more than u32::MAX tasks" + ); + + let next = current + (1 << EXPECTED_SHIFT); + if self + .0 + .compare_exchange_weak(current, next, Ordering::AcqRel, Ordering::Acquire) + .is_ok() + { + return; + } + } + } + + fn complete_one(&self) -> u64 { + self.0.fetch_add(1, Ordering::AcqRel) + } +} + +#[derive(Clone, Copy)] +struct ScopePtr<'scope>(NonNull>); + +impl<'scope> ScopePtr<'scope> { + fn new(scope: &Scope<'scope>) -> Self { + Self(NonNull::from(scope)) + } + + unsafe fn as_ref(&self) -> &Scope<'scope> { + // SAFETY: callers only dereference this pointer from jobs whose + // completion is counted by the pointed-to scope. The parent scope waits + // for every counted completion before the stack-allocated scope is + // destroyed. + unsafe { self.0.as_ref() } + } +} + +// SAFETY: `ScopePtr` is only created for a live scope. Each job that receives +// this pointer must call `complete_one`, and the parent scope waits for all +// completions before the scope is destroyed. +unsafe impl Send for ScopePtr<'_> {} + +unsafe fn erase_job_lifetime<'scope>(job: ScopedJob<'scope>) -> Job { + // SAFETY: `ThreadPool::scope` waits for the root callback and every + // dynamically expected spawned job to finish before returning to the + // caller, so the erased callback cannot run after its captured `'scope` + // borrows expire. + unsafe { mem::transmute::, Job>(job) } +} + +fn receive_scope_completion(done: &Receiver<()>) { + expect_scope_completion(done.recv()); +} + +fn expect_scope_completion(message: Result<(), crossbeam::channel::RecvError>) { + message.expect("scope completion sender dropped before the scope completed"); +} + +/// A short-lived queue consumer used once inline scope helping gets too deep. +/// +/// A worker that waits for nested scoped work usually helps by running queued +/// jobs on the same stack. Deeply nested scopes can make that recursive +/// execution chain large enough to overflow the worker stack. `BackupWorker` +/// provides the same liveness escape hatch as the original implementation, but +/// only after the waiting worker has already helped inline up to +/// [`MAX_INLINE_SCOPE_HELP_DEPTH`]. +struct BackupWorker { + shutdown: Sender<()>, + worker: Option>, +} + +impl BackupWorker { + fn spawn(pool: &ThreadPoolState) -> Self { + #[cfg(test)] + pool.backup_workers_spawned.fetch_add(1, Ordering::AcqRel); + + let (shutdown, shutdown_receiver) = bounded(1); + let receiver = pool.receiver.clone(); + let pool = ThreadPoolStatePtr::new(pool); + let worker = thread::spawn(move || { + // SAFETY: backup workers are joined by the worker that spawned them + // before that worker resumes, and primary workers are joined before + // the boxed pool state is dropped. + let pool = unsafe { pool.as_ref() }; + #[cfg(test)] + let _live = BackupWorkerLiveGuard::new(pool); + + install_pool(pool, || { + install_background_worker(|| { + loop { + select_biased! { + recv(shutdown_receiver) -> _ => break, + recv(receiver) -> message => match message { + Ok(job) => job(), + Err(_) => break, + }, + } + } + }); + }); + }); + + Self { + shutdown, + worker: Some(worker), + } + } + + fn shutdown_and_join(&mut self) { + let _ = self.shutdown.send(()); + if let Some(worker) = self.worker.take() { + let _ = worker.join(); + } + } +} + +impl Drop for BackupWorker { + fn drop(&mut self) { + self.shutdown_and_join(); + } +} + +#[cfg(test)] +struct BackupWorkerLiveGuard<'a> { + pool: &'a ThreadPoolState, +} + +#[cfg(test)] +impl<'a> BackupWorkerLiveGuard<'a> { + fn new(pool: &'a ThreadPoolState) -> Self { + pool.backup_workers_live.fetch_add(1, Ordering::AcqRel); + Self { pool } + } +} + +#[cfg(test)] +impl Drop for BackupWorkerLiveGuard<'_> { + fn drop(&mut self) { + self.pool.backup_workers_live.fetch_sub(1, Ordering::AcqRel); + } +} + +fn spawn_worker(receiver: Receiver, pool: ThreadPoolStatePtr) -> JoinHandle<()> { + thread::spawn(move || { + // SAFETY: each worker is joined before the boxed pool state is dropped. + let pool = unsafe { pool.as_ref() }; + install_pool(pool, || { + install_background_worker(|| { + for job in receiver { + job(); + } + }); + }); + }) +} + +fn enqueue(sender: &Sender, job: Job) { + match sender.send(job) { + Ok(()) => {} + Err(error) => { + let job = error.0; + job(); + } + } +} + +fn completed(value: u64) -> u32 { + (value & COMPLETED_MASK) as u32 +} + +fn expected(value: u64) -> u32 { + (value >> EXPECTED_SHIFT) as u32 +} + +#[cfg(test)] +mod tests; diff --git a/concurrency/src/threadpool/tests.rs b/concurrency/src/threadpool/tests.rs new file mode 100644 index 00000000..4b43edf8 --- /dev/null +++ b/concurrency/src/threadpool/tests.rs @@ -0,0 +1,603 @@ +use std::{ + panic, + sync::{ + Arc, Barrier, Mutex, + atomic::{AtomicBool, AtomicUsize, Ordering}, + }, + thread, + time::Duration, +}; + +use crate::{ + Notification, Scope, ThreadPool, current_num_threads, scope as threadpool_scope, + without_current_pool, +}; + +use super::{MAX_INLINE_SCOPE_HELP_DEPTH, is_background_worker_thread}; + +#[test] +fn scope_runs_spawned_work_and_waits() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + + pool.scope(|scope| { + for _ in 0..128 { + scope.spawn(|_| { + counter.fetch_add(1, Ordering::Relaxed); + }); + } + }); + + assert_eq!(counter.load(Ordering::Relaxed), 128); +} + +#[test] +fn scope_allows_borrowing_stack_data() { + let pool = ThreadPool::new(2); + let values = [1usize, 3, 5, 7, 11]; + let sum = AtomicUsize::new(0); + + pool.scope(|scope| { + for value in &values { + scope.spawn(|_| { + sum.fetch_add(*value, Ordering::Relaxed); + }); + } + }); + + assert_eq!(sum.load(Ordering::Relaxed), values.iter().sum()); +} + +#[test] +fn scope_allows_one_task_to_mutate_stack_data() { + let pool = ThreadPool::new(1); + let mut value = 0; + + pool.scope(|scope| { + scope.spawn(|_| { + value = 42; + }); + }); + + assert_eq!(value, 42); +} + +#[test] +fn scope_handles_work_completed_before_expected_is_published() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + const TASKS: usize = 64; + + pool.scope(|scope| { + for _ in 0..TASKS { + scope.spawn(|_| { + counter.fetch_add(1, Ordering::Release); + }); + } + + while counter.load(Ordering::Acquire) != TASKS { + thread::yield_now(); + } + }); + + assert_eq!(counter.load(Ordering::Acquire), TASKS); +} + +#[test] +fn scope_waits_for_last_work_after_expected_is_published() { + let pool = ThreadPool::new(2); + let release = Arc::new(Notification::new()); + let entered = Arc::new(Notification::new()); + let scope_returned = Arc::new(AtomicBool::new(false)); + + thread::scope(|thread_scope| { + let release_inner = release.clone(); + let entered_inner = entered.clone(); + let scope_returned_inner = scope_returned.clone(); + let pool = &pool; + thread_scope.spawn(move || { + pool.scope(|scope| { + scope.spawn(move |_| { + entered_inner.notify(); + release_inner.wait(); + }); + }); + scope_returned_inner.store(true, Ordering::Release); + }); + + entered.wait(); + thread::sleep(Duration::from_millis(10)); + assert!(!scope_returned.load(Ordering::Acquire)); + release.notify(); + }); + + assert!(scope_returned.load(Ordering::Acquire)); +} + +#[test] +fn many_scopes_cover_completion_races() { + let pool = ThreadPool::new(4); + + for round in 0..512 { + let counter = AtomicUsize::new(0); + let tasks = round % 65; + + pool.scope(|scope| { + for task in 0..tasks { + let counter = &counter; + scope.spawn(move |_| { + if task % 3 == 0 { + thread::yield_now(); + } + counter.fetch_add(1, Ordering::AcqRel); + }); + } + + if round % 2 == 0 { + while counter.load(Ordering::Acquire) != tasks { + thread::yield_now(); + } + } + }); + + assert_eq!(counter.load(Ordering::Acquire), tasks); + } +} + +#[test] +fn blocked_tasks_complete_together() { + let pool = ThreadPool::new(8); + let barrier = Arc::new(Barrier::new(8)); + let counter = AtomicUsize::new(0); + + pool.scope(|scope| { + for _ in 0..8 { + let barrier = barrier.clone(); + let counter = &counter; + scope.spawn(move |_| { + barrier.wait(); + counter.fetch_add(1, Ordering::AcqRel); + }); + } + }); + + assert_eq!(counter.load(Ordering::Acquire), 8); +} + +#[test] +fn nested_spawn_runs_to_completion() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + + pool.scope(|scope| { + for _ in 0..8 { + scope.spawn(|scope| { + counter.fetch_add(1, Ordering::AcqRel); + for _ in 0..8 { + scope.spawn(|_| { + counter.fetch_add(1, Ordering::AcqRel); + }); + } + }); + } + }); + + assert_eq!(counter.load(Ordering::Acquire), 72); +} + +#[test] +fn nested_spawn_can_borrow_scope_data() { + let pool = ThreadPool::new(4); + let values = [2usize, 4, 8, 16]; + let sum = AtomicUsize::new(0); + + pool.scope(|scope| { + for value in &values { + let sum = ∑ + scope.spawn(move |scope| { + scope.spawn(move |_| { + sum.fetch_add(*value, Ordering::AcqRel); + }); + }); + } + }); + + assert_eq!(sum.load(Ordering::Acquire), values.iter().sum()); +} + +#[test] +fn nested_work_spawned_after_root_callback_returns_is_waited_for() { + let pool = ThreadPool::new(2); + let root_returned = Arc::new(Notification::new()); + let release_nested_spawn = Arc::new(Notification::new()); + let nested_ran = Arc::new(AtomicBool::new(false)); + let scope_returned = Arc::new(AtomicBool::new(false)); + + thread::scope(|thread_scope| { + let root_returned_inner = root_returned.clone(); + let release_nested_spawn_inner = release_nested_spawn.clone(); + let nested_ran_inner = nested_ran.clone(); + let scope_returned_inner = scope_returned.clone(); + let pool = &pool; + + thread_scope.spawn(move || { + pool.scope(|scope| { + scope.spawn(move |scope| { + root_returned_inner.wait(); + release_nested_spawn_inner.wait(); + scope.spawn(move |_| { + nested_ran_inner.store(true, Ordering::Release); + }); + }); + }); + scope_returned_inner.store(true, Ordering::Release); + }); + + root_returned.notify(); + thread::sleep(Duration::from_millis(10)); + assert!(!scope_returned.load(Ordering::Acquire)); + release_nested_spawn.notify(); + }); + + assert!(nested_ran.load(Ordering::Acquire)); + assert!(scope_returned.load(Ordering::Acquire)); +} + +#[test] +fn scope_root_callback_can_borrow_shorter_scheduling_data() { + fn increment<'slice, 'counter>(pool: &ThreadPool, counters: &'slice [&'counter AtomicUsize]) { + pool.scope(move |scope: &Scope<'counter>| { + for &counter in counters { + scope.spawn(move |_| { + counter.fetch_add(1, Ordering::Relaxed); + }); + } + }); + } + + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + increment(&pool, &[&counter; 64]); + + assert_eq!(counter.load(Ordering::Relaxed), 64); +} + +#[test] +fn static_scope_still_allows_local_scheduling_iterator() { + static COUNTER: AtomicUsize = AtomicUsize::new(0); + + let pool = ThreadPool::new(4); + let mut range = 0..32; + let expected = range.clone().sum(); + let iter = &mut range; + + COUNTER.store(0, Ordering::Relaxed); + pool.scope(|scope: &Scope<'static>| { + for value in iter { + scope.spawn(move |_| { + COUNTER.fetch_add(value, Ordering::Relaxed); + }); + } + }); + + assert_eq!(COUNTER.load(Ordering::Relaxed), expected); +} + +#[test] +fn worker_panic_is_propagated_after_other_tasks_finish() { + let pool = ThreadPool::new(2); + let completed = Arc::new(AtomicUsize::new(0)); + + let result = { + let completed = completed.clone(); + panic::catch_unwind(panic::AssertUnwindSafe(|| { + pool.scope(|scope| { + scope.spawn(|_| panic!("worker panic")); + scope.spawn(move |_| { + completed.fetch_add(1, Ordering::Release); + }); + }); + })) + }; + + assert!(result.is_err()); + assert_eq!(completed.load(Ordering::Acquire), 1); +} + +#[test] +fn outer_panic_still_waits_for_spawned_work() { + let pool = ThreadPool::new(1); + let completed = AtomicBool::new(false); + + let result = panic::catch_unwind(panic::AssertUnwindSafe(|| { + pool.scope(|scope| { + scope.spawn(|_| { + completed.store(true, Ordering::Release); + }); + panic!("outer panic"); + }); + })); + + assert!(result.is_err()); + assert!(completed.load(Ordering::Acquire)); +} + +#[test] +fn parallel_for_each_processes_borrowed_items() { + let pool = ThreadPool::new(4); + let values = vec![1usize, 2, 3, 4, 5, 6]; + let seen = Mutex::new(Vec::new()); + + pool.parallel_for_each(values.iter(), |value| { + seen.lock().unwrap().push(*value); + }); + + let mut seen = seen.into_inner().unwrap(); + seen.sort_unstable(); + assert_eq!(seen, values); +} + +#[test] +fn parallel_for_each_waits_for_all_work() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + + pool.parallel_for_each(0..256, |_| { + counter.fetch_add(1, Ordering::AcqRel); + }); + + assert_eq!(counter.load(Ordering::Acquire), 256); +} + +#[test] +fn dropping_pool_closes_workers() { + let pool = ThreadPool::new(4); + assert_eq!(pool.thread_count(), 4); + drop(pool); +} + +#[test] +fn current_num_threads_is_one_without_installed_pool() { + assert_eq!(current_num_threads(), 1); +} + +#[test] +fn install_sets_and_restores_current_pool() { + let outer = ThreadPool::new(2); + let inner = ThreadPool::new(3); + + assert_eq!(current_num_threads(), 1); + outer.install(|| { + assert_eq!(current_num_threads(), 2); + inner.install(|| { + assert_eq!(current_num_threads(), 3); + }); + assert_eq!(current_num_threads(), 2); + }); + assert_eq!(current_num_threads(), 1); +} + +#[test] +fn without_current_pool_clears_and_restores_current_pool() { + let pool = ThreadPool::new(2); + + pool.install(|| { + assert_eq!(current_num_threads(), 2); + without_current_pool(|| { + assert_eq!(current_num_threads(), 1); + }); + assert_eq!(current_num_threads(), 2); + }); + + assert_eq!(current_num_threads(), 1); +} + +#[test] +fn pool_scope_installs_pool_for_root_and_spawned_callbacks() { + let pool = ThreadPool::new(4); + + pool.scope(|scope| { + assert_eq!(current_num_threads(), 4); + scope.spawn(|_| { + assert_eq!(current_num_threads(), 4); + }); + }); + + assert_eq!(pool.state.backup_workers_spawned(), 0); + assert_eq!(pool.state.backup_workers_live(), 0); +} + +#[test] +fn free_scope_uses_installed_pool() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + + pool.install(|| { + threadpool_scope(|scope| { + assert_eq!(current_num_threads(), 4); + scope.spawn(|_| { + assert_eq!(current_num_threads(), 4); + counter.fetch_add(1, Ordering::Relaxed); + }); + }); + }); + + assert_eq!(counter.load(Ordering::Relaxed), 1); +} + +#[test] +fn free_scope_works_from_spawned_callback() { + let pool = ThreadPool::new(4); + let counter = AtomicUsize::new(0); + + pool.scope(|scope| { + scope.spawn(|_| { + threadpool_scope(|scope| { + scope.spawn(|_| { + assert_eq!(current_num_threads(), 4); + counter.fetch_add(1, Ordering::Relaxed); + }); + }); + }); + }); + + assert_eq!(counter.load(Ordering::Relaxed), 1); +} + +#[test] +#[should_panic(expected = "no egglog thread pool is currently installed")] +fn free_scope_panics_without_installed_pool() { + threadpool_scope(|_| {}); +} + +#[test] +fn primary_workers_are_marked_as_background_workers() { + let pool = ThreadPool::new(1); + + assert!(!is_background_worker_thread()); + pool.scope(|scope| { + assert!(!is_background_worker_thread()); + scope.spawn(|_| { + assert!(is_background_worker_thread()); + }); + }); +} + +#[test] +fn root_scope_waits_for_spawned_work() { + let pool = ThreadPool::new(1); + let entered = Arc::new(Notification::new()); + let release = Arc::new(Notification::new()); + + thread::scope(|thread_scope| { + let entered_inner = entered.clone(); + let release_inner = release.clone(); + let pool = &pool; + thread_scope.spawn(move || { + pool.scope(|scope| { + scope.spawn(move |_| { + entered_inner.notify(); + release_inner.wait(); + }); + }); + }); + + entered.wait(); + thread::sleep(Duration::from_millis(10)); + release.notify(); + }); + + assert_eq!(pool.state.backup_workers_spawned(), 0); + assert_eq!(pool.state.backup_workers_live(), 0); +} + +#[test] +fn background_worker_helps_single_worker_nested_scope() { + let pool = ThreadPool::new(1); + let nested_completed = AtomicBool::new(false); + + pool.scope(|scope| { + scope.spawn(|_| { + threadpool_scope(|nested| { + nested.spawn(|_| { + assert!(is_background_worker_thread()); + assert_eq!(current_num_threads(), 1); + nested_completed.store(true, Ordering::Release); + }); + }); + }); + }); + + assert!(nested_completed.load(Ordering::Acquire)); + assert_eq!(pool.state.backup_workers_spawned(), 0); + assert_eq!(pool.state.backup_workers_live(), 0); +} + +#[test] +fn background_worker_wait_returns_after_nested_scope_finishes() { + let pool = ThreadPool::new(1); + let nested_started = Arc::new(Notification::new()); + let release_nested = Arc::new(Notification::new()); + let scope_returned = Arc::new(AtomicBool::new(false)); + + thread::scope(|thread_scope| { + let nested_started_inner = nested_started.clone(); + let release_nested_inner = release_nested.clone(); + let scope_returned_inner = scope_returned.clone(); + let pool = &pool; + thread_scope.spawn(move || { + pool.scope(|scope| { + scope.spawn(move |_| { + threadpool_scope(|nested| { + nested.spawn(move |_| { + nested_started_inner.notify(); + release_nested_inner.wait(); + }); + }); + }); + }); + scope_returned_inner.store(true, Ordering::Release); + }); + + nested_started.wait(); + thread::sleep(Duration::from_millis(10)); + assert!(!scope_returned.load(Ordering::Acquire)); + release_nested.notify(); + }); + + assert!(scope_returned.load(Ordering::Acquire)); + assert_eq!(pool.state.backup_workers_spawned(), 0); + assert_eq!(pool.state.backup_workers_live(), 0); +} + +#[test] +fn nested_background_worker_waits_can_reenter_help_loop() { + let pool = ThreadPool::new(1); + let completed = AtomicUsize::new(0); + + pool.scope(|scope| { + scope.spawn(|_| { + threadpool_scope(|scope| { + scope.spawn(|_| { + threadpool_scope(|scope| { + scope.spawn(|_| { + assert!(is_background_worker_thread()); + completed.fetch_add(1, Ordering::Release); + }); + }); + }); + }); + }); + }); + + assert_eq!(completed.load(Ordering::Acquire), 1); + assert_eq!(pool.state.backup_workers_spawned(), 0); + assert_eq!(pool.state.backup_workers_live(), 0); +} + +#[test] +fn deeply_nested_background_waits_fall_back_to_backup_worker() { + fn recurse(depth: usize, completed: &AtomicUsize) { + if depth == 0 { + completed.fetch_add(1, Ordering::Release); + return; + } + + threadpool_scope(|scope| { + scope.spawn(move |_| recurse(depth - 1, completed)); + }); + } + + let pool = ThreadPool::new(1); + let completed = AtomicUsize::new(0); + + pool.scope(|scope| { + scope.spawn(|_| { + recurse(MAX_INLINE_SCOPE_HELP_DEPTH + 8, &completed); + }); + }); + + assert_eq!(completed.load(Ordering::Acquire), 1); + assert!(pool.state.backup_workers_spawned() >= 1); + assert_eq!(pool.state.backup_workers_live(), 0); +} diff --git a/core-relations/Cargo.toml b/core-relations/Cargo.toml index 942326bf..e73e2b4c 100644 --- a/core-relations/Cargo.toml +++ b/core-relations/Cargo.toml @@ -28,7 +28,6 @@ crossbeam = { workspace = true } crossbeam-queue = { workspace = true } dashmap = { workspace = true, features = ["raw-api"] } web-time = { workspace = true } -rayon = { workspace = true } rand = { workspace = true } dyn-clone = { workspace = true } num = { workspace = true } @@ -37,11 +36,16 @@ once_cell = { workspace = true } [dev-dependencies] divan = { workspace = true } mimalloc = { workspace = true } +rayon = { workspace = true } [[bench]] name = "writes" harness = false +[[bench]] +name = "build_index" +harness = false + [features] default = [] debug-val-trace = [] diff --git a/core-relations/benches/build_index.rs b/core-relations/benches/build_index.rs new file mode 100644 index 00000000..5160def5 --- /dev/null +++ b/core-relations/benches/build_index.rs @@ -0,0 +1,88 @@ +//! Microbenchmarks for building `ColumnIndex`es. +//! +//! Two questions motivate these: +//! * `sort_merge_*`: the rebuild path sorts and merges `(Value, RowId)` pairs with hand-written +//! radix sort + tournament merge instead of the standard library. These compare the two so we +//! can track the speedup rather than assume it. +//! * `build_*`: end-to-end index construction, serially vs. in parallel, across subset sizes. + +use divan::{Bencher, counter::ItemsCount}; +use egglog_core_relations::bench_support::{ + IndexInput, gen_blocks, sort_merge_custom, sort_merge_std, with_threads, +}; + +fn main() { + divan::main() +} + +/// Values are drawn from `rows / DISTINCT_DIVISOR` distinct keys, giving each value several rows. +const DISTINCT_DIVISOR: u32 = 8; + +fn distinct_for(rows: usize) -> u32 { + ((rows as u32) / DISTINCT_DIVISOR).max(1) +} + +// -- Sort + merge primitives: custom vs. standard library --------------------------------------- + +/// Single column: only the per-block sort runs (no merge). Custom = radix sort. +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn sort_single_custom(bench: Bencher) { + let (pairs, bounds) = gen_blocks(N, 1, distinct_for(N), 1); + bench + .with_inputs(|| pairs.clone()) + .input_counter(|p| ItemsCount::new(p.len())) + .bench_values(|p| sort_merge_custom(p, &bounds)); +} + +/// Single column, standard `sort_unstable`. No dedup: with one pair per row every `RowId` is +/// distinct, so no `(Value, RowId)` pair repeats -- matching what the custom path does here. +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn sort_single_std(bench: Bencher) { + let (pairs, _bounds) = gen_blocks(N, 1, distinct_for(N), 1); + bench + .with_inputs(|| pairs.clone()) + .input_counter(|p| ItemsCount::new(p.len())) + .bench_values(|p| sort_merge_std(p, false)); +} + +/// Four columns: per-block radix sort followed by the tournament merge with dedup. +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn merge_multi_custom(bench: Bencher) { + let (pairs, bounds) = gen_blocks(N, 4, distinct_for(N), 1); + bench + .with_inputs(|| pairs.clone()) + .input_counter(|p| ItemsCount::new(p.len())) + .bench_values(|p| sort_merge_custom(p, &bounds)); +} + +/// Four columns, standard `sort_unstable` + `dedup` over the whole concatenation (a value can +/// repeat across a row's columns, so duplicate pairs are possible and must be dropped). +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn merge_multi_std(bench: Bencher) { + let (pairs, _bounds) = gen_blocks(N, 4, distinct_for(N), 1); + bench + .with_inputs(|| pairs.clone()) + .input_counter(|p| ItemsCount::new(p.len())) + .bench_values(|p| sort_merge_std(p, true)); +} + +// -- End-to-end index construction: serial vs. parallel ----------------------------------------- + +const N_VAL_COLS: usize = 3; + +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn build_serial(bench: Bencher) { + bench + .with_inputs(|| IndexInput::random(N, N_VAL_COLS, distinct_for(N), 1)) + .input_counter(|_| ItemsCount::new(N * N_VAL_COLS)) + .bench_refs(|input| input.build_serial()); +} + +#[divan::bench(consts = [4096, 65_536, 1 << 20])] +fn build_parallel(bench: Bencher) { + let threads = std::thread::available_parallelism().map_or(1, |n| n.get()); + bench + .with_inputs(|| IndexInput::random(N, N_VAL_COLS, distinct_for(N), 1)) + .input_counter(|_| ItemsCount::new(N * N_VAL_COLS)) + .bench_refs(|input| with_threads(threads, || input.build_parallel())); +} diff --git a/core-relations/src/containers/mod.rs b/core-relations/src/containers/mod.rs index 39c7e5f5..640852ba 100644 --- a/core-relations/src/containers/mod.rs +++ b/core-relations/src/containers/mod.rs @@ -17,16 +17,13 @@ use std::{ use crate::numeric_id::{DenseIdMap, IdVec, NumericId, define_id}; use crossbeam_queue::SegQueue; use dashmap::SharedValue; -use rayon::{ - iter::{ParallelBridge, ParallelIterator}, - prelude::*, -}; use rustc_hash::FxHasher; use crate::{ ColumnId, CounterId, ExecutionState, Offset, SubsetRef, TableId, TaggedRowBuffer, Value, WrappedTable, common::{DashMap, IndexSet, SubsetTracker}, + parallel, parallel_heuristics::{parallelize_inter_container_op, parallelize_intra_container_op}, table_spec::{Rebuilder, ValueRebuilder}, }; @@ -202,22 +199,20 @@ impl ContainerValues { self.subset_tracker.recent_updates(table_id, table) }); let mut summary = if parallelize_inter_container_op(self.data.next_id().index()) { - self.data - .iter_mut() - .zip(std::iter::repeat_with(|| exec_state.clone())) - .par_bridge() - .map(|((_, env), mut exec_state)| { - env.apply_rebuild( - table, - &*rebuilder, - to_scan.as_ref().map(|x| x.as_ref()), - &mut exec_state, - ) - }) - .reduce(ContainerRebuildSummary::default, |mut acc, summary| { - acc.extend(summary); - acc - }) + parallel::map_dense_id_map_mut(&mut self.data, |_, env| { + let mut exec_state = exec_state.clone(); + env.apply_rebuild( + table, + &*rebuilder, + to_scan.as_ref().map(|x| x.as_ref()), + &mut exec_state, + ) + }) + .into_iter() + .fold(ContainerRebuildSummary::default(), |mut acc, summary| { + acc.extend(summary); + acc + }) } else { let mut summary = ContainerRebuildSummary::default(); for (_, env) in self.data.iter_mut() { @@ -631,110 +626,104 @@ impl ContainerEnv { to_reinsert.resize_with(self.to_id.shards().len(), Default::default); let shards = self.to_id.shards_mut(); - let changed = shards - .par_iter_mut() - .map(|shard| { - let mut changed = false; - let shard = shard.get_mut(); - // SAFETY: the iterator does not outlive `shard`. - for bucket in unsafe { shard.iter() } { - // SAFETY: the bucket is valid; we just got it from the iterator. - let (container, val) = unsafe { bucket.as_mut() }; - let old_val = *val.get(); - let new_val = rebuilder.rebuild_val(old_val); - let container_changed = container.rebuild_contents(rebuilder); - if !container_changed && new_val == old_val { - // Nothing changed about this entry. Leave it in place. - continue; - } - changed = true; - if container_changed { - // The container changed. Remove both map entries then reinsert. - // SAFETY: This is a valid bucket. Furthermore, iterators remain valid if - // buckets they have already yielded have been removed. - let ((container, _), _) = unsafe { shard.remove(bucket) }; - self.to_container.remove(&old_val); - // Spooky: we're using `to_container` to determine the shard for - // `to_id`. We are assuming that the # shards determination is - // deterministic here. There is a debug assertion in `get_or_insert` - // that attempts to verify this. - let shard = self - .to_container - .determine_shard(hash_container(&container) as usize); - to_reinsert[shard].push((container, new_val, new_val == old_val)); - } else { - // Just the value changed. Leave the container in place. - *val.get_mut() = new_val; - let prev = self.to_container.remove(&old_val).unwrap().1; - self.to_container.insert(new_val, prev); - } + let changed = parallel::map_mut(shards, |_, shard| { + let mut changed = false; + let shard = shard.get_mut(); + // SAFETY: the iterator does not outlive `shard`. + for bucket in unsafe { shard.iter() } { + // SAFETY: the bucket is valid; we just got it from the iterator. + let (container, val) = unsafe { bucket.as_mut() }; + let old_val = *val.get(); + let new_val = rebuilder.rebuild_val(old_val); + let container_changed = container.rebuild_contents(rebuilder); + if !container_changed && new_val == old_val { + // Nothing changed about this entry. Leave it in place. + continue; } - changed - }) - .max() - .unwrap_or(false); + changed = true; + if container_changed { + // The container changed. Remove both map entries then reinsert. + // SAFETY: This is a valid bucket. Furthermore, iterators remain valid if + // buckets they have already yielded have been removed. + let ((container, _), _) = unsafe { shard.remove(bucket) }; + self.to_container.remove(&old_val); + // Spooky: we're using `to_container` to determine the shard for + // `to_id`. We are assuming that the # shards determination is + // deterministic here. There is a debug assertion in `get_or_insert` + // that attempts to verify this. + let shard = self + .to_container + .determine_shard(hash_container(&container) as usize); + to_reinsert[shard].push((container, new_val, new_val == old_val)); + } else { + // Just the value changed. Leave the container in place. + *val.get_mut() = new_val; + let prev = self.to_container.remove(&old_val).unwrap().1; + self.to_container.insert(new_val, prev); + } + } + changed + }) + .into_iter() + .any(|changed| changed); let dirty_ids = SegQueue::new(); - shards - .iter_mut() - .enumerate() - .map(|(i, shard)| (i, shard, exec_state.clone())) - .par_bridge() - .for_each(|(shard_id, shard, mut exec_state)| { - // This bit is a real slog. Once Dashmap updates from RawTable to HashTable for - // the underlying shard, this will get a little better. - // - // NB: We are probably leaving some paralellism on the floor with these calls - // to `to_container` and `val_index`. - let shard = shard.get_mut(); - let queue = &to_reinsert[shard_id]; - while let Some((container, val, stable_id)) = queue.pop() { - let hc = hash_container(&container); - let target_map = self.to_container.determine_shard(hc as usize); - match shard.find_or_find_insert_slot( - hc, - |(c, _)| c == &container, - |(c, _)| hash_container(c), - ) { - Ok(bucket) => { - // SAFETY: the bucket is valid; we just got it from the shard and - // we have not done any operations that can invalidate the bucket. - let (container, val_slot) = unsafe { bucket.as_mut() }; - let old_val = *val_slot.get(); - let result = (self.merge_fn)(&mut exec_state, old_val, val); - if result != old_val { - self.to_container.remove(&old_val); - self.to_container.insert(result, (hc as usize, target_map)); - *val_slot.get_mut() = result; - for val in container.iter() { - let mut index = self.val_index.entry(val).or_default(); - index.swap_remove(&old_val); - index.insert(result); - } - } - // As in the serial path, only same-id semantic - // changes need an explicit parent-row refresh. - if stable_id && result == val { - dirty_ids.push(val); + parallel::for_each_mut(shards, |shard_id, shard| { + let mut exec_state = exec_state.clone(); + // This bit is a real slog. Once Dashmap updates from RawTable to HashTable for + // the underlying shard, this will get a little better. + // + // NB: We are probably leaving some paralellism on the floor with these calls + // to `to_container` and `val_index`. + let shard = shard.get_mut(); + let queue = &to_reinsert[shard_id]; + while let Some((container, val, stable_id)) = queue.pop() { + let hc = hash_container(&container); + let target_map = self.to_container.determine_shard(hc as usize); + match shard.find_or_find_insert_slot( + hc, + |(c, _)| c == &container, + |(c, _)| hash_container(c), + ) { + Ok(bucket) => { + // SAFETY: the bucket is valid; we just got it from the shard and + // we have not done any operations that can invalidate the bucket. + let (container, val_slot) = unsafe { bucket.as_mut() }; + let old_val = *val_slot.get(); + let result = (self.merge_fn)(&mut exec_state, old_val, val); + if result != old_val { + self.to_container.remove(&old_val); + self.to_container.insert(result, (hc as usize, target_map)); + *val_slot.get_mut() = result; + for val in container.iter() { + let mut index = self.val_index.entry(val).or_default(); + index.swap_remove(&old_val); + index.insert(result); } } - Err(slot) => { - self.to_container.insert(val, (hc as usize, target_map)); - for v in container.iter() { - self.val_index.entry(v).or_default().insert(val); - } - // SAFETY: We just got this slot from `find_or_find_insert_slot` - // and we have not mutated the map at all since then. - unsafe { - shard.insert_in_slot(hc, slot, (container, SharedValue::new(val))); - } - if stable_id { - dirty_ids.push(val); - } + // As in the serial path, only same-id semantic + // changes need an explicit parent-row refresh. + if stable_id && result == val { + dirty_ids.push(val); + } + } + Err(slot) => { + self.to_container.insert(val, (hc as usize, target_map)); + for v in container.iter() { + self.val_index.entry(v).or_default().insert(val); + } + // SAFETY: We just got this slot from `find_or_find_insert_slot` + // and we have not mutated the map at all since then. + unsafe { + shard.insert_in_slot(hc, slot, (container, SharedValue::new(val))); + } + if stable_id { + dirty_ids.push(val); } } } - }); + } + }); let mut summary = ContainerRebuildSummary::default(); if changed { summary.note_change(); diff --git a/core-relations/src/free_join/execute.rs b/core-relations/src/free_join/execute.rs index dfda4ee5..39d4b0f2 100644 --- a/core-relations/src/free_join/execute.rs +++ b/core-relations/src/free_join/execute.rs @@ -3,11 +3,14 @@ use std::{ cmp, iter, mem, ops::Range, - sync::{Arc, OnceLock, RwLock, atomic::AtomicUsize}, + sync::{ + Arc, OnceLock, RwLock, + atomic::{AtomicUsize, Ordering}, + }, }; use crate::{ - common::{HashMap, IndexMap}, + common::{HashMap, HashSet, IndexMap}, free_join::plan::{JoinStages, MatId, MatScanMode, MatSpec}, numeric_id::{DenseIdMap, IdVec, NumericId}, query::Atom, @@ -16,6 +19,7 @@ use crate::{ use crossbeam::utils::CachePadded; use dashmap::mapref::entry::Entry; use dashmap::mapref::one::RefMut; +use egglog_concurrency::Scope; use egglog_reports::{ReportLevel, RuleReport, RuleSetReport}; use smallvec::SmallVec; use web_time::Instant; @@ -28,9 +32,9 @@ use crate::{ frame_update::{FrameUpdates, UpdateInstr}, get_index_from_tableinfo, }, - hash_index::{ColumnIndex, IndexBase, TupleIndex}, + hash_index::{IndexBase, TupleIndex}, offsets::{Offsets, RowId, SortedOffsetSlice, SortedOffsetVector, Subset}, - parallel_heuristics::parallelize_db_level_op, + parallel_heuristics::{action_batch_size, free_join_fork_depth, parallelize_db_level_op}, pool::Pooled, query::RuleSet, row_buffer::TaggedRowBuffer, @@ -38,7 +42,7 @@ use crate::{ }; use super::{ - ActionId, AtomId, Database, HashColumnIndex, HashIndex, TableInfo, Variable, + ActionId, AtomId, Database, HashColumnIndex, HashIndex, TableId, TableInfo, Variable, get_column_index_from_tableinfo, plan::{JoinHeader, JoinStage, Plan}, with_pool_set, @@ -152,6 +156,94 @@ impl SparseColumnIndex { } } +/// Return a `SubsetRef` for `ids[range]`, which must be nonempty and sorted +/// ascending. A contiguous run is returned as `Dense` to avoid a pool +/// allocation when the subset is later materialized. +/// +/// # Safety +/// `ids[range]` must be sorted in non-decreasing order. +#[inline] +unsafe fn dense_or_sparse_ref(ids: &[RowId], range: Range) -> SubsetRef<'_> { + let slice = &ids[range]; + let first = slice[0]; + let last = slice[slice.len() - 1]; + if last.index() - first.index() == slice.len() - 1 { + SubsetRef::Dense(OffsetRange::new(first, last.inc())) + } else { + // SAFETY: caller guarantees `slice` is sorted. + SubsetRef::Sparse(unsafe { SortedOffsetSlice::new_unchecked(slice) }) + } +} + +/// A heap-allocated, sort-based single-column index for on-the-fly (per-subset) +/// indexing during joins. +/// +/// Unlike a hash-based column index, the (value -> rows) groups live in sorted +/// arrays: `for_each` walks them directly and `get_subset` binary-searches the +/// keys. Building it therefore skips hash-table construction, which is wasteful +/// for the high-cardinality columns joined on in an e-graph, where each value +/// typically maps to only one or two rows. +pub(crate) struct SortedColumnIndex { + /// Distinct column values (ascending) paired with the start offset of their + /// rows in `row_ids`. A trailing `(_, row_ids.len())` sentinel delimits the + /// final group. + keys: Vec<(Value, u32)>, + /// Row ids grouped by key; each group is ascending. + row_ids: Vec, +} + +impl SortedColumnIndex { + fn build_for_subset(table: WrappedTableRef, subset: SubsetRef, col: ColumnId) -> Self { + let mut pairs: Vec<(Value, RowId)> = Vec::new(); + // Rows arrive in RowId-ascending order, so a value-stable sort leaves + // each value's rows ascending. + table.collect_col_pairs(subset, col, &mut pairs); + let mut scratch = vec![(Value::new_const(0), RowId::new_const(0)); pairs.len()]; + crate::hash_index::radix_sort_slice_by_value(&mut pairs, &mut scratch); + drop(scratch); + + let mut keys: Vec<(Value, u32)> = Vec::new(); + let mut row_ids: Vec = Vec::with_capacity(pairs.len()); + for (val, row) in pairs { + if keys.last().map(|&(v, _)| v) != Some(val) { + keys.push((val, row_ids.len() as u32)); + } + row_ids.push(row); + } + keys.push((Value::new_const(0), row_ids.len() as u32)); + SortedColumnIndex { keys, row_ids } + } + + fn get_subset(&self, key: Value) -> Option> { + // The trailing sentinel is never a real match: it is stored as value 0 + // but the search space excludes it via the `len - 1` bound below. + let n = self.len(); + let i = self.keys[..n] + .binary_search_by_key(&key, |&(v, _)| v) + .ok()?; + let lo = self.keys[i].1 as usize; + let hi = self.keys[i + 1].1 as usize; + // SAFETY: rows within a single key's range are ascending (see `build_for_subset`). + Some(unsafe { dense_or_sparse_ref(&self.row_ids, lo..hi) }) + } + + fn for_each(&self, mut f: impl FnMut(Value, SubsetRef)) { + let n = self.len(); + for i in 0..n { + let (val, lo) = self.keys[i]; + let hi = self.keys[i + 1].1 as usize; + // SAFETY: see `get_subset`. + let subset = unsafe { dense_or_sparse_ref(&self.row_ids, lo as usize..hi) }; + f(val, subset); + } + } + + fn len(&self) -> usize { + // The last entry is the sentinel offset, not a key. + self.keys.len().saturating_sub(1) + } +} + enum DynamicIndex { Cached { /// When Some(range), intersect each subset from the index with this dense range. @@ -166,7 +258,7 @@ enum DynamicIndex { table: HashColumnIndex, }, Dynamic(TupleIndex), - DynamicColumn(Arc), + DynamicColumn(Arc), SparseColumn(SparseColumnIndex), } @@ -199,13 +291,6 @@ impl PotentiallyStale> { fn size(&self) -> usize { self.inner.size() } - - fn to_owned(&self, pool: &Pool) -> PotentiallyStale { - PotentiallyStale { - inner: self.inner.to_owned(pool), - can_be_stale: self.can_be_stale, - } - } } /// Intersect a `SubsetRef` with a dense `OffsetRange` and return the result as a @@ -273,7 +358,7 @@ impl Prober { } DynamicIndex::Dynamic(tab) => tab.get_subset(key).map(PotentiallyStale::not_stale), DynamicIndex::DynamicColumn(tab) => { - tab.get_subset(&key[0]).map(PotentiallyStale::not_stale) + tab.get_subset(key[0]).map(PotentiallyStale::not_stale) } DynamicIndex::SparseColumn(tab) => { debug_assert_eq!(key.len(), 1); @@ -325,7 +410,7 @@ impl Prober { tab.for_each(|k, v| f(k, PotentiallyStale::not_stale(v))); } DynamicIndex::DynamicColumn(tab) => tab.for_each(|k, v| { - f(&[*k], PotentiallyStale::not_stale(v)); + f(&[k], PotentiallyStale::not_stale(v)); }), DynamicIndex::SparseColumn(tab) => { tab.for_each(|k, v| f(k, PotentiallyStale::not_stale(v))); @@ -350,6 +435,28 @@ impl Database { return RuleSetReport::default(); } let match_counter = Arc::new(MatchCounter::new(rule_set.actions.n_ids())); + // Trie roots are shared across all plans in this run. Tables are frozen + // for the duration, so a given root key always denotes the same subset; + // the cache is scoped to (and dropped at the end of) this call. Only + // roots used by more than one plan are shared. + // + // The `mark_shared_roots` pre-pass and the per-atom root-signature work + // are a fixed cost paid every call; on small databases (few/cheap index + // builds) that cost outweighs the sharing it enables. Gate it on the + // database size so small rule-set runs keep the zero-overhead per-plan + // path (an empty `shared` set makes `root_node` skip the signature + // entirely). The estimate grows over a run, so early/cheap iterations + // stay ungated while large ones opt in exactly when sharing pays off. + // Enable cross-plan root sharing only when some root is actually reused + // across plans. `None` means `root_node` builds fresh per-plan roots with + // zero added work — no signature machinery and (crucially on many-core + // hosts) no DashMap allocation. The pre-pass is a cheap scan of the plans' + // atoms; the shard count is matched to the thread count (see `with_shared`). + let trie_cache: Option> = { + let shared = + TrieCache::compute_shared(rule_set.plans.values().map(|(plan, _, _)| plan)); + (!shared.is_empty()).then(|| Arc::new(TrieCache::with_shared(shared))) + }; let search_and_apply_timer = Instant::now(); // let mut rule_reports: HashMap>; @@ -359,7 +466,7 @@ impl Database { let dash_rule_reports: Arc, Vec>> = Arc::new(DashMap::default()); let db: &Database = self; - rayon::in_place_scope(|scope| { + egglog_concurrency::scope(|scope| { for (plan, desc, symbol_map) in rule_set.plans.values() { // TODO: add stats let report_plan = match report_level { @@ -373,30 +480,22 @@ impl Database { let desc = desc.clone(); let exec_state = exec_state.clone(); let match_counter = match_counter.clone(); + let trie_cache = trie_cache.clone(); scope.spawn(move |rule_scope| { - let join_state = JoinState::new(db, exec_state.clone()); + let join_state = JoinState::new(db, exec_state.clone(), trie_cache); let mut binding_info = BindingInfo::default(); - for (id, info) in plan.atoms().iter() { - let table = join_state.db.get_table(info.table); - binding_info.insert_subset(id, table.all()); - } let mut action_buf = ScopedActionBuffer::new(rule_scope, rule_set, match_counter.clone()); let search_and_apply_timer = Instant::now(); 'eval: { - for JoinHeader { atom, subset, .. } in plan.header() { - if subset.is_empty() { - break 'eval; - } - let mut cur = - Arc::try_unwrap(binding_info.unwrap_val(*atom)).unwrap(); - debug_assert!(cur.cached_subsets.get().is_none()); - cur.subset.intersect(subset.as_ref(), &join_state.pool); - if cur.subset.is_empty() { - break 'eval; + for (id, info) in plan.atoms().iter() { + let headers: SmallVec<[&JoinHeader; 2]> = + plan.header().iter().filter(|h| h.atom == id).collect(); + match join_state.root_node(info.table, &headers) { + Some(node) => binding_info.insert_node(id, node), + None => break 'eval, } - binding_info.move_back_node(*atom, Arc::new(cur)); } match plan { @@ -436,7 +535,7 @@ impl Database { plan.stages.blocks.iter().enumerate() { let mat_id = MatId::from_usize(mat_id); - rayon::in_place_scope(|stage_scope| { + egglog_concurrency::scope(|stage_scope| { let mut materializer = ScopedMaterializer { scope: stage_scope, specs: specs.clone(), @@ -499,7 +598,7 @@ impl Database { .collect(); } else { rule_reports = HashMap::default(); - let join_state = JoinState::new(self, exec_state.clone()); + let join_state = JoinState::new(self, exec_state.clone(), trie_cache.clone()); // Just run all of the plans in order with a single in-place action // buffer. let mut action_buf = InPlaceActionBuffer { @@ -516,26 +615,15 @@ impl Database { }; let mut binding_info = BindingInfo::default(); - for (id, info) in plan.atoms().iter() { - let table = join_state.db.get_table(info.table); - binding_info.insert_subset(id, table.all()); - } - let search_and_apply_timer = Instant::now(); 'eval: { - for JoinHeader { atom, subset, .. } in plan.header() { - if subset.is_empty() { - break 'eval; - } - // Before query execution, Arc is owned exclusively by the binding info. - // Trie nodes are only shared once we start running the query. - let mut cur = Arc::try_unwrap(binding_info.unwrap_val(*atom)).unwrap(); - debug_assert!(cur.cached_subsets.get().is_none()); - cur.subset.intersect(subset.as_ref(), &join_state.pool); - if cur.subset.is_empty() { - break 'eval; + for (id, info) in plan.atoms().iter() { + let headers: SmallVec<[&JoinHeader; 2]> = + plan.header().iter().filter(|h| h.atom == id).collect(); + match join_state.root_node(info.table, &headers) { + Some(node) => binding_info.insert_node(id, node), + None => break 'eval, } - binding_info.move_back_node(*atom, Arc::new(cur)); } match plan { Plan::SinglePlan(plan) => { @@ -641,12 +729,12 @@ struct ActionState { bindings: Bindings, } -impl Default for ActionState { - fn default() -> Self { +impl ActionState { + fn new(batch_size: usize) -> Self { Self { n_runs: 0, len: 0, - bindings: Bindings::new(VAR_BATCH_SIZE), + bindings: Bindings::new(batch_size), } } } @@ -657,14 +745,128 @@ struct JoinState<'a> { /// Cached thread-local pool for SortedOffsetVector allocations. /// Stored here to avoid a per-call `with_pool_set` TLS access in `get_index`. pool: Pool, + /// Cross-plan trie-root cache for the current `run_rule_set`, or `None` when + /// sharing is disabled (small run, or nothing reused across plans). + trie_cache: Option>, } /// Per-column indexes on a trie node's subset, lazily initialized on first access per column. -type ColumnIndexes = IdVec>>; +type ColumnIndexes = IdVec>>; // Each TrieNode is probed with exactly one column in practice, so we store a single -// (ColumnId, map) pair instead of a per-column IdVec of Mutexes. Boxed to keep -// TrieNode size small for the many short-lived TrieNodes that never need caching. -type ChildrenMaps = IdVec>>>; +// (ColumnId, map) pair instead of a per-column IdVec of Mutexes. +// +// The child cache (see [`TrieNode::get_cached_trie_node`]): keyed by the bound +// value, storing the child node and the edge constraints used to build it. The +// stored constraints guard against distinct scans reaching the same +// (node, col, value) with different slow constraints; they are almost always +// empty, in which case the guard is a cheap length check. +type ChildrenMaps = IdVec, Box<[Constraint]>)>>>; + +/// Canonical signature of a trie root: the table plus its sorted header (fast) +/// constraints. Distinct signatures get distinct base ids from [`TrieCache`]. +type BaseSig = (TableId, SmallVec<[Constraint; 2]>); + +/// Key for a shared trie root: the table plus an interned id for its fast +/// (header) constraints. +type RootKey = (TableId, u32); + +/// A cache of trie *roots* shared across all plans within a single +/// `run_rule_set` call. Two plans that constrain the same table with the same +/// fast constraints share a root; the rest of the trie is then shared implicitly +/// because a shared root's per-node child caches are shared with it. Sharing lets +/// each node's cached sub-indexes and children be built once and reused across +/// plans. +/// +/// Only roots that more than one plan actually uses are shared (`shared`), so +/// single-use roots stay per-plan and keep the pool-recycling behavior of the +/// unshared path — sharing a root that is never reused is pure overhead. +/// +/// Concurrency: the parallel executor runs plans on multiple threads, so the maps +/// are concurrent. Tables are frozen during a run, so a given key always denotes +/// the same subset. +#[derive(Default)] +struct TrieCache { + roots: DashMap>, + /// Interns base signatures to small ids to keep [`RootKey`] cheap. + bases: DashMap, + next_base: AtomicUsize, + /// Root signatures used by more than one plan; only these are shared. + shared: HashSet, +} + +impl TrieCache { + /// Return the interned base id for a root subset identified by `table` and + /// its (fast) header constraints. + /// + /// Base id 0 is reserved for the (common) unconstrained case, so atoms with + /// no fast constraints skip the interning map entirely. `RootKey` already + /// carries `table`, so base ids only need to distinguish constraint sets + /// within a table. + fn base_id(&self, table: TableId, fast: &[Constraint]) -> u32 { + if fast.is_empty() { + return 0; + } + let mut sig: SmallVec<[Constraint; 2]> = SmallVec::from_iter(fast.iter().cloned()); + sig.sort_unstable(); + match self.bases.entry((table, sig)) { + Entry::Occupied(o) => *o.get(), + Entry::Vacant(v) => { + let id = self.next_base.fetch_add(1, Ordering::Relaxed) as u32 + 1; + v.insert(id); + id + } + } + } + + /// The canonical root signature (table + sorted fast constraints) for `atom` + /// given its headers. + fn root_sig(plan: &Plan, atom: AtomId, table: TableId) -> BaseSig { + let mut fast: SmallVec<[Constraint; 2]> = SmallVec::new(); + for h in plan.header().iter().filter(|h| h.atom == atom) { + fast.extend(h.constraints.iter().cloned()); + } + fast.sort_unstable(); + (table, fast) + } + + /// Compute the set of root signatures used by more than one plan atom (across + /// all plans); only these are worth sharing. + fn compute_shared<'a>(plans: impl Iterator) -> HashSet { + let mut counts: HashMap = HashMap::default(); + for plan in plans { + for (atom, info) in plan.atoms().iter() { + *counts + .entry(Self::root_sig(plan, atom, info.table)) + .or_default() += 1; + } + } + counts + .into_iter() + .filter_map(|(sig, n)| (n > 1).then_some(sig)) + .collect() + } + + /// Build a cache for the given shared root signatures. Only called when + /// `shared` is non-empty, so the DashMap allocations always pay off. + /// + /// Shard the maps to the actual thread count rather than DashMap's default + /// (`4 * num_cpus`): on a many-core host the default allocates hundreds of + /// shards per `run_rule_set`, which dwarfs the sharing savings on smaller + /// runs. Serial runs get a single shard. + fn with_shared(shared: HashSet) -> TrieCache { + // DashMap requires at least 2 shards; that is plenty for serial runs and + // still far below the default (4 * num_cpus). + let shards = crate::parallel::current_num_threads() + .next_power_of_two() + .max(2); + TrieCache { + roots: DashMap::with_hasher_and_shard_amount(Default::default(), shards), + bases: DashMap::with_hasher_and_shard_amount(Default::default(), shards), + next_base: AtomicUsize::new(0), + shared, + } + } +} /// Information about the current subset of an atom's relation that is being considered, along with /// lazily-initialized, cached indexes on that subset. @@ -680,7 +882,9 @@ pub(crate) struct TrieNode { cached_subsets: OnceLock>, /// Cached child trie nodes, keyed by value. In practice each TrieNode is /// only ever probed with a single column, so we store one (col, map) pair - /// instead of an IdVec across all columns. + /// instead of an IdVec across all columns. When this node is a shared root + /// (or reachable from one), this cache is shared across plans too, so + /// children are shared without any global lookup. cached_children: OnceLock>, } @@ -704,7 +908,7 @@ impl TrieNode { fn size(&self) -> usize { self.subset.size() } - fn get_cached_index(&self, col: ColumnId, info: &TableInfo) -> Arc { + fn get_cached_index(&self, col: ColumnId, info: &TableInfo) -> Arc { self.cached_subsets.get_or_init(|| { // Pre-size the vector so we do not need to borrow it mutably to initialize the index. let mut vec: Pooled = with_pool_set(|ps| ps.get()); @@ -712,16 +916,30 @@ impl TrieNode { vec })[col] .get_or_init(|| { - let col_index = info.table.group_by_col(self.subset.as_ref(), col); - Arc::new(col_index) + Arc::new(SortedColumnIndex::build_for_subset( + info.table.as_ref(), + self.subset.as_ref(), + col, + )) }) .clone() } + /// Return the child node reached by additionally constraining `col = value` + /// (and applying `edge_cs`). `sub` computes the child subset and is only + /// called on a cache miss. + /// + /// Children are cached on the node itself, keyed by `value`. When this node + /// is a shared root (or reachable from one) its child cache is shared across + /// plans, so a hit yields cross-plan child sharing with a single-value lookup + /// and no global cache access. The stored constraints guard against distinct + /// scans reaching the same (node, col, value) with different slow + /// constraints; they are almost always empty (a cheap length check). fn get_cached_trie_node( &self, col: ColumnId, value: Value, + edge_cs: &[Constraint], info: &TableInfo, sub: impl FnOnce() -> Subset, ) -> Arc { @@ -730,21 +948,25 @@ impl TrieNode { vec.resize_with(info.spec.arity(), || RwLock::new(HashMap::default())); vec })[col]; - // Optimistic read path: most calls are cache hits, so try shared lock first. + // Optimistic read path: most calls are cache hits, so try a shared lock + // first. A hit is only valid when the edge constraints match. { let guard = map.read().unwrap(); - if let Some(node) = guard.get(&value) { + if let Some((node, stored_cs)) = guard.get(&value) + && &**stored_cs == edge_cs + { return node.clone(); } } - // Cache miss: acquire write lock and insert. + // Cache miss (or constraint mismatch): acquire the write lock and insert. let mut guard = map.write().unwrap(); - // Double-check in case another thread inserted while we were waiting. - if let Some(node) = guard.get(&value) { + if let Some((node, stored_cs)) = guard.get(&value) + && &**stored_cs == edge_cs + { return node.clone(); } let new_node = Arc::new(TrieNode::new(sub())); - guard.insert(value, new_node.clone()); + guard.insert(value, (new_node.clone(), Box::from(edge_cs))); new_node } } @@ -808,14 +1030,88 @@ impl BindingInfo { } impl<'a> JoinState<'a> { - fn new(db: &'a Database, exec_state: ExecutionState<'a>) -> Self { + fn new( + db: &'a Database, + exec_state: ExecutionState<'a>, + trie_cache: Option>, + ) -> Self { Self { db, exec_state, pool: with_pool_set(|ps| ps.get_pool()), + trie_cache, } } + /// Look up (or create) the root trie node for `atom` given all of its + /// headers. + /// + /// An atom may carry more than one header (e.g. seminaive adds a timestamp + /// constraint on top of the plan's original fast constraints); the root + /// subset is the whole table intersected with every header subset. Returns + /// `None` when that subset is empty. + /// + /// Roots whose signature is used by more than one plan (see + /// [`TrieCache::shared`]) are shared through the cache; the rest are built + /// fresh per plan so the pool can recycle them. + fn root_node(&self, table_id: TableId, headers: &[&JoinHeader]) -> Option> { + // Fast path: when sharing is disabled this run (small database, or no + // root reused across plans), skip the root-signature machinery entirely + // and build a fresh per-plan root — matching the pre-sharing behavior at + // no added cost. + let Some(trie_cache) = self.trie_cache.as_ref() else { + return Some(Arc::new(TrieNode::new( + self.build_root_subset(table_id, headers)?, + ))); + }; + // The base identity is the union of all fast constraints on this atom. + let mut fast: SmallVec<[Constraint; 2]> = SmallVec::new(); + for h in headers { + fast.extend(h.constraints.iter().cloned()); + } + fast.sort_unstable(); + let sig: BaseSig = (table_id, fast); + + if !trie_cache.shared.contains(&sig) { + // Not reused across plans: build a fresh, unshared root. + return Some(Arc::new(TrieNode::new( + self.build_root_subset(table_id, headers)?, + ))); + } + + let base = trie_cache.base_id(table_id, &sig.1); + let key: RootKey = (table_id, base); + if let Some(node) = trie_cache.roots.get(&key) { + return (!node.subset.is_empty()).then(|| node.clone()); + } + let subset = self.build_root_subset(table_id, headers)?; + let node = match trie_cache.roots.entry(key) { + Entry::Occupied(o) => o.get().clone(), + Entry::Vacant(v) => { + let node = Arc::new(TrieNode::new(subset)); + v.insert(node.clone()); + node + } + }; + (!node.subset.is_empty()).then_some(node) + } + + /// The root subset for `table_id`: the whole table intersected with every + /// header subset. Returns `None` if the result is empty. + fn build_root_subset(&self, table_id: TableId, headers: &[&JoinHeader]) -> Option { + let mut subset = self.db.get_table(table_id).all(); + for h in headers { + if h.subset.is_empty() { + return None; + } + subset.intersect(h.subset.as_ref(), &self.pool); + if subset.is_empty() { + return None; + } + } + Some(subset) + } + fn get_index( &self, atoms: &Arc>, @@ -986,7 +1282,7 @@ impl<'a> JoinState<'a> { } // TODO: `supports_parallel_drain`` is a hack because currently // `drain_updates_parallel!`` is a bit slower because of the additional ExecutionState clone. - if (cur == 0 || cur == 1) && action_buf.supports_parallel_drain() { + if cur < free_join_fork_depth() && action_buf.supports_parallel_drain() { drain_updates_parallel!($updates) } else { $updates.drain(|update| match update { @@ -1036,6 +1332,7 @@ impl<'a> JoinState<'a> { let db = self.db; let exec_state_for_factory = self.exec_state.clone(); let exec_state_for_work = self.exec_state.clone(); + let trie_cache = self.trie_cache.clone(); action_buf.recur( BorrowedLocalState { binding_info, @@ -1065,10 +1362,11 @@ impl<'a> JoinState<'a> { JoinState { db, exec_state: exec_state_for_work.clone(), - // Each rayon task uses its own thread-local pool. + // Each scoped task uses its own thread-local pool. // This makes drain_updates_parallel slightly more expensive // than drain_updates eevn when both are run in single thread pool: with_pool_set(|ps| ps.get_pool()), + trie_cache: trie_cache.clone(), } .run_plan( stages, @@ -1089,20 +1387,19 @@ impl<'a> JoinState<'a> { } fn refine_subset( - sub: PotentiallyStale, + sub: PotentiallyStale>, constraints: &[Constraint], table: &WrappedTableRef, has_stale: bool, + pool: &Pool, ) -> Subset { - let sub = if sub.can_be_stale && has_stale { - table.refine_live(sub.inner) + let need_live = sub.can_be_stale && has_stale; + if constraints.is_empty() && !need_live { + sub.inner.to_owned(pool) } else { - sub.inner - }; - if constraints.is_empty() { - sub - } else { - table.refine(sub, constraints) + // Fused copy + liveness + constraint filter (single pass for + // tables that implement `refine_ref` directly). + table.refine_ref(sub.inner, constraints, need_live) } } @@ -1122,19 +1419,20 @@ impl<'a> JoinState<'a> { prober.for_each(|val, x| { updates.push_binding(*var, val[0]); if x.size() <= 16 { - let sub = refine_subset(x.to_owned(pool), &a.cs, &table, has_stale); + let sub = refine_subset(x, &a.cs, &table, has_stale, pool); if sub.is_empty() { updates.rollback(); return; } updates.refine_atom_subset(a.atom, sub); } else { - let node = - prober - .node - .get_cached_trie_node(a.column, val[0], info, || { - refine_subset(x.to_owned(pool), &a.cs, &table, has_stale) - }); + let node = prober.node.get_cached_trie_node( + a.column, + val[0], + &a.cs, + info, + || refine_subset(x, &a.cs, &table, has_stale, pool), + ); if node.subset.is_empty() { updates.rollback(); return; @@ -1174,10 +1472,11 @@ impl<'a> JoinState<'a> { updates.push_binding(*var, val[0]); if small_sub.size() <= 16 { let small_sub = refine_subset( - small_sub.to_owned(pool), + small_sub, &smaller_scan.cs, &small_table, small_has_stale, + pool, ); if small_sub.is_empty() { updates.rollback(); @@ -1188,13 +1487,15 @@ impl<'a> JoinState<'a> { let smaller_node = smaller.node.get_cached_trie_node( smaller_scan.column, val[0], + &smaller_scan.cs, small_info, || { refine_subset( - small_sub.to_owned(pool), + small_sub, &smaller_scan.cs, &small_table, small_has_stale, + pool, ) }, ); @@ -1206,10 +1507,11 @@ impl<'a> JoinState<'a> { } if large_sub.size() <= 16 { let large_sub = refine_subset( - large_sub.to_owned(pool), + large_sub, &larger_scan.cs, &large_table, large_has_stale, + pool, ); if large_sub.is_empty() { updates.rollback(); @@ -1220,13 +1522,15 @@ impl<'a> JoinState<'a> { let larger_node = larger.node.get_cached_trie_node( larger_scan.column, val[0], + &larger_scan.cs, large_info, || { refine_subset( - large_sub.to_owned(pool), + large_sub, &larger_scan.cs, &large_table, large_has_stale, + pool, ) }, ); @@ -1292,10 +1596,11 @@ impl<'a> JoinState<'a> { self.db.tables[atoms[rest[i].atom].table].table.as_ref(); if sub.size() <= 16 { let sub = refine_subset( - sub.to_owned(pool), + sub, &rest[i].cs, &table, rest_has_stale[i], + pool, ); if sub.is_empty() { updates.rollback(); @@ -1306,13 +1611,15 @@ impl<'a> JoinState<'a> { let node = probers[i].node.get_cached_trie_node( scan.column, key[0], + &rest[i].cs, &self.db.tables[atoms[scan.atom].table], || { refine_subset( - sub.to_owned(pool), + sub, &rest[i].cs, &table, rest_has_stale[i], + pool, ) }, ); @@ -1330,10 +1637,11 @@ impl<'a> JoinState<'a> { } if sub.size() <= 16 { let main_sub = refine_subset( - sub.to_owned(pool), + sub, &main_spec.cs, &main_spec_table, main_spec_has_stale, + pool, ); if main_sub.is_empty() { updates.rollback(); @@ -1344,14 +1652,15 @@ impl<'a> JoinState<'a> { let main_node = probers[smallest].node.get_cached_trie_node( main_spec.column, key[0], + &main_spec.cs, main_spec_info, || { - let sub = sub.to_owned(pool); refine_subset( sub, &main_spec.cs, &main_spec_table, main_spec_has_stale, + pool, ) }, ); @@ -1533,10 +1842,11 @@ impl<'a> JoinState<'a> { let table_info = &self.db.tables[atoms[*atom].table]; let cs = &to_intersect[*i].0.constraints; let subset = refine_subset( - subset.to_owned(pool), + subset, cs, &table_info.table.as_ref(), index_has_stale[prober_idx], + pool, ); if subset.is_empty() { updates.rollback(); @@ -1696,12 +2006,13 @@ impl<'a> JoinState<'a> { } if let Some(subset) = prober.get_subset(&key) { let subset = refine_subset( - subset.to_owned(pool), + subset, &spec.constraints, &self.db.tables[atoms[spec.to_index.atom].table] .table .as_ref(), probers_has_stale[j], + pool, ); if subset.is_empty() { return false; @@ -1804,7 +2115,7 @@ impl<'a> JoinState<'a> { } } -const VAR_BATCH_SIZE: usize = 128; +const LOCAL_ACTION_BATCH_SIZE: usize = 128; /// A trait used to abstract over different ways of buffering actions together /// before running them. @@ -1899,7 +2210,9 @@ impl<'a, 'outer: 'a> ActionBuffer<'a, ActionId> for InPlaceActionBuffer<'outer> bindings: &DenseIdMap, mut to_exec_state: impl FnMut() -> ExecutionState<'a>, ) { - let action_state = self.batches.get_or_default(action); + let action_state = self + .batches + .get_or_insert(action, || ActionState::new(LOCAL_ACTION_BATCH_SIZE)); action_state.n_runs += 1; action_state.len += 1; let action_info = &self.rule_set.actions[action]; @@ -1908,7 +2221,7 @@ impl<'a, 'outer: 'a> ActionBuffer<'a, ActionId> for InPlaceActionBuffer<'outer> unsafe { action_state.bindings.push(bindings, &action_info.used_vars); } - if action_state.len >= VAR_BATCH_SIZE { + if action_state.len >= LOCAL_ACTION_BATCH_SIZE { let mut state = to_exec_state(); let succeeded = state.run_instrs(&action_info.instrs, &mut action_state.bindings); action_state.bindings.clear(); @@ -1940,9 +2253,9 @@ impl<'a, 'outer: 'a> ActionBuffer<'a, ActionId> for InPlaceActionBuffer<'outer> } } -/// An Action buffer that hands off batches to of actions to rayon to execute. +/// An action buffer that hands off batches of actions to scoped worker tasks. struct ScopedActionBuffer<'inner, 'scope> { - scope: &'inner rayon::Scope<'scope>, + scope: &'inner Scope<'scope>, rule_set: &'scope RuleSet, match_counter: Arc, batches: DenseIdMap, @@ -1951,7 +2264,7 @@ struct ScopedActionBuffer<'inner, 'scope> { impl<'inner, 'scope> ScopedActionBuffer<'inner, 'scope> { fn new( - scope: &'inner rayon::Scope<'scope>, + scope: &'inner Scope<'scope>, rule_set: &'scope RuleSet, match_counter: Arc, ) -> Self { @@ -1977,7 +2290,10 @@ impl<'scope> ActionBuffer<'scope, ActionId> for ScopedActionBuffer<'_, 'scope> { mut to_exec_state: impl FnMut() -> ExecutionState<'scope>, ) { self.needs_flush = true; - let action_state = self.batches.get_or_default(action); + let batch_size = action_batch_size(); + let action_state = self + .batches + .get_or_insert(action, || ActionState::new(batch_size)); action_state.n_runs += 1; action_state.len += 1; let action_info = &self.rule_set.actions[action]; @@ -1986,10 +2302,9 @@ impl<'scope> ActionBuffer<'scope, ActionId> for ScopedActionBuffer<'_, 'scope> { unsafe { action_state.bindings.push(bindings, &action_info.used_vars); } - if action_state.len >= VAR_BATCH_SIZE { + if action_state.len >= batch_size { let mut state = to_exec_state(); - let mut bindings = - mem::replace(&mut action_state.bindings, Bindings::new(VAR_BATCH_SIZE)); + let mut bindings = mem::replace(&mut action_state.bindings, Bindings::new(batch_size)); action_state.len = 0; let match_counter = self.match_counter.clone(); self.scope.spawn(move |_| { @@ -2171,7 +2486,7 @@ impl<'a> ActionBuffer<'a, MatId> for InPlaceMaterializer<'a> { } struct ScopedMaterializer<'inner, 'scope> { - scope: &'inner rayon::Scope<'scope>, + scope: &'inner Scope<'scope>, specs: Arc>, materializations: Arc, RowBuffer>>>>, scratch_key: Vec, diff --git a/core-relations/src/free_join/mod.rs b/core-relations/src/free_join/mod.rs index d5f055db..97417988 100644 --- a/core-relations/src/free_join/mod.rs +++ b/core-relations/src/free_join/mod.rs @@ -13,7 +13,6 @@ use crate::{ numeric_id::{DenseIdMap, DenseIdMapWithReuse, NumericId, define_id}, }; use egglog_concurrency::{NotificationList, ResettableOnceLock}; -use rayon::prelude::*; use smallvec::SmallVec; use crate::{ @@ -25,6 +24,7 @@ use crate::{ dependency_graph::DependencyGraph, hash_index::{ColumnIndex, Index, IndexBase}, offsets::Subset, + parallel, parallel_heuristics::parallelize_db_level_op, pool::{Pool, Pooled, with_pool_set}, query::{Query, RuleSetBuilder}, @@ -314,8 +314,8 @@ pub struct Database { impl Database { /// Create an empty Database. /// - /// Queries are executed using the current rayon thread pool, which defaults to the global - /// thread pool. + /// Queries use the currently installed egglog thread pool. If no pool is + /// installed, queries run single-threaded. pub fn new() -> Database { Database::default() } @@ -420,7 +420,7 @@ impl Database { tables.push((*id, self.tables.take(*id).unwrap())); } let view = self.read_only_view(); - tables.par_iter_mut().for_each(|(id, info)| { + parallel::for_each_mut(&mut tables, |_, (id, info)| { if run(*id, info, &view) { self.notification_list.notify(*id); } @@ -560,14 +560,12 @@ impl Database { } let db = self.read_only_view(); changed |= if do_parallel { - tables_merging - .par_iter_mut() - .map(|(_, (info, buffers))| { - let mut es = ExecutionState::new(db, mem::take(buffers)); - info.as_mut().unwrap().table.merge(&mut es).added || es.changed - }) - .max() - .unwrap_or(false) + parallel::map_dense_id_map_mut(&mut tables_merging, |_, (info, buffers)| { + let mut es = ExecutionState::new(db, mem::take(buffers)); + info.as_mut().unwrap().table.merge(&mut es).added || es.changed + }) + .into_iter() + .any(|changed| changed) } else { tables_merging .iter_mut() @@ -834,11 +832,8 @@ impl Database { impl Drop for Database { fn drop(&mut self) { - // Clean up the ambient thread pool. - // - // Calling mem::forget on the egraph can result in much faster execution times. + // Clean up this thread's ambient memory pool. with_pool_set(PoolSet::clear); - rayon::broadcast(|_| with_pool_set(PoolSet::clear)); } } diff --git a/core-relations/src/hash_index/bench_support.rs b/core-relations/src/hash_index/bench_support.rs new file mode 100644 index 00000000..a13495fb --- /dev/null +++ b/core-relations/src/hash_index/bench_support.rs @@ -0,0 +1,138 @@ +//! Benchmark-only entry points into the internal index-construction code. +//! +//! Exposed via `#[doc(hidden)] pub` solely so `benches/build_index.rs` can measure the custom +//! radix-sort + tournament-merge against the standard library and time serial vs parallel +//! `ColumnIndex` construction. Not a stable API; signatures may change without notice. + +use egglog_concurrency::ThreadPool; +use rand::{Rng, SeedableRng, rngs::StdRng}; + +use crate::{ + common::Value, + free_join::Database, + numeric_id::NumericId, + offsets::RowId, + table::SortedWritesTable, + table_spec::{ColumnId, Table, WrappedTable}, +}; + +use super::{ColumnIndex, IndexBase, merge_sorted_blocks_dedup, radix_sort_slice_by_value}; + +/// Generate `n_cols` column blocks of `(Value, RowId)` pairs. Each block is RowId-ascending +/// (matching a table scan) with values drawn from `0..distinct`, so equal-value runs occur. +/// +/// Returns the concatenated pairs and the block bounds: block `b` is `[bounds[b], bounds[b + 1])`. +pub fn gen_blocks( + n_rows: usize, + n_cols: usize, + distinct: u32, + seed: u64, +) -> (Vec<(Value, RowId)>, Vec) { + let mut rng = StdRng::seed_from_u64(seed); + let mut pairs = Vec::with_capacity(n_rows * n_cols); + let mut bounds = vec![0usize]; + for _ in 0..n_cols { + for r in 0..n_rows { + pairs.push(( + Value::new(rng.random_range(0..distinct)), + RowId::from_usize(r), + )); + } + bounds.push(pairs.len()); + } + (pairs, bounds) +} + +/// The custom sort/merge from `rebuild_full`: radix-sort each block by value, then merge the +/// blocks with dedup (a single block skips the merge). +pub fn sort_merge_custom(mut pairs: Vec<(Value, RowId)>, bounds: &[usize]) -> Vec<(Value, RowId)> { + let widest = bounds.windows(2).map(|w| w[1] - w[0]).max().unwrap_or(0); + let mut scratch = vec![(Value::new_const(0), RowId::new_const(0)); widest]; + for b in 0..bounds.len() - 1 { + radix_sort_slice_by_value(&mut pairs[bounds[b]..bounds[b + 1]], &mut scratch); + } + if bounds.len() <= 2 { + pairs + } else { + merge_sorted_blocks_dedup(pairs, bounds) + } +} + +/// The standard-library analogue of [`sort_merge_custom`]: sort the whole concatenation by +/// `(Value, RowId)`, then drop duplicates iff `dedup` is set. +/// +/// Pass `dedup = false` for a single column and `true` for several, mirroring what +/// `sort_merge_custom` does: a single block has one pair per row, so every `RowId` is distinct +/// and no `(Value, RowId)` pair can repeat -- deduping there is a wasted pass that would unfairly +/// handicap this side of the comparison. Only multiple columns can put the same value (hence the +/// same pair) on one row. +pub fn sort_merge_std(mut pairs: Vec<(Value, RowId)>, dedup: bool) -> Vec<(Value, RowId)> { + pairs.sort_unstable(); + if dedup { + pairs.dedup(); + } + pairs +} + +/// Run `f` with an index thread pool of `n` threads installed, so parallel construction actually +/// forks: `ColumnIndex` derives both its shard count and worker-pool size from the ambient pool. +pub fn with_threads(n: usize, f: impl FnOnce() -> R) -> R { + ThreadPool::new(n.max(1)).install(f) +} + +/// A random table set up to (re)build a `ColumnIndex` over its value columns (`1..=n_val_cols`; +/// column 0 is a unique key so no rows merge). +pub struct IndexInput { + table: WrappedTable, + cols: Vec, +} + +impl IndexInput { + pub fn random(n_rows: usize, n_val_cols: usize, distinct: u32, seed: u64) -> Self { + let mut rng = StdRng::seed_from_u64(seed); + let n_cols = n_val_cols + 1; + let mut table = SortedWritesTable::new( + 1, + n_cols, + None, + vec![], + Box::new(|_, _old, new, out: &mut Vec| { + out.extend_from_slice(new); + false + }), + ); + { + let mut buf = table.new_buffer(); + let mut row = vec![Value::new(0); n_cols]; + for i in 0..n_rows { + row[0] = Value::from_usize(i); + for cell in row.iter_mut().skip(1) { + *cell = Value::new(rng.random_range(0..distinct)); + } + buf.stage_insert(&row); + } + } + let db = Database::default(); + db.with_execution_state(|es| { + table.merge(es); + }); + IndexInput { + table: WrappedTable::new(table), + cols: (1..n_cols).map(ColumnId::from_usize).collect(), + } + } + + /// Build the index with the serial radix-sort + merge path. + pub fn build_serial(&self) { + let mut ci = ColumnIndex::new(); + ci.rebuild_full(&self.cols, self.table.as_ref(), self.table.all().as_ref()); + std::hint::black_box(&ci); + } + + /// Build the index with the parallel sharded path. Call inside [`with_threads`]. + pub fn build_parallel(&self) { + let mut ci = ColumnIndex::new(); + ci.merge_parallel(&self.cols, self.table.as_ref(), self.table.all().as_ref()); + std::hint::black_box(&ci); + } +} diff --git a/core-relations/src/hash_index/mod.rs b/core-relations/src/hash_index/mod.rs index dfa7b93a..839667fe 100644 --- a/core-relations/src/hash_index/mod.rs +++ b/core-relations/src/hash_index/mod.rs @@ -3,24 +3,25 @@ use std::{ cmp, hash::{Hash, Hasher}, mem, - sync::{Arc, Mutex}, + sync::Mutex, }; use crate::{ common::IndexMap, numeric_id::{IdVec, NumericId, define_id}, }; -use egglog_concurrency::{Notification, ReadOptimizedLock}; +use egglog_concurrency::{ReadOptimizedLock, ThreadPool}; use hashbrown::HashTable; use indexmap::map::Entry; use once_cell::sync::Lazy; -use rayon::iter::ParallelIterator; use rustc_hash::FxHasher; +use smallvec::SmallVec; use crate::{ OffsetRange, Subset, common::{ShardData, ShardId, Value}, offsets::{RowId, SortedOffsetSlice, SubsetRef}, + parallel, parallel_heuristics::parallelize_index_construction, pool::{Pooled, with_pool_set}, row_buffer::{RowBuffer, TaggedRowBuffer}, @@ -30,6 +31,9 @@ use crate::{ #[cfg(test)] mod tests; +#[doc(hidden)] +pub mod bench_support; + #[derive(Clone)] pub(crate) struct TableEntry { hash: u64, @@ -79,6 +83,19 @@ impl Index { } else { table.updates_since(self.updated_to.minor) }; + // Three ways to fold `subset` into the index; all produce the same result (each value's + // rows sorted ascending and de-duplicated) but trade fixed overhead against throughput: + // + // * `merge_parallel` shards the rows across worker threads. It handles both full and + // incremental refreshes (it appends to whatever is already indexed), but the thread + // coordination only pays off once `subset` clears the size cutoff. + // * `rebuild_full` is the serial bulk path for a full rebuild: it sorts all (value, row) + // pairs and sizes each key's subset in a single allocation, avoiding the repeated + // regrowth of the row-at-a-time path. It assumes an empty index, so it is only valid + // right after the major-version `clear()` above. + // * `refresh_serial` scans in batches and inserts one row at a time into the existing + // index. Lowest fixed cost, and the only path suited to merging a small incremental + // delta into the index's prior contents. if parallelize_index_construction(subset.size()) { self.table.merge_parallel(&self.key, table, subset.as_ref()); } else if is_full { @@ -189,6 +206,8 @@ pub(crate) trait IndexBase { } struct ColumnIndexShard { + /// It's important that table is implemented using IndexMap instead of the more efficient + /// HashMap because we want stable enumeration order. table: Pooled>, subsets: SubsetBuffer, } @@ -230,9 +249,13 @@ impl IndexBase for ColumnIndex { shard.table.get(key).map(|x| x.as_ref(&shard.subsets)) } fn add_row(&mut self, vals: &[Value], row: RowId) { - // SAFETY: everything in `table` comes from `subsets`. - for key in vals { + for (i, key) in vals.iter().enumerate() { + // A value repeated across this row's covered columns maps the row in only once. + if vals[..i].contains(key) { + continue; + } let shard = self.shard_data.get_shard_mut(key, &mut self.shards); + // SAFETY: everything in `table` comes from `subsets`. unsafe { shard .table @@ -275,7 +298,12 @@ impl IndexBase for ColumnIndex { let mut split = IdVec::::default(); split.resize_with(shard_data.n_shards(), || TaggedRowBuffer::new(1)); for (row_id, keys) in buf.iter() { - for key in keys { + for (i, key) in keys.iter().enumerate() { + // Match `add_row`: a value repeated across this row's covered columns is + // recorded once, so a value's subset never holds a duplicate row id. + if keys[..i].contains(key) { + continue; + } shard_data .get_shard_mut(*key, &mut split) .add_row(row_id, &[*key]); @@ -290,8 +318,8 @@ impl IndexBase for ColumnIndex { } }; - run_in_thread_pool_and_block(&THREAD_POOL, || { - rayon::in_place_scope(|inner| { + run_in_index_thread_pool(|| { + egglog_concurrency::scope(|inner| { let mut cur = Offset::new(0); loop { let mut buf = TaggedRowBuffer::new(cols.len()); @@ -307,7 +335,7 @@ impl IndexBase for ColumnIndex { } }); - self.shards.par_iter_mut().for_each(|(shard_id, shard)| { + parallel::for_each_id_vec_mut(&mut self.shards, |shard_id, shard| { // Sort the vector by start row id to ensure we populate subsets in sorted order. let mut vec = queues[shard_id].lock().unwrap(); vec.sort_by_key(|(start, _)| *start); @@ -335,121 +363,95 @@ impl IndexBase for ColumnIndex { /// then build each key's subset with a single pre-sized allocation. Compared to `merge_rows`, /// this eliminates the doubling memmoves from `push_vec` that occur in the row-at-a-time `add_row` path. /// - /// Supports multiple columns (e.g. rebuild_index covering all value columns): pairs from - /// all columns are merged into one sorted list, so each value maps to the union of rows - /// containing it in any of the covered columns. + /// Supports multiple columns (e.g. rebuild_index covering all value columns): each value + /// maps to the union of rows containing it in any of the covered columns. fn rebuild_full(&mut self, cols: &[ColumnId], table: WrappedTableRef, subset: SubsetRef) { - let n = table.all().size() * cols.len(); - - let mut pairs: Vec<(Value, RowId)> = Vec::with_capacity(n); + // Collect each column into its own contiguous block, still in RowId-ascending scan + // order. `bounds[b]..bounds[b + 1]` delimits column `b`'s block; the number of columns + // is tiny, so it stays inline. + let rows = subset.size(); + let mut pairs: Vec<(Value, RowId)> = Vec::with_capacity(rows * cols.len()); + let mut bounds: SmallVec<[usize; 8]> = SmallVec::new(); + bounds.push(0); for &col in cols { - table.for_each_col(subset, col, &mut |row_id, val| { - pairs.push((val, row_id)); - }); + table.collect_col_pairs(subset, col, &mut pairs); + bounds.push(pairs.len()); } - radix_sort_pairs_by_value(&mut pairs); - if cols.len() > 1 { - // Remove duplicates (same value in multiple columns of the same row). - pairs.dedup(); + // Value-only sort each block. Since each block arrives RowId-ascending and the sort is + // stable, the block ends up ordered by (Value, RowId) without any RowId pass. + let mut scratch: Vec<(Value, RowId)> = + vec![(Value::new_const(0), RowId::new_const(0)); rows]; + for b in 0..cols.len() { + radix_sort_slice_by_value(&mut pairs[bounds[b]..bounds[b + 1]], &mut scratch); } - let mut i = 0; - while i < pairs.len() { - let key = pairs[i].0; - let start = i; - let mut first = pairs[i].1; - let mut last = pairs[i].1; - while i < pairs.len() && pairs[i].0 == key { - last = cmp::max(last, pairs[i].1); - first = cmp::min(first, pairs[i].1); - i += 1; - } - let shard = self.shard_data.get_shard_mut(key, &mut self.shards); - let count = i - start; - let buffered = if last.rep() - first.rep() == (count - 1) as u32 { - // If the row ids are contiguous, we can represent the subset as a dense range - // to avoid allocations - BufferedSubset::Dense(OffsetRange::new(first, last.inc())) - } else { - let bv = shard - .subsets - .new_vec(pairs[start..i].iter().map(|&(_, r)| r)); - BufferedSubset::Sparse(bv) - }; - shard.table.insert(key, buffered); + if cols.len() == 1 { + // A single column needs no merge: its block is already (Value, RowId)-sorted, and a + // row has one value per column so there are no duplicates. + self.build_subsets_from_sorted(&pairs); + return; } + + // Multiple columns: merge the sorted blocks with a balanced (tournament) two-way merge. + // Each merge drops duplicate (Value, RowId) pairs -- a value appearing in several of a + // row's columns -- and dedup composes through the tree, so the result is + // (Value, RowId)-sorted and unique without ever sorting by RowId. Halving the number of + // runs each round makes this O(n log k) rather than the O(n*k) of a left fold (whose + // growing accumulator is re-copied every step), which matters for wide tables. + let merged = merge_sorted_blocks_dedup(pairs, &bounds); + self.build_subsets_from_sorted(&merged); } } -/// This function is an alternative for [`rayon::ThreadPool::install`] that doesn't steal work from -/// the callee's current thread pool while waiting for `f` to finish. -/// -/// We do this to avoid deadlocks. The whole purpose of using a separate threadpool in this module -/// is to allow for sufficient parallelism while holding a lock on the main threadpool. That means -/// we are not worried about an outer lock tying up a thread in the main pool. -/// -/// On the other hand, it _is_ a bad idea to steal work on a rayon thread pool with some locks -/// held. In particular, if another task on the thread pool _itself_ attempts to aquire the same -/// lock, this can cause a deadlock. We saw this in the tests for this crate. The relevant lock -/// are those around individual indexes stored in the database-level index cache. -fn run_in_thread_pool_and_block<'a>(pool: &rayon::ThreadPool, f: impl FnMut() + Send + 'a) { - // NB: We don't need the heap allocations here. But we are only calling this function if - // we are about to do a bunch of work, so clarify is probably going to be better than (even - // more) unsafe code. - - // Alright, here we go: pretend `f` has `'static` lifetime because we are passing it to - // `spawn`. - trait LifetimeWork<'a>: FnMut() + Send + 'a {} - - impl<'a, F: FnMut() + Send + 'a> LifetimeWork<'a> for F {} - let as_lifetime: Box> = Box::new(f); - let mut casted_away = unsafe { - // SAFETY: `casted_away` will be dropped at the end of this method. The notification used - // below will ensure it does not escape. - mem::transmute::>, Box>>(as_lifetime) - }; - let n = Arc::new(Notification::new()); - let inner = n.clone(); - pool.spawn(move || { - casted_away(); - mem::drop(casted_away); - inner.notify(); - }); - n.wait() +/// Number of 8-bit radix passes needed to cover values up to `max`. +fn radix_passes_for(max: u32) -> u32 { + if max < 256 { + 1 + } else if max < 65_536 { + 2 + } else if max < (1 << 24) { + 3 + } else { + 4 + } } -/// Adaptive LSB radix sort for (Value, RowId) pairs, sorting by the Value field. -/// -/// Chooses 1–4 passes of 8-bit radix sort based on the observed maximum Value, so that -/// only the actually-used bit range is processed. Within each Value group the original -/// order (scan order = RowId-ascending) is preserved by the LSB stability guarantee, -/// satisfying the add_row_sorted invariant without an explicit RowId sort. +/// Adaptive value-only LSB radix sort of a single (Value, RowId) block, in place. /// -/// Falls back to `sort_unstable()` for n < 64 where radix setup overhead dominates. -fn radix_sort_pairs_by_value(pairs: &mut Vec<(Value, RowId)>) { - let n = pairs.len(); +/// `scratch` must be at least `data.len()` long; it is used as ping-pong space. Because the +/// sort is stable and `data` arrives in RowId-ascending order, the result is ordered by +/// (Value, RowId). The multi-column rebuild path sorts each column's block this way before +/// merging, so no explicit RowId sort is ever needed. +pub(crate) fn radix_sort_slice_by_value( + data: &mut [(Value, RowId)], + scratch: &mut [(Value, RowId)], +) { + let n = data.len(); if n < 64 { - pairs.sort_unstable(); + data.sort_unstable(); return; } - let max_val = pairs.iter().map(|&(v, _)| v.rep()).max().unwrap_or(0); - let n_passes: u32 = if max_val < 256 { - 1 - } else if max_val < 65_536 { - 2 - } else if max_val < (1 << 24) { - 3 - } else { - 4 - }; - - let null_pair = (Value::new_const(0), RowId::new_const(0)); - let mut buf: Vec<(Value, RowId)> = vec![null_pair; n]; + // One scan computes the pass count and detects already-sorted input (common + // when a column correlates with row order); a sorted block needs no work, + // since stability makes the result identical. + let mut max_val = 0u32; + let mut sorted = true; + let mut prev = 0u32; + for &(v, _) in data.iter() { + let rep = v.rep(); + max_val = max_val.max(rep); + sorted &= prev <= rep; + prev = rep; + } + if sorted { + return; + } + let n_passes = radix_passes_for(max_val); - let mut src: &mut Vec<(Value, RowId)> = pairs; - let mut dst: &mut Vec<(Value, RowId)> = &mut buf; + let mut src: &mut [(Value, RowId)] = data; + let mut dst: &mut [(Value, RowId)] = &mut scratch[..n]; for pass in 0..n_passes { let shift = pass * 8; @@ -479,14 +481,98 @@ fn radix_sort_pairs_by_value(pairs: &mut Vec<(Value, RowId)>) { core::mem::swap(&mut src, &mut dst); } - // After `n_passes` swaps, `src` points to the sorted data. - // Odd passes: src == buf.as_mut_ptr(); copy back to pairs. - // Even passes: src == pairs.as_mut_ptr(); already in place. + // After `n_passes` swaps, `src` points to the sorted data. If odd, that is `scratch`; + // copy it back into `data` (which is now `dst`). if n_passes % 2 == 1 { dst.copy_from_slice(src); } } +/// Merge two (Value, RowId)-sorted slices, *appending* the result to `out` and dropping pairs +/// equal to the previous one emitted *by this call*. +/// +/// Inputs `a` and `b` must each be sorted by (Value, RowId). Duplicates arise when one value +/// appears in several of a row's columns; the dedup check is scoped to this call's output (via +/// `start`) so back-to-back runs packed into the same buffer are not merged into each other. +fn merge2_into(a: &[(Value, RowId)], b: &[(Value, RowId)], out: &mut Vec<(Value, RowId)>) { + let start = out.len(); + let push = |out: &mut Vec<(Value, RowId)>, next: (Value, RowId)| { + if out.len() == start || *out.last().unwrap() != next { + out.push(next); + } + }; + let (mut i, mut j) = (0, 0); + while i < a.len() && j < b.len() { + if a[i] <= b[j] { + push(out, a[i]); + i += 1; + } else { + push(out, b[j]); + j += 1; + } + } + for &next in &a[i..] { + push(out, next); + } + for &next in &b[j..] { + push(out, next); + } +} + +/// Merge the `(Value, RowId)`-sorted column blocks of `src` (block `b` is +/// `src[bounds[b]..bounds[b + 1]]`) into one sorted, de-duplicated vector. +/// +/// Uses a balanced (tournament) two-way merge: adjacent runs are merged pairwise, then the +/// results are merged pairwise, halving the run count each round. This is O(n log k) in the +/// number of blocks `k`, versus the O(n*k) of merging a single growing accumulator against +/// each block in turn -- the difference matters when a table has many covered columns. +/// +/// Each round packs its merged runs contiguously into a second buffer of the same size and the +/// two buffers ping-pong, so the whole tournament uses just one extra allocation (`src` is +/// reused as the other buffer) rather than a fresh `Vec` per merge. Because merging two +/// de-duplicated sorted runs leaves any shared pair adjacent, dedup composes across rounds. +fn merge_sorted_blocks_dedup( + mut src: Vec<(Value, RowId)>, + bounds: &[usize], +) -> Vec<(Value, RowId)> { + let n = src.len(); + debug_assert!(bounds.len() >= 2); + + // `src` holds the current rounds's runs, delimited by `cur`; `dst` receives the merged runs. + let mut dst: Vec<(Value, RowId)> = Vec::with_capacity(n); + let mut cur: SmallVec<[usize; 8]> = bounds.iter().copied().collect(); + + // Each round more than halves the run count (`cur.len() - 1`); stop at a single run. + while cur.len() > 2 { + dst.clear(); + let mut next: SmallVec<[usize; 8]> = SmallVec::new(); + next.push(0); + let runs = cur.len() - 1; + let mut r = 0; + while r < runs { + if r + 1 < runs { + merge2_into( + &src[cur[r]..cur[r + 1]], + &src[cur[r + 1]..cur[r + 2]], + &mut dst, + ); + r += 2; + } else { + // Odd trailing run: already sorted and de-duplicated, so copy it forward. + dst.extend_from_slice(&src[cur[r]..cur[r + 1]]); + r += 1; + } + next.push(dst.len()); + } + mem::swap(&mut src, &mut dst); + cur = next; + } + + // One run remains, packed at the front of `src`. + src.truncate(cur[1]); + src +} + impl ColumnIndex { pub(crate) fn new() -> ColumnIndex { with_pool_set(|ps| { @@ -500,35 +586,35 @@ impl ColumnIndex { }) } - /// Pre-reserve capacity in each shard's HashMap for `n` rows total. - /// Eliminates hashbrown rehashing during add_row for the small-subset path. - pub(crate) fn reserve_for_n_rows(&mut self, n: usize) { - let n_shards = self.shards.len(); - let per_shard = n / n_shards + 2; - for (_, shard) in self.shards.iter_mut() { - shard.table.reserve(per_shard); - } - } - - /// Build a single-column index for `subset` of `table`. Picks between a - /// sort-based bulk path and a per-row scan based on subset size: large - /// subsets amortize the sort overhead, small ones avoid the buffer copy. - pub(crate) fn build_for_subset( - table: WrappedTableRef, - subset: SubsetRef, - col: ColumnId, - ) -> ColumnIndex { - const SORT_BULK_THRESHOLD: usize = 512; - let mut res = ColumnIndex::new(); - if subset.size() >= SORT_BULK_THRESHOLD { - res.rebuild_full(&[col], table, subset); - } else { - res.reserve_for_n_rows(subset.size()); - table.for_each_col(subset, col, &mut |row_id, val| { - res.add_row(&[val], row_id); - }); + /// Build each key's subset from `pairs`, which must be sorted by (Value, RowId) and + /// free of duplicate (Value, RowId) entries. Each contiguous run of equal values + /// becomes one subset, pre-sized from the run length. + fn build_subsets_from_sorted(&mut self, pairs: &[(Value, RowId)]) { + let mut i = 0; + while i < pairs.len() { + let key = pairs[i].0; + let start = i; + let mut first = pairs[i].1; + let mut last = pairs[i].1; + while i < pairs.len() && pairs[i].0 == key { + last = cmp::max(last, pairs[i].1); + first = cmp::min(first, pairs[i].1); + i += 1; + } + let shard = self.shard_data.get_shard_mut(key, &mut self.shards); + let count = i - start; + let buffered = if last.rep() - first.rep() == (count - 1) as u32 { + // If the row ids are contiguous, we can represent the subset as a dense range + // to avoid allocations + BufferedSubset::Dense(OffsetRange::new(first, last.inc())) + } else { + let bv = shard + .subsets + .new_vec(pairs[start..i].iter().map(|&(_, r)| r)); + BufferedSubset::Sparse(bv) + }; + shard.table.insert(key, buffered); } - res } } @@ -669,8 +755,8 @@ impl IndexBase for TupleIndex { queues[shard_id].lock().unwrap().push((first, buf)); } }; - run_in_thread_pool_and_block(&THREAD_POOL, || { - rayon::scope(|scope| { + run_in_index_thread_pool(|| { + egglog_concurrency::scope(|scope| { let mut cur = Offset::new(0); loop { let mut buf = TaggedRowBuffer::new(cols.len()); @@ -685,7 +771,7 @@ impl IndexBase for TupleIndex { } } }); - self.shards.par_iter_mut().for_each(|(shard_id, shard)| { + parallel::for_each_id_vec_mut(&mut self.shards, |shard_id, shard| { use hashbrown::hash_table::Entry; // Sort the vector by start row id to ensure we populate subsets in sorted order. let mut vec = queues[shard_id].lock().unwrap(); @@ -973,23 +1059,21 @@ impl BufferedSubset { } fn num_shards() -> usize { - let n_threads = rayon::current_num_threads(); + let n_threads = parallel::current_num_threads(); if n_threads == 1 { 1 } else { n_threads * 2 } } /// A thread pool specifically for parallel hash index construction. /// -/// We use a separate thread pool here because callers can construct an index under a lock, -/// and we do not want to take a long-running lock in the global thread pool without another -/// way to get parallelism. -/// -/// Earlier solutions using rayon::yield_now() were unreliable. -static THREAD_POOL: Lazy = Lazy::new(|| { - rayon::ThreadPoolBuilder::new() - .num_threads(rayon::current_num_threads()) - .build() - .unwrap() -}); +/// Callers can construct indexes while holding database-level index locks. The +/// separate pool preserves parallelism without tying up the caller's installed +/// pool behind those locks. +static INDEX_THREAD_POOL: Lazy = + Lazy::new(|| ThreadPool::new(parallel::current_num_threads().max(1))); + +fn run_in_index_thread_pool(f: impl FnOnce() -> R) -> R { + INDEX_THREAD_POOL.install(f) +} /// A simple free list used to reuse slots in a [`SubsetBuffer`]. /// diff --git a/core-relations/src/hash_index/tests.rs b/core-relations/src/hash_index/tests.rs index 91cbfb83..35afc1ab 100644 --- a/core-relations/src/hash_index/tests.rs +++ b/core-relations/src/hash_index/tests.rs @@ -1,12 +1,18 @@ -use crate::numeric_id::NumericId; +use std::collections::BTreeMap; + +use egglog_concurrency::ThreadPool; +use rand::{Rng, SeedableRng, rngs::StdRng}; + +use crate::{common::Value, numeric_id::NumericId, offsets::Offsets}; use crate::{ TupleIndex, + hash_index::ColumnIndex, table_shortcuts::{fill_table, v}, table_spec::{ColumnId, WrappedTable}, }; -use super::Index; +use super::{Index, IndexBase}; #[test] fn basic_updates() { @@ -89,3 +95,134 @@ fn basic_updates() { } } } + +#[test] +fn multi_column_column_index_rebuild_orders_each_value_by_row() { + let rows = (0..128).map(|i| { + let left = if i >= 96 { v(7) } else { v(1_000 + i) }; + let right = if i < 32 { v(7) } else { v(2_000 + i) }; + vec![v(i), left, right] + }); + let mut table = WrappedTable::new(fill_table(rows, 1, None, |old, new| { + assert_eq!(old, new, "no conflicts in this test"); + None + })); + let mut index = Index::new(vec![ColumnId::new(1), ColumnId::new(2)], ColumnIndex::new()); + index.refresh(table.as_ref()); + + empty_execution_state!(es); + let start_version = table.version().major; + while table.version().major == start_version { + table.new_buffer().stage_remove(&[v(0)]); + table.merge(&mut es); + table.new_buffer().stage_insert(&[v(0), v(1000), v(7)]); + table.merge(&mut es); + } + + index.refresh(table.as_ref()); + let key = v(7); + let subset = index.get_subset(&key).unwrap(); + let mut row_ids = Vec::new(); + subset.offsets(|row_id| row_ids.push(row_id.index())); + + let mut expected = Vec::new(); + table + .scan(table.all().as_ref()) + .iter() + .for_each(|(row_id, row)| { + if row[1] == key || row[2] == key { + expected.push(row_id.index()); + } + }); + assert_eq!(row_ids, expected); +} + +/// Brute-force oracle: for the covered `cols`, map each value to the list of row ids (in scan, +/// i.e. ascending-RowId, order) that contain it in some covered column. A value appearing in +/// several of a row's columns contributes that row once. +fn oracle(rows: &[Vec], cols: &[usize]) -> BTreeMap> { + let mut map: BTreeMap> = BTreeMap::new(); + for (row_id, row) in rows.iter().enumerate() { + let mut seen_in_row = Vec::new(); + for &c in cols { + let val = row[c].rep(); + if !seen_in_row.contains(&val) { + seen_in_row.push(val); + map.entry(val).or_default().push(row_id); + } + } + } + map +} + +/// Collect a built [`ColumnIndex`] into `value -> row ids` for comparison against [`oracle`]. +fn collect(index: &ColumnIndex) -> BTreeMap> { + let mut got: BTreeMap> = BTreeMap::new(); + index.for_each(|val, subset| { + let mut ids = Vec::new(); + subset.offsets(|row_id| ids.push(row_id.index())); + got.insert(val.rep(), ids); + }); + got +} + +fn assert_matches_oracle(index: &ColumnIndex, expected: &BTreeMap>, ctx: &str) { + let got = collect(index); + for (val, ids) in &got { + // Each value's row ids must be strictly ascending: sorted (the ordering this PR fixes) + // and de-duplicated (a value repeated across a row's columns maps the row in once). + assert!( + ids.windows(2).all(|w| w[0] < w[1]), + "{ctx}: row ids for value {val} not strictly ascending: {ids:?}", + ); + } + assert_eq!(&got, expected, "{ctx}"); +} + +/// Randomized oracle test: build a table whose value columns draw from a small pool (so values +/// repeat across many rows), then check the sort-based rebuild, the parallel rebuild, and the +/// per-row `build_for_subset` path all produce each value's rows in sorted, de-duplicated order. +#[test] +fn column_index_rebuild_matches_oracle() { + // Column 0 is a unique key; columns `1..n_cols` are the covered value columns. + for seed in 0..4u64 { + let mut rng = StdRng::seed_from_u64(seed); + for &n_rows in &[1usize, 10, 63, 64, 200, 512, 1000] { + let distinct = ((n_rows / 4).max(1)) as u32; + for &n_val_cols in &[1usize, 2, 3, 4] { + let n_cols = n_val_cols + 1; + let rows: Vec> = (0..n_rows) + .map(|i| { + let mut row = Vec::with_capacity(n_cols); + row.push(v(i)); + for _ in 1..n_cols { + row.push(v(rng.random_range(0..distinct) as usize)); + } + row + }) + .collect(); + let table = WrappedTable::new(fill_table(rows.clone(), 1, None, |old, new| { + assert_eq!(old, new, "unique keys, so no conflicts"); + None + })); + let cols: Vec = (1..n_cols).map(ColumnId::from_usize).collect(); + let covered: Vec = (1..n_cols).collect(); + let expected = oracle(&rows, &covered); + let ctx = format!("seed={seed} n_rows={n_rows} n_val_cols={n_val_cols}"); + + let mut serial = ColumnIndex::new(); + serial.rebuild_full(&cols, table.as_ref(), table.all().as_ref()); + assert_matches_oracle(&serial, &expected, &format!("{ctx} rebuild_full")); + + // Install a multi-thread pool so `ColumnIndex` shards across several shards and + // the merge actually forks; correctness must not depend on the shard count. + let parallel = ThreadPool::new(4).install(|| { + let mut ci = ColumnIndex::new(); + ci.merge_parallel(&cols, table.as_ref(), table.all().as_ref()); + ci + }); + assert_matches_oracle(¶llel, &expected, &format!("{ctx} merge_parallel")); + } + } + } +} diff --git a/core-relations/src/lib.rs b/core-relations/src/lib.rs index 6ad455d0..1adf0c09 100644 --- a/core-relations/src/lib.rs +++ b/core-relations/src/lib.rs @@ -10,6 +10,7 @@ pub(crate) mod dependency_graph; pub(crate) mod free_join; pub(crate) mod hash_index; pub(crate) mod offsets; +pub(crate) mod parallel; pub(crate) mod parallel_heuristics; pub(crate) mod pool; pub(crate) mod query; @@ -31,6 +32,8 @@ pub use free_join::{ make_external_func, plan::PlanStrategy, }; pub use hash_index::TupleIndex; +#[doc(hidden)] +pub use hash_index::bench_support; pub use offsets::{OffsetRange, RowId, Subset, SubsetRef}; pub use pool::{Pool, PoolSet, Pooled}; pub use query::{ diff --git a/core-relations/src/parallel.rs b/core-relations/src/parallel.rs new file mode 100644 index 00000000..9d098c8c --- /dev/null +++ b/core-relations/src/parallel.rs @@ -0,0 +1,172 @@ +//! Small parallel helpers backed by the installed egglog thread pool. + +use std::sync::OnceLock; + +use crate::numeric_id::{DenseIdMap, IdVec, NumericId}; + +const DEFAULT_TASKS_PER_THREAD: usize = 1; +const TASKS_PER_THREAD_ENV: &str = "EGGLOG_PARALLEL_TASKS_PER_THREAD"; + +static TASKS_PER_THREAD: OnceLock = OnceLock::new(); + +pub(crate) fn current_num_threads() -> usize { + egglog_concurrency::current_num_threads() +} + +pub(crate) fn enabled_for_len(len: usize) -> bool { + len > 1 && current_num_threads() > 1 +} + +fn chunk_len(len: usize) -> usize { + let tasks = current_num_threads() + .saturating_mul(tasks_per_thread()) + .max(1); + len.div_ceil(tasks).max(1) +} + +fn tasks_per_thread() -> usize { + *TASKS_PER_THREAD.get_or_init(|| { + read_usize_env(TASKS_PER_THREAD_ENV) + .unwrap_or(DEFAULT_TASKS_PER_THREAD) + .max(1) + }) +} + +fn read_usize_env(name: &str) -> Option { + std::env::var(name).ok()?.parse().ok() +} + +fn empty_result_slots(len: usize) -> Vec> { + let mut values = Vec::with_capacity(len); + values.resize_with(len, || None); + values +} + +fn collect_result_slots(values: Vec>) -> Vec { + values + .into_iter() + .map(|value| value.expect("parallel map result slot should be initialized")) + .collect() +} + +pub(crate) fn for_each_mut(items: &mut [T], f: F) +where + T: Send, + F: Fn(usize, &mut T) + Sync, +{ + if !enabled_for_len(items.len()) { + for (index, item) in items.iter_mut().enumerate() { + f(index, item); + } + return; + } + + let chunk_len = chunk_len(items.len()); + egglog_concurrency::scope(|scope| { + let f = &f; + for (chunk_index, chunk) in items.chunks_mut(chunk_len).enumerate() { + let base = chunk_index * chunk_len; + scope.spawn(move |_| { + for (offset, item) in chunk.iter_mut().enumerate() { + f(base + offset, item); + } + }); + } + }); +} + +pub(crate) fn map_mut(items: &mut [T], f: F) -> Vec +where + T: Send, + R: Send, + F: Fn(usize, &mut T) -> R + Sync, +{ + if !enabled_for_len(items.len()) { + return items + .iter_mut() + .enumerate() + .map(|(index, item)| f(index, item)) + .collect(); + } + + let chunk_len = chunk_len(items.len()); + let mut results = empty_result_slots(items.len()); + egglog_concurrency::scope(|scope| { + let f = &f; + for (chunk_index, (chunk, out)) in items + .chunks_mut(chunk_len) + .zip(results.chunks_mut(chunk_len)) + .enumerate() + { + let base = chunk_index * chunk_len; + scope.spawn(move |_| { + for (offset, item) in chunk.iter_mut().enumerate() { + out[offset] = Some(f(base + offset, item)); + } + }); + } + }); + + collect_result_slots(results) +} + +pub(crate) fn map_dense_id_map_mut(map: &mut DenseIdMap, f: F) -> Vec +where + K: NumericId, + V: Send, + R: Send, + F: Fn(K, &mut V) -> R + Sync, +{ + map_mut(map.raw_mut(), |index, slot| { + slot.as_mut().map(|value| f(K::from_usize(index), value)) + }) + .into_iter() + .flatten() + .collect() +} + +pub(crate) fn for_each_id_vec_mut(map: &mut IdVec, f: F) +where + K: NumericId, + V: Send, + F: Fn(K, &mut V) + Sync, +{ + for_each_mut(map.as_mut_slice(), |index, value| { + f(K::from_usize(index), value); + }); +} + +pub(crate) fn map(items: &[T], f: F) -> Vec +where + T: Sync, + R: Send, + F: Fn(usize, &T) -> R + Sync, +{ + if !enabled_for_len(items.len()) { + return items + .iter() + .enumerate() + .map(|(index, item)| f(index, item)) + .collect(); + } + + let chunk_len = chunk_len(items.len()); + let mut results = empty_result_slots(items.len()); + egglog_concurrency::scope(|scope| { + let f = &f; + for (chunk_index, (chunk, out)) in items + .chunks(chunk_len) + .zip(results.chunks_mut(chunk_len)) + .enumerate() + { + let base = chunk_index * chunk_len; + scope.spawn(move |_| { + for (offset, item) in chunk.iter().enumerate() { + out[offset] = Some(f(base + offset, item)); + } + }); + } + }); + + collect_result_slots(results) +} diff --git a/core-relations/src/parallel_heuristics.rs b/core-relations/src/parallel_heuristics.rs index 875ee6d6..d6861470 100644 --- a/core-relations/src/parallel_heuristics.rs +++ b/core-relations/src/parallel_heuristics.rs @@ -1,37 +1,114 @@ -//! Basic heuristics for whether or not to use a parallel or serial verion of an algorithm. +//! Basic heuristics for whether or not to use a parallel or serial version of an algorithm. //! //! The parallel implementations in this crate generally have a noticeable overhead when compared //! to the serial versions on small problem sizes. +use std::sync::OnceLock; + +const DEFAULT_DB_LEVEL_OP_CUTOFF: usize = 10_000; +const DEFAULT_INDEX_CONSTRUCTION_CUTOFF: usize = 400_000; +const DEFAULT_REBUILD_CUTOFF: usize = 400_000; +const DEFAULT_INTRA_CONTAINER_CUTOFF: usize = 10_000; +const DEFAULT_INTER_CONTAINER_CUTOFF: usize = 8; +const DEFAULT_TABLE_OP_CUTOFF: usize = 400_000; +const DEFAULT_FREE_JOIN_FORK_DEPTH: usize = 2; +const DEFAULT_ACTION_BATCH_SIZE: usize = 8 * 1024; + +static CUTOFFS: OnceLock = OnceLock::new(); + +struct Cutoffs { + db_level_op: usize, + index_construction: usize, + rebuild: usize, + intra_container: usize, + inter_container: usize, + table_op: usize, + free_join_fork_depth: usize, + action_batch_size: usize, +} + /// These are operations that work on a per-table or per-rule level where the size of the workload /// is hard to gauge ahead of time. In this case, we gate parallel execution based on the number of /// threads available and whether the total size of the database exceeds a certain threshold. pub(crate) fn parallelize_db_level_op(db_size: usize) -> bool { - db_size > 10_000 && rayon::current_num_threads() > 1 + should_parallelize(db_size, cutoffs().db_level_op) } /// Whether or not to use a parallel algorithm to construct a hash index. pub(crate) fn parallelize_index_construction(items_to_insert: usize) -> bool { - items_to_insert > 20_000 && rayon::current_num_threads() > 1 + should_parallelize(items_to_insert, cutoffs().index_construction) } /// Whether or not to use a parallel algorithm to rebuild a [`crate::table::SortedWritesTable`]. pub(crate) fn parallelize_rebuild(table_size: usize) -> bool { - table_size > 10_000 && rayon::current_num_threads() > 1 + should_parallelize(table_size, cutoffs().rebuild) } /// Whether or not to perform an operation for a given container memo table. pub(crate) fn parallelize_intra_container_op(num_containers: usize) -> bool { - num_containers > 1_000 && rayon::current_num_threads() > 1 + should_parallelize(num_containers, cutoffs().intra_container) } /// Whether or not to perform an operation in parallel across a set of different container memo /// tables. pub(crate) fn parallelize_inter_container_op(num_containers: usize) -> bool { - num_containers > 1 && rayon::current_num_threads() > 1 + should_parallelize(num_containers, cutoffs().inter_container) } #[track_caller] pub(crate) fn parallelize_table_op(table_size: usize) -> bool { - table_size > 20_000 && rayon::current_num_threads() > 1 + should_parallelize(table_size, cutoffs().table_op) +} + +/// Number of top free-join frames that may fork recursive drain work. +pub(crate) fn free_join_fork_depth() -> usize { + cutoffs().free_join_fork_depth +} + +/// Number of action bindings to batch before dispatching a scoped worker task. +pub(crate) fn action_batch_size() -> usize { + cutoffs().action_batch_size +} + +fn should_parallelize(len: usize, cutoff: usize) -> bool { + len > cutoff && crate::parallel::current_num_threads() > 1 +} + +fn cutoffs() -> &'static Cutoffs { + CUTOFFS.get_or_init(|| Cutoffs { + db_level_op: cutoff( + "EGGLOG_PARALLEL_DB_LEVEL_OP_CUTOFF", + DEFAULT_DB_LEVEL_OP_CUTOFF, + ), + index_construction: cutoff( + "EGGLOG_PARALLEL_INDEX_CONSTRUCTION_CUTOFF", + DEFAULT_INDEX_CONSTRUCTION_CUTOFF, + ), + rebuild: cutoff("EGGLOG_PARALLEL_REBUILD_CUTOFF", DEFAULT_REBUILD_CUTOFF), + intra_container: cutoff( + "EGGLOG_PARALLEL_INTRA_CONTAINER_CUTOFF", + DEFAULT_INTRA_CONTAINER_CUTOFF, + ), + inter_container: cutoff( + "EGGLOG_PARALLEL_INTER_CONTAINER_CUTOFF", + DEFAULT_INTER_CONTAINER_CUTOFF, + ), + table_op: cutoff("EGGLOG_PARALLEL_TABLE_OP_CUTOFF", DEFAULT_TABLE_OP_CUTOFF), + free_join_fork_depth: cutoff( + "EGGLOG_PARALLEL_FREE_JOIN_FORK_DEPTH", + DEFAULT_FREE_JOIN_FORK_DEPTH, + ), + action_batch_size: cutoff( + "EGGLOG_PARALLEL_ACTION_BATCH_SIZE", + DEFAULT_ACTION_BATCH_SIZE, + ) + .max(1), + }) +} + +fn cutoff(name: &str, default: usize) -> usize { + std::env::var(name) + .ok() + .and_then(|value| value.parse().ok()) + .unwrap_or(default) } diff --git a/core-relations/src/pool/mod.rs b/core-relations/src/pool/mod.rs index e246a618..d6257449 100644 --- a/core-relations/src/pool/mod.rs +++ b/core-relations/src/pool/mod.rs @@ -22,7 +22,8 @@ use crate::{ ColumnId, RowId, action::{Instr, PredictedVals}, common::{HashMap, HashSet, IndexMap, IndexSet, ShardId, Value}, - hash_index::{BufferedSubset, ColumnIndex, TableEntry}, + free_join::execute::SortedColumnIndex, + hash_index::{BufferedSubset, TableEntry}, offsets::SortedOffsetVector, table::TableEntry as SwTableEntry, table_spec::Constraint, @@ -438,10 +439,10 @@ pool_set! { predicted_vals: PredictedVals [ 1 << 20 ], shard_hist: DenseIdMap [ 1 << 20 ], instr_indexes: Vec [ 1 << 20 ], - cached_subsets: IdVec>> [ 4 << 20 ], + cached_subsets: IdVec>> [ 4 << 20 ], intersected_on: DenseIdMap [ 1 << 20 ], - cached_child: IdVec>>> [ 1 << 20 ], + cached_child: IdVec, Box<[Constraint]>)>>> [ 1 << 20 ], } } diff --git a/core-relations/src/row_buffer/mod.rs b/core-relations/src/row_buffer/mod.rs index fb63b9f9..0e757b03 100644 --- a/core-relations/src/row_buffer/mod.rs +++ b/core-relations/src/row_buffer/mod.rs @@ -5,7 +5,6 @@ use std::{cell::Cell, mem, ops::Deref}; use crate::numeric_id::NumericId; use egglog_concurrency::{ParallelVecWriter, parallel_writer::write_cell_slice}; -use rayon::iter::ParallelIterator; use smallvec::SmallVec; use crate::{ @@ -288,20 +287,6 @@ impl RowBuffer { self.total_rows = count; } - /// A parallel version of [`RowBuffer::iter`]. - pub(crate) fn parallel_iter(&self) -> impl ParallelIterator { - use rayon::prelude::*; - // SAFETY: This kind of transmutation is safe so long as no one - // modifies any of the values behind the `Cell` while this value is - // borrowed. - // - // The only time we modify these values is in safe methods requiring - // a mutable reference (`set_stale`, `get_row_mut`), or in the - // unsafe `set_stale_shared` method whose safety requirements imply - // that no call will overlap with borrowing such a row. - unsafe { mem::transmute::<&[Cell], &[Value]>(&self.data) }.par_chunks(self.n_columns) - } - /// Mark a row as stale in the buffer with shared access to it. Returns /// whether the row was already stale. /// @@ -399,11 +384,6 @@ impl TaggedRowBuffer { inner: RowBuffer::new(n_columns + 1), } } - - /// A parallel iterator over the contents of the buffer. - pub fn par_iter(&self) -> impl ParallelIterator { - self.inner.parallel_iter().map(|row| self.unwrap_row(row)) - } } impl TaggedRowBuffer { @@ -464,6 +444,38 @@ impl TaggedRowBuffer { res } + /// Add the given row and RowId to the buffer, then let `patch` edit the + /// copied row in place. Equivalent to copying `row` into a scratch + /// buffer, editing it, and calling [`TaggedRowBuffer::add_row`], without + /// the intermediate copy. + #[inline] + pub fn add_row_with( + &mut self, + row_id: RowId, + row: &[Value], + patch: impl FnOnce(&mut [Value]), + ) -> RowId { + debug_assert_eq!( + row.len(), + self.base_arity(), + "attempting to add a row with mismatched arity to table" + ); + if self.inner.total_rows == 0 { + self.inner.data.refresh(); + } + let res = RowId::from_usize(self.inner.total_rows); + self.inner.data.extend_from_values(row); + self.inner.data.push(Cell::new(Value::new(row_id.rep()))); + self.inner.total_rows += 1; + let vals = self.inner.data.as_values_mut(); + let end = vals.len() - 1; + let dst = &mut vals[end - row.len()..end]; + // SAFETY: see the comment in `RowBuffer::non_stale`; this is the same + // Cell-to-Value transmute used by `get_row_mut`. + patch(unsafe { mem::transmute::<&mut [Cell], &mut [Value]>(dst) }); + res + } + /// Get the row (and the id it was associated with at insertion time) at the /// offset associated with `row`. pub fn get_row(&self, row: RowId) -> (RowId, &[Value]) { diff --git a/core-relations/src/table/mod.rs b/core-relations/src/table/mod.rs index 0fbb0c14..35d3242b 100644 --- a/core-relations/src/table/mod.rs +++ b/core-relations/src/table/mod.rs @@ -18,7 +18,6 @@ use std::{ use crate::numeric_id::{DenseIdMap, NumericId}; use crossbeam_queue::SegQueue; use hashbrown::HashTable; -use rayon::iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator}; use rustc_hash::FxHasher; use sharded_hash_table::ShardedHashTable; @@ -27,7 +26,8 @@ use crate::{ action::ExecutionState, common::{HashMap, ShardData, ShardId, SubsetTracker, Value}, hash_index::{ColumnIndex, Index}, - offsets::{OffsetRange, Offsets, RowId, Subset, SubsetRef}, + offsets::{OffsetRange, Offsets, RowId, SortedOffsetVector, Subset, SubsetRef}, + parallel, parallel_heuristics::parallelize_table_op, pool::with_pool_set, row_buffer::{ParallelRowBufWriter, RowBuffer}, @@ -515,6 +515,26 @@ impl Table for SortedWritesTable { subset } + fn refine_ref(&self, subset: SubsetRef, cs: &[Constraint], _check_live: bool) -> Subset { + // Single fused pass: `eval` reads each row once, checking liveness + // (`get_row` skips stale rows) and all constraints together. A dense + // input whose rows all survive stays dense. + let n = subset.size(); + let mut vec: Pooled = with_pool_set(|ps| ps.get()); + subset.offsets(|row| { + if self.eval(cs, row) { + // SAFETY: `offsets` visits rows in ascending order. + unsafe { vec.push_unchecked(row) } + } + }); + if let SubsetRef::Dense(range) = subset + && vec.slice().inner().len() == n + { + return Subset::Dense(range); + } + Subset::Sparse(vec) + } + fn new_buffer(&self) -> Box { let n_shards = self.hash.shard_data().n_shards(); Box::new(Buffer { @@ -592,46 +612,40 @@ impl SortedWritesTable { /// Flush all pending removals, in parallel. fn parallel_delete(&mut self) -> bool { let shard_data = self.hash.shard_data(); - let stale_delta: usize = self - .hash - .mut_shards() - .par_iter_mut() - .enumerate() - .filter_map(|(shard_id, shard)| { - let shard_id = ShardId::from_usize(shard_id); - if self.pending_state.pending_removals[shard_id].is_empty() { - return None; - } - Some((shard_id, shard)) - }) - .map(|(shard_id, shard)| { - let queue = &self.pending_state.pending_removals[shard_id]; - let mut marked_stale = 0; - while let Some(buf) = queue.pop() { - buf.for_each(|to_remove| { - let (actual_shard, hc) = hash_code(shard_data, to_remove, self.n_keys); - assert_eq!(actual_shard, shard_id); - if let Ok(entry) = shard.find_entry(hc, |entry| { - entry.hashcode == (hc as _) - && &self.data.get_row(entry.row).unwrap()[0..self.n_keys] - == to_remove - }) { - let (ent, _) = entry.remove(); - // SAFETY: The safety requirements of - // `set_stale_shared` are that there are no - // concurrent accesses to `row`. No other threads - // can access this row within this method because - // different `shards` partition the space - // (guaranteed by the assertion above), and we - // launch at most one thread per shard. - marked_stale += - unsafe { !self.data.data.set_stale_shared(ent.row) } as usize; - } - }); - } - marked_stale - }) - .sum(); + let pending_removals = &self.pending_state.pending_removals; + let data = &self.data.data; + let n_keys = self.n_keys; + let stale_delta: usize = parallel::map_mut(self.hash.mut_shards(), |shard_id, shard| { + let shard_id = ShardId::from_usize(shard_id); + if pending_removals[shard_id].is_empty() { + return 0; + } + let queue = &pending_removals[shard_id]; + let mut marked_stale = 0; + while let Some(buf) = queue.pop() { + buf.for_each(|to_remove| { + let (actual_shard, hc) = hash_code(shard_data, to_remove, n_keys); + assert_eq!(actual_shard, shard_id); + if let Ok(entry) = shard.find_entry(hc, |entry| { + entry.hashcode == (hc as _) + && &data.get_row(entry.row)[0..n_keys] == to_remove + }) { + let (ent, _) = entry.remove(); + // SAFETY: The safety requirements of + // `set_stale_shared` are that there are no + // concurrent accesses to `row`. No other threads + // can access this row within this method because + // different `shards` partition the space + // (guaranteed by the assertion above), and we + // launch at most one thread per shard. + marked_stale += unsafe { !data.set_stale_shared(ent.row) } as usize; + } + }); + } + marked_stale + }) + .into_iter() + .sum(); // Update the stale count with the total marked stale. self.data.stale_rows += stale_delta; stale_delta > 0 @@ -829,23 +843,20 @@ impl SortedWritesTable { let n_cols = self.n_columns; let next_offset = RowId::from_usize(self.data.data.len()); let row_writer = self.data.data.parallel_writer(); - let pending_adds = self - .hash - .mut_shards() - .par_iter_mut() - .enumerate() - .map(|(shard_id, shard)| { - let shard_id = ShardId::from_usize(shard_id); - let mut checker = checker.clone(); - let mut exec_state = exec_state.clone(); - let mut scratch = with_pool_set(|ps| ps.get::>()); - let queue = &self.pending_state.pending_rows[shard_id]; - let mut marked_stale = 0usize; - let mut staged = StagedOutputs::new(n_keys, n_cols, BATCH_SIZE); - let mut changed = false; - // The core flush loop: We call once `staged` reaches `BATCH_SIZE` or - // when we're done. - macro_rules! flush_staged_outputs { + let pending_rows = &self.pending_state.pending_rows; + let merge = self.merge.clone(); + let pending_adds = parallel::map_mut(self.hash.mut_shards(), |shard_id, shard| { + let shard_id = ShardId::from_usize(shard_id); + let mut checker = checker.clone(); + let mut exec_state = exec_state.clone(); + let mut scratch = with_pool_set(|ps| ps.get::>()); + let queue = &pending_rows[shard_id]; + let mut marked_stale = 0usize; + let mut staged = StagedOutputs::new(n_keys, n_cols, BATCH_SIZE); + let mut changed = false; + // The core flush loop: We call once `staged` reaches `BATCH_SIZE` or + // when we're done. + macro_rules! flush_staged_outputs { () => {{ // Phase 2: Write the staged rows to the row writer. This only // works due to the `ParallelRowBufWriter` machinery. @@ -899,7 +910,7 @@ impl SortedWritesTable { // concurrent accesses to `row`. We have // exclusive access to any row whose hash matches this // shard. - if (self.merge)(&mut exec_state, cur, row, &mut scratch) { + if (merge)(&mut exec_state, cur, row, &mut scratch) { unsafe { let _was_stale = read_handle.set_stale_shared(occ.get().row); debug_assert!(!_was_stale); @@ -930,47 +941,40 @@ impl SortedWritesTable { staged.clear(); }}; } - // Phase 1: process all incoming updates: - // * Add new values to `staged` - // * Removing entries in `shard` and mark them as stale in - // `data` if they will be overwritten. - while let Some(buf) = queue.pop() { - // We create a read_handle once per batch to avoid blocking - // too many threads if someone needs to resize the row - // writer. - for row in buf.non_stale() { - staged.insert(row, |cur, new, out| { - (self.merge)(&mut exec_state, cur, new, out) - }); - if staged.len() >= BATCH_SIZE { - flush_staged_outputs!(); - } + // Phase 1: process all incoming updates: + // * Add new values to `staged` + // * Removing entries in `shard` and mark them as stale in + // `data` if they will be overwritten. + while let Some(buf) = queue.pop() { + // We create a read_handle once per batch to avoid blocking + // too many threads if someone needs to resize the row + // writer. + for row in buf.non_stale() { + staged.insert(row, |cur, new, out| (merge)(&mut exec_state, cur, new, out)); + if staged.len() >= BATCH_SIZE { + flush_staged_outputs!(); } } - flush_staged_outputs!(); - (checker, marked_stale, changed) - }) - .collect_vec_list(); + } + flush_staged_outputs!(); + (checker, marked_stale, changed) + }); self.data.data = row_writer.finish(); // Now we just need to reset our invariants. // Confirm none of the writes violated sort order and update the // `offsets` vector. - let checker = C::check_global(pending_adds.iter().flatten().map(|(checker, _, _)| checker)); + let checker = C::check_global(pending_adds.iter().map(|(checker, _, _)| checker)); checker.update_offsets(next_offset, &mut self.offsets); // Update the staleness counters. self.data.stale_rows += pending_adds .iter() - .flatten() .map(|(_, stale, _)| *stale) .sum::(); // Register any changes. - pending_adds - .iter() - .flatten() - .any(|(_, _, changed)| *changed) + pending_adds.iter().any(|(_, _, changed)| *changed) } fn binary_search_sort_val(&self, val: Value) -> Result<(RowId, RowId), RowId> { @@ -1045,7 +1049,6 @@ impl SortedWritesTable { } } fn parallel_rehash(&mut self) { - use rayon::prelude::*; // Parallel rehashes go "hash-first" rather than "rows-first". // // We iterate over each shard and then write out new contents to a fresh row, in parallel. @@ -1076,7 +1079,16 @@ impl SortedWritesTable { } } let mut results = Vec::::with_capacity(self.offsets.len()); - results.resize_with(self.offsets.len() - 1, Default::default); + let offset_windows = self + .offsets + .windows(2) + .map(|xs| { + let [(start_val, start_row), (_, end_row)] = xs else { + unreachable!() + }; + (*start_val, *start_row, *end_row) + }) + .collect::>(); // Use a macro rather than a lambda to avoid borrow issues. macro_rules! compute_hist { ($start_val: expr, $start_row: expr, $end_row: expr) => {{ @@ -1099,34 +1111,19 @@ impl SortedWritesTable { } }}; } - let mut last: TimestampStats = Default::default(); - rayon::join( - || { - // This closure handles computing all timestamps but the last one. - self.offsets - .windows(2) - .zip(results.iter_mut()) - .par_bridge() - .for_each(|(xs, res)| { - let [(start_val, start_row), (_, end_row)] = xs else { - unreachable!() - }; - *res = compute_hist!(*start_val, *start_row, *end_row); - }) - }, - || { - // And here we handle the final one. - let (start_val, start_row) = self.offsets.last().unwrap(); - let end_row = self.data.next_row(); - last = compute_hist!(*start_val, *start_row, end_row); - }, - ); + results.extend(parallel::map( + &offset_windows, + |_, (start_val, start_row, end_row)| compute_hist!(*start_val, *start_row, *end_row), + )); + // And here we handle the final one. + let (start_val, start_row) = self.offsets.last().unwrap(); + let end_row = self.data.next_row(); + let last = compute_hist!(*start_val, *start_row, end_row); results.push(last); // Now we need to compute cumulative statistics on the row layouts here. // We do this serially a we currently don't have a ton of use for cases with thousands // of timestamps or more. There are well-known parallel algorithms for computing these - // cumulative statistics in parallel, but they aren't currently all that well-suited - // for rayon at the moment. + // cumulative statistics in parallel, but they are not currently a good fit here. let mut prev_count = 0; self.offsets.clear(); for stats in results.iter_mut() { @@ -1161,42 +1158,37 @@ impl SortedWritesTable { self.data.scratch.clear(); self.data.scratch.reserve(prev_count); - self.hash - .mut_shards() - .par_iter_mut() - .with_max_len(1) - .enumerate() - .for_each(|(shard_id, shard)| { - let shard_id = ShardId::from_usize(shard_id); - let scratch_ptr = self.data.scratch.raw_rows(); - let mut progress = - HashMap::::default(); - progress.reserve(results.len()); - for stats in &results { - let Some(start) = stats.histogram.get(shard_id) else { - continue; - }; - progress.insert(stats.value, RowId::from_usize(*start)); - } - for TableEntry { row: row_id, .. } in shard.iter_mut() { - let row = self - .data - .get_row(*row_id) - .expect("shard should not map to a stale value"); - let val = row[sort_by.index()]; - let next = progress[&val]; - // SAFETY: see above longer comment. - unsafe { - std::ptr::copy_nonoverlapping( - row.as_ptr(), - scratch_ptr.add(next.index() * self.n_columns) as *mut Value, - self.n_columns, - ) - } - *row_id = next; - progress.insert(val, next.inc()); + let scratch_ptr = self.data.scratch.raw_rows() as usize; + let data = &self.data.data; + let n_columns = self.n_columns; + parallel::for_each_mut(self.hash.mut_shards(), |shard_id, shard| { + let shard_id = ShardId::from_usize(shard_id); + let scratch_ptr = scratch_ptr as *const Value; + let mut progress = HashMap::::default(); + progress.reserve(results.len()); + for stats in &results { + let Some(start) = stats.histogram.get(shard_id) else { + continue; + }; + progress.insert(stats.value, RowId::from_usize(*start)); + } + for TableEntry { row: row_id, .. } in shard.iter_mut() { + let row = data.get_row(*row_id); + debug_assert!(!row[0].is_stale(), "shard should not map to a stale value"); + let val = row[sort_by.index()]; + let next = progress[&val]; + // SAFETY: see above longer comment. + unsafe { + std::ptr::copy_nonoverlapping( + row.as_ptr(), + scratch_ptr.add(next.index() * n_columns) as *mut Value, + n_columns, + ) } - }); + *row_id = next; + progress.insert(val, next.inc()); + } + }); // SAFETY: see above longer comment. unsafe { self.data.scratch.set_len(prev_count) }; mem::swap(&mut self.data.data, &mut self.data.scratch); diff --git a/core-relations/src/table/rebuild.rs b/core-relations/src/table/rebuild.rs index e274c0ba..64334c3b 100644 --- a/core-relations/src/table/rebuild.rs +++ b/core-relations/src/table/rebuild.rs @@ -3,7 +3,6 @@ use std::{cmp, mem}; use crate::numeric_id::NumericId; -use rayon::prelude::*; use crate::{ ColumnId, ExecutionState, Offset, RowId, Subset, Table, TableId, TaggedRowBuffer, Value, @@ -11,6 +10,7 @@ use crate::{ common::HashSet, hash_index::{ColumnIndex, Index}, offsets::Offsets, + parallel, parallel_heuristics::parallelize_rebuild, table_spec::{Rebuilder, WrappedTableRef}, }; @@ -139,35 +139,28 @@ impl SortedWritesTable { if parallelize_rebuild(to_scan.size()) { WrappedTableRef::with_wrapper(self, |wrapped| { - buf.par_iter() - .fold( - || (self.new_buffer(), exec_state.clone(), false), - |(mut mutation_buf, mut exec_state, mut changed), (_, row)| { - let Some(subset) = self.rebuild_index.get_subset(&row[0]) else { - return (mutation_buf, exec_state, changed); - }; - let mut scanned = TaggedRowBuffer::new(self.n_columns); - rebuilder.rebuild_subset( - wrapped, - subset, - &mut scanned, - &mut exec_state, - ); - for (row_id, row) in scanned.non_stale_mut() { - let to_remove = - self.data.get_row(row_id).map(|x| &x[0..self.n_keys]); - if let Some(key) = to_remove { - mutation_buf.stage_remove(key); - } - changed = true; - insert_row!(self, mutation_buf, row, next_ts); - } - (mutation_buf, exec_state, changed) - }, - ) - .map(|(_, _, changed)| changed) - .max() - .unwrap_or(false) + let ids = buf.iter().map(|(_, row)| row[0]).collect::>(); + parallel::map(&ids, |_, id| { + let mut mutation_buf = self.new_buffer(); + let mut exec_state = exec_state.clone(); + let mut changed = false; + let Some(subset) = self.rebuild_index.get_subset(id) else { + return changed; + }; + let mut scanned = TaggedRowBuffer::new(self.n_columns); + rebuilder.rebuild_subset(wrapped, subset, &mut scanned, &mut exec_state); + for (row_id, row) in scanned.non_stale_mut() { + let to_remove = self.data.get_row(row_id).map(|x| &x[0..self.n_keys]); + if let Some(key) = to_remove { + mutation_buf.stage_remove(key); + } + changed = true; + insert_row!(self, mutation_buf, row, next_ts); + } + changed + }) + .into_iter() + .any(|changed| changed) }) } else { let mut scratch = TaggedRowBuffer::new(self.n_columns); @@ -202,44 +195,33 @@ impl SortedWritesTable { ) -> bool { const STEP_SIZE: usize = 2048; if parallelize_rebuild(self.data.next_row().index()) { - (0..self.data.next_row().index()) - .into_par_iter() - .step_by(STEP_SIZE) - .fold( - || { - ( - self.new_buffer(), - TaggedRowBuffer::new(self.n_columns), - exec_state.clone(), - false, - ) - }, - |(mut mutation_buf, mut buf, mut exec_state, mut changed), start| { - rebuilder.rebuild_buf( - &self.data.data, - RowId::from_usize(start), - RowId::from_usize(cmp::min( - start + STEP_SIZE, - self.data.next_row().index(), - )), - &mut buf, - &mut exec_state, - ); - for (row_id, row) in buf.non_stale_mut() { - let to_remove = self.data.get_row(row_id).map(|x| &x[0..self.n_keys]); - changed = true; - if let Some(key) = to_remove { - mutation_buf.stage_remove(key); - } - insert_row!(self, mutation_buf, row, next_ts); - } - buf.clear(); - (mutation_buf, buf, exec_state, changed) - }, - ) - .map(|(_, _, _, changed)| changed) - .max() - .unwrap_or(false) + let max_row = self.data.next_row().index(); + let starts = (0..max_row).step_by(STEP_SIZE).collect::>(); + parallel::map(&starts, |_, start| { + let mut mutation_buf = self.new_buffer(); + let mut buf = TaggedRowBuffer::new(self.n_columns); + let mut exec_state = exec_state.clone(); + let mut changed = false; + rebuilder.rebuild_buf( + &self.data.data, + RowId::from_usize(*start), + RowId::from_usize(cmp::min(*start + STEP_SIZE, max_row)), + &mut buf, + &mut exec_state, + ); + for (row_id, row) in buf.non_stale_mut() { + let to_remove = self.data.get_row(row_id).map(|x| &x[0..self.n_keys]); + changed = true; + if let Some(key) = to_remove { + mutation_buf.stage_remove(key); + } + insert_row!(self, mutation_buf, row, next_ts); + } + buf.clear(); + changed + }) + .into_iter() + .any(|changed| changed) } else { let mut buf = TaggedRowBuffer::new(self.n_columns); let mut changed = false; diff --git a/core-relations/src/table/sharded_hash_table.rs b/core-relations/src/table/sharded_hash_table.rs index 16938672..98c15624 100644 --- a/core-relations/src/table/sharded_hash_table.rs +++ b/core-relations/src/table/sharded_hash_table.rs @@ -13,7 +13,7 @@ pub(crate) struct ShardedHashTable { impl Default for ShardedHashTable { fn default() -> Self { - let cur_threads = rayon::current_num_threads(); + let cur_threads = crate::parallel::current_num_threads(); if cur_threads == 1 { Self::with_shards(1) } else { diff --git a/core-relations/src/table_spec.rs b/core-relations/src/table_spec.rs index a4117b5e..8b1da92d 100644 --- a/core-relations/src/table_spec.rs +++ b/core-relations/src/table_spec.rs @@ -20,7 +20,7 @@ use crate::{ mask::{Mask, MaskIter, ValueSource}, }, common::Value, - hash_index::{ColumnIndex, IndexBase, TupleIndex}, + hash_index::{IndexBase, TupleIndex}, offsets::{RowId, Subset, SubsetRef}, pool::{PoolSet, Pooled, with_pool_set}, row_buffer::{RowBuffer, RowSink, TaggedRowBuffer}, @@ -90,7 +90,7 @@ pub struct TableChange { } /// A constraint on the values within a row. -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum Constraint { Eq { l_col: ColumnId, r_col: ColumnId }, EqConst { col: ColumnId, val: Value }, @@ -319,6 +319,23 @@ pub trait Table: Any + Send + Sync { .fold(subset, |subset, c| self.refine_one(subset, c)) } + /// Filter a borrowed `subset` to the rows matching `cs` — and, when + /// `check_live` is set, to live rows — returning an owned subset. + /// + /// Equivalent to `to_owned` + [`Table::refine_live`] + [`Table::refine`]; + /// implementors may fuse the copy and filter into a single pass. + fn refine_ref(&self, subset: SubsetRef, cs: &[Constraint], check_live: bool) -> Subset { + let mut owned = subset.to_owned(&with_pool_set(|ps| ps.get_pool())); + if check_live { + owned = self.refine_live(owned); + } + if cs.is_empty() { + owned + } else { + self.refine(owned, cs) + } + } + /// An optional method for quickly generating a subset from a constraint. /// The standard use-case here is to apply constraints based on a column /// that is known to be sorted. @@ -426,13 +443,6 @@ impl TableWrapper for WrapperImpl { out.add_row(row_id, row); }) } - fn group_by_col(&self, table: &dyn Table, subset: SubsetRef, col: ColumnId) -> ColumnIndex { - let wrapped = WrappedTableRef { - inner: table, - wrapper: self, - }; - ColumnIndex::build_for_subset(wrapped, subset, col) - } fn group_by_key(&self, table: &dyn Table, subset: SubsetRef, cols: &[ColumnId]) -> TupleIndex { let table = table.as_any().downcast_ref::().unwrap(); let mut res = TupleIndex::new(cols.len()); @@ -474,6 +484,21 @@ impl TableWrapper for WrapperImpl { }); } + fn collect_col_pairs( + &self, + table: &dyn Table, + subset: SubsetRef, + col: ColumnId, + out: &mut Vec<(Value, RowId)>, + ) { + let table = table.as_any().downcast_ref::().unwrap(); + let col_idx = col.index(); + out.reserve(subset.size()); + table.scan_generic(subset, |row_id, row| { + out.push((row[col_idx], row_id)); + }); + } + fn scan_project( &self, table: &dyn Table, @@ -613,12 +638,7 @@ impl WrappedTable { self.as_ref().scan_bounded(subset, start, n, out) } - /// Group the contents of the given subset by the given column. - pub(crate) fn group_by_col(&self, subset: SubsetRef, col: ColumnId) -> ColumnIndex { - self.as_ref().group_by_col(subset, col) - } - - /// A multi-column vairant of [`WrappedTable::group_by_col`]. + /// Group the contents of the given subset by the given columns. pub(crate) fn group_by_key(&self, subset: SubsetRef, cols: &[ColumnId]) -> TupleIndex { self.as_ref().group_by_key(subset, cols) } @@ -703,7 +723,6 @@ pub(crate) trait TableWrapper: Send + Sync { n: usize, out: &mut TaggedRowBuffer, ) -> Option; - fn group_by_col(&self, table: &dyn Table, subset: SubsetRef, col: ColumnId) -> ColumnIndex; fn group_by_key(&self, table: &dyn Table, subset: SubsetRef, cols: &[ColumnId]) -> TupleIndex; /// Scan each row in `subset`, calling `f(row_id, col_value)` for each. @@ -717,6 +736,18 @@ pub(crate) trait TableWrapper: Send + Sync { f: &mut dyn FnMut(RowId, Value), ); + /// Append `(col_value, row_id)` for each row in `subset` to `out`. + /// + /// Equivalent to [`TableWrapper::for_each_col`] pushing into `out`, but the + /// scan loop is monomorphized, avoiding a virtual callback per row. + fn collect_col_pairs( + &self, + table: &dyn Table, + subset: SubsetRef, + col: ColumnId, + out: &mut Vec<(Value, RowId)>, + ); + #[allow(clippy::too_many_arguments)] fn scan_project( &self, @@ -797,12 +828,7 @@ impl WrappedTableRef<'_> { self.wrapper.scan_bounded(self.inner, subset, start, n, out) } - /// Group the contents of the given subset by the given column. - pub(crate) fn group_by_col(&self, subset: SubsetRef, col: ColumnId) -> ColumnIndex { - self.wrapper.group_by_col(self.inner, subset, col) - } - - /// A multi-column vairant of [`WrappedTable::group_by_col`]. + /// Group the contents of the given subset by the given columns. pub(crate) fn group_by_key(&self, subset: SubsetRef, cols: &[ColumnId]) -> TupleIndex { self.wrapper.group_by_key(self.inner, subset, cols) } @@ -819,6 +845,17 @@ impl WrappedTableRef<'_> { self.wrapper.for_each_col(self.inner, subset, col, f); } + /// Append `(col_value, row_id)` for each row in `subset` to `out`, using a + /// monomorphized scan loop (no per-row virtual call). + pub(crate) fn collect_col_pairs( + &self, + subset: SubsetRef, + col: ColumnId, + out: &mut Vec<(Value, RowId)>, + ) { + self.wrapper.collect_col_pairs(self.inner, subset, col, out); + } + /// A variant fo [`WrappedTable::scan_bounded`] that projects a subset of /// columns and only appends rows that match the given constraints. pub fn scan_project( diff --git a/core-relations/src/tests.rs b/core-relations/src/tests.rs index 6bacb7b7..ec6a1474 100644 --- a/core-relations/src/tests.rs +++ b/core-relations/src/tests.rs @@ -29,11 +29,12 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc; /// Run a test closure both single-threaded and with 4 threads. fn run_serial_and_parallel(f: impl Fn() + Send + Sync) { for num_threads in [1, 32] { - let pool = rayon::ThreadPoolBuilder::new() - .num_threads(num_threads) - .build() - .unwrap(); - pool.install(&f); + if num_threads == 1 { + f(); + } else { + let pool = egglog_concurrency::ThreadPool::new(num_threads); + pool.install(&f); + } } } diff --git a/core-relations/src/uf/mod.rs b/core-relations/src/uf/mod.rs index edf1d38e..9667dce0 100644 --- a/core-relations/src/uf/mod.rs +++ b/core-relations/src/uf/mod.rs @@ -8,6 +8,7 @@ use std::{ use crate::numeric_id::{DenseIdMap, NumericId}; use crossbeam_queue::SegQueue; +use smallvec::SmallVec; use crate::{ TableChange, TaggedRowBuffer, @@ -88,7 +89,6 @@ impl Rebuilder for Canonicalizer<'_> { } assert!(end.index() <= buf.len()); let mut cur = start; - let mut scratch = with_pool_set(|ps| ps.get::>()); // SAFETY: `cur` is always in-bounds, guaranteed by the above assertion. // Special-case small columns: this gives us a modest speedup on rebuilding-heavy // workloads. @@ -99,10 +99,7 @@ impl Rebuilder for Canonicalizer<'_> { let to_canon = row[c.index()]; let canon = self.table.uf.find_naive(to_canon); if canon != to_canon { - scratch.extend_from_slice(row); - scratch[c.index()] = canon; - out.add_row(cur, &scratch); - scratch.clear(); + out.add_row_with(cur, row, |dst| dst[c.index()] = canon); } cur = cur.inc(); } @@ -115,11 +112,10 @@ impl Rebuilder for Canonicalizer<'_> { let ca1 = self.table.uf.find_naive(v1); let ca2 = self.table.uf.find_naive(v2); if ca1 != v1 || ca2 != v2 { - scratch.extend_from_slice(row); - scratch[c1.index()] = ca1; - scratch[c2.index()] = ca2; - out.add_row(cur, &scratch); - scratch.clear(); + out.add_row_with(cur, row, |dst| { + dst[c1.index()] = ca1; + dst[c2.index()] = ca2; + }); } cur = cur.inc(); } @@ -134,30 +130,34 @@ impl Rebuilder for Canonicalizer<'_> { let ca2 = self.table.uf.find_naive(v2); let ca3 = self.table.uf.find_naive(v3); if ca1 != v1 || ca2 != v2 || ca3 != v3 { - scratch.extend_from_slice(row); - scratch[c1.index()] = ca1; - scratch[c2.index()] = ca2; - scratch[c3.index()] = ca3; - out.add_row(cur, &scratch); - scratch.clear(); + out.add_row_with(cur, row, |dst| { + dst[c1.index()] = ca1; + dst[c2.index()] = ca2; + dst[c3.index()] = ca3; + }); } cur = cur.inc(); } } cs => { + let mut canons: SmallVec<[Value; 8]> = SmallVec::with_capacity(cs.len()); while cur < end { - scratch.extend_from_slice(unsafe { buf.get_row_unchecked(cur) }); + let row = unsafe { buf.get_row_unchecked(cur) }; + canons.clear(); let mut changed = false; for c in cs { - let to_canon = scratch[c.index()]; + let to_canon = row[c.index()]; let canon = self.table.uf.find_naive(to_canon); - scratch[c.index()] = canon; changed |= canon != to_canon; + canons.push(canon); } if changed { - out.add_row(cur, &scratch); + out.add_row_with(cur, row, |dst| { + for (c, canon) in cs.iter().zip(canons.iter()) { + dst[c.index()] = *canon; + } + }); } - scratch.clear(); cur = cur.inc(); } } diff --git a/egglog-ast/src/generic_ast_helpers.rs b/egglog-ast/src/generic_ast_helpers.rs index e3b0b84f..8b694d24 100644 --- a/egglog-ast/src/generic_ast_helpers.rs +++ b/egglog-ast/src/generic_ast_helpers.rs @@ -755,7 +755,21 @@ impl Display for Literal { } } Literal::Bool(b) => Display::fmt(b, f), - Literal::String(s) => write!(f, "\"{s}\""), + // Escape backslashes and quotes so the output round-trips through the + // lexer; otherwise a string holding either character produces text + // that fails to re-parse. Other characters (newlines, tabs, ...) are + // accepted verbatim by the lexer, so we leave them as-is. + Literal::String(s) => { + write!(f, "\"")?; + for c in s.chars() { + match c { + '\\' => write!(f, "\\\\")?, + '"' => write!(f, "\\\"")?, + c => write!(f, "{c}")?, + } + } + write!(f, "\"") + } Literal::Unit => write!(f, "()"), } } @@ -790,4 +804,13 @@ mod tests { assert_eq!(delete.to_string(), "(delete (foo))"); assert_eq!(subsume.to_string(), "(subsume (foo))"); } + + #[test] + fn display_string_literal_escapes_special_characters() { + assert_eq!(Literal::String("plain".into()).to_string(), "\"plain\""); + assert_eq!(Literal::String("a\"b".into()).to_string(), "\"a\\\"b\""); + assert_eq!(Literal::String("a\\b".into()).to_string(), "\"a\\\\b\""); + // Newlines and tabs are accepted verbatim by the lexer, so they are not escaped. + assert_eq!(Literal::String("a\nb".into()).to_string(), "\"a\nb\""); + } } diff --git a/egglog-bridge/Cargo.toml b/egglog-bridge/Cargo.toml index b0ec6c82..1a70ef91 100644 --- a/egglog-bridge/Cargo.toml +++ b/egglog-bridge/Cargo.toml @@ -10,6 +10,7 @@ readme = { workspace = true } [dependencies] egglog-core-relations = { workspace = true } +egglog-concurrency = { workspace = true } egglog-numeric-id = { workspace = true } egglog-union-find = { workspace = true } egglog-reports = { workspace = true } @@ -21,7 +22,6 @@ num-rational = { workspace = true } log = { workspace = true } indexmap = { workspace = true } web-time = { workspace = true } -rayon = { workspace = true } dyn-clone = { workspace = true } once_cell = { workspace = true } ordered-float = { workspace = true } diff --git a/egglog-bridge/src/lib.rs b/egglog-bridge/src/lib.rs index ed427216..bc890c00 100644 --- a/egglog-bridge/src/lib.rs +++ b/egglog-bridge/src/lib.rs @@ -23,6 +23,7 @@ use crate::core_relations::{ WrappedTable, }; use crate::numeric_id::{DenseIdMap, DenseIdMapWithReuse, NumericId, define_id}; +use egglog_concurrency::ThreadPool; use egglog_core_relations as core_relations; use egglog_numeric_id as numeric_id; use egglog_reports::{IterationReport, ReportLevel, RuleSetReport}; @@ -133,23 +134,82 @@ pub struct EGraph { /// [`WriteState`] / [`FullState`] can resolve table actions at /// invoke time. Mutated in place from [`add_table`](EGraph::add_table). action_registry: Arc>, + threads: usize, + thread_pool: Option>, } pub type Result = std::result::Result; +fn normalize_thread_count(threads: usize) -> usize { + #[cfg(target_family = "wasm")] + { + if threads > 1 { + panic!("cannot use more than 1 thread on wasm"); + } + 1 + } + #[cfg(not(target_family = "wasm"))] + { + if threads == 0 { + std::thread::available_parallelism() + .map(usize::from) + .unwrap_or(1) + } else { + threads + } + } +} + +fn install_thread_pool(thread_pool: Option>, f: impl FnOnce() -> R) -> R { + match thread_pool { + Some(thread_pool) => thread_pool.install(f), + None => egglog_concurrency::without_current_pool(f), + } +} + impl Default for EGraph { fn default() -> Self { - let mut db = Database::new(); - let uf_table = db.add_table_named( - DisplacedTable::default(), - "$uf".into(), - iter::empty(), - iter::empty(), - ); - let id_counter = db.add_counter(); - let ts_counter = db.add_counter(); - // Start the timestamp counter at 1. - db.inc_counter(ts_counter); + Self::new(1) + } +} + +/// Properties of a function added to an [`EGraph`]. +pub struct FunctionConfig { + /// The function's schema. The last column in the schema is the return type. + pub schema: Vec, + /// The behavior of the function when lookups are made on keys not currently present. + pub default: DefaultVal, + /// How to resolve FD conflicts for the function. + pub merge: MergeFn, + /// The function's name + pub name: String, + /// Whether or not subsumption is enabled for this function. + pub can_subsume: bool, +} + +impl EGraph { + /// Create an e-graph configured to use `threads` worker threads. + /// + /// Passing `1` keeps execution serial and does not allocate a thread pool. + /// Passing `0` uses the host's available parallelism. + pub fn new(threads: usize) -> Self { + let threads = normalize_thread_count(threads); + let thread_pool = (threads > 1).then(|| Arc::new(ThreadPool::new(threads))); + let (mut db, uf_table, id_counter, ts_counter) = + install_thread_pool(thread_pool.clone(), || { + let mut db = Database::new(); + let uf_table = db.add_table_named( + DisplacedTable::default(), + "$uf".into(), + iter::empty(), + iter::empty(), + ); + let id_counter = db.add_counter(); + let ts_counter = db.add_counter(); + // Start the timestamp counter at 1. + db.inc_counter(ts_counter); + (db, uf_table, id_counter, ts_counter) + }); // Register a default panic external function so the typed // state wrappers' `panic()` method has an id to call. This @@ -184,25 +244,35 @@ impl Default for EGraph { panic_funcs, report_level: Default::default(), action_registry, + threads, + thread_pool, } } -} -/// Properties of a function added to an [`EGraph`]. -pub struct FunctionConfig { - /// The function's schema. The last column in the schema is the return type. - pub schema: Vec, - /// The behavior of the function when lookups are made on keys not currently present. - pub default: DefaultVal, - /// How to resolve FD conflicts for the function. - pub merge: MergeFn, - /// The function's name - pub name: String, - /// Whether or not subsumption is enabled for this function. - pub can_subsume: bool, -} + /// Return a copy of this e-graph configured with a different thread count. + pub fn with_num_threads(mut self, threads: usize) -> Self { + self.set_num_threads(threads); + self + } + + /// Set the number of worker threads used by this e-graph. + /// + /// Passing `1` disables the pool. Passing `0` uses available parallelism. + pub fn set_num_threads(&mut self, threads: usize) { + let threads = normalize_thread_count(threads); + self.threads = threads; + self.thread_pool = (threads > 1).then(|| Arc::new(ThreadPool::new(threads))); + } + + /// Return the configured thread count. + pub fn num_threads(&self) -> usize { + self.threads + } + + fn thread_pool(&self) -> Option> { + self.thread_pool.clone() + } -impl EGraph { fn next_ts(&self) -> Timestamp { Timestamp::from_usize(self.db.read_counter(self.timestamp_counter)) } @@ -533,13 +603,15 @@ impl EGraph { let mut write_deps = IndexSet::::new(); merge.fill_deps(self, &mut read_deps, &mut write_deps); let merge_fn = merge.to_callback(schema_math, &name, self); - let table = SortedWritesTable::new( - n_args, - n_cols, - Some(ColumnId::from_usize(schema.len())), - to_rebuild, - merge_fn, - ); + let table = install_thread_pool(self.thread_pool(), || { + SortedWritesTable::new( + n_args, + n_cols, + Some(ColumnId::from_usize(schema.len())), + to_rebuild, + merge_fn, + ) + }); let name: Arc = name.into(); let table_id = self.db.add_table_named( table, @@ -585,7 +657,8 @@ impl EGraph { /// /// If the given rules are malformed, this method can return an error. pub fn run_rules(&mut self, rules: &[RuleId]) -> Result { - self.run_rules_inner(rules) + let thread_pool = self.thread_pool(); + install_thread_pool(thread_pool, || self.run_rules_inner(rules)) } fn run_rules_inner(&mut self, rules: &[RuleId]) -> Result { @@ -624,7 +697,7 @@ impl EGraph { } fn rebuild(&mut self) -> Result<()> { - let do_parallel = rayon::current_num_threads() > 1; + let do_parallel = egglog_concurrency::current_num_threads() > 1; if self.db.get_table(self.uf_table).rebuilder(&[]).is_some() { // The UF implementation supports "native" rebuilding. let mut tables = Vec::with_capacity(self.funcs.next_id().index()); @@ -941,7 +1014,8 @@ impl EGraph { /// manipulation from outside any rule, not for use inside /// primitive implementations. pub fn with_execution_state(&self, f: impl FnOnce(&mut ExecutionState<'_>) -> R) -> R { - self.db.with_execution_state(f) + let thread_pool = self.thread_pool(); + install_thread_pool(thread_pool, || self.db.with_execution_state(f)) } /// Like [`EGraph::with_execution_state`], but also reports whether `f` @@ -958,6 +1032,11 @@ impl EGraph { /// Flush the pending update buffers to the EGraph. /// Returns `true` if the database is updated. pub fn flush_updates(&mut self) -> bool { + let thread_pool = self.thread_pool(); + install_thread_pool(thread_pool, || self.flush_updates_inner()) + } + + fn flush_updates_inner(&mut self) -> bool { let uf_size_before = self.db.get_table(self.uf_table).len(); let updated = self.db.merge_all(); self.inc_ts(); diff --git a/numeric-id/Cargo.toml b/numeric-id/Cargo.toml index e123eef0..aab7e769 100644 --- a/numeric-id/Cargo.toml +++ b/numeric-id/Cargo.toml @@ -8,8 +8,5 @@ keywords = { workspace = true } license = { workspace = true } readme = { workspace = true } -[dependencies] -rayon = { workspace = true } - [features] default = [] diff --git a/numeric-id/src/lib.rs b/numeric-id/src/lib.rs index cfbe7d71..d8fccddd 100644 --- a/numeric-id/src/lib.rs +++ b/numeric-id/src/lib.rs @@ -160,6 +160,10 @@ impl DenseIdMap { &self.data } + pub fn raw_mut(&mut self) -> &mut [Option] { + &mut self.data + } + pub fn iter(&self) -> impl Iterator { self.data .iter() @@ -217,24 +221,6 @@ impl DenseIdMap { } } -impl DenseIdMap { - /// Get a parallel iterator over the entries in the table. - pub fn par_iter(&self) -> impl ParallelIterator { - self.data - .par_iter() - .enumerate() - .filter_map(|(i, v)| Some((K::from_usize(i), v.as_ref()?))) - } - - /// Get a parallel iterator over mutable references to the entries in the table. - pub fn par_iter_mut(&mut self) -> impl ParallelIterator { - self.data - .par_iter_mut() - .enumerate() - .filter_map(|(i, v)| Some((K::from_usize(i), v.as_mut()?))) - } -} - impl ops::Index for DenseIdMap { type Output = V; @@ -415,15 +401,9 @@ impl IdVec { pub fn get(&self, key: K) -> Option<&V> { self.data.get(key.index()) } -} -impl IdVec { - pub fn par_iter_mut(&mut self) -> impl IndexedParallelIterator { - self.data - .par_iter_mut() - .with_max_len(1) - .enumerate() - .map(|(i, v)| (K::from_usize(i), v)) + pub fn as_mut_slice(&mut self) -> &mut [V] { + &mut self.data } } @@ -441,10 +421,6 @@ impl ops::IndexMut for IdVec { } } -use rayon::iter::{ - IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator, -}; - #[macro_export] #[doc(hidden)] macro_rules! atomic_of { diff --git a/scripts/bench.py b/scripts/bench.py index a78aeb40..055fc65d 100644 --- a/scripts/bench.py +++ b/scripts/bench.py @@ -35,6 +35,13 @@ "python_array_optimize.egg", "cykjson.egg", "eggcc-extraction.egg", + # "gemma.egg", + # "gemma4_moe.egg", + "llama.egg", + "paged_llama.egg", + "qwen.egg", + "qwen3_moe.egg", + "whisper.egg", ] HYPERFINE_RUNS = 15 diff --git a/src/ast/desugar.rs b/src/ast/desugar.rs index 428f22b3..7a1f810f 100644 --- a/src/ast/desugar.rs +++ b/src/ast/desugar.rs @@ -127,10 +127,10 @@ pub(crate) fn desugar_command( } else { rewrite.name.clone() }; - desugar_rewrite(ruleset, resolved_name, rewrite, subsume, parser) + desugar_rewrite(ruleset, resolved_name, rewrite, subsume, parser)? } Command::BiRewrite(ruleset, rewrite) => { - desugar_birewrite(ruleset, rule_name, rewrite, parser) + desugar_birewrite(ruleset, rule_name, rewrite, parser)? } Command::Include(_span, _file) => { unreachable!("Include commands should be expanded before desugaring") @@ -194,9 +194,20 @@ pub(crate) fn desugar_command( vec![NCommand::Pop(span, num)] } Command::Fail(span, cmd) => { + if let Command::Include(..) = *cmd { + return Err(Error::DesugarError( + span.clone(), + "include is not allowed inside (fail ...)".to_string(), + )); + } let mut desugared = desugar_command(*cmd, parser, proof_testing)?; - let last = desugared.pop().unwrap(); + let Some(last) = desugared.pop() else { + return Err(Error::DesugarError( + span.clone(), + "the command inside (fail ...) expands to no commands".to_string(), + )); + }; desugared.push(NCommand::Fail(span, Box::new(last))); return Ok(desugared); } @@ -321,7 +332,7 @@ fn desugar_rewrite( rewrite: Rewrite, subsume: bool, parser: &mut Parser, -) -> Vec { +) -> Result, Error> { let span = rewrite.span.clone(); let var = parser.symbol_gen.fresh("rewrite_var__"); let mut head = Actions::singleton(Action::Union( @@ -340,14 +351,17 @@ fn desugar_rewrite( )); } _ => { - panic!("Subsumed rewrite must have a function call on the lhs"); + return Err(Error::DesugarError( + rewrite.lhs.span(), + "subsumed rewrite must have a function call on the lhs".to_string(), + )); } } } // make two rules- one to insert the rhs, and one to union // this way, the union rule can only be fired once, // which helps proofs not add too much info - vec![NCommand::NormRule { + Ok(vec![NCommand::NormRule { rule: Rule { span: span.clone(), body: [Fact::Eq( @@ -365,7 +379,7 @@ fn desugar_rewrite( no_decomp: false, include_subsumed: false, }, - }] + }]) } fn desugar_birewrite( @@ -373,7 +387,7 @@ fn desugar_birewrite( name: String, rewrite: Rewrite, parser: &mut Parser, -) -> Vec { +) -> Result, Error> { let span = rewrite.span.clone(); let rewrite_name = if rewrite.name.is_empty() { name @@ -387,13 +401,13 @@ fn desugar_birewrite( conditions: rewrite.conditions.clone(), name: rewrite_name.clone(), }; - desugar_rewrite( + Ok(desugar_rewrite( ruleset.clone(), format!("{rewrite_name}=>"), rewrite, false, parser, - ) + )? .into_iter() .chain(desugar_rewrite( ruleset, @@ -401,8 +415,8 @@ fn desugar_birewrite( rw2, false, parser, - )) - .collect() + )?) + .collect()) } /// Desugar relation by making a new sort and a constructor for it. diff --git a/src/ast/parse.rs b/src/ast/parse.rs index e73a8073..dbe56fe3 100644 --- a/src/ast/parse.rs +++ b/src/ast/parse.rs @@ -839,7 +839,10 @@ impl Parser { [subcommand] => { let mut cs = self.parse_command(subcommand)?; if cs.len() != 1 { - todo!("extend Fail to work with multiple parsed commands") + return error!( + span, + "(fail ...) does not support commands that expand into multiple commands" + ); } vec![Command::Fail(span, Box::new(cs.remove(0)))] } diff --git a/src/cli.rs b/src/cli.rs index 3e39e4dd..55f3a219 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -4,6 +4,7 @@ use std::io::{self, BufRead, BufReader, IsTerminal, Read, Write}; use clap::Parser; use env_logger::Env; use std::path::PathBuf; +use std::str::FromStr; #[derive(Debug, Parser)] #[command(version = env!("FULL_VERSION"), about = env!("CARGO_PKG_DESCRIPTION"))] @@ -90,6 +91,8 @@ pub fn cli(mut egraph: EGraph) { let args = Args::parse(); + egraph.set_num_threads(args.threads); + if args.term_encoding { egraph = egraph.with_term_encoding_enabled(); } @@ -103,7 +106,6 @@ pub fn cli(mut egraph: EGraph) { egraph = egraph.with_proof_testing(); } - EGraph::set_num_threads(args.threads); egraph.fact_directory.clone_from(&args.fact_directory); egraph.seminaive = !args.naive; egraph.no_decomp = args.no_decomp; @@ -121,14 +123,18 @@ pub fn cli(mut egraph: EGraph) { } } else { for input in &args.inputs { - let program = std::fs::read_to_string(input).unwrap_or_else(|_| { - let arg = input.to_string_lossy(); - panic!("Failed to read file {arg}") - }); + let program = match std::fs::read_to_string(input) { + Ok(program) => program, + Err(e) => { + let arg = input.to_string_lossy(); + log::error!("Failed to read file {arg}: {e}"); + std::process::exit(1) + } + }; match run_commands( &mut egraph, - Some(input.to_str().unwrap().into()), + Some(input.to_string_lossy().into_owned()), &program, io::stdout(), args.mode, @@ -158,28 +164,36 @@ pub fn cli(mut egraph: EGraph) { let serialize_filename = if args.serialize_split_primitive_outputs { input.with_file_name(format!( "{}-split", - input.file_stem().unwrap().to_str().unwrap() + input + .file_stem() + .map(|s| s.to_string_lossy()) + .unwrap_or_default() )) } else { input.clone() }; if args.to_dot { let dot_path = serialize_filename.with_extension("dot"); - serialized - .to_dot_file(dot_path.clone()) - .unwrap_or_else(|_| panic!("Failed to write dot file to {dot_path:?}")); + if let Err(e) = serialized.to_dot_file(dot_path.clone()) { + log::error!("Failed to write dot file to {dot_path:?}: {e}"); + std::process::exit(1) + } } if args.to_svg { let svg_path = serialize_filename.with_extension("svg"); - serialized.to_svg_file(svg_path.clone()).unwrap_or_else( |_| - panic!("Failed to write svg file to {svg_path:?}. Make sure you have the `dot` executable installed") - ); + if let Err(e) = serialized.to_svg_file(svg_path.clone()) { + log::error!( + "Failed to write svg file to {svg_path:?}: {e}. Make sure you have the `dot` executable installed" + ); + std::process::exit(1) + } } if args.to_json { let json_path = serialize_filename.with_extension("json"); - serialized - .to_json_file(json_path.clone()) - .unwrap_or_else(|_| panic!("Failed to write json file to {json_path:?}")); + if let Err(e) = serialized.to_json_file(json_path.clone()) { + log::error!("Failed to write json file to {json_path:?}: {e}"); + std::process::exit(1) + } } } } @@ -187,12 +201,17 @@ pub fn cli(mut egraph: EGraph) { if let Some(report_path) = args.save_report { let report = egraph.get_overall_run_report(); - serde_json::to_writer( - std::fs::File::create(&report_path) - .unwrap_or_else(|_| panic!("Failed to create report file at {report_path:?}")), - &report, - ) - .expect("Failed to serialize report"); + let file = match std::fs::File::create(&report_path) { + Ok(file) => file, + Err(e) => { + log::error!("Failed to create report file at {report_path:?}: {e}"); + std::process::exit(1) + } + }; + if let Err(e) = serde_json::to_writer(file, &report) { + log::error!("Failed to serialize report: {e}"); + std::process::exit(1) + } log::info!("Saved report to {report_path:?}"); } diff --git a/src/constraint.rs b/src/constraint.rs index 3267a58b..75d5f2b7 100644 --- a/src/constraint.rs +++ b/src/constraint.rs @@ -511,23 +511,23 @@ impl Assignment { expr: &GenericExpr, String>, typeinfo: &TypeInfo, ctx: crate::Context, - ) -> ResolvedExpr { + ) -> Result { match &expr { - GenericExpr::Lit(span, literal) => ResolvedExpr::Lit(span.clone(), literal.clone()), + GenericExpr::Lit(span, literal) => Ok(ResolvedExpr::Lit(span.clone(), literal.clone())), GenericExpr::Var(span, var) => { let global_sort = typeinfo.get_global_sort(var); let ty = global_sort // Span is ignored when looking up atom_terms .or_else(|| self.get(&AtomTerm::Var(Span::Panic, var.clone()))) .expect("All variables should be assigned before annotation"); - ResolvedExpr::Var( + Ok(ResolvedExpr::Var( span.clone(), ResolvedVar { name: var.clone(), sort: ty.clone(), is_global_ref: global_sort.is_some(), }, - ) + )) } GenericExpr::Call( span, @@ -538,10 +538,10 @@ impl Assignment { args, ) => { // get the resolved call using resolve_rule - let args: Vec<_> = args + let args: Vec = args .iter() .map(|arg| self.annotate_expr(arg, typeinfo, ctx)) - .collect(); + .collect::>()?; let types: Vec<_> = args .iter() .map(|arg| arg.output_type()) @@ -551,8 +551,9 @@ impl Assignment { .clone(), )) .collect(); - let resolved_call = ResolvedCall::from_resolution(head, &types, typeinfo, ctx); - GenericExpr::Call(span.clone(), resolved_call, args) + let resolved_call = + ResolvedCall::from_resolution(head, &types, typeinfo, ctx, span)?; + Ok(GenericExpr::Call(span.clone(), resolved_call, args)) } } } @@ -562,14 +563,16 @@ impl Assignment { facts: &GenericFact, String>, typeinfo: &TypeInfo, ctx: crate::Context, - ) -> ResolvedFact { + ) -> Result { match facts { - GenericFact::Eq(span, e1, e2) => ResolvedFact::Eq( + GenericFact::Eq(span, e1, e2) => Ok(ResolvedFact::Eq( span.clone(), - self.annotate_expr(e1, typeinfo, ctx), - self.annotate_expr(e2, typeinfo, ctx), - ), - GenericFact::Fact(expr) => ResolvedFact::Fact(self.annotate_expr(expr, typeinfo, ctx)), + self.annotate_expr(e1, typeinfo, ctx)?, + self.annotate_expr(e2, typeinfo, ctx)?, + )), + GenericFact::Fact(expr) => { + Ok(ResolvedFact::Fact(self.annotate_expr(expr, typeinfo, ctx)?)) + } } } @@ -578,7 +581,7 @@ impl Assignment { mapped_facts: &[GenericFact, String>], typeinfo: &TypeInfo, ctx: crate::Context, - ) -> Vec { + ) -> Result, TypeError> { mapped_facts .iter() .map(|fact| self.annotate_fact(fact, typeinfo, ctx)) @@ -603,7 +606,7 @@ impl Assignment { sort: ty.clone(), is_global_ref: false, }, - self.annotate_expr(expr, typeinfo, ctx), + self.annotate_expr(expr, typeinfo, ctx)?, )) } // Note mapped_var for set is a dummy variable that does not mean anything @@ -616,17 +619,18 @@ impl Assignment { children, rhs, ) => { - let children: Vec<_> = children + let children: Vec = children .iter() .map(|child| self.annotate_expr(child, typeinfo, ctx)) - .collect(); - let rhs = self.annotate_expr(rhs, typeinfo, ctx); + .collect::>()?; + let rhs = self.annotate_expr(rhs, typeinfo, ctx)?; let types: Vec<_> = children .iter() .map(|child| child.output_type()) .chain(once(rhs.output_type())) .collect(); - let resolved_call = ResolvedCall::from_resolution(head, &types, typeinfo, ctx); + let resolved_call = + ResolvedCall::from_resolution(head, &types, typeinfo, ctx, span)?; if !matches!(resolved_call, ResolvedCall::Func(_)) { return Err(TypeError::UnboundFunction(head.clone(), span.clone())); } @@ -647,10 +651,10 @@ impl Assignment { }, children, ) => { - let children: Vec<_> = children + let children: Vec = children .iter() .map(|child| self.annotate_expr(child, typeinfo, ctx)) - .collect(); + .collect::>()?; let types: Vec<_> = children.iter().map(|child| child.output_type()).collect(); let resolved_call = ResolvedCall::from_resolution_func_types(head, &types, typeinfo) @@ -663,8 +667,8 @@ impl Assignment { )) } GenericAction::Union(span, lhs, rhs) => { - let lhs = self.annotate_expr(lhs, typeinfo, ctx); - let rhs = self.annotate_expr(rhs, typeinfo, ctx); + let lhs = self.annotate_expr(lhs, typeinfo, ctx)?; + let rhs = self.annotate_expr(rhs, typeinfo, ctx)?; let sort = lhs.output_type(); assert_eq!(sort.name(), rhs.output_type().name()); @@ -680,7 +684,7 @@ impl Assignment { GenericAction::Panic(span, msg) => Ok(ResolvedAction::Panic(span.clone(), msg.clone())), GenericAction::Expr(span, expr) => Ok(ResolvedAction::Expr( span.clone(), - self.annotate_expr(expr, typeinfo, ctx), + self.annotate_expr(expr, typeinfo, ctx)?, )), } } diff --git a/src/core.rs b/src/core.rs index d0dd46df..47a68abb 100644 --- a/src/core.rs +++ b/src/core.rs @@ -169,12 +169,13 @@ impl ResolvedCall { types: &[ArcSort], typeinfo: &TypeInfo, ctx: crate::Context, - ) -> ResolvedCall { + span: &Span, + ) -> Result { if let Some(ty) = typeinfo.get_func_type(head) { let expected = ty.input.iter().chain(once(&ty.output)).map(|s| s.name()); let actual = types.iter().map(|s| s.name()); if expected.eq(actual) { - return ResolvedCall::Func(ty.clone()); + return Ok(ResolvedCall::Func(ty.clone())); } } @@ -184,20 +185,30 @@ impl ResolvedCall { .flatten() .filter(|p| p.context_ids[ctx].is_some() && p.accept(types, typeinfo)); if let Some(picked) = primitives.next() { + // Type inference has already assigned concrete types, so a valid + // overload (`+`, `map-empty`, container primitives) leaves exactly + // one matching registration. A second match means two registrations + // are indistinguishable for this signature and context. if primitives.next().is_some() { - panic!( - "Ambiguous primitive resolution for {head:?} in direct call context {ctx:?}" - ); + return Err(TypeError::AmbiguousPrimitive { + name: head.to_owned(), + ctx, + span: span.clone(), + }); } let (out, inp) = types.split_last().unwrap(); - return ResolvedCall::Primitive(SpecializedPrimitive { + return Ok(ResolvedCall::Primitive(SpecializedPrimitive { prim_with_id: picked.clone(), input: inp.to_vec(), output: out.clone(), - }); + })); } - panic!("No resolution for {head:?} in context {ctx:?}"); + Err(TypeError::UnresolvedPrimitive { + name: head.to_owned(), + ctx, + span: span.clone(), + }) } } diff --git a/src/extract.rs b/src/extract.rs index 3c7aa40b..1b7593e2 100644 --- a/src/extract.rs +++ b/src/extract.rs @@ -631,8 +631,13 @@ impl Extractor { let find_root_variants = |row: egglog_bridge::ScanEntry| { if !row.subsumed { let target = &row.vals[output_idx]; - if *target == canonical_value { - let cost = self.compute_cost_hyperedge(egraph, &row, func).unwrap(); + // A variant whose cost is `None` has a child e-class with no + // finite extraction (e.g. a purely cyclic child); such a variant + // can never appear in a minimal extraction, so we skip it. The + // target e-class still extracts via its other, costed variants. + if *target == canonical_value + && let Some(cost) = self.compute_cost_hyperedge(egraph, &row, func) + { root_variants.push((cost, func_name.clone(), row.vals.to_vec())); } } @@ -784,7 +789,14 @@ impl EGraph { let extractor = Extractor::compute_costs_from_rootsorts(Some(vec![sort.clone()]), self, cost_model); let mut termdag = TermDag::default(); - let (cost, term) = extractor.extract_best(self, &mut termdag, value).unwrap(); + let (cost, term) = extractor + .extract_best(self, &mut termdag, value) + .ok_or_else(|| { + Error::ExtractError( + "Unable to find any valid extraction (likely due to subsume or delete)" + .to_string(), + ) + })?; Ok((termdag, term, cost)) } diff --git a/src/lib.rs b/src/lib.rs index 9eb5a684..abbd2ed6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -68,7 +68,6 @@ use std::io::{Read as _, Write as _}; use std::iter::once; use std::ops::Deref; use std::path::PathBuf; -use std::str::FromStr; use std::sync::Arc; pub use termdag::{OrdTerm, Term, TermDag, TermId}; use thiserror::Error; @@ -498,6 +497,14 @@ struct ResolvedNCommandsWithOutput { pub struct NotFoundError(String); impl EGraph { + /// Create a new e-graph configured with `num_threads`. + /// + /// Passing `1` keeps execution serial. Passing `0` uses available + /// parallelism. + pub fn new(num_threads: usize) -> Self { + EGraph::default().with_num_threads(num_threads) + } + /// Create a new e-graph with the term-encoding pipeline enabled. /// /// In term-encoding mode the e-graph eagerly instruments every constructor @@ -522,6 +529,7 @@ impl EGraph { /// Enable the term-encoding pipeline on an existing `EGraph`. /// /// This method is to support the current CLI implementation with egglog-experimental (https://github.com/egraphs-good/egglog/issues/768) + #[cfg(feature = "bin")] pub(crate) fn with_term_encoding_enabled(mut self) -> Self { self.proof_state.original_typechecking = Some(Box::new(self.clone())); self @@ -530,6 +538,7 @@ impl EGraph { /// Enable proof generation on this e-graph. /// TODO proofs should be turned on during creation of the e-graph, not afterwards. /// This method is to support the current CLI implementation with egglog-experimental (https://github.com/egraphs-good/egglog/issues/768) + #[cfg(feature = "bin")] pub(crate) fn with_proofs_enabled(mut self) -> Self { self = self.with_term_encoding_enabled(); self.proof_state.proofs_enabled = true; @@ -542,39 +551,26 @@ impl EGraph { self } - /// Set the number of threads used for parallel operations. - /// - /// This is a helper that simply configures the global rayon thread pool. It can only be called - /// once per process; subsequent calls will be ignored. - /// - /// # Panics + /// Return a copy of this e-graph configured with `num_threads`. + pub fn with_num_threads(mut self, num_threads: usize) -> Self { + self.set_num_threads(num_threads); + self + } + + /// Set the number of threads used by this e-graph. /// - /// Panics on wasm if `num_threads > 1`. - pub fn set_num_threads(num_threads: usize) { - #[cfg(target_family = "wasm")] - if num_threads > 1 { - panic!("cannot use more than 1 thread on wasm"); - } - #[cfg(not(target_family = "wasm"))] - { - // This will fail silently if the global pool has already been configured. - let err = rayon::ThreadPoolBuilder::new() - .num_threads(num_threads) - .build_global(); - // print log if successful - if matches!(err, Ok(())) { - log::info!("Initialize global thread pool with {num_threads} threads"); - } else { - log::warn!( - "Failed to initialize global thread pool with {num_threads} threads. This may be because the thread pool was already initialized with a different number of threads. Error: {err:?}" - ); - } + /// Passing `1` keeps execution serial. Passing `0` uses available + /// parallelism. + pub fn set_num_threads(&mut self, num_threads: usize) { + self.backend.set_num_threads(num_threads); + if let Some(original) = &mut self.proof_state.original_typechecking { + original.set_num_threads(num_threads); } } - /// Return the number of threads in the rayon thread pool. + /// Return the number of threads configured for this e-graph. pub fn num_threads(&self) -> usize { - rayon::current_num_threads() + self.backend.num_threads() } /// Return extension-owned state stored on this e-graph. @@ -771,7 +767,7 @@ impl EGraph { .map(|arg| self.translate_expr_to_mergefn(arg)) .collect::, _>>()?; if p.name() == "unstable-fn" { - let Some(GenericExpr::Lit(_, Literal::String(name))) = args.first() else { + let Some(GenericExpr::Lit(span, Literal::String(name))) = args.first() else { return Err(Error::BackendError( "expected string literal after `unstable-fn`".into(), )); @@ -787,6 +783,9 @@ impl EGraph { .read() .unwrap() .default_panic_id(), + // Merge expressions evaluate in the `Write` context. + crate::Context::Write, + span, )?; translated_args[0] = egglog_bridge::MergeFn::Const(self.backend.base_values().get(resolved)); @@ -871,7 +870,8 @@ impl EGraph { &mut self, sym: &str, n: Option, - file: Option, + file: Option<(File, PathBuf)>, + span: Span, mode: PrintFunctionMode, ) -> Result, Error> { let n = match n { @@ -894,10 +894,10 @@ impl EGraph { let terms_and_outputs: Vec<_> = terms.into_iter().zip(outputs.unwrap()).collect(); let output = CommandOutput::PrintFunction(f.clone(), termdag, terms_and_outputs, mode); match file { - Some(mut file) => { + Some((mut file, path)) => { log::info!("Writing output to file"); file.write_all(output.to_string().as_bytes()) - .expect("Error writing to file"); + .map_err(|e| Error::IoError(path, e, span.clone()))?; Ok(None) } None => Ok(Some(output)), @@ -1163,7 +1163,7 @@ impl EGraph { rb.set_no_decomp(no_decomp); let mut translator = BackendRule::new(rb, &self.functions, &self.type_info, requires_read_context); - translator.query(query, rule.include_subsumed); + translator.query(query, rule.include_subsumed)?; translator.actions(actions)?; translator.build() }; @@ -1173,8 +1173,7 @@ impl EGraph { Ruleset::Rules(rules) => { match rules.entry(rule.name.clone()) { indexmap::map::Entry::Occupied(_) => { - let name = rule.name; - panic!("Rule '{name}' was already present") + return Err(Error::RuleAlreadyExists(rule.name, rule.span)); } indexmap::map::Entry::Vacant(e) => e.insert((core_rule, rule_id)), }; @@ -1308,11 +1307,23 @@ impl EGraph { } let resolved_commands = resolved.desugared; - assert_eq!(resolved_commands.len(), 1); - let resolved_command = resolved_commands.into_iter().next().unwrap(); + if resolved_commands.len() != 1 { + return Err(Error::BackendError( + "eval_expr expects a single resolved command".to_string(), + )); + } + let Some(resolved_command) = resolved_commands.into_iter().next() else { + return Err(Error::BackendError( + "eval_expr expects a single resolved command".to_string(), + )); + }; let resolved_expr = match resolved_command { ResolvedNCommand::CoreAction(ResolvedAction::Expr(_, resolved_expr)) => resolved_expr, - _ => unreachable!(), + cmd => { + return Err(Error::BackendError(format!( + "eval_expr: unexpected resolved command: {cmd:?}" + ))); + } }; let sort = resolved_expr.output_type(); let value = self.eval_resolved_expr(span, &resolved_expr)?; @@ -1409,6 +1420,9 @@ impl EGraph { name, prim, panic_id, + // Top-level action evaluation runs in the `Full` context. + crate::Context::Full, + target_span, )?; let fn_value = self.backend.base_values().get(resolved_function); let binding_name = self.parser.symbol_gen.fresh("unstable_fn_target"); @@ -1557,7 +1571,7 @@ impl EGraph { &self.type_info, true, // global query: Read context (may read the DB) ); - translator.query(&query, true); + translator.query(&query, true)?; translator .rb .call_external_func(ext_id, &[], egglog_bridge::ColumnTy::Id, || { @@ -1656,8 +1670,9 @@ impl EGraph { .map_err(|e| Error::IoError(path.clone().into(), e, span.clone()))?; log::info!("Printed overall statistics to json file {path}"); - serde_json::to_writer(&mut file, &self.overall_run_report) - .expect("error serializing to json"); + serde_json::to_writer(&mut file, &self.overall_run_report).map_err(|e| { + Error::BackendError(format!("failed writing statistics: {e}")) + })?; } }, ResolvedNCommand::Check(span, facts) => { @@ -1701,7 +1716,9 @@ impl EGraph { } } else { if n < 0 { - panic!("Cannot extract negative number of variants"); + return Err(Error::ExtractError( + "cannot extract a negative number of variants".to_string(), + )); } let terms: Vec = extractor .extract_variants(self, &mut termdag, x, n as usize) @@ -1734,12 +1751,15 @@ impl EGraph { ResolvedNCommand::PrintFunction(span, f, n, file, mode) => { let file = file .map(|file| { - std::fs::File::create(&file) - .map_err(|e| Error::IoError(file.into(), e, span.clone())) + let path: PathBuf = file.into(); + match std::fs::File::create(&path) { + Ok(f) => Ok((f, path)), + Err(e) => Err(Error::IoError(path, e, span.clone())), + } }) .transpose()?; return self - .print_function(&f, n, file, mode) + .print_function(&f, n, file, span.clone(), mode) .map_err(|e| match e { Error::TypeError(TypeError::UnboundFunction(f, _)) => { Error::TypeError(TypeError::UnboundFunction(f, span.clone())) @@ -1767,12 +1787,8 @@ impl EGraph { return Err(Error::ExpectFail(span)); } } - ResolvedNCommand::Input { - span: _, - name, - file, - } => { - self.input_file(&name, file)?; + ResolvedNCommand::Input { span, name, file } => { + self.input_file(&name, file, span)?; } ResolvedNCommand::Output { span, file, exprs } => { let mut filename = self.fact_directory.clone().unwrap_or_default(); @@ -1796,10 +1812,18 @@ impl EGraph { let value = self.eval_resolved_expr(span.clone(), &expr)?; let expr_type = expr.output_type(); - let term = extractor - .extract_best_with_sort(self, &mut termdag, value, expr_type) - .unwrap() - .1; + let term = match extractor.extract_best_with_sort( + self, + &mut termdag, + value, + expr_type, + ) { + Some((_, term)) => term, + None => return Err(Error::ExtractError( + "Unable to find any valid extraction (likely due to subsume or delete)" + .to_string(), + )), + }; writeln!(f, "{}", termdag.to_string(term)) .map_err(|e| Error::IoError(filename.clone(), e, span.clone()))?; } @@ -1836,11 +1860,13 @@ impl EGraph { Ok(vec![]) } - fn input_file(&mut self, func_name: &str, file: String) -> Result<(), Error> { - let function_type = self - .type_info - .get_func_type(func_name) - .unwrap_or_else(|| panic!("Unrecognized function name {func_name}")); + fn input_file(&mut self, func_name: &str, file: String, span: Span) -> Result<(), Error> { + let function_type = self.type_info.get_func_type(func_name).ok_or_else(|| { + Error::TypeError(TypeError::UnboundFunction( + func_name.to_string(), + span.clone(), + )) + })?; let func = self.functions.get_mut(func_name).unwrap(); let mut filename = self.fact_directory.clone().unwrap_or_default(); @@ -1851,21 +1877,23 @@ impl EGraph { for t in &func.schema.input { match t.name() { "i64" | "f64" | "String" => {} - s => panic!("Unsupported type {s} for input"), + s => return Err(Error::UnsupportedInputType(s.to_string(), span.clone())), } } if function_type.subtype != FunctionSubtype::Constructor { match func.schema.output.name() { "i64" | "String" | "Unit" => {} - s => panic!("Unsupported type {s} for input"), + s => return Err(Error::UnsupportedInputType(s.to_string(), span.clone())), } } log::info!("Opening file '{filename:?}'..."); - let mut f = File::open(filename).unwrap(); + let mut f = + File::open(&filename).map_err(|e| Error::IoError(filename.clone(), e, span.clone()))?; let mut contents = String::new(); - f.read_to_string(&mut contents).unwrap(); + f.read_to_string(&mut contents) + .map_err(|e| Error::IoError(filename.clone(), e, span.clone()))?; // Can also do a row-major Vec let mut parsed_contents: Vec> = Vec::with_capacity(contents.lines().count()); @@ -2437,6 +2465,7 @@ pub use crate::api::{ApiError, FromValue, FromValues, IntoValue, IntoValues, Raw /// `unstable-app` will call later. For primitive targets, this bakes one /// dispatch id per runtime context so application can choose the entrypoint /// matching the primitive body's current call-site context. +#[allow(clippy::too_many_arguments)] fn resolve_function_container_target_with_context( backend: &egglog_bridge::EGraph, functions: &IndexMap, @@ -2444,26 +2473,30 @@ fn resolve_function_container_target_with_context( name: &str, primitive: &core::SpecializedPrimitive, panic_id: ExternalFunctionId, + ctx: crate::Context, + span: &Span, ) -> Result { - let target_function = type_info + let Some(target_function) = type_info .get_sorts::() .into_iter() .find(|function| function.name() == primitive.output().name()) - .ok_or_else(|| { - Error::BackendError(format!( - "`unstable-fn` output sort `{}` is not a function sort", - primitive.output().name() - )) - })?; + else { + return Err(Error::BackendError(format!( + "`unstable-fn` output sort `{}` is not a function sort", + primitive.output().name() + ))); + }; let partial_arcsorts: Vec<_> = primitive.input().iter().skip(1).cloned().collect(); let remaining_inputs = target_function.inputs(); let output = target_function.output(); let id = if let Some(func) = functions.get(name) { - let func_type = type_info - .get_func_type(name) - .ok_or_else(|| Error::BackendError(format!("No resolution for {name:?}")))?; + let func_type = type_info.get_func_type(name).ok_or_else(|| { + Error::BackendError(format!( + "`unstable-fn` references `{name}`, which has no resolved type" + )) + })?; let expected_inputs = partial_arcsorts .iter() .chain(remaining_inputs) @@ -2487,7 +2520,7 @@ fn resolve_function_container_target_with_context( .collect::>() .join(", "); return Err(Error::BackendError(format!( - "function container lookup for `{name}` expected ({}) -> {}, found ({}) -> {}", + "`unstable-fn` reference `{name}` expected ({}) -> {}, found ({}) -> {}", expected_input_names, output.name(), actual_input_names, @@ -2511,42 +2544,46 @@ fn resolve_function_container_target_with_context( .iter() .filter(|primitive| primitive.accept(&signature, type_info)) .collect(); - let mut context_ids = enum_map::EnumMap::from_fn(|_| None); - for runtime_ctx in Context::ALL { + let mut ambiguous_ctx = None; + let context_ids = enum_map::EnumMap::from_fn(|runtime_ctx| { let mut ids = candidates .iter() .filter_map(|primitive| primitive.context_ids[runtime_ctx]); // The first `next` finds the candidate for this runtime context; // the second detects whether there is more than one such candidate. match (ids.next(), ids.next()) { - (None, _) => {} - (Some(id), None) => context_ids[runtime_ctx] = Some(id), + (None, _) => None, + (Some(id), None) => Some(id), (Some(_), Some(_)) => { - return Err(Error::BackendError(format!( - "Ambiguous primitive resolution for {name:?} in unstable-fn context {runtime_ctx:?}" - ))); + ambiguous_ctx = Some(runtime_ctx); + None } } + }); + if let Some(runtime_ctx) = ambiguous_ctx { + return Err(TypeError::AmbiguousPrimitive { + name: name.to_owned(), + ctx: runtime_ctx, + span: span.clone(), + } + .into()); } if !context_ids.iter().any(|(_, id)| id.is_some()) { - let (output_sort, input_sorts) = signature - .split_last() - .expect("primitive signature should include an output sort"); - let input_names = input_sorts - .iter() - .map(|sort| sort.name()) - .collect::>() - .join(", "); - return Err(Error::BackendError(format!( - "no primitive overload matched expected signature for {name:?}: ({}) -> {}; \ - context ids: {context_ids:?}", - input_names, - output_sort.name(), - ))); + return Err(TypeError::UnresolvedPrimitive { + name: name.to_owned(), + ctx, + span: span.clone(), + } + .into()); } ResolvedFunctionId::Primitive { context_ids } } else { - return Err(Error::BackendError(format!("No resolution for {name:?}"))); + return Err(TypeError::UnresolvedPrimitive { + name: name.to_owned(), + ctx, + span: span.clone(), + } + .into()); }; Ok(ResolvedFunction { @@ -2636,7 +2673,7 @@ impl<'a> BackendRule<'a> { prim: &core::SpecializedPrimitive, args: &[core::ResolvedAtomTerm], ctx: crate::Context, - ) -> (ExternalFunctionId, Vec, ColumnTy) { + ) -> Result<(ExternalFunctionId, Vec, ColumnTy), Error> { // The typechecker has already checked that this primitive is // valid in `ctx`; pick the runtime id that stamps the same ctx // onto the state wrapper when invoked. @@ -2645,8 +2682,11 @@ impl<'a> BackendRule<'a> { let mut qe_args = self.args(args); if prim.name() == "unstable-fn" { - let core::ResolvedAtomTerm::Literal(_, Literal::String(ref name)) = args[0] else { - panic!("expected string literal after `unstable-fn`") + let core::ResolvedAtomTerm::Literal(ref span, Literal::String(ref name)) = args[0] + else { + return Err(Error::BackendError( + "expected a string literal as the first argument to `unstable-fn`".to_string(), + )); }; // Pre-register a panic id used by `FunctionContainer::apply` // when the wrapped function is applied in a context that @@ -2664,17 +2704,18 @@ impl<'a> BackendRule<'a> { name, prim, panic_id, - ) - .unwrap_or_else(|err| panic!("{err}")); + ctx, + span, + )?; qe_args[0] = self.rb.egraph().base_value_constant(resolved); } - ( + Ok(( resolved_id, qe_args, prim.output().column_ty(self.rb.egraph()), - ) + )) } fn args<'b>( @@ -2684,7 +2725,11 @@ impl<'a> BackendRule<'a> { args.into_iter().map(|x| self.entry(x)).collect() } - fn query(&mut self, query: &core::Query, include_subsumed: bool) { + fn query( + &mut self, + query: &core::Query, + include_subsumed: bool, + ) -> Result<(), Error> { for atom in &query.atoms { match &atom.head { ResolvedCall::Func(f) => { @@ -2698,11 +2743,12 @@ impl<'a> BackendRule<'a> { } ResolvedCall::Primitive(p) => { let ctx = self.query_context(); - let (p, args, ty) = self.prim(p, &atom.args, ctx); + let (p, args, ty) = self.prim(p, &atom.args, ctx)?; self.rb.query_prim(p, &args, ty).unwrap() } } } + Ok(()) } fn actions(&mut self, actions: &core::ResolvedCoreActions) -> Result<(), Error> { @@ -2723,7 +2769,7 @@ impl<'a> BackendRule<'a> { ResolvedCall::Primitive(p) => { let name = p.name().to_owned(); let ctx = self.action_context(); - let (p, args, ty) = self.prim(p, args, ctx); + let (p, args, ty) = self.prim(p, args, ctx)?; let span = span.clone(); self.rb.call_external_func(p, &args, ty, move || { format!("{span}: call of primitive {name} failed") @@ -2839,6 +2885,12 @@ pub enum Error { Shadowing(String, Span, Span), #[error("{1}\nCommand already exists: {0}")] CommandAlreadyExists(String, Span), + #[error("{1}\nRule already exists: {0}")] + RuleAlreadyExists(String, Span), + #[error("{1}\nUnsupported type {0} for input")] + UnsupportedInputType(String, Span), + #[error("{0}\n{1}")] + DesugarError(Span, String), #[error("Incorrect format in file '{0}'.")] InputFileFormatError(String), #[error( @@ -3341,4 +3393,39 @@ mod tests { .unwrap_err(); assert!(matches!(err, Error::NoSuchRuleset(name, _) if name == "test2")); } + + #[test] + fn test_duplicate_rule_name_errors() { + let err = EGraph::default() + .parse_and_run_program( + None, + "(relation foo (i64)) + (rule ((foo x)) ((foo (+ x 1))) :name \"r\") + (rule ((foo x)) ((foo (+ x 2))) :name \"r\")", + ) + .unwrap_err(); + assert!(matches!(err, Error::RuleAlreadyExists(..))); + } + + #[test] + fn test_extract_negative_variants_errors() { + let err = EGraph::default() + .parse_and_run_program( + None, + "(sort Math)(constructor Num (i64) Math)(let x (Num 5))(extract x -1)", + ) + .unwrap_err(); + assert!(matches!(err, Error::ExtractError(..))); + } + + #[test] + fn test_input_missing_file_errors() { + let err = EGraph::default() + .parse_and_run_program( + None, + "(function edge (i64) i64 :merge old)(input edge \"/no/such/file_xyz\")", + ) + .unwrap_err(); + assert!(matches!(err, Error::IoError(..))); + } } diff --git a/src/proofs/proof_encoding.rs b/src/proofs/proof_encoding.rs index 1d890857..9804be1c 100644 --- a/src/proofs/proof_encoding.rs +++ b/src/proofs/proof_encoding.rs @@ -1575,7 +1575,11 @@ impl<'a> ProofInstrumentor<'a> { } ResolvedNCommand::Fail(span, cmd) => { self.term_encode_command(cmd, res); - let last = res.pop().unwrap(); + // Every term-encodable inner command pushes at least one command, so + // this pop cannot fail; an empty `res` would be an egglog bug. + let last = res + .pop() + .expect("(fail ...) inner command produced no instrumented command"); res.push(Command::Fail(span.clone(), Box::new(last))); } ResolvedNCommand::Extract(span, expr, variants) => { diff --git a/src/proofs/proof_encoding_helpers.rs b/src/proofs/proof_encoding_helpers.rs index e9835c57..a38b3c65 100644 --- a/src/proofs/proof_encoding_helpers.rs +++ b/src/proofs/proof_encoding_helpers.rs @@ -132,7 +132,9 @@ impl ProofInstrumentor<'_> { let res = self.egraph.parser.get_program_from_string(None, input); self.egraph.parser.ensure_no_reserved_symbols = true; - res.unwrap() + // This program is generated internally by term encoding, so a parse + // failure is an egglog bug rather than a user error. + res.expect("internally generated term-encoding program must parse") } pub(crate) fn format_prooflist(&self, proofs: &[String]) -> String { @@ -170,7 +172,7 @@ impl ProofInstrumentor<'_> { self.egraph.parser.ensure_no_reserved_symbols = false; let res = self.egraph.parser.get_schedule_from_string(None, &input); self.egraph.parser.ensure_no_reserved_symbols = true; - res.unwrap() + res.expect("internally generated term-encoding schedule must parse") } /// Internal parse helper for term encoding- parse and crash on failure. @@ -178,7 +180,12 @@ impl ProofInstrumentor<'_> { self.egraph.parser.ensure_no_reserved_symbols = false; let res = input .iter() - .map(|f| self.egraph.parser.get_fact_from_string(None, f).unwrap()) + .map(|f| { + self.egraph + .parser + .get_fact_from_string(None, f) + .expect("internally generated term-encoding fact must parse") + }) .collect(); self.egraph.parser.ensure_no_reserved_symbols = true; res @@ -189,7 +196,7 @@ impl ProofInstrumentor<'_> { self.egraph.parser.ensure_no_reserved_symbols = false; let res = self.egraph.parser.get_expr_from_string(None, input); self.egraph.parser.ensure_no_reserved_symbols = true; - res.unwrap() + res.expect("internally generated term-encoding expression must parse") } // Each function/constructor gets a view table, the canonicalized e-nodes to accelerate e-matching. @@ -689,6 +696,12 @@ pub(crate) fn command_supports_proof_encoding( Err(ProofEncodingUnsupportedReason::LetBindingWithNonEqSort) } } + // (fail ) must still satisfy the proof encoding constraints on its inner command, + // e.g. (fail (let x 3)) should report the unsupported inner command rather than + // bypassing the guard and panicking later in proof global removal. + GenericCommand::Fail(_span, inner) => { + command_supports_proof_encoding(inner.as_ref(), type_info) + } _ => Ok(()), } } diff --git a/src/proofs/proof_extraction.rs b/src/proofs/proof_extraction.rs index d885107b..53568675 100644 --- a/src/proofs/proof_extraction.rs +++ b/src/proofs/proof_extraction.rs @@ -13,6 +13,8 @@ pub enum ProveExistsError { PrimitivesUnsupported, #[error("Could not find a proof due to query not matching (constructor {constructor}).")] QueryDidNotMatch { constructor: String }, + #[error("prove/prove-exists requires proofs to be enabled (run with --proofs).")] + ProofsNotEnabled, } impl ProofInstrumentor<'_> { @@ -62,13 +64,10 @@ impl ProofInstrumentor<'_> { .proof_state .proof_func_parent .get(output_sort.name()) - .unwrap_or_else(|| { - panic!( - "no :internal-proof-func annotation recorded for sort {} (constructor {})", - output_sort.name(), - func.name - ) - }) + // A missing proof-function annotation means the proof infrastructure + // was never set up for this sort, i.e. proofs are not enabled. This is + // the genuine user-facing precondition for prove/prove-exists. + .ok_or(ProveExistsError::ProofsNotEnabled)? .clone(); let proof_sort = self .egraph diff --git a/src/scheduler.rs b/src/scheduler.rs index 8222c361..2592f79c 100644 --- a/src/scheduler.rs +++ b/src/scheduler.rs @@ -40,6 +40,12 @@ pub struct Matches { matches: Vec, chosen: Vec, vars: Vec, + /// Width of each stored tuple in `matches`. This is `vars.len()` for an + /// ordinary rule. A rule whose head references no variables would otherwise + /// have zero-width tuples, making its match count unrecoverable; for those we + /// collect a single unit marker per match, so the width is 1 while `vars` is + /// empty. + tuple_width: usize, all_chosen: bool, } @@ -60,12 +66,15 @@ impl Match<'_> { impl Matches { fn new(matches: Vec, vars: Vec) -> Self { - let total_len = matches.len(); - let tuple_len = vars.len(); - assert!(total_len.is_multiple_of(tuple_len)); + // Variable-free rules collect one unit marker per match (see + // `SchedulerRuleInfo::new`), so each stored tuple is one value wide even + // though there are no variables. + let tuple_width = vars.len().max(1); + assert!(matches.len().is_multiple_of(tuple_width)); Self { matches, vars, + tuple_width, chosen: Vec::new(), all_chosen: false, } @@ -73,7 +82,7 @@ impl Matches { /// The number of matches in total. pub fn match_size(&self) -> usize { - self.matches.len() / self.vars.len() + self.matches.len() / self.tuple_width } /// The length of a tuple. @@ -107,18 +116,30 @@ impl Matches { state: &mut ExecutionState<'_>, table_action: &TableAction, ) -> Vec { - let tuple_len = self.tuple_len(); + // Width of the stored tuples (1 for variable-free rules, see `new`) versus + // the number of variable columns actually written into the `decided` table. + // For a variable-free rule the stored unit marker is dropped and only the + // trailing unit is inserted, producing the single `(unit)` row that the + // action rule fires on. + let tuple_width = self.tuple_width; + let var_len = self.vars.len(); let unit = state.base_values().get(()); if self.all_chosen { - for row in self.matches.chunks(tuple_len) { - table_action.insert(state, row.iter().cloned().chain(std::iter::once(unit))); + for row in self.matches.chunks(tuple_width) { + table_action.insert( + state, + row[..var_len].iter().cloned().chain(std::iter::once(unit)), + ); } vec![] } else { for idx in self.chosen.iter() { - let row = &self.matches[idx * tuple_len..(idx + 1) * tuple_len]; - table_action.insert(state, row.iter().cloned().chain(std::iter::once(unit))); + let row = &self.matches[idx * tuple_width..(idx + 1) * tuple_width]; + table_action.insert( + state, + row[..var_len].iter().cloned().chain(std::iter::once(unit)), + ); } // swap remove the chosen matches @@ -130,14 +151,14 @@ impl Matches { // matches are exhausted. p -= 1; if c != p { - let idx_c = c * tuple_len; - let idx_p = p * tuple_len; - for i in 0..tuple_len { + let idx_c = c * tuple_width; + let idx_p = p * tuple_width; + for i in 0..tuple_width { self.matches.swap(idx_c + i, idx_p + i); } } } - self.matches.truncate(p * tuple_len); + self.matches.truncate(p * tuple_width); self.matches } @@ -173,8 +194,11 @@ impl EGraph { ruleset: &str, rulesets: &'a IndexMap, ids: &mut Vec<(String, &'a ResolvedCoreRule)>, - ) { - match &rulesets[ruleset] { + ) -> Result<(), Error> { + let Some(r) = rulesets.get(ruleset) else { + return Err(Error::BackendError(format!("no such ruleset: {ruleset}"))); + }; + match r { Ruleset::Rules(rules) => { for (rule_name, (core_rule, _)) in rules.iter() { ids.push((rule_name.clone(), core_rule)); @@ -182,96 +206,112 @@ impl EGraph { } Ruleset::Combined(sub_rulesets) => { for sub_ruleset in sub_rulesets { - collect_rules(sub_ruleset, rulesets, ids); + collect_rules(sub_ruleset, rulesets, ids)?; } } } + Ok(()) } let mut rules = Vec::new(); let rulesets = std::mem::take(&mut self.rulesets); - collect_rules(ruleset, &rulesets, &mut rules); + let collected = collect_rules(ruleset, &rulesets, &mut rules); + // Restore `rulesets` before propagating any error so the EGraph is not + // left with its rulesets taken out. + if let Err(e) = collected { + self.rulesets = rulesets; + return Err(e); + } let mut schedulers = std::mem::take(&mut self.schedulers); - // Step 1: build all the query/action rules and worklist if have not already - let record = &mut schedulers[scheduler_id]; - rules.iter().for_each(|(id, rule)| { - record - .rule_info - .entry((*id).to_owned()) - .or_insert_with(|| SchedulerRuleInfo::new(self, rule, id)); - }); - - // Step 2: run all the queries for one iteration - let query_rules = rules - .iter() - .filter_map(|(rule_id, _rule)| { - let rule_info = record.rule_info.get(rule_id).unwrap(); - - if rule_info.should_seek { - Some(rule_info.query_rule) - } else { - None + // `rulesets` and `schedulers` are now taken out of `self`. The body below + // has several fallible steps (rule compilation, `run_rules`), so run it in + // a closure and restore both fields afterward no matter how it exits. + // Otherwise an early error would leave the EGraph with empty rulesets and + // schedulers. + let result = (|| -> Result { + // Step 1: build all the query/action rules and worklist if have not already + let record = &mut schedulers[scheduler_id]; + for (id, rule) in rules.iter() { + if !record.rule_info.contains_key(id) { + let info = SchedulerRuleInfo::new(self, rule, id)?; + record.rule_info.insert((*id).to_owned(), info); } - }) - .collect::>(); - - let query_iter_report = self - .backend - .run_rules(&query_rules) - .map_err(|e| Error::BackendError(e.to_string()))?; - - // Step 3: let the scheduler decide which matches need to be kept - self.backend.with_execution_state(|state| { - for (rule_id, _rule) in rules.iter() { - let rule_info = record.rule_info.get_mut(rule_id).unwrap(); - - let matches: Vec = - std::mem::take(rule_info.matches.lock().unwrap().as_mut()); - let mut matches = Matches::new(matches, rule_info.free_vars.clone()); - rule_info.should_seek = - record - .scheduler - .filter_matches(rule_id, ruleset, &mut matches); - let table_action = TableAction::new(&self.backend, rule_info.decided); - *rule_info.matches.lock().unwrap() = matches.instantiate(state, &table_action); } - }); - self.backend.flush_updates(); - - // Step 4: run the action rules - let action_rules = rules - .iter() - .map(|(rule_id, _rule)| { - let rule_info = record.rule_info.get(rule_id).unwrap(); - rule_info.action_rule - }) - .collect::>(); - let action_iter_report = self - .backend - .run_rules(&action_rules) - .map_err(|e| Error::BackendError(e.to_string()))?; - - // Step 5: combine the reports - let mut query_report = RunReport::singleton(ruleset, query_iter_report); - let mut action_report = RunReport::singleton(ruleset, action_iter_report); - // query matches don't count - query_report.updated = false; - query_report.num_matches_per_rule.clear(); - // Scheduler state should not count as database progress. Instead it - // determines whether a no-op iteration can be treated as fully stopped. - action_report.can_stop = !action_report.updated && { - let rule_ids = rules.iter().map(|(id, _)| id.as_str()).collect::>(); - record.scheduler.can_stop(&rule_ids, ruleset) - }; + // Step 2: run all the queries for one iteration + let query_rules = rules + .iter() + .filter_map(|(rule_id, _rule)| { + let rule_info = record.rule_info.get(rule_id).unwrap(); - query_report.union(action_report); + if rule_info.should_seek { + Some(rule_info.query_rule) + } else { + None + } + }) + .collect::>(); + + let query_iter_report = self + .backend + .run_rules(&query_rules) + .map_err(|e| Error::BackendError(e.to_string()))?; + + // Step 3: let the scheduler decide which matches need to be kept + self.backend.with_execution_state(|state| { + for (rule_id, _rule) in rules.iter() { + let rule_info = record.rule_info.get_mut(rule_id).unwrap(); + + let matches: Vec = + std::mem::take(rule_info.matches.lock().unwrap().as_mut()); + let mut matches = Matches::new(matches, rule_info.free_vars.clone()); + rule_info.should_seek = + record + .scheduler + .filter_matches(rule_id, ruleset, &mut matches); + let table_action = TableAction::new(&self.backend, rule_info.decided); + *rule_info.matches.lock().unwrap() = matches.instantiate(state, &table_action); + } + }); + self.backend.flush_updates(); + + // Step 4: run the action rules + let action_rules = rules + .iter() + .map(|(rule_id, _rule)| { + let rule_info = record.rule_info.get(rule_id).unwrap(); + rule_info.action_rule + }) + .collect::>(); + let action_iter_report = self + .backend + .run_rules(&action_rules) + .map_err(|e| Error::BackendError(e.to_string()))?; + + // Step 5: combine the reports + let mut query_report = RunReport::singleton(ruleset, query_iter_report); + let mut action_report = RunReport::singleton(ruleset, action_iter_report); + + // query matches don't count + query_report.updated = false; + query_report.num_matches_per_rule.clear(); + // Scheduler state should not count as database progress. Instead it + // determines whether a no-op iteration can be treated as fully stopped. + action_report.can_stop = !action_report.updated && { + let rule_ids = rules.iter().map(|(id, _)| id.as_str()).collect::>(); + record.scheduler.can_stop(&rule_ids, ruleset) + }; + + query_report.union(action_report); + + Ok(query_report) + })(); self.rulesets = rulesets; self.schedulers = schedulers; - Ok(query_report) + result } } @@ -321,7 +361,11 @@ impl ExternalFunction for CollectMatches { } impl SchedulerRuleInfo { - fn new(egraph: &mut EGraph, rule: &ResolvedCoreRule, name: &str) -> SchedulerRuleInfo { + fn new( + egraph: &mut EGraph, + rule: &ResolvedCoreRule, + name: &str, + ) -> Result { let free_vars = rule.head.get_free_vars().into_iter().collect::>(); let unit_type = egraph.backend.base_values().get_ty::<()>(); let unit = egraph.backend.base_values().get(()); @@ -351,11 +395,18 @@ impl SchedulerRuleInfo { &egraph.type_info, false, // seminaive query: Pure/Write contexts ); - qrule_builder.query(&rule.body, false); - let entries = free_vars + qrule_builder.query(&rule.body, false)?; + let mut entries = free_vars .iter() .map(|fv| qrule_builder.entry(&GenericAtomTerm::Var(span!(), fv.clone()))) .collect::>(); + // A rule whose head references no variables would otherwise collect empty + // tuples, leaving the scheduler unable to tell whether the query matched and + // so never applying its actions. Collect a single unit marker per match so + // the match count is recoverable. + if entries.is_empty() { + entries.push(unit_entry.clone()); + } let _var = qrule_builder.rb.call_external_func( collect_matches, &entries, @@ -380,20 +431,20 @@ impl SchedulerRuleInfo { .rb .query_table(decided, &entries, None) .unwrap(); - arule_builder.actions(&rule.head).unwrap(); + arule_builder.actions(&rule.head)?; // Remove the entry as it's now done entries.pop(); arule_builder.rb.remove(decided, &entries); let arule_id = arule_builder.build(); - SchedulerRuleInfo { + Ok(SchedulerRuleInfo { free_vars, query_rule: qrule_id, action_rule: arule_id, matches, decided, should_seek: true, - } + }) } } @@ -550,4 +601,76 @@ mod test { assert!(!report.updated); assert!(!report.can_stop); } + + #[test] + fn test_step_rules_with_scheduler_unknown_ruleset() { + let mut egraph = EGraph::default(); + let scheduler_id = egraph.add_scheduler(Box::new(DelayStopScheduler::default())); + let err = egraph + .step_rules_with_scheduler(scheduler_id, "does-not-exist") + .unwrap_err(); + assert!(matches!(err, Error::BackendError(_))); + } + + /// A scheduler that only inspects `match_size` and never chooses anything. + #[derive(Clone)] + struct InspectSizeScheduler; + + impl Scheduler for InspectSizeScheduler { + fn filter_matches(&mut self, _rule: &str, _ruleset: &str, matches: &mut Matches) -> bool { + // Calling `match_size` on a rule with no free variables used to panic + // with a divide-by-zero. Just exercise it and stop. + let _ = matches.match_size(); + false + } + } + + #[test] + fn test_match_size_with_no_free_vars() { + let mut egraph = EGraph::default(); + let scheduler_id = egraph.add_scheduler(Box::new(InspectSizeScheduler)); + // The action `(R 1)` references no variables, so the rule has no free vars. + let input = r#" + (ruleset test) + (relation R (i64)) + (rule ((R x)) ((R 1)) :ruleset test :name "no-vars") + (R 0) + "#; + egraph.parse_and_run_program(None, input).unwrap(); + egraph + .step_rules_with_scheduler(scheduler_id, "test") + .unwrap(); + } + + /// A scheduler that fires every match. + #[derive(Clone)] + struct ChooseAllScheduler; + + impl Scheduler for ChooseAllScheduler { + fn filter_matches(&mut self, _rule: &str, _ruleset: &str, matches: &mut Matches) -> bool { + matches.choose_all(); + false + } + } + + #[test] + fn test_no_free_vars_rule_applies_actions() { + let mut egraph = EGraph::default(); + let scheduler_id = egraph.add_scheduler(Box::new(ChooseAllScheduler)); + // The action `(S)` references no variables, so the rule has no free vars. + // The scheduler must still apply it when the query matches. + let input = r#" + (ruleset test) + (relation R (i64)) + (relation S ()) + (rule ((R x)) ((S)) :ruleset test :name "no-vars") + (R 0) + "#; + egraph.parse_and_run_program(None, input).unwrap(); + assert_eq!(egraph.get_size("S"), 0); + egraph + .step_rules_with_scheduler(scheduler_id, "test") + .unwrap(); + assert_eq!(egraph.get_size("S"), 1); + } } diff --git a/src/serialize.rs b/src/serialize.rs index 83ab8292..4ff3230e 100644 --- a/src/serialize.rs +++ b/src/serialize.rs @@ -242,18 +242,17 @@ impl EGraph { let value = self .backend .get_canon_repr(value, sort.column_ty(&self.backend)); - assert!( - !sort.name().to_string().contains('-'), - "Tag cannot contain '-' when serializing" - ); use numeric_id::NumericId; + // `value.rep()` is numeric and never contains '-', so the sort tag and the + // value are recovered by splitting on the *last* '-' (see `class_id_to_value`). + // This keeps class IDs unambiguous even when the sort name contains '-'. format!("{}-{}", sort.name(), value.rep()).into() } /// Gets the value for a serialized class ID. pub fn class_id_to_value(&self, eclass_id: &egraph_serialize::ClassId) -> Value { let s = eclass_id.to_string(); - let (_tag, bits) = s.split_once('-').unwrap(); + let (_tag, bits) = s.rsplit_once('-').unwrap(); Value::new_const(bits.parse().unwrap()) } diff --git a/src/sort/add_primitive/Cargo.toml b/src/sort/add_primitive/Cargo.toml index 0bfbf6fd..8cb3f197 100644 --- a/src/sort/add_primitive/Cargo.toml +++ b/src/sort/add_primitive/Cargo.toml @@ -13,4 +13,7 @@ proc-macro = true [dependencies] quote = { workspace = true } -syn = { workspace = true } +# `full` is required: the macro parses whole closure bodies (if/match, method +# calls, `?`, statements) via `syn::Expr`. Declare it here instead of relying +# on another crate in the graph (e.g. clap_derive) to unify it onto our `syn`. +syn = { workspace = true, features = ["full"] } diff --git a/src/sort/add_primitive/src/lib.rs b/src/sort/add_primitive/src/lib.rs index 6cee9ab0..df66dae3 100644 --- a/src/sort/add_primitive/src/lib.rs +++ b/src/sort/add_primitive/src/lib.rs @@ -550,10 +550,10 @@ fn generate_literal_validator( let #x = if let Term::Lit(lit) = termdag.get(args[#i]) { match <#ty as egglog::prelude::LiteralConvertible>::from_literal(&lit) { Some(val) => val, - None => panic!("Failed to extract literal for argument {}", #i), + None => return None, } } else { - panic!("Argument {} is not a literal", #i); + return None; }; } } else { @@ -577,7 +577,7 @@ fn generate_literal_validator( let result_lit = #ret_conv(result); termdag.lit(result_lit) } - None => panic!("Primitive operation failed"), + None => return None, } } } else { diff --git a/src/sort/bigint.rs b/src/sort/bigint.rs index f676fed6..3f4bc0ae 100644 --- a/src/sort/bigint.rs +++ b/src/sort/bigint.rs @@ -23,8 +23,8 @@ impl BaseSort for BigIntSort { add_primitive!(eg, "&" = |a: Z, b: Z| -> Z { a & b }); add_primitive!(eg, "|" = |a: Z, b: Z| -> Z { a | b }); add_primitive!(eg, "^" = |a: Z, b: Z| -> Z { a ^ b }); - add_primitive!(eg, "<<" = |a: Z, b: i64| -> Z { (&*a).shl(b).into() }); - add_primitive!(eg, ">>" = |a: Z, b: i64| -> Z { (&*a).shr(b).into() }); + add_primitive!(eg, "<<" = |a: Z, b: i64| -?> Z { u32::try_from(b).ok().map(|s| (&*a).shl(s as usize).into()) }); + add_primitive!(eg, ">>" = |a: Z, b: i64| -?> Z { u32::try_from(b).ok().map(|s| (&*a).shr(s as usize).into()) }); add_primitive!(eg, "not-Z" = |a: Z| -> Z { Z::new(!&*a) }); add_primitive!(eg, "bits" = |a: Z| -> Z { Z::new(a.bits().into()) }); diff --git a/src/sort/bigrat.rs b/src/sort/bigrat.rs index b4b7097a..3e8ce0e7 100644 --- a/src/sort/bigrat.rs +++ b/src/sort/bigrat.rs @@ -32,7 +32,7 @@ impl BaseSort for BigRatSort { add_primitive!(eg, "ceil" = |a: Q| -> Q { Q::new(a.0.ceil()) }); add_primitive!(eg, "round" = |a: Q| -> Q { Q::new(a.round()) }); - add_primitive!(eg, "bigrat" = |a: Z, b: Z| -> Q { Q::new(BigRational::new(a.0, b.0)) }); + add_primitive!(eg, "bigrat" = |a: Z, b: Z| -?> Q { (!b.0.is_zero()).then(|| Q::new(BigRational::new(a.0, b.0))) }); add_primitive!(eg, "numer" = |a: Q| -> Z { Z::new(a.numer().clone()) }); add_primitive!(eg, "denom" = |a: Q| -> Z { Z::new(a.denom().clone()) }); add_primitive!(eg, "to-f64" = |a: Q| -> F { F::new(OrderedFloat(a.to_f64().unwrap())) }); diff --git a/src/sort/fn.rs b/src/sort/fn.rs index 0f035bf2..fb45019e 100644 --- a/src/sort/fn.rs +++ b/src/sort/fn.rs @@ -106,33 +106,47 @@ impl Presort for FunctionSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { - if let [inputs, Expr::Var(span, output)] = args { + if let [inputs, Expr::Var(output_span, output)] = args { let output_sort = typeinfo .get_sort_by_name(output) - .ok_or(TypeError::UndefinedSort(output.clone(), span.clone()))?; + .ok_or(TypeError::UndefinedSort( + output.clone(), + output_span.clone(), + ))?; let input_sorts = match inputs { Expr::Call(_, first, rest_args) => { - let all_args = once(first).chain(rest_args.iter().map(|arg| { + let mut input_names = vec![first]; + for arg in rest_args { if let Expr::Var(_, arg) = arg { - arg + input_names.push(arg); } else { - panic!("function sort must be called with list of input sorts"); + return Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + arg.span(), + )); } - })); - all_args + } + input_names + .into_iter() .map(|arg| { typeinfo .get_sort_by_name(arg) - .ok_or(TypeError::UndefinedSort(arg.clone(), span.clone())) + .ok_or(TypeError::UndefinedSort(arg.clone(), output_span.clone())) .cloned() }) .collect::, _>>()? } // an empty list of inputs args is parsed as a unit literal Expr::Lit(_, Literal::Unit) => vec![], - _ => panic!("function sort must be called with list of input sorts"), + _ => { + return Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + inputs.span(), + )); + } }; Ok(Arc::new(Self { @@ -142,7 +156,10 @@ impl Presort for FunctionSort { partial_arcsorts: Arc::new(Mutex::new(vec![])), })) } else { - panic!("function sort must be called with list of input args and output sort"); + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } diff --git a/src/sort/i64.rs b/src/sort/i64.rs index e7f31179..06179736 100644 --- a/src/sort/i64.rs +++ b/src/sort/i64.rs @@ -39,7 +39,7 @@ impl BaseSort for I64Sort { add_literal_prim!(eg, ">>" = |a: i64, b: i64| -?> i64 { b.try_into().ok().and_then(|b| a.checked_shr(b)) }); add_literal_prim!(eg, "not-i64" = |a: i64| -> i64 { !a }); - add_literal_prim!(eg, "log2" = |a: i64| -> i64 { a.ilog2() as i64 }); + add_literal_prim!(eg, "log2" = |a: i64| -?> i64 { a.checked_ilog2().map(|x| x as i64) }); add_literal_prim!(eg, "abs" = |a: i64| -?> i64 { a.checked_abs() }); diff --git a/src/sort/map.rs b/src/sort/map.rs index 6d45a346..44459f7d 100644 --- a/src/sort/map.rs +++ b/src/sort/map.rs @@ -125,6 +125,7 @@ impl Presort for MapSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { if let [Expr::Var(k_span, k), Expr::Var(v_span, v)] = args { let k = typeinfo @@ -141,7 +142,10 @@ impl Presort for MapSort { }; Ok(out.to_arcsort()) } else { - panic!() + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } diff --git a/src/sort/mod.rs b/src/sort/mod.rs index 1bcc67fc..7abf6aff 100644 --- a/src/sort/mod.rs +++ b/src/sort/mod.rs @@ -162,10 +162,11 @@ pub trait Presort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result; } -pub type MkSort = fn(&mut TypeInfo, String, &[Expr]) -> Result; +pub type MkSort = fn(&mut TypeInfo, String, &[Expr], Span) -> Result; #[derive(Debug)] pub struct EqSort { diff --git a/src/sort/multiset.rs b/src/sort/multiset.rs index e8cb9fa5..3846ed2c 100644 --- a/src/sort/multiset.rs +++ b/src/sort/multiset.rs @@ -95,11 +95,12 @@ impl Presort for MultiSetSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { - if let [Expr::Var(span, e)] = args { + if let [Expr::Var(arg_span, e)] = args { let e = typeinfo .get_sort_by_name(e) - .ok_or(TypeError::UndefinedSort(e.clone(), span.clone()))?; + .ok_or(TypeError::UndefinedSort(e.clone(), arg_span.clone()))?; let out = Self { name, @@ -107,7 +108,10 @@ impl Presort for MultiSetSort { }; Ok(out.to_arcsort()) } else { - panic!() + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } @@ -183,7 +187,7 @@ impl ContainerSort for MultiSetSort { data: std::iter::repeat_n(x, i).collect() }) }); - add_primitive!(eg, "multiset-pick" = |xs: @MultiSetContainer (arc)| -> # (self.element()) { *xs.data.pick().expect("Cannot pick from an empty multiset") }); + add_primitive!(eg, "multiset-pick" = |xs: @MultiSetContainer (arc)| -?> # (self.element()) { xs.data.pick().copied() }); add_primitive!(eg, "multiset-insert" = |mut xs: @MultiSetContainer (arc), x: # (self.element())| -> @MultiSetContainer (arc) { MultiSetContainer { data: xs.data.insert( x) , ..xs } }); add_primitive!(eg, "multiset-remove" = |mut xs: @MultiSetContainer (arc), x: # (self.element())| -?> @MultiSetContainer (arc) { Some(MultiSetContainer { data: xs.data.remove(&x)?, ..xs } )}); add_primitive!(eg, "multiset-remove-swapped" = |x: # (self.element()), mut xs: @MultiSetContainer (arc)| -?> @MultiSetContainer (arc) { Some(MultiSetContainer { data: xs.data.remove(&x)?, ..xs }) }); @@ -510,9 +514,9 @@ impl FullPrim for FillIndex { .clone(); let action = match fc.0 { ResolvedFunctionId::Constructor(a) | ResolvedFunctionId::Function(a) => a, - ResolvedFunctionId::Primitive { .. } => panic!( - "Primitive functions cannot be used with unstable-multiset-fill-index, since they cannot be set" - ), + // Primitive functions cannot be used with + // unstable-multiset-fill-index, since they cannot be set. + ResolvedFunctionId::Primitive { .. } => return None, }; let unit_val = state.base_values().get::<()>(()); let es = state.raw_exec_state(); @@ -524,7 +528,7 @@ impl FullPrim for FillIndex { if action.lookup(es, &row).is_some() { break; } - row.push(es.base_values().get::(c.try_into().unwrap())); + row.push(es.base_values().get::(c.try_into().ok()?)); action.insert(es, row.into_iter()); } Some(unit_val) @@ -575,9 +579,9 @@ impl WritePrim for ClearIndex { .clone(); let action = match fc.0 { ResolvedFunctionId::Constructor(a) | ResolvedFunctionId::Function(a) => a, - ResolvedFunctionId::Primitive { .. } => panic!( - "Primitive functions cannot be used with unstable-multiset-clear-index, since they cannot be deleted" - ), + // Primitive functions cannot be used with + // unstable-multiset-clear-index, since they cannot be deleted. + ResolvedFunctionId::Primitive { .. } => return None, }; let unit_val = state.base_values().get::<()>(()); let es = state.raw_exec_state(); @@ -641,7 +645,7 @@ impl PurePrim for FlatMap { .get_val::(mapped_ms) .unwrap(); for (mv, mc) in mapped_ms.data.iter_counts() { - new_data.insert_multiple_mut(mv, c * mc); + new_data.insert_multiple_mut(mv, c.checked_mul(mc)?); } } else { new_data.insert_multiple_mut(v, c); @@ -760,7 +764,7 @@ impl PurePrim for SumMultisets { .get_val::(ms_value) .unwrap(); for (v, c) in ms.data.iter_counts() { - data.insert_multiple_mut(v, c * counts); + data.insert_multiple_mut(v, c.checked_mul(counts)?); } } let multiset = MultiSetContainer { diff --git a/src/sort/pair.rs b/src/sort/pair.rs index ebd68c1e..7b91fc51 100644 --- a/src/sort/pair.rs +++ b/src/sort/pair.rs @@ -83,6 +83,7 @@ impl Presort for PairSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { if let [Expr::Var(a_span, a), Expr::Var(b_span, b)] = args { let a = typeinfo @@ -99,7 +100,10 @@ impl Presort for PairSort { }; Ok(out.to_arcsort()) } else { - panic!("Pair sort requires exactly two arguments") + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } diff --git a/src/sort/set.rs b/src/sort/set.rs index 4506ae86..654162d0 100644 --- a/src/sort/set.rs +++ b/src/sort/set.rs @@ -85,11 +85,12 @@ impl Presort for SetSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { - if let [Expr::Var(span, e)] = args { + if let [Expr::Var(arg_span, e)] = args { let e = typeinfo .get_sort_by_name(e) - .ok_or(TypeError::UndefinedSort(e.clone(), span.clone()))?; + .ok_or(TypeError::UndefinedSort(e.clone(), arg_span.clone()))?; let out = Self { name, @@ -97,7 +98,10 @@ impl Presort for SetSort { }; Ok(out.to_arcsort()) } else { - panic!() + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } diff --git a/src/sort/vec.rs b/src/sort/vec.rs index 2b1a9a8f..22076fdd 100644 --- a/src/sort/vec.rs +++ b/src/sort/vec.rs @@ -83,11 +83,12 @@ impl Presort for VecSort { typeinfo: &mut TypeInfo, name: String, args: &[Expr], + span: Span, ) -> Result { - if let [Expr::Var(span, e)] = args { + if let [Expr::Var(arg_span, e)] = args { let e = typeinfo .get_sort_by_name(e) - .ok_or(TypeError::UndefinedSort(e.clone(), span.clone()))?; + .ok_or(TypeError::UndefinedSort(e.clone(), arg_span.clone()))?; let out = Self { name, @@ -95,7 +96,10 @@ impl Presort for VecSort { }; Ok(out.to_arcsort()) } else { - panic!("Vec sort must have sort as argument. Got {args:?}") + Err(TypeError::BadPresortArguments( + Self::presort_name().to_owned(), + span, + )) } } } @@ -189,8 +193,8 @@ impl ContainerSort for VecSort { add_primitive_with_validator!(eg, "vec-not-contains" = |xs: @VecContainer (arc), x: # (self.element())| -?> () { (!xs.data.contains(&x)).then_some(()) }, vec_not_contains_validator); add_primitive_with_validator!(eg, "vec-get" = | xs: @VecContainer (arc), i: i64 | -?> # (self.element()) { xs.data.get(i as usize).copied() }, vec_get_validator); - add_primitive!(eg, "vec-set" = |mut xs: @VecContainer (arc), i: i64, x: # (self.element())| -> @VecContainer (arc) {{ xs.data[i as usize] = x; xs }}); - add_primitive!(eg, "vec-remove" = |mut xs: @VecContainer (arc), i: i64 | -> @VecContainer (arc) {{ xs.data.remove(i as usize); xs }}); + add_primitive!(eg, "vec-set" = |mut xs: @VecContainer (arc), i: i64, x: # (self.element())| -?> @VecContainer (arc) {{ let idx = usize::try_from(i).ok()?; if idx >= xs.data.len() { None } else { xs.data[idx] = x; Some(xs) } }}); + add_primitive!(eg, "vec-remove" = |mut xs: @VecContainer (arc), i: i64 | -?> @VecContainer (arc) {{ let idx = usize::try_from(i).ok()?; if idx >= xs.data.len() { None } else { xs.data.remove(idx); Some(xs) } }}); if self.element.is_eq_sort() { eg.add_write_primitive( Union { diff --git a/src/typechecking.rs b/src/typechecking.rs index 39f3749c..28031a56 100644 --- a/src/typechecking.rs +++ b/src/typechecking.rs @@ -245,7 +245,7 @@ impl EGraph { None => Arc::new(EqSort { name }), Some((presort, args)) => { if let Some(mksort) = self.type_info.mksorts.get(presort) { - mksort(&mut self.type_info, name, args)? + mksort(&mut self.type_info, name, args, span.clone())? } else { return Err(TypeError::PresortNotFound(presort.clone(), span)); } @@ -925,7 +925,7 @@ impl TypeInfo { .solve(|sort: &ArcSort| sort.name()) .map_err(|e| e.to_type_error())?; - let body: Vec = assignment.annotate_facts(&mapped_query, self, query_ctx); + let body: Vec = assignment.annotate_facts(&mapped_query, self, query_ctx)?; let actions: ResolvedActions = assignment.annotate_actions(&mapped_action, self, action_ctx)?; @@ -999,7 +999,7 @@ impl TypeInfo { let assignment = problem .solve(|sort: &ArcSort| sort.name()) .map_err(|e| e.to_type_error())?; - let annotated_facts = assignment.annotate_facts(&mapped_facts, self, Context::Read); + let annotated_facts = assignment.annotate_facts(&mapped_facts, self, Context::Read)?; Ok(annotated_facts) } @@ -1209,6 +1209,8 @@ pub enum TypeError { FunctionTypeMismatch(ArcSort, Vec, ArcSort, Vec), #[error("{1}\nPresort {0} not found.")] PresortNotFound(String, Span), + #[error("{1}\nInvalid arguments to sort constructor `{0}`")] + BadPresortArguments(String, Span), #[error("{}\nFailed to infer a type for: {}", .0.span(), .0)] InferenceFailure(Expr), #[error("{1}\nVariable {0} was already defined")] @@ -1239,6 +1241,20 @@ pub enum TypeError { crate::GLOBAL_NAME_PREFIX )] GlobalMissingPrefix { name: String, span: Span }, + #[error( + "{span}\nAmbiguous primitive resolution for `{name}` in {ctx:?} context: multiple registered primitives match the same signature." + )] + AmbiguousPrimitive { + name: String, + ctx: crate::Context, + span: Span, + }, + #[error("{span}\nNo resolution for `{name}` in {ctx:?} context.")] + UnresolvedPrimitive { + name: String, + ctx: crate::Context, + span: Span, + }, } #[cfg(test)] diff --git a/tests/cykjson.egg b/tests/cykjson.egg index d91c3438..641cda68 100644 --- a/tests/cykjson.egg +++ b/tests/cykjson.egg @@ -41,4 +41,4 @@ (let $test1 (B 801 1 "VAL")) -(check (P 801 1 "VAL")) \ No newline at end of file +(check (P 801 1 "VAL")) diff --git a/tests/files.rs b/tests/files.rs index 094e9c50..9761021f 100644 --- a/tests/files.rs +++ b/tests/files.rs @@ -101,7 +101,7 @@ impl Run { } fn egraph(&self) -> EGraph { - if self.proof_testing { + let egraph = if self.proof_testing { EGraph::new_with_proofs().with_proof_testing() } else if self.proofs { EGraph::new_with_proofs() @@ -109,7 +109,8 @@ impl Run { EGraph::new_with_term_encoding() } else { EGraph::default() - } + }; + egraph.with_num_threads(self.threads) } // Returns a string of the desugared program and a string for the desugared program without proofs @@ -190,20 +191,7 @@ impl Run { fn into_trial(self) -> Trial { let name = self.name().to_string(); Trial::test(name, move || { - // We use a local rayon pool here because `build_global()` can only - // be called once per process, but libtest-mimic runs many trials - // (with different thread counts) in the same process. - // The threads == 1 case also goes through pool.install so the trial - // doesn't fall through to the default global rayon pool (which uses - // num_cpus threads and would make "single-threaded" tests - // nondeterministic). - // TODO: when we move to per-EGraph local thread pools, replace this - // with `egraph.with_num_threads()` and remove the explicit pool. - let pool = rayon::ThreadPoolBuilder::new() - .num_threads(self.threads) - .build() - .expect("failed to build rayon thread pool"); - pool.install(|| self.run()); + self.run(); Ok(()) }) } @@ -304,8 +292,23 @@ fn generate_tests(glob: &str) -> Vec { let mut push_trial = |run: Run| trials.push(run.into_trial()); for entry in glob::glob(glob).unwrap() { + let path = entry.unwrap().clone(); + + // Files under tests/header/ are shared fragments pulled in via + // `(include ...)`, not standalone test programs. + if path.parent().is_some_and(|p| p.ends_with("header")) { + continue; + } + + // Test bypass: files too slow/large to run as part of the normal test + // suite. They remain available as benchmarks (see scripts/bench.py). + let test_bypass_file_list = ["gemma.egg", "gemma4_moe.egg"]; + if test_bypass_file_list.iter().any(|f| path.ends_with(f)) { + continue; + } + let run = Run { - path: entry.unwrap().clone(), + path, desugar: false, term_encoding: false, proofs: false, @@ -322,6 +325,14 @@ fn generate_tests(glob: &str) -> Vec { "eggcc-2mm.egg", "subsume.egg", "subsume-relation.egg", + // Luminal transformer benchmarks: too large/slow to run in proof modes. + "gemma.egg", + "gemma4_moe.egg", + "llama.egg", + "paged_llama.egg", + "qwen.egg", + "qwen3_moe.egg", + "whisper.egg", ]; let supports_proofs = file_supports_proofs(&run.path) && !proof_unsupported_file_list @@ -383,6 +394,10 @@ fn generate_proof_support_snapshot_test() -> Trial { for entry in glob::glob("tests/**/*.egg").unwrap() { let path = entry.unwrap(); + // Skip shared header fragments (see generate_tests). + if path.parent().is_some_and(|p| p.ends_with("header")) { + continue; + } if !file_supports_proofs(&path) && !path.parent().unwrap().ends_with("fail-typecheck") { // Use just the filename for cross-platform consistency let filename = path.file_name().unwrap().to_string_lossy().to_string(); diff --git a/tests/gemma.egg b/tests/gemma.egg new file mode 100644 index 00000000..e240c51c --- /dev/null +++ b/tests/gemma.egg @@ -0,0 +1,4261 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "token_ids" (Int))) +(let t2 (Input 2 "kv_cache.0.k" (F32))) +(let t3 (Output t2 2)) +(let t4 (Input 4 "kv_cache.0.v" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.1.k" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.2.k" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.v" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.3.k" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.v" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.4.k" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "kv_cache.4.v" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "kv_cache.5.k" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "kv_cache.5.v" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "kv_cache.6.k" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "kv_cache.6.v" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "kv_cache.7.k" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "kv_cache.7.v" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "kv_cache.8.k" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "kv_cache.8.v" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "kv_cache.9.k" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "kv_cache.9.v" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "kv_cache.10.k" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "kv_cache.10.v" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "kv_cache.11.k" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "kv_cache.11.v" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "kv_cache.12.k" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "kv_cache.12.v" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "kv_cache.13.k" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "kv_cache.13.v" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "kv_cache.14.k" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "kv_cache.14.v" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "kv_cache.15.k" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "kv_cache.15.v" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "kv_cache.16.k" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "kv_cache.16.v" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "kv_cache.17.k" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "kv_cache.17.v" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "kv_cache.18.k" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "kv_cache.18.v" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "kv_cache.19.k" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "kv_cache.19.v" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "kv_cache.20.k" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "kv_cache.20.v" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "kv_cache.21.k" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "kv_cache.21.v" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "kv_cache.22.k" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "kv_cache.22.v" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "kv_cache.23.k" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "kv_cache.23.v" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "kv_cache.24.k" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "kv_cache.24.v" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "kv_cache.25.k" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "kv_cache.25.v" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "kv_cache.26.k" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "kv_cache.26.v" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "kv_cache.27.k" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "kv_cache.27.v" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "kv_cache.28.k" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "kv_cache.28.v" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "kv_cache.29.k" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "kv_cache.29.v" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "kv_cache.30.k" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "kv_cache.30.v" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "kv_cache.31.k" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "kv_cache.31.v" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "kv_cache.32.k" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "kv_cache.32.v" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "kv_cache.33.k" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "kv_cache.33.v" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "model.layers.0.mlp.up_proj.weight" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "model.layers.0.mlp.gate_proj.weight" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "model.layers.0.mlp.down_proj.weight" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "model.layers.0.self_attn.q_norm.weight" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "model.layers.0.self_attn.k_norm.weight" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "model.layers.0.input_layernorm.weight" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "model.layers.0.pre_feedforward_layernorm.weight" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "model.layers.0.post_feedforward_layernorm.weight" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "model.layers.1.mlp.up_proj.weight" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "model.layers.1.mlp.gate_proj.weight" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "model.layers.1.mlp.down_proj.weight" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "model.layers.1.self_attn.q_norm.weight" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "model.layers.1.self_attn.k_norm.weight" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "model.layers.1.input_layernorm.weight" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "model.layers.1.pre_feedforward_layernorm.weight" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "model.layers.1.post_feedforward_layernorm.weight" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "model.layers.2.mlp.up_proj.weight" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "model.layers.2.mlp.gate_proj.weight" (F32))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.layers.2.mlp.down_proj.weight" (F32))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.layers.2.self_attn.q_norm.weight" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.layers.2.self_attn.k_norm.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.layers.2.input_layernorm.weight" (F32))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.layers.2.pre_feedforward_layernorm.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.layers.2.post_feedforward_layernorm.weight" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.layers.3.mlp.up_proj.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.layers.3.mlp.gate_proj.weight" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.layers.3.mlp.down_proj.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.layers.3.self_attn.q_norm.weight" (F32))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.layers.3.self_attn.k_norm.weight" (F32))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.layers.3.input_layernorm.weight" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.layers.3.pre_feedforward_layernorm.weight" (F32))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.layers.3.post_feedforward_layernorm.weight" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.layers.4.mlp.up_proj.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.layers.4.mlp.gate_proj.weight" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.layers.4.mlp.down_proj.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.layers.4.self_attn.q_norm.weight" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.layers.4.self_attn.k_norm.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.layers.4.input_layernorm.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.layers.4.pre_feedforward_layernorm.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.layers.4.post_feedforward_layernorm.weight" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.layers.5.mlp.up_proj.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.layers.5.mlp.gate_proj.weight" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.layers.5.mlp.down_proj.weight" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.layers.5.self_attn.v_proj.weight" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.layers.5.self_attn.q_norm.weight" (F32))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.layers.5.self_attn.k_norm.weight" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.layers.5.input_layernorm.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.layers.5.pre_feedforward_layernorm.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.layers.5.post_feedforward_layernorm.weight" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.layers.6.mlp.up_proj.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.layers.6.mlp.gate_proj.weight" (F32))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.layers.6.mlp.down_proj.weight" (F32))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.layers.6.self_attn.q_norm.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.layers.6.self_attn.k_norm.weight" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.layers.6.input_layernorm.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.layers.6.pre_feedforward_layernorm.weight" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.layers.6.post_feedforward_layernorm.weight" (F32))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.layers.7.mlp.up_proj.weight" (F32))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.layers.7.mlp.gate_proj.weight" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.layers.7.mlp.down_proj.weight" (F32))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.layers.7.self_attn.q_norm.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.layers.7.self_attn.k_norm.weight" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.layers.7.input_layernorm.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.layers.7.pre_feedforward_layernorm.weight" (F32))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.layers.7.post_feedforward_layernorm.weight" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.layers.8.mlp.up_proj.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.layers.8.mlp.gate_proj.weight" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.layers.8.mlp.down_proj.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t353 (Output t352 352)) +(let t354 (Input 354 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t355 (Output t354 354)) +(let t356 (Input 356 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t357 (Output t356 356)) +(let t358 (Input 358 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t359 (Output t358 358)) +(let t360 (Input 360 "model.layers.8.self_attn.q_norm.weight" (F32))) +(let t361 (Output t360 360)) +(let t362 (Input 362 "model.layers.8.self_attn.k_norm.weight" (F32))) +(let t363 (Output t362 362)) +(let t364 (Input 364 "model.layers.8.input_layernorm.weight" (F32))) +(let t365 (Output t364 364)) +(let t366 (Input 366 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t367 (Output t366 366)) +(let t368 (Input 368 "model.layers.8.pre_feedforward_layernorm.weight" (F32))) +(let t369 (Output t368 368)) +(let t370 (Input 370 "model.layers.8.post_feedforward_layernorm.weight" (F32))) +(let t371 (Output t370 370)) +(let t372 (Input 372 "model.layers.9.mlp.up_proj.weight" (F32))) +(let t373 (Output t372 372)) +(let t374 (Input 374 "model.layers.9.mlp.gate_proj.weight" (F32))) +(let t375 (Output t374 374)) +(let t376 (Input 376 "model.layers.9.mlp.down_proj.weight" (F32))) +(let t377 (Output t376 376)) +(let t378 (Input 378 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t379 (Output t378 378)) +(let t380 (Input 380 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t381 (Output t380 380)) +(let t382 (Input 382 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t383 (Output t382 382)) +(let t384 (Input 384 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t385 (Output t384 384)) +(let t386 (Input 386 "model.layers.9.self_attn.q_norm.weight" (F32))) +(let t387 (Output t386 386)) +(let t388 (Input 388 "model.layers.9.self_attn.k_norm.weight" (F32))) +(let t389 (Output t388 388)) +(let t390 (Input 390 "model.layers.9.input_layernorm.weight" (F32))) +(let t391 (Output t390 390)) +(let t392 (Input 392 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t393 (Output t392 392)) +(let t394 (Input 394 "model.layers.9.pre_feedforward_layernorm.weight" (F32))) +(let t395 (Output t394 394)) +(let t396 (Input 396 "model.layers.9.post_feedforward_layernorm.weight" (F32))) +(let t397 (Output t396 396)) +(let t398 (Input 398 "model.layers.10.mlp.up_proj.weight" (F32))) +(let t399 (Output t398 398)) +(let t400 (Input 400 "model.layers.10.mlp.gate_proj.weight" (F32))) +(let t401 (Output t400 400)) +(let t402 (Input 402 "model.layers.10.mlp.down_proj.weight" (F32))) +(let t403 (Output t402 402)) +(let t404 (Input 404 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t405 (Output t404 404)) +(let t406 (Input 406 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t407 (Output t406 406)) +(let t408 (Input 408 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t409 (Output t408 408)) +(let t410 (Input 410 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t411 (Output t410 410)) +(let t412 (Input 412 "model.layers.10.self_attn.q_norm.weight" (F32))) +(let t413 (Output t412 412)) +(let t414 (Input 414 "model.layers.10.self_attn.k_norm.weight" (F32))) +(let t415 (Output t414 414)) +(let t416 (Input 416 "model.layers.10.input_layernorm.weight" (F32))) +(let t417 (Output t416 416)) +(let t418 (Input 418 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t419 (Output t418 418)) +(let t420 (Input 420 "model.layers.10.pre_feedforward_layernorm.weight" (F32))) +(let t421 (Output t420 420)) +(let t422 (Input 422 "model.layers.10.post_feedforward_layernorm.weight" (F32))) +(let t423 (Output t422 422)) +(let t424 (Input 424 "model.layers.11.mlp.up_proj.weight" (F32))) +(let t425 (Output t424 424)) +(let t426 (Input 426 "model.layers.11.mlp.gate_proj.weight" (F32))) +(let t427 (Output t426 426)) +(let t428 (Input 428 "model.layers.11.mlp.down_proj.weight" (F32))) +(let t429 (Output t428 428)) +(let t430 (Input 430 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t431 (Output t430 430)) +(let t432 (Input 432 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t433 (Output t432 432)) +(let t434 (Input 434 "model.layers.11.self_attn.v_proj.weight" (F32))) +(let t435 (Output t434 434)) +(let t436 (Input 436 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t437 (Output t436 436)) +(let t438 (Input 438 "model.layers.11.self_attn.q_norm.weight" (F32))) +(let t439 (Output t438 438)) +(let t440 (Input 440 "model.layers.11.self_attn.k_norm.weight" (F32))) +(let t441 (Output t440 440)) +(let t442 (Input 442 "model.layers.11.input_layernorm.weight" (F32))) +(let t443 (Output t442 442)) +(let t444 (Input 444 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t445 (Output t444 444)) +(let t446 (Input 446 "model.layers.11.pre_feedforward_layernorm.weight" (F32))) +(let t447 (Output t446 446)) +(let t448 (Input 448 "model.layers.11.post_feedforward_layernorm.weight" (F32))) +(let t449 (Output t448 448)) +(let t450 (Input 450 "model.layers.12.mlp.up_proj.weight" (F32))) +(let t451 (Output t450 450)) +(let t452 (Input 452 "model.layers.12.mlp.gate_proj.weight" (F32))) +(let t453 (Output t452 452)) +(let t454 (Input 454 "model.layers.12.mlp.down_proj.weight" (F32))) +(let t455 (Output t454 454)) +(let t456 (Input 456 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t457 (Output t456 456)) +(let t458 (Input 458 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t459 (Output t458 458)) +(let t460 (Input 460 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t461 (Output t460 460)) +(let t462 (Input 462 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t463 (Output t462 462)) +(let t464 (Input 464 "model.layers.12.self_attn.q_norm.weight" (F32))) +(let t465 (Output t464 464)) +(let t466 (Input 466 "model.layers.12.self_attn.k_norm.weight" (F32))) +(let t467 (Output t466 466)) +(let t468 (Input 468 "model.layers.12.input_layernorm.weight" (F32))) +(let t469 (Output t468 468)) +(let t470 (Input 470 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t471 (Output t470 470)) +(let t472 (Input 472 "model.layers.12.pre_feedforward_layernorm.weight" (F32))) +(let t473 (Output t472 472)) +(let t474 (Input 474 "model.layers.12.post_feedforward_layernorm.weight" (F32))) +(let t475 (Output t474 474)) +(let t476 (Input 476 "model.layers.13.mlp.up_proj.weight" (F32))) +(let t477 (Output t476 476)) +(let t478 (Input 478 "model.layers.13.mlp.gate_proj.weight" (F32))) +(let t479 (Output t478 478)) +(let t480 (Input 480 "model.layers.13.mlp.down_proj.weight" (F32))) +(let t481 (Output t480 480)) +(let t482 (Input 482 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t483 (Output t482 482)) +(let t484 (Input 484 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t485 (Output t484 484)) +(let t486 (Input 486 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t487 (Output t486 486)) +(let t488 (Input 488 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t489 (Output t488 488)) +(let t490 (Input 490 "model.layers.13.self_attn.q_norm.weight" (F32))) +(let t491 (Output t490 490)) +(let t492 (Input 492 "model.layers.13.self_attn.k_norm.weight" (F32))) +(let t493 (Output t492 492)) +(let t494 (Input 494 "model.layers.13.input_layernorm.weight" (F32))) +(let t495 (Output t494 494)) +(let t496 (Input 496 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t497 (Output t496 496)) +(let t498 (Input 498 "model.layers.13.pre_feedforward_layernorm.weight" (F32))) +(let t499 (Output t498 498)) +(let t500 (Input 500 "model.layers.13.post_feedforward_layernorm.weight" (F32))) +(let t501 (Output t500 500)) +(let t502 (Input 502 "model.layers.14.mlp.up_proj.weight" (F32))) +(let t503 (Output t502 502)) +(let t504 (Input 504 "model.layers.14.mlp.gate_proj.weight" (F32))) +(let t505 (Output t504 504)) +(let t506 (Input 506 "model.layers.14.mlp.down_proj.weight" (F32))) +(let t507 (Output t506 506)) +(let t508 (Input 508 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t509 (Output t508 508)) +(let t510 (Input 510 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t511 (Output t510 510)) +(let t512 (Input 512 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t513 (Output t512 512)) +(let t514 (Input 514 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t515 (Output t514 514)) +(let t516 (Input 516 "model.layers.14.self_attn.q_norm.weight" (F32))) +(let t517 (Output t516 516)) +(let t518 (Input 518 "model.layers.14.self_attn.k_norm.weight" (F32))) +(let t519 (Output t518 518)) +(let t520 (Input 520 "model.layers.14.input_layernorm.weight" (F32))) +(let t521 (Output t520 520)) +(let t522 (Input 522 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t523 (Output t522 522)) +(let t524 (Input 524 "model.layers.14.pre_feedforward_layernorm.weight" (F32))) +(let t525 (Output t524 524)) +(let t526 (Input 526 "model.layers.14.post_feedforward_layernorm.weight" (F32))) +(let t527 (Output t526 526)) +(let t528 (Input 528 "model.layers.15.mlp.up_proj.weight" (F32))) +(let t529 (Output t528 528)) +(let t530 (Input 530 "model.layers.15.mlp.gate_proj.weight" (F32))) +(let t531 (Output t530 530)) +(let t532 (Input 532 "model.layers.15.mlp.down_proj.weight" (F32))) +(let t533 (Output t532 532)) +(let t534 (Input 534 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t535 (Output t534 534)) +(let t536 (Input 536 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t537 (Output t536 536)) +(let t538 (Input 538 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t539 (Output t538 538)) +(let t540 (Input 540 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t541 (Output t540 540)) +(let t542 (Input 542 "model.layers.15.self_attn.q_norm.weight" (F32))) +(let t543 (Output t542 542)) +(let t544 (Input 544 "model.layers.15.self_attn.k_norm.weight" (F32))) +(let t545 (Output t544 544)) +(let t546 (Input 546 "model.layers.15.input_layernorm.weight" (F32))) +(let t547 (Output t546 546)) +(let t548 (Input 548 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t549 (Output t548 548)) +(let t550 (Input 550 "model.layers.15.pre_feedforward_layernorm.weight" (F32))) +(let t551 (Output t550 550)) +(let t552 (Input 552 "model.layers.15.post_feedforward_layernorm.weight" (F32))) +(let t553 (Output t552 552)) +(let t554 (Input 554 "model.layers.16.mlp.up_proj.weight" (F32))) +(let t555 (Output t554 554)) +(let t556 (Input 556 "model.layers.16.mlp.gate_proj.weight" (F32))) +(let t557 (Output t556 556)) +(let t558 (Input 558 "model.layers.16.mlp.down_proj.weight" (F32))) +(let t559 (Output t558 558)) +(let t560 (Input 560 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t561 (Output t560 560)) +(let t562 (Input 562 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t563 (Output t562 562)) +(let t564 (Input 564 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t565 (Output t564 564)) +(let t566 (Input 566 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t567 (Output t566 566)) +(let t568 (Input 568 "model.layers.16.self_attn.q_norm.weight" (F32))) +(let t569 (Output t568 568)) +(let t570 (Input 570 "model.layers.16.self_attn.k_norm.weight" (F32))) +(let t571 (Output t570 570)) +(let t572 (Input 572 "model.layers.16.input_layernorm.weight" (F32))) +(let t573 (Output t572 572)) +(let t574 (Input 574 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t575 (Output t574 574)) +(let t576 (Input 576 "model.layers.16.pre_feedforward_layernorm.weight" (F32))) +(let t577 (Output t576 576)) +(let t578 (Input 578 "model.layers.16.post_feedforward_layernorm.weight" (F32))) +(let t579 (Output t578 578)) +(let t580 (Input 580 "model.layers.17.mlp.up_proj.weight" (F32))) +(let t581 (Output t580 580)) +(let t582 (Input 582 "model.layers.17.mlp.gate_proj.weight" (F32))) +(let t583 (Output t582 582)) +(let t584 (Input 584 "model.layers.17.mlp.down_proj.weight" (F32))) +(let t585 (Output t584 584)) +(let t586 (Input 586 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t587 (Output t586 586)) +(let t588 (Input 588 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t589 (Output t588 588)) +(let t590 (Input 590 "model.layers.17.self_attn.v_proj.weight" (F32))) +(let t591 (Output t590 590)) +(let t592 (Input 592 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t593 (Output t592 592)) +(let t594 (Input 594 "model.layers.17.self_attn.q_norm.weight" (F32))) +(let t595 (Output t594 594)) +(let t596 (Input 596 "model.layers.17.self_attn.k_norm.weight" (F32))) +(let t597 (Output t596 596)) +(let t598 (Input 598 "model.layers.17.input_layernorm.weight" (F32))) +(let t599 (Output t598 598)) +(let t600 (Input 600 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t601 (Output t600 600)) +(let t602 (Input 602 "model.layers.17.pre_feedforward_layernorm.weight" (F32))) +(let t603 (Output t602 602)) +(let t604 (Input 604 "model.layers.17.post_feedforward_layernorm.weight" (F32))) +(let t605 (Output t604 604)) +(let t606 (Input 606 "model.layers.18.mlp.up_proj.weight" (F32))) +(let t607 (Output t606 606)) +(let t608 (Input 608 "model.layers.18.mlp.gate_proj.weight" (F32))) +(let t609 (Output t608 608)) +(let t610 (Input 610 "model.layers.18.mlp.down_proj.weight" (F32))) +(let t611 (Output t610 610)) +(let t612 (Input 612 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t613 (Output t612 612)) +(let t614 (Input 614 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t615 (Output t614 614)) +(let t616 (Input 616 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t617 (Output t616 616)) +(let t618 (Input 618 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t619 (Output t618 618)) +(let t620 (Input 620 "model.layers.18.self_attn.q_norm.weight" (F32))) +(let t621 (Output t620 620)) +(let t622 (Input 622 "model.layers.18.self_attn.k_norm.weight" (F32))) +(let t623 (Output t622 622)) +(let t624 (Input 624 "model.layers.18.input_layernorm.weight" (F32))) +(let t625 (Output t624 624)) +(let t626 (Input 626 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t627 (Output t626 626)) +(let t628 (Input 628 "model.layers.18.pre_feedforward_layernorm.weight" (F32))) +(let t629 (Output t628 628)) +(let t630 (Input 630 "model.layers.18.post_feedforward_layernorm.weight" (F32))) +(let t631 (Output t630 630)) +(let t632 (Input 632 "model.layers.19.mlp.up_proj.weight" (F32))) +(let t633 (Output t632 632)) +(let t634 (Input 634 "model.layers.19.mlp.gate_proj.weight" (F32))) +(let t635 (Output t634 634)) +(let t636 (Input 636 "model.layers.19.mlp.down_proj.weight" (F32))) +(let t637 (Output t636 636)) +(let t638 (Input 638 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t639 (Output t638 638)) +(let t640 (Input 640 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t641 (Output t640 640)) +(let t642 (Input 642 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t643 (Output t642 642)) +(let t644 (Input 644 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t645 (Output t644 644)) +(let t646 (Input 646 "model.layers.19.self_attn.q_norm.weight" (F32))) +(let t647 (Output t646 646)) +(let t648 (Input 648 "model.layers.19.self_attn.k_norm.weight" (F32))) +(let t649 (Output t648 648)) +(let t650 (Input 650 "model.layers.19.input_layernorm.weight" (F32))) +(let t651 (Output t650 650)) +(let t652 (Input 652 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t653 (Output t652 652)) +(let t654 (Input 654 "model.layers.19.pre_feedforward_layernorm.weight" (F32))) +(let t655 (Output t654 654)) +(let t656 (Input 656 "model.layers.19.post_feedforward_layernorm.weight" (F32))) +(let t657 (Output t656 656)) +(let t658 (Input 658 "model.layers.20.mlp.up_proj.weight" (F32))) +(let t659 (Output t658 658)) +(let t660 (Input 660 "model.layers.20.mlp.gate_proj.weight" (F32))) +(let t661 (Output t660 660)) +(let t662 (Input 662 "model.layers.20.mlp.down_proj.weight" (F32))) +(let t663 (Output t662 662)) +(let t664 (Input 664 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t665 (Output t664 664)) +(let t666 (Input 666 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t667 (Output t666 666)) +(let t668 (Input 668 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t669 (Output t668 668)) +(let t670 (Input 670 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t671 (Output t670 670)) +(let t672 (Input 672 "model.layers.20.self_attn.q_norm.weight" (F32))) +(let t673 (Output t672 672)) +(let t674 (Input 674 "model.layers.20.self_attn.k_norm.weight" (F32))) +(let t675 (Output t674 674)) +(let t676 (Input 676 "model.layers.20.input_layernorm.weight" (F32))) +(let t677 (Output t676 676)) +(let t678 (Input 678 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t679 (Output t678 678)) +(let t680 (Input 680 "model.layers.20.pre_feedforward_layernorm.weight" (F32))) +(let t681 (Output t680 680)) +(let t682 (Input 682 "model.layers.20.post_feedforward_layernorm.weight" (F32))) +(let t683 (Output t682 682)) +(let t684 (Input 684 "model.layers.21.mlp.up_proj.weight" (F32))) +(let t685 (Output t684 684)) +(let t686 (Input 686 "model.layers.21.mlp.gate_proj.weight" (F32))) +(let t687 (Output t686 686)) +(let t688 (Input 688 "model.layers.21.mlp.down_proj.weight" (F32))) +(let t689 (Output t688 688)) +(let t690 (Input 690 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t691 (Output t690 690)) +(let t692 (Input 692 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t693 (Output t692 692)) +(let t694 (Input 694 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t695 (Output t694 694)) +(let t696 (Input 696 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t697 (Output t696 696)) +(let t698 (Input 698 "model.layers.21.self_attn.q_norm.weight" (F32))) +(let t699 (Output t698 698)) +(let t700 (Input 700 "model.layers.21.self_attn.k_norm.weight" (F32))) +(let t701 (Output t700 700)) +(let t702 (Input 702 "model.layers.21.input_layernorm.weight" (F32))) +(let t703 (Output t702 702)) +(let t704 (Input 704 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t705 (Output t704 704)) +(let t706 (Input 706 "model.layers.21.pre_feedforward_layernorm.weight" (F32))) +(let t707 (Output t706 706)) +(let t708 (Input 708 "model.layers.21.post_feedforward_layernorm.weight" (F32))) +(let t709 (Output t708 708)) +(let t710 (Input 710 "model.layers.22.mlp.up_proj.weight" (F32))) +(let t711 (Output t710 710)) +(let t712 (Input 712 "model.layers.22.mlp.gate_proj.weight" (F32))) +(let t713 (Output t712 712)) +(let t714 (Input 714 "model.layers.22.mlp.down_proj.weight" (F32))) +(let t715 (Output t714 714)) +(let t716 (Input 716 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t717 (Output t716 716)) +(let t718 (Input 718 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t719 (Output t718 718)) +(let t720 (Input 720 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t721 (Output t720 720)) +(let t722 (Input 722 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t723 (Output t722 722)) +(let t724 (Input 724 "model.layers.22.self_attn.q_norm.weight" (F32))) +(let t725 (Output t724 724)) +(let t726 (Input 726 "model.layers.22.self_attn.k_norm.weight" (F32))) +(let t727 (Output t726 726)) +(let t728 (Input 728 "model.layers.22.input_layernorm.weight" (F32))) +(let t729 (Output t728 728)) +(let t730 (Input 730 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t731 (Output t730 730)) +(let t732 (Input 732 "model.layers.22.pre_feedforward_layernorm.weight" (F32))) +(let t733 (Output t732 732)) +(let t734 (Input 734 "model.layers.22.post_feedforward_layernorm.weight" (F32))) +(let t735 (Output t734 734)) +(let t736 (Input 736 "model.layers.23.mlp.up_proj.weight" (F32))) +(let t737 (Output t736 736)) +(let t738 (Input 738 "model.layers.23.mlp.gate_proj.weight" (F32))) +(let t739 (Output t738 738)) +(let t740 (Input 740 "model.layers.23.mlp.down_proj.weight" (F32))) +(let t741 (Output t740 740)) +(let t742 (Input 742 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t743 (Output t742 742)) +(let t744 (Input 744 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t745 (Output t744 744)) +(let t746 (Input 746 "model.layers.23.self_attn.v_proj.weight" (F32))) +(let t747 (Output t746 746)) +(let t748 (Input 748 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t749 (Output t748 748)) +(let t750 (Input 750 "model.layers.23.self_attn.q_norm.weight" (F32))) +(let t751 (Output t750 750)) +(let t752 (Input 752 "model.layers.23.self_attn.k_norm.weight" (F32))) +(let t753 (Output t752 752)) +(let t754 (Input 754 "model.layers.23.input_layernorm.weight" (F32))) +(let t755 (Output t754 754)) +(let t756 (Input 756 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t757 (Output t756 756)) +(let t758 (Input 758 "model.layers.23.pre_feedforward_layernorm.weight" (F32))) +(let t759 (Output t758 758)) +(let t760 (Input 760 "model.layers.23.post_feedforward_layernorm.weight" (F32))) +(let t761 (Output t760 760)) +(let t762 (Input 762 "model.layers.24.mlp.up_proj.weight" (F32))) +(let t763 (Output t762 762)) +(let t764 (Input 764 "model.layers.24.mlp.gate_proj.weight" (F32))) +(let t765 (Output t764 764)) +(let t766 (Input 766 "model.layers.24.mlp.down_proj.weight" (F32))) +(let t767 (Output t766 766)) +(let t768 (Input 768 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t769 (Output t768 768)) +(let t770 (Input 770 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t771 (Output t770 770)) +(let t772 (Input 772 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t773 (Output t772 772)) +(let t774 (Input 774 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t775 (Output t774 774)) +(let t776 (Input 776 "model.layers.24.self_attn.q_norm.weight" (F32))) +(let t777 (Output t776 776)) +(let t778 (Input 778 "model.layers.24.self_attn.k_norm.weight" (F32))) +(let t779 (Output t778 778)) +(let t780 (Input 780 "model.layers.24.input_layernorm.weight" (F32))) +(let t781 (Output t780 780)) +(let t782 (Input 782 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t783 (Output t782 782)) +(let t784 (Input 784 "model.layers.24.pre_feedforward_layernorm.weight" (F32))) +(let t785 (Output t784 784)) +(let t786 (Input 786 "model.layers.24.post_feedforward_layernorm.weight" (F32))) +(let t787 (Output t786 786)) +(let t788 (Input 788 "model.layers.25.mlp.up_proj.weight" (F32))) +(let t789 (Output t788 788)) +(let t790 (Input 790 "model.layers.25.mlp.gate_proj.weight" (F32))) +(let t791 (Output t790 790)) +(let t792 (Input 792 "model.layers.25.mlp.down_proj.weight" (F32))) +(let t793 (Output t792 792)) +(let t794 (Input 794 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t795 (Output t794 794)) +(let t796 (Input 796 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t797 (Output t796 796)) +(let t798 (Input 798 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t799 (Output t798 798)) +(let t800 (Input 800 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t801 (Output t800 800)) +(let t802 (Input 802 "model.layers.25.self_attn.q_norm.weight" (F32))) +(let t803 (Output t802 802)) +(let t804 (Input 804 "model.layers.25.self_attn.k_norm.weight" (F32))) +(let t805 (Output t804 804)) +(let t806 (Input 806 "model.layers.25.input_layernorm.weight" (F32))) +(let t807 (Output t806 806)) +(let t808 (Input 808 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t809 (Output t808 808)) +(let t810 (Input 810 "model.layers.25.pre_feedforward_layernorm.weight" (F32))) +(let t811 (Output t810 810)) +(let t812 (Input 812 "model.layers.25.post_feedforward_layernorm.weight" (F32))) +(let t813 (Output t812 812)) +(let t814 (Input 814 "model.layers.26.mlp.up_proj.weight" (F32))) +(let t815 (Output t814 814)) +(let t816 (Input 816 "model.layers.26.mlp.gate_proj.weight" (F32))) +(let t817 (Output t816 816)) +(let t818 (Input 818 "model.layers.26.mlp.down_proj.weight" (F32))) +(let t819 (Output t818 818)) +(let t820 (Input 820 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t821 (Output t820 820)) +(let t822 (Input 822 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t823 (Output t822 822)) +(let t824 (Input 824 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t825 (Output t824 824)) +(let t826 (Input 826 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t827 (Output t826 826)) +(let t828 (Input 828 "model.layers.26.self_attn.q_norm.weight" (F32))) +(let t829 (Output t828 828)) +(let t830 (Input 830 "model.layers.26.self_attn.k_norm.weight" (F32))) +(let t831 (Output t830 830)) +(let t832 (Input 832 "model.layers.26.input_layernorm.weight" (F32))) +(let t833 (Output t832 832)) +(let t834 (Input 834 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t835 (Output t834 834)) +(let t836 (Input 836 "model.layers.26.pre_feedforward_layernorm.weight" (F32))) +(let t837 (Output t836 836)) +(let t838 (Input 838 "model.layers.26.post_feedforward_layernorm.weight" (F32))) +(let t839 (Output t838 838)) +(let t840 (Input 840 "model.layers.27.mlp.up_proj.weight" (F32))) +(let t841 (Output t840 840)) +(let t842 (Input 842 "model.layers.27.mlp.gate_proj.weight" (F32))) +(let t843 (Output t842 842)) +(let t844 (Input 844 "model.layers.27.mlp.down_proj.weight" (F32))) +(let t845 (Output t844 844)) +(let t846 (Input 846 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t847 (Output t846 846)) +(let t848 (Input 848 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t849 (Output t848 848)) +(let t850 (Input 850 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t851 (Output t850 850)) +(let t852 (Input 852 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t853 (Output t852 852)) +(let t854 (Input 854 "model.layers.27.self_attn.q_norm.weight" (F32))) +(let t855 (Output t854 854)) +(let t856 (Input 856 "model.layers.27.self_attn.k_norm.weight" (F32))) +(let t857 (Output t856 856)) +(let t858 (Input 858 "model.layers.27.input_layernorm.weight" (F32))) +(let t859 (Output t858 858)) +(let t860 (Input 860 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t861 (Output t860 860)) +(let t862 (Input 862 "model.layers.27.pre_feedforward_layernorm.weight" (F32))) +(let t863 (Output t862 862)) +(let t864 (Input 864 "model.layers.27.post_feedforward_layernorm.weight" (F32))) +(let t865 (Output t864 864)) +(let t866 (Input 866 "model.layers.28.mlp.up_proj.weight" (F32))) +(let t867 (Output t866 866)) +(let t868 (Input 868 "model.layers.28.mlp.gate_proj.weight" (F32))) +(let t869 (Output t868 868)) +(let t870 (Input 870 "model.layers.28.mlp.down_proj.weight" (F32))) +(let t871 (Output t870 870)) +(let t872 (Input 872 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t873 (Output t872 872)) +(let t874 (Input 874 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t875 (Output t874 874)) +(let t876 (Input 876 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t877 (Output t876 876)) +(let t878 (Input 878 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t879 (Output t878 878)) +(let t880 (Input 880 "model.layers.28.self_attn.q_norm.weight" (F32))) +(let t881 (Output t880 880)) +(let t882 (Input 882 "model.layers.28.self_attn.k_norm.weight" (F32))) +(let t883 (Output t882 882)) +(let t884 (Input 884 "model.layers.28.input_layernorm.weight" (F32))) +(let t885 (Output t884 884)) +(let t886 (Input 886 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t887 (Output t886 886)) +(let t888 (Input 888 "model.layers.28.pre_feedforward_layernorm.weight" (F32))) +(let t889 (Output t888 888)) +(let t890 (Input 890 "model.layers.28.post_feedforward_layernorm.weight" (F32))) +(let t891 (Output t890 890)) +(let t892 (Input 892 "model.layers.29.mlp.up_proj.weight" (F32))) +(let t893 (Output t892 892)) +(let t894 (Input 894 "model.layers.29.mlp.gate_proj.weight" (F32))) +(let t895 (Output t894 894)) +(let t896 (Input 896 "model.layers.29.mlp.down_proj.weight" (F32))) +(let t897 (Output t896 896)) +(let t898 (Input 898 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t899 (Output t898 898)) +(let t900 (Input 900 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t901 (Output t900 900)) +(let t902 (Input 902 "model.layers.29.self_attn.v_proj.weight" (F32))) +(let t903 (Output t902 902)) +(let t904 (Input 904 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t905 (Output t904 904)) +(let t906 (Input 906 "model.layers.29.self_attn.q_norm.weight" (F32))) +(let t907 (Output t906 906)) +(let t908 (Input 908 "model.layers.29.self_attn.k_norm.weight" (F32))) +(let t909 (Output t908 908)) +(let t910 (Input 910 "model.layers.29.input_layernorm.weight" (F32))) +(let t911 (Output t910 910)) +(let t912 (Input 912 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t913 (Output t912 912)) +(let t914 (Input 914 "model.layers.29.pre_feedforward_layernorm.weight" (F32))) +(let t915 (Output t914 914)) +(let t916 (Input 916 "model.layers.29.post_feedforward_layernorm.weight" (F32))) +(let t917 (Output t916 916)) +(let t918 (Input 918 "model.layers.30.mlp.up_proj.weight" (F32))) +(let t919 (Output t918 918)) +(let t920 (Input 920 "model.layers.30.mlp.gate_proj.weight" (F32))) +(let t921 (Output t920 920)) +(let t922 (Input 922 "model.layers.30.mlp.down_proj.weight" (F32))) +(let t923 (Output t922 922)) +(let t924 (Input 924 "model.layers.30.self_attn.q_proj.weight" (F32))) +(let t925 (Output t924 924)) +(let t926 (Input 926 "model.layers.30.self_attn.k_proj.weight" (F32))) +(let t927 (Output t926 926)) +(let t928 (Input 928 "model.layers.30.self_attn.v_proj.weight" (F32))) +(let t929 (Output t928 928)) +(let t930 (Input 930 "model.layers.30.self_attn.o_proj.weight" (F32))) +(let t931 (Output t930 930)) +(let t932 (Input 932 "model.layers.30.self_attn.q_norm.weight" (F32))) +(let t933 (Output t932 932)) +(let t934 (Input 934 "model.layers.30.self_attn.k_norm.weight" (F32))) +(let t935 (Output t934 934)) +(let t936 (Input 936 "model.layers.30.input_layernorm.weight" (F32))) +(let t937 (Output t936 936)) +(let t938 (Input 938 "model.layers.30.post_attention_layernorm.weight" (F32))) +(let t939 (Output t938 938)) +(let t940 (Input 940 "model.layers.30.pre_feedforward_layernorm.weight" (F32))) +(let t941 (Output t940 940)) +(let t942 (Input 942 "model.layers.30.post_feedforward_layernorm.weight" (F32))) +(let t943 (Output t942 942)) +(let t944 (Input 944 "model.layers.31.mlp.up_proj.weight" (F32))) +(let t945 (Output t944 944)) +(let t946 (Input 946 "model.layers.31.mlp.gate_proj.weight" (F32))) +(let t947 (Output t946 946)) +(let t948 (Input 948 "model.layers.31.mlp.down_proj.weight" (F32))) +(let t949 (Output t948 948)) +(let t950 (Input 950 "model.layers.31.self_attn.q_proj.weight" (F32))) +(let t951 (Output t950 950)) +(let t952 (Input 952 "model.layers.31.self_attn.k_proj.weight" (F32))) +(let t953 (Output t952 952)) +(let t954 (Input 954 "model.layers.31.self_attn.v_proj.weight" (F32))) +(let t955 (Output t954 954)) +(let t956 (Input 956 "model.layers.31.self_attn.o_proj.weight" (F32))) +(let t957 (Output t956 956)) +(let t958 (Input 958 "model.layers.31.self_attn.q_norm.weight" (F32))) +(let t959 (Output t958 958)) +(let t960 (Input 960 "model.layers.31.self_attn.k_norm.weight" (F32))) +(let t961 (Output t960 960)) +(let t962 (Input 962 "model.layers.31.input_layernorm.weight" (F32))) +(let t963 (Output t962 962)) +(let t964 (Input 964 "model.layers.31.post_attention_layernorm.weight" (F32))) +(let t965 (Output t964 964)) +(let t966 (Input 966 "model.layers.31.pre_feedforward_layernorm.weight" (F32))) +(let t967 (Output t966 966)) +(let t968 (Input 968 "model.layers.31.post_feedforward_layernorm.weight" (F32))) +(let t969 (Output t968 968)) +(let t970 (Input 970 "model.layers.32.mlp.up_proj.weight" (F32))) +(let t971 (Output t970 970)) +(let t972 (Input 972 "model.layers.32.mlp.gate_proj.weight" (F32))) +(let t973 (Output t972 972)) +(let t974 (Input 974 "model.layers.32.mlp.down_proj.weight" (F32))) +(let t975 (Output t974 974)) +(let t976 (Input 976 "model.layers.32.self_attn.q_proj.weight" (F32))) +(let t977 (Output t976 976)) +(let t978 (Input 978 "model.layers.32.self_attn.k_proj.weight" (F32))) +(let t979 (Output t978 978)) +(let t980 (Input 980 "model.layers.32.self_attn.v_proj.weight" (F32))) +(let t981 (Output t980 980)) +(let t982 (Input 982 "model.layers.32.self_attn.o_proj.weight" (F32))) +(let t983 (Output t982 982)) +(let t984 (Input 984 "model.layers.32.self_attn.q_norm.weight" (F32))) +(let t985 (Output t984 984)) +(let t986 (Input 986 "model.layers.32.self_attn.k_norm.weight" (F32))) +(let t987 (Output t986 986)) +(let t988 (Input 988 "model.layers.32.input_layernorm.weight" (F32))) +(let t989 (Output t988 988)) +(let t990 (Input 990 "model.layers.32.post_attention_layernorm.weight" (F32))) +(let t991 (Output t990 990)) +(let t992 (Input 992 "model.layers.32.pre_feedforward_layernorm.weight" (F32))) +(let t993 (Output t992 992)) +(let t994 (Input 994 "model.layers.32.post_feedforward_layernorm.weight" (F32))) +(let t995 (Output t994 994)) +(let t996 (Input 996 "model.layers.33.mlp.up_proj.weight" (F32))) +(let t997 (Output t996 996)) +(let t998 (Input 998 "model.layers.33.mlp.gate_proj.weight" (F32))) +(let t999 (Output t998 998)) +(let t1000 (Input 1000 "model.layers.33.mlp.down_proj.weight" (F32))) +(let t1001 (Output t1000 1000)) +(let t1002 (Input 1002 "model.layers.33.self_attn.q_proj.weight" (F32))) +(let t1003 (Output t1002 1002)) +(let t1004 (Input 1004 "model.layers.33.self_attn.k_proj.weight" (F32))) +(let t1005 (Output t1004 1004)) +(let t1006 (Input 1006 "model.layers.33.self_attn.v_proj.weight" (F32))) +(let t1007 (Output t1006 1006)) +(let t1008 (Input 1008 "model.layers.33.self_attn.o_proj.weight" (F32))) +(let t1009 (Output t1008 1008)) +(let t1010 (Input 1010 "model.layers.33.self_attn.q_norm.weight" (F32))) +(let t1011 (Output t1010 1010)) +(let t1012 (Input 1012 "model.layers.33.self_attn.k_norm.weight" (F32))) +(let t1013 (Output t1012 1012)) +(let t1014 (Input 1014 "model.layers.33.input_layernorm.weight" (F32))) +(let t1015 (Output t1014 1014)) +(let t1016 (Input 1016 "model.layers.33.post_attention_layernorm.weight" (F32))) +(let t1017 (Output t1016 1016)) +(let t1018 (Input 1018 "model.layers.33.pre_feedforward_layernorm.weight" (F32))) +(let t1019 (Output t1018 1018)) +(let t1020 (Input 1020 "model.layers.33.post_feedforward_layernorm.weight" (F32))) +(let t1021 (Output t1020 1020)) +(let t1022 (Input 1022 "model.norm.weight" (F32))) +(let t1023 (Output t1022 1022)) +(let t1024 (Input 1024 "model.embed_tokens.weight" (F32))) +(let t1025 (Output t1024 1024)) +(let t1026 (Input 1026 "lm_head.weight" (F32))) +(let t1027 (Output t1026 1026)) +(let t1028 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1029 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t1028 (INil))))) +(let t1030 (Op (Iota (MIter) (MNum 2560)) (INil))) +(let t1031 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1029 (ICons t1030 (INil))))) +(let t1032 (Op (Gather (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 262208) (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1031 (ICons t1024 (INil))))) +(let t1033 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1034 (Op (Cast (MNum 1) (F32)) (ICons t1033 (INil)))) +(let t1035 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1034 (INil)))) +(let t1036 (Op (Constant 0.000001) (INil))) +(let t1037 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1038 (Op (Cast (MNum 1) (F32)) (ICons t1037 (INil)))) +(let t1039 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1038 (INil)))) +(let t1040 (Op (Constant 0.000001) (INil))) +(let t1041 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1042 (Op (Cast (MNum 1) (F32)) (ICons t1041 (INil)))) +(let t1043 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1042 (INil)))) +(let t1044 (Op (Constant 0.000001) (INil))) +(let t1045 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1046 (Op (Cast (MNum 128) (F32)) (ICons t1045 (INil)))) +(let t1047 (Op (Constant 0.003906) (INil))) +(let t1048 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1046 (ICons t1047 (INil))))) +(let t1049 (Op (Constant 9.210340) (INil))) +(let t1050 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1048 (ICons t1049 (INil))))) +(let t1051 (Op (Constant 1.442695) (INil))) +(let t1052 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1050 (ICons t1051 (INil))))) +(let t1053 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1052 (INil)))) +(let t1054 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1053 (INil)))) +(let t1055 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1056 (Op (Constant 1.000000) (INil))) +(let t1057 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1055 (ICons t1056 (INil))))) +(let t1058 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1057 (ICons t1054 (INil))))) +(let t1059 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1058 (INil)))) +(let t1060 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1061 (Op (Constant -1.000000) (INil))) +(let t1062 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1059 (ICons t1061 (INil))))) +(let t1063 (Op (Constant 1.570796) (INil))) +(let t1064 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1062 (ICons t1063 (INil))))) +(let t1065 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1064 (INil)))) +(let t1066 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1059 (INil)))) +(let t1067 (Op (Constant -1.000000) (INil))) +(let t1068 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1069 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1070 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1069 (INil)))) +(let t1071 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1072 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1073 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1072 (INil)))) +(let t1074 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1075 (Op (Cast (MNum 128) (F32)) (ICons t1074 (INil)))) +(let t1076 (Op (Constant 0.003906) (INil))) +(let t1077 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1075 (ICons t1076 (INil))))) +(let t1078 (Op (Constant 9.210340) (INil))) +(let t1079 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1077 (ICons t1078 (INil))))) +(let t1080 (Op (Constant 1.442695) (INil))) +(let t1081 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1079 (ICons t1080 (INil))))) +(let t1082 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1081 (INil)))) +(let t1083 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1082 (INil)))) +(let t1084 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1085 (Op (Constant 1.000000) (INil))) +(let t1086 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1084 (ICons t1085 (INil))))) +(let t1087 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1086 (ICons t1083 (INil))))) +(let t1088 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1087 (INil)))) +(let t1089 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1090 (Op (Constant -1.000000) (INil))) +(let t1091 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1088 (ICons t1090 (INil))))) +(let t1092 (Op (Constant 1.570796) (INil))) +(let t1093 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1091 (ICons t1092 (INil))))) +(let t1094 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1093 (INil)))) +(let t1095 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1088 (INil)))) +(let t1096 (Op (Constant -1.000000) (INil))) +(let t1097 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1098 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1099 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1098 (INil)))) +(let t1100 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1101 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1102 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1101 (INil)))) +(let t1103 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1104 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1105 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1103 (ICons t1104 (INil))))) +(let t1106 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1107 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1108 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1106 (ICons t1107 (INil))))) +(let t1109 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1110 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1108 (ICons t1109 (INil))))) +(let t1111 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1112 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1105 (ICons t1110 (INil))))) +(let t1113 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1112 (ICons t1111 (INil))))) +(let t1114 (Op (Constant 0.062500) (INil))) +(let t1115 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1116 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1115 (INil)))) +(let t1117 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1118 (Op (Cast (MNum 1) (F32)) (ICons t1117 (INil)))) +(let t1119 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1116 (ICons t1118 (INil))))) +(let t1120 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1121 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1120 (INil)))) +(let t1122 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1119 (ICons t1121 (INil))))) +(let t1123 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1122 (INil)))) +(let t1124 (Op (Constant 1023.000000) (INil))) +(let t1125 (Op (Constant -1.000000) (INil))) +(let t1126 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1124 (ICons t1125 (INil))))) +(let t1127 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1119 (ICons t1126 (INil))))) +(let t1128 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1121 (ICons t1127 (INil))))) +(let t1129 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1128 (INil)))) +(let t1130 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1123 (ICons t1129 (INil))))) +(let t1131 (Op (Constant -10000000000.000000) (INil))) +(let t1132 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1130 (ICons t1131 (INil))))) +(let t1133 (Op (Constant -1.000000) (INil))) +(let t1134 (Op (Constant 1.442695) (INil))) +(let t1135 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1136 (Op (Cast (MNum 1) (F32)) (ICons t1135 (INil)))) +(let t1137 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1136 (INil)))) +(let t1138 (Op (Constant 0.000001) (INil))) +(let t1139 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1140 (Op (Cast (MNum 1) (F32)) (ICons t1139 (INil)))) +(let t1141 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1140 (INil)))) +(let t1142 (Op (Constant 0.000001) (INil))) +(let t1143 (Op (Constant 1.595769) (INil))) +(let t1144 (Op (Constant 0.044715) (INil))) +(let t1145 (Op (Constant 1.000000) (INil))) +(let t1146 (Op (Constant -1.000000) (INil))) +(let t1147 (Op (Constant 1.442695) (INil))) +(let t1148 (Op (Constant 1.000000) (INil))) +(let t1149 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1150 (Op (Cast (MNum 1) (F32)) (ICons t1149 (INil)))) +(let t1151 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1150 (INil)))) +(let t1152 (Op (Constant 0.000001) (INil))) +(let t1153 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1154 (Op (Cast (MNum 1) (F32)) (ICons t1153 (INil)))) +(let t1155 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1154 (INil)))) +(let t1156 (Op (Constant 0.000001) (INil))) +(let t1157 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1158 (Op (Cast (MNum 1) (F32)) (ICons t1157 (INil)))) +(let t1159 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1158 (INil)))) +(let t1160 (Op (Constant 0.000001) (INil))) +(let t1161 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1162 (Op (Cast (MNum 1) (F32)) (ICons t1161 (INil)))) +(let t1163 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1162 (INil)))) +(let t1164 (Op (Constant 0.000001) (INil))) +(let t1165 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1166 (Op (Cast (MNum 128) (F32)) (ICons t1165 (INil)))) +(let t1167 (Op (Constant 0.003906) (INil))) +(let t1168 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1166 (ICons t1167 (INil))))) +(let t1169 (Op (Constant 9.210340) (INil))) +(let t1170 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1168 (ICons t1169 (INil))))) +(let t1171 (Op (Constant 1.442695) (INil))) +(let t1172 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1170 (ICons t1171 (INil))))) +(let t1173 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1172 (INil)))) +(let t1174 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1173 (INil)))) +(let t1175 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1176 (Op (Constant 1.000000) (INil))) +(let t1177 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1175 (ICons t1176 (INil))))) +(let t1178 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1177 (ICons t1174 (INil))))) +(let t1179 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1178 (INil)))) +(let t1180 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1181 (Op (Constant -1.000000) (INil))) +(let t1182 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1179 (ICons t1181 (INil))))) +(let t1183 (Op (Constant 1.570796) (INil))) +(let t1184 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1182 (ICons t1183 (INil))))) +(let t1185 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1184 (INil)))) +(let t1186 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1179 (INil)))) +(let t1187 (Op (Constant -1.000000) (INil))) +(let t1188 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1189 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1190 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1189 (INil)))) +(let t1191 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1192 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1193 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1192 (INil)))) +(let t1194 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1195 (Op (Cast (MNum 128) (F32)) (ICons t1194 (INil)))) +(let t1196 (Op (Constant 0.003906) (INil))) +(let t1197 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1195 (ICons t1196 (INil))))) +(let t1198 (Op (Constant 9.210340) (INil))) +(let t1199 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1197 (ICons t1198 (INil))))) +(let t1200 (Op (Constant 1.442695) (INil))) +(let t1201 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1199 (ICons t1200 (INil))))) +(let t1202 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1201 (INil)))) +(let t1203 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1202 (INil)))) +(let t1204 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1205 (Op (Constant 1.000000) (INil))) +(let t1206 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1204 (ICons t1205 (INil))))) +(let t1207 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1206 (ICons t1203 (INil))))) +(let t1208 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1207 (INil)))) +(let t1209 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1210 (Op (Constant -1.000000) (INil))) +(let t1211 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1208 (ICons t1210 (INil))))) +(let t1212 (Op (Constant 1.570796) (INil))) +(let t1213 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1211 (ICons t1212 (INil))))) +(let t1214 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1213 (INil)))) +(let t1215 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1208 (INil)))) +(let t1216 (Op (Constant -1.000000) (INil))) +(let t1217 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1218 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1219 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1218 (INil)))) +(let t1220 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1221 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1222 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1221 (INil)))) +(let t1223 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1224 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1225 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1223 (ICons t1224 (INil))))) +(let t1226 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1227 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1228 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1226 (ICons t1227 (INil))))) +(let t1229 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1230 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1228 (ICons t1229 (INil))))) +(let t1231 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1232 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1225 (ICons t1230 (INil))))) +(let t1233 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1232 (ICons t1231 (INil))))) +(let t1234 (Op (Constant 0.062500) (INil))) +(let t1235 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1236 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1235 (INil)))) +(let t1237 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1238 (Op (Cast (MNum 1) (F32)) (ICons t1237 (INil)))) +(let t1239 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1236 (ICons t1238 (INil))))) +(let t1240 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1241 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1240 (INil)))) +(let t1242 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1239 (ICons t1241 (INil))))) +(let t1243 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1242 (INil)))) +(let t1244 (Op (Constant 1023.000000) (INil))) +(let t1245 (Op (Constant -1.000000) (INil))) +(let t1246 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1244 (ICons t1245 (INil))))) +(let t1247 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1239 (ICons t1246 (INil))))) +(let t1248 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1241 (ICons t1247 (INil))))) +(let t1249 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1248 (INil)))) +(let t1250 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1243 (ICons t1249 (INil))))) +(let t1251 (Op (Constant -10000000000.000000) (INil))) +(let t1252 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1250 (ICons t1251 (INil))))) +(let t1253 (Op (Constant -1.000000) (INil))) +(let t1254 (Op (Constant 1.442695) (INil))) +(let t1255 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1256 (Op (Cast (MNum 1) (F32)) (ICons t1255 (INil)))) +(let t1257 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1256 (INil)))) +(let t1258 (Op (Constant 0.000001) (INil))) +(let t1259 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1260 (Op (Cast (MNum 1) (F32)) (ICons t1259 (INil)))) +(let t1261 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1260 (INil)))) +(let t1262 (Op (Constant 0.000001) (INil))) +(let t1263 (Op (Constant 1.595769) (INil))) +(let t1264 (Op (Constant 0.044715) (INil))) +(let t1265 (Op (Constant 1.000000) (INil))) +(let t1266 (Op (Constant -1.000000) (INil))) +(let t1267 (Op (Constant 1.442695) (INil))) +(let t1268 (Op (Constant 1.000000) (INil))) +(let t1269 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1270 (Op (Cast (MNum 1) (F32)) (ICons t1269 (INil)))) +(let t1271 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1270 (INil)))) +(let t1272 (Op (Constant 0.000001) (INil))) +(let t1273 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1274 (Op (Cast (MNum 1) (F32)) (ICons t1273 (INil)))) +(let t1275 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1274 (INil)))) +(let t1276 (Op (Constant 0.000001) (INil))) +(let t1277 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1278 (Op (Cast (MNum 1) (F32)) (ICons t1277 (INil)))) +(let t1279 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1278 (INil)))) +(let t1280 (Op (Constant 0.000001) (INil))) +(let t1281 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1282 (Op (Cast (MNum 1) (F32)) (ICons t1281 (INil)))) +(let t1283 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1282 (INil)))) +(let t1284 (Op (Constant 0.000001) (INil))) +(let t1285 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1286 (Op (Cast (MNum 128) (F32)) (ICons t1285 (INil)))) +(let t1287 (Op (Constant 0.003906) (INil))) +(let t1288 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1286 (ICons t1287 (INil))))) +(let t1289 (Op (Constant 9.210340) (INil))) +(let t1290 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1288 (ICons t1289 (INil))))) +(let t1291 (Op (Constant 1.442695) (INil))) +(let t1292 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1290 (ICons t1291 (INil))))) +(let t1293 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1292 (INil)))) +(let t1294 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1293 (INil)))) +(let t1295 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1296 (Op (Constant 1.000000) (INil))) +(let t1297 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1295 (ICons t1296 (INil))))) +(let t1298 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1297 (ICons t1294 (INil))))) +(let t1299 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1298 (INil)))) +(let t1300 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1301 (Op (Constant -1.000000) (INil))) +(let t1302 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1299 (ICons t1301 (INil))))) +(let t1303 (Op (Constant 1.570796) (INil))) +(let t1304 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1302 (ICons t1303 (INil))))) +(let t1305 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1304 (INil)))) +(let t1306 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1299 (INil)))) +(let t1307 (Op (Constant -1.000000) (INil))) +(let t1308 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1309 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1310 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1309 (INil)))) +(let t1311 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1312 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1313 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1312 (INil)))) +(let t1314 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1315 (Op (Cast (MNum 128) (F32)) (ICons t1314 (INil)))) +(let t1316 (Op (Constant 0.003906) (INil))) +(let t1317 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1315 (ICons t1316 (INil))))) +(let t1318 (Op (Constant 9.210340) (INil))) +(let t1319 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1317 (ICons t1318 (INil))))) +(let t1320 (Op (Constant 1.442695) (INil))) +(let t1321 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1319 (ICons t1320 (INil))))) +(let t1322 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1321 (INil)))) +(let t1323 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1322 (INil)))) +(let t1324 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1325 (Op (Constant 1.000000) (INil))) +(let t1326 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1324 (ICons t1325 (INil))))) +(let t1327 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1326 (ICons t1323 (INil))))) +(let t1328 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1327 (INil)))) +(let t1329 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1330 (Op (Constant -1.000000) (INil))) +(let t1331 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1328 (ICons t1330 (INil))))) +(let t1332 (Op (Constant 1.570796) (INil))) +(let t1333 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1331 (ICons t1332 (INil))))) +(let t1334 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1333 (INil)))) +(let t1335 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1328 (INil)))) +(let t1336 (Op (Constant -1.000000) (INil))) +(let t1337 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1338 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1339 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1338 (INil)))) +(let t1340 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1341 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1342 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1341 (INil)))) +(let t1343 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1344 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1345 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1343 (ICons t1344 (INil))))) +(let t1346 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1347 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1348 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1346 (ICons t1347 (INil))))) +(let t1349 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1350 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1348 (ICons t1349 (INil))))) +(let t1351 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1352 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1345 (ICons t1350 (INil))))) +(let t1353 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1352 (ICons t1351 (INil))))) +(let t1354 (Op (Constant 0.062500) (INil))) +(let t1355 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1356 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1355 (INil)))) +(let t1357 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1358 (Op (Cast (MNum 1) (F32)) (ICons t1357 (INil)))) +(let t1359 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1356 (ICons t1358 (INil))))) +(let t1360 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1361 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1360 (INil)))) +(let t1362 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1359 (ICons t1361 (INil))))) +(let t1363 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1362 (INil)))) +(let t1364 (Op (Constant 1023.000000) (INil))) +(let t1365 (Op (Constant -1.000000) (INil))) +(let t1366 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1364 (ICons t1365 (INil))))) +(let t1367 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1359 (ICons t1366 (INil))))) +(let t1368 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1361 (ICons t1367 (INil))))) +(let t1369 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1368 (INil)))) +(let t1370 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1363 (ICons t1369 (INil))))) +(let t1371 (Op (Constant -10000000000.000000) (INil))) +(let t1372 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1370 (ICons t1371 (INil))))) +(let t1373 (Op (Constant -1.000000) (INil))) +(let t1374 (Op (Constant 1.442695) (INil))) +(let t1375 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1376 (Op (Cast (MNum 1) (F32)) (ICons t1375 (INil)))) +(let t1377 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1376 (INil)))) +(let t1378 (Op (Constant 0.000001) (INil))) +(let t1379 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1380 (Op (Cast (MNum 1) (F32)) (ICons t1379 (INil)))) +(let t1381 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1380 (INil)))) +(let t1382 (Op (Constant 0.000001) (INil))) +(let t1383 (Op (Constant 1.595769) (INil))) +(let t1384 (Op (Constant 0.044715) (INil))) +(let t1385 (Op (Constant 1.000000) (INil))) +(let t1386 (Op (Constant -1.000000) (INil))) +(let t1387 (Op (Constant 1.442695) (INil))) +(let t1388 (Op (Constant 1.000000) (INil))) +(let t1389 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1390 (Op (Cast (MNum 1) (F32)) (ICons t1389 (INil)))) +(let t1391 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1390 (INil)))) +(let t1392 (Op (Constant 0.000001) (INil))) +(let t1393 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1394 (Op (Cast (MNum 1) (F32)) (ICons t1393 (INil)))) +(let t1395 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1394 (INil)))) +(let t1396 (Op (Constant 0.000001) (INil))) +(let t1397 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1398 (Op (Cast (MNum 1) (F32)) (ICons t1397 (INil)))) +(let t1399 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1398 (INil)))) +(let t1400 (Op (Constant 0.000001) (INil))) +(let t1401 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1402 (Op (Cast (MNum 1) (F32)) (ICons t1401 (INil)))) +(let t1403 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1402 (INil)))) +(let t1404 (Op (Constant 0.000001) (INil))) +(let t1405 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1406 (Op (Cast (MNum 128) (F32)) (ICons t1405 (INil)))) +(let t1407 (Op (Constant 0.003906) (INil))) +(let t1408 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1406 (ICons t1407 (INil))))) +(let t1409 (Op (Constant 9.210340) (INil))) +(let t1410 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1408 (ICons t1409 (INil))))) +(let t1411 (Op (Constant 1.442695) (INil))) +(let t1412 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1410 (ICons t1411 (INil))))) +(let t1413 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1412 (INil)))) +(let t1414 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1413 (INil)))) +(let t1415 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1416 (Op (Constant 1.000000) (INil))) +(let t1417 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1415 (ICons t1416 (INil))))) +(let t1418 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1417 (ICons t1414 (INil))))) +(let t1419 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1418 (INil)))) +(let t1420 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1421 (Op (Constant -1.000000) (INil))) +(let t1422 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1419 (ICons t1421 (INil))))) +(let t1423 (Op (Constant 1.570796) (INil))) +(let t1424 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1422 (ICons t1423 (INil))))) +(let t1425 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1424 (INil)))) +(let t1426 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1419 (INil)))) +(let t1427 (Op (Constant -1.000000) (INil))) +(let t1428 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1429 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1430 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1429 (INil)))) +(let t1431 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1432 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1433 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1432 (INil)))) +(let t1434 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1435 (Op (Cast (MNum 128) (F32)) (ICons t1434 (INil)))) +(let t1436 (Op (Constant 0.003906) (INil))) +(let t1437 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1435 (ICons t1436 (INil))))) +(let t1438 (Op (Constant 9.210340) (INil))) +(let t1439 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1437 (ICons t1438 (INil))))) +(let t1440 (Op (Constant 1.442695) (INil))) +(let t1441 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1439 (ICons t1440 (INil))))) +(let t1442 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1441 (INil)))) +(let t1443 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1442 (INil)))) +(let t1444 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1445 (Op (Constant 1.000000) (INil))) +(let t1446 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1444 (ICons t1445 (INil))))) +(let t1447 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1446 (ICons t1443 (INil))))) +(let t1448 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1447 (INil)))) +(let t1449 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1450 (Op (Constant -1.000000) (INil))) +(let t1451 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1448 (ICons t1450 (INil))))) +(let t1452 (Op (Constant 1.570796) (INil))) +(let t1453 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1451 (ICons t1452 (INil))))) +(let t1454 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1453 (INil)))) +(let t1455 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1448 (INil)))) +(let t1456 (Op (Constant -1.000000) (INil))) +(let t1457 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1458 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1459 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1458 (INil)))) +(let t1460 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1461 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1462 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1461 (INil)))) +(let t1463 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1464 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1465 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1463 (ICons t1464 (INil))))) +(let t1466 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1467 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1468 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1466 (ICons t1467 (INil))))) +(let t1469 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1470 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1468 (ICons t1469 (INil))))) +(let t1471 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1472 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1465 (ICons t1470 (INil))))) +(let t1473 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1472 (ICons t1471 (INil))))) +(let t1474 (Op (Constant 0.062500) (INil))) +(let t1475 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1476 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1475 (INil)))) +(let t1477 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1478 (Op (Cast (MNum 1) (F32)) (ICons t1477 (INil)))) +(let t1479 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1476 (ICons t1478 (INil))))) +(let t1480 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1481 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1480 (INil)))) +(let t1482 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1479 (ICons t1481 (INil))))) +(let t1483 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1482 (INil)))) +(let t1484 (Op (Constant 1023.000000) (INil))) +(let t1485 (Op (Constant -1.000000) (INil))) +(let t1486 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1484 (ICons t1485 (INil))))) +(let t1487 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1479 (ICons t1486 (INil))))) +(let t1488 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1481 (ICons t1487 (INil))))) +(let t1489 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1488 (INil)))) +(let t1490 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1483 (ICons t1489 (INil))))) +(let t1491 (Op (Constant -10000000000.000000) (INil))) +(let t1492 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1490 (ICons t1491 (INil))))) +(let t1493 (Op (Constant -1.000000) (INil))) +(let t1494 (Op (Constant 1.442695) (INil))) +(let t1495 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1496 (Op (Cast (MNum 1) (F32)) (ICons t1495 (INil)))) +(let t1497 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1496 (INil)))) +(let t1498 (Op (Constant 0.000001) (INil))) +(let t1499 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1500 (Op (Cast (MNum 1) (F32)) (ICons t1499 (INil)))) +(let t1501 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1500 (INil)))) +(let t1502 (Op (Constant 0.000001) (INil))) +(let t1503 (Op (Constant 1.595769) (INil))) +(let t1504 (Op (Constant 0.044715) (INil))) +(let t1505 (Op (Constant 1.000000) (INil))) +(let t1506 (Op (Constant -1.000000) (INil))) +(let t1507 (Op (Constant 1.442695) (INil))) +(let t1508 (Op (Constant 1.000000) (INil))) +(let t1509 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1510 (Op (Cast (MNum 1) (F32)) (ICons t1509 (INil)))) +(let t1511 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1510 (INil)))) +(let t1512 (Op (Constant 0.000001) (INil))) +(let t1513 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1514 (Op (Cast (MNum 1) (F32)) (ICons t1513 (INil)))) +(let t1515 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1514 (INil)))) +(let t1516 (Op (Constant 0.000001) (INil))) +(let t1517 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1518 (Op (Cast (MNum 1) (F32)) (ICons t1517 (INil)))) +(let t1519 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1518 (INil)))) +(let t1520 (Op (Constant 0.000001) (INil))) +(let t1521 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1522 (Op (Cast (MNum 1) (F32)) (ICons t1521 (INil)))) +(let t1523 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1522 (INil)))) +(let t1524 (Op (Constant 0.000001) (INil))) +(let t1525 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1526 (Op (Cast (MNum 128) (F32)) (ICons t1525 (INil)))) +(let t1527 (Op (Constant 0.003906) (INil))) +(let t1528 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1526 (ICons t1527 (INil))))) +(let t1529 (Op (Constant 9.210340) (INil))) +(let t1530 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1528 (ICons t1529 (INil))))) +(let t1531 (Op (Constant 1.442695) (INil))) +(let t1532 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1530 (ICons t1531 (INil))))) +(let t1533 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1532 (INil)))) +(let t1534 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1533 (INil)))) +(let t1535 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1536 (Op (Constant 1.000000) (INil))) +(let t1537 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1535 (ICons t1536 (INil))))) +(let t1538 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1537 (ICons t1534 (INil))))) +(let t1539 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1538 (INil)))) +(let t1540 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1541 (Op (Constant -1.000000) (INil))) +(let t1542 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1539 (ICons t1541 (INil))))) +(let t1543 (Op (Constant 1.570796) (INil))) +(let t1544 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1542 (ICons t1543 (INil))))) +(let t1545 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1544 (INil)))) +(let t1546 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1539 (INil)))) +(let t1547 (Op (Constant -1.000000) (INil))) +(let t1548 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1549 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1550 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1549 (INil)))) +(let t1551 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1552 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1553 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1552 (INil)))) +(let t1554 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1555 (Op (Cast (MNum 128) (F32)) (ICons t1554 (INil)))) +(let t1556 (Op (Constant 0.003906) (INil))) +(let t1557 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1555 (ICons t1556 (INil))))) +(let t1558 (Op (Constant 9.210340) (INil))) +(let t1559 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1557 (ICons t1558 (INil))))) +(let t1560 (Op (Constant 1.442695) (INil))) +(let t1561 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1559 (ICons t1560 (INil))))) +(let t1562 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1561 (INil)))) +(let t1563 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1562 (INil)))) +(let t1564 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1565 (Op (Constant 1.000000) (INil))) +(let t1566 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1564 (ICons t1565 (INil))))) +(let t1567 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1566 (ICons t1563 (INil))))) +(let t1568 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1567 (INil)))) +(let t1569 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1570 (Op (Constant -1.000000) (INil))) +(let t1571 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1568 (ICons t1570 (INil))))) +(let t1572 (Op (Constant 1.570796) (INil))) +(let t1573 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1571 (ICons t1572 (INil))))) +(let t1574 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1573 (INil)))) +(let t1575 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1568 (INil)))) +(let t1576 (Op (Constant -1.000000) (INil))) +(let t1577 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1578 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1579 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1578 (INil)))) +(let t1580 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1581 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1582 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1581 (INil)))) +(let t1583 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1584 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1585 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1583 (ICons t1584 (INil))))) +(let t1586 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1587 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1588 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1586 (ICons t1587 (INil))))) +(let t1589 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1590 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1588 (ICons t1589 (INil))))) +(let t1591 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1592 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1585 (ICons t1590 (INil))))) +(let t1593 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1592 (ICons t1591 (INil))))) +(let t1594 (Op (Constant 0.062500) (INil))) +(let t1595 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1596 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1595 (INil)))) +(let t1597 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1598 (Op (Cast (MNum 1) (F32)) (ICons t1597 (INil)))) +(let t1599 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1596 (ICons t1598 (INil))))) +(let t1600 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1601 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1600 (INil)))) +(let t1602 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1599 (ICons t1601 (INil))))) +(let t1603 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1602 (INil)))) +(let t1604 (Op (Constant 1023.000000) (INil))) +(let t1605 (Op (Constant -1.000000) (INil))) +(let t1606 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1604 (ICons t1605 (INil))))) +(let t1607 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1599 (ICons t1606 (INil))))) +(let t1608 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1601 (ICons t1607 (INil))))) +(let t1609 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1608 (INil)))) +(let t1610 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1603 (ICons t1609 (INil))))) +(let t1611 (Op (Constant -10000000000.000000) (INil))) +(let t1612 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1610 (ICons t1611 (INil))))) +(let t1613 (Op (Constant -1.000000) (INil))) +(let t1614 (Op (Constant 1.442695) (INil))) +(let t1615 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1616 (Op (Cast (MNum 1) (F32)) (ICons t1615 (INil)))) +(let t1617 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1616 (INil)))) +(let t1618 (Op (Constant 0.000001) (INil))) +(let t1619 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1620 (Op (Cast (MNum 1) (F32)) (ICons t1619 (INil)))) +(let t1621 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1620 (INil)))) +(let t1622 (Op (Constant 0.000001) (INil))) +(let t1623 (Op (Constant 1.595769) (INil))) +(let t1624 (Op (Constant 0.044715) (INil))) +(let t1625 (Op (Constant 1.000000) (INil))) +(let t1626 (Op (Constant -1.000000) (INil))) +(let t1627 (Op (Constant 1.442695) (INil))) +(let t1628 (Op (Constant 1.000000) (INil))) +(let t1629 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1630 (Op (Cast (MNum 1) (F32)) (ICons t1629 (INil)))) +(let t1631 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1630 (INil)))) +(let t1632 (Op (Constant 0.000001) (INil))) +(let t1633 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1634 (Op (Cast (MNum 1) (F32)) (ICons t1633 (INil)))) +(let t1635 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1634 (INil)))) +(let t1636 (Op (Constant 0.000001) (INil))) +(let t1637 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1638 (Op (Cast (MNum 1) (F32)) (ICons t1637 (INil)))) +(let t1639 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1638 (INil)))) +(let t1640 (Op (Constant 0.000001) (INil))) +(let t1641 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1642 (Op (Cast (MNum 1) (F32)) (ICons t1641 (INil)))) +(let t1643 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1642 (INil)))) +(let t1644 (Op (Constant 0.000001) (INil))) +(let t1645 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1646 (Op (Cast (MNum 128) (F32)) (ICons t1645 (INil)))) +(let t1647 (Op (Constant 0.003906) (INil))) +(let t1648 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1646 (ICons t1647 (INil))))) +(let t1649 (Op (Constant 13.815511) (INil))) +(let t1650 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1648 (ICons t1649 (INil))))) +(let t1651 (Op (Constant 1.442695) (INil))) +(let t1652 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1650 (ICons t1651 (INil))))) +(let t1653 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1652 (INil)))) +(let t1654 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1653 (INil)))) +(let t1655 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1656 (Op (Constant 0.125000) (INil))) +(let t1657 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1655 (ICons t1656 (INil))))) +(let t1658 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1657 (ICons t1654 (INil))))) +(let t1659 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1658 (INil)))) +(let t1660 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1661 (Op (Constant -1.000000) (INil))) +(let t1662 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1659 (ICons t1661 (INil))))) +(let t1663 (Op (Constant 1.570796) (INil))) +(let t1664 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1662 (ICons t1663 (INil))))) +(let t1665 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1664 (INil)))) +(let t1666 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1659 (INil)))) +(let t1667 (Op (Constant -1.000000) (INil))) +(let t1668 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1669 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1670 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1669 (INil)))) +(let t1671 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1672 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1673 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1672 (INil)))) +(let t1674 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1675 (Op (Cast (MNum 128) (F32)) (ICons t1674 (INil)))) +(let t1676 (Op (Constant 0.003906) (INil))) +(let t1677 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1675 (ICons t1676 (INil))))) +(let t1678 (Op (Constant 13.815511) (INil))) +(let t1679 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1677 (ICons t1678 (INil))))) +(let t1680 (Op (Constant 1.442695) (INil))) +(let t1681 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1679 (ICons t1680 (INil))))) +(let t1682 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1681 (INil)))) +(let t1683 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1682 (INil)))) +(let t1684 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1685 (Op (Constant 0.125000) (INil))) +(let t1686 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1684 (ICons t1685 (INil))))) +(let t1687 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1686 (ICons t1683 (INil))))) +(let t1688 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1687 (INil)))) +(let t1689 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1690 (Op (Constant -1.000000) (INil))) +(let t1691 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1688 (ICons t1690 (INil))))) +(let t1692 (Op (Constant 1.570796) (INil))) +(let t1693 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1691 (ICons t1692 (INil))))) +(let t1694 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1693 (INil)))) +(let t1695 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1688 (INil)))) +(let t1696 (Op (Constant -1.000000) (INil))) +(let t1697 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1698 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1699 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1698 (INil)))) +(let t1700 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1701 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1702 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1701 (INil)))) +(let t1703 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1704 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1705 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1703 (ICons t1704 (INil))))) +(let t1706 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1707 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1708 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1706 (ICons t1707 (INil))))) +(let t1709 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1710 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1708 (ICons t1709 (INil))))) +(let t1711 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1712 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1705 (ICons t1710 (INil))))) +(let t1713 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1712 (ICons t1711 (INil))))) +(let t1714 (Op (Constant 0.062500) (INil))) +(let t1715 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1716 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1715 (INil)))) +(let t1717 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1718 (Op (Cast (MNum 1) (F32)) (ICons t1717 (INil)))) +(let t1719 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1716 (ICons t1718 (INil))))) +(let t1720 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1721 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1720 (INil)))) +(let t1722 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1719 (ICons t1721 (INil))))) +(let t1723 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1722 (INil)))) +(let t1724 (Op (Constant -10000000000.000000) (INil))) +(let t1725 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1723 (ICons t1724 (INil))))) +(let t1726 (Op (Constant -1.000000) (INil))) +(let t1727 (Op (Constant 1.442695) (INil))) +(let t1728 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1729 (Op (Cast (MNum 1) (F32)) (ICons t1728 (INil)))) +(let t1730 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1729 (INil)))) +(let t1731 (Op (Constant 0.000001) (INil))) +(let t1732 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1733 (Op (Cast (MNum 1) (F32)) (ICons t1732 (INil)))) +(let t1734 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1733 (INil)))) +(let t1735 (Op (Constant 0.000001) (INil))) +(let t1736 (Op (Constant 1.595769) (INil))) +(let t1737 (Op (Constant 0.044715) (INil))) +(let t1738 (Op (Constant 1.000000) (INil))) +(let t1739 (Op (Constant -1.000000) (INil))) +(let t1740 (Op (Constant 1.442695) (INil))) +(let t1741 (Op (Constant 1.000000) (INil))) +(let t1742 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1743 (Op (Cast (MNum 1) (F32)) (ICons t1742 (INil)))) +(let t1744 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1743 (INil)))) +(let t1745 (Op (Constant 0.000001) (INil))) +(let t1746 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1747 (Op (Cast (MNum 1) (F32)) (ICons t1746 (INil)))) +(let t1748 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1747 (INil)))) +(let t1749 (Op (Constant 0.000001) (INil))) +(let t1750 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1751 (Op (Cast (MNum 1) (F32)) (ICons t1750 (INil)))) +(let t1752 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1751 (INil)))) +(let t1753 (Op (Constant 0.000001) (INil))) +(let t1754 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1755 (Op (Cast (MNum 1) (F32)) (ICons t1754 (INil)))) +(let t1756 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1755 (INil)))) +(let t1757 (Op (Constant 0.000001) (INil))) +(let t1758 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1759 (Op (Cast (MNum 128) (F32)) (ICons t1758 (INil)))) +(let t1760 (Op (Constant 0.003906) (INil))) +(let t1761 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1759 (ICons t1760 (INil))))) +(let t1762 (Op (Constant 9.210340) (INil))) +(let t1763 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1761 (ICons t1762 (INil))))) +(let t1764 (Op (Constant 1.442695) (INil))) +(let t1765 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1763 (ICons t1764 (INil))))) +(let t1766 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1765 (INil)))) +(let t1767 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1766 (INil)))) +(let t1768 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1769 (Op (Constant 1.000000) (INil))) +(let t1770 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1768 (ICons t1769 (INil))))) +(let t1771 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1770 (ICons t1767 (INil))))) +(let t1772 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1771 (INil)))) +(let t1773 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1774 (Op (Constant -1.000000) (INil))) +(let t1775 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1772 (ICons t1774 (INil))))) +(let t1776 (Op (Constant 1.570796) (INil))) +(let t1777 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1775 (ICons t1776 (INil))))) +(let t1778 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1777 (INil)))) +(let t1779 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1772 (INil)))) +(let t1780 (Op (Constant -1.000000) (INil))) +(let t1781 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1782 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1783 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1782 (INil)))) +(let t1784 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1785 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1786 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1785 (INil)))) +(let t1787 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1788 (Op (Cast (MNum 128) (F32)) (ICons t1787 (INil)))) +(let t1789 (Op (Constant 0.003906) (INil))) +(let t1790 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1788 (ICons t1789 (INil))))) +(let t1791 (Op (Constant 9.210340) (INil))) +(let t1792 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1790 (ICons t1791 (INil))))) +(let t1793 (Op (Constant 1.442695) (INil))) +(let t1794 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1792 (ICons t1793 (INil))))) +(let t1795 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1794 (INil)))) +(let t1796 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1795 (INil)))) +(let t1797 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1798 (Op (Constant 1.000000) (INil))) +(let t1799 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1797 (ICons t1798 (INil))))) +(let t1800 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1799 (ICons t1796 (INil))))) +(let t1801 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1800 (INil)))) +(let t1802 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1803 (Op (Constant -1.000000) (INil))) +(let t1804 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1801 (ICons t1803 (INil))))) +(let t1805 (Op (Constant 1.570796) (INil))) +(let t1806 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1804 (ICons t1805 (INil))))) +(let t1807 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1806 (INil)))) +(let t1808 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1801 (INil)))) +(let t1809 (Op (Constant -1.000000) (INil))) +(let t1810 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1811 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1812 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1811 (INil)))) +(let t1813 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1814 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1815 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1814 (INil)))) +(let t1816 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1817 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1818 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1816 (ICons t1817 (INil))))) +(let t1819 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1820 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1821 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1819 (ICons t1820 (INil))))) +(let t1822 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1823 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1821 (ICons t1822 (INil))))) +(let t1824 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1825 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1818 (ICons t1823 (INil))))) +(let t1826 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1825 (ICons t1824 (INil))))) +(let t1827 (Op (Constant 0.062500) (INil))) +(let t1828 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1829 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1828 (INil)))) +(let t1830 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1831 (Op (Cast (MNum 1) (F32)) (ICons t1830 (INil)))) +(let t1832 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1829 (ICons t1831 (INil))))) +(let t1833 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1834 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1833 (INil)))) +(let t1835 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1832 (ICons t1834 (INil))))) +(let t1836 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1835 (INil)))) +(let t1837 (Op (Constant 1023.000000) (INil))) +(let t1838 (Op (Constant -1.000000) (INil))) +(let t1839 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1837 (ICons t1838 (INil))))) +(let t1840 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1832 (ICons t1839 (INil))))) +(let t1841 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1834 (ICons t1840 (INil))))) +(let t1842 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1841 (INil)))) +(let t1843 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1836 (ICons t1842 (INil))))) +(let t1844 (Op (Constant -10000000000.000000) (INil))) +(let t1845 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1843 (ICons t1844 (INil))))) +(let t1846 (Op (Constant -1.000000) (INil))) +(let t1847 (Op (Constant 1.442695) (INil))) +(let t1848 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1849 (Op (Cast (MNum 1) (F32)) (ICons t1848 (INil)))) +(let t1850 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1849 (INil)))) +(let t1851 (Op (Constant 0.000001) (INil))) +(let t1852 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1853 (Op (Cast (MNum 1) (F32)) (ICons t1852 (INil)))) +(let t1854 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1853 (INil)))) +(let t1855 (Op (Constant 0.000001) (INil))) +(let t1856 (Op (Constant 1.595769) (INil))) +(let t1857 (Op (Constant 0.044715) (INil))) +(let t1858 (Op (Constant 1.000000) (INil))) +(let t1859 (Op (Constant -1.000000) (INil))) +(let t1860 (Op (Constant 1.442695) (INil))) +(let t1861 (Op (Constant 1.000000) (INil))) +(let t1862 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1863 (Op (Cast (MNum 1) (F32)) (ICons t1862 (INil)))) +(let t1864 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1863 (INil)))) +(let t1865 (Op (Constant 0.000001) (INil))) +(let t1866 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1867 (Op (Cast (MNum 1) (F32)) (ICons t1866 (INil)))) +(let t1868 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1867 (INil)))) +(let t1869 (Op (Constant 0.000001) (INil))) +(let t1870 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1871 (Op (Cast (MNum 1) (F32)) (ICons t1870 (INil)))) +(let t1872 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1871 (INil)))) +(let t1873 (Op (Constant 0.000001) (INil))) +(let t1874 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1875 (Op (Cast (MNum 1) (F32)) (ICons t1874 (INil)))) +(let t1876 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1875 (INil)))) +(let t1877 (Op (Constant 0.000001) (INil))) +(let t1878 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1879 (Op (Cast (MNum 128) (F32)) (ICons t1878 (INil)))) +(let t1880 (Op (Constant 0.003906) (INil))) +(let t1881 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1879 (ICons t1880 (INil))))) +(let t1882 (Op (Constant 9.210340) (INil))) +(let t1883 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1881 (ICons t1882 (INil))))) +(let t1884 (Op (Constant 1.442695) (INil))) +(let t1885 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1883 (ICons t1884 (INil))))) +(let t1886 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1885 (INil)))) +(let t1887 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1886 (INil)))) +(let t1888 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1889 (Op (Constant 1.000000) (INil))) +(let t1890 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1888 (ICons t1889 (INil))))) +(let t1891 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1890 (ICons t1887 (INil))))) +(let t1892 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1891 (INil)))) +(let t1893 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1894 (Op (Constant -1.000000) (INil))) +(let t1895 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1892 (ICons t1894 (INil))))) +(let t1896 (Op (Constant 1.570796) (INil))) +(let t1897 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1895 (ICons t1896 (INil))))) +(let t1898 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1897 (INil)))) +(let t1899 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1892 (INil)))) +(let t1900 (Op (Constant -1.000000) (INil))) +(let t1901 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1902 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1903 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1902 (INil)))) +(let t1904 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1905 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1906 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1905 (INil)))) +(let t1907 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1908 (Op (Cast (MNum 128) (F32)) (ICons t1907 (INil)))) +(let t1909 (Op (Constant 0.003906) (INil))) +(let t1910 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1908 (ICons t1909 (INil))))) +(let t1911 (Op (Constant 9.210340) (INil))) +(let t1912 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1910 (ICons t1911 (INil))))) +(let t1913 (Op (Constant 1.442695) (INil))) +(let t1914 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1912 (ICons t1913 (INil))))) +(let t1915 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1914 (INil)))) +(let t1916 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1915 (INil)))) +(let t1917 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1918 (Op (Constant 1.000000) (INil))) +(let t1919 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1917 (ICons t1918 (INil))))) +(let t1920 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1919 (ICons t1916 (INil))))) +(let t1921 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1920 (INil)))) +(let t1922 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1923 (Op (Constant -1.000000) (INil))) +(let t1924 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1921 (ICons t1923 (INil))))) +(let t1925 (Op (Constant 1.570796) (INil))) +(let t1926 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1924 (ICons t1925 (INil))))) +(let t1927 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1926 (INil)))) +(let t1928 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1921 (INil)))) +(let t1929 (Op (Constant -1.000000) (INil))) +(let t1930 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1931 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1932 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1931 (INil)))) +(let t1933 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1934 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t1935 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1934 (INil)))) +(let t1936 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1937 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1938 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1936 (ICons t1937 (INil))))) +(let t1939 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1940 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1941 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1939 (ICons t1940 (INil))))) +(let t1942 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1943 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1941 (ICons t1942 (INil))))) +(let t1944 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1945 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1938 (ICons t1943 (INil))))) +(let t1946 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1945 (ICons t1944 (INil))))) +(let t1947 (Op (Constant 0.062500) (INil))) +(let t1948 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1949 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1948 (INil)))) +(let t1950 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1951 (Op (Cast (MNum 1) (F32)) (ICons t1950 (INil)))) +(let t1952 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1949 (ICons t1951 (INil))))) +(let t1953 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1954 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1953 (INil)))) +(let t1955 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1952 (ICons t1954 (INil))))) +(let t1956 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1955 (INil)))) +(let t1957 (Op (Constant 1023.000000) (INil))) +(let t1958 (Op (Constant -1.000000) (INil))) +(let t1959 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1957 (ICons t1958 (INil))))) +(let t1960 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1952 (ICons t1959 (INil))))) +(let t1961 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1954 (ICons t1960 (INil))))) +(let t1962 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1961 (INil)))) +(let t1963 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1956 (ICons t1962 (INil))))) +(let t1964 (Op (Constant -10000000000.000000) (INil))) +(let t1965 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1963 (ICons t1964 (INil))))) +(let t1966 (Op (Constant -1.000000) (INil))) +(let t1967 (Op (Constant 1.442695) (INil))) +(let t1968 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1969 (Op (Cast (MNum 1) (F32)) (ICons t1968 (INil)))) +(let t1970 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1969 (INil)))) +(let t1971 (Op (Constant 0.000001) (INil))) +(let t1972 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1973 (Op (Cast (MNum 1) (F32)) (ICons t1972 (INil)))) +(let t1974 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1973 (INil)))) +(let t1975 (Op (Constant 0.000001) (INil))) +(let t1976 (Op (Constant 1.595769) (INil))) +(let t1977 (Op (Constant 0.044715) (INil))) +(let t1978 (Op (Constant 1.000000) (INil))) +(let t1979 (Op (Constant -1.000000) (INil))) +(let t1980 (Op (Constant 1.442695) (INil))) +(let t1981 (Op (Constant 1.000000) (INil))) +(let t1982 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1983 (Op (Cast (MNum 1) (F32)) (ICons t1982 (INil)))) +(let t1984 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1983 (INil)))) +(let t1985 (Op (Constant 0.000001) (INil))) +(let t1986 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1987 (Op (Cast (MNum 1) (F32)) (ICons t1986 (INil)))) +(let t1988 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1987 (INil)))) +(let t1989 (Op (Constant 0.000001) (INil))) +(let t1990 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1991 (Op (Cast (MNum 1) (F32)) (ICons t1990 (INil)))) +(let t1992 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1991 (INil)))) +(let t1993 (Op (Constant 0.000001) (INil))) +(let t1994 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1995 (Op (Cast (MNum 1) (F32)) (ICons t1994 (INil)))) +(let t1996 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1995 (INil)))) +(let t1997 (Op (Constant 0.000001) (INil))) +(let t1998 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1999 (Op (Cast (MNum 128) (F32)) (ICons t1998 (INil)))) +(let t2000 (Op (Constant 0.003906) (INil))) +(let t2001 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1999 (ICons t2000 (INil))))) +(let t2002 (Op (Constant 9.210340) (INil))) +(let t2003 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2001 (ICons t2002 (INil))))) +(let t2004 (Op (Constant 1.442695) (INil))) +(let t2005 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2003 (ICons t2004 (INil))))) +(let t2006 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2005 (INil)))) +(let t2007 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2006 (INil)))) +(let t2008 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2009 (Op (Constant 1.000000) (INil))) +(let t2010 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2008 (ICons t2009 (INil))))) +(let t2011 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2010 (ICons t2007 (INil))))) +(let t2012 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2011 (INil)))) +(let t2013 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2014 (Op (Constant -1.000000) (INil))) +(let t2015 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2012 (ICons t2014 (INil))))) +(let t2016 (Op (Constant 1.570796) (INil))) +(let t2017 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2015 (ICons t2016 (INil))))) +(let t2018 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2017 (INil)))) +(let t2019 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2012 (INil)))) +(let t2020 (Op (Constant -1.000000) (INil))) +(let t2021 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2022 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2023 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2022 (INil)))) +(let t2024 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2025 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2026 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2025 (INil)))) +(let t2027 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2028 (Op (Cast (MNum 128) (F32)) (ICons t2027 (INil)))) +(let t2029 (Op (Constant 0.003906) (INil))) +(let t2030 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2028 (ICons t2029 (INil))))) +(let t2031 (Op (Constant 9.210340) (INil))) +(let t2032 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2030 (ICons t2031 (INil))))) +(let t2033 (Op (Constant 1.442695) (INil))) +(let t2034 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2032 (ICons t2033 (INil))))) +(let t2035 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2034 (INil)))) +(let t2036 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2035 (INil)))) +(let t2037 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2038 (Op (Constant 1.000000) (INil))) +(let t2039 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2037 (ICons t2038 (INil))))) +(let t2040 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2039 (ICons t2036 (INil))))) +(let t2041 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2040 (INil)))) +(let t2042 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t2043 (Op (Constant -1.000000) (INil))) +(let t2044 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2041 (ICons t2043 (INil))))) +(let t2045 (Op (Constant 1.570796) (INil))) +(let t2046 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2044 (ICons t2045 (INil))))) +(let t2047 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2046 (INil)))) +(let t2048 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2041 (INil)))) +(let t2049 (Op (Constant -1.000000) (INil))) +(let t2050 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2051 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2052 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2051 (INil)))) +(let t2053 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2054 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2055 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2054 (INil)))) +(let t2056 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t2057 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2058 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2056 (ICons t2057 (INil))))) +(let t2059 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2060 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2061 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2059 (ICons t2060 (INil))))) +(let t2062 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2063 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2061 (ICons t2062 (INil))))) +(let t2064 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2065 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2058 (ICons t2063 (INil))))) +(let t2066 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2065 (ICons t2064 (INil))))) +(let t2067 (Op (Constant 0.062500) (INil))) +(let t2068 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2069 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2068 (INil)))) +(let t2070 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2071 (Op (Cast (MNum 1) (F32)) (ICons t2070 (INil)))) +(let t2072 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2069 (ICons t2071 (INil))))) +(let t2073 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2074 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2073 (INil)))) +(let t2075 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2072 (ICons t2074 (INil))))) +(let t2076 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2075 (INil)))) +(let t2077 (Op (Constant 1023.000000) (INil))) +(let t2078 (Op (Constant -1.000000) (INil))) +(let t2079 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2077 (ICons t2078 (INil))))) +(let t2080 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2072 (ICons t2079 (INil))))) +(let t2081 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2074 (ICons t2080 (INil))))) +(let t2082 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2081 (INil)))) +(let t2083 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2076 (ICons t2082 (INil))))) +(let t2084 (Op (Constant -10000000000.000000) (INil))) +(let t2085 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2083 (ICons t2084 (INil))))) +(let t2086 (Op (Constant -1.000000) (INil))) +(let t2087 (Op (Constant 1.442695) (INil))) +(let t2088 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2089 (Op (Cast (MNum 1) (F32)) (ICons t2088 (INil)))) +(let t2090 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2089 (INil)))) +(let t2091 (Op (Constant 0.000001) (INil))) +(let t2092 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2093 (Op (Cast (MNum 1) (F32)) (ICons t2092 (INil)))) +(let t2094 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2093 (INil)))) +(let t2095 (Op (Constant 0.000001) (INil))) +(let t2096 (Op (Constant 1.595769) (INil))) +(let t2097 (Op (Constant 0.044715) (INil))) +(let t2098 (Op (Constant 1.000000) (INil))) +(let t2099 (Op (Constant -1.000000) (INil))) +(let t2100 (Op (Constant 1.442695) (INil))) +(let t2101 (Op (Constant 1.000000) (INil))) +(let t2102 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2103 (Op (Cast (MNum 1) (F32)) (ICons t2102 (INil)))) +(let t2104 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2103 (INil)))) +(let t2105 (Op (Constant 0.000001) (INil))) +(let t2106 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2107 (Op (Cast (MNum 1) (F32)) (ICons t2106 (INil)))) +(let t2108 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2107 (INil)))) +(let t2109 (Op (Constant 0.000001) (INil))) +(let t2110 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2111 (Op (Cast (MNum 1) (F32)) (ICons t2110 (INil)))) +(let t2112 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2111 (INil)))) +(let t2113 (Op (Constant 0.000001) (INil))) +(let t2114 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2115 (Op (Cast (MNum 1) (F32)) (ICons t2114 (INil)))) +(let t2116 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2115 (INil)))) +(let t2117 (Op (Constant 0.000001) (INil))) +(let t2118 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2119 (Op (Cast (MNum 128) (F32)) (ICons t2118 (INil)))) +(let t2120 (Op (Constant 0.003906) (INil))) +(let t2121 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2119 (ICons t2120 (INil))))) +(let t2122 (Op (Constant 9.210340) (INil))) +(let t2123 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2121 (ICons t2122 (INil))))) +(let t2124 (Op (Constant 1.442695) (INil))) +(let t2125 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2123 (ICons t2124 (INil))))) +(let t2126 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2125 (INil)))) +(let t2127 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2126 (INil)))) +(let t2128 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2129 (Op (Constant 1.000000) (INil))) +(let t2130 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2128 (ICons t2129 (INil))))) +(let t2131 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2130 (ICons t2127 (INil))))) +(let t2132 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2131 (INil)))) +(let t2133 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2134 (Op (Constant -1.000000) (INil))) +(let t2135 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2132 (ICons t2134 (INil))))) +(let t2136 (Op (Constant 1.570796) (INil))) +(let t2137 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2135 (ICons t2136 (INil))))) +(let t2138 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2137 (INil)))) +(let t2139 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2132 (INil)))) +(let t2140 (Op (Constant -1.000000) (INil))) +(let t2141 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2142 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2143 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2142 (INil)))) +(let t2144 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2145 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2146 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2145 (INil)))) +(let t2147 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2148 (Op (Cast (MNum 128) (F32)) (ICons t2147 (INil)))) +(let t2149 (Op (Constant 0.003906) (INil))) +(let t2150 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2148 (ICons t2149 (INil))))) +(let t2151 (Op (Constant 9.210340) (INil))) +(let t2152 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2150 (ICons t2151 (INil))))) +(let t2153 (Op (Constant 1.442695) (INil))) +(let t2154 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2152 (ICons t2153 (INil))))) +(let t2155 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2154 (INil)))) +(let t2156 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2155 (INil)))) +(let t2157 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2158 (Op (Constant 1.000000) (INil))) +(let t2159 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2157 (ICons t2158 (INil))))) +(let t2160 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2159 (ICons t2156 (INil))))) +(let t2161 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2160 (INil)))) +(let t2162 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t2163 (Op (Constant -1.000000) (INil))) +(let t2164 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2161 (ICons t2163 (INil))))) +(let t2165 (Op (Constant 1.570796) (INil))) +(let t2166 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2164 (ICons t2165 (INil))))) +(let t2167 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2166 (INil)))) +(let t2168 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2161 (INil)))) +(let t2169 (Op (Constant -1.000000) (INil))) +(let t2170 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2171 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2172 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2171 (INil)))) +(let t2173 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2174 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 256))) (INil))) +(let t2175 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2174 (INil)))) +(let t2176 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t2177 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2178 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2176 (ICons t2177 (INil))))) +(let t2179 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2180 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2181 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2179 (ICons t2180 (INil))))) +(let t2182 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2183 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2181 (ICons t2182 (INil))))) +(let t2184 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2185 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2178 (ICons t2183 (INil))))) +(let t2186 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2185 (ICons t2184 (INil))))) +(let t2187 (Op (Constant 0.062500) (INil))) +(let t2188 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2189 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2188 (INil)))) +(let t2190 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2191 (Op (Cast (MNum 1) (F32)) (ICons t2190 (INil)))) +(let t2192 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2189 (ICons t2191 (INil))))) +(let t2193 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2194 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2193 (INil)))) +(let t2195 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2192 (ICons t2194 (INil))))) +(let t2196 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2195 (INil)))) +(let t2197 (Op (Constant 1023.000000) (INil))) +(let t2198 (Op (Constant -1.000000) (INil))) +(let t2199 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2197 (ICons t2198 (INil))))) +(let t2200 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2192 (ICons t2199 (INil))))) +(let t2201 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2194 (ICons t2200 (INil))))) +(let t2202 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2201 (INil)))) +(let t2203 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2196 (ICons t2202 (INil))))) +(let t2204 (Op (Constant -10000000000.000000) (INil))) +(let t2205 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2203 (ICons t2204 (INil))))) +(let t2206 (Op (Constant -1.000000) (INil))) +(let t2207 (Op (Constant 1.442695) (INil))) +(let t2208 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2209 (Op (Cast (MNum 1) (F32)) (ICons t2208 (INil)))) +(let t2210 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2209 (INil)))) +(let t2211 (Op (Constant 0.000001) (INil))) +(let t2212 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2213 (Op (Cast (MNum 1) (F32)) (ICons t2212 (INil)))) +(let t2214 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2213 (INil)))) +(let t2215 (Op (Constant 0.000001) (INil))) +(let t2216 (Op (Constant 1.595769) (INil))) +(let t2217 (Op (Constant 0.044715) (INil))) +(let t2218 (Op (Constant 1.000000) (INil))) +(let t2219 (Op (Constant -1.000000) (INil))) +(let t2220 (Op (Constant 1.442695) (INil))) +(let t2221 (Op (Constant 1.000000) (INil))) +(let t2222 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2223 (Op (Cast (MNum 1) (F32)) (ICons t2222 (INil)))) +(let t2224 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2223 (INil)))) +(let t2225 (Op (Constant 0.000001) (INil))) +(let t2226 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t2227 (Op (Cast (MNum 1) (F32)) (ICons t2226 (INil)))) +(let t2228 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2227 (INil)))) +(let t2229 (Op (Constant 0.000001) (INil))) +(let t2230 (LoopStart t1032 0 0 (MNum 5) (F32))) +(let t2231 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2230 (ICons t2230 (INil))))) +(let t2232 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2231 (INil)))) +(let t2233 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2232 (ICons t1035 (INil))))) +(let t2234 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2233 (ICons t1036 (INil))))) +(let t2235 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2234 (INil)))) +(let t2236 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2235 (INil)))) +(let t2237 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2236 (ICons t2230 (INil))))) +(let t2238 (Op (LoopInput 0 1 (F32)) (ICons t156 (ICons t312 (ICons t468 (ICons t624 (ICons t780 (INil)))))))) +(let t2239 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2237 (ICons t2238 (INil))))) +(let t2240 (Op (LoopInput 0 2 (F32)) (ICons t144 (ICons t300 (ICons t456 (ICons t612 (ICons t768 (INil)))))))) +(let t2241 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2239 (ICons t2240 (INil))))) +(let t2242 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2241 (INil)))) +(let t2243 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2242 (ICons t2242 (INil))))) +(let t2244 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2243 (INil)))) +(let t2245 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2244 (ICons t1039 (INil))))) +(let t2246 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2245 (ICons t1040 (INil))))) +(let t2247 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2246 (INil)))) +(let t2248 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2247 (INil)))) +(let t2249 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2248 (ICons t2242 (INil))))) +(let t2250 (Op (LoopInput 0 3 (F32)) (ICons t146 (ICons t302 (ICons t458 (ICons t614 (ICons t770 (INil)))))))) +(let t2251 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2239 (ICons t2250 (INil))))) +(let t2252 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2251 (INil)))) +(let t2253 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2252 (ICons t2252 (INil))))) +(let t2254 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2253 (INil)))) +(let t2255 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2254 (ICons t1043 (INil))))) +(let t2256 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2255 (ICons t1044 (INil))))) +(let t2257 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2256 (INil)))) +(let t2258 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2257 (INil)))) +(let t2259 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2258 (ICons t2252 (INil))))) +(let t2260 (Op (LoopInput 0 4 (F32)) (ICons t148 (ICons t304 (ICons t460 (ICons t616 (ICons t772 (INil)))))))) +(let t2261 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2239 (ICons t2260 (INil))))) +(let t2262 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2261 (INil)))) +(let t2263 (Op (LoopInput 0 5 (F32)) (ICons t152 (ICons t308 (ICons t464 (ICons t620 (ICons t776 (INil)))))))) +(let t2264 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2249 (ICons t2263 (INil))))) +(let t2265 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1060 (ICons t2264 (INil))))) +(let t2266 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2264 (ICons t1065 (INil))))) +(let t2267 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2265 (ICons t1066 (INil))))) +(let t2268 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2267 (ICons t1067 (INil))))) +(let t2269 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2266 (ICons t2268 (INil))))) +(let t2270 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2265 (ICons t1065 (INil))))) +(let t2271 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2264 (ICons t1066 (INil))))) +(let t2272 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2270 (ICons t2271 (INil))))) +(let t2273 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1068 (ICons t2269 (INil))))) +(let t2274 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2273 (ICons t1070 (INil))))) +(let t2275 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1071 (ICons t2272 (INil))))) +(let t2276 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2275 (ICons t1073 (INil))))) +(let t2277 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2274 (ICons t2276 (INil))))) +(let t2278 (Op (LoopInput 0 6 (F32)) (ICons t154 (ICons t310 (ICons t466 (ICons t622 (ICons t778 (INil)))))))) +(let t2279 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2259 (ICons t2278 (INil))))) +(let t2280 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1089 (ICons t2279 (INil))))) +(let t2281 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2279 (ICons t1094 (INil))))) +(let t2282 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2280 (ICons t1095 (INil))))) +(let t2283 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2282 (ICons t1096 (INil))))) +(let t2284 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2281 (ICons t2283 (INil))))) +(let t2285 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2280 (ICons t1094 (INil))))) +(let t2286 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2279 (ICons t1095 (INil))))) +(let t2287 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2285 (ICons t2286 (INil))))) +(let t2288 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1097 (ICons t2284 (INil))))) +(let t2289 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2288 (ICons t1099 (INil))))) +(let t2290 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1100 (ICons t2287 (INil))))) +(let t2291 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2290 (ICons t1102 (INil))))) +(let t2292 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2289 (ICons t2291 (INil))))) +(let t2293 (Op (LoopInput 0 8 (F32)) (ICons t2 (ICons t26 (ICons t50 (ICons t74 (ICons t98 (INil)))))))) +(let t2294 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2293 (ICons t1113 (ICons t2292 (INil)))))) +(let t2295 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2277 (ICons t2294 (INil))))) +(let t2296 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2295 (INil)))) +(let t2297 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2296 (ICons t1114 (INil))))) +(let t2298 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2297 (ICons t1132 (INil))))) +(let t2299 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2298 (INil)))) +(let t2300 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2299 (ICons t1133 (INil))))) +(let t2301 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2298 (ICons t2300 (INil))))) +(let t2302 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2301 (ICons t1134 (INil))))) +(let t2303 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2302 (INil)))) +(let t2304 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2303 (INil)))) +(let t2305 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2304 (INil)))) +(let t2306 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2303 (ICons t2305 (INil))))) +(let t2307 (Op (LoopInput 0 9 (F32)) (ICons t4 (ICons t28 (ICons t52 (ICons t76 (ICons t100 (INil)))))))) +(let t2308 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2307 (ICons t1113 (ICons t2262 (INil)))))) +(let t2309 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2306 (ICons t2308 (INil))))) +(let t2310 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2309 (INil)))) +(let t2311 (Op (LoopInput 0 10 (F32)) (ICons t150 (ICons t306 (ICons t462 (ICons t618 (ICons t774 (INil)))))))) +(let t2312 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2310 (ICons t2311 (INil))))) +(let t2313 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2312 (INil)))) +(let t2314 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2313 (ICons t2313 (INil))))) +(let t2315 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2314 (INil)))) +(let t2316 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2315 (ICons t1137 (INil))))) +(let t2317 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2316 (ICons t1138 (INil))))) +(let t2318 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2317 (INil)))) +(let t2319 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2318 (INil)))) +(let t2320 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2319 (ICons t2313 (INil))))) +(let t2321 (Op (LoopInput 0 11 (F32)) (ICons t158 (ICons t314 (ICons t470 (ICons t626 (ICons t782 (INil)))))))) +(let t2322 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2320 (ICons t2321 (INil))))) +(let t2323 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2230 (ICons t2322 (INil))))) +(let t2324 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2323 (ICons t2323 (INil))))) +(let t2325 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2324 (INil)))) +(let t2326 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2325 (ICons t1141 (INil))))) +(let t2327 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2326 (ICons t1142 (INil))))) +(let t2328 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2327 (INil)))) +(let t2329 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2328 (INil)))) +(let t2330 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2329 (ICons t2323 (INil))))) +(let t2331 (Op (LoopInput 0 12 (F32)) (ICons t160 (ICons t316 (ICons t472 (ICons t628 (ICons t784 (INil)))))))) +(let t2332 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2330 (ICons t2331 (INil))))) +(let t2333 (Op (LoopInput 0 13 (F32)) (ICons t140 (ICons t296 (ICons t452 (ICons t608 (ICons t764 (INil)))))))) +(let t2334 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2332 (ICons t2333 (INil))))) +(let t2335 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2334 (INil)))) +(let t2336 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2335 (ICons t1143 (INil))))) +(let t2337 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2335 (ICons t1144 (INil))))) +(let t2338 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2337 (ICons t2335 (INil))))) +(let t2339 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2338 (ICons t1145 (INil))))) +(let t2340 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2336 (ICons t2339 (INil))))) +(let t2341 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2340 (ICons t1146 (INil))))) +(let t2342 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2341 (ICons t1147 (INil))))) +(let t2343 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2342 (INil)))) +(let t2344 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2343 (ICons t1148 (INil))))) +(let t2345 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2344 (INil)))) +(let t2346 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2335 (ICons t2345 (INil))))) +(let t2347 (Op (LoopInput 0 14 (F32)) (ICons t138 (ICons t294 (ICons t450 (ICons t606 (ICons t762 (INil)))))))) +(let t2348 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2332 (ICons t2347 (INil))))) +(let t2349 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2348 (INil)))) +(let t2350 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2346 (ICons t2349 (INil))))) +(let t2351 (Op (LoopInput 0 15 (F32)) (ICons t142 (ICons t298 (ICons t454 (ICons t610 (ICons t766 (INil)))))))) +(let t2352 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t2350 (ICons t2351 (INil))))) +(let t2353 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2352 (INil)))) +(let t2354 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2353 (ICons t2353 (INil))))) +(let t2355 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2354 (INil)))) +(let t2356 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2355 (ICons t1151 (INil))))) +(let t2357 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2356 (ICons t1152 (INil))))) +(let t2358 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2357 (INil)))) +(let t2359 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2358 (INil)))) +(let t2360 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2359 (ICons t2353 (INil))))) +(let t2361 (Op (LoopInput 0 16 (F32)) (ICons t162 (ICons t318 (ICons t474 (ICons t630 (ICons t786 (INil)))))))) +(let t2362 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2360 (ICons t2361 (INil))))) +(let t2363 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2323 (ICons t2362 (INil))))) +(let t2364 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2363 (ICons t2363 (INil))))) +(let t2365 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2364 (INil)))) +(let t2366 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2365 (ICons t1155 (INil))))) +(let t2367 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2366 (ICons t1156 (INil))))) +(let t2368 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2367 (INil)))) +(let t2369 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2368 (INil)))) +(let t2370 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2369 (ICons t2363 (INil))))) +(let t2371 (Op (LoopInput 0 17 (F32)) (ICons t182 (ICons t338 (ICons t494 (ICons t650 (ICons t806 (INil)))))))) +(let t2372 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2370 (ICons t2371 (INil))))) +(let t2373 (Op (LoopInput 0 18 (F32)) (ICons t170 (ICons t326 (ICons t482 (ICons t638 (ICons t794 (INil)))))))) +(let t2374 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2372 (ICons t2373 (INil))))) +(let t2375 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2374 (INil)))) +(let t2376 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2375 (ICons t2375 (INil))))) +(let t2377 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2376 (INil)))) +(let t2378 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2377 (ICons t1159 (INil))))) +(let t2379 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2378 (ICons t1160 (INil))))) +(let t2380 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2379 (INil)))) +(let t2381 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2380 (INil)))) +(let t2382 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2381 (ICons t2375 (INil))))) +(let t2383 (Op (LoopInput 0 19 (F32)) (ICons t172 (ICons t328 (ICons t484 (ICons t640 (ICons t796 (INil)))))))) +(let t2384 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2372 (ICons t2383 (INil))))) +(let t2385 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2384 (INil)))) +(let t2386 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2385 (ICons t2385 (INil))))) +(let t2387 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2386 (INil)))) +(let t2388 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2387 (ICons t1163 (INil))))) +(let t2389 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2388 (ICons t1164 (INil))))) +(let t2390 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2389 (INil)))) +(let t2391 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2390 (INil)))) +(let t2392 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2391 (ICons t2385 (INil))))) +(let t2393 (Op (LoopInput 0 20 (F32)) (ICons t174 (ICons t330 (ICons t486 (ICons t642 (ICons t798 (INil)))))))) +(let t2394 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2372 (ICons t2393 (INil))))) +(let t2395 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2394 (INil)))) +(let t2396 (Op (LoopInput 0 21 (F32)) (ICons t178 (ICons t334 (ICons t490 (ICons t646 (ICons t802 (INil)))))))) +(let t2397 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2382 (ICons t2396 (INil))))) +(let t2398 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1180 (ICons t2397 (INil))))) +(let t2399 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2397 (ICons t1185 (INil))))) +(let t2400 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2398 (ICons t1186 (INil))))) +(let t2401 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2400 (ICons t1187 (INil))))) +(let t2402 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2399 (ICons t2401 (INil))))) +(let t2403 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2398 (ICons t1185 (INil))))) +(let t2404 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2397 (ICons t1186 (INil))))) +(let t2405 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2403 (ICons t2404 (INil))))) +(let t2406 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1188 (ICons t2402 (INil))))) +(let t2407 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2406 (ICons t1190 (INil))))) +(let t2408 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1191 (ICons t2405 (INil))))) +(let t2409 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2408 (ICons t1193 (INil))))) +(let t2410 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2407 (ICons t2409 (INil))))) +(let t2411 (Op (LoopInput 0 22 (F32)) (ICons t180 (ICons t336 (ICons t492 (ICons t648 (ICons t804 (INil)))))))) +(let t2412 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2392 (ICons t2411 (INil))))) +(let t2413 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1209 (ICons t2412 (INil))))) +(let t2414 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2412 (ICons t1214 (INil))))) +(let t2415 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2413 (ICons t1215 (INil))))) +(let t2416 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2415 (ICons t1216 (INil))))) +(let t2417 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2414 (ICons t2416 (INil))))) +(let t2418 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2413 (ICons t1214 (INil))))) +(let t2419 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2412 (ICons t1215 (INil))))) +(let t2420 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2418 (ICons t2419 (INil))))) +(let t2421 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1217 (ICons t2417 (INil))))) +(let t2422 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2421 (ICons t1219 (INil))))) +(let t2423 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1220 (ICons t2420 (INil))))) +(let t2424 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2423 (ICons t1222 (INil))))) +(let t2425 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2422 (ICons t2424 (INil))))) +(let t2426 (Op (LoopInput 0 23 (F32)) (ICons t6 (ICons t30 (ICons t54 (ICons t78 (ICons t102 (INil)))))))) +(let t2427 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2426 (ICons t1233 (ICons t2425 (INil)))))) +(let t2428 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2410 (ICons t2427 (INil))))) +(let t2429 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2428 (INil)))) +(let t2430 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2429 (ICons t1234 (INil))))) +(let t2431 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2430 (ICons t1252 (INil))))) +(let t2432 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2431 (INil)))) +(let t2433 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2432 (ICons t1253 (INil))))) +(let t2434 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2431 (ICons t2433 (INil))))) +(let t2435 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2434 (ICons t1254 (INil))))) +(let t2436 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2435 (INil)))) +(let t2437 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2436 (INil)))) +(let t2438 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2437 (INil)))) +(let t2439 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2436 (ICons t2438 (INil))))) +(let t2440 (Op (LoopInput 0 24 (F32)) (ICons t8 (ICons t32 (ICons t56 (ICons t80 (ICons t104 (INil)))))))) +(let t2441 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2440 (ICons t1233 (ICons t2395 (INil)))))) +(let t2442 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2439 (ICons t2441 (INil))))) +(let t2443 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2442 (INil)))) +(let t2444 (Op (LoopInput 0 25 (F32)) (ICons t176 (ICons t332 (ICons t488 (ICons t644 (ICons t800 (INil)))))))) +(let t2445 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2443 (ICons t2444 (INil))))) +(let t2446 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2445 (INil)))) +(let t2447 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2446 (ICons t2446 (INil))))) +(let t2448 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2447 (INil)))) +(let t2449 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2448 (ICons t1257 (INil))))) +(let t2450 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2449 (ICons t1258 (INil))))) +(let t2451 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2450 (INil)))) +(let t2452 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2451 (INil)))) +(let t2453 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2452 (ICons t2446 (INil))))) +(let t2454 (Op (LoopInput 0 26 (F32)) (ICons t184 (ICons t340 (ICons t496 (ICons t652 (ICons t808 (INil)))))))) +(let t2455 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2453 (ICons t2454 (INil))))) +(let t2456 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2363 (ICons t2455 (INil))))) +(let t2457 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2456 (ICons t2456 (INil))))) +(let t2458 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2457 (INil)))) +(let t2459 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2458 (ICons t1261 (INil))))) +(let t2460 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2459 (ICons t1262 (INil))))) +(let t2461 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2460 (INil)))) +(let t2462 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2461 (INil)))) +(let t2463 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2462 (ICons t2456 (INil))))) +(let t2464 (Op (LoopInput 0 27 (F32)) (ICons t186 (ICons t342 (ICons t498 (ICons t654 (ICons t810 (INil)))))))) +(let t2465 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2463 (ICons t2464 (INil))))) +(let t2466 (Op (LoopInput 0 28 (F32)) (ICons t166 (ICons t322 (ICons t478 (ICons t634 (ICons t790 (INil)))))))) +(let t2467 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2465 (ICons t2466 (INil))))) +(let t2468 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2467 (INil)))) +(let t2469 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2468 (ICons t1263 (INil))))) +(let t2470 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2468 (ICons t1264 (INil))))) +(let t2471 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2470 (ICons t2468 (INil))))) +(let t2472 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2471 (ICons t1265 (INil))))) +(let t2473 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2469 (ICons t2472 (INil))))) +(let t2474 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2473 (ICons t1266 (INil))))) +(let t2475 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2474 (ICons t1267 (INil))))) +(let t2476 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2475 (INil)))) +(let t2477 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2476 (ICons t1268 (INil))))) +(let t2478 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2477 (INil)))) +(let t2479 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2468 (ICons t2478 (INil))))) +(let t2480 (Op (LoopInput 0 29 (F32)) (ICons t164 (ICons t320 (ICons t476 (ICons t632 (ICons t788 (INil)))))))) +(let t2481 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2465 (ICons t2480 (INil))))) +(let t2482 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2481 (INil)))) +(let t2483 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2479 (ICons t2482 (INil))))) +(let t2484 (Op (LoopInput 0 30 (F32)) (ICons t168 (ICons t324 (ICons t480 (ICons t636 (ICons t792 (INil)))))))) +(let t2485 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t2483 (ICons t2484 (INil))))) +(let t2486 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2485 (INil)))) +(let t2487 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2486 (ICons t2486 (INil))))) +(let t2488 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2487 (INil)))) +(let t2489 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2488 (ICons t1271 (INil))))) +(let t2490 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2489 (ICons t1272 (INil))))) +(let t2491 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2490 (INil)))) +(let t2492 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2491 (INil)))) +(let t2493 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2492 (ICons t2486 (INil))))) +(let t2494 (Op (LoopInput 0 31 (F32)) (ICons t188 (ICons t344 (ICons t500 (ICons t656 (ICons t812 (INil)))))))) +(let t2495 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2493 (ICons t2494 (INil))))) +(let t2496 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2456 (ICons t2495 (INil))))) +(let t2497 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2496 (ICons t2496 (INil))))) +(let t2498 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2497 (INil)))) +(let t2499 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2498 (ICons t1275 (INil))))) +(let t2500 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2499 (ICons t1276 (INil))))) +(let t2501 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2500 (INil)))) +(let t2502 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2501 (INil)))) +(let t2503 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2502 (ICons t2496 (INil))))) +(let t2504 (Op (LoopInput 0 32 (F32)) (ICons t208 (ICons t364 (ICons t520 (ICons t676 (ICons t832 (INil)))))))) +(let t2505 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2503 (ICons t2504 (INil))))) +(let t2506 (Op (LoopInput 0 33 (F32)) (ICons t196 (ICons t352 (ICons t508 (ICons t664 (ICons t820 (INil)))))))) +(let t2507 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2505 (ICons t2506 (INil))))) +(let t2508 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2507 (INil)))) +(let t2509 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2508 (ICons t2508 (INil))))) +(let t2510 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2509 (INil)))) +(let t2511 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2510 (ICons t1279 (INil))))) +(let t2512 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2511 (ICons t1280 (INil))))) +(let t2513 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2512 (INil)))) +(let t2514 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2513 (INil)))) +(let t2515 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2514 (ICons t2508 (INil))))) +(let t2516 (Op (LoopInput 0 34 (F32)) (ICons t198 (ICons t354 (ICons t510 (ICons t666 (ICons t822 (INil)))))))) +(let t2517 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2505 (ICons t2516 (INil))))) +(let t2518 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2517 (INil)))) +(let t2519 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2518 (ICons t2518 (INil))))) +(let t2520 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2519 (INil)))) +(let t2521 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2520 (ICons t1283 (INil))))) +(let t2522 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2521 (ICons t1284 (INil))))) +(let t2523 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2522 (INil)))) +(let t2524 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2523 (INil)))) +(let t2525 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2524 (ICons t2518 (INil))))) +(let t2526 (Op (LoopInput 0 35 (F32)) (ICons t200 (ICons t356 (ICons t512 (ICons t668 (ICons t824 (INil)))))))) +(let t2527 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2505 (ICons t2526 (INil))))) +(let t2528 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2527 (INil)))) +(let t2529 (Op (LoopInput 0 36 (F32)) (ICons t204 (ICons t360 (ICons t516 (ICons t672 (ICons t828 (INil)))))))) +(let t2530 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2515 (ICons t2529 (INil))))) +(let t2531 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1300 (ICons t2530 (INil))))) +(let t2532 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2530 (ICons t1305 (INil))))) +(let t2533 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2531 (ICons t1306 (INil))))) +(let t2534 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2533 (ICons t1307 (INil))))) +(let t2535 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2532 (ICons t2534 (INil))))) +(let t2536 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2531 (ICons t1305 (INil))))) +(let t2537 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2530 (ICons t1306 (INil))))) +(let t2538 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2536 (ICons t2537 (INil))))) +(let t2539 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1308 (ICons t2535 (INil))))) +(let t2540 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2539 (ICons t1310 (INil))))) +(let t2541 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1311 (ICons t2538 (INil))))) +(let t2542 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2541 (ICons t1313 (INil))))) +(let t2543 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2540 (ICons t2542 (INil))))) +(let t2544 (Op (LoopInput 0 37 (F32)) (ICons t206 (ICons t362 (ICons t518 (ICons t674 (ICons t830 (INil)))))))) +(let t2545 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2525 (ICons t2544 (INil))))) +(let t2546 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1329 (ICons t2545 (INil))))) +(let t2547 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2545 (ICons t1334 (INil))))) +(let t2548 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2546 (ICons t1335 (INil))))) +(let t2549 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2548 (ICons t1336 (INil))))) +(let t2550 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2547 (ICons t2549 (INil))))) +(let t2551 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2546 (ICons t1334 (INil))))) +(let t2552 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2545 (ICons t1335 (INil))))) +(let t2553 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2551 (ICons t2552 (INil))))) +(let t2554 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1337 (ICons t2550 (INil))))) +(let t2555 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2554 (ICons t1339 (INil))))) +(let t2556 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1340 (ICons t2553 (INil))))) +(let t2557 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2556 (ICons t1342 (INil))))) +(let t2558 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2555 (ICons t2557 (INil))))) +(let t2559 (Op (LoopInput 0 38 (F32)) (ICons t10 (ICons t34 (ICons t58 (ICons t82 (ICons t106 (INil)))))))) +(let t2560 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2559 (ICons t1353 (ICons t2558 (INil)))))) +(let t2561 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2543 (ICons t2560 (INil))))) +(let t2562 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2561 (INil)))) +(let t2563 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2562 (ICons t1354 (INil))))) +(let t2564 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2563 (ICons t1372 (INil))))) +(let t2565 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2564 (INil)))) +(let t2566 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2565 (ICons t1373 (INil))))) +(let t2567 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2564 (ICons t2566 (INil))))) +(let t2568 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2567 (ICons t1374 (INil))))) +(let t2569 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2568 (INil)))) +(let t2570 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2569 (INil)))) +(let t2571 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2570 (INil)))) +(let t2572 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2569 (ICons t2571 (INil))))) +(let t2573 (Op (LoopInput 0 39 (F32)) (ICons t12 (ICons t36 (ICons t60 (ICons t84 (ICons t108 (INil)))))))) +(let t2574 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2573 (ICons t1353 (ICons t2528 (INil)))))) +(let t2575 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2572 (ICons t2574 (INil))))) +(let t2576 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2575 (INil)))) +(let t2577 (Op (LoopInput 0 40 (F32)) (ICons t202 (ICons t358 (ICons t514 (ICons t670 (ICons t826 (INil)))))))) +(let t2578 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2576 (ICons t2577 (INil))))) +(let t2579 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2578 (INil)))) +(let t2580 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2579 (ICons t2579 (INil))))) +(let t2581 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2580 (INil)))) +(let t2582 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2581 (ICons t1377 (INil))))) +(let t2583 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2582 (ICons t1378 (INil))))) +(let t2584 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2583 (INil)))) +(let t2585 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2584 (INil)))) +(let t2586 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2585 (ICons t2579 (INil))))) +(let t2587 (Op (LoopInput 0 41 (F32)) (ICons t210 (ICons t366 (ICons t522 (ICons t678 (ICons t834 (INil)))))))) +(let t2588 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2586 (ICons t2587 (INil))))) +(let t2589 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2496 (ICons t2588 (INil))))) +(let t2590 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2589 (ICons t2589 (INil))))) +(let t2591 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2590 (INil)))) +(let t2592 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2591 (ICons t1381 (INil))))) +(let t2593 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2592 (ICons t1382 (INil))))) +(let t2594 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2593 (INil)))) +(let t2595 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2594 (INil)))) +(let t2596 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2595 (ICons t2589 (INil))))) +(let t2597 (Op (LoopInput 0 42 (F32)) (ICons t212 (ICons t368 (ICons t524 (ICons t680 (ICons t836 (INil)))))))) +(let t2598 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2596 (ICons t2597 (INil))))) +(let t2599 (Op (LoopInput 0 43 (F32)) (ICons t192 (ICons t348 (ICons t504 (ICons t660 (ICons t816 (INil)))))))) +(let t2600 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2598 (ICons t2599 (INil))))) +(let t2601 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2600 (INil)))) +(let t2602 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2601 (ICons t1383 (INil))))) +(let t2603 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2601 (ICons t1384 (INil))))) +(let t2604 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2603 (ICons t2601 (INil))))) +(let t2605 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2604 (ICons t1385 (INil))))) +(let t2606 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2602 (ICons t2605 (INil))))) +(let t2607 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2606 (ICons t1386 (INil))))) +(let t2608 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2607 (ICons t1387 (INil))))) +(let t2609 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2608 (INil)))) +(let t2610 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2609 (ICons t1388 (INil))))) +(let t2611 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2610 (INil)))) +(let t2612 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2601 (ICons t2611 (INil))))) +(let t2613 (Op (LoopInput 0 44 (F32)) (ICons t190 (ICons t346 (ICons t502 (ICons t658 (ICons t814 (INil)))))))) +(let t2614 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2598 (ICons t2613 (INil))))) +(let t2615 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2614 (INil)))) +(let t2616 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2612 (ICons t2615 (INil))))) +(let t2617 (Op (LoopInput 0 45 (F32)) (ICons t194 (ICons t350 (ICons t506 (ICons t662 (ICons t818 (INil)))))))) +(let t2618 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t2616 (ICons t2617 (INil))))) +(let t2619 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2618 (INil)))) +(let t2620 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2619 (ICons t2619 (INil))))) +(let t2621 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2620 (INil)))) +(let t2622 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2621 (ICons t1391 (INil))))) +(let t2623 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2622 (ICons t1392 (INil))))) +(let t2624 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2623 (INil)))) +(let t2625 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2624 (INil)))) +(let t2626 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2625 (ICons t2619 (INil))))) +(let t2627 (Op (LoopInput 0 46 (F32)) (ICons t214 (ICons t370 (ICons t526 (ICons t682 (ICons t838 (INil)))))))) +(let t2628 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2626 (ICons t2627 (INil))))) +(let t2629 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2589 (ICons t2628 (INil))))) +(let t2630 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2629 (ICons t2629 (INil))))) +(let t2631 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2630 (INil)))) +(let t2632 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2631 (ICons t1395 (INil))))) +(let t2633 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2632 (ICons t1396 (INil))))) +(let t2634 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2633 (INil)))) +(let t2635 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2634 (INil)))) +(let t2636 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2635 (ICons t2629 (INil))))) +(let t2637 (Op (LoopInput 0 47 (F32)) (ICons t234 (ICons t390 (ICons t546 (ICons t702 (ICons t858 (INil)))))))) +(let t2638 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2636 (ICons t2637 (INil))))) +(let t2639 (Op (LoopInput 0 48 (F32)) (ICons t222 (ICons t378 (ICons t534 (ICons t690 (ICons t846 (INil)))))))) +(let t2640 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2638 (ICons t2639 (INil))))) +(let t2641 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2640 (INil)))) +(let t2642 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2641 (ICons t2641 (INil))))) +(let t2643 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2642 (INil)))) +(let t2644 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2643 (ICons t1399 (INil))))) +(let t2645 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2644 (ICons t1400 (INil))))) +(let t2646 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2645 (INil)))) +(let t2647 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2646 (INil)))) +(let t2648 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2647 (ICons t2641 (INil))))) +(let t2649 (Op (LoopInput 0 49 (F32)) (ICons t224 (ICons t380 (ICons t536 (ICons t692 (ICons t848 (INil)))))))) +(let t2650 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2638 (ICons t2649 (INil))))) +(let t2651 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2650 (INil)))) +(let t2652 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2651 (ICons t2651 (INil))))) +(let t2653 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2652 (INil)))) +(let t2654 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2653 (ICons t1403 (INil))))) +(let t2655 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2654 (ICons t1404 (INil))))) +(let t2656 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2655 (INil)))) +(let t2657 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2656 (INil)))) +(let t2658 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2657 (ICons t2651 (INil))))) +(let t2659 (Op (LoopInput 0 50 (F32)) (ICons t226 (ICons t382 (ICons t538 (ICons t694 (ICons t850 (INil)))))))) +(let t2660 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2638 (ICons t2659 (INil))))) +(let t2661 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2660 (INil)))) +(let t2662 (Op (LoopInput 0 51 (F32)) (ICons t230 (ICons t386 (ICons t542 (ICons t698 (ICons t854 (INil)))))))) +(let t2663 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2648 (ICons t2662 (INil))))) +(let t2664 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1420 (ICons t2663 (INil))))) +(let t2665 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2663 (ICons t1425 (INil))))) +(let t2666 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2664 (ICons t1426 (INil))))) +(let t2667 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2666 (ICons t1427 (INil))))) +(let t2668 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2665 (ICons t2667 (INil))))) +(let t2669 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2664 (ICons t1425 (INil))))) +(let t2670 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2663 (ICons t1426 (INil))))) +(let t2671 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2669 (ICons t2670 (INil))))) +(let t2672 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1428 (ICons t2668 (INil))))) +(let t2673 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2672 (ICons t1430 (INil))))) +(let t2674 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1431 (ICons t2671 (INil))))) +(let t2675 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2674 (ICons t1433 (INil))))) +(let t2676 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2673 (ICons t2675 (INil))))) +(let t2677 (Op (LoopInput 0 52 (F32)) (ICons t232 (ICons t388 (ICons t544 (ICons t700 (ICons t856 (INil)))))))) +(let t2678 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2658 (ICons t2677 (INil))))) +(let t2679 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1449 (ICons t2678 (INil))))) +(let t2680 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2678 (ICons t1454 (INil))))) +(let t2681 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2679 (ICons t1455 (INil))))) +(let t2682 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2681 (ICons t1456 (INil))))) +(let t2683 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2680 (ICons t2682 (INil))))) +(let t2684 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2679 (ICons t1454 (INil))))) +(let t2685 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2678 (ICons t1455 (INil))))) +(let t2686 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2684 (ICons t2685 (INil))))) +(let t2687 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1457 (ICons t2683 (INil))))) +(let t2688 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2687 (ICons t1459 (INil))))) +(let t2689 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1460 (ICons t2686 (INil))))) +(let t2690 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2689 (ICons t1462 (INil))))) +(let t2691 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2688 (ICons t2690 (INil))))) +(let t2692 (Op (LoopInput 0 53 (F32)) (ICons t14 (ICons t38 (ICons t62 (ICons t86 (ICons t110 (INil)))))))) +(let t2693 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2692 (ICons t1473 (ICons t2691 (INil)))))) +(let t2694 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2676 (ICons t2693 (INil))))) +(let t2695 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2694 (INil)))) +(let t2696 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2695 (ICons t1474 (INil))))) +(let t2697 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2696 (ICons t1492 (INil))))) +(let t2698 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2697 (INil)))) +(let t2699 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2698 (ICons t1493 (INil))))) +(let t2700 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2697 (ICons t2699 (INil))))) +(let t2701 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2700 (ICons t1494 (INil))))) +(let t2702 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2701 (INil)))) +(let t2703 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2702 (INil)))) +(let t2704 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2703 (INil)))) +(let t2705 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2702 (ICons t2704 (INil))))) +(let t2706 (Op (LoopInput 0 54 (F32)) (ICons t16 (ICons t40 (ICons t64 (ICons t88 (ICons t112 (INil)))))))) +(let t2707 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2706 (ICons t1473 (ICons t2661 (INil)))))) +(let t2708 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2705 (ICons t2707 (INil))))) +(let t2709 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2708 (INil)))) +(let t2710 (Op (LoopInput 0 55 (F32)) (ICons t228 (ICons t384 (ICons t540 (ICons t696 (ICons t852 (INil)))))))) +(let t2711 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2709 (ICons t2710 (INil))))) +(let t2712 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2711 (INil)))) +(let t2713 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2712 (ICons t2712 (INil))))) +(let t2714 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2713 (INil)))) +(let t2715 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2714 (ICons t1497 (INil))))) +(let t2716 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2715 (ICons t1498 (INil))))) +(let t2717 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2716 (INil)))) +(let t2718 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2717 (INil)))) +(let t2719 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2718 (ICons t2712 (INil))))) +(let t2720 (Op (LoopInput 0 56 (F32)) (ICons t236 (ICons t392 (ICons t548 (ICons t704 (ICons t860 (INil)))))))) +(let t2721 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2719 (ICons t2720 (INil))))) +(let t2722 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2629 (ICons t2721 (INil))))) +(let t2723 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2722 (ICons t2722 (INil))))) +(let t2724 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2723 (INil)))) +(let t2725 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2724 (ICons t1501 (INil))))) +(let t2726 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2725 (ICons t1502 (INil))))) +(let t2727 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2726 (INil)))) +(let t2728 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2727 (INil)))) +(let t2729 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2728 (ICons t2722 (INil))))) +(let t2730 (Op (LoopInput 0 57 (F32)) (ICons t238 (ICons t394 (ICons t550 (ICons t706 (ICons t862 (INil)))))))) +(let t2731 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2729 (ICons t2730 (INil))))) +(let t2732 (Op (LoopInput 0 58 (F32)) (ICons t218 (ICons t374 (ICons t530 (ICons t686 (ICons t842 (INil)))))))) +(let t2733 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2731 (ICons t2732 (INil))))) +(let t2734 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2733 (INil)))) +(let t2735 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2734 (ICons t1503 (INil))))) +(let t2736 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2734 (ICons t1504 (INil))))) +(let t2737 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2736 (ICons t2734 (INil))))) +(let t2738 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2737 (ICons t1505 (INil))))) +(let t2739 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2735 (ICons t2738 (INil))))) +(let t2740 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2739 (ICons t1506 (INil))))) +(let t2741 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2740 (ICons t1507 (INil))))) +(let t2742 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2741 (INil)))) +(let t2743 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2742 (ICons t1508 (INil))))) +(let t2744 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2743 (INil)))) +(let t2745 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2734 (ICons t2744 (INil))))) +(let t2746 (Op (LoopInput 0 59 (F32)) (ICons t216 (ICons t372 (ICons t528 (ICons t684 (ICons t840 (INil)))))))) +(let t2747 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2731 (ICons t2746 (INil))))) +(let t2748 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2747 (INil)))) +(let t2749 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2745 (ICons t2748 (INil))))) +(let t2750 (Op (LoopInput 0 60 (F32)) (ICons t220 (ICons t376 (ICons t532 (ICons t688 (ICons t844 (INil)))))))) +(let t2751 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t2749 (ICons t2750 (INil))))) +(let t2752 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2751 (INil)))) +(let t2753 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2752 (ICons t2752 (INil))))) +(let t2754 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2753 (INil)))) +(let t2755 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2754 (ICons t1511 (INil))))) +(let t2756 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2755 (ICons t1512 (INil))))) +(let t2757 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2756 (INil)))) +(let t2758 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2757 (INil)))) +(let t2759 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2758 (ICons t2752 (INil))))) +(let t2760 (Op (LoopInput 0 61 (F32)) (ICons t240 (ICons t396 (ICons t552 (ICons t708 (ICons t864 (INil)))))))) +(let t2761 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2759 (ICons t2760 (INil))))) +(let t2762 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2722 (ICons t2761 (INil))))) +(let t2763 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2762 (ICons t2762 (INil))))) +(let t2764 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2763 (INil)))) +(let t2765 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2764 (ICons t1515 (INil))))) +(let t2766 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2765 (ICons t1516 (INil))))) +(let t2767 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2766 (INil)))) +(let t2768 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2767 (INil)))) +(let t2769 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2768 (ICons t2762 (INil))))) +(let t2770 (Op (LoopInput 0 62 (F32)) (ICons t260 (ICons t416 (ICons t572 (ICons t728 (ICons t884 (INil)))))))) +(let t2771 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2769 (ICons t2770 (INil))))) +(let t2772 (Op (LoopInput 0 63 (F32)) (ICons t248 (ICons t404 (ICons t560 (ICons t716 (ICons t872 (INil)))))))) +(let t2773 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2771 (ICons t2772 (INil))))) +(let t2774 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2773 (INil)))) +(let t2775 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2774 (ICons t2774 (INil))))) +(let t2776 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2775 (INil)))) +(let t2777 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2776 (ICons t1519 (INil))))) +(let t2778 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2777 (ICons t1520 (INil))))) +(let t2779 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2778 (INil)))) +(let t2780 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2779 (INil)))) +(let t2781 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2780 (ICons t2774 (INil))))) +(let t2782 (Op (LoopInput 0 64 (F32)) (ICons t250 (ICons t406 (ICons t562 (ICons t718 (ICons t874 (INil)))))))) +(let t2783 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2771 (ICons t2782 (INil))))) +(let t2784 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2783 (INil)))) +(let t2785 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2784 (ICons t2784 (INil))))) +(let t2786 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2785 (INil)))) +(let t2787 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2786 (ICons t1523 (INil))))) +(let t2788 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2787 (ICons t1524 (INil))))) +(let t2789 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2788 (INil)))) +(let t2790 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2789 (INil)))) +(let t2791 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2790 (ICons t2784 (INil))))) +(let t2792 (Op (LoopInput 0 65 (F32)) (ICons t252 (ICons t408 (ICons t564 (ICons t720 (ICons t876 (INil)))))))) +(let t2793 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2771 (ICons t2792 (INil))))) +(let t2794 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2793 (INil)))) +(let t2795 (Op (LoopInput 0 66 (F32)) (ICons t256 (ICons t412 (ICons t568 (ICons t724 (ICons t880 (INil)))))))) +(let t2796 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2781 (ICons t2795 (INil))))) +(let t2797 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1540 (ICons t2796 (INil))))) +(let t2798 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2796 (ICons t1545 (INil))))) +(let t2799 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2797 (ICons t1546 (INil))))) +(let t2800 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2799 (ICons t1547 (INil))))) +(let t2801 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2798 (ICons t2800 (INil))))) +(let t2802 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2797 (ICons t1545 (INil))))) +(let t2803 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2796 (ICons t1546 (INil))))) +(let t2804 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2802 (ICons t2803 (INil))))) +(let t2805 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1548 (ICons t2801 (INil))))) +(let t2806 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2805 (ICons t1550 (INil))))) +(let t2807 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1551 (ICons t2804 (INil))))) +(let t2808 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2807 (ICons t1553 (INil))))) +(let t2809 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2806 (ICons t2808 (INil))))) +(let t2810 (Op (LoopInput 0 67 (F32)) (ICons t258 (ICons t414 (ICons t570 (ICons t726 (ICons t882 (INil)))))))) +(let t2811 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2791 (ICons t2810 (INil))))) +(let t2812 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1569 (ICons t2811 (INil))))) +(let t2813 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2811 (ICons t1574 (INil))))) +(let t2814 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2812 (ICons t1575 (INil))))) +(let t2815 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2814 (ICons t1576 (INil))))) +(let t2816 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2813 (ICons t2815 (INil))))) +(let t2817 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2812 (ICons t1574 (INil))))) +(let t2818 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2811 (ICons t1575 (INil))))) +(let t2819 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2817 (ICons t2818 (INil))))) +(let t2820 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1577 (ICons t2816 (INil))))) +(let t2821 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2820 (ICons t1579 (INil))))) +(let t2822 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1580 (ICons t2819 (INil))))) +(let t2823 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2822 (ICons t1582 (INil))))) +(let t2824 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2821 (ICons t2823 (INil))))) +(let t2825 (Op (LoopInput 0 68 (F32)) (ICons t18 (ICons t42 (ICons t66 (ICons t90 (ICons t114 (INil)))))))) +(let t2826 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2825 (ICons t1593 (ICons t2824 (INil)))))) +(let t2827 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2809 (ICons t2826 (INil))))) +(let t2828 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2827 (INil)))) +(let t2829 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2828 (ICons t1594 (INil))))) +(let t2830 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2829 (ICons t1612 (INil))))) +(let t2831 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2830 (INil)))) +(let t2832 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2831 (ICons t1613 (INil))))) +(let t2833 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2830 (ICons t2832 (INil))))) +(let t2834 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2833 (ICons t1614 (INil))))) +(let t2835 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2834 (INil)))) +(let t2836 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2835 (INil)))) +(let t2837 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2836 (INil)))) +(let t2838 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2835 (ICons t2837 (INil))))) +(let t2839 (Op (LoopInput 0 69 (F32)) (ICons t20 (ICons t44 (ICons t68 (ICons t92 (ICons t116 (INil)))))))) +(let t2840 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2839 (ICons t1593 (ICons t2794 (INil)))))) +(let t2841 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2838 (ICons t2840 (INil))))) +(let t2842 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2841 (INil)))) +(let t2843 (Op (LoopInput 0 70 (F32)) (ICons t254 (ICons t410 (ICons t566 (ICons t722 (ICons t878 (INil)))))))) +(let t2844 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2842 (ICons t2843 (INil))))) +(let t2845 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2844 (INil)))) +(let t2846 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2845 (ICons t2845 (INil))))) +(let t2847 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2846 (INil)))) +(let t2848 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2847 (ICons t1617 (INil))))) +(let t2849 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2848 (ICons t1618 (INil))))) +(let t2850 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2849 (INil)))) +(let t2851 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2850 (INil)))) +(let t2852 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2851 (ICons t2845 (INil))))) +(let t2853 (Op (LoopInput 0 71 (F32)) (ICons t262 (ICons t418 (ICons t574 (ICons t730 (ICons t886 (INil)))))))) +(let t2854 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2852 (ICons t2853 (INil))))) +(let t2855 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2762 (ICons t2854 (INil))))) +(let t2856 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2855 (ICons t2855 (INil))))) +(let t2857 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2856 (INil)))) +(let t2858 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2857 (ICons t1621 (INil))))) +(let t2859 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2858 (ICons t1622 (INil))))) +(let t2860 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2859 (INil)))) +(let t2861 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2860 (INil)))) +(let t2862 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2861 (ICons t2855 (INil))))) +(let t2863 (Op (LoopInput 0 72 (F32)) (ICons t264 (ICons t420 (ICons t576 (ICons t732 (ICons t888 (INil)))))))) +(let t2864 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2862 (ICons t2863 (INil))))) +(let t2865 (Op (LoopInput 0 73 (F32)) (ICons t244 (ICons t400 (ICons t556 (ICons t712 (ICons t868 (INil)))))))) +(let t2866 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2864 (ICons t2865 (INil))))) +(let t2867 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2866 (INil)))) +(let t2868 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2867 (ICons t1623 (INil))))) +(let t2869 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2867 (ICons t1624 (INil))))) +(let t2870 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2869 (ICons t2867 (INil))))) +(let t2871 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2870 (ICons t1625 (INil))))) +(let t2872 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2868 (ICons t2871 (INil))))) +(let t2873 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2872 (ICons t1626 (INil))))) +(let t2874 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2873 (ICons t1627 (INil))))) +(let t2875 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2874 (INil)))) +(let t2876 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2875 (ICons t1628 (INil))))) +(let t2877 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2876 (INil)))) +(let t2878 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2867 (ICons t2877 (INil))))) +(let t2879 (Op (LoopInput 0 74 (F32)) (ICons t242 (ICons t398 (ICons t554 (ICons t710 (ICons t866 (INil)))))))) +(let t2880 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2864 (ICons t2879 (INil))))) +(let t2881 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2880 (INil)))) +(let t2882 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2878 (ICons t2881 (INil))))) +(let t2883 (Op (LoopInput 0 75 (F32)) (ICons t246 (ICons t402 (ICons t558 (ICons t714 (ICons t870 (INil)))))))) +(let t2884 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t2882 (ICons t2883 (INil))))) +(let t2885 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2884 (INil)))) +(let t2886 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2885 (ICons t2885 (INil))))) +(let t2887 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2886 (INil)))) +(let t2888 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2887 (ICons t1631 (INil))))) +(let t2889 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2888 (ICons t1632 (INil))))) +(let t2890 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2889 (INil)))) +(let t2891 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2890 (INil)))) +(let t2892 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2891 (ICons t2885 (INil))))) +(let t2893 (Op (LoopInput 0 76 (F32)) (ICons t266 (ICons t422 (ICons t578 (ICons t734 (ICons t890 (INil)))))))) +(let t2894 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2892 (ICons t2893 (INil))))) +(let t2895 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2855 (ICons t2894 (INil))))) +(let t2896 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2895 (ICons t2895 (INil))))) +(let t2897 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2896 (INil)))) +(let t2898 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2897 (ICons t1635 (INil))))) +(let t2899 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2898 (ICons t1636 (INil))))) +(let t2900 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2899 (INil)))) +(let t2901 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2900 (INil)))) +(let t2902 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2901 (ICons t2895 (INil))))) +(let t2903 (Op (LoopInput 0 77 (F32)) (ICons t286 (ICons t442 (ICons t598 (ICons t754 (ICons t910 (INil)))))))) +(let t2904 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2902 (ICons t2903 (INil))))) +(let t2905 (Op (LoopInput 0 78 (F32)) (ICons t274 (ICons t430 (ICons t586 (ICons t742 (ICons t898 (INil)))))))) +(let t2906 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2904 (ICons t2905 (INil))))) +(let t2907 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t2906 (INil)))) +(let t2908 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2907 (ICons t2907 (INil))))) +(let t2909 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2908 (INil)))) +(let t2910 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2909 (ICons t1639 (INil))))) +(let t2911 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2910 (ICons t1640 (INil))))) +(let t2912 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2911 (INil)))) +(let t2913 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2912 (INil)))) +(let t2914 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2913 (ICons t2907 (INil))))) +(let t2915 (Op (LoopInput 0 79 (F32)) (ICons t276 (ICons t432 (ICons t588 (ICons t744 (ICons t900 (INil)))))))) +(let t2916 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2904 (ICons t2915 (INil))))) +(let t2917 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2916 (INil)))) +(let t2918 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2917 (ICons t2917 (INil))))) +(let t2919 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2918 (INil)))) +(let t2920 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2919 (ICons t1643 (INil))))) +(let t2921 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2920 (ICons t1644 (INil))))) +(let t2922 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2921 (INil)))) +(let t2923 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t2922 (INil)))) +(let t2924 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2923 (ICons t2917 (INil))))) +(let t2925 (Op (LoopInput 0 80 (F32)) (ICons t278 (ICons t434 (ICons t590 (ICons t746 (ICons t902 (INil)))))))) +(let t2926 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2904 (ICons t2925 (INil))))) +(let t2927 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t2926 (INil)))) +(let t2928 (Op (LoopInput 0 81 (F32)) (ICons t282 (ICons t438 (ICons t594 (ICons t750 (ICons t906 (INil)))))))) +(let t2929 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2914 (ICons t2928 (INil))))) +(let t2930 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1660 (ICons t2929 (INil))))) +(let t2931 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2929 (ICons t1665 (INil))))) +(let t2932 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2930 (ICons t1666 (INil))))) +(let t2933 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2932 (ICons t1667 (INil))))) +(let t2934 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2931 (ICons t2933 (INil))))) +(let t2935 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2930 (ICons t1665 (INil))))) +(let t2936 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2929 (ICons t1666 (INil))))) +(let t2937 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2935 (ICons t2936 (INil))))) +(let t2938 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1668 (ICons t2934 (INil))))) +(let t2939 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2938 (ICons t1670 (INil))))) +(let t2940 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1671 (ICons t2937 (INil))))) +(let t2941 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2940 (ICons t1673 (INil))))) +(let t2942 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2939 (ICons t2941 (INil))))) +(let t2943 (Op (LoopInput 0 82 (F32)) (ICons t284 (ICons t440 (ICons t596 (ICons t752 (ICons t908 (INil)))))))) +(let t2944 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2924 (ICons t2943 (INil))))) +(let t2945 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1689 (ICons t2944 (INil))))) +(let t2946 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2944 (ICons t1694 (INil))))) +(let t2947 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2945 (ICons t1695 (INil))))) +(let t2948 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2947 (ICons t1696 (INil))))) +(let t2949 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2946 (ICons t2948 (INil))))) +(let t2950 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2945 (ICons t1694 (INil))))) +(let t2951 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2944 (ICons t1695 (INil))))) +(let t2952 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2950 (ICons t2951 (INil))))) +(let t2953 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1697 (ICons t2949 (INil))))) +(let t2954 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2953 (ICons t1699 (INil))))) +(let t2955 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1700 (ICons t2952 (INil))))) +(let t2956 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2955 (ICons t1702 (INil))))) +(let t2957 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2954 (ICons t2956 (INil))))) +(let t2958 (Op (LoopInput 0 83 (F32)) (ICons t22 (ICons t46 (ICons t70 (ICons t94 (ICons t118 (INil)))))))) +(let t2959 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t2958 (ICons t1713 (ICons t2957 (INil)))))) +(let t2960 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t2942 (ICons t2959 (INil))))) +(let t2961 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2960 (INil)))) +(let t2962 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2961 (ICons t1714 (INil))))) +(let t2963 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2962 (ICons t1725 (INil))))) +(let t2964 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2963 (INil)))) +(let t2965 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2964 (ICons t1726 (INil))))) +(let t2966 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2963 (ICons t2965 (INil))))) +(let t2967 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2966 (ICons t1727 (INil))))) +(let t2968 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2967 (INil)))) +(let t2969 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t2968 (INil)))) +(let t2970 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2969 (INil)))) +(let t2971 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t2968 (ICons t2970 (INil))))) +(let t2972 (Op (LoopInput 0 84 (F32)) (ICons t24 (ICons t48 (ICons t72 (ICons t96 (ICons t120 (INil)))))))) +(let t2973 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t2972 (ICons t1713 (ICons t2927 (INil)))))) +(let t2974 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t2971 (ICons t2973 (INil))))) +(let t2975 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2974 (INil)))) +(let t2976 (Op (LoopInput 0 85 (F32)) (ICons t280 (ICons t436 (ICons t592 (ICons t748 (ICons t904 (INil)))))))) +(let t2977 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t2975 (ICons t2976 (INil))))) +(let t2978 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2977 (INil)))) +(let t2979 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2978 (ICons t2978 (INil))))) +(let t2980 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2979 (INil)))) +(let t2981 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2980 (ICons t1730 (INil))))) +(let t2982 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2981 (ICons t1731 (INil))))) +(let t2983 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2982 (INil)))) +(let t2984 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2983 (INil)))) +(let t2985 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2984 (ICons t2978 (INil))))) +(let t2986 (Op (LoopInput 0 86 (F32)) (ICons t288 (ICons t444 (ICons t600 (ICons t756 (ICons t912 (INil)))))))) +(let t2987 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2985 (ICons t2986 (INil))))) +(let t2988 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2895 (ICons t2987 (INil))))) +(let t2989 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2988 (ICons t2988 (INil))))) +(let t2990 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t2989 (INil)))) +(let t2991 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2990 (ICons t1734 (INil))))) +(let t2992 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2991 (ICons t1735 (INil))))) +(let t2993 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2992 (INil)))) +(let t2994 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2993 (INil)))) +(let t2995 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2994 (ICons t2988 (INil))))) +(let t2996 (Op (LoopInput 0 87 (F32)) (ICons t290 (ICons t446 (ICons t602 (ICons t758 (ICons t914 (INil)))))))) +(let t2997 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2995 (ICons t2996 (INil))))) +(let t2998 (Op (LoopInput 0 88 (F32)) (ICons t270 (ICons t426 (ICons t582 (ICons t738 (ICons t894 (INil)))))))) +(let t2999 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2997 (ICons t2998 (INil))))) +(let t3000 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t2999 (INil)))) +(let t3001 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3000 (ICons t1736 (INil))))) +(let t3002 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3000 (ICons t1737 (INil))))) +(let t3003 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3002 (ICons t3000 (INil))))) +(let t3004 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3003 (ICons t1738 (INil))))) +(let t3005 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3001 (ICons t3004 (INil))))) +(let t3006 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3005 (ICons t1739 (INil))))) +(let t3007 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3006 (ICons t1740 (INil))))) +(let t3008 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3007 (INil)))) +(let t3009 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3008 (ICons t1741 (INil))))) +(let t3010 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3009 (INil)))) +(let t3011 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3000 (ICons t3010 (INil))))) +(let t3012 (Op (LoopInput 0 89 (F32)) (ICons t268 (ICons t424 (ICons t580 (ICons t736 (ICons t892 (INil)))))))) +(let t3013 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t2997 (ICons t3012 (INil))))) +(let t3014 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3013 (INil)))) +(let t3015 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3011 (ICons t3014 (INil))))) +(let t3016 (Op (LoopInput 0 90 (F32)) (ICons t272 (ICons t428 (ICons t584 (ICons t740 (ICons t896 (INil)))))))) +(let t3017 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t3015 (ICons t3016 (INil))))) +(let t3018 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3017 (INil)))) +(let t3019 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3018 (ICons t3018 (INil))))) +(let t3020 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3019 (INil)))) +(let t3021 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3020 (ICons t1744 (INil))))) +(let t3022 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3021 (ICons t1745 (INil))))) +(let t3023 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3022 (INil)))) +(let t3024 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3023 (INil)))) +(let t3025 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3024 (ICons t3018 (INil))))) +(let t3026 (Op (LoopInput 0 91 (F32)) (ICons t292 (ICons t448 (ICons t604 (ICons t760 (ICons t916 (INil)))))))) +(let t3027 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3025 (ICons t3026 (INil))))) +(let t3028 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t2988 (ICons t3027 (INil))))) +(let t3029 (LoopEnd t3028 0 0 (F32))) +(let t3030 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3029 (ICons t3029 (INil))))) +(let t3031 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3030 (INil)))) +(let t3032 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3031 (ICons t1748 (INil))))) +(let t3033 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3032 (ICons t1749 (INil))))) +(let t3034 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3033 (INil)))) +(let t3035 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3034 (INil)))) +(let t3036 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3035 (ICons t3029 (INil))))) +(let t3037 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3036 (ICons t936 (INil))))) +(let t3038 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3037 (ICons t924 (INil))))) +(let t3039 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3038 (INil)))) +(let t3040 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3037 (ICons t926 (INil))))) +(let t3041 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3040 (INil)))) +(let t3042 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3037 (ICons t928 (INil))))) +(let t3043 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3042 (INil)))) +(let t3044 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3039 (ICons t3039 (INil))))) +(let t3045 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3044 (INil)))) +(let t3046 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3045 (ICons t1752 (INil))))) +(let t3047 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3046 (ICons t1753 (INil))))) +(let t3048 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3047 (INil)))) +(let t3049 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3048 (INil)))) +(let t3050 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3049 (ICons t3039 (INil))))) +(let t3051 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3050 (ICons t932 (INil))))) +(let t3052 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3041 (ICons t3041 (INil))))) +(let t3053 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3052 (INil)))) +(let t3054 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3053 (ICons t1756 (INil))))) +(let t3055 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3054 (ICons t1757 (INil))))) +(let t3056 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3055 (INil)))) +(let t3057 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3056 (INil)))) +(let t3058 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3057 (ICons t3041 (INil))))) +(let t3059 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3058 (ICons t934 (INil))))) +(let t3060 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1773 (ICons t3051 (INil))))) +(let t3061 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3051 (ICons t1778 (INil))))) +(let t3062 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3060 (ICons t1779 (INil))))) +(let t3063 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3062 (ICons t1780 (INil))))) +(let t3064 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3061 (ICons t3063 (INil))))) +(let t3065 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3060 (ICons t1778 (INil))))) +(let t3066 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3051 (ICons t1779 (INil))))) +(let t3067 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3065 (ICons t3066 (INil))))) +(let t3068 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1781 (ICons t3064 (INil))))) +(let t3069 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3068 (ICons t1783 (INil))))) +(let t3070 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1784 (ICons t3067 (INil))))) +(let t3071 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3070 (ICons t1786 (INil))))) +(let t3072 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3069 (ICons t3071 (INil))))) +(let t3073 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1802 (ICons t3059 (INil))))) +(let t3074 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3059 (ICons t1807 (INil))))) +(let t3075 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3073 (ICons t1808 (INil))))) +(let t3076 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3075 (ICons t1809 (INil))))) +(let t3077 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3074 (ICons t3076 (INil))))) +(let t3078 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3073 (ICons t1807 (INil))))) +(let t3079 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3059 (ICons t1808 (INil))))) +(let t3080 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3078 (ICons t3079 (INil))))) +(let t3081 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1810 (ICons t3077 (INil))))) +(let t3082 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3081 (ICons t1812 (INil))))) +(let t3083 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1813 (ICons t3080 (INil))))) +(let t3084 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3083 (ICons t1815 (INil))))) +(let t3085 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3082 (ICons t3084 (INil))))) +(let t3086 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t122 (ICons t1826 (ICons t3085 (INil)))))) +(let t3087 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t124 (ICons t1826 (ICons t3043 (INil)))))) +(let t3088 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3072 (ICons t3086 (INil))))) +(let t3089 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3088 (INil)))) +(let t3090 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3089 (ICons t1827 (INil))))) +(let t3091 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3090 (ICons t1845 (INil))))) +(let t3092 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3091 (INil)))) +(let t3093 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3092 (ICons t1846 (INil))))) +(let t3094 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3091 (ICons t3093 (INil))))) +(let t3095 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3094 (ICons t1847 (INil))))) +(let t3096 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3095 (INil)))) +(let t3097 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3096 (INil)))) +(let t3098 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3097 (INil)))) +(let t3099 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3096 (ICons t3098 (INil))))) +(let t3100 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3099 (ICons t3087 (INil))))) +(let t3101 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3100 (INil)))) +(let t3102 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t3101 (ICons t930 (INil))))) +(let t3103 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3102 (INil)))) +(let t3104 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3103 (ICons t3103 (INil))))) +(let t3105 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3104 (INil)))) +(let t3106 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3105 (ICons t1850 (INil))))) +(let t3107 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3106 (ICons t1851 (INil))))) +(let t3108 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3107 (INil)))) +(let t3109 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3108 (INil)))) +(let t3110 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3109 (ICons t3103 (INil))))) +(let t3111 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3110 (ICons t938 (INil))))) +(let t3112 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3029 (ICons t3111 (INil))))) +(let t3113 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3112 (ICons t3112 (INil))))) +(let t3114 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3113 (INil)))) +(let t3115 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3114 (ICons t1854 (INil))))) +(let t3116 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3115 (ICons t1855 (INil))))) +(let t3117 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3116 (INil)))) +(let t3118 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3117 (INil)))) +(let t3119 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3118 (ICons t3112 (INil))))) +(let t3120 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3119 (ICons t940 (INil))))) +(let t3121 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3120 (ICons t920 (INil))))) +(let t3122 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3121 (INil)))) +(let t3123 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3122 (ICons t1856 (INil))))) +(let t3124 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3122 (ICons t1857 (INil))))) +(let t3125 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3124 (ICons t3122 (INil))))) +(let t3126 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3125 (ICons t1858 (INil))))) +(let t3127 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3123 (ICons t3126 (INil))))) +(let t3128 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3127 (ICons t1859 (INil))))) +(let t3129 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3128 (ICons t1860 (INil))))) +(let t3130 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3129 (INil)))) +(let t3131 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3130 (ICons t1861 (INil))))) +(let t3132 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3131 (INil)))) +(let t3133 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3122 (ICons t3132 (INil))))) +(let t3134 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3120 (ICons t918 (INil))))) +(let t3135 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3134 (INil)))) +(let t3136 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3133 (ICons t3135 (INil))))) +(let t3137 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t3136 (ICons t922 (INil))))) +(let t3138 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3137 (INil)))) +(let t3139 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3138 (ICons t3138 (INil))))) +(let t3140 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3139 (INil)))) +(let t3141 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3140 (ICons t1864 (INil))))) +(let t3142 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3141 (ICons t1865 (INil))))) +(let t3143 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3142 (INil)))) +(let t3144 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3143 (INil)))) +(let t3145 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3144 (ICons t3138 (INil))))) +(let t3146 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3145 (ICons t942 (INil))))) +(let t3147 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3112 (ICons t3146 (INil))))) +(let t3148 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3147 (ICons t3147 (INil))))) +(let t3149 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3148 (INil)))) +(let t3150 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3149 (ICons t1868 (INil))))) +(let t3151 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3150 (ICons t1869 (INil))))) +(let t3152 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3151 (INil)))) +(let t3153 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3152 (INil)))) +(let t3154 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3153 (ICons t3147 (INil))))) +(let t3155 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3154 (ICons t962 (INil))))) +(let t3156 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3155 (ICons t950 (INil))))) +(let t3157 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3156 (INil)))) +(let t3158 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3155 (ICons t952 (INil))))) +(let t3159 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3158 (INil)))) +(let t3160 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3155 (ICons t954 (INil))))) +(let t3161 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3160 (INil)))) +(let t3162 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3157 (ICons t3157 (INil))))) +(let t3163 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3162 (INil)))) +(let t3164 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3163 (ICons t1872 (INil))))) +(let t3165 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3164 (ICons t1873 (INil))))) +(let t3166 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3165 (INil)))) +(let t3167 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3166 (INil)))) +(let t3168 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3167 (ICons t3157 (INil))))) +(let t3169 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3168 (ICons t958 (INil))))) +(let t3170 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3159 (ICons t3159 (INil))))) +(let t3171 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3170 (INil)))) +(let t3172 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3171 (ICons t1876 (INil))))) +(let t3173 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3172 (ICons t1877 (INil))))) +(let t3174 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3173 (INil)))) +(let t3175 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3174 (INil)))) +(let t3176 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3175 (ICons t3159 (INil))))) +(let t3177 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3176 (ICons t960 (INil))))) +(let t3178 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1893 (ICons t3169 (INil))))) +(let t3179 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3169 (ICons t1898 (INil))))) +(let t3180 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3178 (ICons t1899 (INil))))) +(let t3181 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3180 (ICons t1900 (INil))))) +(let t3182 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3179 (ICons t3181 (INil))))) +(let t3183 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3178 (ICons t1898 (INil))))) +(let t3184 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3169 (ICons t1899 (INil))))) +(let t3185 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3183 (ICons t3184 (INil))))) +(let t3186 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1901 (ICons t3182 (INil))))) +(let t3187 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3186 (ICons t1903 (INil))))) +(let t3188 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1904 (ICons t3185 (INil))))) +(let t3189 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3188 (ICons t1906 (INil))))) +(let t3190 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3187 (ICons t3189 (INil))))) +(let t3191 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1922 (ICons t3177 (INil))))) +(let t3192 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3177 (ICons t1927 (INil))))) +(let t3193 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3191 (ICons t1928 (INil))))) +(let t3194 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3193 (ICons t1929 (INil))))) +(let t3195 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3192 (ICons t3194 (INil))))) +(let t3196 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3191 (ICons t1927 (INil))))) +(let t3197 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3177 (ICons t1928 (INil))))) +(let t3198 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3196 (ICons t3197 (INil))))) +(let t3199 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1930 (ICons t3195 (INil))))) +(let t3200 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3199 (ICons t1932 (INil))))) +(let t3201 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1933 (ICons t3198 (INil))))) +(let t3202 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3201 (ICons t1935 (INil))))) +(let t3203 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3200 (ICons t3202 (INil))))) +(let t3204 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t126 (ICons t1946 (ICons t3203 (INil)))))) +(let t3205 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t128 (ICons t1946 (ICons t3161 (INil)))))) +(let t3206 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3190 (ICons t3204 (INil))))) +(let t3207 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3206 (INil)))) +(let t3208 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3207 (ICons t1947 (INil))))) +(let t3209 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3208 (ICons t1965 (INil))))) +(let t3210 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3209 (INil)))) +(let t3211 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3210 (ICons t1966 (INil))))) +(let t3212 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3209 (ICons t3211 (INil))))) +(let t3213 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3212 (ICons t1967 (INil))))) +(let t3214 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3213 (INil)))) +(let t3215 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3214 (INil)))) +(let t3216 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3215 (INil)))) +(let t3217 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3214 (ICons t3216 (INil))))) +(let t3218 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3217 (ICons t3205 (INil))))) +(let t3219 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3218 (INil)))) +(let t3220 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t3219 (ICons t956 (INil))))) +(let t3221 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3220 (INil)))) +(let t3222 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3221 (ICons t3221 (INil))))) +(let t3223 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3222 (INil)))) +(let t3224 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3223 (ICons t1970 (INil))))) +(let t3225 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3224 (ICons t1971 (INil))))) +(let t3226 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3225 (INil)))) +(let t3227 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3226 (INil)))) +(let t3228 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3227 (ICons t3221 (INil))))) +(let t3229 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3228 (ICons t964 (INil))))) +(let t3230 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3147 (ICons t3229 (INil))))) +(let t3231 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3230 (ICons t3230 (INil))))) +(let t3232 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3231 (INil)))) +(let t3233 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3232 (ICons t1974 (INil))))) +(let t3234 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3233 (ICons t1975 (INil))))) +(let t3235 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3234 (INil)))) +(let t3236 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3235 (INil)))) +(let t3237 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3236 (ICons t3230 (INil))))) +(let t3238 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3237 (ICons t966 (INil))))) +(let t3239 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3238 (ICons t946 (INil))))) +(let t3240 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3239 (INil)))) +(let t3241 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3240 (ICons t1976 (INil))))) +(let t3242 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3240 (ICons t1977 (INil))))) +(let t3243 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3242 (ICons t3240 (INil))))) +(let t3244 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3243 (ICons t1978 (INil))))) +(let t3245 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3241 (ICons t3244 (INil))))) +(let t3246 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3245 (ICons t1979 (INil))))) +(let t3247 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3246 (ICons t1980 (INil))))) +(let t3248 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3247 (INil)))) +(let t3249 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3248 (ICons t1981 (INil))))) +(let t3250 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3249 (INil)))) +(let t3251 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3240 (ICons t3250 (INil))))) +(let t3252 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3238 (ICons t944 (INil))))) +(let t3253 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3252 (INil)))) +(let t3254 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3251 (ICons t3253 (INil))))) +(let t3255 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t3254 (ICons t948 (INil))))) +(let t3256 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3255 (INil)))) +(let t3257 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3256 (ICons t3256 (INil))))) +(let t3258 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3257 (INil)))) +(let t3259 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3258 (ICons t1984 (INil))))) +(let t3260 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3259 (ICons t1985 (INil))))) +(let t3261 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3260 (INil)))) +(let t3262 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3261 (INil)))) +(let t3263 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3262 (ICons t3256 (INil))))) +(let t3264 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3263 (ICons t968 (INil))))) +(let t3265 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3230 (ICons t3264 (INil))))) +(let t3266 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3265 (ICons t3265 (INil))))) +(let t3267 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3266 (INil)))) +(let t3268 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3267 (ICons t1988 (INil))))) +(let t3269 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3268 (ICons t1989 (INil))))) +(let t3270 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3269 (INil)))) +(let t3271 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3270 (INil)))) +(let t3272 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3271 (ICons t3265 (INil))))) +(let t3273 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3272 (ICons t988 (INil))))) +(let t3274 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3273 (ICons t976 (INil))))) +(let t3275 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3274 (INil)))) +(let t3276 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3273 (ICons t978 (INil))))) +(let t3277 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3276 (INil)))) +(let t3278 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3273 (ICons t980 (INil))))) +(let t3279 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3278 (INil)))) +(let t3280 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3275 (ICons t3275 (INil))))) +(let t3281 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3280 (INil)))) +(let t3282 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3281 (ICons t1992 (INil))))) +(let t3283 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3282 (ICons t1993 (INil))))) +(let t3284 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3283 (INil)))) +(let t3285 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3284 (INil)))) +(let t3286 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3285 (ICons t3275 (INil))))) +(let t3287 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3286 (ICons t984 (INil))))) +(let t3288 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3277 (ICons t3277 (INil))))) +(let t3289 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3288 (INil)))) +(let t3290 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3289 (ICons t1996 (INil))))) +(let t3291 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3290 (ICons t1997 (INil))))) +(let t3292 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3291 (INil)))) +(let t3293 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3292 (INil)))) +(let t3294 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3293 (ICons t3277 (INil))))) +(let t3295 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3294 (ICons t986 (INil))))) +(let t3296 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2013 (ICons t3287 (INil))))) +(let t3297 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3287 (ICons t2018 (INil))))) +(let t3298 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3296 (ICons t2019 (INil))))) +(let t3299 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3298 (ICons t2020 (INil))))) +(let t3300 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3297 (ICons t3299 (INil))))) +(let t3301 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3296 (ICons t2018 (INil))))) +(let t3302 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3287 (ICons t2019 (INil))))) +(let t3303 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3301 (ICons t3302 (INil))))) +(let t3304 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2021 (ICons t3300 (INil))))) +(let t3305 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3304 (ICons t2023 (INil))))) +(let t3306 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2024 (ICons t3303 (INil))))) +(let t3307 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3306 (ICons t2026 (INil))))) +(let t3308 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3305 (ICons t3307 (INil))))) +(let t3309 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t2042 (ICons t3295 (INil))))) +(let t3310 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3295 (ICons t2047 (INil))))) +(let t3311 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3309 (ICons t2048 (INil))))) +(let t3312 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3311 (ICons t2049 (INil))))) +(let t3313 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3310 (ICons t3312 (INil))))) +(let t3314 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3309 (ICons t2047 (INil))))) +(let t3315 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3295 (ICons t2048 (INil))))) +(let t3316 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3314 (ICons t3315 (INil))))) +(let t3317 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2050 (ICons t3313 (INil))))) +(let t3318 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3317 (ICons t2052 (INil))))) +(let t3319 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2053 (ICons t3316 (INil))))) +(let t3320 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3319 (ICons t2055 (INil))))) +(let t3321 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3318 (ICons t3320 (INil))))) +(let t3322 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t130 (ICons t2066 (ICons t3321 (INil)))))) +(let t3323 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t132 (ICons t2066 (ICons t3279 (INil)))))) +(let t3324 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3308 (ICons t3322 (INil))))) +(let t3325 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3324 (INil)))) +(let t3326 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3325 (ICons t2067 (INil))))) +(let t3327 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3326 (ICons t2085 (INil))))) +(let t3328 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3327 (INil)))) +(let t3329 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3328 (ICons t2086 (INil))))) +(let t3330 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3327 (ICons t3329 (INil))))) +(let t3331 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3330 (ICons t2087 (INil))))) +(let t3332 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3331 (INil)))) +(let t3333 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3332 (INil)))) +(let t3334 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3333 (INil)))) +(let t3335 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3332 (ICons t3334 (INil))))) +(let t3336 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3335 (ICons t3323 (INil))))) +(let t3337 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3336 (INil)))) +(let t3338 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t3337 (ICons t982 (INil))))) +(let t3339 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3338 (INil)))) +(let t3340 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3339 (ICons t3339 (INil))))) +(let t3341 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3340 (INil)))) +(let t3342 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3341 (ICons t2090 (INil))))) +(let t3343 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3342 (ICons t2091 (INil))))) +(let t3344 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3343 (INil)))) +(let t3345 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3344 (INil)))) +(let t3346 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3345 (ICons t3339 (INil))))) +(let t3347 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3346 (ICons t990 (INil))))) +(let t3348 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3265 (ICons t3347 (INil))))) +(let t3349 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3348 (ICons t3348 (INil))))) +(let t3350 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3349 (INil)))) +(let t3351 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3350 (ICons t2094 (INil))))) +(let t3352 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3351 (ICons t2095 (INil))))) +(let t3353 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3352 (INil)))) +(let t3354 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3353 (INil)))) +(let t3355 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3354 (ICons t3348 (INil))))) +(let t3356 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3355 (ICons t992 (INil))))) +(let t3357 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3356 (ICons t972 (INil))))) +(let t3358 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3357 (INil)))) +(let t3359 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3358 (ICons t2096 (INil))))) +(let t3360 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3358 (ICons t2097 (INil))))) +(let t3361 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3360 (ICons t3358 (INil))))) +(let t3362 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3361 (ICons t2098 (INil))))) +(let t3363 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3359 (ICons t3362 (INil))))) +(let t3364 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3363 (ICons t2099 (INil))))) +(let t3365 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3364 (ICons t2100 (INil))))) +(let t3366 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3365 (INil)))) +(let t3367 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3366 (ICons t2101 (INil))))) +(let t3368 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3367 (INil)))) +(let t3369 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3358 (ICons t3368 (INil))))) +(let t3370 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3356 (ICons t970 (INil))))) +(let t3371 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3370 (INil)))) +(let t3372 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3369 (ICons t3371 (INil))))) +(let t3373 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t3372 (ICons t974 (INil))))) +(let t3374 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3373 (INil)))) +(let t3375 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3374 (ICons t3374 (INil))))) +(let t3376 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3375 (INil)))) +(let t3377 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3376 (ICons t2104 (INil))))) +(let t3378 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3377 (ICons t2105 (INil))))) +(let t3379 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3378 (INil)))) +(let t3380 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3379 (INil)))) +(let t3381 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3380 (ICons t3374 (INil))))) +(let t3382 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3381 (ICons t994 (INil))))) +(let t3383 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3348 (ICons t3382 (INil))))) +(let t3384 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3383 (ICons t3383 (INil))))) +(let t3385 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3384 (INil)))) +(let t3386 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3385 (ICons t2108 (INil))))) +(let t3387 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3386 (ICons t2109 (INil))))) +(let t3388 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3387 (INil)))) +(let t3389 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3388 (INil)))) +(let t3390 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3389 (ICons t3383 (INil))))) +(let t3391 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3390 (ICons t1014 (INil))))) +(let t3392 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3391 (ICons t1002 (INil))))) +(let t3393 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3392 (INil)))) +(let t3394 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3391 (ICons t1004 (INil))))) +(let t3395 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3394 (INil)))) +(let t3396 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3391 (ICons t1006 (INil))))) +(let t3397 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t3396 (INil)))) +(let t3398 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3393 (ICons t3393 (INil))))) +(let t3399 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3398 (INil)))) +(let t3400 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3399 (ICons t2112 (INil))))) +(let t3401 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3400 (ICons t2113 (INil))))) +(let t3402 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3401 (INil)))) +(let t3403 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3402 (INil)))) +(let t3404 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3403 (ICons t3393 (INil))))) +(let t3405 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3404 (ICons t1010 (INil))))) +(let t3406 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3395 (ICons t3395 (INil))))) +(let t3407 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3406 (INil)))) +(let t3408 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3407 (ICons t2116 (INil))))) +(let t3409 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3408 (ICons t2117 (INil))))) +(let t3410 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3409 (INil)))) +(let t3411 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t3410 (INil)))) +(let t3412 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3411 (ICons t3395 (INil))))) +(let t3413 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3412 (ICons t1012 (INil))))) +(let t3414 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2133 (ICons t3405 (INil))))) +(let t3415 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3405 (ICons t2138 (INil))))) +(let t3416 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3414 (ICons t2139 (INil))))) +(let t3417 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3416 (ICons t2140 (INil))))) +(let t3418 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3415 (ICons t3417 (INil))))) +(let t3419 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3414 (ICons t2138 (INil))))) +(let t3420 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3405 (ICons t2139 (INil))))) +(let t3421 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3419 (ICons t3420 (INil))))) +(let t3422 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2141 (ICons t3418 (INil))))) +(let t3423 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3422 (ICons t2143 (INil))))) +(let t3424 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2144 (ICons t3421 (INil))))) +(let t3425 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3424 (ICons t2146 (INil))))) +(let t3426 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3423 (ICons t3425 (INil))))) +(let t3427 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t2162 (ICons t3413 (INil))))) +(let t3428 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3413 (ICons t2167 (INil))))) +(let t3429 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3427 (ICons t2168 (INil))))) +(let t3430 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3429 (ICons t2169 (INil))))) +(let t3431 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3428 (ICons t3430 (INil))))) +(let t3432 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3427 (ICons t2167 (INil))))) +(let t3433 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3413 (ICons t2168 (INil))))) +(let t3434 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3432 (ICons t3433 (INil))))) +(let t3435 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2170 (ICons t3431 (INil))))) +(let t3436 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3435 (ICons t2172 (INil))))) +(let t3437 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2173 (ICons t3434 (INil))))) +(let t3438 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3437 (ICons t2175 (INil))))) +(let t3439 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3436 (ICons t3438 (INil))))) +(let t3440 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t134 (ICons t2186 (ICons t3439 (INil)))))) +(let t3441 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t136 (ICons t2186 (ICons t3397 (INil)))))) +(let t3442 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3426 (ICons t3440 (INil))))) +(let t3443 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3442 (INil)))) +(let t3444 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3443 (ICons t2187 (INil))))) +(let t3445 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3444 (ICons t2205 (INil))))) +(let t3446 (Op (Max (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3445 (INil)))) +(let t3447 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3446 (ICons t2206 (INil))))) +(let t3448 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3445 (ICons t3447 (INil))))) +(let t3449 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3448 (ICons t2207 (INil))))) +(let t3450 (Op (Exp2 (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3449 (INil)))) +(let t3451 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3450 (INil)))) +(let t3452 (Op (Recip (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3451 (INil)))) +(let t3453 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3450 (ICons t3452 (INil))))) +(let t3454 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3453 (ICons t3441 (INil))))) +(let t3455 (Op (Sum (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3454 (INil)))) +(let t3456 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t3455 (ICons t1008 (INil))))) +(let t3457 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 2560)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3456 (INil)))) +(let t3458 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3457 (ICons t3457 (INil))))) +(let t3459 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3458 (INil)))) +(let t3460 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3459 (ICons t2210 (INil))))) +(let t3461 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3460 (ICons t2211 (INil))))) +(let t3462 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3461 (INil)))) +(let t3463 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3462 (INil)))) +(let t3464 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3463 (ICons t3457 (INil))))) +(let t3465 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3464 (ICons t1016 (INil))))) +(let t3466 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3383 (ICons t3465 (INil))))) +(let t3467 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3466 (ICons t3466 (INil))))) +(let t3468 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3467 (INil)))) +(let t3469 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3468 (ICons t2214 (INil))))) +(let t3470 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3469 (ICons t2215 (INil))))) +(let t3471 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3470 (INil)))) +(let t3472 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3471 (INil)))) +(let t3473 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3472 (ICons t3466 (INil))))) +(let t3474 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3473 (ICons t1018 (INil))))) +(let t3475 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3474 (ICons t998 (INil))))) +(let t3476 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3475 (INil)))) +(let t3477 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3476 (ICons t2216 (INil))))) +(let t3478 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3476 (ICons t2217 (INil))))) +(let t3479 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3478 (ICons t3476 (INil))))) +(let t3480 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3479 (ICons t2218 (INil))))) +(let t3481 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3477 (ICons t3480 (INil))))) +(let t3482 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3481 (ICons t2219 (INil))))) +(let t3483 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3482 (ICons t2220 (INil))))) +(let t3484 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3483 (INil)))) +(let t3485 (Op (Add (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3484 (ICons t2221 (INil))))) +(let t3486 (Op (Recip (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3485 (INil)))) +(let t3487 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3476 (ICons t3486 (INil))))) +(let t3488 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3474 (ICons t996 (INil))))) +(let t3489 (Op (Sum (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 10240)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3488 (INil)))) +(let t3490 (Op (Mul (ECons (MVar "s") (ECons (MNum 10240) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ICons t3487 (ICons t3489 (INil))))) +(let t3491 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 10240) (ENil)))) (ECons (MMul (MIter) (MNum 10240)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ECons (MIter) (ENil))))) (ICons t3490 (ICons t1000 (INil))))) +(let t3492 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 10240) (ECons (MMul (MMul (MIter) (MNum 10240)) (MNum 2560)) (ECons (MMul (MIter) (MNum 10240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3491 (INil)))) +(let t3493 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3492 (ICons t3492 (INil))))) +(let t3494 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3493 (INil)))) +(let t3495 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3494 (ICons t2224 (INil))))) +(let t3496 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3495 (ICons t2225 (INil))))) +(let t3497 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3496 (INil)))) +(let t3498 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3497 (INil)))) +(let t3499 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3498 (ICons t3492 (INil))))) +(let t3500 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3499 (ICons t1020 (INil))))) +(let t3501 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3466 (ICons t3500 (INil))))) +(let t3502 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3501 (ICons t3501 (INil))))) +(let t3503 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3502 (INil)))) +(let t3504 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3503 (ICons t2228 (INil))))) +(let t3505 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3504 (ICons t2229 (INil))))) +(let t3506 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3505 (INil)))) +(let t3507 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3506 (INil)))) +(let t3508 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3507 (ICons t3501 (INil))))) +(let t3509 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t3508 (ICons t1022 (INil))))) +(let t3510 (Op (Mul (ECons (MVar "s") (ECons (MNum 262208) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 262208)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t3509 (ICons t1026 (INil))))) +(let t3511 (Op (Sum (ECons (MVar "s") (ECons (MNum 262208) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 262208)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 262208)) (ECons (MIter) (ENil)))) (ICons t3510 (INil)))) +(let t3512 (Output t3511 9103)) +(let t3513 (Output t3086 8275)) +(let t3514 (Output t3087 8276)) +(let t3515 (Output t3204 8513)) +(let t3516 (Output t3205 8514)) +(let t3517 (Output t3322 8751)) +(let t3518 (Output t3323 8752)) +(let t3519 (Output t3440 8989)) +(let t3520 (Output t3441 8990)) +(let t3521 (Op (LoopOutput 0 0 (F32)) (ICons t2294 (INil)))) +(let t3522 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t3521 (INil)))) +(let t3523 (Output t3522 1170)) +(let t3524 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t3521 (INil)))) +(let t3525 (Output t3524 2591)) +(let t3526 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t3521 (INil)))) +(let t3527 (Output t3526 4012)) +(let t3528 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t3521 (INil)))) +(let t3529 (Output t3528 5433)) +(let t3530 (Op (LoopOutputSelect 0 0 4 (F32)) (ICons t3521 (INil)))) +(let t3531 (Output t3530 6854)) +(let t3532 (Op (LoopOutput 0 1 (F32)) (ICons t2308 (INil)))) +(let t3533 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t3532 (INil)))) +(let t3534 (Output t3533 1171)) +(let t3535 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t3532 (INil)))) +(let t3536 (Output t3535 2592)) +(let t3537 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t3532 (INil)))) +(let t3538 (Output t3537 4013)) +(let t3539 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t3532 (INil)))) +(let t3540 (Output t3539 5434)) +(let t3541 (Op (LoopOutputSelect 0 1 4 (F32)) (ICons t3532 (INil)))) +(let t3542 (Output t3541 6855)) +(let t3543 (Op (LoopOutput 0 2 (F32)) (ICons t2427 (INil)))) +(let t3544 (Op (LoopOutputSelect 0 2 0 (F32)) (ICons t3543 (INil)))) +(let t3545 (Output t3544 1408)) +(let t3546 (Op (LoopOutputSelect 0 2 1 (F32)) (ICons t3543 (INil)))) +(let t3547 (Output t3546 2829)) +(let t3548 (Op (LoopOutputSelect 0 2 2 (F32)) (ICons t3543 (INil)))) +(let t3549 (Output t3548 4250)) +(let t3550 (Op (LoopOutputSelect 0 2 3 (F32)) (ICons t3543 (INil)))) +(let t3551 (Output t3550 5671)) +(let t3552 (Op (LoopOutputSelect 0 2 4 (F32)) (ICons t3543 (INil)))) +(let t3553 (Output t3552 7092)) +(let t3554 (Op (LoopOutput 0 3 (F32)) (ICons t2441 (INil)))) +(let t3555 (Op (LoopOutputSelect 0 3 0 (F32)) (ICons t3554 (INil)))) +(let t3556 (Output t3555 1409)) +(let t3557 (Op (LoopOutputSelect 0 3 1 (F32)) (ICons t3554 (INil)))) +(let t3558 (Output t3557 2830)) +(let t3559 (Op (LoopOutputSelect 0 3 2 (F32)) (ICons t3554 (INil)))) +(let t3560 (Output t3559 4251)) +(let t3561 (Op (LoopOutputSelect 0 3 3 (F32)) (ICons t3554 (INil)))) +(let t3562 (Output t3561 5672)) +(let t3563 (Op (LoopOutputSelect 0 3 4 (F32)) (ICons t3554 (INil)))) +(let t3564 (Output t3563 7093)) +(let t3565 (Op (LoopOutput 0 4 (F32)) (ICons t2560 (INil)))) +(let t3566 (Op (LoopOutputSelect 0 4 0 (F32)) (ICons t3565 (INil)))) +(let t3567 (Output t3566 1646)) +(let t3568 (Op (LoopOutputSelect 0 4 1 (F32)) (ICons t3565 (INil)))) +(let t3569 (Output t3568 3067)) +(let t3570 (Op (LoopOutputSelect 0 4 2 (F32)) (ICons t3565 (INil)))) +(let t3571 (Output t3570 4488)) +(let t3572 (Op (LoopOutputSelect 0 4 3 (F32)) (ICons t3565 (INil)))) +(let t3573 (Output t3572 5909)) +(let t3574 (Op (LoopOutputSelect 0 4 4 (F32)) (ICons t3565 (INil)))) +(let t3575 (Output t3574 7330)) +(let t3576 (Op (LoopOutput 0 5 (F32)) (ICons t2574 (INil)))) +(let t3577 (Op (LoopOutputSelect 0 5 0 (F32)) (ICons t3576 (INil)))) +(let t3578 (Output t3577 1647)) +(let t3579 (Op (LoopOutputSelect 0 5 1 (F32)) (ICons t3576 (INil)))) +(let t3580 (Output t3579 3068)) +(let t3581 (Op (LoopOutputSelect 0 5 2 (F32)) (ICons t3576 (INil)))) +(let t3582 (Output t3581 4489)) +(let t3583 (Op (LoopOutputSelect 0 5 3 (F32)) (ICons t3576 (INil)))) +(let t3584 (Output t3583 5910)) +(let t3585 (Op (LoopOutputSelect 0 5 4 (F32)) (ICons t3576 (INil)))) +(let t3586 (Output t3585 7331)) +(let t3587 (Op (LoopOutput 0 6 (F32)) (ICons t2693 (INil)))) +(let t3588 (Op (LoopOutputSelect 0 6 0 (F32)) (ICons t3587 (INil)))) +(let t3589 (Output t3588 1884)) +(let t3590 (Op (LoopOutputSelect 0 6 1 (F32)) (ICons t3587 (INil)))) +(let t3591 (Output t3590 3305)) +(let t3592 (Op (LoopOutputSelect 0 6 2 (F32)) (ICons t3587 (INil)))) +(let t3593 (Output t3592 4726)) +(let t3594 (Op (LoopOutputSelect 0 6 3 (F32)) (ICons t3587 (INil)))) +(let t3595 (Output t3594 6147)) +(let t3596 (Op (LoopOutputSelect 0 6 4 (F32)) (ICons t3587 (INil)))) +(let t3597 (Output t3596 7568)) +(let t3598 (Op (LoopOutput 0 7 (F32)) (ICons t2707 (INil)))) +(let t3599 (Op (LoopOutputSelect 0 7 0 (F32)) (ICons t3598 (INil)))) +(let t3600 (Output t3599 1885)) +(let t3601 (Op (LoopOutputSelect 0 7 1 (F32)) (ICons t3598 (INil)))) +(let t3602 (Output t3601 3306)) +(let t3603 (Op (LoopOutputSelect 0 7 2 (F32)) (ICons t3598 (INil)))) +(let t3604 (Output t3603 4727)) +(let t3605 (Op (LoopOutputSelect 0 7 3 (F32)) (ICons t3598 (INil)))) +(let t3606 (Output t3605 6148)) +(let t3607 (Op (LoopOutputSelect 0 7 4 (F32)) (ICons t3598 (INil)))) +(let t3608 (Output t3607 7569)) +(let t3609 (Op (LoopOutput 0 8 (F32)) (ICons t2826 (INil)))) +(let t3610 (Op (LoopOutputSelect 0 8 0 (F32)) (ICons t3609 (INil)))) +(let t3611 (Output t3610 2122)) +(let t3612 (Op (LoopOutputSelect 0 8 1 (F32)) (ICons t3609 (INil)))) +(let t3613 (Output t3612 3543)) +(let t3614 (Op (LoopOutputSelect 0 8 2 (F32)) (ICons t3609 (INil)))) +(let t3615 (Output t3614 4964)) +(let t3616 (Op (LoopOutputSelect 0 8 3 (F32)) (ICons t3609 (INil)))) +(let t3617 (Output t3616 6385)) +(let t3618 (Op (LoopOutputSelect 0 8 4 (F32)) (ICons t3609 (INil)))) +(let t3619 (Output t3618 7806)) +(let t3620 (Op (LoopOutput 0 9 (F32)) (ICons t2840 (INil)))) +(let t3621 (Op (LoopOutputSelect 0 9 0 (F32)) (ICons t3620 (INil)))) +(let t3622 (Output t3621 2123)) +(let t3623 (Op (LoopOutputSelect 0 9 1 (F32)) (ICons t3620 (INil)))) +(let t3624 (Output t3623 3544)) +(let t3625 (Op (LoopOutputSelect 0 9 2 (F32)) (ICons t3620 (INil)))) +(let t3626 (Output t3625 4965)) +(let t3627 (Op (LoopOutputSelect 0 9 3 (F32)) (ICons t3620 (INil)))) +(let t3628 (Output t3627 6386)) +(let t3629 (Op (LoopOutputSelect 0 9 4 (F32)) (ICons t3620 (INil)))) +(let t3630 (Output t3629 7807)) +(let t3631 (Op (LoopOutput 0 10 (F32)) (ICons t2959 (INil)))) +(let t3632 (Op (LoopOutputSelect 0 10 0 (F32)) (ICons t3631 (INil)))) +(let t3633 (Output t3632 2360)) +(let t3634 (Op (LoopOutputSelect 0 10 1 (F32)) (ICons t3631 (INil)))) +(let t3635 (Output t3634 3781)) +(let t3636 (Op (LoopOutputSelect 0 10 2 (F32)) (ICons t3631 (INil)))) +(let t3637 (Output t3636 5202)) +(let t3638 (Op (LoopOutputSelect 0 10 3 (F32)) (ICons t3631 (INil)))) +(let t3639 (Output t3638 6623)) +(let t3640 (Op (LoopOutputSelect 0 10 4 (F32)) (ICons t3631 (INil)))) +(let t3641 (Output t3640 8044)) +(let t3642 (Op (LoopOutput 0 11 (F32)) (ICons t2973 (INil)))) +(let t3643 (Op (LoopOutputSelect 0 11 0 (F32)) (ICons t3642 (INil)))) +(let t3644 (Output t3643 2361)) +(let t3645 (Op (LoopOutputSelect 0 11 1 (F32)) (ICons t3642 (INil)))) +(let t3646 (Output t3645 3782)) +(let t3647 (Op (LoopOutputSelect 0 11 2 (F32)) (ICons t3642 (INil)))) +(let t3648 (Output t3647 5203)) +(let t3649 (Op (LoopOutputSelect 0 11 3 (F32)) (ICons t3642 (INil)))) +(let t3650 (Output t3649 6624)) +(let t3651 (Op (LoopOutputSelect 0 11 4 (F32)) (ICons t3642 (INil)))) +(let t3652 (Output t3651 8045)) +(let t3654 (OutputJoin t3 t5)) +(let t3655 (OutputJoin t3654 t7)) +(let t3656 (OutputJoin t3655 t9)) +(let t3657 (OutputJoin t3656 t11)) +(let t3658 (OutputJoin t3657 t13)) +(let t3659 (OutputJoin t3658 t15)) +(let t3660 (OutputJoin t3659 t17)) +(let t3661 (OutputJoin t3660 t19)) +(let t3662 (OutputJoin t3661 t21)) +(let t3663 (OutputJoin t3662 t23)) +(let t3664 (OutputJoin t3663 t25)) +(let t3665 (OutputJoin t3664 t27)) +(let t3666 (OutputJoin t3665 t29)) +(let t3667 (OutputJoin t3666 t31)) +(let t3668 (OutputJoin t3667 t33)) +(let t3669 (OutputJoin t3668 t35)) +(let t3670 (OutputJoin t3669 t37)) +(let t3671 (OutputJoin t3670 t39)) +(let t3672 (OutputJoin t3671 t41)) +(let t3673 (OutputJoin t3672 t43)) +(let t3674 (OutputJoin t3673 t45)) +(let t3675 (OutputJoin t3674 t47)) +(let t3676 (OutputJoin t3675 t49)) +(let t3677 (OutputJoin t3676 t51)) +(let t3678 (OutputJoin t3677 t53)) +(let t3679 (OutputJoin t3678 t55)) +(let t3680 (OutputJoin t3679 t57)) +(let t3681 (OutputJoin t3680 t59)) +(let t3682 (OutputJoin t3681 t61)) +(let t3683 (OutputJoin t3682 t63)) +(let t3684 (OutputJoin t3683 t65)) +(let t3685 (OutputJoin t3684 t67)) +(let t3686 (OutputJoin t3685 t69)) +(let t3687 (OutputJoin t3686 t71)) +(let t3688 (OutputJoin t3687 t73)) +(let t3689 (OutputJoin t3688 t75)) +(let t3690 (OutputJoin t3689 t77)) +(let t3691 (OutputJoin t3690 t79)) +(let t3692 (OutputJoin t3691 t81)) +(let t3693 (OutputJoin t3692 t83)) +(let t3694 (OutputJoin t3693 t85)) +(let t3695 (OutputJoin t3694 t87)) +(let t3696 (OutputJoin t3695 t89)) +(let t3697 (OutputJoin t3696 t91)) +(let t3698 (OutputJoin t3697 t93)) +(let t3699 (OutputJoin t3698 t95)) +(let t3700 (OutputJoin t3699 t97)) +(let t3701 (OutputJoin t3700 t99)) +(let t3702 (OutputJoin t3701 t101)) +(let t3703 (OutputJoin t3702 t103)) +(let t3704 (OutputJoin t3703 t105)) +(let t3705 (OutputJoin t3704 t107)) +(let t3706 (OutputJoin t3705 t109)) +(let t3707 (OutputJoin t3706 t111)) +(let t3708 (OutputJoin t3707 t113)) +(let t3709 (OutputJoin t3708 t115)) +(let t3710 (OutputJoin t3709 t117)) +(let t3711 (OutputJoin t3710 t119)) +(let t3712 (OutputJoin t3711 t121)) +(let t3713 (OutputJoin t3712 t123)) +(let t3714 (OutputJoin t3713 t125)) +(let t3715 (OutputJoin t3714 t127)) +(let t3716 (OutputJoin t3715 t129)) +(let t3717 (OutputJoin t3716 t131)) +(let t3718 (OutputJoin t3717 t133)) +(let t3719 (OutputJoin t3718 t135)) +(let t3720 (OutputJoin t3719 t137)) +(let t3721 (OutputJoin t3720 t139)) +(let t3722 (OutputJoin t3721 t141)) +(let t3723 (OutputJoin t3722 t143)) +(let t3724 (OutputJoin t3723 t145)) +(let t3725 (OutputJoin t3724 t147)) +(let t3726 (OutputJoin t3725 t149)) +(let t3727 (OutputJoin t3726 t151)) +(let t3728 (OutputJoin t3727 t153)) +(let t3729 (OutputJoin t3728 t155)) +(let t3730 (OutputJoin t3729 t157)) +(let t3731 (OutputJoin t3730 t159)) +(let t3732 (OutputJoin t3731 t161)) +(let t3733 (OutputJoin t3732 t163)) +(let t3734 (OutputJoin t3733 t165)) +(let t3735 (OutputJoin t3734 t167)) +(let t3736 (OutputJoin t3735 t169)) +(let t3737 (OutputJoin t3736 t171)) +(let t3738 (OutputJoin t3737 t173)) +(let t3739 (OutputJoin t3738 t175)) +(let t3740 (OutputJoin t3739 t177)) +(let t3741 (OutputJoin t3740 t179)) +(let t3742 (OutputJoin t3741 t181)) +(let t3743 (OutputJoin t3742 t183)) +(let t3744 (OutputJoin t3743 t185)) +(let t3745 (OutputJoin t3744 t187)) +(let t3746 (OutputJoin t3745 t189)) +(let t3747 (OutputJoin t3746 t191)) +(let t3748 (OutputJoin t3747 t193)) +(let t3749 (OutputJoin t3748 t195)) +(let t3750 (OutputJoin t3749 t197)) +(let t3751 (OutputJoin t3750 t199)) +(let t3752 (OutputJoin t3751 t201)) +(let t3753 (OutputJoin t3752 t203)) +(let t3754 (OutputJoin t3753 t205)) +(let t3755 (OutputJoin t3754 t207)) +(let t3756 (OutputJoin t3755 t209)) +(let t3757 (OutputJoin t3756 t211)) +(let t3758 (OutputJoin t3757 t213)) +(let t3759 (OutputJoin t3758 t215)) +(let t3760 (OutputJoin t3759 t217)) +(let t3761 (OutputJoin t3760 t219)) +(let t3762 (OutputJoin t3761 t221)) +(let t3763 (OutputJoin t3762 t223)) +(let t3764 (OutputJoin t3763 t225)) +(let t3765 (OutputJoin t3764 t227)) +(let t3766 (OutputJoin t3765 t229)) +(let t3767 (OutputJoin t3766 t231)) +(let t3768 (OutputJoin t3767 t233)) +(let t3769 (OutputJoin t3768 t235)) +(let t3770 (OutputJoin t3769 t237)) +(let t3771 (OutputJoin t3770 t239)) +(let t3772 (OutputJoin t3771 t241)) +(let t3773 (OutputJoin t3772 t243)) +(let t3774 (OutputJoin t3773 t245)) +(let t3775 (OutputJoin t3774 t247)) +(let t3776 (OutputJoin t3775 t249)) +(let t3777 (OutputJoin t3776 t251)) +(let t3778 (OutputJoin t3777 t253)) +(let t3779 (OutputJoin t3778 t255)) +(let t3780 (OutputJoin t3779 t257)) +(let t3781 (OutputJoin t3780 t259)) +(let t3782 (OutputJoin t3781 t261)) +(let t3783 (OutputJoin t3782 t263)) +(let t3784 (OutputJoin t3783 t265)) +(let t3785 (OutputJoin t3784 t267)) +(let t3786 (OutputJoin t3785 t269)) +(let t3787 (OutputJoin t3786 t271)) +(let t3788 (OutputJoin t3787 t273)) +(let t3789 (OutputJoin t3788 t275)) +(let t3790 (OutputJoin t3789 t277)) +(let t3791 (OutputJoin t3790 t279)) +(let t3792 (OutputJoin t3791 t281)) +(let t3793 (OutputJoin t3792 t283)) +(let t3794 (OutputJoin t3793 t285)) +(let t3795 (OutputJoin t3794 t287)) +(let t3796 (OutputJoin t3795 t289)) +(let t3797 (OutputJoin t3796 t291)) +(let t3798 (OutputJoin t3797 t293)) +(let t3799 (OutputJoin t3798 t295)) +(let t3800 (OutputJoin t3799 t297)) +(let t3801 (OutputJoin t3800 t299)) +(let t3802 (OutputJoin t3801 t301)) +(let t3803 (OutputJoin t3802 t303)) +(let t3804 (OutputJoin t3803 t305)) +(let t3805 (OutputJoin t3804 t307)) +(let t3806 (OutputJoin t3805 t309)) +(let t3807 (OutputJoin t3806 t311)) +(let t3808 (OutputJoin t3807 t313)) +(let t3809 (OutputJoin t3808 t315)) +(let t3810 (OutputJoin t3809 t317)) +(let t3811 (OutputJoin t3810 t319)) +(let t3812 (OutputJoin t3811 t321)) +(let t3813 (OutputJoin t3812 t323)) +(let t3814 (OutputJoin t3813 t325)) +(let t3815 (OutputJoin t3814 t327)) +(let t3816 (OutputJoin t3815 t329)) +(let t3817 (OutputJoin t3816 t331)) +(let t3818 (OutputJoin t3817 t333)) +(let t3819 (OutputJoin t3818 t335)) +(let t3820 (OutputJoin t3819 t337)) +(let t3821 (OutputJoin t3820 t339)) +(let t3822 (OutputJoin t3821 t341)) +(let t3823 (OutputJoin t3822 t343)) +(let t3824 (OutputJoin t3823 t345)) +(let t3825 (OutputJoin t3824 t347)) +(let t3826 (OutputJoin t3825 t349)) +(let t3827 (OutputJoin t3826 t351)) +(let t3828 (OutputJoin t3827 t353)) +(let t3829 (OutputJoin t3828 t355)) +(let t3830 (OutputJoin t3829 t357)) +(let t3831 (OutputJoin t3830 t359)) +(let t3832 (OutputJoin t3831 t361)) +(let t3833 (OutputJoin t3832 t363)) +(let t3834 (OutputJoin t3833 t365)) +(let t3835 (OutputJoin t3834 t367)) +(let t3836 (OutputJoin t3835 t369)) +(let t3837 (OutputJoin t3836 t371)) +(let t3838 (OutputJoin t3837 t373)) +(let t3839 (OutputJoin t3838 t375)) +(let t3840 (OutputJoin t3839 t377)) +(let t3841 (OutputJoin t3840 t379)) +(let t3842 (OutputJoin t3841 t381)) +(let t3843 (OutputJoin t3842 t383)) +(let t3844 (OutputJoin t3843 t385)) +(let t3845 (OutputJoin t3844 t387)) +(let t3846 (OutputJoin t3845 t389)) +(let t3847 (OutputJoin t3846 t391)) +(let t3848 (OutputJoin t3847 t393)) +(let t3849 (OutputJoin t3848 t395)) +(let t3850 (OutputJoin t3849 t397)) +(let t3851 (OutputJoin t3850 t399)) +(let t3852 (OutputJoin t3851 t401)) +(let t3853 (OutputJoin t3852 t403)) +(let t3854 (OutputJoin t3853 t405)) +(let t3855 (OutputJoin t3854 t407)) +(let t3856 (OutputJoin t3855 t409)) +(let t3857 (OutputJoin t3856 t411)) +(let t3858 (OutputJoin t3857 t413)) +(let t3859 (OutputJoin t3858 t415)) +(let t3860 (OutputJoin t3859 t417)) +(let t3861 (OutputJoin t3860 t419)) +(let t3862 (OutputJoin t3861 t421)) +(let t3863 (OutputJoin t3862 t423)) +(let t3864 (OutputJoin t3863 t425)) +(let t3865 (OutputJoin t3864 t427)) +(let t3866 (OutputJoin t3865 t429)) +(let t3867 (OutputJoin t3866 t431)) +(let t3868 (OutputJoin t3867 t433)) +(let t3869 (OutputJoin t3868 t435)) +(let t3870 (OutputJoin t3869 t437)) +(let t3871 (OutputJoin t3870 t439)) +(let t3872 (OutputJoin t3871 t441)) +(let t3873 (OutputJoin t3872 t443)) +(let t3874 (OutputJoin t3873 t445)) +(let t3875 (OutputJoin t3874 t447)) +(let t3876 (OutputJoin t3875 t449)) +(let t3877 (OutputJoin t3876 t451)) +(let t3878 (OutputJoin t3877 t453)) +(let t3879 (OutputJoin t3878 t455)) +(let t3880 (OutputJoin t3879 t457)) +(let t3881 (OutputJoin t3880 t459)) +(let t3882 (OutputJoin t3881 t461)) +(let t3883 (OutputJoin t3882 t463)) +(let t3884 (OutputJoin t3883 t465)) +(let t3885 (OutputJoin t3884 t467)) +(let t3886 (OutputJoin t3885 t469)) +(let t3887 (OutputJoin t3886 t471)) +(let t3888 (OutputJoin t3887 t473)) +(let t3889 (OutputJoin t3888 t475)) +(let t3890 (OutputJoin t3889 t477)) +(let t3891 (OutputJoin t3890 t479)) +(let t3892 (OutputJoin t3891 t481)) +(let t3893 (OutputJoin t3892 t483)) +(let t3894 (OutputJoin t3893 t485)) +(let t3895 (OutputJoin t3894 t487)) +(let t3896 (OutputJoin t3895 t489)) +(let t3897 (OutputJoin t3896 t491)) +(let t3898 (OutputJoin t3897 t493)) +(let t3899 (OutputJoin t3898 t495)) +(let t3900 (OutputJoin t3899 t497)) +(let t3901 (OutputJoin t3900 t499)) +(let t3902 (OutputJoin t3901 t501)) +(let t3903 (OutputJoin t3902 t503)) +(let t3904 (OutputJoin t3903 t505)) +(let t3905 (OutputJoin t3904 t507)) +(let t3906 (OutputJoin t3905 t509)) +(let t3907 (OutputJoin t3906 t511)) +(let t3908 (OutputJoin t3907 t513)) +(let t3909 (OutputJoin t3908 t515)) +(let t3910 (OutputJoin t3909 t517)) +(let t3911 (OutputJoin t3910 t519)) +(let t3912 (OutputJoin t3911 t521)) +(let t3913 (OutputJoin t3912 t523)) +(let t3914 (OutputJoin t3913 t525)) +(let t3915 (OutputJoin t3914 t527)) +(let t3916 (OutputJoin t3915 t529)) +(let t3917 (OutputJoin t3916 t531)) +(let t3918 (OutputJoin t3917 t533)) +(let t3919 (OutputJoin t3918 t535)) +(let t3920 (OutputJoin t3919 t537)) +(let t3921 (OutputJoin t3920 t539)) +(let t3922 (OutputJoin t3921 t541)) +(let t3923 (OutputJoin t3922 t543)) +(let t3924 (OutputJoin t3923 t545)) +(let t3925 (OutputJoin t3924 t547)) +(let t3926 (OutputJoin t3925 t549)) +(let t3927 (OutputJoin t3926 t551)) +(let t3928 (OutputJoin t3927 t553)) +(let t3929 (OutputJoin t3928 t555)) +(let t3930 (OutputJoin t3929 t557)) +(let t3931 (OutputJoin t3930 t559)) +(let t3932 (OutputJoin t3931 t561)) +(let t3933 (OutputJoin t3932 t563)) +(let t3934 (OutputJoin t3933 t565)) +(let t3935 (OutputJoin t3934 t567)) +(let t3936 (OutputJoin t3935 t569)) +(let t3937 (OutputJoin t3936 t571)) +(let t3938 (OutputJoin t3937 t573)) +(let t3939 (OutputJoin t3938 t575)) +(let t3940 (OutputJoin t3939 t577)) +(let t3941 (OutputJoin t3940 t579)) +(let t3942 (OutputJoin t3941 t581)) +(let t3943 (OutputJoin t3942 t583)) +(let t3944 (OutputJoin t3943 t585)) +(let t3945 (OutputJoin t3944 t587)) +(let t3946 (OutputJoin t3945 t589)) +(let t3947 (OutputJoin t3946 t591)) +(let t3948 (OutputJoin t3947 t593)) +(let t3949 (OutputJoin t3948 t595)) +(let t3950 (OutputJoin t3949 t597)) +(let t3951 (OutputJoin t3950 t599)) +(let t3952 (OutputJoin t3951 t601)) +(let t3953 (OutputJoin t3952 t603)) +(let t3954 (OutputJoin t3953 t605)) +(let t3955 (OutputJoin t3954 t607)) +(let t3956 (OutputJoin t3955 t609)) +(let t3957 (OutputJoin t3956 t611)) +(let t3958 (OutputJoin t3957 t613)) +(let t3959 (OutputJoin t3958 t615)) +(let t3960 (OutputJoin t3959 t617)) +(let t3961 (OutputJoin t3960 t619)) +(let t3962 (OutputJoin t3961 t621)) +(let t3963 (OutputJoin t3962 t623)) +(let t3964 (OutputJoin t3963 t625)) +(let t3965 (OutputJoin t3964 t627)) +(let t3966 (OutputJoin t3965 t629)) +(let t3967 (OutputJoin t3966 t631)) +(let t3968 (OutputJoin t3967 t633)) +(let t3969 (OutputJoin t3968 t635)) +(let t3970 (OutputJoin t3969 t637)) +(let t3971 (OutputJoin t3970 t639)) +(let t3972 (OutputJoin t3971 t641)) +(let t3973 (OutputJoin t3972 t643)) +(let t3974 (OutputJoin t3973 t645)) +(let t3975 (OutputJoin t3974 t647)) +(let t3976 (OutputJoin t3975 t649)) +(let t3977 (OutputJoin t3976 t651)) +(let t3978 (OutputJoin t3977 t653)) +(let t3979 (OutputJoin t3978 t655)) +(let t3980 (OutputJoin t3979 t657)) +(let t3981 (OutputJoin t3980 t659)) +(let t3982 (OutputJoin t3981 t661)) +(let t3983 (OutputJoin t3982 t663)) +(let t3984 (OutputJoin t3983 t665)) +(let t3985 (OutputJoin t3984 t667)) +(let t3986 (OutputJoin t3985 t669)) +(let t3987 (OutputJoin t3986 t671)) +(let t3988 (OutputJoin t3987 t673)) +(let t3989 (OutputJoin t3988 t675)) +(let t3990 (OutputJoin t3989 t677)) +(let t3991 (OutputJoin t3990 t679)) +(let t3992 (OutputJoin t3991 t681)) +(let t3993 (OutputJoin t3992 t683)) +(let t3994 (OutputJoin t3993 t685)) +(let t3995 (OutputJoin t3994 t687)) +(let t3996 (OutputJoin t3995 t689)) +(let t3997 (OutputJoin t3996 t691)) +(let t3998 (OutputJoin t3997 t693)) +(let t3999 (OutputJoin t3998 t695)) +(let t4000 (OutputJoin t3999 t697)) +(let t4001 (OutputJoin t4000 t699)) +(let t4002 (OutputJoin t4001 t701)) +(let t4003 (OutputJoin t4002 t703)) +(let t4004 (OutputJoin t4003 t705)) +(let t4005 (OutputJoin t4004 t707)) +(let t4006 (OutputJoin t4005 t709)) +(let t4007 (OutputJoin t4006 t711)) +(let t4008 (OutputJoin t4007 t713)) +(let t4009 (OutputJoin t4008 t715)) +(let t4010 (OutputJoin t4009 t717)) +(let t4011 (OutputJoin t4010 t719)) +(let t4012 (OutputJoin t4011 t721)) +(let t4013 (OutputJoin t4012 t723)) +(let t4014 (OutputJoin t4013 t725)) +(let t4015 (OutputJoin t4014 t727)) +(let t4016 (OutputJoin t4015 t729)) +(let t4017 (OutputJoin t4016 t731)) +(let t4018 (OutputJoin t4017 t733)) +(let t4019 (OutputJoin t4018 t735)) +(let t4020 (OutputJoin t4019 t737)) +(let t4021 (OutputJoin t4020 t739)) +(let t4022 (OutputJoin t4021 t741)) +(let t4023 (OutputJoin t4022 t743)) +(let t4024 (OutputJoin t4023 t745)) +(let t4025 (OutputJoin t4024 t747)) +(let t4026 (OutputJoin t4025 t749)) +(let t4027 (OutputJoin t4026 t751)) +(let t4028 (OutputJoin t4027 t753)) +(let t4029 (OutputJoin t4028 t755)) +(let t4030 (OutputJoin t4029 t757)) +(let t4031 (OutputJoin t4030 t759)) +(let t4032 (OutputJoin t4031 t761)) +(let t4033 (OutputJoin t4032 t763)) +(let t4034 (OutputJoin t4033 t765)) +(let t4035 (OutputJoin t4034 t767)) +(let t4036 (OutputJoin t4035 t769)) +(let t4037 (OutputJoin t4036 t771)) +(let t4038 (OutputJoin t4037 t773)) +(let t4039 (OutputJoin t4038 t775)) +(let t4040 (OutputJoin t4039 t777)) +(let t4041 (OutputJoin t4040 t779)) +(let t4042 (OutputJoin t4041 t781)) +(let t4043 (OutputJoin t4042 t783)) +(let t4044 (OutputJoin t4043 t785)) +(let t4045 (OutputJoin t4044 t787)) +(let t4046 (OutputJoin t4045 t789)) +(let t4047 (OutputJoin t4046 t791)) +(let t4048 (OutputJoin t4047 t793)) +(let t4049 (OutputJoin t4048 t795)) +(let t4050 (OutputJoin t4049 t797)) +(let t4051 (OutputJoin t4050 t799)) +(let t4052 (OutputJoin t4051 t801)) +(let t4053 (OutputJoin t4052 t803)) +(let t4054 (OutputJoin t4053 t805)) +(let t4055 (OutputJoin t4054 t807)) +(let t4056 (OutputJoin t4055 t809)) +(let t4057 (OutputJoin t4056 t811)) +(let t4058 (OutputJoin t4057 t813)) +(let t4059 (OutputJoin t4058 t815)) +(let t4060 (OutputJoin t4059 t817)) +(let t4061 (OutputJoin t4060 t819)) +(let t4062 (OutputJoin t4061 t821)) +(let t4063 (OutputJoin t4062 t823)) +(let t4064 (OutputJoin t4063 t825)) +(let t4065 (OutputJoin t4064 t827)) +(let t4066 (OutputJoin t4065 t829)) +(let t4067 (OutputJoin t4066 t831)) +(let t4068 (OutputJoin t4067 t833)) +(let t4069 (OutputJoin t4068 t835)) +(let t4070 (OutputJoin t4069 t837)) +(let t4071 (OutputJoin t4070 t839)) +(let t4072 (OutputJoin t4071 t841)) +(let t4073 (OutputJoin t4072 t843)) +(let t4074 (OutputJoin t4073 t845)) +(let t4075 (OutputJoin t4074 t847)) +(let t4076 (OutputJoin t4075 t849)) +(let t4077 (OutputJoin t4076 t851)) +(let t4078 (OutputJoin t4077 t853)) +(let t4079 (OutputJoin t4078 t855)) +(let t4080 (OutputJoin t4079 t857)) +(let t4081 (OutputJoin t4080 t859)) +(let t4082 (OutputJoin t4081 t861)) +(let t4083 (OutputJoin t4082 t863)) +(let t4084 (OutputJoin t4083 t865)) +(let t4085 (OutputJoin t4084 t867)) +(let t4086 (OutputJoin t4085 t869)) +(let t4087 (OutputJoin t4086 t871)) +(let t4088 (OutputJoin t4087 t873)) +(let t4089 (OutputJoin t4088 t875)) +(let t4090 (OutputJoin t4089 t877)) +(let t4091 (OutputJoin t4090 t879)) +(let t4092 (OutputJoin t4091 t881)) +(let t4093 (OutputJoin t4092 t883)) +(let t4094 (OutputJoin t4093 t885)) +(let t4095 (OutputJoin t4094 t887)) +(let t4096 (OutputJoin t4095 t889)) +(let t4097 (OutputJoin t4096 t891)) +(let t4098 (OutputJoin t4097 t893)) +(let t4099 (OutputJoin t4098 t895)) +(let t4100 (OutputJoin t4099 t897)) +(let t4101 (OutputJoin t4100 t899)) +(let t4102 (OutputJoin t4101 t901)) +(let t4103 (OutputJoin t4102 t903)) +(let t4104 (OutputJoin t4103 t905)) +(let t4105 (OutputJoin t4104 t907)) +(let t4106 (OutputJoin t4105 t909)) +(let t4107 (OutputJoin t4106 t911)) +(let t4108 (OutputJoin t4107 t913)) +(let t4109 (OutputJoin t4108 t915)) +(let t4110 (OutputJoin t4109 t917)) +(let t4111 (OutputJoin t4110 t919)) +(let t4112 (OutputJoin t4111 t921)) +(let t4113 (OutputJoin t4112 t923)) +(let t4114 (OutputJoin t4113 t925)) +(let t4115 (OutputJoin t4114 t927)) +(let t4116 (OutputJoin t4115 t929)) +(let t4117 (OutputJoin t4116 t931)) +(let t4118 (OutputJoin t4117 t933)) +(let t4119 (OutputJoin t4118 t935)) +(let t4120 (OutputJoin t4119 t937)) +(let t4121 (OutputJoin t4120 t939)) +(let t4122 (OutputJoin t4121 t941)) +(let t4123 (OutputJoin t4122 t943)) +(let t4124 (OutputJoin t4123 t945)) +(let t4125 (OutputJoin t4124 t947)) +(let t4126 (OutputJoin t4125 t949)) +(let t4127 (OutputJoin t4126 t951)) +(let t4128 (OutputJoin t4127 t953)) +(let t4129 (OutputJoin t4128 t955)) +(let t4130 (OutputJoin t4129 t957)) +(let t4131 (OutputJoin t4130 t959)) +(let t4132 (OutputJoin t4131 t961)) +(let t4133 (OutputJoin t4132 t963)) +(let t4134 (OutputJoin t4133 t965)) +(let t4135 (OutputJoin t4134 t967)) +(let t4136 (OutputJoin t4135 t969)) +(let t4137 (OutputJoin t4136 t971)) +(let t4138 (OutputJoin t4137 t973)) +(let t4139 (OutputJoin t4138 t975)) +(let t4140 (OutputJoin t4139 t977)) +(let t4141 (OutputJoin t4140 t979)) +(let t4142 (OutputJoin t4141 t981)) +(let t4143 (OutputJoin t4142 t983)) +(let t4144 (OutputJoin t4143 t985)) +(let t4145 (OutputJoin t4144 t987)) +(let t4146 (OutputJoin t4145 t989)) +(let t4147 (OutputJoin t4146 t991)) +(let t4148 (OutputJoin t4147 t993)) +(let t4149 (OutputJoin t4148 t995)) +(let t4150 (OutputJoin t4149 t997)) +(let t4151 (OutputJoin t4150 t999)) +(let t4152 (OutputJoin t4151 t1001)) +(let t4153 (OutputJoin t4152 t1003)) +(let t4154 (OutputJoin t4153 t1005)) +(let t4155 (OutputJoin t4154 t1007)) +(let t4156 (OutputJoin t4155 t1009)) +(let t4157 (OutputJoin t4156 t1011)) +(let t4158 (OutputJoin t4157 t1013)) +(let t4159 (OutputJoin t4158 t1015)) +(let t4160 (OutputJoin t4159 t1017)) +(let t4161 (OutputJoin t4160 t1019)) +(let t4162 (OutputJoin t4161 t1021)) +(let t4163 (OutputJoin t4162 t1023)) +(let t4164 (OutputJoin t4163 t1025)) +(let t4165 (OutputJoin t4164 t1027)) +(let t4166 (OutputJoin t4165 t3512)) +(let t4167 (OutputJoin t4166 t3523)) +(let t4168 (OutputJoin t4167 t3534)) +(let t4169 (OutputJoin t4168 t3545)) +(let t4170 (OutputJoin t4169 t3556)) +(let t4171 (OutputJoin t4170 t3567)) +(let t4172 (OutputJoin t4171 t3578)) +(let t4173 (OutputJoin t4172 t3589)) +(let t4174 (OutputJoin t4173 t3600)) +(let t4175 (OutputJoin t4174 t3611)) +(let t4176 (OutputJoin t4175 t3622)) +(let t4177 (OutputJoin t4176 t3633)) +(let t4178 (OutputJoin t4177 t3644)) +(let t4179 (OutputJoin t4178 t3525)) +(let t4180 (OutputJoin t4179 t3536)) +(let t4181 (OutputJoin t4180 t3547)) +(let t4182 (OutputJoin t4181 t3558)) +(let t4183 (OutputJoin t4182 t3569)) +(let t4184 (OutputJoin t4183 t3580)) +(let t4185 (OutputJoin t4184 t3591)) +(let t4186 (OutputJoin t4185 t3602)) +(let t4187 (OutputJoin t4186 t3613)) +(let t4188 (OutputJoin t4187 t3624)) +(let t4189 (OutputJoin t4188 t3635)) +(let t4190 (OutputJoin t4189 t3646)) +(let t4191 (OutputJoin t4190 t3527)) +(let t4192 (OutputJoin t4191 t3538)) +(let t4193 (OutputJoin t4192 t3549)) +(let t4194 (OutputJoin t4193 t3560)) +(let t4195 (OutputJoin t4194 t3571)) +(let t4196 (OutputJoin t4195 t3582)) +(let t4197 (OutputJoin t4196 t3593)) +(let t4198 (OutputJoin t4197 t3604)) +(let t4199 (OutputJoin t4198 t3615)) +(let t4200 (OutputJoin t4199 t3626)) +(let t4201 (OutputJoin t4200 t3637)) +(let t4202 (OutputJoin t4201 t3648)) +(let t4203 (OutputJoin t4202 t3529)) +(let t4204 (OutputJoin t4203 t3540)) +(let t4205 (OutputJoin t4204 t3551)) +(let t4206 (OutputJoin t4205 t3562)) +(let t4207 (OutputJoin t4206 t3573)) +(let t4208 (OutputJoin t4207 t3584)) +(let t4209 (OutputJoin t4208 t3595)) +(let t4210 (OutputJoin t4209 t3606)) +(let t4211 (OutputJoin t4210 t3617)) +(let t4212 (OutputJoin t4211 t3628)) +(let t4213 (OutputJoin t4212 t3639)) +(let t4214 (OutputJoin t4213 t3650)) +(let t4215 (OutputJoin t4214 t3531)) +(let t4216 (OutputJoin t4215 t3542)) +(let t4217 (OutputJoin t4216 t3553)) +(let t4218 (OutputJoin t4217 t3564)) +(let t4219 (OutputJoin t4218 t3575)) +(let t4220 (OutputJoin t4219 t3586)) +(let t4221 (OutputJoin t4220 t3597)) +(let t4222 (OutputJoin t4221 t3608)) +(let t4223 (OutputJoin t4222 t3619)) +(let t4224 (OutputJoin t4223 t3630)) +(let t4225 (OutputJoin t4224 t3641)) +(let t4226 (OutputJoin t4225 t3652)) +(let t4227 (OutputJoin t4226 t3513)) +(let t4228 (OutputJoin t4227 t3514)) +(let t4229 (OutputJoin t4228 t3515)) +(let t4230 (OutputJoin t4229 t3516)) +(let t4231 (OutputJoin t4230 t3517)) +(let t4232 (OutputJoin t4231 t3518)) +(let t4233 (OutputJoin t4232 t3519)) +(let t4234 (OutputJoin t4233 t3520)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/gemma4_moe.egg b/tests/gemma4_moe.egg new file mode 100644 index 00000000..600befe1 --- /dev/null +++ b/tests/gemma4_moe.egg @@ -0,0 +1,7030 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "pos_ids" (Int))) +(let t2 (Input 2 "kv_cache.0.k" (F32))) +(let t3 (Output t2 2)) +(let t4 (Input 4 "kv_cache.0.v" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.1.k" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.2.k" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.v" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.3.k" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.v" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.4.k" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "kv_cache.4.v" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "kv_cache.5.k" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "kv_cache.5.v" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "kv_cache.6.k" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "kv_cache.6.v" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "kv_cache.7.k" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "kv_cache.7.v" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "kv_cache.8.k" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "kv_cache.8.v" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "kv_cache.9.k" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "kv_cache.9.v" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "kv_cache.10.k" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "kv_cache.10.v" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "kv_cache.11.k" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "kv_cache.11.v" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "kv_cache.12.k" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "kv_cache.12.v" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "kv_cache.13.k" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "kv_cache.13.v" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "kv_cache.14.k" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "kv_cache.14.v" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "kv_cache.15.k" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "kv_cache.15.v" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "kv_cache.16.k" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "kv_cache.16.v" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "kv_cache.17.k" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "kv_cache.17.v" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "kv_cache.18.k" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "kv_cache.18.v" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "kv_cache.19.k" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "kv_cache.19.v" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "kv_cache.20.k" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "kv_cache.20.v" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "kv_cache.21.k" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "kv_cache.21.v" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "kv_cache.22.k" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "kv_cache.22.v" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "kv_cache.23.k" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "kv_cache.23.v" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "kv_cache.24.k" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "kv_cache.24.v" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "kv_cache.25.k" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "kv_cache.25.v" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "kv_cache.26.k" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "kv_cache.26.v" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "kv_cache.27.k" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "kv_cache.27.v" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "kv_cache.28.k" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "kv_cache.28.v" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "kv_cache.29.k" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "kv_cache.29.v" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "model.layers.0.mlp.gate_proj.weight" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "model.layers.0.mlp.up_proj.weight" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "model.layers.0.mlp.down_proj.weight" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "model.layers.0.self_attn.q_norm.weight" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "model.layers.0.self_attn.k_norm.weight" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "model.layers.0.layer_scalar" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "model.layers.0.router.scale" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "model.layers.0.router.proj.weight" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "model.layers.0.router.per_expert_scale" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "model.layers.0.experts.gate_up_proj" (Bf16))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "model.layers.0.experts.down_proj" (Bf16))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "model.layers.0.input_layernorm.weight" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "model.layers.0.pre_feedforward_layernorm.weight" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "model.layers.0.post_feedforward_layernorm.weight" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "model.layers.0.post_feedforward_layernorm_1.weight" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "model.layers.0.post_feedforward_layernorm_2.weight" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "model.layers.0.pre_feedforward_layernorm_2.weight" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "model.layers.1.mlp.gate_proj.weight" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "model.layers.1.mlp.up_proj.weight" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "model.layers.1.mlp.down_proj.weight" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "model.layers.1.self_attn.q_norm.weight" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "model.layers.1.self_attn.k_norm.weight" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "model.layers.1.layer_scalar" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "model.layers.1.router.scale" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "model.layers.1.router.proj.weight" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "model.layers.1.router.per_expert_scale" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "model.layers.1.experts.gate_up_proj" (Bf16))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.layers.1.experts.down_proj" (Bf16))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.layers.1.input_layernorm.weight" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.layers.1.pre_feedforward_layernorm.weight" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.layers.1.post_feedforward_layernorm.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.layers.1.post_feedforward_layernorm_1.weight" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.layers.1.post_feedforward_layernorm_2.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.layers.1.pre_feedforward_layernorm_2.weight" (F32))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.layers.2.mlp.gate_proj.weight" (F32))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.layers.2.mlp.up_proj.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.layers.2.mlp.down_proj.weight" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.layers.2.self_attn.q_norm.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.layers.2.self_attn.k_norm.weight" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.layers.2.layer_scalar" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.layers.2.router.scale" (F32))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.layers.2.router.proj.weight" (F32))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.layers.2.router.per_expert_scale" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.layers.2.experts.gate_up_proj" (Bf16))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.layers.2.experts.down_proj" (Bf16))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.layers.2.input_layernorm.weight" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.layers.2.pre_feedforward_layernorm.weight" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.layers.2.post_feedforward_layernorm.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.layers.2.post_feedforward_layernorm_1.weight" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.layers.2.post_feedforward_layernorm_2.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.layers.2.pre_feedforward_layernorm_2.weight" (F32))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.layers.3.mlp.gate_proj.weight" (F32))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.layers.3.mlp.up_proj.weight" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.layers.3.mlp.down_proj.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.layers.3.self_attn.q_norm.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.layers.3.self_attn.k_norm.weight" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.layers.3.layer_scalar" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.layers.3.router.scale" (F32))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.layers.3.router.proj.weight" (F32))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.layers.3.router.per_expert_scale" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.layers.3.experts.gate_up_proj" (Bf16))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.layers.3.experts.down_proj" (Bf16))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.layers.3.input_layernorm.weight" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.layers.3.pre_feedforward_layernorm.weight" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.layers.3.post_feedforward_layernorm.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.layers.3.post_feedforward_layernorm_1.weight" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.layers.3.post_feedforward_layernorm_2.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.layers.3.pre_feedforward_layernorm_2.weight" (F32))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.layers.4.mlp.gate_proj.weight" (F32))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.layers.4.mlp.up_proj.weight" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.layers.4.mlp.down_proj.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.layers.4.self_attn.q_norm.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.layers.4.self_attn.k_norm.weight" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.layers.4.layer_scalar" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.layers.4.router.scale" (F32))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.layers.4.router.proj.weight" (F32))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.layers.4.router.per_expert_scale" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.layers.4.experts.gate_up_proj" (Bf16))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.layers.4.experts.down_proj" (Bf16))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.layers.4.input_layernorm.weight" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.layers.4.pre_feedforward_layernorm.weight" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.layers.4.post_feedforward_layernorm.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.layers.4.post_feedforward_layernorm_1.weight" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.layers.4.post_feedforward_layernorm_2.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.layers.4.pre_feedforward_layernorm_2.weight" (F32))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.layers.5.mlp.gate_proj.weight" (F32))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.layers.5.mlp.up_proj.weight" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.layers.5.mlp.down_proj.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t353 (Output t352 352)) +(let t354 (Input 354 "model.layers.5.self_attn.q_norm.weight" (F32))) +(let t355 (Output t354 354)) +(let t356 (Input 356 "model.layers.5.self_attn.k_norm.weight" (F32))) +(let t357 (Output t356 356)) +(let t358 (Input 358 "model.layers.5.layer_scalar" (F32))) +(let t359 (Output t358 358)) +(let t360 (Input 360 "model.layers.5.router.scale" (F32))) +(let t361 (Output t360 360)) +(let t362 (Input 362 "model.layers.5.router.proj.weight" (F32))) +(let t363 (Output t362 362)) +(let t364 (Input 364 "model.layers.5.router.per_expert_scale" (F32))) +(let t365 (Output t364 364)) +(let t366 (Input 366 "model.layers.5.experts.gate_up_proj" (Bf16))) +(let t367 (Output t366 366)) +(let t368 (Input 368 "model.layers.5.experts.down_proj" (Bf16))) +(let t369 (Output t368 368)) +(let t370 (Input 370 "model.layers.5.input_layernorm.weight" (F32))) +(let t371 (Output t370 370)) +(let t372 (Input 372 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t373 (Output t372 372)) +(let t374 (Input 374 "model.layers.5.pre_feedforward_layernorm.weight" (F32))) +(let t375 (Output t374 374)) +(let t376 (Input 376 "model.layers.5.post_feedforward_layernorm.weight" (F32))) +(let t377 (Output t376 376)) +(let t378 (Input 378 "model.layers.5.post_feedforward_layernorm_1.weight" (F32))) +(let t379 (Output t378 378)) +(let t380 (Input 380 "model.layers.5.post_feedforward_layernorm_2.weight" (F32))) +(let t381 (Output t380 380)) +(let t382 (Input 382 "model.layers.5.pre_feedforward_layernorm_2.weight" (F32))) +(let t383 (Output t382 382)) +(let t384 (Input 384 "model.layers.6.mlp.gate_proj.weight" (F32))) +(let t385 (Output t384 384)) +(let t386 (Input 386 "model.layers.6.mlp.up_proj.weight" (F32))) +(let t387 (Output t386 386)) +(let t388 (Input 388 "model.layers.6.mlp.down_proj.weight" (F32))) +(let t389 (Output t388 388)) +(let t390 (Input 390 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t391 (Output t390 390)) +(let t392 (Input 392 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t393 (Output t392 392)) +(let t394 (Input 394 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t395 (Output t394 394)) +(let t396 (Input 396 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t397 (Output t396 396)) +(let t398 (Input 398 "model.layers.6.self_attn.q_norm.weight" (F32))) +(let t399 (Output t398 398)) +(let t400 (Input 400 "model.layers.6.self_attn.k_norm.weight" (F32))) +(let t401 (Output t400 400)) +(let t402 (Input 402 "model.layers.6.layer_scalar" (F32))) +(let t403 (Output t402 402)) +(let t404 (Input 404 "model.layers.6.router.scale" (F32))) +(let t405 (Output t404 404)) +(let t406 (Input 406 "model.layers.6.router.proj.weight" (F32))) +(let t407 (Output t406 406)) +(let t408 (Input 408 "model.layers.6.router.per_expert_scale" (F32))) +(let t409 (Output t408 408)) +(let t410 (Input 410 "model.layers.6.experts.gate_up_proj" (Bf16))) +(let t411 (Output t410 410)) +(let t412 (Input 412 "model.layers.6.experts.down_proj" (Bf16))) +(let t413 (Output t412 412)) +(let t414 (Input 414 "model.layers.6.input_layernorm.weight" (F32))) +(let t415 (Output t414 414)) +(let t416 (Input 416 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t417 (Output t416 416)) +(let t418 (Input 418 "model.layers.6.pre_feedforward_layernorm.weight" (F32))) +(let t419 (Output t418 418)) +(let t420 (Input 420 "model.layers.6.post_feedforward_layernorm.weight" (F32))) +(let t421 (Output t420 420)) +(let t422 (Input 422 "model.layers.6.post_feedforward_layernorm_1.weight" (F32))) +(let t423 (Output t422 422)) +(let t424 (Input 424 "model.layers.6.post_feedforward_layernorm_2.weight" (F32))) +(let t425 (Output t424 424)) +(let t426 (Input 426 "model.layers.6.pre_feedforward_layernorm_2.weight" (F32))) +(let t427 (Output t426 426)) +(let t428 (Input 428 "model.layers.7.mlp.gate_proj.weight" (F32))) +(let t429 (Output t428 428)) +(let t430 (Input 430 "model.layers.7.mlp.up_proj.weight" (F32))) +(let t431 (Output t430 430)) +(let t432 (Input 432 "model.layers.7.mlp.down_proj.weight" (F32))) +(let t433 (Output t432 432)) +(let t434 (Input 434 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t435 (Output t434 434)) +(let t436 (Input 436 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t437 (Output t436 436)) +(let t438 (Input 438 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t439 (Output t438 438)) +(let t440 (Input 440 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t441 (Output t440 440)) +(let t442 (Input 442 "model.layers.7.self_attn.q_norm.weight" (F32))) +(let t443 (Output t442 442)) +(let t444 (Input 444 "model.layers.7.self_attn.k_norm.weight" (F32))) +(let t445 (Output t444 444)) +(let t446 (Input 446 "model.layers.7.layer_scalar" (F32))) +(let t447 (Output t446 446)) +(let t448 (Input 448 "model.layers.7.router.scale" (F32))) +(let t449 (Output t448 448)) +(let t450 (Input 450 "model.layers.7.router.proj.weight" (F32))) +(let t451 (Output t450 450)) +(let t452 (Input 452 "model.layers.7.router.per_expert_scale" (F32))) +(let t453 (Output t452 452)) +(let t454 (Input 454 "model.layers.7.experts.gate_up_proj" (Bf16))) +(let t455 (Output t454 454)) +(let t456 (Input 456 "model.layers.7.experts.down_proj" (Bf16))) +(let t457 (Output t456 456)) +(let t458 (Input 458 "model.layers.7.input_layernorm.weight" (F32))) +(let t459 (Output t458 458)) +(let t460 (Input 460 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t461 (Output t460 460)) +(let t462 (Input 462 "model.layers.7.pre_feedforward_layernorm.weight" (F32))) +(let t463 (Output t462 462)) +(let t464 (Input 464 "model.layers.7.post_feedforward_layernorm.weight" (F32))) +(let t465 (Output t464 464)) +(let t466 (Input 466 "model.layers.7.post_feedforward_layernorm_1.weight" (F32))) +(let t467 (Output t466 466)) +(let t468 (Input 468 "model.layers.7.post_feedforward_layernorm_2.weight" (F32))) +(let t469 (Output t468 468)) +(let t470 (Input 470 "model.layers.7.pre_feedforward_layernorm_2.weight" (F32))) +(let t471 (Output t470 470)) +(let t472 (Input 472 "model.layers.8.mlp.gate_proj.weight" (F32))) +(let t473 (Output t472 472)) +(let t474 (Input 474 "model.layers.8.mlp.up_proj.weight" (F32))) +(let t475 (Output t474 474)) +(let t476 (Input 476 "model.layers.8.mlp.down_proj.weight" (F32))) +(let t477 (Output t476 476)) +(let t478 (Input 478 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t479 (Output t478 478)) +(let t480 (Input 480 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t481 (Output t480 480)) +(let t482 (Input 482 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t483 (Output t482 482)) +(let t484 (Input 484 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t485 (Output t484 484)) +(let t486 (Input 486 "model.layers.8.self_attn.q_norm.weight" (F32))) +(let t487 (Output t486 486)) +(let t488 (Input 488 "model.layers.8.self_attn.k_norm.weight" (F32))) +(let t489 (Output t488 488)) +(let t490 (Input 490 "model.layers.8.layer_scalar" (F32))) +(let t491 (Output t490 490)) +(let t492 (Input 492 "model.layers.8.router.scale" (F32))) +(let t493 (Output t492 492)) +(let t494 (Input 494 "model.layers.8.router.proj.weight" (F32))) +(let t495 (Output t494 494)) +(let t496 (Input 496 "model.layers.8.router.per_expert_scale" (F32))) +(let t497 (Output t496 496)) +(let t498 (Input 498 "model.layers.8.experts.gate_up_proj" (Bf16))) +(let t499 (Output t498 498)) +(let t500 (Input 500 "model.layers.8.experts.down_proj" (Bf16))) +(let t501 (Output t500 500)) +(let t502 (Input 502 "model.layers.8.input_layernorm.weight" (F32))) +(let t503 (Output t502 502)) +(let t504 (Input 504 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t505 (Output t504 504)) +(let t506 (Input 506 "model.layers.8.pre_feedforward_layernorm.weight" (F32))) +(let t507 (Output t506 506)) +(let t508 (Input 508 "model.layers.8.post_feedforward_layernorm.weight" (F32))) +(let t509 (Output t508 508)) +(let t510 (Input 510 "model.layers.8.post_feedforward_layernorm_1.weight" (F32))) +(let t511 (Output t510 510)) +(let t512 (Input 512 "model.layers.8.post_feedforward_layernorm_2.weight" (F32))) +(let t513 (Output t512 512)) +(let t514 (Input 514 "model.layers.8.pre_feedforward_layernorm_2.weight" (F32))) +(let t515 (Output t514 514)) +(let t516 (Input 516 "model.layers.9.mlp.gate_proj.weight" (F32))) +(let t517 (Output t516 516)) +(let t518 (Input 518 "model.layers.9.mlp.up_proj.weight" (F32))) +(let t519 (Output t518 518)) +(let t520 (Input 520 "model.layers.9.mlp.down_proj.weight" (F32))) +(let t521 (Output t520 520)) +(let t522 (Input 522 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t523 (Output t522 522)) +(let t524 (Input 524 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t525 (Output t524 524)) +(let t526 (Input 526 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t527 (Output t526 526)) +(let t528 (Input 528 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t529 (Output t528 528)) +(let t530 (Input 530 "model.layers.9.self_attn.q_norm.weight" (F32))) +(let t531 (Output t530 530)) +(let t532 (Input 532 "model.layers.9.self_attn.k_norm.weight" (F32))) +(let t533 (Output t532 532)) +(let t534 (Input 534 "model.layers.9.layer_scalar" (F32))) +(let t535 (Output t534 534)) +(let t536 (Input 536 "model.layers.9.router.scale" (F32))) +(let t537 (Output t536 536)) +(let t538 (Input 538 "model.layers.9.router.proj.weight" (F32))) +(let t539 (Output t538 538)) +(let t540 (Input 540 "model.layers.9.router.per_expert_scale" (F32))) +(let t541 (Output t540 540)) +(let t542 (Input 542 "model.layers.9.experts.gate_up_proj" (Bf16))) +(let t543 (Output t542 542)) +(let t544 (Input 544 "model.layers.9.experts.down_proj" (Bf16))) +(let t545 (Output t544 544)) +(let t546 (Input 546 "model.layers.9.input_layernorm.weight" (F32))) +(let t547 (Output t546 546)) +(let t548 (Input 548 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t549 (Output t548 548)) +(let t550 (Input 550 "model.layers.9.pre_feedforward_layernorm.weight" (F32))) +(let t551 (Output t550 550)) +(let t552 (Input 552 "model.layers.9.post_feedforward_layernorm.weight" (F32))) +(let t553 (Output t552 552)) +(let t554 (Input 554 "model.layers.9.post_feedforward_layernorm_1.weight" (F32))) +(let t555 (Output t554 554)) +(let t556 (Input 556 "model.layers.9.post_feedforward_layernorm_2.weight" (F32))) +(let t557 (Output t556 556)) +(let t558 (Input 558 "model.layers.9.pre_feedforward_layernorm_2.weight" (F32))) +(let t559 (Output t558 558)) +(let t560 (Input 560 "model.layers.10.mlp.gate_proj.weight" (F32))) +(let t561 (Output t560 560)) +(let t562 (Input 562 "model.layers.10.mlp.up_proj.weight" (F32))) +(let t563 (Output t562 562)) +(let t564 (Input 564 "model.layers.10.mlp.down_proj.weight" (F32))) +(let t565 (Output t564 564)) +(let t566 (Input 566 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t567 (Output t566 566)) +(let t568 (Input 568 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t569 (Output t568 568)) +(let t570 (Input 570 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t571 (Output t570 570)) +(let t572 (Input 572 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t573 (Output t572 572)) +(let t574 (Input 574 "model.layers.10.self_attn.q_norm.weight" (F32))) +(let t575 (Output t574 574)) +(let t576 (Input 576 "model.layers.10.self_attn.k_norm.weight" (F32))) +(let t577 (Output t576 576)) +(let t578 (Input 578 "model.layers.10.layer_scalar" (F32))) +(let t579 (Output t578 578)) +(let t580 (Input 580 "model.layers.10.router.scale" (F32))) +(let t581 (Output t580 580)) +(let t582 (Input 582 "model.layers.10.router.proj.weight" (F32))) +(let t583 (Output t582 582)) +(let t584 (Input 584 "model.layers.10.router.per_expert_scale" (F32))) +(let t585 (Output t584 584)) +(let t586 (Input 586 "model.layers.10.experts.gate_up_proj" (Bf16))) +(let t587 (Output t586 586)) +(let t588 (Input 588 "model.layers.10.experts.down_proj" (Bf16))) +(let t589 (Output t588 588)) +(let t590 (Input 590 "model.layers.10.input_layernorm.weight" (F32))) +(let t591 (Output t590 590)) +(let t592 (Input 592 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t593 (Output t592 592)) +(let t594 (Input 594 "model.layers.10.pre_feedforward_layernorm.weight" (F32))) +(let t595 (Output t594 594)) +(let t596 (Input 596 "model.layers.10.post_feedforward_layernorm.weight" (F32))) +(let t597 (Output t596 596)) +(let t598 (Input 598 "model.layers.10.post_feedforward_layernorm_1.weight" (F32))) +(let t599 (Output t598 598)) +(let t600 (Input 600 "model.layers.10.post_feedforward_layernorm_2.weight" (F32))) +(let t601 (Output t600 600)) +(let t602 (Input 602 "model.layers.10.pre_feedforward_layernorm_2.weight" (F32))) +(let t603 (Output t602 602)) +(let t604 (Input 604 "model.layers.11.mlp.gate_proj.weight" (F32))) +(let t605 (Output t604 604)) +(let t606 (Input 606 "model.layers.11.mlp.up_proj.weight" (F32))) +(let t607 (Output t606 606)) +(let t608 (Input 608 "model.layers.11.mlp.down_proj.weight" (F32))) +(let t609 (Output t608 608)) +(let t610 (Input 610 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t611 (Output t610 610)) +(let t612 (Input 612 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t613 (Output t612 612)) +(let t614 (Input 614 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t615 (Output t614 614)) +(let t616 (Input 616 "model.layers.11.self_attn.q_norm.weight" (F32))) +(let t617 (Output t616 616)) +(let t618 (Input 618 "model.layers.11.self_attn.k_norm.weight" (F32))) +(let t619 (Output t618 618)) +(let t620 (Input 620 "model.layers.11.layer_scalar" (F32))) +(let t621 (Output t620 620)) +(let t622 (Input 622 "model.layers.11.router.scale" (F32))) +(let t623 (Output t622 622)) +(let t624 (Input 624 "model.layers.11.router.proj.weight" (F32))) +(let t625 (Output t624 624)) +(let t626 (Input 626 "model.layers.11.router.per_expert_scale" (F32))) +(let t627 (Output t626 626)) +(let t628 (Input 628 "model.layers.11.experts.gate_up_proj" (Bf16))) +(let t629 (Output t628 628)) +(let t630 (Input 630 "model.layers.11.experts.down_proj" (Bf16))) +(let t631 (Output t630 630)) +(let t632 (Input 632 "model.layers.11.input_layernorm.weight" (F32))) +(let t633 (Output t632 632)) +(let t634 (Input 634 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t635 (Output t634 634)) +(let t636 (Input 636 "model.layers.11.pre_feedforward_layernorm.weight" (F32))) +(let t637 (Output t636 636)) +(let t638 (Input 638 "model.layers.11.post_feedforward_layernorm.weight" (F32))) +(let t639 (Output t638 638)) +(let t640 (Input 640 "model.layers.11.post_feedforward_layernorm_1.weight" (F32))) +(let t641 (Output t640 640)) +(let t642 (Input 642 "model.layers.11.post_feedforward_layernorm_2.weight" (F32))) +(let t643 (Output t642 642)) +(let t644 (Input 644 "model.layers.11.pre_feedforward_layernorm_2.weight" (F32))) +(let t645 (Output t644 644)) +(let t646 (Input 646 "model.layers.12.mlp.gate_proj.weight" (F32))) +(let t647 (Output t646 646)) +(let t648 (Input 648 "model.layers.12.mlp.up_proj.weight" (F32))) +(let t649 (Output t648 648)) +(let t650 (Input 650 "model.layers.12.mlp.down_proj.weight" (F32))) +(let t651 (Output t650 650)) +(let t652 (Input 652 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t653 (Output t652 652)) +(let t654 (Input 654 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t655 (Output t654 654)) +(let t656 (Input 656 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t657 (Output t656 656)) +(let t658 (Input 658 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t659 (Output t658 658)) +(let t660 (Input 660 "model.layers.12.self_attn.q_norm.weight" (F32))) +(let t661 (Output t660 660)) +(let t662 (Input 662 "model.layers.12.self_attn.k_norm.weight" (F32))) +(let t663 (Output t662 662)) +(let t664 (Input 664 "model.layers.12.layer_scalar" (F32))) +(let t665 (Output t664 664)) +(let t666 (Input 666 "model.layers.12.router.scale" (F32))) +(let t667 (Output t666 666)) +(let t668 (Input 668 "model.layers.12.router.proj.weight" (F32))) +(let t669 (Output t668 668)) +(let t670 (Input 670 "model.layers.12.router.per_expert_scale" (F32))) +(let t671 (Output t670 670)) +(let t672 (Input 672 "model.layers.12.experts.gate_up_proj" (Bf16))) +(let t673 (Output t672 672)) +(let t674 (Input 674 "model.layers.12.experts.down_proj" (Bf16))) +(let t675 (Output t674 674)) +(let t676 (Input 676 "model.layers.12.input_layernorm.weight" (F32))) +(let t677 (Output t676 676)) +(let t678 (Input 678 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t679 (Output t678 678)) +(let t680 (Input 680 "model.layers.12.pre_feedforward_layernorm.weight" (F32))) +(let t681 (Output t680 680)) +(let t682 (Input 682 "model.layers.12.post_feedforward_layernorm.weight" (F32))) +(let t683 (Output t682 682)) +(let t684 (Input 684 "model.layers.12.post_feedforward_layernorm_1.weight" (F32))) +(let t685 (Output t684 684)) +(let t686 (Input 686 "model.layers.12.post_feedforward_layernorm_2.weight" (F32))) +(let t687 (Output t686 686)) +(let t688 (Input 688 "model.layers.12.pre_feedforward_layernorm_2.weight" (F32))) +(let t689 (Output t688 688)) +(let t690 (Input 690 "model.layers.13.mlp.gate_proj.weight" (F32))) +(let t691 (Output t690 690)) +(let t692 (Input 692 "model.layers.13.mlp.up_proj.weight" (F32))) +(let t693 (Output t692 692)) +(let t694 (Input 694 "model.layers.13.mlp.down_proj.weight" (F32))) +(let t695 (Output t694 694)) +(let t696 (Input 696 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t697 (Output t696 696)) +(let t698 (Input 698 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t699 (Output t698 698)) +(let t700 (Input 700 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t701 (Output t700 700)) +(let t702 (Input 702 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t703 (Output t702 702)) +(let t704 (Input 704 "model.layers.13.self_attn.q_norm.weight" (F32))) +(let t705 (Output t704 704)) +(let t706 (Input 706 "model.layers.13.self_attn.k_norm.weight" (F32))) +(let t707 (Output t706 706)) +(let t708 (Input 708 "model.layers.13.layer_scalar" (F32))) +(let t709 (Output t708 708)) +(let t710 (Input 710 "model.layers.13.router.scale" (F32))) +(let t711 (Output t710 710)) +(let t712 (Input 712 "model.layers.13.router.proj.weight" (F32))) +(let t713 (Output t712 712)) +(let t714 (Input 714 "model.layers.13.router.per_expert_scale" (F32))) +(let t715 (Output t714 714)) +(let t716 (Input 716 "model.layers.13.experts.gate_up_proj" (Bf16))) +(let t717 (Output t716 716)) +(let t718 (Input 718 "model.layers.13.experts.down_proj" (Bf16))) +(let t719 (Output t718 718)) +(let t720 (Input 720 "model.layers.13.input_layernorm.weight" (F32))) +(let t721 (Output t720 720)) +(let t722 (Input 722 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t723 (Output t722 722)) +(let t724 (Input 724 "model.layers.13.pre_feedforward_layernorm.weight" (F32))) +(let t725 (Output t724 724)) +(let t726 (Input 726 "model.layers.13.post_feedforward_layernorm.weight" (F32))) +(let t727 (Output t726 726)) +(let t728 (Input 728 "model.layers.13.post_feedforward_layernorm_1.weight" (F32))) +(let t729 (Output t728 728)) +(let t730 (Input 730 "model.layers.13.post_feedforward_layernorm_2.weight" (F32))) +(let t731 (Output t730 730)) +(let t732 (Input 732 "model.layers.13.pre_feedforward_layernorm_2.weight" (F32))) +(let t733 (Output t732 732)) +(let t734 (Input 734 "model.layers.14.mlp.gate_proj.weight" (F32))) +(let t735 (Output t734 734)) +(let t736 (Input 736 "model.layers.14.mlp.up_proj.weight" (F32))) +(let t737 (Output t736 736)) +(let t738 (Input 738 "model.layers.14.mlp.down_proj.weight" (F32))) +(let t739 (Output t738 738)) +(let t740 (Input 740 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t741 (Output t740 740)) +(let t742 (Input 742 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t743 (Output t742 742)) +(let t744 (Input 744 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t745 (Output t744 744)) +(let t746 (Input 746 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t747 (Output t746 746)) +(let t748 (Input 748 "model.layers.14.self_attn.q_norm.weight" (F32))) +(let t749 (Output t748 748)) +(let t750 (Input 750 "model.layers.14.self_attn.k_norm.weight" (F32))) +(let t751 (Output t750 750)) +(let t752 (Input 752 "model.layers.14.layer_scalar" (F32))) +(let t753 (Output t752 752)) +(let t754 (Input 754 "model.layers.14.router.scale" (F32))) +(let t755 (Output t754 754)) +(let t756 (Input 756 "model.layers.14.router.proj.weight" (F32))) +(let t757 (Output t756 756)) +(let t758 (Input 758 "model.layers.14.router.per_expert_scale" (F32))) +(let t759 (Output t758 758)) +(let t760 (Input 760 "model.layers.14.experts.gate_up_proj" (Bf16))) +(let t761 (Output t760 760)) +(let t762 (Input 762 "model.layers.14.experts.down_proj" (Bf16))) +(let t763 (Output t762 762)) +(let t764 (Input 764 "model.layers.14.input_layernorm.weight" (F32))) +(let t765 (Output t764 764)) +(let t766 (Input 766 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t767 (Output t766 766)) +(let t768 (Input 768 "model.layers.14.pre_feedforward_layernorm.weight" (F32))) +(let t769 (Output t768 768)) +(let t770 (Input 770 "model.layers.14.post_feedforward_layernorm.weight" (F32))) +(let t771 (Output t770 770)) +(let t772 (Input 772 "model.layers.14.post_feedforward_layernorm_1.weight" (F32))) +(let t773 (Output t772 772)) +(let t774 (Input 774 "model.layers.14.post_feedforward_layernorm_2.weight" (F32))) +(let t775 (Output t774 774)) +(let t776 (Input 776 "model.layers.14.pre_feedforward_layernorm_2.weight" (F32))) +(let t777 (Output t776 776)) +(let t778 (Input 778 "model.layers.15.mlp.gate_proj.weight" (F32))) +(let t779 (Output t778 778)) +(let t780 (Input 780 "model.layers.15.mlp.up_proj.weight" (F32))) +(let t781 (Output t780 780)) +(let t782 (Input 782 "model.layers.15.mlp.down_proj.weight" (F32))) +(let t783 (Output t782 782)) +(let t784 (Input 784 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t785 (Output t784 784)) +(let t786 (Input 786 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t787 (Output t786 786)) +(let t788 (Input 788 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t789 (Output t788 788)) +(let t790 (Input 790 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t791 (Output t790 790)) +(let t792 (Input 792 "model.layers.15.self_attn.q_norm.weight" (F32))) +(let t793 (Output t792 792)) +(let t794 (Input 794 "model.layers.15.self_attn.k_norm.weight" (F32))) +(let t795 (Output t794 794)) +(let t796 (Input 796 "model.layers.15.layer_scalar" (F32))) +(let t797 (Output t796 796)) +(let t798 (Input 798 "model.layers.15.router.scale" (F32))) +(let t799 (Output t798 798)) +(let t800 (Input 800 "model.layers.15.router.proj.weight" (F32))) +(let t801 (Output t800 800)) +(let t802 (Input 802 "model.layers.15.router.per_expert_scale" (F32))) +(let t803 (Output t802 802)) +(let t804 (Input 804 "model.layers.15.experts.gate_up_proj" (Bf16))) +(let t805 (Output t804 804)) +(let t806 (Input 806 "model.layers.15.experts.down_proj" (Bf16))) +(let t807 (Output t806 806)) +(let t808 (Input 808 "model.layers.15.input_layernorm.weight" (F32))) +(let t809 (Output t808 808)) +(let t810 (Input 810 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t811 (Output t810 810)) +(let t812 (Input 812 "model.layers.15.pre_feedforward_layernorm.weight" (F32))) +(let t813 (Output t812 812)) +(let t814 (Input 814 "model.layers.15.post_feedforward_layernorm.weight" (F32))) +(let t815 (Output t814 814)) +(let t816 (Input 816 "model.layers.15.post_feedforward_layernorm_1.weight" (F32))) +(let t817 (Output t816 816)) +(let t818 (Input 818 "model.layers.15.post_feedforward_layernorm_2.weight" (F32))) +(let t819 (Output t818 818)) +(let t820 (Input 820 "model.layers.15.pre_feedforward_layernorm_2.weight" (F32))) +(let t821 (Output t820 820)) +(let t822 (Input 822 "model.layers.16.mlp.gate_proj.weight" (F32))) +(let t823 (Output t822 822)) +(let t824 (Input 824 "model.layers.16.mlp.up_proj.weight" (F32))) +(let t825 (Output t824 824)) +(let t826 (Input 826 "model.layers.16.mlp.down_proj.weight" (F32))) +(let t827 (Output t826 826)) +(let t828 (Input 828 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t829 (Output t828 828)) +(let t830 (Input 830 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t831 (Output t830 830)) +(let t832 (Input 832 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t833 (Output t832 832)) +(let t834 (Input 834 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t835 (Output t834 834)) +(let t836 (Input 836 "model.layers.16.self_attn.q_norm.weight" (F32))) +(let t837 (Output t836 836)) +(let t838 (Input 838 "model.layers.16.self_attn.k_norm.weight" (F32))) +(let t839 (Output t838 838)) +(let t840 (Input 840 "model.layers.16.layer_scalar" (F32))) +(let t841 (Output t840 840)) +(let t842 (Input 842 "model.layers.16.router.scale" (F32))) +(let t843 (Output t842 842)) +(let t844 (Input 844 "model.layers.16.router.proj.weight" (F32))) +(let t845 (Output t844 844)) +(let t846 (Input 846 "model.layers.16.router.per_expert_scale" (F32))) +(let t847 (Output t846 846)) +(let t848 (Input 848 "model.layers.16.experts.gate_up_proj" (Bf16))) +(let t849 (Output t848 848)) +(let t850 (Input 850 "model.layers.16.experts.down_proj" (Bf16))) +(let t851 (Output t850 850)) +(let t852 (Input 852 "model.layers.16.input_layernorm.weight" (F32))) +(let t853 (Output t852 852)) +(let t854 (Input 854 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t855 (Output t854 854)) +(let t856 (Input 856 "model.layers.16.pre_feedforward_layernorm.weight" (F32))) +(let t857 (Output t856 856)) +(let t858 (Input 858 "model.layers.16.post_feedforward_layernorm.weight" (F32))) +(let t859 (Output t858 858)) +(let t860 (Input 860 "model.layers.16.post_feedforward_layernorm_1.weight" (F32))) +(let t861 (Output t860 860)) +(let t862 (Input 862 "model.layers.16.post_feedforward_layernorm_2.weight" (F32))) +(let t863 (Output t862 862)) +(let t864 (Input 864 "model.layers.16.pre_feedforward_layernorm_2.weight" (F32))) +(let t865 (Output t864 864)) +(let t866 (Input 866 "model.layers.17.mlp.gate_proj.weight" (F32))) +(let t867 (Output t866 866)) +(let t868 (Input 868 "model.layers.17.mlp.up_proj.weight" (F32))) +(let t869 (Output t868 868)) +(let t870 (Input 870 "model.layers.17.mlp.down_proj.weight" (F32))) +(let t871 (Output t870 870)) +(let t872 (Input 872 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t873 (Output t872 872)) +(let t874 (Input 874 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t875 (Output t874 874)) +(let t876 (Input 876 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t877 (Output t876 876)) +(let t878 (Input 878 "model.layers.17.self_attn.q_norm.weight" (F32))) +(let t879 (Output t878 878)) +(let t880 (Input 880 "model.layers.17.self_attn.k_norm.weight" (F32))) +(let t881 (Output t880 880)) +(let t882 (Input 882 "model.layers.17.layer_scalar" (F32))) +(let t883 (Output t882 882)) +(let t884 (Input 884 "model.layers.17.router.scale" (F32))) +(let t885 (Output t884 884)) +(let t886 (Input 886 "model.layers.17.router.proj.weight" (F32))) +(let t887 (Output t886 886)) +(let t888 (Input 888 "model.layers.17.router.per_expert_scale" (F32))) +(let t889 (Output t888 888)) +(let t890 (Input 890 "model.layers.17.experts.gate_up_proj" (Bf16))) +(let t891 (Output t890 890)) +(let t892 (Input 892 "model.layers.17.experts.down_proj" (Bf16))) +(let t893 (Output t892 892)) +(let t894 (Input 894 "model.layers.17.input_layernorm.weight" (F32))) +(let t895 (Output t894 894)) +(let t896 (Input 896 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t897 (Output t896 896)) +(let t898 (Input 898 "model.layers.17.pre_feedforward_layernorm.weight" (F32))) +(let t899 (Output t898 898)) +(let t900 (Input 900 "model.layers.17.post_feedforward_layernorm.weight" (F32))) +(let t901 (Output t900 900)) +(let t902 (Input 902 "model.layers.17.post_feedforward_layernorm_1.weight" (F32))) +(let t903 (Output t902 902)) +(let t904 (Input 904 "model.layers.17.post_feedforward_layernorm_2.weight" (F32))) +(let t905 (Output t904 904)) +(let t906 (Input 906 "model.layers.17.pre_feedforward_layernorm_2.weight" (F32))) +(let t907 (Output t906 906)) +(let t908 (Input 908 "model.layers.18.mlp.gate_proj.weight" (F32))) +(let t909 (Output t908 908)) +(let t910 (Input 910 "model.layers.18.mlp.up_proj.weight" (F32))) +(let t911 (Output t910 910)) +(let t912 (Input 912 "model.layers.18.mlp.down_proj.weight" (F32))) +(let t913 (Output t912 912)) +(let t914 (Input 914 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t915 (Output t914 914)) +(let t916 (Input 916 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t917 (Output t916 916)) +(let t918 (Input 918 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t919 (Output t918 918)) +(let t920 (Input 920 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t921 (Output t920 920)) +(let t922 (Input 922 "model.layers.18.self_attn.q_norm.weight" (F32))) +(let t923 (Output t922 922)) +(let t924 (Input 924 "model.layers.18.self_attn.k_norm.weight" (F32))) +(let t925 (Output t924 924)) +(let t926 (Input 926 "model.layers.18.layer_scalar" (F32))) +(let t927 (Output t926 926)) +(let t928 (Input 928 "model.layers.18.router.scale" (F32))) +(let t929 (Output t928 928)) +(let t930 (Input 930 "model.layers.18.router.proj.weight" (F32))) +(let t931 (Output t930 930)) +(let t932 (Input 932 "model.layers.18.router.per_expert_scale" (F32))) +(let t933 (Output t932 932)) +(let t934 (Input 934 "model.layers.18.experts.gate_up_proj" (Bf16))) +(let t935 (Output t934 934)) +(let t936 (Input 936 "model.layers.18.experts.down_proj" (Bf16))) +(let t937 (Output t936 936)) +(let t938 (Input 938 "model.layers.18.input_layernorm.weight" (F32))) +(let t939 (Output t938 938)) +(let t940 (Input 940 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t941 (Output t940 940)) +(let t942 (Input 942 "model.layers.18.pre_feedforward_layernorm.weight" (F32))) +(let t943 (Output t942 942)) +(let t944 (Input 944 "model.layers.18.post_feedforward_layernorm.weight" (F32))) +(let t945 (Output t944 944)) +(let t946 (Input 946 "model.layers.18.post_feedforward_layernorm_1.weight" (F32))) +(let t947 (Output t946 946)) +(let t948 (Input 948 "model.layers.18.post_feedforward_layernorm_2.weight" (F32))) +(let t949 (Output t948 948)) +(let t950 (Input 950 "model.layers.18.pre_feedforward_layernorm_2.weight" (F32))) +(let t951 (Output t950 950)) +(let t952 (Input 952 "model.layers.19.mlp.gate_proj.weight" (F32))) +(let t953 (Output t952 952)) +(let t954 (Input 954 "model.layers.19.mlp.up_proj.weight" (F32))) +(let t955 (Output t954 954)) +(let t956 (Input 956 "model.layers.19.mlp.down_proj.weight" (F32))) +(let t957 (Output t956 956)) +(let t958 (Input 958 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t959 (Output t958 958)) +(let t960 (Input 960 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t961 (Output t960 960)) +(let t962 (Input 962 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t963 (Output t962 962)) +(let t964 (Input 964 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t965 (Output t964 964)) +(let t966 (Input 966 "model.layers.19.self_attn.q_norm.weight" (F32))) +(let t967 (Output t966 966)) +(let t968 (Input 968 "model.layers.19.self_attn.k_norm.weight" (F32))) +(let t969 (Output t968 968)) +(let t970 (Input 970 "model.layers.19.layer_scalar" (F32))) +(let t971 (Output t970 970)) +(let t972 (Input 972 "model.layers.19.router.scale" (F32))) +(let t973 (Output t972 972)) +(let t974 (Input 974 "model.layers.19.router.proj.weight" (F32))) +(let t975 (Output t974 974)) +(let t976 (Input 976 "model.layers.19.router.per_expert_scale" (F32))) +(let t977 (Output t976 976)) +(let t978 (Input 978 "model.layers.19.experts.gate_up_proj" (Bf16))) +(let t979 (Output t978 978)) +(let t980 (Input 980 "model.layers.19.experts.down_proj" (Bf16))) +(let t981 (Output t980 980)) +(let t982 (Input 982 "model.layers.19.input_layernorm.weight" (F32))) +(let t983 (Output t982 982)) +(let t984 (Input 984 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t985 (Output t984 984)) +(let t986 (Input 986 "model.layers.19.pre_feedforward_layernorm.weight" (F32))) +(let t987 (Output t986 986)) +(let t988 (Input 988 "model.layers.19.post_feedforward_layernorm.weight" (F32))) +(let t989 (Output t988 988)) +(let t990 (Input 990 "model.layers.19.post_feedforward_layernorm_1.weight" (F32))) +(let t991 (Output t990 990)) +(let t992 (Input 992 "model.layers.19.post_feedforward_layernorm_2.weight" (F32))) +(let t993 (Output t992 992)) +(let t994 (Input 994 "model.layers.19.pre_feedforward_layernorm_2.weight" (F32))) +(let t995 (Output t994 994)) +(let t996 (Input 996 "model.layers.20.mlp.gate_proj.weight" (F32))) +(let t997 (Output t996 996)) +(let t998 (Input 998 "model.layers.20.mlp.up_proj.weight" (F32))) +(let t999 (Output t998 998)) +(let t1000 (Input 1000 "model.layers.20.mlp.down_proj.weight" (F32))) +(let t1001 (Output t1000 1000)) +(let t1002 (Input 1002 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t1003 (Output t1002 1002)) +(let t1004 (Input 1004 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t1005 (Output t1004 1004)) +(let t1006 (Input 1006 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t1007 (Output t1006 1006)) +(let t1008 (Input 1008 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t1009 (Output t1008 1008)) +(let t1010 (Input 1010 "model.layers.20.self_attn.q_norm.weight" (F32))) +(let t1011 (Output t1010 1010)) +(let t1012 (Input 1012 "model.layers.20.self_attn.k_norm.weight" (F32))) +(let t1013 (Output t1012 1012)) +(let t1014 (Input 1014 "model.layers.20.layer_scalar" (F32))) +(let t1015 (Output t1014 1014)) +(let t1016 (Input 1016 "model.layers.20.router.scale" (F32))) +(let t1017 (Output t1016 1016)) +(let t1018 (Input 1018 "model.layers.20.router.proj.weight" (F32))) +(let t1019 (Output t1018 1018)) +(let t1020 (Input 1020 "model.layers.20.router.per_expert_scale" (F32))) +(let t1021 (Output t1020 1020)) +(let t1022 (Input 1022 "model.layers.20.experts.gate_up_proj" (Bf16))) +(let t1023 (Output t1022 1022)) +(let t1024 (Input 1024 "model.layers.20.experts.down_proj" (Bf16))) +(let t1025 (Output t1024 1024)) +(let t1026 (Input 1026 "model.layers.20.input_layernorm.weight" (F32))) +(let t1027 (Output t1026 1026)) +(let t1028 (Input 1028 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t1029 (Output t1028 1028)) +(let t1030 (Input 1030 "model.layers.20.pre_feedforward_layernorm.weight" (F32))) +(let t1031 (Output t1030 1030)) +(let t1032 (Input 1032 "model.layers.20.post_feedforward_layernorm.weight" (F32))) +(let t1033 (Output t1032 1032)) +(let t1034 (Input 1034 "model.layers.20.post_feedforward_layernorm_1.weight" (F32))) +(let t1035 (Output t1034 1034)) +(let t1036 (Input 1036 "model.layers.20.post_feedforward_layernorm_2.weight" (F32))) +(let t1037 (Output t1036 1036)) +(let t1038 (Input 1038 "model.layers.20.pre_feedforward_layernorm_2.weight" (F32))) +(let t1039 (Output t1038 1038)) +(let t1040 (Input 1040 "model.layers.21.mlp.gate_proj.weight" (F32))) +(let t1041 (Output t1040 1040)) +(let t1042 (Input 1042 "model.layers.21.mlp.up_proj.weight" (F32))) +(let t1043 (Output t1042 1042)) +(let t1044 (Input 1044 "model.layers.21.mlp.down_proj.weight" (F32))) +(let t1045 (Output t1044 1044)) +(let t1046 (Input 1046 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t1047 (Output t1046 1046)) +(let t1048 (Input 1048 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t1049 (Output t1048 1048)) +(let t1050 (Input 1050 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t1051 (Output t1050 1050)) +(let t1052 (Input 1052 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t1053 (Output t1052 1052)) +(let t1054 (Input 1054 "model.layers.21.self_attn.q_norm.weight" (F32))) +(let t1055 (Output t1054 1054)) +(let t1056 (Input 1056 "model.layers.21.self_attn.k_norm.weight" (F32))) +(let t1057 (Output t1056 1056)) +(let t1058 (Input 1058 "model.layers.21.layer_scalar" (F32))) +(let t1059 (Output t1058 1058)) +(let t1060 (Input 1060 "model.layers.21.router.scale" (F32))) +(let t1061 (Output t1060 1060)) +(let t1062 (Input 1062 "model.layers.21.router.proj.weight" (F32))) +(let t1063 (Output t1062 1062)) +(let t1064 (Input 1064 "model.layers.21.router.per_expert_scale" (F32))) +(let t1065 (Output t1064 1064)) +(let t1066 (Input 1066 "model.layers.21.experts.gate_up_proj" (Bf16))) +(let t1067 (Output t1066 1066)) +(let t1068 (Input 1068 "model.layers.21.experts.down_proj" (Bf16))) +(let t1069 (Output t1068 1068)) +(let t1070 (Input 1070 "model.layers.21.input_layernorm.weight" (F32))) +(let t1071 (Output t1070 1070)) +(let t1072 (Input 1072 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t1073 (Output t1072 1072)) +(let t1074 (Input 1074 "model.layers.21.pre_feedforward_layernorm.weight" (F32))) +(let t1075 (Output t1074 1074)) +(let t1076 (Input 1076 "model.layers.21.post_feedforward_layernorm.weight" (F32))) +(let t1077 (Output t1076 1076)) +(let t1078 (Input 1078 "model.layers.21.post_feedforward_layernorm_1.weight" (F32))) +(let t1079 (Output t1078 1078)) +(let t1080 (Input 1080 "model.layers.21.post_feedforward_layernorm_2.weight" (F32))) +(let t1081 (Output t1080 1080)) +(let t1082 (Input 1082 "model.layers.21.pre_feedforward_layernorm_2.weight" (F32))) +(let t1083 (Output t1082 1082)) +(let t1084 (Input 1084 "model.layers.22.mlp.gate_proj.weight" (F32))) +(let t1085 (Output t1084 1084)) +(let t1086 (Input 1086 "model.layers.22.mlp.up_proj.weight" (F32))) +(let t1087 (Output t1086 1086)) +(let t1088 (Input 1088 "model.layers.22.mlp.down_proj.weight" (F32))) +(let t1089 (Output t1088 1088)) +(let t1090 (Input 1090 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t1091 (Output t1090 1090)) +(let t1092 (Input 1092 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t1093 (Output t1092 1092)) +(let t1094 (Input 1094 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t1095 (Output t1094 1094)) +(let t1096 (Input 1096 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t1097 (Output t1096 1096)) +(let t1098 (Input 1098 "model.layers.22.self_attn.q_norm.weight" (F32))) +(let t1099 (Output t1098 1098)) +(let t1100 (Input 1100 "model.layers.22.self_attn.k_norm.weight" (F32))) +(let t1101 (Output t1100 1100)) +(let t1102 (Input 1102 "model.layers.22.layer_scalar" (F32))) +(let t1103 (Output t1102 1102)) +(let t1104 (Input 1104 "model.layers.22.router.scale" (F32))) +(let t1105 (Output t1104 1104)) +(let t1106 (Input 1106 "model.layers.22.router.proj.weight" (F32))) +(let t1107 (Output t1106 1106)) +(let t1108 (Input 1108 "model.layers.22.router.per_expert_scale" (F32))) +(let t1109 (Output t1108 1108)) +(let t1110 (Input 1110 "model.layers.22.experts.gate_up_proj" (Bf16))) +(let t1111 (Output t1110 1110)) +(let t1112 (Input 1112 "model.layers.22.experts.down_proj" (Bf16))) +(let t1113 (Output t1112 1112)) +(let t1114 (Input 1114 "model.layers.22.input_layernorm.weight" (F32))) +(let t1115 (Output t1114 1114)) +(let t1116 (Input 1116 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t1117 (Output t1116 1116)) +(let t1118 (Input 1118 "model.layers.22.pre_feedforward_layernorm.weight" (F32))) +(let t1119 (Output t1118 1118)) +(let t1120 (Input 1120 "model.layers.22.post_feedforward_layernorm.weight" (F32))) +(let t1121 (Output t1120 1120)) +(let t1122 (Input 1122 "model.layers.22.post_feedforward_layernorm_1.weight" (F32))) +(let t1123 (Output t1122 1122)) +(let t1124 (Input 1124 "model.layers.22.post_feedforward_layernorm_2.weight" (F32))) +(let t1125 (Output t1124 1124)) +(let t1126 (Input 1126 "model.layers.22.pre_feedforward_layernorm_2.weight" (F32))) +(let t1127 (Output t1126 1126)) +(let t1128 (Input 1128 "model.layers.23.mlp.gate_proj.weight" (F32))) +(let t1129 (Output t1128 1128)) +(let t1130 (Input 1130 "model.layers.23.mlp.up_proj.weight" (F32))) +(let t1131 (Output t1130 1130)) +(let t1132 (Input 1132 "model.layers.23.mlp.down_proj.weight" (F32))) +(let t1133 (Output t1132 1132)) +(let t1134 (Input 1134 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t1135 (Output t1134 1134)) +(let t1136 (Input 1136 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t1137 (Output t1136 1136)) +(let t1138 (Input 1138 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t1139 (Output t1138 1138)) +(let t1140 (Input 1140 "model.layers.23.self_attn.q_norm.weight" (F32))) +(let t1141 (Output t1140 1140)) +(let t1142 (Input 1142 "model.layers.23.self_attn.k_norm.weight" (F32))) +(let t1143 (Output t1142 1142)) +(let t1144 (Input 1144 "model.layers.23.layer_scalar" (F32))) +(let t1145 (Output t1144 1144)) +(let t1146 (Input 1146 "model.layers.23.router.scale" (F32))) +(let t1147 (Output t1146 1146)) +(let t1148 (Input 1148 "model.layers.23.router.proj.weight" (F32))) +(let t1149 (Output t1148 1148)) +(let t1150 (Input 1150 "model.layers.23.router.per_expert_scale" (F32))) +(let t1151 (Output t1150 1150)) +(let t1152 (Input 1152 "model.layers.23.experts.gate_up_proj" (Bf16))) +(let t1153 (Output t1152 1152)) +(let t1154 (Input 1154 "model.layers.23.experts.down_proj" (Bf16))) +(let t1155 (Output t1154 1154)) +(let t1156 (Input 1156 "model.layers.23.input_layernorm.weight" (F32))) +(let t1157 (Output t1156 1156)) +(let t1158 (Input 1158 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t1159 (Output t1158 1158)) +(let t1160 (Input 1160 "model.layers.23.pre_feedforward_layernorm.weight" (F32))) +(let t1161 (Output t1160 1160)) +(let t1162 (Input 1162 "model.layers.23.post_feedforward_layernorm.weight" (F32))) +(let t1163 (Output t1162 1162)) +(let t1164 (Input 1164 "model.layers.23.post_feedforward_layernorm_1.weight" (F32))) +(let t1165 (Output t1164 1164)) +(let t1166 (Input 1166 "model.layers.23.post_feedforward_layernorm_2.weight" (F32))) +(let t1167 (Output t1166 1166)) +(let t1168 (Input 1168 "model.layers.23.pre_feedforward_layernorm_2.weight" (F32))) +(let t1169 (Output t1168 1168)) +(let t1170 (Input 1170 "model.layers.24.mlp.gate_proj.weight" (F32))) +(let t1171 (Output t1170 1170)) +(let t1172 (Input 1172 "model.layers.24.mlp.up_proj.weight" (F32))) +(let t1173 (Output t1172 1172)) +(let t1174 (Input 1174 "model.layers.24.mlp.down_proj.weight" (F32))) +(let t1175 (Output t1174 1174)) +(let t1176 (Input 1176 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t1177 (Output t1176 1176)) +(let t1178 (Input 1178 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t1179 (Output t1178 1178)) +(let t1180 (Input 1180 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t1181 (Output t1180 1180)) +(let t1182 (Input 1182 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t1183 (Output t1182 1182)) +(let t1184 (Input 1184 "model.layers.24.self_attn.q_norm.weight" (F32))) +(let t1185 (Output t1184 1184)) +(let t1186 (Input 1186 "model.layers.24.self_attn.k_norm.weight" (F32))) +(let t1187 (Output t1186 1186)) +(let t1188 (Input 1188 "model.layers.24.layer_scalar" (F32))) +(let t1189 (Output t1188 1188)) +(let t1190 (Input 1190 "model.layers.24.router.scale" (F32))) +(let t1191 (Output t1190 1190)) +(let t1192 (Input 1192 "model.layers.24.router.proj.weight" (F32))) +(let t1193 (Output t1192 1192)) +(let t1194 (Input 1194 "model.layers.24.router.per_expert_scale" (F32))) +(let t1195 (Output t1194 1194)) +(let t1196 (Input 1196 "model.layers.24.experts.gate_up_proj" (Bf16))) +(let t1197 (Output t1196 1196)) +(let t1198 (Input 1198 "model.layers.24.experts.down_proj" (Bf16))) +(let t1199 (Output t1198 1198)) +(let t1200 (Input 1200 "model.layers.24.input_layernorm.weight" (F32))) +(let t1201 (Output t1200 1200)) +(let t1202 (Input 1202 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t1203 (Output t1202 1202)) +(let t1204 (Input 1204 "model.layers.24.pre_feedforward_layernorm.weight" (F32))) +(let t1205 (Output t1204 1204)) +(let t1206 (Input 1206 "model.layers.24.post_feedforward_layernorm.weight" (F32))) +(let t1207 (Output t1206 1206)) +(let t1208 (Input 1208 "model.layers.24.post_feedforward_layernorm_1.weight" (F32))) +(let t1209 (Output t1208 1208)) +(let t1210 (Input 1210 "model.layers.24.post_feedforward_layernorm_2.weight" (F32))) +(let t1211 (Output t1210 1210)) +(let t1212 (Input 1212 "model.layers.24.pre_feedforward_layernorm_2.weight" (F32))) +(let t1213 (Output t1212 1212)) +(let t1214 (Input 1214 "model.layers.25.mlp.gate_proj.weight" (F32))) +(let t1215 (Output t1214 1214)) +(let t1216 (Input 1216 "model.layers.25.mlp.up_proj.weight" (F32))) +(let t1217 (Output t1216 1216)) +(let t1218 (Input 1218 "model.layers.25.mlp.down_proj.weight" (F32))) +(let t1219 (Output t1218 1218)) +(let t1220 (Input 1220 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t1221 (Output t1220 1220)) +(let t1222 (Input 1222 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t1223 (Output t1222 1222)) +(let t1224 (Input 1224 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t1225 (Output t1224 1224)) +(let t1226 (Input 1226 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t1227 (Output t1226 1226)) +(let t1228 (Input 1228 "model.layers.25.self_attn.q_norm.weight" (F32))) +(let t1229 (Output t1228 1228)) +(let t1230 (Input 1230 "model.layers.25.self_attn.k_norm.weight" (F32))) +(let t1231 (Output t1230 1230)) +(let t1232 (Input 1232 "model.layers.25.layer_scalar" (F32))) +(let t1233 (Output t1232 1232)) +(let t1234 (Input 1234 "model.layers.25.router.scale" (F32))) +(let t1235 (Output t1234 1234)) +(let t1236 (Input 1236 "model.layers.25.router.proj.weight" (F32))) +(let t1237 (Output t1236 1236)) +(let t1238 (Input 1238 "model.layers.25.router.per_expert_scale" (F32))) +(let t1239 (Output t1238 1238)) +(let t1240 (Input 1240 "model.layers.25.experts.gate_up_proj" (Bf16))) +(let t1241 (Output t1240 1240)) +(let t1242 (Input 1242 "model.layers.25.experts.down_proj" (Bf16))) +(let t1243 (Output t1242 1242)) +(let t1244 (Input 1244 "model.layers.25.input_layernorm.weight" (F32))) +(let t1245 (Output t1244 1244)) +(let t1246 (Input 1246 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t1247 (Output t1246 1246)) +(let t1248 (Input 1248 "model.layers.25.pre_feedforward_layernorm.weight" (F32))) +(let t1249 (Output t1248 1248)) +(let t1250 (Input 1250 "model.layers.25.post_feedforward_layernorm.weight" (F32))) +(let t1251 (Output t1250 1250)) +(let t1252 (Input 1252 "model.layers.25.post_feedforward_layernorm_1.weight" (F32))) +(let t1253 (Output t1252 1252)) +(let t1254 (Input 1254 "model.layers.25.post_feedforward_layernorm_2.weight" (F32))) +(let t1255 (Output t1254 1254)) +(let t1256 (Input 1256 "model.layers.25.pre_feedforward_layernorm_2.weight" (F32))) +(let t1257 (Output t1256 1256)) +(let t1258 (Input 1258 "model.layers.26.mlp.gate_proj.weight" (F32))) +(let t1259 (Output t1258 1258)) +(let t1260 (Input 1260 "model.layers.26.mlp.up_proj.weight" (F32))) +(let t1261 (Output t1260 1260)) +(let t1262 (Input 1262 "model.layers.26.mlp.down_proj.weight" (F32))) +(let t1263 (Output t1262 1262)) +(let t1264 (Input 1264 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t1265 (Output t1264 1264)) +(let t1266 (Input 1266 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t1267 (Output t1266 1266)) +(let t1268 (Input 1268 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t1269 (Output t1268 1268)) +(let t1270 (Input 1270 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t1271 (Output t1270 1270)) +(let t1272 (Input 1272 "model.layers.26.self_attn.q_norm.weight" (F32))) +(let t1273 (Output t1272 1272)) +(let t1274 (Input 1274 "model.layers.26.self_attn.k_norm.weight" (F32))) +(let t1275 (Output t1274 1274)) +(let t1276 (Input 1276 "model.layers.26.layer_scalar" (F32))) +(let t1277 (Output t1276 1276)) +(let t1278 (Input 1278 "model.layers.26.router.scale" (F32))) +(let t1279 (Output t1278 1278)) +(let t1280 (Input 1280 "model.layers.26.router.proj.weight" (F32))) +(let t1281 (Output t1280 1280)) +(let t1282 (Input 1282 "model.layers.26.router.per_expert_scale" (F32))) +(let t1283 (Output t1282 1282)) +(let t1284 (Input 1284 "model.layers.26.experts.gate_up_proj" (Bf16))) +(let t1285 (Output t1284 1284)) +(let t1286 (Input 1286 "model.layers.26.experts.down_proj" (Bf16))) +(let t1287 (Output t1286 1286)) +(let t1288 (Input 1288 "model.layers.26.input_layernorm.weight" (F32))) +(let t1289 (Output t1288 1288)) +(let t1290 (Input 1290 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t1291 (Output t1290 1290)) +(let t1292 (Input 1292 "model.layers.26.pre_feedforward_layernorm.weight" (F32))) +(let t1293 (Output t1292 1292)) +(let t1294 (Input 1294 "model.layers.26.post_feedforward_layernorm.weight" (F32))) +(let t1295 (Output t1294 1294)) +(let t1296 (Input 1296 "model.layers.26.post_feedforward_layernorm_1.weight" (F32))) +(let t1297 (Output t1296 1296)) +(let t1298 (Input 1298 "model.layers.26.post_feedforward_layernorm_2.weight" (F32))) +(let t1299 (Output t1298 1298)) +(let t1300 (Input 1300 "model.layers.26.pre_feedforward_layernorm_2.weight" (F32))) +(let t1301 (Output t1300 1300)) +(let t1302 (Input 1302 "model.layers.27.mlp.gate_proj.weight" (F32))) +(let t1303 (Output t1302 1302)) +(let t1304 (Input 1304 "model.layers.27.mlp.up_proj.weight" (F32))) +(let t1305 (Output t1304 1304)) +(let t1306 (Input 1306 "model.layers.27.mlp.down_proj.weight" (F32))) +(let t1307 (Output t1306 1306)) +(let t1308 (Input 1308 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t1309 (Output t1308 1308)) +(let t1310 (Input 1310 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t1311 (Output t1310 1310)) +(let t1312 (Input 1312 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t1313 (Output t1312 1312)) +(let t1314 (Input 1314 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t1315 (Output t1314 1314)) +(let t1316 (Input 1316 "model.layers.27.self_attn.q_norm.weight" (F32))) +(let t1317 (Output t1316 1316)) +(let t1318 (Input 1318 "model.layers.27.self_attn.k_norm.weight" (F32))) +(let t1319 (Output t1318 1318)) +(let t1320 (Input 1320 "model.layers.27.layer_scalar" (F32))) +(let t1321 (Output t1320 1320)) +(let t1322 (Input 1322 "model.layers.27.router.scale" (F32))) +(let t1323 (Output t1322 1322)) +(let t1324 (Input 1324 "model.layers.27.router.proj.weight" (F32))) +(let t1325 (Output t1324 1324)) +(let t1326 (Input 1326 "model.layers.27.router.per_expert_scale" (F32))) +(let t1327 (Output t1326 1326)) +(let t1328 (Input 1328 "model.layers.27.experts.gate_up_proj" (Bf16))) +(let t1329 (Output t1328 1328)) +(let t1330 (Input 1330 "model.layers.27.experts.down_proj" (Bf16))) +(let t1331 (Output t1330 1330)) +(let t1332 (Input 1332 "model.layers.27.input_layernorm.weight" (F32))) +(let t1333 (Output t1332 1332)) +(let t1334 (Input 1334 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t1335 (Output t1334 1334)) +(let t1336 (Input 1336 "model.layers.27.pre_feedforward_layernorm.weight" (F32))) +(let t1337 (Output t1336 1336)) +(let t1338 (Input 1338 "model.layers.27.post_feedforward_layernorm.weight" (F32))) +(let t1339 (Output t1338 1338)) +(let t1340 (Input 1340 "model.layers.27.post_feedforward_layernorm_1.weight" (F32))) +(let t1341 (Output t1340 1340)) +(let t1342 (Input 1342 "model.layers.27.post_feedforward_layernorm_2.weight" (F32))) +(let t1343 (Output t1342 1342)) +(let t1344 (Input 1344 "model.layers.27.pre_feedforward_layernorm_2.weight" (F32))) +(let t1345 (Output t1344 1344)) +(let t1346 (Input 1346 "model.layers.28.mlp.gate_proj.weight" (F32))) +(let t1347 (Output t1346 1346)) +(let t1348 (Input 1348 "model.layers.28.mlp.up_proj.weight" (F32))) +(let t1349 (Output t1348 1348)) +(let t1350 (Input 1350 "model.layers.28.mlp.down_proj.weight" (F32))) +(let t1351 (Output t1350 1350)) +(let t1352 (Input 1352 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t1353 (Output t1352 1352)) +(let t1354 (Input 1354 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t1355 (Output t1354 1354)) +(let t1356 (Input 1356 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t1357 (Output t1356 1356)) +(let t1358 (Input 1358 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t1359 (Output t1358 1358)) +(let t1360 (Input 1360 "model.layers.28.self_attn.q_norm.weight" (F32))) +(let t1361 (Output t1360 1360)) +(let t1362 (Input 1362 "model.layers.28.self_attn.k_norm.weight" (F32))) +(let t1363 (Output t1362 1362)) +(let t1364 (Input 1364 "model.layers.28.layer_scalar" (F32))) +(let t1365 (Output t1364 1364)) +(let t1366 (Input 1366 "model.layers.28.router.scale" (F32))) +(let t1367 (Output t1366 1366)) +(let t1368 (Input 1368 "model.layers.28.router.proj.weight" (F32))) +(let t1369 (Output t1368 1368)) +(let t1370 (Input 1370 "model.layers.28.router.per_expert_scale" (F32))) +(let t1371 (Output t1370 1370)) +(let t1372 (Input 1372 "model.layers.28.experts.gate_up_proj" (Bf16))) +(let t1373 (Output t1372 1372)) +(let t1374 (Input 1374 "model.layers.28.experts.down_proj" (Bf16))) +(let t1375 (Output t1374 1374)) +(let t1376 (Input 1376 "model.layers.28.input_layernorm.weight" (F32))) +(let t1377 (Output t1376 1376)) +(let t1378 (Input 1378 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t1379 (Output t1378 1378)) +(let t1380 (Input 1380 "model.layers.28.pre_feedforward_layernorm.weight" (F32))) +(let t1381 (Output t1380 1380)) +(let t1382 (Input 1382 "model.layers.28.post_feedforward_layernorm.weight" (F32))) +(let t1383 (Output t1382 1382)) +(let t1384 (Input 1384 "model.layers.28.post_feedforward_layernorm_1.weight" (F32))) +(let t1385 (Output t1384 1384)) +(let t1386 (Input 1386 "model.layers.28.post_feedforward_layernorm_2.weight" (F32))) +(let t1387 (Output t1386 1386)) +(let t1388 (Input 1388 "model.layers.28.pre_feedforward_layernorm_2.weight" (F32))) +(let t1389 (Output t1388 1388)) +(let t1390 (Input 1390 "model.layers.29.mlp.gate_proj.weight" (F32))) +(let t1391 (Output t1390 1390)) +(let t1392 (Input 1392 "model.layers.29.mlp.up_proj.weight" (F32))) +(let t1393 (Output t1392 1392)) +(let t1394 (Input 1394 "model.layers.29.mlp.down_proj.weight" (F32))) +(let t1395 (Output t1394 1394)) +(let t1396 (Input 1396 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t1397 (Output t1396 1396)) +(let t1398 (Input 1398 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t1399 (Output t1398 1398)) +(let t1400 (Input 1400 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t1401 (Output t1400 1400)) +(let t1402 (Input 1402 "model.layers.29.self_attn.q_norm.weight" (F32))) +(let t1403 (Output t1402 1402)) +(let t1404 (Input 1404 "model.layers.29.self_attn.k_norm.weight" (F32))) +(let t1405 (Output t1404 1404)) +(let t1406 (Input 1406 "model.layers.29.layer_scalar" (F32))) +(let t1407 (Output t1406 1406)) +(let t1408 (Input 1408 "model.layers.29.router.scale" (F32))) +(let t1409 (Output t1408 1408)) +(let t1410 (Input 1410 "model.layers.29.router.proj.weight" (F32))) +(let t1411 (Output t1410 1410)) +(let t1412 (Input 1412 "model.layers.29.router.per_expert_scale" (F32))) +(let t1413 (Output t1412 1412)) +(let t1414 (Input 1414 "model.layers.29.experts.gate_up_proj" (Bf16))) +(let t1415 (Output t1414 1414)) +(let t1416 (Input 1416 "model.layers.29.experts.down_proj" (Bf16))) +(let t1417 (Output t1416 1416)) +(let t1418 (Input 1418 "model.layers.29.input_layernorm.weight" (F32))) +(let t1419 (Output t1418 1418)) +(let t1420 (Input 1420 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t1421 (Output t1420 1420)) +(let t1422 (Input 1422 "model.layers.29.pre_feedforward_layernorm.weight" (F32))) +(let t1423 (Output t1422 1422)) +(let t1424 (Input 1424 "model.layers.29.post_feedforward_layernorm.weight" (F32))) +(let t1425 (Output t1424 1424)) +(let t1426 (Input 1426 "model.layers.29.post_feedforward_layernorm_1.weight" (F32))) +(let t1427 (Output t1426 1426)) +(let t1428 (Input 1428 "model.layers.29.post_feedforward_layernorm_2.weight" (F32))) +(let t1429 (Output t1428 1428)) +(let t1430 (Input 1430 "model.layers.29.pre_feedforward_layernorm_2.weight" (F32))) +(let t1431 (Output t1430 1430)) +(let t1432 (Input 1432 "model.embed_tokens.weight" (F32))) +(let t1433 (Output t1432 1432)) +(let t1434 (Input 1434 "lm_head.weight" (F32))) +(let t1435 (Output t1434 1434)) +(let t1436 (Input 1436 "model.norm.weight" (F32))) +(let t1437 (Output t1436 1436)) +(let t1438 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1439 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t1438 (INil))))) +(let t1440 (Op (Iota (MIter) (MNum 2816)) (INil))) +(let t1441 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t1439 (ICons t1440 (INil))))) +(let t1442 (Op (Gather (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 262144) (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t1441 (ICons t1432 (INil))))) +(let t1443 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1444 (Op (Cast (MNum 1) (F32)) (ICons t1443 (INil)))) +(let t1445 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1444 (INil)))) +(let t1446 (Op (Constant 0.000001) (INil))) +(let t1447 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1448 (Op (Cast (MNum 1) (F32)) (ICons t1447 (INil)))) +(let t1449 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t1448 (INil)))) +(let t1450 (Op (Constant 0.000001) (INil))) +(let t1451 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1452 (Op (Cast (MNum 1) (F32)) (ICons t1451 (INil)))) +(let t1453 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1452 (INil)))) +(let t1454 (Op (Constant 0.000001) (INil))) +(let t1455 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1456 (Op (Cast (MNum 1) (F32)) (ICons t1455 (INil)))) +(let t1457 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1456 (INil)))) +(let t1458 (Op (Constant 0.000001) (INil))) +(let t1459 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1460 (Op (Cast (MNum 128) (F32)) (ICons t1459 (INil)))) +(let t1461 (Op (Constant 0.003906) (INil))) +(let t1462 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1460 (ICons t1461 (INil))))) +(let t1463 (Op (Constant 9.210340) (INil))) +(let t1464 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1462 (ICons t1463 (INil))))) +(let t1465 (Op (Constant 1.442695) (INil))) +(let t1466 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1464 (ICons t1465 (INil))))) +(let t1467 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1466 (INil)))) +(let t1468 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1467 (INil)))) +(let t1469 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1470 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1469 (ICons t1468 (INil))))) +(let t1471 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1470 (INil)))) +(let t1472 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t1473 (Op (Constant -1.000000) (INil))) +(let t1474 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1471 (ICons t1473 (INil))))) +(let t1475 (Op (Constant 1.570796) (INil))) +(let t1476 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1474 (ICons t1475 (INil))))) +(let t1477 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1476 (INil)))) +(let t1478 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1471 (INil)))) +(let t1479 (Op (Constant -1.000000) (INil))) +(let t1480 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1481 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1482 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1481 (INil)))) +(let t1483 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1484 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1485 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1484 (INil)))) +(let t1486 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1487 (Op (Cast (MNum 128) (F32)) (ICons t1486 (INil)))) +(let t1488 (Op (Constant 0.003906) (INil))) +(let t1489 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1487 (ICons t1488 (INil))))) +(let t1490 (Op (Constant 9.210340) (INil))) +(let t1491 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1489 (ICons t1490 (INil))))) +(let t1492 (Op (Constant 1.442695) (INil))) +(let t1493 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1491 (ICons t1492 (INil))))) +(let t1494 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1493 (INil)))) +(let t1495 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1494 (INil)))) +(let t1496 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1497 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1496 (ICons t1495 (INil))))) +(let t1498 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1497 (INil)))) +(let t1499 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1500 (Op (Constant -1.000000) (INil))) +(let t1501 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1498 (ICons t1500 (INil))))) +(let t1502 (Op (Constant 1.570796) (INil))) +(let t1503 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1501 (ICons t1502 (INil))))) +(let t1504 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1503 (INil)))) +(let t1505 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1498 (INil)))) +(let t1506 (Op (Constant -1.000000) (INil))) +(let t1507 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1508 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1509 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1508 (INil)))) +(let t1510 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1511 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1512 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1511 (INil)))) +(let t1513 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1514 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1515 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1513 (ICons t1514 (INil))))) +(let t1516 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1517 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1518 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1516 (ICons t1517 (INil))))) +(let t1519 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1520 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1518 (ICons t1519 (INil))))) +(let t1521 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1522 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1515 (ICons t1520 (INil))))) +(let t1523 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1522 (ICons t1521 (INil))))) +(let t1524 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1525 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1524 (INil)))) +(let t1526 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1527 (Op (Cast (MNum 1) (F32)) (ICons t1526 (INil)))) +(let t1528 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1525 (ICons t1527 (INil))))) +(let t1529 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1530 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1529 (INil)))) +(let t1531 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1528 (ICons t1530 (INil))))) +(let t1532 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1531 (INil)))) +(let t1533 (Op (Constant 1023.000000) (INil))) +(let t1534 (Op (Constant -1.000000) (INil))) +(let t1535 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1533 (ICons t1534 (INil))))) +(let t1536 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1528 (ICons t1535 (INil))))) +(let t1537 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1530 (ICons t1536 (INil))))) +(let t1538 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1537 (INil)))) +(let t1539 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1532 (ICons t1538 (INil))))) +(let t1540 (Op (Constant -10000000000.000000) (INil))) +(let t1541 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1539 (ICons t1540 (INil))))) +(let t1542 (Op (Constant -1.000000) (INil))) +(let t1543 (Op (Constant 1.442695) (INil))) +(let t1544 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1545 (Op (Cast (MNum 1) (F32)) (ICons t1544 (INil)))) +(let t1546 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1545 (INil)))) +(let t1547 (Op (Constant 0.000001) (INil))) +(let t1548 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1549 (Op (Cast (MNum 1) (F32)) (ICons t1548 (INil)))) +(let t1550 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1549 (INil)))) +(let t1551 (Op (Constant 0.000001) (INil))) +(let t1552 (Op (Constant 1.595769) (INil))) +(let t1553 (Op (Constant 0.044715) (INil))) +(let t1554 (Op (Constant 1.000000) (INil))) +(let t1555 (Op (Constant -1.000000) (INil))) +(let t1556 (Op (Constant 1.442695) (INil))) +(let t1557 (Op (Constant 1.000000) (INil))) +(let t1558 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1559 (Op (Cast (MNum 1) (F32)) (ICons t1558 (INil)))) +(let t1560 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1559 (INil)))) +(let t1561 (Op (Constant 0.000001) (INil))) +(let t1562 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1563 (Op (Cast (MNum 1) (F32)) (ICons t1562 (INil)))) +(let t1564 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1563 (INil)))) +(let t1565 (Op (Constant 0.000001) (INil))) +(let t1566 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1567 (Op (Cast (MNum 1) (F32)) (ICons t1566 (INil)))) +(let t1568 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1567 (INil)))) +(let t1569 (Op (Constant 0.000001) (INil))) +(let t1570 (Op (Constant 0.018844) (INil))) +(let t1571 (Op (Constant -1.000000) (INil))) +(let t1572 (Op (Constant 1.442695) (INil))) +(let t1573 (Op (Constant 0.000000) (INil))) +(let t1574 (Op (Constant 0.000000) (INil))) +(let t1575 (Op (Constant 0.000000) (INil))) +(let t1576 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1577 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t1578 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t1579 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t1580 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t1581 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t1582 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t1583 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t1584 (Op (Constant 1.595769) (INil))) +(let t1585 (Op (Constant 0.044715) (INil))) +(let t1586 (Op (Constant 1.000000) (INil))) +(let t1587 (Op (Constant -1.000000) (INil))) +(let t1588 (Op (Constant 1.442695) (INil))) +(let t1589 (Op (Constant 1.000000) (INil))) +(let t1590 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t1591 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t1592 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1593 (Op (Cast (MNum 1) (F32)) (ICons t1592 (INil)))) +(let t1594 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1593 (INil)))) +(let t1595 (Op (Constant 0.000001) (INil))) +(let t1596 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1597 (Op (Cast (MNum 1) (F32)) (ICons t1596 (INil)))) +(let t1598 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1597 (INil)))) +(let t1599 (Op (Constant 0.000001) (INil))) +(let t1600 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1601 (Op (Cast (MNum 1) (F32)) (ICons t1600 (INil)))) +(let t1602 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1601 (INil)))) +(let t1603 (Op (Constant 0.000001) (INil))) +(let t1604 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1605 (Op (Cast (MNum 1) (F32)) (ICons t1604 (INil)))) +(let t1606 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t1605 (INil)))) +(let t1607 (Op (Constant 0.000001) (INil))) +(let t1608 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1609 (Op (Cast (MNum 1) (F32)) (ICons t1608 (INil)))) +(let t1610 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1609 (INil)))) +(let t1611 (Op (Constant 0.000001) (INil))) +(let t1612 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1613 (Op (Cast (MNum 1) (F32)) (ICons t1612 (INil)))) +(let t1614 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1613 (INil)))) +(let t1615 (Op (Constant 0.000001) (INil))) +(let t1616 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1617 (Op (Cast (MNum 128) (F32)) (ICons t1616 (INil)))) +(let t1618 (Op (Constant 0.003906) (INil))) +(let t1619 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1617 (ICons t1618 (INil))))) +(let t1620 (Op (Constant 9.210340) (INil))) +(let t1621 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1619 (ICons t1620 (INil))))) +(let t1622 (Op (Constant 1.442695) (INil))) +(let t1623 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1621 (ICons t1622 (INil))))) +(let t1624 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1623 (INil)))) +(let t1625 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1624 (INil)))) +(let t1626 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1627 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1626 (ICons t1625 (INil))))) +(let t1628 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1627 (INil)))) +(let t1629 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t1630 (Op (Constant -1.000000) (INil))) +(let t1631 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1628 (ICons t1630 (INil))))) +(let t1632 (Op (Constant 1.570796) (INil))) +(let t1633 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1631 (ICons t1632 (INil))))) +(let t1634 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1633 (INil)))) +(let t1635 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1628 (INil)))) +(let t1636 (Op (Constant -1.000000) (INil))) +(let t1637 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1638 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1639 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1638 (INil)))) +(let t1640 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1641 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1642 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1641 (INil)))) +(let t1643 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1644 (Op (Cast (MNum 128) (F32)) (ICons t1643 (INil)))) +(let t1645 (Op (Constant 0.003906) (INil))) +(let t1646 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1644 (ICons t1645 (INil))))) +(let t1647 (Op (Constant 9.210340) (INil))) +(let t1648 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1646 (ICons t1647 (INil))))) +(let t1649 (Op (Constant 1.442695) (INil))) +(let t1650 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1648 (ICons t1649 (INil))))) +(let t1651 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1650 (INil)))) +(let t1652 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1651 (INil)))) +(let t1653 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1654 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1653 (ICons t1652 (INil))))) +(let t1655 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1654 (INil)))) +(let t1656 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1657 (Op (Constant -1.000000) (INil))) +(let t1658 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1655 (ICons t1657 (INil))))) +(let t1659 (Op (Constant 1.570796) (INil))) +(let t1660 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1658 (ICons t1659 (INil))))) +(let t1661 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1660 (INil)))) +(let t1662 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1655 (INil)))) +(let t1663 (Op (Constant -1.000000) (INil))) +(let t1664 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1665 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1666 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1665 (INil)))) +(let t1667 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1668 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1669 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1668 (INil)))) +(let t1670 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1671 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1672 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1670 (ICons t1671 (INil))))) +(let t1673 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1674 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1675 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1673 (ICons t1674 (INil))))) +(let t1676 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1677 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1675 (ICons t1676 (INil))))) +(let t1678 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1679 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1672 (ICons t1677 (INil))))) +(let t1680 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1679 (ICons t1678 (INil))))) +(let t1681 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1682 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1681 (INil)))) +(let t1683 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1684 (Op (Cast (MNum 1) (F32)) (ICons t1683 (INil)))) +(let t1685 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1682 (ICons t1684 (INil))))) +(let t1686 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1687 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1686 (INil)))) +(let t1688 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1685 (ICons t1687 (INil))))) +(let t1689 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1688 (INil)))) +(let t1690 (Op (Constant 1023.000000) (INil))) +(let t1691 (Op (Constant -1.000000) (INil))) +(let t1692 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1690 (ICons t1691 (INil))))) +(let t1693 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1685 (ICons t1692 (INil))))) +(let t1694 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1687 (ICons t1693 (INil))))) +(let t1695 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1694 (INil)))) +(let t1696 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1689 (ICons t1695 (INil))))) +(let t1697 (Op (Constant -10000000000.000000) (INil))) +(let t1698 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1696 (ICons t1697 (INil))))) +(let t1699 (Op (Constant -1.000000) (INil))) +(let t1700 (Op (Constant 1.442695) (INil))) +(let t1701 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1702 (Op (Cast (MNum 1) (F32)) (ICons t1701 (INil)))) +(let t1703 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1702 (INil)))) +(let t1704 (Op (Constant 0.000001) (INil))) +(let t1705 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1706 (Op (Cast (MNum 1) (F32)) (ICons t1705 (INil)))) +(let t1707 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1706 (INil)))) +(let t1708 (Op (Constant 0.000001) (INil))) +(let t1709 (Op (Constant 1.595769) (INil))) +(let t1710 (Op (Constant 0.044715) (INil))) +(let t1711 (Op (Constant 1.000000) (INil))) +(let t1712 (Op (Constant -1.000000) (INil))) +(let t1713 (Op (Constant 1.442695) (INil))) +(let t1714 (Op (Constant 1.000000) (INil))) +(let t1715 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1716 (Op (Cast (MNum 1) (F32)) (ICons t1715 (INil)))) +(let t1717 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1716 (INil)))) +(let t1718 (Op (Constant 0.000001) (INil))) +(let t1719 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1720 (Op (Cast (MNum 1) (F32)) (ICons t1719 (INil)))) +(let t1721 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1720 (INil)))) +(let t1722 (Op (Constant 0.000001) (INil))) +(let t1723 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1724 (Op (Cast (MNum 1) (F32)) (ICons t1723 (INil)))) +(let t1725 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1724 (INil)))) +(let t1726 (Op (Constant 0.000001) (INil))) +(let t1727 (Op (Constant 0.018844) (INil))) +(let t1728 (Op (Constant -1.000000) (INil))) +(let t1729 (Op (Constant 1.442695) (INil))) +(let t1730 (Op (Constant 0.000000) (INil))) +(let t1731 (Op (Constant 0.000000) (INil))) +(let t1732 (Op (Constant 0.000000) (INil))) +(let t1733 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1734 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t1735 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t1736 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t1737 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t1738 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t1739 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t1740 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t1741 (Op (Constant 1.595769) (INil))) +(let t1742 (Op (Constant 0.044715) (INil))) +(let t1743 (Op (Constant 1.000000) (INil))) +(let t1744 (Op (Constant -1.000000) (INil))) +(let t1745 (Op (Constant 1.442695) (INil))) +(let t1746 (Op (Constant 1.000000) (INil))) +(let t1747 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t1748 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t1749 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1750 (Op (Cast (MNum 1) (F32)) (ICons t1749 (INil)))) +(let t1751 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1750 (INil)))) +(let t1752 (Op (Constant 0.000001) (INil))) +(let t1753 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1754 (Op (Cast (MNum 1) (F32)) (ICons t1753 (INil)))) +(let t1755 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1754 (INil)))) +(let t1756 (Op (Constant 0.000001) (INil))) +(let t1757 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1758 (Op (Cast (MNum 1) (F32)) (ICons t1757 (INil)))) +(let t1759 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1758 (INil)))) +(let t1760 (Op (Constant 0.000001) (INil))) +(let t1761 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1762 (Op (Cast (MNum 1) (F32)) (ICons t1761 (INil)))) +(let t1763 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t1762 (INil)))) +(let t1764 (Op (Constant 0.000001) (INil))) +(let t1765 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1766 (Op (Cast (MNum 1) (F32)) (ICons t1765 (INil)))) +(let t1767 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1766 (INil)))) +(let t1768 (Op (Constant 0.000001) (INil))) +(let t1769 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1770 (Op (Cast (MNum 1) (F32)) (ICons t1769 (INil)))) +(let t1771 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1770 (INil)))) +(let t1772 (Op (Constant 0.000001) (INil))) +(let t1773 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1774 (Op (Cast (MNum 128) (F32)) (ICons t1773 (INil)))) +(let t1775 (Op (Constant 0.003906) (INil))) +(let t1776 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1774 (ICons t1775 (INil))))) +(let t1777 (Op (Constant 9.210340) (INil))) +(let t1778 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1776 (ICons t1777 (INil))))) +(let t1779 (Op (Constant 1.442695) (INil))) +(let t1780 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1778 (ICons t1779 (INil))))) +(let t1781 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1780 (INil)))) +(let t1782 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1781 (INil)))) +(let t1783 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1784 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1783 (ICons t1782 (INil))))) +(let t1785 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1784 (INil)))) +(let t1786 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t1787 (Op (Constant -1.000000) (INil))) +(let t1788 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1785 (ICons t1787 (INil))))) +(let t1789 (Op (Constant 1.570796) (INil))) +(let t1790 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1788 (ICons t1789 (INil))))) +(let t1791 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1790 (INil)))) +(let t1792 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1785 (INil)))) +(let t1793 (Op (Constant -1.000000) (INil))) +(let t1794 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1795 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1796 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1795 (INil)))) +(let t1797 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1798 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1799 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1798 (INil)))) +(let t1800 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1801 (Op (Cast (MNum 128) (F32)) (ICons t1800 (INil)))) +(let t1802 (Op (Constant 0.003906) (INil))) +(let t1803 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1801 (ICons t1802 (INil))))) +(let t1804 (Op (Constant 9.210340) (INil))) +(let t1805 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1803 (ICons t1804 (INil))))) +(let t1806 (Op (Constant 1.442695) (INil))) +(let t1807 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1805 (ICons t1806 (INil))))) +(let t1808 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1807 (INil)))) +(let t1809 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1808 (INil)))) +(let t1810 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1811 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1810 (ICons t1809 (INil))))) +(let t1812 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1811 (INil)))) +(let t1813 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1814 (Op (Constant -1.000000) (INil))) +(let t1815 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1812 (ICons t1814 (INil))))) +(let t1816 (Op (Constant 1.570796) (INil))) +(let t1817 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1815 (ICons t1816 (INil))))) +(let t1818 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1817 (INil)))) +(let t1819 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1812 (INil)))) +(let t1820 (Op (Constant -1.000000) (INil))) +(let t1821 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1822 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1823 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1822 (INil)))) +(let t1824 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1825 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1826 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1825 (INil)))) +(let t1827 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1828 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1829 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1827 (ICons t1828 (INil))))) +(let t1830 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1831 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1832 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1830 (ICons t1831 (INil))))) +(let t1833 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1834 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1832 (ICons t1833 (INil))))) +(let t1835 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1836 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1829 (ICons t1834 (INil))))) +(let t1837 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1836 (ICons t1835 (INil))))) +(let t1838 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1839 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1838 (INil)))) +(let t1840 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1841 (Op (Cast (MNum 1) (F32)) (ICons t1840 (INil)))) +(let t1842 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1839 (ICons t1841 (INil))))) +(let t1843 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1844 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1843 (INil)))) +(let t1845 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1842 (ICons t1844 (INil))))) +(let t1846 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1845 (INil)))) +(let t1847 (Op (Constant 1023.000000) (INil))) +(let t1848 (Op (Constant -1.000000) (INil))) +(let t1849 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1847 (ICons t1848 (INil))))) +(let t1850 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1842 (ICons t1849 (INil))))) +(let t1851 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1844 (ICons t1850 (INil))))) +(let t1852 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1851 (INil)))) +(let t1853 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1846 (ICons t1852 (INil))))) +(let t1854 (Op (Constant -10000000000.000000) (INil))) +(let t1855 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1853 (ICons t1854 (INil))))) +(let t1856 (Op (Constant -1.000000) (INil))) +(let t1857 (Op (Constant 1.442695) (INil))) +(let t1858 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1859 (Op (Cast (MNum 1) (F32)) (ICons t1858 (INil)))) +(let t1860 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1859 (INil)))) +(let t1861 (Op (Constant 0.000001) (INil))) +(let t1862 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1863 (Op (Cast (MNum 1) (F32)) (ICons t1862 (INil)))) +(let t1864 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1863 (INil)))) +(let t1865 (Op (Constant 0.000001) (INil))) +(let t1866 (Op (Constant 1.595769) (INil))) +(let t1867 (Op (Constant 0.044715) (INil))) +(let t1868 (Op (Constant 1.000000) (INil))) +(let t1869 (Op (Constant -1.000000) (INil))) +(let t1870 (Op (Constant 1.442695) (INil))) +(let t1871 (Op (Constant 1.000000) (INil))) +(let t1872 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1873 (Op (Cast (MNum 1) (F32)) (ICons t1872 (INil)))) +(let t1874 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1873 (INil)))) +(let t1875 (Op (Constant 0.000001) (INil))) +(let t1876 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1877 (Op (Cast (MNum 1) (F32)) (ICons t1876 (INil)))) +(let t1878 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1877 (INil)))) +(let t1879 (Op (Constant 0.000001) (INil))) +(let t1880 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1881 (Op (Cast (MNum 1) (F32)) (ICons t1880 (INil)))) +(let t1882 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1881 (INil)))) +(let t1883 (Op (Constant 0.000001) (INil))) +(let t1884 (Op (Constant 0.018844) (INil))) +(let t1885 (Op (Constant -1.000000) (INil))) +(let t1886 (Op (Constant 1.442695) (INil))) +(let t1887 (Op (Constant 0.000000) (INil))) +(let t1888 (Op (Constant 0.000000) (INil))) +(let t1889 (Op (Constant 0.000000) (INil))) +(let t1890 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1891 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t1892 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t1893 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t1894 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t1895 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t1896 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t1897 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t1898 (Op (Constant 1.595769) (INil))) +(let t1899 (Op (Constant 0.044715) (INil))) +(let t1900 (Op (Constant 1.000000) (INil))) +(let t1901 (Op (Constant -1.000000) (INil))) +(let t1902 (Op (Constant 1.442695) (INil))) +(let t1903 (Op (Constant 1.000000) (INil))) +(let t1904 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t1905 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t1906 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1907 (Op (Cast (MNum 1) (F32)) (ICons t1906 (INil)))) +(let t1908 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1907 (INil)))) +(let t1909 (Op (Constant 0.000001) (INil))) +(let t1910 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1911 (Op (Cast (MNum 1) (F32)) (ICons t1910 (INil)))) +(let t1912 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1911 (INil)))) +(let t1913 (Op (Constant 0.000001) (INil))) +(let t1914 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t1915 (Op (Cast (MNum 1) (F32)) (ICons t1914 (INil)))) +(let t1916 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1915 (INil)))) +(let t1917 (Op (Constant 0.000001) (INil))) +(let t1918 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1919 (Op (Cast (MNum 1) (F32)) (ICons t1918 (INil)))) +(let t1920 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t1919 (INil)))) +(let t1921 (Op (Constant 0.000001) (INil))) +(let t1922 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1923 (Op (Cast (MNum 1) (F32)) (ICons t1922 (INil)))) +(let t1924 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1923 (INil)))) +(let t1925 (Op (Constant 0.000001) (INil))) +(let t1926 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1927 (Op (Cast (MNum 1) (F32)) (ICons t1926 (INil)))) +(let t1928 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1927 (INil)))) +(let t1929 (Op (Constant 0.000001) (INil))) +(let t1930 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1931 (Op (Cast (MNum 128) (F32)) (ICons t1930 (INil)))) +(let t1932 (Op (Constant 0.003906) (INil))) +(let t1933 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1931 (ICons t1932 (INil))))) +(let t1934 (Op (Constant 9.210340) (INil))) +(let t1935 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1933 (ICons t1934 (INil))))) +(let t1936 (Op (Constant 1.442695) (INil))) +(let t1937 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1935 (ICons t1936 (INil))))) +(let t1938 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1937 (INil)))) +(let t1939 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1938 (INil)))) +(let t1940 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1941 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1940 (ICons t1939 (INil))))) +(let t1942 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1941 (INil)))) +(let t1943 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t1944 (Op (Constant -1.000000) (INil))) +(let t1945 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1942 (ICons t1944 (INil))))) +(let t1946 (Op (Constant 1.570796) (INil))) +(let t1947 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1945 (ICons t1946 (INil))))) +(let t1948 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1947 (INil)))) +(let t1949 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1942 (INil)))) +(let t1950 (Op (Constant -1.000000) (INil))) +(let t1951 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1952 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1953 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1952 (INil)))) +(let t1954 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1955 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t1956 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1955 (INil)))) +(let t1957 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t1958 (Op (Cast (MNum 128) (F32)) (ICons t1957 (INil)))) +(let t1959 (Op (Constant 0.003906) (INil))) +(let t1960 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1958 (ICons t1959 (INil))))) +(let t1961 (Op (Constant 9.210340) (INil))) +(let t1962 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1960 (ICons t1961 (INil))))) +(let t1963 (Op (Constant 1.442695) (INil))) +(let t1964 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1962 (ICons t1963 (INil))))) +(let t1965 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1964 (INil)))) +(let t1966 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1965 (INil)))) +(let t1967 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1968 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1967 (ICons t1966 (INil))))) +(let t1969 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1968 (INil)))) +(let t1970 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1971 (Op (Constant -1.000000) (INil))) +(let t1972 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1969 (ICons t1971 (INil))))) +(let t1973 (Op (Constant 1.570796) (INil))) +(let t1974 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1972 (ICons t1973 (INil))))) +(let t1975 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1974 (INil)))) +(let t1976 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1969 (INil)))) +(let t1977 (Op (Constant -1.000000) (INil))) +(let t1978 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1979 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1980 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1979 (INil)))) +(let t1981 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1982 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t1983 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t1982 (INil)))) +(let t1984 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1985 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t1986 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1984 (ICons t1985 (INil))))) +(let t1987 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1988 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1989 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1987 (ICons t1988 (INil))))) +(let t1990 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t1991 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1989 (ICons t1990 (INil))))) +(let t1992 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t1993 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1986 (ICons t1991 (INil))))) +(let t1994 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t1993 (ICons t1992 (INil))))) +(let t1995 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1996 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1995 (INil)))) +(let t1997 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1998 (Op (Cast (MNum 1) (F32)) (ICons t1997 (INil)))) +(let t1999 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1996 (ICons t1998 (INil))))) +(let t2000 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2001 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2000 (INil)))) +(let t2002 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1999 (ICons t2001 (INil))))) +(let t2003 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2002 (INil)))) +(let t2004 (Op (Constant 1023.000000) (INil))) +(let t2005 (Op (Constant -1.000000) (INil))) +(let t2006 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2004 (ICons t2005 (INil))))) +(let t2007 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1999 (ICons t2006 (INil))))) +(let t2008 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2001 (ICons t2007 (INil))))) +(let t2009 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2008 (INil)))) +(let t2010 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2003 (ICons t2009 (INil))))) +(let t2011 (Op (Constant -10000000000.000000) (INil))) +(let t2012 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2010 (ICons t2011 (INil))))) +(let t2013 (Op (Constant -1.000000) (INil))) +(let t2014 (Op (Constant 1.442695) (INil))) +(let t2015 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2016 (Op (Cast (MNum 1) (F32)) (ICons t2015 (INil)))) +(let t2017 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2016 (INil)))) +(let t2018 (Op (Constant 0.000001) (INil))) +(let t2019 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2020 (Op (Cast (MNum 1) (F32)) (ICons t2019 (INil)))) +(let t2021 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2020 (INil)))) +(let t2022 (Op (Constant 0.000001) (INil))) +(let t2023 (Op (Constant 1.595769) (INil))) +(let t2024 (Op (Constant 0.044715) (INil))) +(let t2025 (Op (Constant 1.000000) (INil))) +(let t2026 (Op (Constant -1.000000) (INil))) +(let t2027 (Op (Constant 1.442695) (INil))) +(let t2028 (Op (Constant 1.000000) (INil))) +(let t2029 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2030 (Op (Cast (MNum 1) (F32)) (ICons t2029 (INil)))) +(let t2031 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2030 (INil)))) +(let t2032 (Op (Constant 0.000001) (INil))) +(let t2033 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2034 (Op (Cast (MNum 1) (F32)) (ICons t2033 (INil)))) +(let t2035 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2034 (INil)))) +(let t2036 (Op (Constant 0.000001) (INil))) +(let t2037 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2038 (Op (Cast (MNum 1) (F32)) (ICons t2037 (INil)))) +(let t2039 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2038 (INil)))) +(let t2040 (Op (Constant 0.000001) (INil))) +(let t2041 (Op (Constant 0.018844) (INil))) +(let t2042 (Op (Constant -1.000000) (INil))) +(let t2043 (Op (Constant 1.442695) (INil))) +(let t2044 (Op (Constant 0.000000) (INil))) +(let t2045 (Op (Constant 0.000000) (INil))) +(let t2046 (Op (Constant 0.000000) (INil))) +(let t2047 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2048 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2049 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2050 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2051 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2052 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2053 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2054 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2055 (Op (Constant 1.595769) (INil))) +(let t2056 (Op (Constant 0.044715) (INil))) +(let t2057 (Op (Constant 1.000000) (INil))) +(let t2058 (Op (Constant -1.000000) (INil))) +(let t2059 (Op (Constant 1.442695) (INil))) +(let t2060 (Op (Constant 1.000000) (INil))) +(let t2061 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2062 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2063 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2064 (Op (Cast (MNum 1) (F32)) (ICons t2063 (INil)))) +(let t2065 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2064 (INil)))) +(let t2066 (Op (Constant 0.000001) (INil))) +(let t2067 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2068 (Op (Cast (MNum 1) (F32)) (ICons t2067 (INil)))) +(let t2069 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2068 (INil)))) +(let t2070 (Op (Constant 0.000001) (INil))) +(let t2071 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2072 (Op (Cast (MNum 1) (F32)) (ICons t2071 (INil)))) +(let t2073 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2072 (INil)))) +(let t2074 (Op (Constant 0.000001) (INil))) +(let t2075 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2076 (Op (Cast (MNum 1) (F32)) (ICons t2075 (INil)))) +(let t2077 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2076 (INil)))) +(let t2078 (Op (Constant 0.000001) (INil))) +(let t2079 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2080 (Op (Cast (MNum 1) (F32)) (ICons t2079 (INil)))) +(let t2081 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2080 (INil)))) +(let t2082 (Op (Constant 0.000001) (INil))) +(let t2083 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2084 (Op (Cast (MNum 1) (F32)) (ICons t2083 (INil)))) +(let t2085 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2084 (INil)))) +(let t2086 (Op (Constant 0.000001) (INil))) +(let t2087 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2088 (Op (Cast (MNum 128) (F32)) (ICons t2087 (INil)))) +(let t2089 (Op (Constant 0.003906) (INil))) +(let t2090 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2088 (ICons t2089 (INil))))) +(let t2091 (Op (Constant 9.210340) (INil))) +(let t2092 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2090 (ICons t2091 (INil))))) +(let t2093 (Op (Constant 1.442695) (INil))) +(let t2094 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2092 (ICons t2093 (INil))))) +(let t2095 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2094 (INil)))) +(let t2096 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2095 (INil)))) +(let t2097 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2098 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2097 (ICons t2096 (INil))))) +(let t2099 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2098 (INil)))) +(let t2100 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t2101 (Op (Constant -1.000000) (INil))) +(let t2102 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2099 (ICons t2101 (INil))))) +(let t2103 (Op (Constant 1.570796) (INil))) +(let t2104 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2102 (ICons t2103 (INil))))) +(let t2105 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2104 (INil)))) +(let t2106 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2099 (INil)))) +(let t2107 (Op (Constant -1.000000) (INil))) +(let t2108 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2109 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2110 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2109 (INil)))) +(let t2111 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2112 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2113 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2112 (INil)))) +(let t2114 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2115 (Op (Cast (MNum 128) (F32)) (ICons t2114 (INil)))) +(let t2116 (Op (Constant 0.003906) (INil))) +(let t2117 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2115 (ICons t2116 (INil))))) +(let t2118 (Op (Constant 9.210340) (INil))) +(let t2119 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2117 (ICons t2118 (INil))))) +(let t2120 (Op (Constant 1.442695) (INil))) +(let t2121 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2119 (ICons t2120 (INil))))) +(let t2122 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2121 (INil)))) +(let t2123 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2122 (INil)))) +(let t2124 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2125 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2124 (ICons t2123 (INil))))) +(let t2126 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2125 (INil)))) +(let t2127 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2128 (Op (Constant -1.000000) (INil))) +(let t2129 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2126 (ICons t2128 (INil))))) +(let t2130 (Op (Constant 1.570796) (INil))) +(let t2131 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2129 (ICons t2130 (INil))))) +(let t2132 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2131 (INil)))) +(let t2133 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2126 (INil)))) +(let t2134 (Op (Constant -1.000000) (INil))) +(let t2135 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2136 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2137 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2136 (INil)))) +(let t2138 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2139 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2140 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2139 (INil)))) +(let t2141 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t2142 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2143 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2141 (ICons t2142 (INil))))) +(let t2144 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2145 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2146 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2144 (ICons t2145 (INil))))) +(let t2147 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2148 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2146 (ICons t2147 (INil))))) +(let t2149 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2150 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2143 (ICons t2148 (INil))))) +(let t2151 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2150 (ICons t2149 (INil))))) +(let t2152 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2153 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2152 (INil)))) +(let t2154 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2155 (Op (Cast (MNum 1) (F32)) (ICons t2154 (INil)))) +(let t2156 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2153 (ICons t2155 (INil))))) +(let t2157 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2158 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2157 (INil)))) +(let t2159 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2156 (ICons t2158 (INil))))) +(let t2160 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2159 (INil)))) +(let t2161 (Op (Constant 1023.000000) (INil))) +(let t2162 (Op (Constant -1.000000) (INil))) +(let t2163 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2161 (ICons t2162 (INil))))) +(let t2164 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2156 (ICons t2163 (INil))))) +(let t2165 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2158 (ICons t2164 (INil))))) +(let t2166 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2165 (INil)))) +(let t2167 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2160 (ICons t2166 (INil))))) +(let t2168 (Op (Constant -10000000000.000000) (INil))) +(let t2169 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2167 (ICons t2168 (INil))))) +(let t2170 (Op (Constant -1.000000) (INil))) +(let t2171 (Op (Constant 1.442695) (INil))) +(let t2172 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2173 (Op (Cast (MNum 1) (F32)) (ICons t2172 (INil)))) +(let t2174 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2173 (INil)))) +(let t2175 (Op (Constant 0.000001) (INil))) +(let t2176 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2177 (Op (Cast (MNum 1) (F32)) (ICons t2176 (INil)))) +(let t2178 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2177 (INil)))) +(let t2179 (Op (Constant 0.000001) (INil))) +(let t2180 (Op (Constant 1.595769) (INil))) +(let t2181 (Op (Constant 0.044715) (INil))) +(let t2182 (Op (Constant 1.000000) (INil))) +(let t2183 (Op (Constant -1.000000) (INil))) +(let t2184 (Op (Constant 1.442695) (INil))) +(let t2185 (Op (Constant 1.000000) (INil))) +(let t2186 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2187 (Op (Cast (MNum 1) (F32)) (ICons t2186 (INil)))) +(let t2188 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2187 (INil)))) +(let t2189 (Op (Constant 0.000001) (INil))) +(let t2190 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2191 (Op (Cast (MNum 1) (F32)) (ICons t2190 (INil)))) +(let t2192 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2191 (INil)))) +(let t2193 (Op (Constant 0.000001) (INil))) +(let t2194 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2195 (Op (Cast (MNum 1) (F32)) (ICons t2194 (INil)))) +(let t2196 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2195 (INil)))) +(let t2197 (Op (Constant 0.000001) (INil))) +(let t2198 (Op (Constant 0.018844) (INil))) +(let t2199 (Op (Constant -1.000000) (INil))) +(let t2200 (Op (Constant 1.442695) (INil))) +(let t2201 (Op (Constant 0.000000) (INil))) +(let t2202 (Op (Constant 0.000000) (INil))) +(let t2203 (Op (Constant 0.000000) (INil))) +(let t2204 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2205 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2206 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2207 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2208 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2209 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2210 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2211 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2212 (Op (Constant 1.595769) (INil))) +(let t2213 (Op (Constant 0.044715) (INil))) +(let t2214 (Op (Constant 1.000000) (INil))) +(let t2215 (Op (Constant -1.000000) (INil))) +(let t2216 (Op (Constant 1.442695) (INil))) +(let t2217 (Op (Constant 1.000000) (INil))) +(let t2218 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2219 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2220 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2221 (Op (Cast (MNum 1) (F32)) (ICons t2220 (INil)))) +(let t2222 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2221 (INil)))) +(let t2223 (Op (Constant 0.000001) (INil))) +(let t2224 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2225 (Op (Cast (MNum 1) (F32)) (ICons t2224 (INil)))) +(let t2226 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2225 (INil)))) +(let t2227 (Op (Constant 0.000001) (INil))) +(let t2228 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2229 (Op (Cast (MNum 1) (F32)) (ICons t2228 (INil)))) +(let t2230 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2229 (INil)))) +(let t2231 (Op (Constant 0.000001) (INil))) +(let t2232 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t2233 (Op (Cast (MNum 1) (F32)) (ICons t2232 (INil)))) +(let t2234 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2233 (INil)))) +(let t2235 (Op (Constant 0.000001) (INil))) +(let t2236 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t2237 (Op (Cast (MNum 1) (F32)) (ICons t2236 (INil)))) +(let t2238 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t2237 (INil)))) +(let t2239 (Op (Constant 0.000001) (INil))) +(let t2240 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t2241 (Op (Cast (MNum 1) (F32)) (ICons t2240 (INil)))) +(let t2242 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t2241 (INil)))) +(let t2243 (Op (Constant 0.000001) (INil))) +(let t2244 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t2245 (Op (Cast (MNum 64) (F32)) (ICons t2244 (INil)))) +(let t2246 (Op (Constant 0.001953) (INil))) +(let t2247 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2245 (ICons t2246 (INil))))) +(let t2248 (Op (Constant 13.815511) (INil))) +(let t2249 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2247 (ICons t2248 (INil))))) +(let t2250 (Op (Constant 1.442695) (INil))) +(let t2251 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2249 (ICons t2250 (INil))))) +(let t2252 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2251 (INil)))) +(let t2253 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2252 (INil)))) +(let t2254 (Op (Iota (MIter) (MNum 192)) (INil))) +(let t2255 (Op (Cast (MNum 192) (F32)) (ICons t2254 (INil)))) +(let t2256 (Op (Constant 0.000000) (INil))) +(let t2257 (Op (Mul (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2255 (ICons t2256 (INil))))) +(let t2258 (Op (Iota (MMin (MIter) (MNum 63)) (MNum 256)) (INil))) +(let t2259 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil))) (ICons t2258 (ICons t2253 (INil))))) +(let t2260 (Op (Iota (MLt (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t2261 (Op (Cast (MNum 256) (F32)) (ICons t2260 (INil)))) +(let t2262 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2259 (ICons t2261 (INil))))) +(let t2263 (Op (Iota (MMax (MSub (MIter) (MNum 64)) (MNum 0)) (MNum 256)) (INil))) +(let t2264 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil))) (ICons t2263 (ICons t2257 (INil))))) +(let t2265 (Op (Iota (MGte (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t2266 (Op (Cast (MNum 256) (F32)) (ICons t2265 (INil)))) +(let t2267 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2264 (ICons t2266 (INil))))) +(let t2268 (Op (Add (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2262 (ICons t2267 (INil))))) +(let t2269 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2270 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2269 (ICons t2268 (INil))))) +(let t2271 (Op (Sum (ECons (MVar "s") (ECons (MNum 256) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2270 (INil)))) +(let t2272 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 256)) (MNum 256)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 512))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 512) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2273 (Op (Constant -1.000000) (INil))) +(let t2274 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2271 (ICons t2273 (INil))))) +(let t2275 (Op (Constant 1.570796) (INil))) +(let t2276 (Op (Add (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2274 (ICons t2275 (INil))))) +(let t2277 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2276 (INil)))) +(let t2278 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2271 (INil)))) +(let t2279 (Op (Constant -1.000000) (INil))) +(let t2280 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 512)) (MNum 255)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t2281 (Op (Iota (MLt (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t2282 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t2281 (INil)))) +(let t2283 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 512)) (MNum 256)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t2284 (Op (Iota (MGte (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t2285 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t2284 (INil)))) +(let t2286 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t2287 (Op (Cast (MNum 64) (F32)) (ICons t2286 (INil)))) +(let t2288 (Op (Constant 0.001953) (INil))) +(let t2289 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2287 (ICons t2288 (INil))))) +(let t2290 (Op (Constant 13.815511) (INil))) +(let t2291 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2289 (ICons t2290 (INil))))) +(let t2292 (Op (Constant 1.442695) (INil))) +(let t2293 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2291 (ICons t2292 (INil))))) +(let t2294 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2293 (INil)))) +(let t2295 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2294 (INil)))) +(let t2296 (Op (Iota (MIter) (MNum 192)) (INil))) +(let t2297 (Op (Cast (MNum 192) (F32)) (ICons t2296 (INil)))) +(let t2298 (Op (Constant 0.000000) (INil))) +(let t2299 (Op (Mul (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2297 (ICons t2298 (INil))))) +(let t2300 (Op (Iota (MMin (MIter) (MNum 63)) (MNum 256)) (INil))) +(let t2301 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil))) (ICons t2300 (ICons t2295 (INil))))) +(let t2302 (Op (Iota (MLt (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t2303 (Op (Cast (MNum 256) (F32)) (ICons t2302 (INil)))) +(let t2304 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2301 (ICons t2303 (INil))))) +(let t2305 (Op (Iota (MMax (MSub (MIter) (MNum 64)) (MNum 0)) (MNum 256)) (INil))) +(let t2306 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil))) (ICons t2305 (ICons t2299 (INil))))) +(let t2307 (Op (Iota (MGte (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t2308 (Op (Cast (MNum 256) (F32)) (ICons t2307 (INil)))) +(let t2309 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2306 (ICons t2308 (INil))))) +(let t2310 (Op (Add (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2304 (ICons t2309 (INil))))) +(let t2311 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2312 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2311 (ICons t2310 (INil))))) +(let t2313 (Op (Sum (ECons (MVar "s") (ECons (MNum 256) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2312 (INil)))) +(let t2314 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 256)) (MNum 256)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 512))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 512) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 256))) (INil))) +(let t2315 (Op (Constant -1.000000) (INil))) +(let t2316 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2313 (ICons t2315 (INil))))) +(let t2317 (Op (Constant 1.570796) (INil))) +(let t2318 (Op (Add (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2316 (ICons t2317 (INil))))) +(let t2319 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2318 (INil)))) +(let t2320 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t2313 (INil)))) +(let t2321 (Op (Constant -1.000000) (INil))) +(let t2322 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 512)) (MNum 255)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t2323 (Op (Iota (MLt (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t2324 (Op (Cast (MMax (MMul (MMul (MNum 2) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t2323 (INil)))) +(let t2325 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 512)) (MNum 256)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t2326 (Op (Iota (MGte (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t2327 (Op (Cast (MMax (MMul (MMul (MNum 2) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t2326 (INil)))) +(let t2328 (Op (Iota (MIter) (MNum 2)) (INil))) +(let t2329 (Op (Iota (MNum 2097152) (MNum 1)) (INil))) +(let t2330 (Op (Mul (ECons (MNum 2) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2328 (ICons t2329 (INil))))) +(let t2331 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2332 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2333 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2331 (ICons t2332 (INil))))) +(let t2334 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t2335 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2333 (ICons t2334 (INil))))) +(let t2336 (Op (Iota (MIter) (MNum 512)) (INil))) +(let t2337 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t2330 (ICons t2335 (INil))))) +(let t2338 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t2337 (ICons t2336 (INil))))) +(let t2339 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2340 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2339 (INil)))) +(let t2341 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2342 (Op (Cast (MNum 1) (F32)) (ICons t2341 (INil)))) +(let t2343 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2340 (ICons t2342 (INil))))) +(let t2344 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2345 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2344 (INil)))) +(let t2346 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2343 (ICons t2345 (INil))))) +(let t2347 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2346 (INil)))) +(let t2348 (Op (Constant -10000000000.000000) (INil))) +(let t2349 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2347 (ICons t2348 (INil))))) +(let t2350 (Op (Constant -1.000000) (INil))) +(let t2351 (Op (Constant 1.442695) (INil))) +(let t2352 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2353 (Op (Cast (MNum 1) (F32)) (ICons t2352 (INil)))) +(let t2354 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2353 (INil)))) +(let t2355 (Op (Constant 0.000001) (INil))) +(let t2356 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2357 (Op (Cast (MNum 1) (F32)) (ICons t2356 (INil)))) +(let t2358 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2357 (INil)))) +(let t2359 (Op (Constant 0.000001) (INil))) +(let t2360 (Op (Constant 1.595769) (INil))) +(let t2361 (Op (Constant 0.044715) (INil))) +(let t2362 (Op (Constant 1.000000) (INil))) +(let t2363 (Op (Constant -1.000000) (INil))) +(let t2364 (Op (Constant 1.442695) (INil))) +(let t2365 (Op (Constant 1.000000) (INil))) +(let t2366 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2367 (Op (Cast (MNum 1) (F32)) (ICons t2366 (INil)))) +(let t2368 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2367 (INil)))) +(let t2369 (Op (Constant 0.000001) (INil))) +(let t2370 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2371 (Op (Cast (MNum 1) (F32)) (ICons t2370 (INil)))) +(let t2372 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2371 (INil)))) +(let t2373 (Op (Constant 0.000001) (INil))) +(let t2374 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2375 (Op (Cast (MNum 1) (F32)) (ICons t2374 (INil)))) +(let t2376 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2375 (INil)))) +(let t2377 (Op (Constant 0.000001) (INil))) +(let t2378 (Op (Constant 0.018844) (INil))) +(let t2379 (Op (Constant -1.000000) (INil))) +(let t2380 (Op (Constant 1.442695) (INil))) +(let t2381 (Op (Constant 0.000000) (INil))) +(let t2382 (Op (Constant 0.000000) (INil))) +(let t2383 (Op (Constant 0.000000) (INil))) +(let t2384 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2385 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2386 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2387 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2388 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2389 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2390 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2391 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2392 (Op (Constant 1.595769) (INil))) +(let t2393 (Op (Constant 0.044715) (INil))) +(let t2394 (Op (Constant 1.000000) (INil))) +(let t2395 (Op (Constant -1.000000) (INil))) +(let t2396 (Op (Constant 1.442695) (INil))) +(let t2397 (Op (Constant 1.000000) (INil))) +(let t2398 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2399 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2400 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2401 (Op (Cast (MNum 1) (F32)) (ICons t2400 (INil)))) +(let t2402 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2401 (INil)))) +(let t2403 (Op (Constant 0.000001) (INil))) +(let t2404 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2405 (Op (Cast (MNum 1) (F32)) (ICons t2404 (INil)))) +(let t2406 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2405 (INil)))) +(let t2407 (Op (Constant 0.000001) (INil))) +(let t2408 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2409 (Op (Cast (MNum 1) (F32)) (ICons t2408 (INil)))) +(let t2410 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2409 (INil)))) +(let t2411 (Op (Constant 0.000001) (INil))) +(let t2412 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2413 (Op (Cast (MNum 1) (F32)) (ICons t2412 (INil)))) +(let t2414 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2413 (INil)))) +(let t2415 (Op (Constant 0.000001) (INil))) +(let t2416 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2417 (Op (Cast (MNum 1) (F32)) (ICons t2416 (INil)))) +(let t2418 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2417 (INil)))) +(let t2419 (Op (Constant 0.000001) (INil))) +(let t2420 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2421 (Op (Cast (MNum 1) (F32)) (ICons t2420 (INil)))) +(let t2422 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2421 (INil)))) +(let t2423 (Op (Constant 0.000001) (INil))) +(let t2424 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2425 (Op (Cast (MNum 128) (F32)) (ICons t2424 (INil)))) +(let t2426 (Op (Constant 0.003906) (INil))) +(let t2427 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2425 (ICons t2426 (INil))))) +(let t2428 (Op (Constant 9.210340) (INil))) +(let t2429 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2427 (ICons t2428 (INil))))) +(let t2430 (Op (Constant 1.442695) (INil))) +(let t2431 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2429 (ICons t2430 (INil))))) +(let t2432 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2431 (INil)))) +(let t2433 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2432 (INil)))) +(let t2434 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2435 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2434 (ICons t2433 (INil))))) +(let t2436 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2435 (INil)))) +(let t2437 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t2438 (Op (Constant -1.000000) (INil))) +(let t2439 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2436 (ICons t2438 (INil))))) +(let t2440 (Op (Constant 1.570796) (INil))) +(let t2441 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2439 (ICons t2440 (INil))))) +(let t2442 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2441 (INil)))) +(let t2443 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2436 (INil)))) +(let t2444 (Op (Constant -1.000000) (INil))) +(let t2445 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2446 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2447 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2446 (INil)))) +(let t2448 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2449 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2450 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2449 (INil)))) +(let t2451 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2452 (Op (Cast (MNum 128) (F32)) (ICons t2451 (INil)))) +(let t2453 (Op (Constant 0.003906) (INil))) +(let t2454 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2452 (ICons t2453 (INil))))) +(let t2455 (Op (Constant 9.210340) (INil))) +(let t2456 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2454 (ICons t2455 (INil))))) +(let t2457 (Op (Constant 1.442695) (INil))) +(let t2458 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2456 (ICons t2457 (INil))))) +(let t2459 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2458 (INil)))) +(let t2460 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2459 (INil)))) +(let t2461 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2462 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2461 (ICons t2460 (INil))))) +(let t2463 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2462 (INil)))) +(let t2464 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2465 (Op (Constant -1.000000) (INil))) +(let t2466 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2463 (ICons t2465 (INil))))) +(let t2467 (Op (Constant 1.570796) (INil))) +(let t2468 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2466 (ICons t2467 (INil))))) +(let t2469 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2468 (INil)))) +(let t2470 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2463 (INil)))) +(let t2471 (Op (Constant -1.000000) (INil))) +(let t2472 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2473 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2474 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2473 (INil)))) +(let t2475 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2476 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2477 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2476 (INil)))) +(let t2478 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t2479 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2480 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2478 (ICons t2479 (INil))))) +(let t2481 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2482 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2483 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2481 (ICons t2482 (INil))))) +(let t2484 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2485 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2483 (ICons t2484 (INil))))) +(let t2486 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2487 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2480 (ICons t2485 (INil))))) +(let t2488 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2487 (ICons t2486 (INil))))) +(let t2489 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2490 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2489 (INil)))) +(let t2491 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2492 (Op (Cast (MNum 1) (F32)) (ICons t2491 (INil)))) +(let t2493 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2490 (ICons t2492 (INil))))) +(let t2494 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2495 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2494 (INil)))) +(let t2496 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2493 (ICons t2495 (INil))))) +(let t2497 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2496 (INil)))) +(let t2498 (Op (Constant 1023.000000) (INil))) +(let t2499 (Op (Constant -1.000000) (INil))) +(let t2500 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2498 (ICons t2499 (INil))))) +(let t2501 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2493 (ICons t2500 (INil))))) +(let t2502 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2495 (ICons t2501 (INil))))) +(let t2503 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2502 (INil)))) +(let t2504 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2497 (ICons t2503 (INil))))) +(let t2505 (Op (Constant -10000000000.000000) (INil))) +(let t2506 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2504 (ICons t2505 (INil))))) +(let t2507 (Op (Constant -1.000000) (INil))) +(let t2508 (Op (Constant 1.442695) (INil))) +(let t2509 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2510 (Op (Cast (MNum 1) (F32)) (ICons t2509 (INil)))) +(let t2511 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2510 (INil)))) +(let t2512 (Op (Constant 0.000001) (INil))) +(let t2513 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2514 (Op (Cast (MNum 1) (F32)) (ICons t2513 (INil)))) +(let t2515 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2514 (INil)))) +(let t2516 (Op (Constant 0.000001) (INil))) +(let t2517 (Op (Constant 1.595769) (INil))) +(let t2518 (Op (Constant 0.044715) (INil))) +(let t2519 (Op (Constant 1.000000) (INil))) +(let t2520 (Op (Constant -1.000000) (INil))) +(let t2521 (Op (Constant 1.442695) (INil))) +(let t2522 (Op (Constant 1.000000) (INil))) +(let t2523 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2524 (Op (Cast (MNum 1) (F32)) (ICons t2523 (INil)))) +(let t2525 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2524 (INil)))) +(let t2526 (Op (Constant 0.000001) (INil))) +(let t2527 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2528 (Op (Cast (MNum 1) (F32)) (ICons t2527 (INil)))) +(let t2529 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2528 (INil)))) +(let t2530 (Op (Constant 0.000001) (INil))) +(let t2531 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2532 (Op (Cast (MNum 1) (F32)) (ICons t2531 (INil)))) +(let t2533 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2532 (INil)))) +(let t2534 (Op (Constant 0.000001) (INil))) +(let t2535 (Op (Constant 0.018844) (INil))) +(let t2536 (Op (Constant -1.000000) (INil))) +(let t2537 (Op (Constant 1.442695) (INil))) +(let t2538 (Op (Constant 0.000000) (INil))) +(let t2539 (Op (Constant 0.000000) (INil))) +(let t2540 (Op (Constant 0.000000) (INil))) +(let t2541 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2542 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2543 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2544 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2545 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2546 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2547 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2548 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2549 (Op (Constant 1.595769) (INil))) +(let t2550 (Op (Constant 0.044715) (INil))) +(let t2551 (Op (Constant 1.000000) (INil))) +(let t2552 (Op (Constant -1.000000) (INil))) +(let t2553 (Op (Constant 1.442695) (INil))) +(let t2554 (Op (Constant 1.000000) (INil))) +(let t2555 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2556 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2557 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2558 (Op (Cast (MNum 1) (F32)) (ICons t2557 (INil)))) +(let t2559 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2558 (INil)))) +(let t2560 (Op (Constant 0.000001) (INil))) +(let t2561 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2562 (Op (Cast (MNum 1) (F32)) (ICons t2561 (INil)))) +(let t2563 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2562 (INil)))) +(let t2564 (Op (Constant 0.000001) (INil))) +(let t2565 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2566 (Op (Cast (MNum 1) (F32)) (ICons t2565 (INil)))) +(let t2567 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2566 (INil)))) +(let t2568 (Op (Constant 0.000001) (INil))) +(let t2569 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2570 (Op (Cast (MNum 1) (F32)) (ICons t2569 (INil)))) +(let t2571 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2570 (INil)))) +(let t2572 (Op (Constant 0.000001) (INil))) +(let t2573 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2574 (Op (Cast (MNum 1) (F32)) (ICons t2573 (INil)))) +(let t2575 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2574 (INil)))) +(let t2576 (Op (Constant 0.000001) (INil))) +(let t2577 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2578 (Op (Cast (MNum 1) (F32)) (ICons t2577 (INil)))) +(let t2579 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2578 (INil)))) +(let t2580 (Op (Constant 0.000001) (INil))) +(let t2581 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2582 (Op (Cast (MNum 128) (F32)) (ICons t2581 (INil)))) +(let t2583 (Op (Constant 0.003906) (INil))) +(let t2584 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2582 (ICons t2583 (INil))))) +(let t2585 (Op (Constant 9.210340) (INil))) +(let t2586 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2584 (ICons t2585 (INil))))) +(let t2587 (Op (Constant 1.442695) (INil))) +(let t2588 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2586 (ICons t2587 (INil))))) +(let t2589 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2588 (INil)))) +(let t2590 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2589 (INil)))) +(let t2591 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2592 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2591 (ICons t2590 (INil))))) +(let t2593 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2592 (INil)))) +(let t2594 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t2595 (Op (Constant -1.000000) (INil))) +(let t2596 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2593 (ICons t2595 (INil))))) +(let t2597 (Op (Constant 1.570796) (INil))) +(let t2598 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2596 (ICons t2597 (INil))))) +(let t2599 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2598 (INil)))) +(let t2600 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2593 (INil)))) +(let t2601 (Op (Constant -1.000000) (INil))) +(let t2602 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2603 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2604 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2603 (INil)))) +(let t2605 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2606 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2607 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2606 (INil)))) +(let t2608 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2609 (Op (Cast (MNum 128) (F32)) (ICons t2608 (INil)))) +(let t2610 (Op (Constant 0.003906) (INil))) +(let t2611 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2609 (ICons t2610 (INil))))) +(let t2612 (Op (Constant 9.210340) (INil))) +(let t2613 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2611 (ICons t2612 (INil))))) +(let t2614 (Op (Constant 1.442695) (INil))) +(let t2615 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2613 (ICons t2614 (INil))))) +(let t2616 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2615 (INil)))) +(let t2617 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2616 (INil)))) +(let t2618 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2619 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2618 (ICons t2617 (INil))))) +(let t2620 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2619 (INil)))) +(let t2621 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2622 (Op (Constant -1.000000) (INil))) +(let t2623 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2620 (ICons t2622 (INil))))) +(let t2624 (Op (Constant 1.570796) (INil))) +(let t2625 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2623 (ICons t2624 (INil))))) +(let t2626 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2625 (INil)))) +(let t2627 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2620 (INil)))) +(let t2628 (Op (Constant -1.000000) (INil))) +(let t2629 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2630 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2631 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2630 (INil)))) +(let t2632 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2633 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2634 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2633 (INil)))) +(let t2635 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t2636 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2637 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2635 (ICons t2636 (INil))))) +(let t2638 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2639 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2640 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2638 (ICons t2639 (INil))))) +(let t2641 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2642 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2640 (ICons t2641 (INil))))) +(let t2643 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2644 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2637 (ICons t2642 (INil))))) +(let t2645 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2644 (ICons t2643 (INil))))) +(let t2646 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2647 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2646 (INil)))) +(let t2648 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2649 (Op (Cast (MNum 1) (F32)) (ICons t2648 (INil)))) +(let t2650 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2647 (ICons t2649 (INil))))) +(let t2651 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2652 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2651 (INil)))) +(let t2653 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2650 (ICons t2652 (INil))))) +(let t2654 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2653 (INil)))) +(let t2655 (Op (Constant 1023.000000) (INil))) +(let t2656 (Op (Constant -1.000000) (INil))) +(let t2657 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2655 (ICons t2656 (INil))))) +(let t2658 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2650 (ICons t2657 (INil))))) +(let t2659 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2652 (ICons t2658 (INil))))) +(let t2660 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2659 (INil)))) +(let t2661 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2654 (ICons t2660 (INil))))) +(let t2662 (Op (Constant -10000000000.000000) (INil))) +(let t2663 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2661 (ICons t2662 (INil))))) +(let t2664 (Op (Constant -1.000000) (INil))) +(let t2665 (Op (Constant 1.442695) (INil))) +(let t2666 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2667 (Op (Cast (MNum 1) (F32)) (ICons t2666 (INil)))) +(let t2668 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2667 (INil)))) +(let t2669 (Op (Constant 0.000001) (INil))) +(let t2670 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2671 (Op (Cast (MNum 1) (F32)) (ICons t2670 (INil)))) +(let t2672 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2671 (INil)))) +(let t2673 (Op (Constant 0.000001) (INil))) +(let t2674 (Op (Constant 1.595769) (INil))) +(let t2675 (Op (Constant 0.044715) (INil))) +(let t2676 (Op (Constant 1.000000) (INil))) +(let t2677 (Op (Constant -1.000000) (INil))) +(let t2678 (Op (Constant 1.442695) (INil))) +(let t2679 (Op (Constant 1.000000) (INil))) +(let t2680 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2681 (Op (Cast (MNum 1) (F32)) (ICons t2680 (INil)))) +(let t2682 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2681 (INil)))) +(let t2683 (Op (Constant 0.000001) (INil))) +(let t2684 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2685 (Op (Cast (MNum 1) (F32)) (ICons t2684 (INil)))) +(let t2686 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2685 (INil)))) +(let t2687 (Op (Constant 0.000001) (INil))) +(let t2688 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2689 (Op (Cast (MNum 1) (F32)) (ICons t2688 (INil)))) +(let t2690 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2689 (INil)))) +(let t2691 (Op (Constant 0.000001) (INil))) +(let t2692 (Op (Constant 0.018844) (INil))) +(let t2693 (Op (Constant -1.000000) (INil))) +(let t2694 (Op (Constant 1.442695) (INil))) +(let t2695 (Op (Constant 0.000000) (INil))) +(let t2696 (Op (Constant 0.000000) (INil))) +(let t2697 (Op (Constant 0.000000) (INil))) +(let t2698 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2699 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2700 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2701 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2702 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2703 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2704 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2705 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2706 (Op (Constant 1.595769) (INil))) +(let t2707 (Op (Constant 0.044715) (INil))) +(let t2708 (Op (Constant 1.000000) (INil))) +(let t2709 (Op (Constant -1.000000) (INil))) +(let t2710 (Op (Constant 1.442695) (INil))) +(let t2711 (Op (Constant 1.000000) (INil))) +(let t2712 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2713 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2714 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2715 (Op (Cast (MNum 1) (F32)) (ICons t2714 (INil)))) +(let t2716 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2715 (INil)))) +(let t2717 (Op (Constant 0.000001) (INil))) +(let t2718 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2719 (Op (Cast (MNum 1) (F32)) (ICons t2718 (INil)))) +(let t2720 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2719 (INil)))) +(let t2721 (Op (Constant 0.000001) (INil))) +(let t2722 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2723 (Op (Cast (MNum 1) (F32)) (ICons t2722 (INil)))) +(let t2724 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2723 (INil)))) +(let t2725 (Op (Constant 0.000001) (INil))) +(let t2726 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2727 (Op (Cast (MNum 1) (F32)) (ICons t2726 (INil)))) +(let t2728 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2727 (INil)))) +(let t2729 (Op (Constant 0.000001) (INil))) +(let t2730 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2731 (Op (Cast (MNum 1) (F32)) (ICons t2730 (INil)))) +(let t2732 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2731 (INil)))) +(let t2733 (Op (Constant 0.000001) (INil))) +(let t2734 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2735 (Op (Cast (MNum 1) (F32)) (ICons t2734 (INil)))) +(let t2736 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2735 (INil)))) +(let t2737 (Op (Constant 0.000001) (INil))) +(let t2738 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2739 (Op (Cast (MNum 128) (F32)) (ICons t2738 (INil)))) +(let t2740 (Op (Constant 0.003906) (INil))) +(let t2741 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2739 (ICons t2740 (INil))))) +(let t2742 (Op (Constant 9.210340) (INil))) +(let t2743 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2741 (ICons t2742 (INil))))) +(let t2744 (Op (Constant 1.442695) (INil))) +(let t2745 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2743 (ICons t2744 (INil))))) +(let t2746 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2745 (INil)))) +(let t2747 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2746 (INil)))) +(let t2748 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2749 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2748 (ICons t2747 (INil))))) +(let t2750 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2749 (INil)))) +(let t2751 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t2752 (Op (Constant -1.000000) (INil))) +(let t2753 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2750 (ICons t2752 (INil))))) +(let t2754 (Op (Constant 1.570796) (INil))) +(let t2755 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2753 (ICons t2754 (INil))))) +(let t2756 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2755 (INil)))) +(let t2757 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2750 (INil)))) +(let t2758 (Op (Constant -1.000000) (INil))) +(let t2759 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2760 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2761 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2760 (INil)))) +(let t2762 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2763 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2764 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2763 (INil)))) +(let t2765 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2766 (Op (Cast (MNum 128) (F32)) (ICons t2765 (INil)))) +(let t2767 (Op (Constant 0.003906) (INil))) +(let t2768 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2766 (ICons t2767 (INil))))) +(let t2769 (Op (Constant 9.210340) (INil))) +(let t2770 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2768 (ICons t2769 (INil))))) +(let t2771 (Op (Constant 1.442695) (INil))) +(let t2772 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2770 (ICons t2771 (INil))))) +(let t2773 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2772 (INil)))) +(let t2774 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2773 (INil)))) +(let t2775 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2776 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2775 (ICons t2774 (INil))))) +(let t2777 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2776 (INil)))) +(let t2778 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2779 (Op (Constant -1.000000) (INil))) +(let t2780 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2777 (ICons t2779 (INil))))) +(let t2781 (Op (Constant 1.570796) (INil))) +(let t2782 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2780 (ICons t2781 (INil))))) +(let t2783 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2782 (INil)))) +(let t2784 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2777 (INil)))) +(let t2785 (Op (Constant -1.000000) (INil))) +(let t2786 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2787 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2788 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2787 (INil)))) +(let t2789 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2790 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2791 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2790 (INil)))) +(let t2792 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t2793 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2794 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2792 (ICons t2793 (INil))))) +(let t2795 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2796 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2797 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2795 (ICons t2796 (INil))))) +(let t2798 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2799 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2797 (ICons t2798 (INil))))) +(let t2800 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2801 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2794 (ICons t2799 (INil))))) +(let t2802 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2801 (ICons t2800 (INil))))) +(let t2803 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2804 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2803 (INil)))) +(let t2805 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2806 (Op (Cast (MNum 1) (F32)) (ICons t2805 (INil)))) +(let t2807 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2804 (ICons t2806 (INil))))) +(let t2808 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2809 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2808 (INil)))) +(let t2810 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2807 (ICons t2809 (INil))))) +(let t2811 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2810 (INil)))) +(let t2812 (Op (Constant 1023.000000) (INil))) +(let t2813 (Op (Constant -1.000000) (INil))) +(let t2814 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2812 (ICons t2813 (INil))))) +(let t2815 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2807 (ICons t2814 (INil))))) +(let t2816 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2809 (ICons t2815 (INil))))) +(let t2817 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2816 (INil)))) +(let t2818 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2811 (ICons t2817 (INil))))) +(let t2819 (Op (Constant -10000000000.000000) (INil))) +(let t2820 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2818 (ICons t2819 (INil))))) +(let t2821 (Op (Constant -1.000000) (INil))) +(let t2822 (Op (Constant 1.442695) (INil))) +(let t2823 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2824 (Op (Cast (MNum 1) (F32)) (ICons t2823 (INil)))) +(let t2825 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2824 (INil)))) +(let t2826 (Op (Constant 0.000001) (INil))) +(let t2827 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2828 (Op (Cast (MNum 1) (F32)) (ICons t2827 (INil)))) +(let t2829 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2828 (INil)))) +(let t2830 (Op (Constant 0.000001) (INil))) +(let t2831 (Op (Constant 1.595769) (INil))) +(let t2832 (Op (Constant 0.044715) (INil))) +(let t2833 (Op (Constant 1.000000) (INil))) +(let t2834 (Op (Constant -1.000000) (INil))) +(let t2835 (Op (Constant 1.442695) (INil))) +(let t2836 (Op (Constant 1.000000) (INil))) +(let t2837 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2838 (Op (Cast (MNum 1) (F32)) (ICons t2837 (INil)))) +(let t2839 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2838 (INil)))) +(let t2840 (Op (Constant 0.000001) (INil))) +(let t2841 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2842 (Op (Cast (MNum 1) (F32)) (ICons t2841 (INil)))) +(let t2843 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2842 (INil)))) +(let t2844 (Op (Constant 0.000001) (INil))) +(let t2845 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2846 (Op (Cast (MNum 1) (F32)) (ICons t2845 (INil)))) +(let t2847 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2846 (INil)))) +(let t2848 (Op (Constant 0.000001) (INil))) +(let t2849 (Op (Constant 0.018844) (INil))) +(let t2850 (Op (Constant -1.000000) (INil))) +(let t2851 (Op (Constant 1.442695) (INil))) +(let t2852 (Op (Constant 0.000000) (INil))) +(let t2853 (Op (Constant 0.000000) (INil))) +(let t2854 (Op (Constant 0.000000) (INil))) +(let t2855 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t2856 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t2857 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t2858 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t2859 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t2860 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t2861 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t2862 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t2863 (Op (Constant 1.595769) (INil))) +(let t2864 (Op (Constant 0.044715) (INil))) +(let t2865 (Op (Constant 1.000000) (INil))) +(let t2866 (Op (Constant -1.000000) (INil))) +(let t2867 (Op (Constant 1.442695) (INil))) +(let t2868 (Op (Constant 1.000000) (INil))) +(let t2869 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t2870 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t2871 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2872 (Op (Cast (MNum 1) (F32)) (ICons t2871 (INil)))) +(let t2873 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2872 (INil)))) +(let t2874 (Op (Constant 0.000001) (INil))) +(let t2875 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2876 (Op (Cast (MNum 1) (F32)) (ICons t2875 (INil)))) +(let t2877 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2876 (INil)))) +(let t2878 (Op (Constant 0.000001) (INil))) +(let t2879 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2880 (Op (Cast (MNum 1) (F32)) (ICons t2879 (INil)))) +(let t2881 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2880 (INil)))) +(let t2882 (Op (Constant 0.000001) (INil))) +(let t2883 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2884 (Op (Cast (MNum 1) (F32)) (ICons t2883 (INil)))) +(let t2885 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t2884 (INil)))) +(let t2886 (Op (Constant 0.000001) (INil))) +(let t2887 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2888 (Op (Cast (MNum 1) (F32)) (ICons t2887 (INil)))) +(let t2889 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2888 (INil)))) +(let t2890 (Op (Constant 0.000001) (INil))) +(let t2891 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2892 (Op (Cast (MNum 1) (F32)) (ICons t2891 (INil)))) +(let t2893 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2892 (INil)))) +(let t2894 (Op (Constant 0.000001) (INil))) +(let t2895 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2896 (Op (Cast (MNum 128) (F32)) (ICons t2895 (INil)))) +(let t2897 (Op (Constant 0.003906) (INil))) +(let t2898 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2896 (ICons t2897 (INil))))) +(let t2899 (Op (Constant 9.210340) (INil))) +(let t2900 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2898 (ICons t2899 (INil))))) +(let t2901 (Op (Constant 1.442695) (INil))) +(let t2902 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2900 (ICons t2901 (INil))))) +(let t2903 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2902 (INil)))) +(let t2904 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2903 (INil)))) +(let t2905 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2906 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2905 (ICons t2904 (INil))))) +(let t2907 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2906 (INil)))) +(let t2908 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t2909 (Op (Constant -1.000000) (INil))) +(let t2910 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2907 (ICons t2909 (INil))))) +(let t2911 (Op (Constant 1.570796) (INil))) +(let t2912 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2910 (ICons t2911 (INil))))) +(let t2913 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2912 (INil)))) +(let t2914 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2907 (INil)))) +(let t2915 (Op (Constant -1.000000) (INil))) +(let t2916 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2917 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2918 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2917 (INil)))) +(let t2919 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2920 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t2921 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2920 (INil)))) +(let t2922 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t2923 (Op (Cast (MNum 128) (F32)) (ICons t2922 (INil)))) +(let t2924 (Op (Constant 0.003906) (INil))) +(let t2925 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2923 (ICons t2924 (INil))))) +(let t2926 (Op (Constant 9.210340) (INil))) +(let t2927 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2925 (ICons t2926 (INil))))) +(let t2928 (Op (Constant 1.442695) (INil))) +(let t2929 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2927 (ICons t2928 (INil))))) +(let t2930 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2929 (INil)))) +(let t2931 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2930 (INil)))) +(let t2932 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t2933 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t2932 (ICons t2931 (INil))))) +(let t2934 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2933 (INil)))) +(let t2935 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t2936 (Op (Constant -1.000000) (INil))) +(let t2937 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2934 (ICons t2936 (INil))))) +(let t2938 (Op (Constant 1.570796) (INil))) +(let t2939 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2937 (ICons t2938 (INil))))) +(let t2940 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2939 (INil)))) +(let t2941 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2934 (INil)))) +(let t2942 (Op (Constant -1.000000) (INil))) +(let t2943 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2944 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2945 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2944 (INil)))) +(let t2946 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2947 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t2948 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t2947 (INil)))) +(let t2949 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t2950 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t2951 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2949 (ICons t2950 (INil))))) +(let t2952 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2953 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2954 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2952 (ICons t2953 (INil))))) +(let t2955 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t2956 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2954 (ICons t2955 (INil))))) +(let t2957 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t2958 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2951 (ICons t2956 (INil))))) +(let t2959 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2958 (ICons t2957 (INil))))) +(let t2960 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t2961 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t2960 (INil)))) +(let t2962 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t2963 (Op (Cast (MNum 1) (F32)) (ICons t2962 (INil)))) +(let t2964 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2961 (ICons t2963 (INil))))) +(let t2965 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t2966 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t2965 (INil)))) +(let t2967 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2964 (ICons t2966 (INil))))) +(let t2968 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2967 (INil)))) +(let t2969 (Op (Constant 1023.000000) (INil))) +(let t2970 (Op (Constant -1.000000) (INil))) +(let t2971 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2969 (ICons t2970 (INil))))) +(let t2972 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t2964 (ICons t2971 (INil))))) +(let t2973 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2966 (ICons t2972 (INil))))) +(let t2974 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t2973 (INil)))) +(let t2975 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t2968 (ICons t2974 (INil))))) +(let t2976 (Op (Constant -10000000000.000000) (INil))) +(let t2977 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t2975 (ICons t2976 (INil))))) +(let t2978 (Op (Constant -1.000000) (INil))) +(let t2979 (Op (Constant 1.442695) (INil))) +(let t2980 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2981 (Op (Cast (MNum 1) (F32)) (ICons t2980 (INil)))) +(let t2982 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2981 (INil)))) +(let t2983 (Op (Constant 0.000001) (INil))) +(let t2984 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2985 (Op (Cast (MNum 1) (F32)) (ICons t2984 (INil)))) +(let t2986 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2985 (INil)))) +(let t2987 (Op (Constant 0.000001) (INil))) +(let t2988 (Op (Constant 1.595769) (INil))) +(let t2989 (Op (Constant 0.044715) (INil))) +(let t2990 (Op (Constant 1.000000) (INil))) +(let t2991 (Op (Constant -1.000000) (INil))) +(let t2992 (Op (Constant 1.442695) (INil))) +(let t2993 (Op (Constant 1.000000) (INil))) +(let t2994 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2995 (Op (Cast (MNum 1) (F32)) (ICons t2994 (INil)))) +(let t2996 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2995 (INil)))) +(let t2997 (Op (Constant 0.000001) (INil))) +(let t2998 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t2999 (Op (Cast (MNum 1) (F32)) (ICons t2998 (INil)))) +(let t3000 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2999 (INil)))) +(let t3001 (Op (Constant 0.000001) (INil))) +(let t3002 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3003 (Op (Cast (MNum 1) (F32)) (ICons t3002 (INil)))) +(let t3004 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3003 (INil)))) +(let t3005 (Op (Constant 0.000001) (INil))) +(let t3006 (Op (Constant 0.018844) (INil))) +(let t3007 (Op (Constant -1.000000) (INil))) +(let t3008 (Op (Constant 1.442695) (INil))) +(let t3009 (Op (Constant 0.000000) (INil))) +(let t3010 (Op (Constant 0.000000) (INil))) +(let t3011 (Op (Constant 0.000000) (INil))) +(let t3012 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t3013 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t3014 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t3015 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t3016 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t3017 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t3018 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t3019 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t3020 (Op (Constant 1.595769) (INil))) +(let t3021 (Op (Constant 0.044715) (INil))) +(let t3022 (Op (Constant 1.000000) (INil))) +(let t3023 (Op (Constant -1.000000) (INil))) +(let t3024 (Op (Constant 1.442695) (INil))) +(let t3025 (Op (Constant 1.000000) (INil))) +(let t3026 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t3027 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t3028 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3029 (Op (Cast (MNum 1) (F32)) (ICons t3028 (INil)))) +(let t3030 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3029 (INil)))) +(let t3031 (Op (Constant 0.000001) (INil))) +(let t3032 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3033 (Op (Cast (MNum 1) (F32)) (ICons t3032 (INil)))) +(let t3034 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3033 (INil)))) +(let t3035 (Op (Constant 0.000001) (INil))) +(let t3036 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3037 (Op (Cast (MNum 1) (F32)) (ICons t3036 (INil)))) +(let t3038 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3037 (INil)))) +(let t3039 (Op (Constant 0.000001) (INil))) +(let t3040 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t3041 (Op (Cast (MNum 1) (F32)) (ICons t3040 (INil)))) +(let t3042 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3041 (INil)))) +(let t3043 (Op (Constant 0.000001) (INil))) +(let t3044 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t3045 (Op (Cast (MNum 1) (F32)) (ICons t3044 (INil)))) +(let t3046 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3045 (INil)))) +(let t3047 (Op (Constant 0.000001) (INil))) +(let t3048 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t3049 (Op (Cast (MNum 1) (F32)) (ICons t3048 (INil)))) +(let t3050 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3049 (INil)))) +(let t3051 (Op (Constant 0.000001) (INil))) +(let t3052 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t3053 (Op (Cast (MNum 128) (F32)) (ICons t3052 (INil)))) +(let t3054 (Op (Constant 0.003906) (INil))) +(let t3055 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3053 (ICons t3054 (INil))))) +(let t3056 (Op (Constant 9.210340) (INil))) +(let t3057 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3055 (ICons t3056 (INil))))) +(let t3058 (Op (Constant 1.442695) (INil))) +(let t3059 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3057 (ICons t3058 (INil))))) +(let t3060 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3059 (INil)))) +(let t3061 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3060 (INil)))) +(let t3062 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t3063 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t3062 (ICons t3061 (INil))))) +(let t3064 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3063 (INil)))) +(let t3065 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 128))) (INil))) +(let t3066 (Op (Constant -1.000000) (INil))) +(let t3067 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3064 (ICons t3066 (INil))))) +(let t3068 (Op (Constant 1.570796) (INil))) +(let t3069 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3067 (ICons t3068 (INil))))) +(let t3070 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3069 (INil)))) +(let t3071 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3064 (INil)))) +(let t3072 (Op (Constant -1.000000) (INil))) +(let t3073 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t3074 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t3075 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t3074 (INil)))) +(let t3076 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t3077 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t3078 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t3077 (INil)))) +(let t3079 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 128)) (INil))) +(let t3080 (Op (Cast (MNum 128) (F32)) (ICons t3079 (INil)))) +(let t3081 (Op (Constant 0.003906) (INil))) +(let t3082 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3080 (ICons t3081 (INil))))) +(let t3083 (Op (Constant 9.210340) (INil))) +(let t3084 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3082 (ICons t3083 (INil))))) +(let t3085 (Op (Constant 1.442695) (INil))) +(let t3086 (Op (Mul (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3084 (ICons t3085 (INil))))) +(let t3087 (Op (Exp2 (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3086 (INil)))) +(let t3088 (Op (Recip (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3087 (INil)))) +(let t3089 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t3090 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t3089 (ICons t3088 (INil))))) +(let t3091 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3090 (INil)))) +(let t3092 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 128)) (MNum 128)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t3093 (Op (Constant -1.000000) (INil))) +(let t3094 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3091 (ICons t3093 (INil))))) +(let t3095 (Op (Constant 1.570796) (INil))) +(let t3096 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3094 (ICons t3095 (INil))))) +(let t3097 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3096 (INil)))) +(let t3098 (Op (Sin (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3091 (INil)))) +(let t3099 (Op (Constant -1.000000) (INil))) +(let t3100 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 256)) (MNum 127)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t3101 (Op (Iota (MLt (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t3102 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t3101 (INil)))) +(let t3103 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 256)) (MNum 128)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t3104 (Op (Iota (MGte (MMod (MIter) (MNum 256)) (MNum 128)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 256))) (INil))) +(let t3105 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 256)) (MNum 1)) (F32)) (ICons t3104 (INil)))) +(let t3106 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t3107 (Op (Iota (MNum 1048576) (MNum 1)) (INil))) +(let t3108 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3106 (ICons t3107 (INil))))) +(let t3109 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t3110 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t3111 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3109 (ICons t3110 (INil))))) +(let t3112 (Op (Iota (MNum 256) (MNum 1)) (INil))) +(let t3113 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3111 (ICons t3112 (INil))))) +(let t3114 (Op (Iota (MIter) (MNum 256)) (INil))) +(let t3115 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3108 (ICons t3113 (INil))))) +(let t3116 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3115 (ICons t3114 (INil))))) +(let t3117 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t3118 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t3117 (INil)))) +(let t3119 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t3120 (Op (Cast (MNum 1) (F32)) (ICons t3119 (INil)))) +(let t3121 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3118 (ICons t3120 (INil))))) +(let t3122 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t3123 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t3122 (INil)))) +(let t3124 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t3121 (ICons t3123 (INil))))) +(let t3125 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t3124 (INil)))) +(let t3126 (Op (Constant 1023.000000) (INil))) +(let t3127 (Op (Constant -1.000000) (INil))) +(let t3128 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3126 (ICons t3127 (INil))))) +(let t3129 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3121 (ICons t3128 (INil))))) +(let t3130 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t3123 (ICons t3129 (INil))))) +(let t3131 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t3130 (INil)))) +(let t3132 (Op (Add (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t3125 (ICons t3131 (INil))))) +(let t3133 (Op (Constant -10000000000.000000) (INil))) +(let t3134 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t3132 (ICons t3133 (INil))))) +(let t3135 (Op (Constant -1.000000) (INil))) +(let t3136 (Op (Constant 1.442695) (INil))) +(let t3137 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3138 (Op (Cast (MNum 1) (F32)) (ICons t3137 (INil)))) +(let t3139 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3138 (INil)))) +(let t3140 (Op (Constant 0.000001) (INil))) +(let t3141 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3142 (Op (Cast (MNum 1) (F32)) (ICons t3141 (INil)))) +(let t3143 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3142 (INil)))) +(let t3144 (Op (Constant 0.000001) (INil))) +(let t3145 (Op (Constant 1.595769) (INil))) +(let t3146 (Op (Constant 0.044715) (INil))) +(let t3147 (Op (Constant 1.000000) (INil))) +(let t3148 (Op (Constant -1.000000) (INil))) +(let t3149 (Op (Constant 1.442695) (INil))) +(let t3150 (Op (Constant 1.000000) (INil))) +(let t3151 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3152 (Op (Cast (MNum 1) (F32)) (ICons t3151 (INil)))) +(let t3153 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3152 (INil)))) +(let t3154 (Op (Constant 0.000001) (INil))) +(let t3155 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3156 (Op (Cast (MNum 1) (F32)) (ICons t3155 (INil)))) +(let t3157 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3156 (INil)))) +(let t3158 (Op (Constant 0.000001) (INil))) +(let t3159 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3160 (Op (Cast (MNum 1) (F32)) (ICons t3159 (INil)))) +(let t3161 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3160 (INil)))) +(let t3162 (Op (Constant 0.000001) (INil))) +(let t3163 (Op (Constant 0.018844) (INil))) +(let t3164 (Op (Constant -1.000000) (INil))) +(let t3165 (Op (Constant 1.442695) (INil))) +(let t3166 (Op (Constant 0.000000) (INil))) +(let t3167 (Op (Constant 0.000000) (INil))) +(let t3168 (Op (Constant 0.000000) (INil))) +(let t3169 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t3170 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t3171 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t3172 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t3173 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t3174 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t3175 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t3176 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t3177 (Op (Constant 1.595769) (INil))) +(let t3178 (Op (Constant 0.044715) (INil))) +(let t3179 (Op (Constant 1.000000) (INil))) +(let t3180 (Op (Constant -1.000000) (INil))) +(let t3181 (Op (Constant 1.442695) (INil))) +(let t3182 (Op (Constant 1.000000) (INil))) +(let t3183 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t3184 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t3185 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3186 (Op (Cast (MNum 1) (F32)) (ICons t3185 (INil)))) +(let t3187 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3186 (INil)))) +(let t3188 (Op (Constant 0.000001) (INil))) +(let t3189 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3190 (Op (Cast (MNum 1) (F32)) (ICons t3189 (INil)))) +(let t3191 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3190 (INil)))) +(let t3192 (Op (Constant 0.000001) (INil))) +(let t3193 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3194 (Op (Cast (MNum 1) (F32)) (ICons t3193 (INil)))) +(let t3195 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3194 (INil)))) +(let t3196 (Op (Constant 0.000001) (INil))) +(let t3197 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t3198 (Op (Cast (MNum 1) (F32)) (ICons t3197 (INil)))) +(let t3199 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3198 (INil)))) +(let t3200 (Op (Constant 0.000001) (INil))) +(let t3201 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t3202 (Op (Cast (MNum 1) (F32)) (ICons t3201 (INil)))) +(let t3203 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t3202 (INil)))) +(let t3204 (Op (Constant 0.000001) (INil))) +(let t3205 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t3206 (Op (Cast (MNum 1) (F32)) (ICons t3205 (INil)))) +(let t3207 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t3206 (INil)))) +(let t3208 (Op (Constant 0.000001) (INil))) +(let t3209 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t3210 (Op (Cast (MNum 64) (F32)) (ICons t3209 (INil)))) +(let t3211 (Op (Constant 0.001953) (INil))) +(let t3212 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3210 (ICons t3211 (INil))))) +(let t3213 (Op (Constant 13.815511) (INil))) +(let t3214 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3212 (ICons t3213 (INil))))) +(let t3215 (Op (Constant 1.442695) (INil))) +(let t3216 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3214 (ICons t3215 (INil))))) +(let t3217 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3216 (INil)))) +(let t3218 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3217 (INil)))) +(let t3219 (Op (Iota (MIter) (MNum 192)) (INil))) +(let t3220 (Op (Cast (MNum 192) (F32)) (ICons t3219 (INil)))) +(let t3221 (Op (Constant 0.000000) (INil))) +(let t3222 (Op (Mul (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3220 (ICons t3221 (INil))))) +(let t3223 (Op (Iota (MMin (MIter) (MNum 63)) (MNum 256)) (INil))) +(let t3224 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil))) (ICons t3223 (ICons t3218 (INil))))) +(let t3225 (Op (Iota (MLt (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t3226 (Op (Cast (MNum 256) (F32)) (ICons t3225 (INil)))) +(let t3227 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3224 (ICons t3226 (INil))))) +(let t3228 (Op (Iota (MMax (MSub (MIter) (MNum 64)) (MNum 0)) (MNum 256)) (INil))) +(let t3229 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil))) (ICons t3228 (ICons t3222 (INil))))) +(let t3230 (Op (Iota (MGte (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t3231 (Op (Cast (MNum 256) (F32)) (ICons t3230 (INil)))) +(let t3232 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3229 (ICons t3231 (INil))))) +(let t3233 (Op (Add (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3227 (ICons t3232 (INil))))) +(let t3234 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t3235 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t3234 (ICons t3233 (INil))))) +(let t3236 (Op (Sum (ECons (MVar "s") (ECons (MNum 256) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3235 (INil)))) +(let t3237 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 256)) (MNum 256)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 512))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 512) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 256))) (INil))) +(let t3238 (Op (Constant -1.000000) (INil))) +(let t3239 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3236 (ICons t3238 (INil))))) +(let t3240 (Op (Constant 1.570796) (INil))) +(let t3241 (Op (Add (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3239 (ICons t3240 (INil))))) +(let t3242 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3241 (INil)))) +(let t3243 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3236 (INil)))) +(let t3244 (Op (Constant -1.000000) (INil))) +(let t3245 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 512)) (MNum 255)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t3246 (Op (Iota (MLt (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t3247 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t3246 (INil)))) +(let t3248 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 512)) (MNum 256)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t3249 (Op (Iota (MGte (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 16) (MVar "s")) (MNum 512))) (INil))) +(let t3250 (Op (Cast (MMax (MMul (MMul (MNum 16) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t3249 (INil)))) +(let t3251 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t3252 (Op (Cast (MNum 64) (F32)) (ICons t3251 (INil)))) +(let t3253 (Op (Constant 0.001953) (INil))) +(let t3254 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3252 (ICons t3253 (INil))))) +(let t3255 (Op (Constant 13.815511) (INil))) +(let t3256 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3254 (ICons t3255 (INil))))) +(let t3257 (Op (Constant 1.442695) (INil))) +(let t3258 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3256 (ICons t3257 (INil))))) +(let t3259 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3258 (INil)))) +(let t3260 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3259 (INil)))) +(let t3261 (Op (Iota (MIter) (MNum 192)) (INil))) +(let t3262 (Op (Cast (MNum 192) (F32)) (ICons t3261 (INil)))) +(let t3263 (Op (Constant 0.000000) (INil))) +(let t3264 (Op (Mul (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3262 (ICons t3263 (INil))))) +(let t3265 (Op (Iota (MMin (MIter) (MNum 63)) (MNum 256)) (INil))) +(let t3266 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil))) (ICons t3265 (ICons t3260 (INil))))) +(let t3267 (Op (Iota (MLt (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t3268 (Op (Cast (MNum 256) (F32)) (ICons t3267 (INil)))) +(let t3269 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3266 (ICons t3268 (INil))))) +(let t3270 (Op (Iota (MMax (MSub (MIter) (MNum 64)) (MNum 0)) (MNum 256)) (INil))) +(let t3271 (Op (Gather (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 192) (ENil)) (ECons (MIter) (ENil))) (ICons t3270 (ICons t3264 (INil))))) +(let t3272 (Op (Iota (MGte (MIter) (MNum 64)) (MNum 256)) (INil))) +(let t3273 (Op (Cast (MNum 256) (F32)) (ICons t3272 (INil)))) +(let t3274 (Op (Mul (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3271 (ICons t3273 (INil))))) +(let t3275 (Op (Add (ECons (MNum 256) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3269 (ICons t3274 (INil))))) +(let t3276 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t3277 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t3276 (ICons t3275 (INil))))) +(let t3278 (Op (Sum (ECons (MVar "s") (ECons (MNum 256) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3277 (INil)))) +(let t3279 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 256)) (MNum 256)) (MMul (MMod (MDiv (MIter) (MNum 256)) (MVar "s")) (MNum 512))) (MMul (MDiv (MIter) (MMul (MNum 256) (MVar "s"))) (MMul (MNum 512) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 256))) (INil))) +(let t3280 (Op (Constant -1.000000) (INil))) +(let t3281 (Op (Mul (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3278 (ICons t3280 (INil))))) +(let t3282 (Op (Constant 1.570796) (INil))) +(let t3283 (Op (Add (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3281 (ICons t3282 (INil))))) +(let t3284 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3283 (INil)))) +(let t3285 (Op (Sin (ECons (MVar "s") (ECons (MNum 256) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ICons t3278 (INil)))) +(let t3286 (Op (Constant -1.000000) (INil))) +(let t3287 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 512)) (MNum 255)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t3288 (Op (Iota (MLt (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t3289 (Op (Cast (MMax (MMul (MMul (MNum 2) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t3288 (INil)))) +(let t3290 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 512)) (MNum 256)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 512)) (MVar "s")) (MNum 256))) (MMul (MDiv (MIter) (MMul (MNum 512) (MVar "s"))) (MMul (MNum 256) (MVar "s")))) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t3291 (Op (Iota (MGte (MMod (MIter) (MNum 512)) (MNum 256)) (MMul (MMul (MNum 2) (MVar "s")) (MNum 512))) (INil))) +(let t3292 (Op (Cast (MMax (MMul (MMul (MNum 2) (MVar "s")) (MNum 512)) (MNum 1)) (F32)) (ICons t3291 (INil)))) +(let t3293 (Op (Iota (MIter) (MNum 2)) (INil))) +(let t3294 (Op (Iota (MNum 2097152) (MNum 1)) (INil))) +(let t3295 (Op (Mul (ECons (MNum 2) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3293 (ICons t3294 (INil))))) +(let t3296 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t3297 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t3298 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3296 (ICons t3297 (INil))))) +(let t3299 (Op (Iota (MNum 512) (MNum 1)) (INil))) +(let t3300 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3298 (ICons t3299 (INil))))) +(let t3301 (Op (Iota (MIter) (MNum 512)) (INil))) +(let t3302 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t3295 (ICons t3300 (INil))))) +(let t3303 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t3302 (ICons t3301 (INil))))) +(let t3304 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t3305 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t3304 (INil)))) +(let t3306 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t3307 (Op (Cast (MNum 1) (F32)) (ICons t3306 (INil)))) +(let t3308 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3305 (ICons t3307 (INil))))) +(let t3309 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t3310 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t3309 (INil)))) +(let t3311 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t3308 (ICons t3310 (INil))))) +(let t3312 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t3311 (INil)))) +(let t3313 (Op (Constant -10000000000.000000) (INil))) +(let t3314 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t3312 (ICons t3313 (INil))))) +(let t3315 (Op (Constant -1.000000) (INil))) +(let t3316 (Op (Constant 1.442695) (INil))) +(let t3317 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3318 (Op (Cast (MNum 1) (F32)) (ICons t3317 (INil)))) +(let t3319 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3318 (INil)))) +(let t3320 (Op (Constant 0.000001) (INil))) +(let t3321 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3322 (Op (Cast (MNum 1) (F32)) (ICons t3321 (INil)))) +(let t3323 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3322 (INil)))) +(let t3324 (Op (Constant 0.000001) (INil))) +(let t3325 (Op (Constant 1.595769) (INil))) +(let t3326 (Op (Constant 0.044715) (INil))) +(let t3327 (Op (Constant 1.000000) (INil))) +(let t3328 (Op (Constant -1.000000) (INil))) +(let t3329 (Op (Constant 1.442695) (INil))) +(let t3330 (Op (Constant 1.000000) (INil))) +(let t3331 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3332 (Op (Cast (MNum 1) (F32)) (ICons t3331 (INil)))) +(let t3333 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3332 (INil)))) +(let t3334 (Op (Constant 0.000001) (INil))) +(let t3335 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3336 (Op (Cast (MNum 1) (F32)) (ICons t3335 (INil)))) +(let t3337 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3336 (INil)))) +(let t3338 (Op (Constant 0.000001) (INil))) +(let t3339 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3340 (Op (Cast (MNum 1) (F32)) (ICons t3339 (INil)))) +(let t3341 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3340 (INil)))) +(let t3342 (Op (Constant 0.000001) (INil))) +(let t3343 (Op (Constant 0.018844) (INil))) +(let t3344 (Op (Constant -1.000000) (INil))) +(let t3345 (Op (Constant 1.442695) (INil))) +(let t3346 (Op (Constant 0.000000) (INil))) +(let t3347 (Op (Constant 0.000000) (INil))) +(let t3348 (Op (Constant 0.000000) (INil))) +(let t3349 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t3350 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t3351 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t3352 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t3353 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t3354 (Op (Iota (MNum 3964928) (MNum 1)) (INil))) +(let t3355 (Op (Iota (MIter) (MNum 3964928)) (INil))) +(let t3356 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 704)) (MNum 704)) (MMul (MMod (MDiv (MIter) (MNum 704)) (MNum 8)) (MNum 1408))) (MMul (MDiv (MIter) (MNum 5632)) (MNum 11264))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 704))) (INil))) +(let t3357 (Op (Constant 1.595769) (INil))) +(let t3358 (Op (Constant 0.044715) (INil))) +(let t3359 (Op (Constant 1.000000) (INil))) +(let t3360 (Op (Constant -1.000000) (INil))) +(let t3361 (Op (Constant 1.442695) (INil))) +(let t3362 (Op (Constant 1.000000) (INil))) +(let t3363 (Op (Iota (MNum 1982464) (MNum 1)) (INil))) +(let t3364 (Op (Iota (MIter) (MNum 1982464)) (INil))) +(let t3365 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3366 (Op (Cast (MNum 1) (F32)) (ICons t3365 (INil)))) +(let t3367 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3366 (INil)))) +(let t3368 (Op (Constant 0.000001) (INil))) +(let t3369 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3370 (Op (Cast (MNum 1) (F32)) (ICons t3369 (INil)))) +(let t3371 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3370 (INil)))) +(let t3372 (Op (Constant 0.000001) (INil))) +(let t3373 (Op (Iota (MNum 2816) (MNum 1)) (INil))) +(let t3374 (Op (Cast (MNum 1) (F32)) (ICons t3373 (INil)))) +(let t3375 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3374 (INil)))) +(let t3376 (Op (Constant 0.000001) (INil))) +(let t3377 (Op (Constant 0.033333) (INil))) +(let t3378 (Op (Constant 2.000000) (INil))) +(let t3379 (Op (Constant -1.000000) (INil))) +(let t3380 (Op (Constant 1.442695) (INil))) +(let t3381 (Op (Constant 1.000000) (INil))) +(let t3382 (Op (Constant 2.000000) (INil))) +(let t3383 (Op (Constant 1.000000) (INil))) +(let t3384 (Op (Constant -1.000000) (INil))) +(let t3385 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t3383 (ICons t3384 (INil))))) +(let t3386 (Op (Constant 30.000000) (INil))) +(let t3387 (LoopStart t1442 0 0 (MNum 4) (F32))) +(let t3388 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3387 (ICons t3387 (INil))))) +(let t3389 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3388 (INil)))) +(let t3390 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3389 (ICons t1445 (INil))))) +(let t3391 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3390 (ICons t1446 (INil))))) +(let t3392 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3391 (INil)))) +(let t3393 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3392 (INil)))) +(let t3394 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3393 (ICons t3387 (INil))))) +(let t3395 (Op (LoopInput 0 1 (F32)) (ICons t152 (ICons t414 (ICons t676 (ICons t938 (INil))))))) +(let t3396 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3394 (ICons t3395 (INil))))) +(let t3397 (Op (LoopInput 0 2 (F32)) (ICons t128 (ICons t390 (ICons t652 (ICons t914 (INil))))))) +(let t3398 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3396 (ICons t3397 (INil))))) +(let t3399 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t3398 (INil)))) +(let t3400 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3399 (ICons t3399 (INil))))) +(let t3401 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3400 (INil)))) +(let t3402 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3401 (ICons t1449 (INil))))) +(let t3403 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3402 (ICons t1450 (INil))))) +(let t3404 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3403 (INil)))) +(let t3405 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3404 (INil)))) +(let t3406 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3405 (ICons t3399 (INil))))) +(let t3407 (Op (LoopInput 0 3 (F32)) (ICons t130 (ICons t392 (ICons t654 (ICons t916 (INil))))))) +(let t3408 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3396 (ICons t3407 (INil))))) +(let t3409 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3408 (INil)))) +(let t3410 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3409 (ICons t3409 (INil))))) +(let t3411 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3410 (INil)))) +(let t3412 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3411 (ICons t1453 (INil))))) +(let t3413 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3412 (ICons t1454 (INil))))) +(let t3414 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3413 (INil)))) +(let t3415 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3414 (INil)))) +(let t3416 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3415 (ICons t3409 (INil))))) +(let t3417 (Op (LoopInput 0 4 (F32)) (ICons t132 (ICons t394 (ICons t656 (ICons t918 (INil))))))) +(let t3418 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3396 (ICons t3417 (INil))))) +(let t3419 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3418 (INil)))) +(let t3420 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3419 (ICons t3419 (INil))))) +(let t3421 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3420 (INil)))) +(let t3422 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3421 (ICons t1457 (INil))))) +(let t3423 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3422 (ICons t1458 (INil))))) +(let t3424 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3423 (INil)))) +(let t3425 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3424 (INil)))) +(let t3426 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3425 (ICons t3419 (INil))))) +(let t3427 (Op (LoopInput 0 5 (F32)) (ICons t136 (ICons t398 (ICons t660 (ICons t922 (INil))))))) +(let t3428 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3406 (ICons t3427 (INil))))) +(let t3429 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t1472 (ICons t3428 (INil))))) +(let t3430 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3428 (ICons t1477 (INil))))) +(let t3431 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3429 (ICons t1478 (INil))))) +(let t3432 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3431 (ICons t1479 (INil))))) +(let t3433 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3430 (ICons t3432 (INil))))) +(let t3434 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3429 (ICons t1477 (INil))))) +(let t3435 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3428 (ICons t1478 (INil))))) +(let t3436 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3434 (ICons t3435 (INil))))) +(let t3437 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1480 (ICons t3433 (INil))))) +(let t3438 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3437 (ICons t1482 (INil))))) +(let t3439 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1483 (ICons t3436 (INil))))) +(let t3440 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3439 (ICons t1485 (INil))))) +(let t3441 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3438 (ICons t3440 (INil))))) +(let t3442 (Op (LoopInput 0 6 (F32)) (ICons t138 (ICons t400 (ICons t662 (ICons t924 (INil))))))) +(let t3443 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3416 (ICons t3442 (INil))))) +(let t3444 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1499 (ICons t3443 (INil))))) +(let t3445 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3443 (ICons t1504 (INil))))) +(let t3446 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3444 (ICons t1505 (INil))))) +(let t3447 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3446 (ICons t1506 (INil))))) +(let t3448 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3445 (ICons t3447 (INil))))) +(let t3449 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3444 (ICons t1504 (INil))))) +(let t3450 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3443 (ICons t1505 (INil))))) +(let t3451 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3449 (ICons t3450 (INil))))) +(let t3452 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1507 (ICons t3448 (INil))))) +(let t3453 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3452 (ICons t1509 (INil))))) +(let t3454 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1510 (ICons t3451 (INil))))) +(let t3455 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3454 (ICons t1512 (INil))))) +(let t3456 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3453 (ICons t3455 (INil))))) +(let t3457 (Op (LoopInput 0 8 (F32)) (ICons t2 (ICons t26 (ICons t50 (ICons t74 (INil))))))) +(let t3458 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t3457 (ICons t1523 (ICons t3456 (INil)))))) +(let t3459 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3441 (ICons t3458 (INil))))) +(let t3460 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3459 (INil)))) +(let t3461 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3460 (ICons t1541 (INil))))) +(let t3462 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3461 (INil)))) +(let t3463 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3462 (ICons t1542 (INil))))) +(let t3464 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3461 (ICons t3463 (INil))))) +(let t3465 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3464 (ICons t1543 (INil))))) +(let t3466 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3465 (INil)))) +(let t3467 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3466 (INil)))) +(let t3468 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3467 (INil)))) +(let t3469 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3466 (ICons t3468 (INil))))) +(let t3470 (Op (LoopInput 0 9 (F32)) (ICons t4 (ICons t28 (ICons t52 (ICons t76 (INil))))))) +(let t3471 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t3470 (ICons t1523 (ICons t3426 (INil)))))) +(let t3472 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3469 (ICons t3471 (INil))))) +(let t3473 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3472 (INil)))) +(let t3474 (Op (LoopInput 0 10 (F32)) (ICons t134 (ICons t396 (ICons t658 (ICons t920 (INil))))))) +(let t3475 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t3473 (ICons t3474 (INil))))) +(let t3476 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3475 (INil)))) +(let t3477 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3476 (ICons t3476 (INil))))) +(let t3478 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3477 (INil)))) +(let t3479 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3478 (ICons t1546 (INil))))) +(let t3480 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3479 (ICons t1547 (INil))))) +(let t3481 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3480 (INil)))) +(let t3482 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3481 (INil)))) +(let t3483 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3482 (ICons t3476 (INil))))) +(let t3484 (Op (LoopInput 0 11 (F32)) (ICons t154 (ICons t416 (ICons t678 (ICons t940 (INil))))))) +(let t3485 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3483 (ICons t3484 (INil))))) +(let t3486 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3387 (ICons t3485 (INil))))) +(let t3487 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3486 (ICons t3486 (INil))))) +(let t3488 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3487 (INil)))) +(let t3489 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3488 (ICons t1550 (INil))))) +(let t3490 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3489 (ICons t1551 (INil))))) +(let t3491 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3490 (INil)))) +(let t3492 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3491 (INil)))) +(let t3493 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3492 (ICons t3486 (INil))))) +(let t3494 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3486 (ICons t3486 (INil))))) +(let t3495 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3494 (INil)))) +(let t3496 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3495 (ICons t1564 (INil))))) +(let t3497 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3496 (ICons t1565 (INil))))) +(let t3498 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3497 (INil)))) +(let t3499 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3498 (INil)))) +(let t3500 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3499 (ICons t3486 (INil))))) +(let t3501 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3486 (ICons t3486 (INil))))) +(let t3502 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3501 (INil)))) +(let t3503 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3502 (ICons t1568 (INil))))) +(let t3504 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3503 (ICons t1569 (INil))))) +(let t3505 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3504 (INil)))) +(let t3506 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3505 (INil)))) +(let t3507 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3506 (ICons t3486 (INil))))) +(let t3508 (Op (LoopInput 0 12 (F32)) (ICons t156 (ICons t418 (ICons t680 (ICons t942 (INil))))))) +(let t3509 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3493 (ICons t3508 (INil))))) +(let t3510 (Op (LoopInput 0 13 (F32)) (ICons t122 (ICons t384 (ICons t646 (ICons t908 (INil))))))) +(let t3511 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3509 (ICons t3510 (INil))))) +(let t3512 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3511 (INil)))) +(let t3513 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3512 (ICons t1552 (INil))))) +(let t3514 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3512 (ICons t1553 (INil))))) +(let t3515 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3514 (ICons t3512 (INil))))) +(let t3516 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3515 (ICons t1554 (INil))))) +(let t3517 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3513 (ICons t3516 (INil))))) +(let t3518 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3517 (ICons t1555 (INil))))) +(let t3519 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3518 (ICons t1556 (INil))))) +(let t3520 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3519 (INil)))) +(let t3521 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3520 (ICons t1557 (INil))))) +(let t3522 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3521 (INil)))) +(let t3523 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3512 (ICons t3522 (INil))))) +(let t3524 (Op (LoopInput 0 14 (F32)) (ICons t124 (ICons t386 (ICons t648 (ICons t910 (INil))))))) +(let t3525 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3509 (ICons t3524 (INil))))) +(let t3526 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3525 (INil)))) +(let t3527 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3523 (ICons t3526 (INil))))) +(let t3528 (Op (LoopInput 0 15 (F32)) (ICons t126 (ICons t388 (ICons t650 (ICons t912 (INil))))))) +(let t3529 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t3527 (ICons t3528 (INil))))) +(let t3530 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3529 (INil)))) +(let t3531 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3530 (ICons t3530 (INil))))) +(let t3532 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3531 (INil)))) +(let t3533 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3532 (ICons t1560 (INil))))) +(let t3534 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3533 (ICons t1561 (INil))))) +(let t3535 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3534 (INil)))) +(let t3536 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3535 (INil)))) +(let t3537 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3536 (ICons t3530 (INil))))) +(let t3538 (Op (LoopInput 0 16 (F32)) (ICons t160 (ICons t422 (ICons t684 (ICons t946 (INil))))))) +(let t3539 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3537 (ICons t3538 (INil))))) +(let t3540 (Op (LoopInput 0 17 (F32)) (ICons t164 (ICons t426 (ICons t688 (ICons t950 (INil))))))) +(let t3541 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3500 (ICons t3540 (INil))))) +(let t3542 (Op (LoopInput 0 18 (F32)) (ICons t142 (ICons t404 (ICons t666 (ICons t928 (INil))))))) +(let t3543 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3507 (ICons t3542 (INil))))) +(let t3544 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3543 (ICons t1570 (INil))))) +(let t3545 (Op (LoopInput 0 19 (F32)) (ICons t144 (ICons t406 (ICons t668 (ICons t930 (INil))))))) +(let t3546 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3544 (ICons t3545 (INil))))) +(let t3547 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3546 (INil)))) +(let t3548 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3547 (INil)))) +(let t3549 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3548 (ICons t1571 (INil))))) +(let t3550 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3547 (ICons t3549 (INil))))) +(let t3551 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3550 (ICons t1572 (INil))))) +(let t3552 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3551 (INil)))) +(let t3553 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3552 (INil)))) +(let t3554 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3553 (INil)))) +(let t3555 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3552 (ICons t3554 (INil))))) +(let t3556 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3555 (ICons t1573 (INil))))) +(let t3557 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3555 (ICons t1574 (INil))))) +(let t3558 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3557 (ICons t3556 (INil))))) +(let t3559 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t3558 (INil)))) +(let t3560 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3559 (ICons t1575 (INil))))) +(let t3561 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3560 (INil)))) +(let t3562 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t3561 (INil)))) +(let t3563 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3562 (ICons t1578 (INil))))) +(let t3564 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1579 (ICons t3563 (INil))))) +(let t3565 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t1577 (ICons t3564 (ICons t1576 (INil)))))) +(let t3566 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1580 (ICons t3565 (INil))))) +(let t3567 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3566 (ICons t3555 (INil))))) +(let t3568 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3567 (INil)))) +(let t3569 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3568 (INil)))) +(let t3570 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3567 (ICons t3569 (INil))))) +(let t3571 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3565 (ICons t1581 (INil))))) +(let t3572 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t3571 (ICons t1582 (INil))))) +(let t3573 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3565 (ICons t1590 (INil))))) +(let t3574 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t3573 (ICons t1591 (INil))))) +(let t3575 (Op (LoopInput 0 20 (F32)) (ICons t146 (ICons t408 (ICons t670 (ICons t932 (INil))))))) +(let t3576 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t3565 (ICons t3575 (INil))))) +(let t3577 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3570 (ICons t3576 (INil))))) +(let t3578 (Op (LoopInput 0 21 (Bf16)) (ICons t148 (ICons t410 (ICons t672 (ICons t934 (INil))))))) +(let t3579 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3572 (ICons t3578 (INil))))) +(let t3580 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t3579 (INil)))) +(let t3581 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t3541 (ICons t3580 (INil))))) +(let t3582 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t3581 (INil)))) +(let t3583 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t1583 (ICons t3582 (INil))))) +(let t3584 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3582 (ICons t1584 (INil))))) +(let t3585 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3582 (ICons t1585 (INil))))) +(let t3586 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3585 (ICons t3582 (INil))))) +(let t3587 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3586 (ICons t1586 (INil))))) +(let t3588 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3584 (ICons t3587 (INil))))) +(let t3589 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3588 (ICons t1587 (INil))))) +(let t3590 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3589 (ICons t1588 (INil))))) +(let t3591 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3590 (INil)))) +(let t3592 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3591 (ICons t1589 (INil))))) +(let t3593 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3592 (INil)))) +(let t3594 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3582 (ICons t3593 (INil))))) +(let t3595 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3594 (ICons t3583 (INil))))) +(let t3596 (Op (LoopInput 0 22 (Bf16)) (ICons t150 (ICons t412 (ICons t674 (ICons t936 (INil))))))) +(let t3597 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3574 (ICons t3596 (INil))))) +(let t3598 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t3597 (INil)))) +(let t3599 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t3595 (ICons t3598 (INil))))) +(let t3600 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t3599 (INil)))) +(let t3601 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3600 (ICons t3577 (INil))))) +(let t3602 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3601 (INil)))) +(let t3603 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3602 (ICons t3602 (INil))))) +(let t3604 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3603 (INil)))) +(let t3605 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3604 (ICons t1594 (INil))))) +(let t3606 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3605 (ICons t1595 (INil))))) +(let t3607 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3606 (INil)))) +(let t3608 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3607 (INil)))) +(let t3609 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3608 (ICons t3602 (INil))))) +(let t3610 (Op (LoopInput 0 23 (F32)) (ICons t162 (ICons t424 (ICons t686 (ICons t948 (INil))))))) +(let t3611 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3609 (ICons t3610 (INil))))) +(let t3612 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3539 (ICons t3611 (INil))))) +(let t3613 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3612 (ICons t3612 (INil))))) +(let t3614 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3613 (INil)))) +(let t3615 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3614 (ICons t1598 (INil))))) +(let t3616 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3615 (ICons t1599 (INil))))) +(let t3617 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3616 (INil)))) +(let t3618 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3617 (INil)))) +(let t3619 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3618 (ICons t3612 (INil))))) +(let t3620 (Op (LoopInput 0 24 (F32)) (ICons t158 (ICons t420 (ICons t682 (ICons t944 (INil))))))) +(let t3621 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3619 (ICons t3620 (INil))))) +(let t3622 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3486 (ICons t3621 (INil))))) +(let t3623 (Op (LoopInput 0 25 (F32)) (ICons t140 (ICons t402 (ICons t664 (ICons t926 (INil))))))) +(let t3624 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3622 (ICons t3623 (INil))))) +(let t3625 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3624 (ICons t3624 (INil))))) +(let t3626 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3625 (INil)))) +(let t3627 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3626 (ICons t1602 (INil))))) +(let t3628 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3627 (ICons t1603 (INil))))) +(let t3629 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3628 (INil)))) +(let t3630 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3629 (INil)))) +(let t3631 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3630 (ICons t3624 (INil))))) +(let t3632 (Op (LoopInput 0 26 (F32)) (ICons t196 (ICons t458 (ICons t720 (ICons t982 (INil))))))) +(let t3633 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3631 (ICons t3632 (INil))))) +(let t3634 (Op (LoopInput 0 27 (F32)) (ICons t172 (ICons t434 (ICons t696 (ICons t958 (INil))))))) +(let t3635 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3633 (ICons t3634 (INil))))) +(let t3636 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t3635 (INil)))) +(let t3637 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3636 (ICons t3636 (INil))))) +(let t3638 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3637 (INil)))) +(let t3639 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3638 (ICons t1606 (INil))))) +(let t3640 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3639 (ICons t1607 (INil))))) +(let t3641 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3640 (INil)))) +(let t3642 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3641 (INil)))) +(let t3643 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3642 (ICons t3636 (INil))))) +(let t3644 (Op (LoopInput 0 28 (F32)) (ICons t174 (ICons t436 (ICons t698 (ICons t960 (INil))))))) +(let t3645 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3633 (ICons t3644 (INil))))) +(let t3646 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3645 (INil)))) +(let t3647 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3646 (ICons t3646 (INil))))) +(let t3648 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3647 (INil)))) +(let t3649 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3648 (ICons t1610 (INil))))) +(let t3650 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3649 (ICons t1611 (INil))))) +(let t3651 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3650 (INil)))) +(let t3652 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3651 (INil)))) +(let t3653 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3652 (ICons t3646 (INil))))) +(let t3654 (Op (LoopInput 0 29 (F32)) (ICons t176 (ICons t438 (ICons t700 (ICons t962 (INil))))))) +(let t3655 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3633 (ICons t3654 (INil))))) +(let t3656 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3655 (INil)))) +(let t3657 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3656 (ICons t3656 (INil))))) +(let t3658 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3657 (INil)))) +(let t3659 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3658 (ICons t1614 (INil))))) +(let t3660 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3659 (ICons t1615 (INil))))) +(let t3661 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3660 (INil)))) +(let t3662 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3661 (INil)))) +(let t3663 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3662 (ICons t3656 (INil))))) +(let t3664 (Op (LoopInput 0 30 (F32)) (ICons t180 (ICons t442 (ICons t704 (ICons t966 (INil))))))) +(let t3665 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3643 (ICons t3664 (INil))))) +(let t3666 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t1629 (ICons t3665 (INil))))) +(let t3667 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3665 (ICons t1634 (INil))))) +(let t3668 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3666 (ICons t1635 (INil))))) +(let t3669 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3668 (ICons t1636 (INil))))) +(let t3670 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3667 (ICons t3669 (INil))))) +(let t3671 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3666 (ICons t1634 (INil))))) +(let t3672 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3665 (ICons t1635 (INil))))) +(let t3673 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3671 (ICons t3672 (INil))))) +(let t3674 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1637 (ICons t3670 (INil))))) +(let t3675 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3674 (ICons t1639 (INil))))) +(let t3676 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1640 (ICons t3673 (INil))))) +(let t3677 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3676 (ICons t1642 (INil))))) +(let t3678 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3675 (ICons t3677 (INil))))) +(let t3679 (Op (LoopInput 0 31 (F32)) (ICons t182 (ICons t444 (ICons t706 (ICons t968 (INil))))))) +(let t3680 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3653 (ICons t3679 (INil))))) +(let t3681 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1656 (ICons t3680 (INil))))) +(let t3682 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3680 (ICons t1661 (INil))))) +(let t3683 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3681 (ICons t1662 (INil))))) +(let t3684 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3683 (ICons t1663 (INil))))) +(let t3685 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3682 (ICons t3684 (INil))))) +(let t3686 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3681 (ICons t1661 (INil))))) +(let t3687 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3680 (ICons t1662 (INil))))) +(let t3688 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3686 (ICons t3687 (INil))))) +(let t3689 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1664 (ICons t3685 (INil))))) +(let t3690 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3689 (ICons t1666 (INil))))) +(let t3691 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1667 (ICons t3688 (INil))))) +(let t3692 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3691 (ICons t1669 (INil))))) +(let t3693 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3690 (ICons t3692 (INil))))) +(let t3694 (Op (LoopInput 0 32 (F32)) (ICons t6 (ICons t30 (ICons t54 (ICons t78 (INil))))))) +(let t3695 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t3694 (ICons t1680 (ICons t3693 (INil)))))) +(let t3696 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3678 (ICons t3695 (INil))))) +(let t3697 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3696 (INil)))) +(let t3698 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3697 (ICons t1698 (INil))))) +(let t3699 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3698 (INil)))) +(let t3700 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3699 (ICons t1699 (INil))))) +(let t3701 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3698 (ICons t3700 (INil))))) +(let t3702 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3701 (ICons t1700 (INil))))) +(let t3703 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3702 (INil)))) +(let t3704 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3703 (INil)))) +(let t3705 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3704 (INil)))) +(let t3706 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3703 (ICons t3705 (INil))))) +(let t3707 (Op (LoopInput 0 33 (F32)) (ICons t8 (ICons t32 (ICons t56 (ICons t80 (INil))))))) +(let t3708 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t3707 (ICons t1680 (ICons t3663 (INil)))))) +(let t3709 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3706 (ICons t3708 (INil))))) +(let t3710 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3709 (INil)))) +(let t3711 (Op (LoopInput 0 34 (F32)) (ICons t178 (ICons t440 (ICons t702 (ICons t964 (INil))))))) +(let t3712 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t3710 (ICons t3711 (INil))))) +(let t3713 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3712 (INil)))) +(let t3714 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3713 (ICons t3713 (INil))))) +(let t3715 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3714 (INil)))) +(let t3716 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3715 (ICons t1703 (INil))))) +(let t3717 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3716 (ICons t1704 (INil))))) +(let t3718 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3717 (INil)))) +(let t3719 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3718 (INil)))) +(let t3720 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3719 (ICons t3713 (INil))))) +(let t3721 (Op (LoopInput 0 35 (F32)) (ICons t198 (ICons t460 (ICons t722 (ICons t984 (INil))))))) +(let t3722 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3720 (ICons t3721 (INil))))) +(let t3723 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3624 (ICons t3722 (INil))))) +(let t3724 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3723 (ICons t3723 (INil))))) +(let t3725 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3724 (INil)))) +(let t3726 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3725 (ICons t1707 (INil))))) +(let t3727 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3726 (ICons t1708 (INil))))) +(let t3728 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3727 (INil)))) +(let t3729 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3728 (INil)))) +(let t3730 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3729 (ICons t3723 (INil))))) +(let t3731 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3723 (ICons t3723 (INil))))) +(let t3732 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3731 (INil)))) +(let t3733 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3732 (ICons t1721 (INil))))) +(let t3734 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3733 (ICons t1722 (INil))))) +(let t3735 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3734 (INil)))) +(let t3736 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3735 (INil)))) +(let t3737 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3736 (ICons t3723 (INil))))) +(let t3738 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3723 (ICons t3723 (INil))))) +(let t3739 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3738 (INil)))) +(let t3740 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3739 (ICons t1725 (INil))))) +(let t3741 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3740 (ICons t1726 (INil))))) +(let t3742 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3741 (INil)))) +(let t3743 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3742 (INil)))) +(let t3744 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3743 (ICons t3723 (INil))))) +(let t3745 (Op (LoopInput 0 36 (F32)) (ICons t200 (ICons t462 (ICons t724 (ICons t986 (INil))))))) +(let t3746 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3730 (ICons t3745 (INil))))) +(let t3747 (Op (LoopInput 0 37 (F32)) (ICons t166 (ICons t428 (ICons t690 (ICons t952 (INil))))))) +(let t3748 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3746 (ICons t3747 (INil))))) +(let t3749 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3748 (INil)))) +(let t3750 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3749 (ICons t1709 (INil))))) +(let t3751 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3749 (ICons t1710 (INil))))) +(let t3752 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3751 (ICons t3749 (INil))))) +(let t3753 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3752 (ICons t1711 (INil))))) +(let t3754 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3750 (ICons t3753 (INil))))) +(let t3755 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3754 (ICons t1712 (INil))))) +(let t3756 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3755 (ICons t1713 (INil))))) +(let t3757 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3756 (INil)))) +(let t3758 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3757 (ICons t1714 (INil))))) +(let t3759 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3758 (INil)))) +(let t3760 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3749 (ICons t3759 (INil))))) +(let t3761 (Op (LoopInput 0 38 (F32)) (ICons t168 (ICons t430 (ICons t692 (ICons t954 (INil))))))) +(let t3762 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3746 (ICons t3761 (INil))))) +(let t3763 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3762 (INil)))) +(let t3764 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3760 (ICons t3763 (INil))))) +(let t3765 (Op (LoopInput 0 39 (F32)) (ICons t170 (ICons t432 (ICons t694 (ICons t956 (INil))))))) +(let t3766 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t3764 (ICons t3765 (INil))))) +(let t3767 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3766 (INil)))) +(let t3768 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3767 (ICons t3767 (INil))))) +(let t3769 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3768 (INil)))) +(let t3770 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3769 (ICons t1717 (INil))))) +(let t3771 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3770 (ICons t1718 (INil))))) +(let t3772 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3771 (INil)))) +(let t3773 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3772 (INil)))) +(let t3774 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3773 (ICons t3767 (INil))))) +(let t3775 (Op (LoopInput 0 40 (F32)) (ICons t204 (ICons t466 (ICons t728 (ICons t990 (INil))))))) +(let t3776 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3774 (ICons t3775 (INil))))) +(let t3777 (Op (LoopInput 0 41 (F32)) (ICons t208 (ICons t470 (ICons t732 (ICons t994 (INil))))))) +(let t3778 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3737 (ICons t3777 (INil))))) +(let t3779 (Op (LoopInput 0 42 (F32)) (ICons t186 (ICons t448 (ICons t710 (ICons t972 (INil))))))) +(let t3780 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3744 (ICons t3779 (INil))))) +(let t3781 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3780 (ICons t1727 (INil))))) +(let t3782 (Op (LoopInput 0 43 (F32)) (ICons t188 (ICons t450 (ICons t712 (ICons t974 (INil))))))) +(let t3783 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3781 (ICons t3782 (INil))))) +(let t3784 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3783 (INil)))) +(let t3785 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3784 (INil)))) +(let t3786 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3785 (ICons t1728 (INil))))) +(let t3787 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3784 (ICons t3786 (INil))))) +(let t3788 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3787 (ICons t1729 (INil))))) +(let t3789 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3788 (INil)))) +(let t3790 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3789 (INil)))) +(let t3791 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3790 (INil)))) +(let t3792 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3789 (ICons t3791 (INil))))) +(let t3793 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3792 (ICons t1730 (INil))))) +(let t3794 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3792 (ICons t1731 (INil))))) +(let t3795 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3794 (ICons t3793 (INil))))) +(let t3796 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t3795 (INil)))) +(let t3797 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3796 (ICons t1732 (INil))))) +(let t3798 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3797 (INil)))) +(let t3799 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t3798 (INil)))) +(let t3800 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3799 (ICons t1735 (INil))))) +(let t3801 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1736 (ICons t3800 (INil))))) +(let t3802 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t1734 (ICons t3801 (ICons t1733 (INil)))))) +(let t3803 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1737 (ICons t3802 (INil))))) +(let t3804 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3803 (ICons t3792 (INil))))) +(let t3805 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3804 (INil)))) +(let t3806 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3805 (INil)))) +(let t3807 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3804 (ICons t3806 (INil))))) +(let t3808 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3802 (ICons t1738 (INil))))) +(let t3809 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t3808 (ICons t1739 (INil))))) +(let t3810 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3802 (ICons t1747 (INil))))) +(let t3811 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t3810 (ICons t1748 (INil))))) +(let t3812 (Op (LoopInput 0 44 (F32)) (ICons t190 (ICons t452 (ICons t714 (ICons t976 (INil))))))) +(let t3813 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t3802 (ICons t3812 (INil))))) +(let t3814 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3807 (ICons t3813 (INil))))) +(let t3815 (Op (LoopInput 0 45 (Bf16)) (ICons t192 (ICons t454 (ICons t716 (ICons t978 (INil))))))) +(let t3816 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3809 (ICons t3815 (INil))))) +(let t3817 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t3816 (INil)))) +(let t3818 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t3778 (ICons t3817 (INil))))) +(let t3819 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t3818 (INil)))) +(let t3820 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t1740 (ICons t3819 (INil))))) +(let t3821 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3819 (ICons t1741 (INil))))) +(let t3822 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3819 (ICons t1742 (INil))))) +(let t3823 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3822 (ICons t3819 (INil))))) +(let t3824 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3823 (ICons t1743 (INil))))) +(let t3825 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3821 (ICons t3824 (INil))))) +(let t3826 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3825 (ICons t1744 (INil))))) +(let t3827 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3826 (ICons t1745 (INil))))) +(let t3828 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3827 (INil)))) +(let t3829 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3828 (ICons t1746 (INil))))) +(let t3830 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3829 (INil)))) +(let t3831 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3819 (ICons t3830 (INil))))) +(let t3832 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3831 (ICons t3820 (INil))))) +(let t3833 (Op (LoopInput 0 46 (Bf16)) (ICons t194 (ICons t456 (ICons t718 (ICons t980 (INil))))))) +(let t3834 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t3811 (ICons t3833 (INil))))) +(let t3835 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t3834 (INil)))) +(let t3836 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t3832 (ICons t3835 (INil))))) +(let t3837 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t3836 (INil)))) +(let t3838 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3837 (ICons t3814 (INil))))) +(let t3839 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3838 (INil)))) +(let t3840 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3839 (ICons t3839 (INil))))) +(let t3841 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3840 (INil)))) +(let t3842 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3841 (ICons t1751 (INil))))) +(let t3843 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3842 (ICons t1752 (INil))))) +(let t3844 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3843 (INil)))) +(let t3845 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3844 (INil)))) +(let t3846 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3845 (ICons t3839 (INil))))) +(let t3847 (Op (LoopInput 0 47 (F32)) (ICons t206 (ICons t468 (ICons t730 (ICons t992 (INil))))))) +(let t3848 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3846 (ICons t3847 (INil))))) +(let t3849 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3776 (ICons t3848 (INil))))) +(let t3850 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3849 (ICons t3849 (INil))))) +(let t3851 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3850 (INil)))) +(let t3852 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3851 (ICons t1755 (INil))))) +(let t3853 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3852 (ICons t1756 (INil))))) +(let t3854 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3853 (INil)))) +(let t3855 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3854 (INil)))) +(let t3856 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3855 (ICons t3849 (INil))))) +(let t3857 (Op (LoopInput 0 48 (F32)) (ICons t202 (ICons t464 (ICons t726 (ICons t988 (INil))))))) +(let t3858 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3856 (ICons t3857 (INil))))) +(let t3859 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3723 (ICons t3858 (INil))))) +(let t3860 (Op (LoopInput 0 49 (F32)) (ICons t184 (ICons t446 (ICons t708 (ICons t970 (INil))))))) +(let t3861 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3859 (ICons t3860 (INil))))) +(let t3862 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3861 (ICons t3861 (INil))))) +(let t3863 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3862 (INil)))) +(let t3864 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3863 (ICons t1759 (INil))))) +(let t3865 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3864 (ICons t1760 (INil))))) +(let t3866 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3865 (INil)))) +(let t3867 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3866 (INil)))) +(let t3868 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3867 (ICons t3861 (INil))))) +(let t3869 (Op (LoopInput 0 50 (F32)) (ICons t240 (ICons t502 (ICons t764 (ICons t1026 (INil))))))) +(let t3870 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3868 (ICons t3869 (INil))))) +(let t3871 (Op (LoopInput 0 51 (F32)) (ICons t216 (ICons t478 (ICons t740 (ICons t1002 (INil))))))) +(let t3872 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3870 (ICons t3871 (INil))))) +(let t3873 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t3872 (INil)))) +(let t3874 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3873 (ICons t3873 (INil))))) +(let t3875 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3874 (INil)))) +(let t3876 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3875 (ICons t1763 (INil))))) +(let t3877 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3876 (ICons t1764 (INil))))) +(let t3878 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3877 (INil)))) +(let t3879 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t3878 (INil)))) +(let t3880 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3879 (ICons t3873 (INil))))) +(let t3881 (Op (LoopInput 0 52 (F32)) (ICons t218 (ICons t480 (ICons t742 (ICons t1004 (INil))))))) +(let t3882 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3870 (ICons t3881 (INil))))) +(let t3883 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3882 (INil)))) +(let t3884 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3883 (ICons t3883 (INil))))) +(let t3885 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3884 (INil)))) +(let t3886 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3885 (ICons t1767 (INil))))) +(let t3887 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3886 (ICons t1768 (INil))))) +(let t3888 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3887 (INil)))) +(let t3889 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3888 (INil)))) +(let t3890 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3889 (ICons t3883 (INil))))) +(let t3891 (Op (LoopInput 0 53 (F32)) (ICons t220 (ICons t482 (ICons t744 (ICons t1006 (INil))))))) +(let t3892 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3870 (ICons t3891 (INil))))) +(let t3893 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t3892 (INil)))) +(let t3894 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3893 (ICons t3893 (INil))))) +(let t3895 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3894 (INil)))) +(let t3896 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3895 (ICons t1771 (INil))))) +(let t3897 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3896 (ICons t1772 (INil))))) +(let t3898 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3897 (INil)))) +(let t3899 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3898 (INil)))) +(let t3900 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3899 (ICons t3893 (INil))))) +(let t3901 (Op (LoopInput 0 54 (F32)) (ICons t224 (ICons t486 (ICons t748 (ICons t1010 (INil))))))) +(let t3902 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3880 (ICons t3901 (INil))))) +(let t3903 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t1786 (ICons t3902 (INil))))) +(let t3904 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3902 (ICons t1791 (INil))))) +(let t3905 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3903 (ICons t1792 (INil))))) +(let t3906 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3905 (ICons t1793 (INil))))) +(let t3907 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3904 (ICons t3906 (INil))))) +(let t3908 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3903 (ICons t1791 (INil))))) +(let t3909 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3902 (ICons t1792 (INil))))) +(let t3910 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3908 (ICons t3909 (INil))))) +(let t3911 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1794 (ICons t3907 (INil))))) +(let t3912 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3911 (ICons t1796 (INil))))) +(let t3913 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1797 (ICons t3910 (INil))))) +(let t3914 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3913 (ICons t1799 (INil))))) +(let t3915 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3912 (ICons t3914 (INil))))) +(let t3916 (Op (LoopInput 0 55 (F32)) (ICons t226 (ICons t488 (ICons t750 (ICons t1012 (INil))))))) +(let t3917 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3890 (ICons t3916 (INil))))) +(let t3918 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1813 (ICons t3917 (INil))))) +(let t3919 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3917 (ICons t1818 (INil))))) +(let t3920 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3918 (ICons t1819 (INil))))) +(let t3921 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3920 (ICons t1820 (INil))))) +(let t3922 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3919 (ICons t3921 (INil))))) +(let t3923 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3918 (ICons t1818 (INil))))) +(let t3924 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3917 (ICons t1819 (INil))))) +(let t3925 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3923 (ICons t3924 (INil))))) +(let t3926 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1821 (ICons t3922 (INil))))) +(let t3927 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3926 (ICons t1823 (INil))))) +(let t3928 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1824 (ICons t3925 (INil))))) +(let t3929 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3928 (ICons t1826 (INil))))) +(let t3930 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3927 (ICons t3929 (INil))))) +(let t3931 (Op (LoopInput 0 56 (F32)) (ICons t10 (ICons t34 (ICons t58 (ICons t82 (INil))))))) +(let t3932 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t3931 (ICons t1837 (ICons t3930 (INil)))))) +(let t3933 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t3915 (ICons t3932 (INil))))) +(let t3934 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3933 (INil)))) +(let t3935 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3934 (ICons t1855 (INil))))) +(let t3936 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3935 (INil)))) +(let t3937 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3936 (ICons t1856 (INil))))) +(let t3938 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3935 (ICons t3937 (INil))))) +(let t3939 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3938 (ICons t1857 (INil))))) +(let t3940 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3939 (INil)))) +(let t3941 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t3940 (INil)))) +(let t3942 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3941 (INil)))) +(let t3943 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t3940 (ICons t3942 (INil))))) +(let t3944 (Op (LoopInput 0 57 (F32)) (ICons t12 (ICons t36 (ICons t60 (ICons t84 (INil))))))) +(let t3945 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t3944 (ICons t1837 (ICons t3900 (INil)))))) +(let t3946 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t3943 (ICons t3945 (INil))))) +(let t3947 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3946 (INil)))) +(let t3948 (Op (LoopInput 0 58 (F32)) (ICons t222 (ICons t484 (ICons t746 (ICons t1008 (INil))))))) +(let t3949 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t3947 (ICons t3948 (INil))))) +(let t3950 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3949 (INil)))) +(let t3951 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3950 (ICons t3950 (INil))))) +(let t3952 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3951 (INil)))) +(let t3953 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3952 (ICons t1860 (INil))))) +(let t3954 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3953 (ICons t1861 (INil))))) +(let t3955 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3954 (INil)))) +(let t3956 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3955 (INil)))) +(let t3957 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3956 (ICons t3950 (INil))))) +(let t3958 (Op (LoopInput 0 59 (F32)) (ICons t242 (ICons t504 (ICons t766 (ICons t1028 (INil))))))) +(let t3959 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3957 (ICons t3958 (INil))))) +(let t3960 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3861 (ICons t3959 (INil))))) +(let t3961 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3960 (ICons t3960 (INil))))) +(let t3962 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3961 (INil)))) +(let t3963 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3962 (ICons t1864 (INil))))) +(let t3964 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3963 (ICons t1865 (INil))))) +(let t3965 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3964 (INil)))) +(let t3966 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3965 (INil)))) +(let t3967 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3966 (ICons t3960 (INil))))) +(let t3968 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3960 (ICons t3960 (INil))))) +(let t3969 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3968 (INil)))) +(let t3970 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3969 (ICons t1878 (INil))))) +(let t3971 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3970 (ICons t1879 (INil))))) +(let t3972 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3971 (INil)))) +(let t3973 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3972 (INil)))) +(let t3974 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3973 (ICons t3960 (INil))))) +(let t3975 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3960 (ICons t3960 (INil))))) +(let t3976 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t3975 (INil)))) +(let t3977 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3976 (ICons t1882 (INil))))) +(let t3978 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3977 (ICons t1883 (INil))))) +(let t3979 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3978 (INil)))) +(let t3980 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t3979 (INil)))) +(let t3981 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3980 (ICons t3960 (INil))))) +(let t3982 (Op (LoopInput 0 60 (F32)) (ICons t244 (ICons t506 (ICons t768 (ICons t1030 (INil))))))) +(let t3983 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3967 (ICons t3982 (INil))))) +(let t3984 (Op (LoopInput 0 61 (F32)) (ICons t210 (ICons t472 (ICons t734 (ICons t996 (INil))))))) +(let t3985 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3983 (ICons t3984 (INil))))) +(let t3986 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3985 (INil)))) +(let t3987 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3986 (ICons t1866 (INil))))) +(let t3988 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3986 (ICons t1867 (INil))))) +(let t3989 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3988 (ICons t3986 (INil))))) +(let t3990 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3989 (ICons t1868 (INil))))) +(let t3991 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3987 (ICons t3990 (INil))))) +(let t3992 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3991 (ICons t1869 (INil))))) +(let t3993 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3992 (ICons t1870 (INil))))) +(let t3994 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3993 (INil)))) +(let t3995 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3994 (ICons t1871 (INil))))) +(let t3996 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3995 (INil)))) +(let t3997 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3986 (ICons t3996 (INil))))) +(let t3998 (Op (LoopInput 0 62 (F32)) (ICons t212 (ICons t474 (ICons t736 (ICons t998 (INil))))))) +(let t3999 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t3983 (ICons t3998 (INil))))) +(let t4000 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3999 (INil)))) +(let t4001 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t3997 (ICons t4000 (INil))))) +(let t4002 (Op (LoopInput 0 63 (F32)) (ICons t214 (ICons t476 (ICons t738 (ICons t1000 (INil))))))) +(let t4003 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t4001 (ICons t4002 (INil))))) +(let t4004 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4003 (INil)))) +(let t4005 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4004 (ICons t4004 (INil))))) +(let t4006 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4005 (INil)))) +(let t4007 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4006 (ICons t1874 (INil))))) +(let t4008 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4007 (ICons t1875 (INil))))) +(let t4009 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4008 (INil)))) +(let t4010 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4009 (INil)))) +(let t4011 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4010 (ICons t4004 (INil))))) +(let t4012 (Op (LoopInput 0 64 (F32)) (ICons t248 (ICons t510 (ICons t772 (ICons t1034 (INil))))))) +(let t4013 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4011 (ICons t4012 (INil))))) +(let t4014 (Op (LoopInput 0 65 (F32)) (ICons t252 (ICons t514 (ICons t776 (ICons t1038 (INil))))))) +(let t4015 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3974 (ICons t4014 (INil))))) +(let t4016 (Op (LoopInput 0 66 (F32)) (ICons t230 (ICons t492 (ICons t754 (ICons t1016 (INil))))))) +(let t4017 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3981 (ICons t4016 (INil))))) +(let t4018 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4017 (ICons t1884 (INil))))) +(let t4019 (Op (LoopInput 0 67 (F32)) (ICons t232 (ICons t494 (ICons t756 (ICons t1018 (INil))))))) +(let t4020 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4018 (ICons t4019 (INil))))) +(let t4021 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4020 (INil)))) +(let t4022 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4021 (INil)))) +(let t4023 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4022 (ICons t1885 (INil))))) +(let t4024 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4021 (ICons t4023 (INil))))) +(let t4025 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4024 (ICons t1886 (INil))))) +(let t4026 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4025 (INil)))) +(let t4027 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4026 (INil)))) +(let t4028 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4027 (INil)))) +(let t4029 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4026 (ICons t4028 (INil))))) +(let t4030 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4029 (ICons t1887 (INil))))) +(let t4031 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4029 (ICons t1888 (INil))))) +(let t4032 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4031 (ICons t4030 (INil))))) +(let t4033 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t4032 (INil)))) +(let t4034 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4033 (ICons t1889 (INil))))) +(let t4035 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4034 (INil)))) +(let t4036 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t4035 (INil)))) +(let t4037 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4036 (ICons t1892 (INil))))) +(let t4038 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1893 (ICons t4037 (INil))))) +(let t4039 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t1891 (ICons t4038 (ICons t1890 (INil)))))) +(let t4040 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1894 (ICons t4039 (INil))))) +(let t4041 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4040 (ICons t4029 (INil))))) +(let t4042 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4041 (INil)))) +(let t4043 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4042 (INil)))) +(let t4044 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4041 (ICons t4043 (INil))))) +(let t4045 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4039 (ICons t1895 (INil))))) +(let t4046 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4045 (ICons t1896 (INil))))) +(let t4047 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4039 (ICons t1904 (INil))))) +(let t4048 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t4047 (ICons t1905 (INil))))) +(let t4049 (Op (LoopInput 0 68 (F32)) (ICons t234 (ICons t496 (ICons t758 (ICons t1020 (INil))))))) +(let t4050 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t4039 (ICons t4049 (INil))))) +(let t4051 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4044 (ICons t4050 (INil))))) +(let t4052 (Op (LoopInput 0 69 (Bf16)) (ICons t236 (ICons t498 (ICons t760 (ICons t1022 (INil))))))) +(let t4053 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4046 (ICons t4052 (INil))))) +(let t4054 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t4053 (INil)))) +(let t4055 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t4015 (ICons t4054 (INil))))) +(let t4056 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t4055 (INil)))) +(let t4057 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t1897 (ICons t4056 (INil))))) +(let t4058 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4056 (ICons t1898 (INil))))) +(let t4059 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4056 (ICons t1899 (INil))))) +(let t4060 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4059 (ICons t4056 (INil))))) +(let t4061 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4060 (ICons t1900 (INil))))) +(let t4062 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4058 (ICons t4061 (INil))))) +(let t4063 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4062 (ICons t1901 (INil))))) +(let t4064 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4063 (ICons t1902 (INil))))) +(let t4065 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4064 (INil)))) +(let t4066 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4065 (ICons t1903 (INil))))) +(let t4067 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4066 (INil)))) +(let t4068 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4056 (ICons t4067 (INil))))) +(let t4069 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4068 (ICons t4057 (INil))))) +(let t4070 (Op (LoopInput 0 70 (Bf16)) (ICons t238 (ICons t500 (ICons t762 (ICons t1024 (INil))))))) +(let t4071 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4048 (ICons t4070 (INil))))) +(let t4072 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t4071 (INil)))) +(let t4073 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t4069 (ICons t4072 (INil))))) +(let t4074 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4073 (INil)))) +(let t4075 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4074 (ICons t4051 (INil))))) +(let t4076 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4075 (INil)))) +(let t4077 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4076 (ICons t4076 (INil))))) +(let t4078 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4077 (INil)))) +(let t4079 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4078 (ICons t1908 (INil))))) +(let t4080 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4079 (ICons t1909 (INil))))) +(let t4081 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4080 (INil)))) +(let t4082 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4081 (INil)))) +(let t4083 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4082 (ICons t4076 (INil))))) +(let t4084 (Op (LoopInput 0 71 (F32)) (ICons t250 (ICons t512 (ICons t774 (ICons t1036 (INil))))))) +(let t4085 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4083 (ICons t4084 (INil))))) +(let t4086 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4013 (ICons t4085 (INil))))) +(let t4087 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4086 (ICons t4086 (INil))))) +(let t4088 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4087 (INil)))) +(let t4089 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4088 (ICons t1912 (INil))))) +(let t4090 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4089 (ICons t1913 (INil))))) +(let t4091 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4090 (INil)))) +(let t4092 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4091 (INil)))) +(let t4093 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4092 (ICons t4086 (INil))))) +(let t4094 (Op (LoopInput 0 72 (F32)) (ICons t246 (ICons t508 (ICons t770 (ICons t1032 (INil))))))) +(let t4095 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4093 (ICons t4094 (INil))))) +(let t4096 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t3960 (ICons t4095 (INil))))) +(let t4097 (Op (LoopInput 0 73 (F32)) (ICons t228 (ICons t490 (ICons t752 (ICons t1014 (INil))))))) +(let t4098 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4096 (ICons t4097 (INil))))) +(let t4099 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4098 (ICons t4098 (INil))))) +(let t4100 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4099 (INil)))) +(let t4101 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4100 (ICons t1916 (INil))))) +(let t4102 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4101 (ICons t1917 (INil))))) +(let t4103 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4102 (INil)))) +(let t4104 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4103 (INil)))) +(let t4105 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4104 (ICons t4098 (INil))))) +(let t4106 (Op (LoopInput 0 74 (F32)) (ICons t284 (ICons t546 (ICons t808 (ICons t1070 (INil))))))) +(let t4107 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4105 (ICons t4106 (INil))))) +(let t4108 (Op (LoopInput 0 75 (F32)) (ICons t260 (ICons t522 (ICons t784 (ICons t1046 (INil))))))) +(let t4109 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4107 (ICons t4108 (INil))))) +(let t4110 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t4109 (INil)))) +(let t4111 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4110 (ICons t4110 (INil))))) +(let t4112 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4111 (INil)))) +(let t4113 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4112 (ICons t1920 (INil))))) +(let t4114 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4113 (ICons t1921 (INil))))) +(let t4115 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4114 (INil)))) +(let t4116 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4115 (INil)))) +(let t4117 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4116 (ICons t4110 (INil))))) +(let t4118 (Op (LoopInput 0 76 (F32)) (ICons t262 (ICons t524 (ICons t786 (ICons t1048 (INil))))))) +(let t4119 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4107 (ICons t4118 (INil))))) +(let t4120 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4119 (INil)))) +(let t4121 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4120 (ICons t4120 (INil))))) +(let t4122 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4121 (INil)))) +(let t4123 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4122 (ICons t1924 (INil))))) +(let t4124 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4123 (ICons t1925 (INil))))) +(let t4125 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4124 (INil)))) +(let t4126 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4125 (INil)))) +(let t4127 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4126 (ICons t4120 (INil))))) +(let t4128 (Op (LoopInput 0 77 (F32)) (ICons t264 (ICons t526 (ICons t788 (ICons t1050 (INil))))))) +(let t4129 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4107 (ICons t4128 (INil))))) +(let t4130 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4129 (INil)))) +(let t4131 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4130 (ICons t4130 (INil))))) +(let t4132 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4131 (INil)))) +(let t4133 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4132 (ICons t1928 (INil))))) +(let t4134 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4133 (ICons t1929 (INil))))) +(let t4135 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4134 (INil)))) +(let t4136 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4135 (INil)))) +(let t4137 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4136 (ICons t4130 (INil))))) +(let t4138 (Op (LoopInput 0 78 (F32)) (ICons t268 (ICons t530 (ICons t792 (ICons t1054 (INil))))))) +(let t4139 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4117 (ICons t4138 (INil))))) +(let t4140 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t1943 (ICons t4139 (INil))))) +(let t4141 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4139 (ICons t1948 (INil))))) +(let t4142 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4140 (ICons t1949 (INil))))) +(let t4143 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4142 (ICons t1950 (INil))))) +(let t4144 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4141 (ICons t4143 (INil))))) +(let t4145 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4140 (ICons t1948 (INil))))) +(let t4146 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4139 (ICons t1949 (INil))))) +(let t4147 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4145 (ICons t4146 (INil))))) +(let t4148 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1951 (ICons t4144 (INil))))) +(let t4149 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4148 (ICons t1953 (INil))))) +(let t4150 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1954 (ICons t4147 (INil))))) +(let t4151 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4150 (ICons t1956 (INil))))) +(let t4152 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4149 (ICons t4151 (INil))))) +(let t4153 (Op (LoopInput 0 79 (F32)) (ICons t270 (ICons t532 (ICons t794 (ICons t1056 (INil))))))) +(let t4154 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4127 (ICons t4153 (INil))))) +(let t4155 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1970 (ICons t4154 (INil))))) +(let t4156 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4154 (ICons t1975 (INil))))) +(let t4157 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4155 (ICons t1976 (INil))))) +(let t4158 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4157 (ICons t1977 (INil))))) +(let t4159 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4156 (ICons t4158 (INil))))) +(let t4160 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4155 (ICons t1975 (INil))))) +(let t4161 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4154 (ICons t1976 (INil))))) +(let t4162 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4160 (ICons t4161 (INil))))) +(let t4163 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1978 (ICons t4159 (INil))))) +(let t4164 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4163 (ICons t1980 (INil))))) +(let t4165 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1981 (ICons t4162 (INil))))) +(let t4166 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4165 (ICons t1983 (INil))))) +(let t4167 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4164 (ICons t4166 (INil))))) +(let t4168 (Op (LoopInput 0 80 (F32)) (ICons t14 (ICons t38 (ICons t62 (ICons t86 (INil))))))) +(let t4169 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t4168 (ICons t1994 (ICons t4167 (INil)))))) +(let t4170 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t4152 (ICons t4169 (INil))))) +(let t4171 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4170 (INil)))) +(let t4172 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4171 (ICons t2012 (INil))))) +(let t4173 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4172 (INil)))) +(let t4174 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4173 (ICons t2013 (INil))))) +(let t4175 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4172 (ICons t4174 (INil))))) +(let t4176 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4175 (ICons t2014 (INil))))) +(let t4177 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4176 (INil)))) +(let t4178 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4177 (INil)))) +(let t4179 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4178 (INil)))) +(let t4180 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4177 (ICons t4179 (INil))))) +(let t4181 (Op (LoopInput 0 81 (F32)) (ICons t16 (ICons t40 (ICons t64 (ICons t88 (INil))))))) +(let t4182 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t4181 (ICons t1994 (ICons t4137 (INil)))))) +(let t4183 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t4180 (ICons t4182 (INil))))) +(let t4184 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4183 (INil)))) +(let t4185 (Op (LoopInput 0 82 (F32)) (ICons t266 (ICons t528 (ICons t790 (ICons t1052 (INil))))))) +(let t4186 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t4184 (ICons t4185 (INil))))) +(let t4187 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4186 (INil)))) +(let t4188 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4187 (ICons t4187 (INil))))) +(let t4189 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4188 (INil)))) +(let t4190 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4189 (ICons t2017 (INil))))) +(let t4191 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4190 (ICons t2018 (INil))))) +(let t4192 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4191 (INil)))) +(let t4193 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4192 (INil)))) +(let t4194 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4193 (ICons t4187 (INil))))) +(let t4195 (Op (LoopInput 0 83 (F32)) (ICons t286 (ICons t548 (ICons t810 (ICons t1072 (INil))))))) +(let t4196 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4194 (ICons t4195 (INil))))) +(let t4197 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4098 (ICons t4196 (INil))))) +(let t4198 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4197 (ICons t4197 (INil))))) +(let t4199 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4198 (INil)))) +(let t4200 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4199 (ICons t2021 (INil))))) +(let t4201 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4200 (ICons t2022 (INil))))) +(let t4202 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4201 (INil)))) +(let t4203 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4202 (INil)))) +(let t4204 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4203 (ICons t4197 (INil))))) +(let t4205 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4197 (ICons t4197 (INil))))) +(let t4206 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4205 (INil)))) +(let t4207 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4206 (ICons t2035 (INil))))) +(let t4208 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4207 (ICons t2036 (INil))))) +(let t4209 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4208 (INil)))) +(let t4210 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4209 (INil)))) +(let t4211 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4210 (ICons t4197 (INil))))) +(let t4212 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4197 (ICons t4197 (INil))))) +(let t4213 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4212 (INil)))) +(let t4214 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4213 (ICons t2039 (INil))))) +(let t4215 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4214 (ICons t2040 (INil))))) +(let t4216 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4215 (INil)))) +(let t4217 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4216 (INil)))) +(let t4218 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4217 (ICons t4197 (INil))))) +(let t4219 (Op (LoopInput 0 84 (F32)) (ICons t288 (ICons t550 (ICons t812 (ICons t1074 (INil))))))) +(let t4220 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4204 (ICons t4219 (INil))))) +(let t4221 (Op (LoopInput 0 85 (F32)) (ICons t254 (ICons t516 (ICons t778 (ICons t1040 (INil))))))) +(let t4222 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4220 (ICons t4221 (INil))))) +(let t4223 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4222 (INil)))) +(let t4224 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4223 (ICons t2023 (INil))))) +(let t4225 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4223 (ICons t2024 (INil))))) +(let t4226 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4225 (ICons t4223 (INil))))) +(let t4227 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4226 (ICons t2025 (INil))))) +(let t4228 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4224 (ICons t4227 (INil))))) +(let t4229 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4228 (ICons t2026 (INil))))) +(let t4230 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4229 (ICons t2027 (INil))))) +(let t4231 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4230 (INil)))) +(let t4232 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4231 (ICons t2028 (INil))))) +(let t4233 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4232 (INil)))) +(let t4234 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4223 (ICons t4233 (INil))))) +(let t4235 (Op (LoopInput 0 86 (F32)) (ICons t256 (ICons t518 (ICons t780 (ICons t1042 (INil))))))) +(let t4236 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4220 (ICons t4235 (INil))))) +(let t4237 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4236 (INil)))) +(let t4238 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4234 (ICons t4237 (INil))))) +(let t4239 (Op (LoopInput 0 87 (F32)) (ICons t258 (ICons t520 (ICons t782 (ICons t1044 (INil))))))) +(let t4240 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t4238 (ICons t4239 (INil))))) +(let t4241 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4240 (INil)))) +(let t4242 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4241 (ICons t4241 (INil))))) +(let t4243 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4242 (INil)))) +(let t4244 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4243 (ICons t2031 (INil))))) +(let t4245 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4244 (ICons t2032 (INil))))) +(let t4246 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4245 (INil)))) +(let t4247 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4246 (INil)))) +(let t4248 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4247 (ICons t4241 (INil))))) +(let t4249 (Op (LoopInput 0 88 (F32)) (ICons t292 (ICons t554 (ICons t816 (ICons t1078 (INil))))))) +(let t4250 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4248 (ICons t4249 (INil))))) +(let t4251 (Op (LoopInput 0 89 (F32)) (ICons t296 (ICons t558 (ICons t820 (ICons t1082 (INil))))))) +(let t4252 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4211 (ICons t4251 (INil))))) +(let t4253 (Op (LoopInput 0 90 (F32)) (ICons t274 (ICons t536 (ICons t798 (ICons t1060 (INil))))))) +(let t4254 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4218 (ICons t4253 (INil))))) +(let t4255 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4254 (ICons t2041 (INil))))) +(let t4256 (Op (LoopInput 0 91 (F32)) (ICons t276 (ICons t538 (ICons t800 (ICons t1062 (INil))))))) +(let t4257 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4255 (ICons t4256 (INil))))) +(let t4258 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4257 (INil)))) +(let t4259 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4258 (INil)))) +(let t4260 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4259 (ICons t2042 (INil))))) +(let t4261 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4258 (ICons t4260 (INil))))) +(let t4262 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4261 (ICons t2043 (INil))))) +(let t4263 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4262 (INil)))) +(let t4264 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4263 (INil)))) +(let t4265 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4264 (INil)))) +(let t4266 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4263 (ICons t4265 (INil))))) +(let t4267 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4266 (ICons t2044 (INil))))) +(let t4268 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4266 (ICons t2045 (INil))))) +(let t4269 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4268 (ICons t4267 (INil))))) +(let t4270 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t4269 (INil)))) +(let t4271 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4270 (ICons t2046 (INil))))) +(let t4272 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4271 (INil)))) +(let t4273 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t4272 (INil)))) +(let t4274 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4273 (ICons t2049 (INil))))) +(let t4275 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2050 (ICons t4274 (INil))))) +(let t4276 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2048 (ICons t4275 (ICons t2047 (INil)))))) +(let t4277 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2051 (ICons t4276 (INil))))) +(let t4278 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4277 (ICons t4266 (INil))))) +(let t4279 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4278 (INil)))) +(let t4280 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4279 (INil)))) +(let t4281 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4278 (ICons t4280 (INil))))) +(let t4282 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4276 (ICons t2052 (INil))))) +(let t4283 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4282 (ICons t2053 (INil))))) +(let t4284 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4276 (ICons t2061 (INil))))) +(let t4285 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t4284 (ICons t2062 (INil))))) +(let t4286 (Op (LoopInput 0 92 (F32)) (ICons t278 (ICons t540 (ICons t802 (ICons t1064 (INil))))))) +(let t4287 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t4276 (ICons t4286 (INil))))) +(let t4288 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4281 (ICons t4287 (INil))))) +(let t4289 (Op (LoopInput 0 93 (Bf16)) (ICons t280 (ICons t542 (ICons t804 (ICons t1066 (INil))))))) +(let t4290 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4283 (ICons t4289 (INil))))) +(let t4291 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t4290 (INil)))) +(let t4292 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t4252 (ICons t4291 (INil))))) +(let t4293 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t4292 (INil)))) +(let t4294 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2054 (ICons t4293 (INil))))) +(let t4295 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4293 (ICons t2055 (INil))))) +(let t4296 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4293 (ICons t2056 (INil))))) +(let t4297 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4296 (ICons t4293 (INil))))) +(let t4298 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4297 (ICons t2057 (INil))))) +(let t4299 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4295 (ICons t4298 (INil))))) +(let t4300 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4299 (ICons t2058 (INil))))) +(let t4301 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4300 (ICons t2059 (INil))))) +(let t4302 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4301 (INil)))) +(let t4303 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4302 (ICons t2060 (INil))))) +(let t4304 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4303 (INil)))) +(let t4305 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4293 (ICons t4304 (INil))))) +(let t4306 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4305 (ICons t4294 (INil))))) +(let t4307 (Op (LoopInput 0 94 (Bf16)) (ICons t282 (ICons t544 (ICons t806 (ICons t1068 (INil))))))) +(let t4308 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4285 (ICons t4307 (INil))))) +(let t4309 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t4308 (INil)))) +(let t4310 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t4306 (ICons t4309 (INil))))) +(let t4311 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4310 (INil)))) +(let t4312 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4311 (ICons t4288 (INil))))) +(let t4313 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4312 (INil)))) +(let t4314 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4313 (ICons t4313 (INil))))) +(let t4315 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4314 (INil)))) +(let t4316 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4315 (ICons t2065 (INil))))) +(let t4317 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4316 (ICons t2066 (INil))))) +(let t4318 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4317 (INil)))) +(let t4319 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4318 (INil)))) +(let t4320 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4319 (ICons t4313 (INil))))) +(let t4321 (Op (LoopInput 0 95 (F32)) (ICons t294 (ICons t556 (ICons t818 (ICons t1080 (INil))))))) +(let t4322 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4320 (ICons t4321 (INil))))) +(let t4323 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4250 (ICons t4322 (INil))))) +(let t4324 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4323 (ICons t4323 (INil))))) +(let t4325 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4324 (INil)))) +(let t4326 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4325 (ICons t2069 (INil))))) +(let t4327 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4326 (ICons t2070 (INil))))) +(let t4328 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4327 (INil)))) +(let t4329 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4328 (INil)))) +(let t4330 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4329 (ICons t4323 (INil))))) +(let t4331 (Op (LoopInput 0 96 (F32)) (ICons t290 (ICons t552 (ICons t814 (ICons t1076 (INil))))))) +(let t4332 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4330 (ICons t4331 (INil))))) +(let t4333 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4197 (ICons t4332 (INil))))) +(let t4334 (Op (LoopInput 0 97 (F32)) (ICons t272 (ICons t534 (ICons t796 (ICons t1058 (INil))))))) +(let t4335 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4333 (ICons t4334 (INil))))) +(let t4336 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4335 (ICons t4335 (INil))))) +(let t4337 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4336 (INil)))) +(let t4338 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4337 (ICons t2073 (INil))))) +(let t4339 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4338 (ICons t2074 (INil))))) +(let t4340 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4339 (INil)))) +(let t4341 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4340 (INil)))) +(let t4342 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4341 (ICons t4335 (INil))))) +(let t4343 (Op (LoopInput 0 98 (F32)) (ICons t328 (ICons t590 (ICons t852 (ICons t1114 (INil))))))) +(let t4344 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4342 (ICons t4343 (INil))))) +(let t4345 (Op (LoopInput 0 99 (F32)) (ICons t304 (ICons t566 (ICons t828 (ICons t1090 (INil))))))) +(let t4346 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4344 (ICons t4345 (INil))))) +(let t4347 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t4346 (INil)))) +(let t4348 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4347 (ICons t4347 (INil))))) +(let t4349 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4348 (INil)))) +(let t4350 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4349 (ICons t2077 (INil))))) +(let t4351 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4350 (ICons t2078 (INil))))) +(let t4352 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4351 (INil)))) +(let t4353 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4352 (INil)))) +(let t4354 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4353 (ICons t4347 (INil))))) +(let t4355 (Op (LoopInput 0 100 (F32)) (ICons t306 (ICons t568 (ICons t830 (ICons t1092 (INil))))))) +(let t4356 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4344 (ICons t4355 (INil))))) +(let t4357 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4356 (INil)))) +(let t4358 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4357 (ICons t4357 (INil))))) +(let t4359 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4358 (INil)))) +(let t4360 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4359 (ICons t2081 (INil))))) +(let t4361 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4360 (ICons t2082 (INil))))) +(let t4362 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4361 (INil)))) +(let t4363 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4362 (INil)))) +(let t4364 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4363 (ICons t4357 (INil))))) +(let t4365 (Op (LoopInput 0 101 (F32)) (ICons t308 (ICons t570 (ICons t832 (ICons t1094 (INil))))))) +(let t4366 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4344 (ICons t4365 (INil))))) +(let t4367 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4366 (INil)))) +(let t4368 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4367 (ICons t4367 (INil))))) +(let t4369 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4368 (INil)))) +(let t4370 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4369 (ICons t2085 (INil))))) +(let t4371 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4370 (ICons t2086 (INil))))) +(let t4372 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4371 (INil)))) +(let t4373 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4372 (INil)))) +(let t4374 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4373 (ICons t4367 (INil))))) +(let t4375 (Op (LoopInput 0 102 (F32)) (ICons t312 (ICons t574 (ICons t836 (ICons t1098 (INil))))))) +(let t4376 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4354 (ICons t4375 (INil))))) +(let t4377 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2100 (ICons t4376 (INil))))) +(let t4378 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4376 (ICons t2105 (INil))))) +(let t4379 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4377 (ICons t2106 (INil))))) +(let t4380 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4379 (ICons t2107 (INil))))) +(let t4381 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4378 (ICons t4380 (INil))))) +(let t4382 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4377 (ICons t2105 (INil))))) +(let t4383 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4376 (ICons t2106 (INil))))) +(let t4384 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4382 (ICons t4383 (INil))))) +(let t4385 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2108 (ICons t4381 (INil))))) +(let t4386 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4385 (ICons t2110 (INil))))) +(let t4387 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2111 (ICons t4384 (INil))))) +(let t4388 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4387 (ICons t2113 (INil))))) +(let t4389 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4386 (ICons t4388 (INil))))) +(let t4390 (Op (LoopInput 0 103 (F32)) (ICons t314 (ICons t576 (ICons t838 (ICons t1100 (INil))))))) +(let t4391 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4364 (ICons t4390 (INil))))) +(let t4392 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2127 (ICons t4391 (INil))))) +(let t4393 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4391 (ICons t2132 (INil))))) +(let t4394 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4392 (ICons t2133 (INil))))) +(let t4395 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4394 (ICons t2134 (INil))))) +(let t4396 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4393 (ICons t4395 (INil))))) +(let t4397 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4392 (ICons t2132 (INil))))) +(let t4398 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4391 (ICons t2133 (INil))))) +(let t4399 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4397 (ICons t4398 (INil))))) +(let t4400 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2135 (ICons t4396 (INil))))) +(let t4401 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4400 (ICons t2137 (INil))))) +(let t4402 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2138 (ICons t4399 (INil))))) +(let t4403 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4402 (ICons t2140 (INil))))) +(let t4404 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4401 (ICons t4403 (INil))))) +(let t4405 (Op (LoopInput 0 104 (F32)) (ICons t18 (ICons t42 (ICons t66 (ICons t90 (INil))))))) +(let t4406 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t4405 (ICons t2151 (ICons t4404 (INil)))))) +(let t4407 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t4389 (ICons t4406 (INil))))) +(let t4408 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4407 (INil)))) +(let t4409 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4408 (ICons t2169 (INil))))) +(let t4410 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4409 (INil)))) +(let t4411 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4410 (ICons t2170 (INil))))) +(let t4412 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4409 (ICons t4411 (INil))))) +(let t4413 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4412 (ICons t2171 (INil))))) +(let t4414 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4413 (INil)))) +(let t4415 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4414 (INil)))) +(let t4416 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4415 (INil)))) +(let t4417 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4414 (ICons t4416 (INil))))) +(let t4418 (Op (LoopInput 0 105 (F32)) (ICons t20 (ICons t44 (ICons t68 (ICons t92 (INil))))))) +(let t4419 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t4418 (ICons t2151 (ICons t4374 (INil)))))) +(let t4420 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t4417 (ICons t4419 (INil))))) +(let t4421 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4420 (INil)))) +(let t4422 (Op (LoopInput 0 106 (F32)) (ICons t310 (ICons t572 (ICons t834 (ICons t1096 (INil))))))) +(let t4423 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t4421 (ICons t4422 (INil))))) +(let t4424 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4423 (INil)))) +(let t4425 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4424 (ICons t4424 (INil))))) +(let t4426 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4425 (INil)))) +(let t4427 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4426 (ICons t2174 (INil))))) +(let t4428 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4427 (ICons t2175 (INil))))) +(let t4429 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4428 (INil)))) +(let t4430 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4429 (INil)))) +(let t4431 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4430 (ICons t4424 (INil))))) +(let t4432 (Op (LoopInput 0 107 (F32)) (ICons t330 (ICons t592 (ICons t854 (ICons t1116 (INil))))))) +(let t4433 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4431 (ICons t4432 (INil))))) +(let t4434 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4335 (ICons t4433 (INil))))) +(let t4435 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4434 (ICons t4434 (INil))))) +(let t4436 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4435 (INil)))) +(let t4437 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4436 (ICons t2178 (INil))))) +(let t4438 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4437 (ICons t2179 (INil))))) +(let t4439 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4438 (INil)))) +(let t4440 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4439 (INil)))) +(let t4441 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4440 (ICons t4434 (INil))))) +(let t4442 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4434 (ICons t4434 (INil))))) +(let t4443 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4442 (INil)))) +(let t4444 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4443 (ICons t2192 (INil))))) +(let t4445 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4444 (ICons t2193 (INil))))) +(let t4446 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4445 (INil)))) +(let t4447 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4446 (INil)))) +(let t4448 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4447 (ICons t4434 (INil))))) +(let t4449 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4434 (ICons t4434 (INil))))) +(let t4450 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4449 (INil)))) +(let t4451 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4450 (ICons t2196 (INil))))) +(let t4452 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4451 (ICons t2197 (INil))))) +(let t4453 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4452 (INil)))) +(let t4454 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4453 (INil)))) +(let t4455 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4454 (ICons t4434 (INil))))) +(let t4456 (Op (LoopInput 0 108 (F32)) (ICons t332 (ICons t594 (ICons t856 (ICons t1118 (INil))))))) +(let t4457 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4441 (ICons t4456 (INil))))) +(let t4458 (Op (LoopInput 0 109 (F32)) (ICons t298 (ICons t560 (ICons t822 (ICons t1084 (INil))))))) +(let t4459 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4457 (ICons t4458 (INil))))) +(let t4460 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4459 (INil)))) +(let t4461 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4460 (ICons t2180 (INil))))) +(let t4462 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4460 (ICons t2181 (INil))))) +(let t4463 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4462 (ICons t4460 (INil))))) +(let t4464 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4463 (ICons t2182 (INil))))) +(let t4465 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4461 (ICons t4464 (INil))))) +(let t4466 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4465 (ICons t2183 (INil))))) +(let t4467 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4466 (ICons t2184 (INil))))) +(let t4468 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4467 (INil)))) +(let t4469 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4468 (ICons t2185 (INil))))) +(let t4470 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4469 (INil)))) +(let t4471 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4460 (ICons t4470 (INil))))) +(let t4472 (Op (LoopInput 0 110 (F32)) (ICons t300 (ICons t562 (ICons t824 (ICons t1086 (INil))))))) +(let t4473 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4457 (ICons t4472 (INil))))) +(let t4474 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4473 (INil)))) +(let t4475 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4471 (ICons t4474 (INil))))) +(let t4476 (Op (LoopInput 0 111 (F32)) (ICons t302 (ICons t564 (ICons t826 (ICons t1088 (INil))))))) +(let t4477 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t4475 (ICons t4476 (INil))))) +(let t4478 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4477 (INil)))) +(let t4479 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4478 (ICons t4478 (INil))))) +(let t4480 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4479 (INil)))) +(let t4481 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4480 (ICons t2188 (INil))))) +(let t4482 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4481 (ICons t2189 (INil))))) +(let t4483 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4482 (INil)))) +(let t4484 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4483 (INil)))) +(let t4485 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4484 (ICons t4478 (INil))))) +(let t4486 (Op (LoopInput 0 112 (F32)) (ICons t336 (ICons t598 (ICons t860 (ICons t1122 (INil))))))) +(let t4487 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4485 (ICons t4486 (INil))))) +(let t4488 (Op (LoopInput 0 113 (F32)) (ICons t340 (ICons t602 (ICons t864 (ICons t1126 (INil))))))) +(let t4489 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4448 (ICons t4488 (INil))))) +(let t4490 (Op (LoopInput 0 114 (F32)) (ICons t318 (ICons t580 (ICons t842 (ICons t1104 (INil))))))) +(let t4491 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4455 (ICons t4490 (INil))))) +(let t4492 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4491 (ICons t2198 (INil))))) +(let t4493 (Op (LoopInput 0 115 (F32)) (ICons t320 (ICons t582 (ICons t844 (ICons t1106 (INil))))))) +(let t4494 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4492 (ICons t4493 (INil))))) +(let t4495 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4494 (INil)))) +(let t4496 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4495 (INil)))) +(let t4497 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4496 (ICons t2199 (INil))))) +(let t4498 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4495 (ICons t4497 (INil))))) +(let t4499 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4498 (ICons t2200 (INil))))) +(let t4500 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4499 (INil)))) +(let t4501 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4500 (INil)))) +(let t4502 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4501 (INil)))) +(let t4503 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4500 (ICons t4502 (INil))))) +(let t4504 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4503 (ICons t2201 (INil))))) +(let t4505 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4503 (ICons t2202 (INil))))) +(let t4506 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4505 (ICons t4504 (INil))))) +(let t4507 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t4506 (INil)))) +(let t4508 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4507 (ICons t2203 (INil))))) +(let t4509 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4508 (INil)))) +(let t4510 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t4509 (INil)))) +(let t4511 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4510 (ICons t2206 (INil))))) +(let t4512 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2207 (ICons t4511 (INil))))) +(let t4513 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2205 (ICons t4512 (ICons t2204 (INil)))))) +(let t4514 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2208 (ICons t4513 (INil))))) +(let t4515 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4514 (ICons t4503 (INil))))) +(let t4516 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4515 (INil)))) +(let t4517 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4516 (INil)))) +(let t4518 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4515 (ICons t4517 (INil))))) +(let t4519 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4513 (ICons t2209 (INil))))) +(let t4520 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4519 (ICons t2210 (INil))))) +(let t4521 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4513 (ICons t2218 (INil))))) +(let t4522 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t4521 (ICons t2219 (INil))))) +(let t4523 (Op (LoopInput 0 116 (F32)) (ICons t322 (ICons t584 (ICons t846 (ICons t1108 (INil))))))) +(let t4524 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t4513 (ICons t4523 (INil))))) +(let t4525 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4518 (ICons t4524 (INil))))) +(let t4526 (Op (LoopInput 0 117 (Bf16)) (ICons t324 (ICons t586 (ICons t848 (ICons t1110 (INil))))))) +(let t4527 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4520 (ICons t4526 (INil))))) +(let t4528 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t4527 (INil)))) +(let t4529 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t4489 (ICons t4528 (INil))))) +(let t4530 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t4529 (INil)))) +(let t4531 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2211 (ICons t4530 (INil))))) +(let t4532 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4530 (ICons t2212 (INil))))) +(let t4533 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4530 (ICons t2213 (INil))))) +(let t4534 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4533 (ICons t4530 (INil))))) +(let t4535 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4534 (ICons t2214 (INil))))) +(let t4536 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4532 (ICons t4535 (INil))))) +(let t4537 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4536 (ICons t2215 (INil))))) +(let t4538 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4537 (ICons t2216 (INil))))) +(let t4539 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4538 (INil)))) +(let t4540 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4539 (ICons t2217 (INil))))) +(let t4541 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4540 (INil)))) +(let t4542 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4530 (ICons t4541 (INil))))) +(let t4543 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4542 (ICons t4531 (INil))))) +(let t4544 (Op (LoopInput 0 118 (Bf16)) (ICons t326 (ICons t588 (ICons t850 (ICons t1112 (INil))))))) +(let t4545 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4522 (ICons t4544 (INil))))) +(let t4546 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t4545 (INil)))) +(let t4547 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t4543 (ICons t4546 (INil))))) +(let t4548 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4547 (INil)))) +(let t4549 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4548 (ICons t4525 (INil))))) +(let t4550 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4549 (INil)))) +(let t4551 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4550 (ICons t4550 (INil))))) +(let t4552 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4551 (INil)))) +(let t4553 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4552 (ICons t2222 (INil))))) +(let t4554 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4553 (ICons t2223 (INil))))) +(let t4555 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4554 (INil)))) +(let t4556 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4555 (INil)))) +(let t4557 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4556 (ICons t4550 (INil))))) +(let t4558 (Op (LoopInput 0 119 (F32)) (ICons t338 (ICons t600 (ICons t862 (ICons t1124 (INil))))))) +(let t4559 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4557 (ICons t4558 (INil))))) +(let t4560 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4487 (ICons t4559 (INil))))) +(let t4561 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4560 (ICons t4560 (INil))))) +(let t4562 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4561 (INil)))) +(let t4563 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4562 (ICons t2226 (INil))))) +(let t4564 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4563 (ICons t2227 (INil))))) +(let t4565 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4564 (INil)))) +(let t4566 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4565 (INil)))) +(let t4567 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4566 (ICons t4560 (INil))))) +(let t4568 (Op (LoopInput 0 120 (F32)) (ICons t334 (ICons t596 (ICons t858 (ICons t1120 (INil))))))) +(let t4569 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4567 (ICons t4568 (INil))))) +(let t4570 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4434 (ICons t4569 (INil))))) +(let t4571 (Op (LoopInput 0 121 (F32)) (ICons t316 (ICons t578 (ICons t840 (ICons t1102 (INil))))))) +(let t4572 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4570 (ICons t4571 (INil))))) +(let t4573 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4572 (ICons t4572 (INil))))) +(let t4574 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4573 (INil)))) +(let t4575 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4574 (ICons t2230 (INil))))) +(let t4576 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4575 (ICons t2231 (INil))))) +(let t4577 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4576 (INil)))) +(let t4578 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4577 (INil)))) +(let t4579 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4578 (ICons t4572 (INil))))) +(let t4580 (Op (LoopInput 0 122 (F32)) (ICons t370 (ICons t632 (ICons t894 (ICons t1156 (INil))))))) +(let t4581 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4579 (ICons t4580 (INil))))) +(let t4582 (Op (LoopInput 0 123 (F32)) (ICons t348 (ICons t610 (ICons t872 (ICons t1134 (INil))))))) +(let t4583 (Op (Mul (ECons (MVar "s") (ECons (MNum 8192) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8192)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4581 (ICons t4582 (INil))))) +(let t4584 (Op (Sum (ECons (MVar "s") (ECons (MNum 8192) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8192)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil)))) (ICons t4583 (INil)))) +(let t4585 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4584 (ICons t4584 (INil))))) +(let t4586 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4585 (INil)))) +(let t4587 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4586 (ICons t2234 (INil))))) +(let t4588 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4587 (ICons t2235 (INil))))) +(let t4589 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4588 (INil)))) +(let t4590 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4589 (INil)))) +(let t4591 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4590 (ICons t4584 (INil))))) +(let t4592 (Op (LoopInput 0 124 (F32)) (ICons t350 (ICons t612 (ICons t874 (ICons t1136 (INil))))))) +(let t4593 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4581 (ICons t4592 (INil))))) +(let t4594 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t4593 (INil)))) +(let t4595 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4594 (ICons t4594 (INil))))) +(let t4596 (Op (Sum (ECons (MVar "s") (ECons (MNum 2) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4595 (INil)))) +(let t4597 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4596 (ICons t2238 (INil))))) +(let t4598 (Op (Add (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4597 (ICons t2239 (INil))))) +(let t4599 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4598 (INil)))) +(let t4600 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4599 (INil)))) +(let t4601 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4600 (ICons t4594 (INil))))) +(let t4602 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4594 (ICons t4594 (INil))))) +(let t4603 (Op (Sum (ECons (MVar "s") (ECons (MNum 2) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4602 (INil)))) +(let t4604 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4603 (ICons t2242 (INil))))) +(let t4605 (Op (Add (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4604 (ICons t2243 (INil))))) +(let t4606 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4605 (INil)))) +(let t4607 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t4606 (INil)))) +(let t4608 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4607 (ICons t4594 (INil))))) +(let t4609 (Op (LoopInput 0 125 (F32)) (ICons t354 (ICons t616 (ICons t878 (ICons t1140 (INil))))))) +(let t4610 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4591 (ICons t4609 (INil))))) +(let t4611 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2272 (ICons t4610 (INil))))) +(let t4612 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4610 (ICons t2277 (INil))))) +(let t4613 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4611 (ICons t2278 (INil))))) +(let t4614 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4613 (ICons t2279 (INil))))) +(let t4615 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4612 (ICons t4614 (INil))))) +(let t4616 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4611 (ICons t2277 (INil))))) +(let t4617 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4610 (ICons t2278 (INil))))) +(let t4618 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4616 (ICons t4617 (INil))))) +(let t4619 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2280 (ICons t4615 (INil))))) +(let t4620 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4619 (ICons t2282 (INil))))) +(let t4621 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2283 (ICons t4618 (INil))))) +(let t4622 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4621 (ICons t2285 (INil))))) +(let t4623 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4620 (ICons t4622 (INil))))) +(let t4624 (Op (LoopInput 0 126 (F32)) (ICons t356 (ICons t618 (ICons t880 (ICons t1142 (INil))))))) +(let t4625 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4601 (ICons t4624 (INil))))) +(let t4626 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil))))) (ICons t2314 (ICons t4625 (INil))))) +(let t4627 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4625 (ICons t2319 (INil))))) +(let t4628 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4626 (ICons t2320 (INil))))) +(let t4629 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4628 (ICons t2321 (INil))))) +(let t4630 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4627 (ICons t4629 (INil))))) +(let t4631 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4626 (ICons t2319 (INil))))) +(let t4632 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4625 (ICons t2320 (INil))))) +(let t4633 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4631 (ICons t4632 (INil))))) +(let t4634 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2322 (ICons t4630 (INil))))) +(let t4635 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4634 (ICons t2324 (INil))))) +(let t4636 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t2325 (ICons t4633 (INil))))) +(let t4637 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4636 (ICons t2327 (INil))))) +(let t4638 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4635 (ICons t4637 (INil))))) +(let t4639 (Op (LoopInput 0 127 (F32)) (ICons t22 (ICons t46 (ICons t70 (ICons t94 (INil))))))) +(let t4640 (Op (Scatter (ECons (MNum 2) (ECons (MNum 4096) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 4096)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (MNum 512)) (ECons (MMul (MIter) (MNum 512)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil))))) (ICons t4639 (ICons t2338 (ICons t4638 (INil)))))) +(let t4641 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 512) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (MNum 512)) (ECons (MMul (MIter) (MNum 512)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 512)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))))) (ICons t4623 (ICons t4640 (INil))))) +(let t4642 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 512) (ECons (MMul (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 512)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4641 (INil)))) +(let t4643 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4642 (ICons t2349 (INil))))) +(let t4644 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4643 (INil)))) +(let t4645 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4644 (ICons t2350 (INil))))) +(let t4646 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4643 (ICons t4645 (INil))))) +(let t4647 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4646 (ICons t2351 (INil))))) +(let t4648 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4647 (INil)))) +(let t4649 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4648 (INil)))) +(let t4650 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4649 (INil)))) +(let t4651 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4648 (ICons t4650 (INil))))) +(let t4652 (Op (LoopInput 0 128 (F32)) (ICons t24 (ICons t48 (ICons t72 (ICons t96 (INil))))))) +(let t4653 (Op (Scatter (ECons (MNum 2) (ECons (MNum 4096) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 4096)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil))))) (ICons t4652 (ICons t2338 (ICons t4608 (INil)))))) +(let t4654 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 512)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 512)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t4651 (ICons t4653 (INil))))) +(let t4655 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t4654 (INil)))) +(let t4656 (Op (LoopInput 0 129 (F32)) (ICons t352 (ICons t614 (ICons t876 (ICons t1138 (INil))))))) +(let t4657 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 8192) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 8192)) (MNum 2816)) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil))))) (ICons t4655 (ICons t4656 (INil))))) +(let t4658 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8192) (ECons (MMul (MMul (MIter) (MNum 8192)) (MNum 2816)) (ECons (MMul (MIter) (MNum 8192)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4657 (INil)))) +(let t4659 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4658 (ICons t4658 (INil))))) +(let t4660 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4659 (INil)))) +(let t4661 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4660 (ICons t2354 (INil))))) +(let t4662 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4661 (ICons t2355 (INil))))) +(let t4663 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4662 (INil)))) +(let t4664 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4663 (INil)))) +(let t4665 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4664 (ICons t4658 (INil))))) +(let t4666 (Op (LoopInput 0 130 (F32)) (ICons t372 (ICons t634 (ICons t896 (ICons t1158 (INil))))))) +(let t4667 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4665 (ICons t4666 (INil))))) +(let t4668 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4572 (ICons t4667 (INil))))) +(let t4669 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4668 (ICons t4668 (INil))))) +(let t4670 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4669 (INil)))) +(let t4671 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4670 (ICons t2358 (INil))))) +(let t4672 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4671 (ICons t2359 (INil))))) +(let t4673 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4672 (INil)))) +(let t4674 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4673 (INil)))) +(let t4675 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4674 (ICons t4668 (INil))))) +(let t4676 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4668 (ICons t4668 (INil))))) +(let t4677 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4676 (INil)))) +(let t4678 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4677 (ICons t2372 (INil))))) +(let t4679 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4678 (ICons t2373 (INil))))) +(let t4680 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4679 (INil)))) +(let t4681 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4680 (INil)))) +(let t4682 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4681 (ICons t4668 (INil))))) +(let t4683 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4668 (ICons t4668 (INil))))) +(let t4684 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4683 (INil)))) +(let t4685 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4684 (ICons t2376 (INil))))) +(let t4686 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4685 (ICons t2377 (INil))))) +(let t4687 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4686 (INil)))) +(let t4688 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4687 (INil)))) +(let t4689 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4688 (ICons t4668 (INil))))) +(let t4690 (Op (LoopInput 0 131 (F32)) (ICons t374 (ICons t636 (ICons t898 (ICons t1160 (INil))))))) +(let t4691 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4675 (ICons t4690 (INil))))) +(let t4692 (Op (LoopInput 0 132 (F32)) (ICons t342 (ICons t604 (ICons t866 (ICons t1128 (INil))))))) +(let t4693 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4691 (ICons t4692 (INil))))) +(let t4694 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4693 (INil)))) +(let t4695 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4694 (ICons t2360 (INil))))) +(let t4696 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4694 (ICons t2361 (INil))))) +(let t4697 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4696 (ICons t4694 (INil))))) +(let t4698 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4697 (ICons t2362 (INil))))) +(let t4699 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4695 (ICons t4698 (INil))))) +(let t4700 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4699 (ICons t2363 (INil))))) +(let t4701 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4700 (ICons t2364 (INil))))) +(let t4702 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4701 (INil)))) +(let t4703 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4702 (ICons t2365 (INil))))) +(let t4704 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4703 (INil)))) +(let t4705 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4694 (ICons t4704 (INil))))) +(let t4706 (Op (LoopInput 0 133 (F32)) (ICons t344 (ICons t606 (ICons t868 (ICons t1130 (INil))))))) +(let t4707 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4691 (ICons t4706 (INil))))) +(let t4708 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4707 (INil)))) +(let t4709 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4705 (ICons t4708 (INil))))) +(let t4710 (Op (LoopInput 0 134 (F32)) (ICons t346 (ICons t608 (ICons t870 (ICons t1132 (INil))))))) +(let t4711 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t4709 (ICons t4710 (INil))))) +(let t4712 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4711 (INil)))) +(let t4713 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4712 (ICons t4712 (INil))))) +(let t4714 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4713 (INil)))) +(let t4715 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4714 (ICons t2368 (INil))))) +(let t4716 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4715 (ICons t2369 (INil))))) +(let t4717 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4716 (INil)))) +(let t4718 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4717 (INil)))) +(let t4719 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4718 (ICons t4712 (INil))))) +(let t4720 (Op (LoopInput 0 135 (F32)) (ICons t378 (ICons t640 (ICons t902 (ICons t1164 (INil))))))) +(let t4721 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4719 (ICons t4720 (INil))))) +(let t4722 (Op (LoopInput 0 136 (F32)) (ICons t382 (ICons t644 (ICons t906 (ICons t1168 (INil))))))) +(let t4723 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4682 (ICons t4722 (INil))))) +(let t4724 (Op (LoopInput 0 137 (F32)) (ICons t360 (ICons t622 (ICons t884 (ICons t1146 (INil))))))) +(let t4725 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4689 (ICons t4724 (INil))))) +(let t4726 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4725 (ICons t2378 (INil))))) +(let t4727 (Op (LoopInput 0 138 (F32)) (ICons t362 (ICons t624 (ICons t886 (ICons t1148 (INil))))))) +(let t4728 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4726 (ICons t4727 (INil))))) +(let t4729 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4728 (INil)))) +(let t4730 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4729 (INil)))) +(let t4731 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4730 (ICons t2379 (INil))))) +(let t4732 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4729 (ICons t4731 (INil))))) +(let t4733 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4732 (ICons t2380 (INil))))) +(let t4734 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4733 (INil)))) +(let t4735 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4734 (INil)))) +(let t4736 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4735 (INil)))) +(let t4737 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4734 (ICons t4736 (INil))))) +(let t4738 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4737 (ICons t2381 (INil))))) +(let t4739 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4737 (ICons t2382 (INil))))) +(let t4740 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4739 (ICons t4738 (INil))))) +(let t4741 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t4740 (INil)))) +(let t4742 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4741 (ICons t2383 (INil))))) +(let t4743 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4742 (INil)))) +(let t4744 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t4743 (INil)))) +(let t4745 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4744 (ICons t2386 (INil))))) +(let t4746 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2387 (ICons t4745 (INil))))) +(let t4747 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2385 (ICons t4746 (ICons t2384 (INil)))))) +(let t4748 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2388 (ICons t4747 (INil))))) +(let t4749 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4748 (ICons t4737 (INil))))) +(let t4750 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4749 (INil)))) +(let t4751 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4750 (INil)))) +(let t4752 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4749 (ICons t4751 (INil))))) +(let t4753 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4747 (ICons t2389 (INil))))) +(let t4754 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4753 (ICons t2390 (INil))))) +(let t4755 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4747 (ICons t2398 (INil))))) +(let t4756 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t4755 (ICons t2399 (INil))))) +(let t4757 (Op (LoopInput 0 139 (F32)) (ICons t364 (ICons t626 (ICons t888 (ICons t1150 (INil))))))) +(let t4758 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t4747 (ICons t4757 (INil))))) +(let t4759 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4752 (ICons t4758 (INil))))) +(let t4760 (Op (LoopInput 0 140 (Bf16)) (ICons t366 (ICons t628 (ICons t890 (ICons t1152 (INil))))))) +(let t4761 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4754 (ICons t4760 (INil))))) +(let t4762 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t4761 (INil)))) +(let t4763 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t4723 (ICons t4762 (INil))))) +(let t4764 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t4763 (INil)))) +(let t4765 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2391 (ICons t4764 (INil))))) +(let t4766 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4764 (ICons t2392 (INil))))) +(let t4767 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4764 (ICons t2393 (INil))))) +(let t4768 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4767 (ICons t4764 (INil))))) +(let t4769 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4768 (ICons t2394 (INil))))) +(let t4770 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4766 (ICons t4769 (INil))))) +(let t4771 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4770 (ICons t2395 (INil))))) +(let t4772 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4771 (ICons t2396 (INil))))) +(let t4773 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4772 (INil)))) +(let t4774 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4773 (ICons t2397 (INil))))) +(let t4775 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4774 (INil)))) +(let t4776 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4764 (ICons t4775 (INil))))) +(let t4777 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4776 (ICons t4765 (INil))))) +(let t4778 (Op (LoopInput 0 141 (Bf16)) (ICons t368 (ICons t630 (ICons t892 (ICons t1154 (INil))))))) +(let t4779 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4756 (ICons t4778 (INil))))) +(let t4780 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t4779 (INil)))) +(let t4781 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t4777 (ICons t4780 (INil))))) +(let t4782 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4781 (INil)))) +(let t4783 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4782 (ICons t4759 (INil))))) +(let t4784 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4783 (INil)))) +(let t4785 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4784 (ICons t4784 (INil))))) +(let t4786 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4785 (INil)))) +(let t4787 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4786 (ICons t2402 (INil))))) +(let t4788 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4787 (ICons t2403 (INil))))) +(let t4789 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4788 (INil)))) +(let t4790 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4789 (INil)))) +(let t4791 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4790 (ICons t4784 (INil))))) +(let t4792 (Op (LoopInput 0 142 (F32)) (ICons t380 (ICons t642 (ICons t904 (ICons t1166 (INil))))))) +(let t4793 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4791 (ICons t4792 (INil))))) +(let t4794 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4721 (ICons t4793 (INil))))) +(let t4795 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4794 (ICons t4794 (INil))))) +(let t4796 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4795 (INil)))) +(let t4797 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4796 (ICons t2406 (INil))))) +(let t4798 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4797 (ICons t2407 (INil))))) +(let t4799 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4798 (INil)))) +(let t4800 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4799 (INil)))) +(let t4801 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4800 (ICons t4794 (INil))))) +(let t4802 (Op (LoopInput 0 143 (F32)) (ICons t376 (ICons t638 (ICons t900 (ICons t1162 (INil))))))) +(let t4803 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4801 (ICons t4802 (INil))))) +(let t4804 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4668 (ICons t4803 (INil))))) +(let t4805 (Op (LoopInput 0 144 (F32)) (ICons t358 (ICons t620 (ICons t882 (ICons t1144 (INil))))))) +(let t4806 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4804 (ICons t4805 (INil))))) +(let t4807 (LoopEnd t4806 0 0 (F32))) +(let t4808 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4807 (ICons t4807 (INil))))) +(let t4809 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4808 (INil)))) +(let t4810 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4809 (ICons t2410 (INil))))) +(let t4811 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4810 (ICons t2411 (INil))))) +(let t4812 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4811 (INil)))) +(let t4813 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4812 (INil)))) +(let t4814 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4813 (ICons t4807 (INil))))) +(let t4815 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4814 (ICons t1200 (INil))))) +(let t4816 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4815 (ICons t1176 (INil))))) +(let t4817 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t4816 (INil)))) +(let t4818 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4815 (ICons t1178 (INil))))) +(let t4819 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4818 (INil)))) +(let t4820 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4815 (ICons t1180 (INil))))) +(let t4821 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t4820 (INil)))) +(let t4822 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4817 (ICons t4817 (INil))))) +(let t4823 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4822 (INil)))) +(let t4824 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4823 (ICons t2414 (INil))))) +(let t4825 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4824 (ICons t2415 (INil))))) +(let t4826 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4825 (INil)))) +(let t4827 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t4826 (INil)))) +(let t4828 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4827 (ICons t4817 (INil))))) +(let t4829 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4828 (ICons t1184 (INil))))) +(let t4830 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4819 (ICons t4819 (INil))))) +(let t4831 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4830 (INil)))) +(let t4832 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4831 (ICons t2418 (INil))))) +(let t4833 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4832 (ICons t2419 (INil))))) +(let t4834 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4833 (INil)))) +(let t4835 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4834 (INil)))) +(let t4836 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4835 (ICons t4819 (INil))))) +(let t4837 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4836 (ICons t1186 (INil))))) +(let t4838 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4821 (ICons t4821 (INil))))) +(let t4839 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4838 (INil)))) +(let t4840 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4839 (ICons t2422 (INil))))) +(let t4841 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4840 (ICons t2423 (INil))))) +(let t4842 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4841 (INil)))) +(let t4843 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4842 (INil)))) +(let t4844 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4843 (ICons t4821 (INil))))) +(let t4845 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2437 (ICons t4829 (INil))))) +(let t4846 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4829 (ICons t2442 (INil))))) +(let t4847 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4845 (ICons t2443 (INil))))) +(let t4848 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4847 (ICons t2444 (INil))))) +(let t4849 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4846 (ICons t4848 (INil))))) +(let t4850 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4845 (ICons t2442 (INil))))) +(let t4851 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4829 (ICons t2443 (INil))))) +(let t4852 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4850 (ICons t4851 (INil))))) +(let t4853 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2445 (ICons t4849 (INil))))) +(let t4854 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4853 (ICons t2447 (INil))))) +(let t4855 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2448 (ICons t4852 (INil))))) +(let t4856 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4855 (ICons t2450 (INil))))) +(let t4857 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4854 (ICons t4856 (INil))))) +(let t4858 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2464 (ICons t4837 (INil))))) +(let t4859 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4837 (ICons t2469 (INil))))) +(let t4860 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4858 (ICons t2470 (INil))))) +(let t4861 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4860 (ICons t2471 (INil))))) +(let t4862 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4859 (ICons t4861 (INil))))) +(let t4863 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4858 (ICons t2469 (INil))))) +(let t4864 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4837 (ICons t2470 (INil))))) +(let t4865 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4863 (ICons t4864 (INil))))) +(let t4866 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2472 (ICons t4862 (INil))))) +(let t4867 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4866 (ICons t2474 (INil))))) +(let t4868 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2475 (ICons t4865 (INil))))) +(let t4869 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4868 (ICons t2477 (INil))))) +(let t4870 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4867 (ICons t4869 (INil))))) +(let t4871 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t98 (ICons t2488 (ICons t4870 (INil)))))) +(let t4872 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t100 (ICons t2488 (ICons t4844 (INil)))))) +(let t4873 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t4857 (ICons t4871 (INil))))) +(let t4874 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4873 (INil)))) +(let t4875 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4874 (ICons t2506 (INil))))) +(let t4876 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4875 (INil)))) +(let t4877 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4876 (ICons t2507 (INil))))) +(let t4878 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4875 (ICons t4877 (INil))))) +(let t4879 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4878 (ICons t2508 (INil))))) +(let t4880 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4879 (INil)))) +(let t4881 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t4880 (INil)))) +(let t4882 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4881 (INil)))) +(let t4883 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t4880 (ICons t4882 (INil))))) +(let t4884 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t4883 (ICons t4872 (INil))))) +(let t4885 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t4884 (INil)))) +(let t4886 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t4885 (ICons t1182 (INil))))) +(let t4887 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4886 (INil)))) +(let t4888 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4887 (ICons t4887 (INil))))) +(let t4889 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4888 (INil)))) +(let t4890 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4889 (ICons t2511 (INil))))) +(let t4891 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4890 (ICons t2512 (INil))))) +(let t4892 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4891 (INil)))) +(let t4893 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4892 (INil)))) +(let t4894 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4893 (ICons t4887 (INil))))) +(let t4895 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4894 (ICons t1202 (INil))))) +(let t4896 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4807 (ICons t4895 (INil))))) +(let t4897 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4896 (ICons t4896 (INil))))) +(let t4898 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4897 (INil)))) +(let t4899 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4898 (ICons t2515 (INil))))) +(let t4900 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4899 (ICons t2516 (INil))))) +(let t4901 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4900 (INil)))) +(let t4902 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4901 (INil)))) +(let t4903 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4902 (ICons t4896 (INil))))) +(let t4904 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4903 (ICons t1204 (INil))))) +(let t4905 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4904 (ICons t1170 (INil))))) +(let t4906 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4905 (INil)))) +(let t4907 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4906 (ICons t2517 (INil))))) +(let t4908 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4906 (ICons t2518 (INil))))) +(let t4909 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4908 (ICons t4906 (INil))))) +(let t4910 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4909 (ICons t2519 (INil))))) +(let t4911 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4907 (ICons t4910 (INil))))) +(let t4912 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4911 (ICons t2520 (INil))))) +(let t4913 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4912 (ICons t2521 (INil))))) +(let t4914 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4913 (INil)))) +(let t4915 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4914 (ICons t2522 (INil))))) +(let t4916 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4915 (INil)))) +(let t4917 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4906 (ICons t4916 (INil))))) +(let t4918 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4904 (ICons t1172 (INil))))) +(let t4919 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4918 (INil)))) +(let t4920 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t4917 (ICons t4919 (INil))))) +(let t4921 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t4920 (ICons t1174 (INil))))) +(let t4922 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4921 (INil)))) +(let t4923 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4922 (ICons t4922 (INil))))) +(let t4924 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4923 (INil)))) +(let t4925 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4924 (ICons t2525 (INil))))) +(let t4926 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4925 (ICons t2526 (INil))))) +(let t4927 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4926 (INil)))) +(let t4928 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4927 (INil)))) +(let t4929 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4928 (ICons t4922 (INil))))) +(let t4930 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4929 (ICons t1208 (INil))))) +(let t4931 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4896 (ICons t4896 (INil))))) +(let t4932 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4931 (INil)))) +(let t4933 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4932 (ICons t2529 (INil))))) +(let t4934 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4933 (ICons t2530 (INil))))) +(let t4935 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4934 (INil)))) +(let t4936 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4935 (INil)))) +(let t4937 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4936 (ICons t4896 (INil))))) +(let t4938 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4937 (ICons t1212 (INil))))) +(let t4939 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4896 (ICons t4896 (INil))))) +(let t4940 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4939 (INil)))) +(let t4941 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4940 (ICons t2533 (INil))))) +(let t4942 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t4941 (ICons t2534 (INil))))) +(let t4943 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4942 (INil)))) +(let t4944 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t4943 (INil)))) +(let t4945 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4944 (ICons t4896 (INil))))) +(let t4946 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4945 (ICons t1190 (INil))))) +(let t4947 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4946 (ICons t2535 (INil))))) +(let t4948 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4947 (ICons t1192 (INil))))) +(let t4949 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4948 (INil)))) +(let t4950 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4949 (INil)))) +(let t4951 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4950 (ICons t2536 (INil))))) +(let t4952 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4949 (ICons t4951 (INil))))) +(let t4953 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4952 (ICons t2537 (INil))))) +(let t4954 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4953 (INil)))) +(let t4955 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4954 (INil)))) +(let t4956 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4955 (INil)))) +(let t4957 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4954 (ICons t4956 (INil))))) +(let t4958 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4957 (ICons t2538 (INil))))) +(let t4959 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4957 (ICons t2539 (INil))))) +(let t4960 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4959 (ICons t4958 (INil))))) +(let t4961 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t4960 (INil)))) +(let t4962 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t4961 (ICons t2540 (INil))))) +(let t4963 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4962 (INil)))) +(let t4964 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t4963 (INil)))) +(let t4965 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4964 (ICons t2543 (INil))))) +(let t4966 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2544 (ICons t4965 (INil))))) +(let t4967 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2542 (ICons t4966 (ICons t2541 (INil)))))) +(let t4968 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2545 (ICons t4967 (INil))))) +(let t4969 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t4968 (ICons t4957 (INil))))) +(let t4970 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t4969 (INil)))) +(let t4971 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4970 (INil)))) +(let t4972 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4969 (ICons t4971 (INil))))) +(let t4973 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t4967 (ICons t1194 (INil))))) +(let t4974 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4972 (ICons t4973 (INil))))) +(let t4975 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4967 (ICons t2546 (INil))))) +(let t4976 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4975 (ICons t2547 (INil))))) +(let t4977 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4976 (ICons t1196 (INil))))) +(let t4978 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t4977 (INil)))) +(let t4979 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t4938 (ICons t4978 (INil))))) +(let t4980 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t4979 (INil)))) +(let t4981 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2548 (ICons t4980 (INil))))) +(let t4982 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4980 (ICons t2549 (INil))))) +(let t4983 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4980 (ICons t2550 (INil))))) +(let t4984 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4983 (ICons t4980 (INil))))) +(let t4985 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4984 (ICons t2551 (INil))))) +(let t4986 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4982 (ICons t4985 (INil))))) +(let t4987 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4986 (ICons t2552 (INil))))) +(let t4988 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4987 (ICons t2553 (INil))))) +(let t4989 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4988 (INil)))) +(let t4990 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4989 (ICons t2554 (INil))))) +(let t4991 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4990 (INil)))) +(let t4992 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4980 (ICons t4991 (INil))))) +(let t4993 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4992 (ICons t4981 (INil))))) +(let t4994 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t4967 (ICons t2555 (INil))))) +(let t4995 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t4994 (ICons t2556 (INil))))) +(let t4996 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t4995 (ICons t1198 (INil))))) +(let t4997 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t4996 (INil)))) +(let t4998 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t4993 (ICons t4997 (INil))))) +(let t4999 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t4998 (INil)))) +(let t5000 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t4999 (ICons t4974 (INil))))) +(let t5001 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5000 (INil)))) +(let t5002 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5001 (ICons t5001 (INil))))) +(let t5003 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5002 (INil)))) +(let t5004 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5003 (ICons t2559 (INil))))) +(let t5005 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5004 (ICons t2560 (INil))))) +(let t5006 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5005 (INil)))) +(let t5007 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5006 (INil)))) +(let t5008 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5007 (ICons t5001 (INil))))) +(let t5009 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5008 (ICons t1210 (INil))))) +(let t5010 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4930 (ICons t5009 (INil))))) +(let t5011 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5010 (ICons t5010 (INil))))) +(let t5012 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5011 (INil)))) +(let t5013 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5012 (ICons t2563 (INil))))) +(let t5014 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5013 (ICons t2564 (INil))))) +(let t5015 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5014 (INil)))) +(let t5016 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5015 (INil)))) +(let t5017 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5016 (ICons t5010 (INil))))) +(let t5018 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5017 (ICons t1206 (INil))))) +(let t5019 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t4896 (ICons t5018 (INil))))) +(let t5020 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5019 (ICons t1188 (INil))))) +(let t5021 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5020 (ICons t5020 (INil))))) +(let t5022 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5021 (INil)))) +(let t5023 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5022 (ICons t2567 (INil))))) +(let t5024 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5023 (ICons t2568 (INil))))) +(let t5025 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5024 (INil)))) +(let t5026 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5025 (INil)))) +(let t5027 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5026 (ICons t5020 (INil))))) +(let t5028 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5027 (ICons t1244 (INil))))) +(let t5029 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5028 (ICons t1220 (INil))))) +(let t5030 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t5029 (INil)))) +(let t5031 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5028 (ICons t1222 (INil))))) +(let t5032 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5031 (INil)))) +(let t5033 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5028 (ICons t1224 (INil))))) +(let t5034 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5033 (INil)))) +(let t5035 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5030 (ICons t5030 (INil))))) +(let t5036 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5035 (INil)))) +(let t5037 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5036 (ICons t2571 (INil))))) +(let t5038 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5037 (ICons t2572 (INil))))) +(let t5039 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5038 (INil)))) +(let t5040 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5039 (INil)))) +(let t5041 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5040 (ICons t5030 (INil))))) +(let t5042 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5041 (ICons t1228 (INil))))) +(let t5043 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5032 (ICons t5032 (INil))))) +(let t5044 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5043 (INil)))) +(let t5045 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5044 (ICons t2575 (INil))))) +(let t5046 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5045 (ICons t2576 (INil))))) +(let t5047 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5046 (INil)))) +(let t5048 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5047 (INil)))) +(let t5049 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5048 (ICons t5032 (INil))))) +(let t5050 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5049 (ICons t1230 (INil))))) +(let t5051 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5034 (ICons t5034 (INil))))) +(let t5052 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5051 (INil)))) +(let t5053 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5052 (ICons t2579 (INil))))) +(let t5054 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5053 (ICons t2580 (INil))))) +(let t5055 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5054 (INil)))) +(let t5056 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5055 (INil)))) +(let t5057 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5056 (ICons t5034 (INil))))) +(let t5058 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2594 (ICons t5042 (INil))))) +(let t5059 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5042 (ICons t2599 (INil))))) +(let t5060 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5058 (ICons t2600 (INil))))) +(let t5061 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5060 (ICons t2601 (INil))))) +(let t5062 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5059 (ICons t5061 (INil))))) +(let t5063 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5058 (ICons t2599 (INil))))) +(let t5064 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5042 (ICons t2600 (INil))))) +(let t5065 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5063 (ICons t5064 (INil))))) +(let t5066 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2602 (ICons t5062 (INil))))) +(let t5067 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5066 (ICons t2604 (INil))))) +(let t5068 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2605 (ICons t5065 (INil))))) +(let t5069 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5068 (ICons t2607 (INil))))) +(let t5070 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5067 (ICons t5069 (INil))))) +(let t5071 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2621 (ICons t5050 (INil))))) +(let t5072 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5050 (ICons t2626 (INil))))) +(let t5073 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5071 (ICons t2627 (INil))))) +(let t5074 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5073 (ICons t2628 (INil))))) +(let t5075 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5072 (ICons t5074 (INil))))) +(let t5076 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5071 (ICons t2626 (INil))))) +(let t5077 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5050 (ICons t2627 (INil))))) +(let t5078 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5076 (ICons t5077 (INil))))) +(let t5079 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2629 (ICons t5075 (INil))))) +(let t5080 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5079 (ICons t2631 (INil))))) +(let t5081 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2632 (ICons t5078 (INil))))) +(let t5082 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5081 (ICons t2634 (INil))))) +(let t5083 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5080 (ICons t5082 (INil))))) +(let t5084 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t102 (ICons t2645 (ICons t5083 (INil)))))) +(let t5085 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t104 (ICons t2645 (ICons t5057 (INil)))))) +(let t5086 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t5070 (ICons t5084 (INil))))) +(let t5087 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5086 (INil)))) +(let t5088 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5087 (ICons t2663 (INil))))) +(let t5089 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5088 (INil)))) +(let t5090 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5089 (ICons t2664 (INil))))) +(let t5091 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5088 (ICons t5090 (INil))))) +(let t5092 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5091 (ICons t2665 (INil))))) +(let t5093 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5092 (INil)))) +(let t5094 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5093 (INil)))) +(let t5095 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5094 (INil)))) +(let t5096 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5093 (ICons t5095 (INil))))) +(let t5097 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t5096 (ICons t5085 (INil))))) +(let t5098 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5097 (INil)))) +(let t5099 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t5098 (ICons t1226 (INil))))) +(let t5100 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5099 (INil)))) +(let t5101 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5100 (ICons t5100 (INil))))) +(let t5102 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5101 (INil)))) +(let t5103 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5102 (ICons t2668 (INil))))) +(let t5104 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5103 (ICons t2669 (INil))))) +(let t5105 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5104 (INil)))) +(let t5106 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5105 (INil)))) +(let t5107 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5106 (ICons t5100 (INil))))) +(let t5108 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5107 (ICons t1246 (INil))))) +(let t5109 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5020 (ICons t5108 (INil))))) +(let t5110 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5109 (ICons t5109 (INil))))) +(let t5111 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5110 (INil)))) +(let t5112 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5111 (ICons t2672 (INil))))) +(let t5113 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5112 (ICons t2673 (INil))))) +(let t5114 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5113 (INil)))) +(let t5115 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5114 (INil)))) +(let t5116 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5115 (ICons t5109 (INil))))) +(let t5117 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5116 (ICons t1248 (INil))))) +(let t5118 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5117 (ICons t1214 (INil))))) +(let t5119 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5118 (INil)))) +(let t5120 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5119 (ICons t2674 (INil))))) +(let t5121 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5119 (ICons t2675 (INil))))) +(let t5122 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5121 (ICons t5119 (INil))))) +(let t5123 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5122 (ICons t2676 (INil))))) +(let t5124 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5120 (ICons t5123 (INil))))) +(let t5125 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5124 (ICons t2677 (INil))))) +(let t5126 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5125 (ICons t2678 (INil))))) +(let t5127 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5126 (INil)))) +(let t5128 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5127 (ICons t2679 (INil))))) +(let t5129 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5128 (INil)))) +(let t5130 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5119 (ICons t5129 (INil))))) +(let t5131 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5117 (ICons t1216 (INil))))) +(let t5132 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5131 (INil)))) +(let t5133 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5130 (ICons t5132 (INil))))) +(let t5134 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t5133 (ICons t1218 (INil))))) +(let t5135 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5134 (INil)))) +(let t5136 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5135 (ICons t5135 (INil))))) +(let t5137 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5136 (INil)))) +(let t5138 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5137 (ICons t2682 (INil))))) +(let t5139 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5138 (ICons t2683 (INil))))) +(let t5140 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5139 (INil)))) +(let t5141 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5140 (INil)))) +(let t5142 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5141 (ICons t5135 (INil))))) +(let t5143 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5142 (ICons t1252 (INil))))) +(let t5144 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5109 (ICons t5109 (INil))))) +(let t5145 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5144 (INil)))) +(let t5146 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5145 (ICons t2686 (INil))))) +(let t5147 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5146 (ICons t2687 (INil))))) +(let t5148 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5147 (INil)))) +(let t5149 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5148 (INil)))) +(let t5150 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5149 (ICons t5109 (INil))))) +(let t5151 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5150 (ICons t1256 (INil))))) +(let t5152 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5109 (ICons t5109 (INil))))) +(let t5153 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5152 (INil)))) +(let t5154 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5153 (ICons t2690 (INil))))) +(let t5155 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5154 (ICons t2691 (INil))))) +(let t5156 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5155 (INil)))) +(let t5157 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5156 (INil)))) +(let t5158 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5157 (ICons t5109 (INil))))) +(let t5159 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5158 (ICons t1234 (INil))))) +(let t5160 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5159 (ICons t2692 (INil))))) +(let t5161 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5160 (ICons t1236 (INil))))) +(let t5162 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5161 (INil)))) +(let t5163 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5162 (INil)))) +(let t5164 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5163 (ICons t2693 (INil))))) +(let t5165 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5162 (ICons t5164 (INil))))) +(let t5166 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5165 (ICons t2694 (INil))))) +(let t5167 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5166 (INil)))) +(let t5168 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5167 (INil)))) +(let t5169 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5168 (INil)))) +(let t5170 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5167 (ICons t5169 (INil))))) +(let t5171 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5170 (ICons t2695 (INil))))) +(let t5172 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5170 (ICons t2696 (INil))))) +(let t5173 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5172 (ICons t5171 (INil))))) +(let t5174 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t5173 (INil)))) +(let t5175 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5174 (ICons t2697 (INil))))) +(let t5176 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5175 (INil)))) +(let t5177 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t5176 (INil)))) +(let t5178 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5177 (ICons t2700 (INil))))) +(let t5179 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2701 (ICons t5178 (INil))))) +(let t5180 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2699 (ICons t5179 (ICons t2698 (INil)))))) +(let t5181 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2702 (ICons t5180 (INil))))) +(let t5182 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5181 (ICons t5170 (INil))))) +(let t5183 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5182 (INil)))) +(let t5184 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5183 (INil)))) +(let t5185 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5182 (ICons t5184 (INil))))) +(let t5186 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t5180 (ICons t1238 (INil))))) +(let t5187 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5185 (ICons t5186 (INil))))) +(let t5188 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5180 (ICons t2703 (INil))))) +(let t5189 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5188 (ICons t2704 (INil))))) +(let t5190 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5189 (ICons t1240 (INil))))) +(let t5191 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t5190 (INil)))) +(let t5192 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t5151 (ICons t5191 (INil))))) +(let t5193 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t5192 (INil)))) +(let t5194 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2705 (ICons t5193 (INil))))) +(let t5195 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5193 (ICons t2706 (INil))))) +(let t5196 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5193 (ICons t2707 (INil))))) +(let t5197 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5196 (ICons t5193 (INil))))) +(let t5198 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5197 (ICons t2708 (INil))))) +(let t5199 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5195 (ICons t5198 (INil))))) +(let t5200 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5199 (ICons t2709 (INil))))) +(let t5201 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5200 (ICons t2710 (INil))))) +(let t5202 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5201 (INil)))) +(let t5203 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5202 (ICons t2711 (INil))))) +(let t5204 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5203 (INil)))) +(let t5205 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5193 (ICons t5204 (INil))))) +(let t5206 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5205 (ICons t5194 (INil))))) +(let t5207 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5180 (ICons t2712 (INil))))) +(let t5208 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t5207 (ICons t2713 (INil))))) +(let t5209 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5208 (ICons t1242 (INil))))) +(let t5210 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t5209 (INil)))) +(let t5211 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t5206 (ICons t5210 (INil))))) +(let t5212 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5211 (INil)))) +(let t5213 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5212 (ICons t5187 (INil))))) +(let t5214 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5213 (INil)))) +(let t5215 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5214 (ICons t5214 (INil))))) +(let t5216 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5215 (INil)))) +(let t5217 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5216 (ICons t2716 (INil))))) +(let t5218 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5217 (ICons t2717 (INil))))) +(let t5219 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5218 (INil)))) +(let t5220 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5219 (INil)))) +(let t5221 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5220 (ICons t5214 (INil))))) +(let t5222 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5221 (ICons t1254 (INil))))) +(let t5223 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5143 (ICons t5222 (INil))))) +(let t5224 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5223 (ICons t5223 (INil))))) +(let t5225 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5224 (INil)))) +(let t5226 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5225 (ICons t2720 (INil))))) +(let t5227 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5226 (ICons t2721 (INil))))) +(let t5228 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5227 (INil)))) +(let t5229 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5228 (INil)))) +(let t5230 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5229 (ICons t5223 (INil))))) +(let t5231 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5230 (ICons t1250 (INil))))) +(let t5232 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5109 (ICons t5231 (INil))))) +(let t5233 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5232 (ICons t1232 (INil))))) +(let t5234 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5233 (ICons t5233 (INil))))) +(let t5235 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5234 (INil)))) +(let t5236 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5235 (ICons t2724 (INil))))) +(let t5237 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5236 (ICons t2725 (INil))))) +(let t5238 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5237 (INil)))) +(let t5239 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5238 (INil)))) +(let t5240 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5239 (ICons t5233 (INil))))) +(let t5241 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5240 (ICons t1288 (INil))))) +(let t5242 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5241 (ICons t1264 (INil))))) +(let t5243 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t5242 (INil)))) +(let t5244 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5241 (ICons t1266 (INil))))) +(let t5245 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5244 (INil)))) +(let t5246 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5241 (ICons t1268 (INil))))) +(let t5247 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5246 (INil)))) +(let t5248 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5243 (ICons t5243 (INil))))) +(let t5249 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5248 (INil)))) +(let t5250 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5249 (ICons t2728 (INil))))) +(let t5251 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5250 (ICons t2729 (INil))))) +(let t5252 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5251 (INil)))) +(let t5253 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5252 (INil)))) +(let t5254 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5253 (ICons t5243 (INil))))) +(let t5255 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5254 (ICons t1272 (INil))))) +(let t5256 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5245 (ICons t5245 (INil))))) +(let t5257 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5256 (INil)))) +(let t5258 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5257 (ICons t2732 (INil))))) +(let t5259 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5258 (ICons t2733 (INil))))) +(let t5260 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5259 (INil)))) +(let t5261 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5260 (INil)))) +(let t5262 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5261 (ICons t5245 (INil))))) +(let t5263 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5262 (ICons t1274 (INil))))) +(let t5264 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5247 (ICons t5247 (INil))))) +(let t5265 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5264 (INil)))) +(let t5266 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5265 (ICons t2736 (INil))))) +(let t5267 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5266 (ICons t2737 (INil))))) +(let t5268 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5267 (INil)))) +(let t5269 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5268 (INil)))) +(let t5270 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5269 (ICons t5247 (INil))))) +(let t5271 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2751 (ICons t5255 (INil))))) +(let t5272 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5255 (ICons t2756 (INil))))) +(let t5273 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5271 (ICons t2757 (INil))))) +(let t5274 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5273 (ICons t2758 (INil))))) +(let t5275 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5272 (ICons t5274 (INil))))) +(let t5276 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5271 (ICons t2756 (INil))))) +(let t5277 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5255 (ICons t2757 (INil))))) +(let t5278 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5276 (ICons t5277 (INil))))) +(let t5279 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2759 (ICons t5275 (INil))))) +(let t5280 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5279 (ICons t2761 (INil))))) +(let t5281 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2762 (ICons t5278 (INil))))) +(let t5282 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5281 (ICons t2764 (INil))))) +(let t5283 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5280 (ICons t5282 (INil))))) +(let t5284 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2778 (ICons t5263 (INil))))) +(let t5285 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5263 (ICons t2783 (INil))))) +(let t5286 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5284 (ICons t2784 (INil))))) +(let t5287 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5286 (ICons t2785 (INil))))) +(let t5288 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5285 (ICons t5287 (INil))))) +(let t5289 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5284 (ICons t2783 (INil))))) +(let t5290 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5263 (ICons t2784 (INil))))) +(let t5291 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5289 (ICons t5290 (INil))))) +(let t5292 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2786 (ICons t5288 (INil))))) +(let t5293 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5292 (ICons t2788 (INil))))) +(let t5294 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2789 (ICons t5291 (INil))))) +(let t5295 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5294 (ICons t2791 (INil))))) +(let t5296 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5293 (ICons t5295 (INil))))) +(let t5297 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t106 (ICons t2802 (ICons t5296 (INil)))))) +(let t5298 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t108 (ICons t2802 (ICons t5270 (INil)))))) +(let t5299 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t5283 (ICons t5297 (INil))))) +(let t5300 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5299 (INil)))) +(let t5301 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5300 (ICons t2820 (INil))))) +(let t5302 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5301 (INil)))) +(let t5303 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5302 (ICons t2821 (INil))))) +(let t5304 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5301 (ICons t5303 (INil))))) +(let t5305 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5304 (ICons t2822 (INil))))) +(let t5306 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5305 (INil)))) +(let t5307 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5306 (INil)))) +(let t5308 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5307 (INil)))) +(let t5309 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5306 (ICons t5308 (INil))))) +(let t5310 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t5309 (ICons t5298 (INil))))) +(let t5311 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5310 (INil)))) +(let t5312 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t5311 (ICons t1270 (INil))))) +(let t5313 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5312 (INil)))) +(let t5314 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5313 (ICons t5313 (INil))))) +(let t5315 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5314 (INil)))) +(let t5316 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5315 (ICons t2825 (INil))))) +(let t5317 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5316 (ICons t2826 (INil))))) +(let t5318 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5317 (INil)))) +(let t5319 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5318 (INil)))) +(let t5320 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5319 (ICons t5313 (INil))))) +(let t5321 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5320 (ICons t1290 (INil))))) +(let t5322 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5233 (ICons t5321 (INil))))) +(let t5323 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5322 (ICons t5322 (INil))))) +(let t5324 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5323 (INil)))) +(let t5325 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5324 (ICons t2829 (INil))))) +(let t5326 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5325 (ICons t2830 (INil))))) +(let t5327 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5326 (INil)))) +(let t5328 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5327 (INil)))) +(let t5329 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5328 (ICons t5322 (INil))))) +(let t5330 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5329 (ICons t1292 (INil))))) +(let t5331 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5330 (ICons t1258 (INil))))) +(let t5332 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5331 (INil)))) +(let t5333 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5332 (ICons t2831 (INil))))) +(let t5334 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5332 (ICons t2832 (INil))))) +(let t5335 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5334 (ICons t5332 (INil))))) +(let t5336 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5335 (ICons t2833 (INil))))) +(let t5337 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5333 (ICons t5336 (INil))))) +(let t5338 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5337 (ICons t2834 (INil))))) +(let t5339 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5338 (ICons t2835 (INil))))) +(let t5340 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5339 (INil)))) +(let t5341 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5340 (ICons t2836 (INil))))) +(let t5342 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5341 (INil)))) +(let t5343 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5332 (ICons t5342 (INil))))) +(let t5344 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5330 (ICons t1260 (INil))))) +(let t5345 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5344 (INil)))) +(let t5346 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5343 (ICons t5345 (INil))))) +(let t5347 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t5346 (ICons t1262 (INil))))) +(let t5348 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5347 (INil)))) +(let t5349 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5348 (ICons t5348 (INil))))) +(let t5350 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5349 (INil)))) +(let t5351 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5350 (ICons t2839 (INil))))) +(let t5352 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5351 (ICons t2840 (INil))))) +(let t5353 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5352 (INil)))) +(let t5354 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5353 (INil)))) +(let t5355 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5354 (ICons t5348 (INil))))) +(let t5356 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5355 (ICons t1296 (INil))))) +(let t5357 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5322 (ICons t5322 (INil))))) +(let t5358 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5357 (INil)))) +(let t5359 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5358 (ICons t2843 (INil))))) +(let t5360 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5359 (ICons t2844 (INil))))) +(let t5361 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5360 (INil)))) +(let t5362 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5361 (INil)))) +(let t5363 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5362 (ICons t5322 (INil))))) +(let t5364 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5363 (ICons t1300 (INil))))) +(let t5365 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5322 (ICons t5322 (INil))))) +(let t5366 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5365 (INil)))) +(let t5367 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5366 (ICons t2847 (INil))))) +(let t5368 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5367 (ICons t2848 (INil))))) +(let t5369 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5368 (INil)))) +(let t5370 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5369 (INil)))) +(let t5371 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5370 (ICons t5322 (INil))))) +(let t5372 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5371 (ICons t1278 (INil))))) +(let t5373 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5372 (ICons t2849 (INil))))) +(let t5374 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5373 (ICons t1280 (INil))))) +(let t5375 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5374 (INil)))) +(let t5376 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5375 (INil)))) +(let t5377 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5376 (ICons t2850 (INil))))) +(let t5378 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5375 (ICons t5377 (INil))))) +(let t5379 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5378 (ICons t2851 (INil))))) +(let t5380 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5379 (INil)))) +(let t5381 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5380 (INil)))) +(let t5382 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5381 (INil)))) +(let t5383 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5380 (ICons t5382 (INil))))) +(let t5384 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5383 (ICons t2852 (INil))))) +(let t5385 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5383 (ICons t2853 (INil))))) +(let t5386 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5385 (ICons t5384 (INil))))) +(let t5387 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t5386 (INil)))) +(let t5388 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5387 (ICons t2854 (INil))))) +(let t5389 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5388 (INil)))) +(let t5390 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t5389 (INil)))) +(let t5391 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5390 (ICons t2857 (INil))))) +(let t5392 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t2858 (ICons t5391 (INil))))) +(let t5393 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t2856 (ICons t5392 (ICons t2855 (INil)))))) +(let t5394 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t2859 (ICons t5393 (INil))))) +(let t5395 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5394 (ICons t5383 (INil))))) +(let t5396 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5395 (INil)))) +(let t5397 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5396 (INil)))) +(let t5398 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5395 (ICons t5397 (INil))))) +(let t5399 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t5393 (ICons t1282 (INil))))) +(let t5400 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5398 (ICons t5399 (INil))))) +(let t5401 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5393 (ICons t2860 (INil))))) +(let t5402 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5401 (ICons t2861 (INil))))) +(let t5403 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5402 (ICons t1284 (INil))))) +(let t5404 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t5403 (INil)))) +(let t5405 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t5364 (ICons t5404 (INil))))) +(let t5406 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t5405 (INil)))) +(let t5407 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t2862 (ICons t5406 (INil))))) +(let t5408 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5406 (ICons t2863 (INil))))) +(let t5409 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5406 (ICons t2864 (INil))))) +(let t5410 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5409 (ICons t5406 (INil))))) +(let t5411 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5410 (ICons t2865 (INil))))) +(let t5412 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5408 (ICons t5411 (INil))))) +(let t5413 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5412 (ICons t2866 (INil))))) +(let t5414 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5413 (ICons t2867 (INil))))) +(let t5415 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5414 (INil)))) +(let t5416 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5415 (ICons t2868 (INil))))) +(let t5417 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5416 (INil)))) +(let t5418 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5406 (ICons t5417 (INil))))) +(let t5419 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5418 (ICons t5407 (INil))))) +(let t5420 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5393 (ICons t2869 (INil))))) +(let t5421 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t5420 (ICons t2870 (INil))))) +(let t5422 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5421 (ICons t1286 (INil))))) +(let t5423 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t5422 (INil)))) +(let t5424 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t5419 (ICons t5423 (INil))))) +(let t5425 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5424 (INil)))) +(let t5426 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5425 (ICons t5400 (INil))))) +(let t5427 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5426 (INil)))) +(let t5428 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5427 (ICons t5427 (INil))))) +(let t5429 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5428 (INil)))) +(let t5430 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5429 (ICons t2873 (INil))))) +(let t5431 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5430 (ICons t2874 (INil))))) +(let t5432 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5431 (INil)))) +(let t5433 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5432 (INil)))) +(let t5434 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5433 (ICons t5427 (INil))))) +(let t5435 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5434 (ICons t1298 (INil))))) +(let t5436 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5356 (ICons t5435 (INil))))) +(let t5437 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5436 (ICons t5436 (INil))))) +(let t5438 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5437 (INil)))) +(let t5439 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5438 (ICons t2877 (INil))))) +(let t5440 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5439 (ICons t2878 (INil))))) +(let t5441 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5440 (INil)))) +(let t5442 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5441 (INil)))) +(let t5443 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5442 (ICons t5436 (INil))))) +(let t5444 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5443 (ICons t1294 (INil))))) +(let t5445 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5322 (ICons t5444 (INil))))) +(let t5446 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5445 (ICons t1276 (INil))))) +(let t5447 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5446 (ICons t5446 (INil))))) +(let t5448 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5447 (INil)))) +(let t5449 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5448 (ICons t2881 (INil))))) +(let t5450 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5449 (ICons t2882 (INil))))) +(let t5451 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5450 (INil)))) +(let t5452 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5451 (INil)))) +(let t5453 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5452 (ICons t5446 (INil))))) +(let t5454 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5453 (ICons t1332 (INil))))) +(let t5455 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5454 (ICons t1308 (INil))))) +(let t5456 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t5455 (INil)))) +(let t5457 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5454 (ICons t1310 (INil))))) +(let t5458 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5457 (INil)))) +(let t5459 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5454 (ICons t1312 (INil))))) +(let t5460 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5459 (INil)))) +(let t5461 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5456 (ICons t5456 (INil))))) +(let t5462 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5461 (INil)))) +(let t5463 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5462 (ICons t2885 (INil))))) +(let t5464 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5463 (ICons t2886 (INil))))) +(let t5465 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5464 (INil)))) +(let t5466 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5465 (INil)))) +(let t5467 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5466 (ICons t5456 (INil))))) +(let t5468 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5467 (ICons t1316 (INil))))) +(let t5469 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5458 (ICons t5458 (INil))))) +(let t5470 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5469 (INil)))) +(let t5471 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5470 (ICons t2889 (INil))))) +(let t5472 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5471 (ICons t2890 (INil))))) +(let t5473 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5472 (INil)))) +(let t5474 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5473 (INil)))) +(let t5475 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5474 (ICons t5458 (INil))))) +(let t5476 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5475 (ICons t1318 (INil))))) +(let t5477 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5460 (ICons t5460 (INil))))) +(let t5478 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5477 (INil)))) +(let t5479 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5478 (ICons t2893 (INil))))) +(let t5480 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5479 (ICons t2894 (INil))))) +(let t5481 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5480 (INil)))) +(let t5482 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5481 (INil)))) +(let t5483 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5482 (ICons t5460 (INil))))) +(let t5484 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t2908 (ICons t5468 (INil))))) +(let t5485 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5468 (ICons t2913 (INil))))) +(let t5486 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5484 (ICons t2914 (INil))))) +(let t5487 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5486 (ICons t2915 (INil))))) +(let t5488 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5485 (ICons t5487 (INil))))) +(let t5489 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5484 (ICons t2913 (INil))))) +(let t5490 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5468 (ICons t2914 (INil))))) +(let t5491 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5489 (ICons t5490 (INil))))) +(let t5492 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2916 (ICons t5488 (INil))))) +(let t5493 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5492 (ICons t2918 (INil))))) +(let t5494 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2919 (ICons t5491 (INil))))) +(let t5495 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5494 (ICons t2921 (INil))))) +(let t5496 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5493 (ICons t5495 (INil))))) +(let t5497 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t2935 (ICons t5476 (INil))))) +(let t5498 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5476 (ICons t2940 (INil))))) +(let t5499 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5497 (ICons t2941 (INil))))) +(let t5500 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5499 (ICons t2942 (INil))))) +(let t5501 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5498 (ICons t5500 (INil))))) +(let t5502 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5497 (ICons t2940 (INil))))) +(let t5503 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5476 (ICons t2941 (INil))))) +(let t5504 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5502 (ICons t5503 (INil))))) +(let t5505 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2943 (ICons t5501 (INil))))) +(let t5506 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5505 (ICons t2945 (INil))))) +(let t5507 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t2946 (ICons t5504 (INil))))) +(let t5508 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5507 (ICons t2948 (INil))))) +(let t5509 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5506 (ICons t5508 (INil))))) +(let t5510 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t110 (ICons t2959 (ICons t5509 (INil)))))) +(let t5511 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t112 (ICons t2959 (ICons t5483 (INil)))))) +(let t5512 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t5496 (ICons t5510 (INil))))) +(let t5513 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5512 (INil)))) +(let t5514 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5513 (ICons t2977 (INil))))) +(let t5515 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5514 (INil)))) +(let t5516 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5515 (ICons t2978 (INil))))) +(let t5517 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5514 (ICons t5516 (INil))))) +(let t5518 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5517 (ICons t2979 (INil))))) +(let t5519 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5518 (INil)))) +(let t5520 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5519 (INil)))) +(let t5521 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5520 (INil)))) +(let t5522 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5519 (ICons t5521 (INil))))) +(let t5523 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t5522 (ICons t5511 (INil))))) +(let t5524 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5523 (INil)))) +(let t5525 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t5524 (ICons t1314 (INil))))) +(let t5526 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5525 (INil)))) +(let t5527 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5526 (ICons t5526 (INil))))) +(let t5528 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5527 (INil)))) +(let t5529 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5528 (ICons t2982 (INil))))) +(let t5530 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5529 (ICons t2983 (INil))))) +(let t5531 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5530 (INil)))) +(let t5532 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5531 (INil)))) +(let t5533 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5532 (ICons t5526 (INil))))) +(let t5534 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5533 (ICons t1334 (INil))))) +(let t5535 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5446 (ICons t5534 (INil))))) +(let t5536 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5535 (ICons t5535 (INil))))) +(let t5537 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5536 (INil)))) +(let t5538 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5537 (ICons t2986 (INil))))) +(let t5539 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5538 (ICons t2987 (INil))))) +(let t5540 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5539 (INil)))) +(let t5541 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5540 (INil)))) +(let t5542 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5541 (ICons t5535 (INil))))) +(let t5543 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5542 (ICons t1336 (INil))))) +(let t5544 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5543 (ICons t1302 (INil))))) +(let t5545 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5544 (INil)))) +(let t5546 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5545 (ICons t2988 (INil))))) +(let t5547 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5545 (ICons t2989 (INil))))) +(let t5548 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5547 (ICons t5545 (INil))))) +(let t5549 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5548 (ICons t2990 (INil))))) +(let t5550 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5546 (ICons t5549 (INil))))) +(let t5551 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5550 (ICons t2991 (INil))))) +(let t5552 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5551 (ICons t2992 (INil))))) +(let t5553 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5552 (INil)))) +(let t5554 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5553 (ICons t2993 (INil))))) +(let t5555 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5554 (INil)))) +(let t5556 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5545 (ICons t5555 (INil))))) +(let t5557 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5543 (ICons t1304 (INil))))) +(let t5558 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5557 (INil)))) +(let t5559 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5556 (ICons t5558 (INil))))) +(let t5560 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t5559 (ICons t1306 (INil))))) +(let t5561 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5560 (INil)))) +(let t5562 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5561 (ICons t5561 (INil))))) +(let t5563 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5562 (INil)))) +(let t5564 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5563 (ICons t2996 (INil))))) +(let t5565 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5564 (ICons t2997 (INil))))) +(let t5566 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5565 (INil)))) +(let t5567 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5566 (INil)))) +(let t5568 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5567 (ICons t5561 (INil))))) +(let t5569 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5568 (ICons t1340 (INil))))) +(let t5570 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5535 (ICons t5535 (INil))))) +(let t5571 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5570 (INil)))) +(let t5572 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5571 (ICons t3000 (INil))))) +(let t5573 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5572 (ICons t3001 (INil))))) +(let t5574 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5573 (INil)))) +(let t5575 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5574 (INil)))) +(let t5576 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5575 (ICons t5535 (INil))))) +(let t5577 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5576 (ICons t1344 (INil))))) +(let t5578 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5535 (ICons t5535 (INil))))) +(let t5579 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5578 (INil)))) +(let t5580 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5579 (ICons t3004 (INil))))) +(let t5581 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5580 (ICons t3005 (INil))))) +(let t5582 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5581 (INil)))) +(let t5583 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5582 (INil)))) +(let t5584 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5583 (ICons t5535 (INil))))) +(let t5585 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5584 (ICons t1322 (INil))))) +(let t5586 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5585 (ICons t3006 (INil))))) +(let t5587 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5586 (ICons t1324 (INil))))) +(let t5588 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5587 (INil)))) +(let t5589 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5588 (INil)))) +(let t5590 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5589 (ICons t3007 (INil))))) +(let t5591 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5588 (ICons t5590 (INil))))) +(let t5592 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5591 (ICons t3008 (INil))))) +(let t5593 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5592 (INil)))) +(let t5594 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5593 (INil)))) +(let t5595 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5594 (INil)))) +(let t5596 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5593 (ICons t5595 (INil))))) +(let t5597 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5596 (ICons t3009 (INil))))) +(let t5598 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5596 (ICons t3010 (INil))))) +(let t5599 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5598 (ICons t5597 (INil))))) +(let t5600 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t5599 (INil)))) +(let t5601 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5600 (ICons t3011 (INil))))) +(let t5602 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5601 (INil)))) +(let t5603 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t5602 (INil)))) +(let t5604 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5603 (ICons t3014 (INil))))) +(let t5605 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3015 (ICons t5604 (INil))))) +(let t5606 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t3013 (ICons t5605 (ICons t3012 (INil)))))) +(let t5607 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3016 (ICons t5606 (INil))))) +(let t5608 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5607 (ICons t5596 (INil))))) +(let t5609 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5608 (INil)))) +(let t5610 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5609 (INil)))) +(let t5611 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5608 (ICons t5610 (INil))))) +(let t5612 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t5606 (ICons t1326 (INil))))) +(let t5613 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5611 (ICons t5612 (INil))))) +(let t5614 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5606 (ICons t3017 (INil))))) +(let t5615 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5614 (ICons t3018 (INil))))) +(let t5616 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5615 (ICons t1328 (INil))))) +(let t5617 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t5616 (INil)))) +(let t5618 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t5577 (ICons t5617 (INil))))) +(let t5619 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t5618 (INil)))) +(let t5620 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t3019 (ICons t5619 (INil))))) +(let t5621 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5619 (ICons t3020 (INil))))) +(let t5622 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5619 (ICons t3021 (INil))))) +(let t5623 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5622 (ICons t5619 (INil))))) +(let t5624 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5623 (ICons t3022 (INil))))) +(let t5625 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5621 (ICons t5624 (INil))))) +(let t5626 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5625 (ICons t3023 (INil))))) +(let t5627 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5626 (ICons t3024 (INil))))) +(let t5628 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5627 (INil)))) +(let t5629 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5628 (ICons t3025 (INil))))) +(let t5630 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5629 (INil)))) +(let t5631 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5619 (ICons t5630 (INil))))) +(let t5632 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5631 (ICons t5620 (INil))))) +(let t5633 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5606 (ICons t3026 (INil))))) +(let t5634 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t5633 (ICons t3027 (INil))))) +(let t5635 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5634 (ICons t1330 (INil))))) +(let t5636 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t5635 (INil)))) +(let t5637 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t5632 (ICons t5636 (INil))))) +(let t5638 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5637 (INil)))) +(let t5639 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5638 (ICons t5613 (INil))))) +(let t5640 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5639 (INil)))) +(let t5641 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5640 (ICons t5640 (INil))))) +(let t5642 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5641 (INil)))) +(let t5643 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5642 (ICons t3030 (INil))))) +(let t5644 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5643 (ICons t3031 (INil))))) +(let t5645 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5644 (INil)))) +(let t5646 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5645 (INil)))) +(let t5647 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5646 (ICons t5640 (INil))))) +(let t5648 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5647 (ICons t1342 (INil))))) +(let t5649 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5569 (ICons t5648 (INil))))) +(let t5650 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5649 (ICons t5649 (INil))))) +(let t5651 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5650 (INil)))) +(let t5652 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5651 (ICons t3034 (INil))))) +(let t5653 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5652 (ICons t3035 (INil))))) +(let t5654 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5653 (INil)))) +(let t5655 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5654 (INil)))) +(let t5656 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5655 (ICons t5649 (INil))))) +(let t5657 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5656 (ICons t1338 (INil))))) +(let t5658 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5535 (ICons t5657 (INil))))) +(let t5659 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5658 (ICons t1320 (INil))))) +(let t5660 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5659 (ICons t5659 (INil))))) +(let t5661 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5660 (INil)))) +(let t5662 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5661 (ICons t3038 (INil))))) +(let t5663 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5662 (ICons t3039 (INil))))) +(let t5664 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5663 (INil)))) +(let t5665 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5664 (INil)))) +(let t5666 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5665 (ICons t5659 (INil))))) +(let t5667 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5666 (ICons t1376 (INil))))) +(let t5668 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5667 (ICons t1352 (INil))))) +(let t5669 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t5668 (INil)))) +(let t5670 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5667 (ICons t1354 (INil))))) +(let t5671 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5670 (INil)))) +(let t5672 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5667 (ICons t1356 (INil))))) +(let t5673 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2048)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t5672 (INil)))) +(let t5674 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5669 (ICons t5669 (INil))))) +(let t5675 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5674 (INil)))) +(let t5676 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5675 (ICons t3042 (INil))))) +(let t5677 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5676 (ICons t3043 (INil))))) +(let t5678 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5677 (INil)))) +(let t5679 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5678 (INil)))) +(let t5680 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5679 (ICons t5669 (INil))))) +(let t5681 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5680 (ICons t1360 (INil))))) +(let t5682 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5671 (ICons t5671 (INil))))) +(let t5683 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5682 (INil)))) +(let t5684 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5683 (ICons t3046 (INil))))) +(let t5685 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5684 (ICons t3047 (INil))))) +(let t5686 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5685 (INil)))) +(let t5687 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5686 (INil)))) +(let t5688 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5687 (ICons t5671 (INil))))) +(let t5689 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5688 (ICons t1362 (INil))))) +(let t5690 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5673 (ICons t5673 (INil))))) +(let t5691 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 256) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5690 (INil)))) +(let t5692 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5691 (ICons t3050 (INil))))) +(let t5693 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5692 (ICons t3051 (INil))))) +(let t5694 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5693 (INil)))) +(let t5695 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5694 (INil)))) +(let t5696 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5695 (ICons t5673 (INil))))) +(let t5697 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t3065 (ICons t5681 (INil))))) +(let t5698 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5681 (ICons t3070 (INil))))) +(let t5699 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5697 (ICons t3071 (INil))))) +(let t5700 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5699 (ICons t3072 (INil))))) +(let t5701 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5698 (ICons t5700 (INil))))) +(let t5702 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5697 (ICons t3070 (INil))))) +(let t5703 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5681 (ICons t3071 (INil))))) +(let t5704 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5702 (ICons t5703 (INil))))) +(let t5705 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3073 (ICons t5701 (INil))))) +(let t5706 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5705 (ICons t3075 (INil))))) +(let t5707 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3076 (ICons t5704 (INil))))) +(let t5708 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5707 (ICons t3078 (INil))))) +(let t5709 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5706 (ICons t5708 (INil))))) +(let t5710 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t3092 (ICons t5689 (INil))))) +(let t5711 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5689 (ICons t3097 (INil))))) +(let t5712 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5710 (ICons t3098 (INil))))) +(let t5713 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5712 (ICons t3099 (INil))))) +(let t5714 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5711 (ICons t5713 (INil))))) +(let t5715 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5710 (ICons t3097 (INil))))) +(let t5716 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5689 (ICons t3098 (INil))))) +(let t5717 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5715 (ICons t5716 (INil))))) +(let t5718 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3100 (ICons t5714 (INil))))) +(let t5719 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5718 (ICons t3102 (INil))))) +(let t5720 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t3103 (ICons t5717 (INil))))) +(let t5721 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5720 (ICons t3105 (INil))))) +(let t5722 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5719 (ICons t5721 (INil))))) +(let t5723 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ICons t114 (ICons t3116 (ICons t5722 (INil)))))) +(let t5724 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 4096)) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MMul (MMul (MIter) (MNum 256)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t116 (ICons t3116 (ICons t5696 (INil)))))) +(let t5725 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 256) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (MNum 256)) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))))) (ICons t5709 (ICons t5723 (INil))))) +(let t5726 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 256) (ECons (MMul (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 256)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 256)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5725 (INil)))) +(let t5727 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5726 (ICons t3134 (INil))))) +(let t5728 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5727 (INil)))) +(let t5729 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5728 (ICons t3135 (INil))))) +(let t5730 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5727 (ICons t5729 (INil))))) +(let t5731 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5730 (ICons t3136 (INil))))) +(let t5732 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5731 (INil)))) +(let t5733 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5732 (INil)))) +(let t5734 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5733 (INil)))) +(let t5735 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5732 (ICons t5734 (INil))))) +(let t5736 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 2)) (MNum 256)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 256)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t5735 (ICons t5724 (INil))))) +(let t5737 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 256)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5736 (INil)))) +(let t5738 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 256)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 256)) (MNum 256)) (MVar "s")) (MMod (MIter) (MNum 256))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t5737 (ICons t1358 (INil))))) +(let t5739 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2816)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5738 (INil)))) +(let t5740 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5739 (ICons t5739 (INil))))) +(let t5741 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5740 (INil)))) +(let t5742 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5741 (ICons t3139 (INil))))) +(let t5743 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5742 (ICons t3140 (INil))))) +(let t5744 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5743 (INil)))) +(let t5745 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5744 (INil)))) +(let t5746 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5745 (ICons t5739 (INil))))) +(let t5747 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5746 (ICons t1378 (INil))))) +(let t5748 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5659 (ICons t5747 (INil))))) +(let t5749 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5748 (ICons t5748 (INil))))) +(let t5750 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5749 (INil)))) +(let t5751 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5750 (ICons t3143 (INil))))) +(let t5752 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5751 (ICons t3144 (INil))))) +(let t5753 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5752 (INil)))) +(let t5754 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5753 (INil)))) +(let t5755 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5754 (ICons t5748 (INil))))) +(let t5756 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5755 (ICons t1380 (INil))))) +(let t5757 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5756 (ICons t1346 (INil))))) +(let t5758 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5757 (INil)))) +(let t5759 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5758 (ICons t3145 (INil))))) +(let t5760 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5758 (ICons t3146 (INil))))) +(let t5761 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5760 (ICons t5758 (INil))))) +(let t5762 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5761 (ICons t3147 (INil))))) +(let t5763 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5759 (ICons t5762 (INil))))) +(let t5764 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5763 (ICons t3148 (INil))))) +(let t5765 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5764 (ICons t3149 (INil))))) +(let t5766 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5765 (INil)))) +(let t5767 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5766 (ICons t3150 (INil))))) +(let t5768 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5767 (INil)))) +(let t5769 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5758 (ICons t5768 (INil))))) +(let t5770 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5756 (ICons t1348 (INil))))) +(let t5771 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5770 (INil)))) +(let t5772 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5769 (ICons t5771 (INil))))) +(let t5773 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t5772 (ICons t1350 (INil))))) +(let t5774 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5773 (INil)))) +(let t5775 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5774 (ICons t5774 (INil))))) +(let t5776 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5775 (INil)))) +(let t5777 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5776 (ICons t3153 (INil))))) +(let t5778 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5777 (ICons t3154 (INil))))) +(let t5779 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5778 (INil)))) +(let t5780 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5779 (INil)))) +(let t5781 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5780 (ICons t5774 (INil))))) +(let t5782 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5781 (ICons t1384 (INil))))) +(let t5783 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5748 (ICons t5748 (INil))))) +(let t5784 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5783 (INil)))) +(let t5785 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5784 (ICons t3157 (INil))))) +(let t5786 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5785 (ICons t3158 (INil))))) +(let t5787 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5786 (INil)))) +(let t5788 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5787 (INil)))) +(let t5789 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5788 (ICons t5748 (INil))))) +(let t5790 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5789 (ICons t1388 (INil))))) +(let t5791 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5748 (ICons t5748 (INil))))) +(let t5792 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5791 (INil)))) +(let t5793 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5792 (ICons t3161 (INil))))) +(let t5794 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5793 (ICons t3162 (INil))))) +(let t5795 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5794 (INil)))) +(let t5796 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5795 (INil)))) +(let t5797 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5796 (ICons t5748 (INil))))) +(let t5798 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5797 (ICons t1366 (INil))))) +(let t5799 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5798 (ICons t3163 (INil))))) +(let t5800 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5799 (ICons t1368 (INil))))) +(let t5801 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5800 (INil)))) +(let t5802 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5801 (INil)))) +(let t5803 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5802 (ICons t3164 (INil))))) +(let t5804 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5801 (ICons t5803 (INil))))) +(let t5805 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5804 (ICons t3165 (INil))))) +(let t5806 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5805 (INil)))) +(let t5807 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5806 (INil)))) +(let t5808 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5807 (INil)))) +(let t5809 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5806 (ICons t5808 (INil))))) +(let t5810 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5809 (ICons t3166 (INil))))) +(let t5811 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5809 (ICons t3167 (INil))))) +(let t5812 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5811 (ICons t5810 (INil))))) +(let t5813 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t5812 (INil)))) +(let t5814 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t5813 (ICons t3168 (INil))))) +(let t5815 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5814 (INil)))) +(let t5816 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t5815 (INil)))) +(let t5817 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5816 (ICons t3171 (INil))))) +(let t5818 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3172 (ICons t5817 (INil))))) +(let t5819 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t3170 (ICons t5818 (ICons t3169 (INil)))))) +(let t5820 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3173 (ICons t5819 (INil))))) +(let t5821 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t5820 (ICons t5809 (INil))))) +(let t5822 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5821 (INil)))) +(let t5823 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5822 (INil)))) +(let t5824 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5821 (ICons t5823 (INil))))) +(let t5825 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t5819 (ICons t1370 (INil))))) +(let t5826 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5824 (ICons t5825 (INil))))) +(let t5827 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5819 (ICons t3174 (INil))))) +(let t5828 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5827 (ICons t3175 (INil))))) +(let t5829 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5828 (ICons t1372 (INil))))) +(let t5830 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t5829 (INil)))) +(let t5831 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t5790 (ICons t5830 (INil))))) +(let t5832 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t5831 (INil)))) +(let t5833 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t3176 (ICons t5832 (INil))))) +(let t5834 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5832 (ICons t3177 (INil))))) +(let t5835 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5832 (ICons t3178 (INil))))) +(let t5836 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5835 (ICons t5832 (INil))))) +(let t5837 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5836 (ICons t3179 (INil))))) +(let t5838 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5834 (ICons t5837 (INil))))) +(let t5839 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5838 (ICons t3180 (INil))))) +(let t5840 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5839 (ICons t3181 (INil))))) +(let t5841 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5840 (INil)))) +(let t5842 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5841 (ICons t3182 (INil))))) +(let t5843 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5842 (INil)))) +(let t5844 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5832 (ICons t5843 (INil))))) +(let t5845 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5844 (ICons t5833 (INil))))) +(let t5846 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t5819 (ICons t3183 (INil))))) +(let t5847 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t5846 (ICons t3184 (INil))))) +(let t5848 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t5847 (ICons t1374 (INil))))) +(let t5849 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t5848 (INil)))) +(let t5850 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t5845 (ICons t5849 (INil))))) +(let t5851 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t5850 (INil)))) +(let t5852 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5851 (ICons t5826 (INil))))) +(let t5853 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5852 (INil)))) +(let t5854 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5853 (ICons t5853 (INil))))) +(let t5855 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5854 (INil)))) +(let t5856 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5855 (ICons t3187 (INil))))) +(let t5857 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5856 (ICons t3188 (INil))))) +(let t5858 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5857 (INil)))) +(let t5859 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5858 (INil)))) +(let t5860 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5859 (ICons t5853 (INil))))) +(let t5861 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5860 (ICons t1386 (INil))))) +(let t5862 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5782 (ICons t5861 (INil))))) +(let t5863 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5862 (ICons t5862 (INil))))) +(let t5864 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5863 (INil)))) +(let t5865 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5864 (ICons t3191 (INil))))) +(let t5866 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5865 (ICons t3192 (INil))))) +(let t5867 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5866 (INil)))) +(let t5868 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5867 (INil)))) +(let t5869 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5868 (ICons t5862 (INil))))) +(let t5870 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5869 (ICons t1382 (INil))))) +(let t5871 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5748 (ICons t5870 (INil))))) +(let t5872 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5871 (ICons t1364 (INil))))) +(let t5873 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5872 (ICons t5872 (INil))))) +(let t5874 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5873 (INil)))) +(let t5875 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5874 (ICons t3195 (INil))))) +(let t5876 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5875 (ICons t3196 (INil))))) +(let t5877 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5876 (INil)))) +(let t5878 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5877 (INil)))) +(let t5879 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5878 (ICons t5872 (INil))))) +(let t5880 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5879 (ICons t1418 (INil))))) +(let t5881 (Op (Mul (ECons (MVar "s") (ECons (MNum 8192) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8192)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5880 (ICons t1396 (INil))))) +(let t5882 (Op (Sum (ECons (MVar "s") (ECons (MNum 8192) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8192)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil)))) (ICons t5881 (INil)))) +(let t5883 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5880 (ICons t1398 (INil))))) +(let t5884 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t5883 (INil)))) +(let t5885 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5882 (ICons t5882 (INil))))) +(let t5886 (Op (Sum (ECons (MVar "s") (ECons (MNum 16) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5885 (INil)))) +(let t5887 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5886 (ICons t3199 (INil))))) +(let t5888 (Op (Add (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5887 (ICons t3200 (INil))))) +(let t5889 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5888 (INil)))) +(let t5890 (Op (Recip (ECons (MVar "s") (ECons (MNum 16) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ENil)))) (ICons t5889 (INil)))) +(let t5891 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 16)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 8192)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5890 (ICons t5882 (INil))))) +(let t5892 (Op (Mul (ECons (MVar "s") (ECons (MNum 16) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5891 (ICons t1402 (INil))))) +(let t5893 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5884 (ICons t5884 (INil))))) +(let t5894 (Op (Sum (ECons (MVar "s") (ECons (MNum 2) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5893 (INil)))) +(let t5895 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5894 (ICons t3203 (INil))))) +(let t5896 (Op (Add (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5895 (ICons t3204 (INil))))) +(let t5897 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5896 (INil)))) +(let t5898 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5897 (INil)))) +(let t5899 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5898 (ICons t5884 (INil))))) +(let t5900 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5899 (ICons t1404 (INil))))) +(let t5901 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5884 (ICons t5884 (INil))))) +(let t5902 (Op (Sum (ECons (MVar "s") (ECons (MNum 2) (ENil))) (MNum 512) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5901 (INil)))) +(let t5903 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5902 (ICons t3207 (INil))))) +(let t5904 (Op (Add (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5903 (ICons t3208 (INil))))) +(let t5905 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5904 (INil)))) +(let t5906 (Op (Recip (ECons (MVar "s") (ECons (MNum 2) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ENil)))) (ICons t5905 (INil)))) +(let t5907 (Op (Mul (ECons (MVar "s") (ECons (MNum 2) (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 2)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5906 (ICons t5884 (INil))))) +(let t5908 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil))))) (ICons t3237 (ICons t5892 (INil))))) +(let t5909 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5892 (ICons t3242 (INil))))) +(let t5910 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5908 (ICons t3243 (INil))))) +(let t5911 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5910 (ICons t3244 (INil))))) +(let t5912 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5909 (ICons t5911 (INil))))) +(let t5913 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5908 (ICons t3242 (INil))))) +(let t5914 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 16)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5892 (ICons t3243 (INil))))) +(let t5915 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5913 (ICons t5914 (INil))))) +(let t5916 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3245 (ICons t5912 (INil))))) +(let t5917 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5916 (ICons t3247 (INil))))) +(let t5918 (Op (Gather (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3248 (ICons t5915 (INil))))) +(let t5919 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5918 (ICons t3250 (INil))))) +(let t5920 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5917 (ICons t5919 (INil))))) +(let t5921 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil))))) (ICons t3279 (ICons t5900 (INil))))) +(let t5922 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5900 (ICons t3284 (INil))))) +(let t5923 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5921 (ICons t3285 (INil))))) +(let t5924 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5923 (ICons t3286 (INil))))) +(let t5925 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5922 (ICons t5924 (INil))))) +(let t5926 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5921 (ICons t3284 (INil))))) +(let t5927 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5900 (ICons t3285 (INil))))) +(let t5928 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t5926 (ICons t5927 (INil))))) +(let t5929 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3287 (ICons t5925 (INil))))) +(let t5930 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5929 (ICons t3289 (INil))))) +(let t5931 (Op (Gather (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 256) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 256)) (MVar "s")) (ECons (MMul (MIter) (MNum 256)) (ECons (MIter) (ENil))))) (ICons t3290 (ICons t5928 (INil))))) +(let t5932 (Op (Mul (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5931 (ICons t3292 (INil))))) +(let t5933 (Op (Add (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5930 (ICons t5932 (INil))))) +(let t5934 (Op (Scatter (ECons (MNum 2) (ECons (MNum 4096) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 4096)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (MNum 512)) (ECons (MMul (MIter) (MNum 512)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil))))) (ICons t118 (ICons t3303 (ICons t5933 (INil)))))) +(let t5935 (Op (Scatter (ECons (MNum 2) (ECons (MNum 4096) (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 4096)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MNum 2) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MMul (MIter) (MNum 512)) (MNum 2)) (ECons (MIter) (ENil))))) (ICons t120 (ICons t3303 (ICons t5907 (INil)))))) +(let t5936 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 512) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (MNum 512)) (ECons (MMul (MIter) (MNum 512)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 512)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))))) (ICons t5920 (ICons t5934 (INil))))) +(let t5937 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 512) (ECons (MMul (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 512)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 512)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5936 (INil)))) +(let t5938 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5937 (ICons t3314 (INil))))) +(let t5939 (Op (Max (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5938 (INil)))) +(let t5940 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5939 (ICons t3315 (INil))))) +(let t5941 (Op (Add (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5938 (ICons t5940 (INil))))) +(let t5942 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5941 (ICons t3316 (INil))))) +(let t5943 (Op (Exp2 (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5942 (INil)))) +(let t5944 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t5943 (INil)))) +(let t5945 (Op (Recip (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5944 (INil)))) +(let t5946 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t5943 (ICons t5945 (INil))))) +(let t5947 (Op (Mul (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 512)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 512)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t5946 (ICons t5935 (INil))))) +(let t5948 (Op (Sum (ECons (MNum 16) (ECons (MVar "s") (ECons (MNum 512) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 512)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 512)) (MVar "s")) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t5947 (INil)))) +(let t5949 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 8192) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 512)) (MNum 512)) (MVar "s")) (MMod (MIter) (MNum 512))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 8192)) (MNum 2816)) (ECons (MMul (MIter) (MNum 8192)) (ECons (MIter) (ENil))))) (ICons t5948 (ICons t1400 (INil))))) +(let t5950 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8192) (ECons (MMul (MMul (MIter) (MNum 8192)) (MNum 2816)) (ECons (MMul (MIter) (MNum 8192)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5949 (INil)))) +(let t5951 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5950 (ICons t5950 (INil))))) +(let t5952 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5951 (INil)))) +(let t5953 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5952 (ICons t3319 (INil))))) +(let t5954 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5953 (ICons t3320 (INil))))) +(let t5955 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5954 (INil)))) +(let t5956 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5955 (INil)))) +(let t5957 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5956 (ICons t5950 (INil))))) +(let t5958 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5957 (ICons t1420 (INil))))) +(let t5959 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5872 (ICons t5958 (INil))))) +(let t5960 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5959 (ICons t5959 (INil))))) +(let t5961 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5960 (INil)))) +(let t5962 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5961 (ICons t3323 (INil))))) +(let t5963 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5962 (ICons t3324 (INil))))) +(let t5964 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5963 (INil)))) +(let t5965 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5964 (INil)))) +(let t5966 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5965 (ICons t5959 (INil))))) +(let t5967 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5966 (ICons t1422 (INil))))) +(let t5968 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5967 (ICons t1390 (INil))))) +(let t5969 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5968 (INil)))) +(let t5970 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5969 (ICons t3325 (INil))))) +(let t5971 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5969 (ICons t3326 (INil))))) +(let t5972 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5971 (ICons t5969 (INil))))) +(let t5973 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5972 (ICons t3327 (INil))))) +(let t5974 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5970 (ICons t5973 (INil))))) +(let t5975 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5974 (ICons t3328 (INil))))) +(let t5976 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5975 (ICons t3329 (INil))))) +(let t5977 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5976 (INil)))) +(let t5978 (Op (Add (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5977 (ICons t3330 (INil))))) +(let t5979 (Op (Recip (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5978 (INil)))) +(let t5980 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5969 (ICons t5979 (INil))))) +(let t5981 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t5967 (ICons t1392 (INil))))) +(let t5982 (Op (Sum (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 2112)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5981 (INil)))) +(let t5983 (Op (Mul (ECons (MVar "s") (ECons (MNum 2112) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ICons t5980 (ICons t5982 (INil))))) +(let t5984 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ECons (MNum 2112) (ENil)))) (ECons (MMul (MIter) (MNum 2112)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ECons (MIter) (ENil))))) (ICons t5983 (ICons t1394 (INil))))) +(let t5985 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 2112) (ECons (MMul (MMul (MIter) (MNum 2112)) (MNum 2816)) (ECons (MMul (MIter) (MNum 2112)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5984 (INil)))) +(let t5986 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5985 (ICons t5985 (INil))))) +(let t5987 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5986 (INil)))) +(let t5988 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5987 (ICons t3333 (INil))))) +(let t5989 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5988 (ICons t3334 (INil))))) +(let t5990 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5989 (INil)))) +(let t5991 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5990 (INil)))) +(let t5992 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5991 (ICons t5985 (INil))))) +(let t5993 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5992 (ICons t1426 (INil))))) +(let t5994 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5959 (ICons t5959 (INil))))) +(let t5995 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t5994 (INil)))) +(let t5996 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5995 (ICons t3337 (INil))))) +(let t5997 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t5996 (ICons t3338 (INil))))) +(let t5998 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5997 (INil)))) +(let t5999 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t5998 (INil)))) +(let t6000 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5999 (ICons t5959 (INil))))) +(let t6001 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6000 (ICons t1430 (INil))))) +(let t6002 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5959 (ICons t5959 (INil))))) +(let t6003 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6002 (INil)))) +(let t6004 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6003 (ICons t3341 (INil))))) +(let t6005 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t6004 (ICons t3342 (INil))))) +(let t6006 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6005 (INil)))) +(let t6007 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6006 (INil)))) +(let t6008 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6007 (ICons t5959 (INil))))) +(let t6009 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6008 (ICons t1408 (INil))))) +(let t6010 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6009 (ICons t3343 (INil))))) +(let t6011 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t6010 (ICons t1410 (INil))))) +(let t6012 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 128)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6011 (INil)))) +(let t6013 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6012 (INil)))) +(let t6014 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6013 (ICons t3344 (INil))))) +(let t6015 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6012 (ICons t6014 (INil))))) +(let t6016 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6015 (ICons t3345 (INil))))) +(let t6017 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6016 (INil)))) +(let t6018 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6017 (INil)))) +(let t6019 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6018 (INil)))) +(let t6020 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6017 (ICons t6019 (INil))))) +(let t6021 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t6020 (ICons t3346 (INil))))) +(let t6022 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t6020 (ICons t3347 (INil))))) +(let t6023 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t6022 (ICons t6021 (INil))))) +(let t6024 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t6023 (INil)))) +(let t6025 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t6024 (ICons t3348 (INil))))) +(let t6026 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6025 (INil)))) +(let t6027 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t6026 (INil)))) +(let t6028 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6027 (ICons t3351 (INil))))) +(let t6029 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t3352 (ICons t6028 (INil))))) +(let t6030 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t3350 (ICons t6029 (ICons t3349 (INil)))))) +(let t6031 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t3353 (ICons t6030 (INil))))) +(let t6032 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t6031 (ICons t6020 (INil))))) +(let t6033 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 8) (ECons (MMul (MIter) (MNum 8)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6032 (INil)))) +(let t6034 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t6033 (INil)))) +(let t6035 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t6032 (ICons t6034 (INil))))) +(let t6036 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 128) (ENil)) (ECons (MIter) (ENil))) (ICons t6030 (ICons t1412 (INil))))) +(let t6037 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t6035 (ICons t6036 (INil))))) +(let t6038 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t6030 (ICons t3354 (INil))))) +(let t6039 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t6038 (ICons t3355 (INil))))) +(let t6040 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ECons (MNum 2816) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t6039 (ICons t1414 (INil))))) +(let t6041 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1408)) (MNum 2816)) (MNum 1)) (F32)) (ICons t6040 (INil)))) +(let t6042 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ECons (MNum 2816) (ENil)))))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))))) (ICons t6001 (ICons t6041 (INil))))) +(let t6043 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1408) (ENil))))) (MNum 2816) (ECons (MMul (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 1408)) (ECons (MMul (MIter) (MNum 2816)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))))) (ICons t6042 (INil)))) +(let t6044 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1408) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil))))) (ICons t3356 (ICons t6043 (INil))))) +(let t6045 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6043 (ICons t3357 (INil))))) +(let t6046 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6043 (ICons t3358 (INil))))) +(let t6047 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6046 (ICons t6043 (INil))))) +(let t6048 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6047 (ICons t3359 (INil))))) +(let t6049 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6045 (ICons t6048 (INil))))) +(let t6050 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6049 (ICons t3360 (INil))))) +(let t6051 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6050 (ICons t3361 (INil))))) +(let t6052 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6051 (INil)))) +(let t6053 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6052 (ICons t3362 (INil))))) +(let t6054 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6053 (INil)))) +(let t6055 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1408)) (MNum 8)) (ECons (MMul (MIter) (MNum 1408)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6043 (ICons t6054 (INil))))) +(let t6056 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6055 (ICons t6044 (INil))))) +(let t6057 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t6030 (ICons t3363 (INil))))) +(let t6058 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ICons t6057 (ICons t3364 (INil))))) +(let t6059 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ECons (MNum 704) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))) (ICons t6058 (ICons t1416 (INil))))) +(let t6060 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2816)) (MNum 704)) (MNum 1)) (F32)) (ICons t6059 (INil)))) +(let t6061 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ECons (MNum 704) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 8)) (ECons (MMul (MIter) (MNum 704)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ECons (MIter) (ENil))))))) (ICons t6056 (ICons t6060 (INil))))) +(let t6062 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2816) (ENil))))) (MNum 704) (ECons (MMul (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MMul (MIter) (MNum 704)) (MNum 2816)) (ECons (MMul (MIter) (MNum 704)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))))) (ICons t6061 (INil)))) +(let t6063 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t6062 (ICons t6037 (INil))))) +(let t6064 (Op (Sum (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2816)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6063 (INil)))) +(let t6065 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6064 (ICons t6064 (INil))))) +(let t6066 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6065 (INil)))) +(let t6067 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6066 (ICons t3367 (INil))))) +(let t6068 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t6067 (ICons t3368 (INil))))) +(let t6069 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6068 (INil)))) +(let t6070 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6069 (INil)))) +(let t6071 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6070 (ICons t6064 (INil))))) +(let t6072 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6071 (ICons t1428 (INil))))) +(let t6073 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5993 (ICons t6072 (INil))))) +(let t6074 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6073 (ICons t6073 (INil))))) +(let t6075 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6074 (INil)))) +(let t6076 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6075 (ICons t3371 (INil))))) +(let t6077 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t6076 (ICons t3372 (INil))))) +(let t6078 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6077 (INil)))) +(let t6079 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6078 (INil)))) +(let t6080 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6079 (ICons t6073 (INil))))) +(let t6081 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6080 (ICons t1424 (INil))))) +(let t6082 (Op (Add (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t5959 (ICons t6081 (INil))))) +(let t6083 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6082 (ICons t1406 (INil))))) +(let t6084 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6083 (ICons t6083 (INil))))) +(let t6085 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2816) (ECons (MMul (MIter) (MNum 2816)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t6084 (INil)))) +(let t6086 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6085 (ICons t3375 (INil))))) +(let t6087 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t6086 (ICons t3376 (INil))))) +(let t6088 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6087 (INil)))) +(let t6089 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t6088 (INil)))) +(let t6090 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6089 (ICons t6083 (INil))))) +(let t6091 (Op (Mul (ECons (MVar "s") (ECons (MNum 2816) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ICons t6090 (ICons t1436 (INil))))) +(let t6092 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ECons (MNum 2816) (ENil)))) (ECons (MMul (MIter) (MNum 2816)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 262144)) (ECons (MMul (MIter) (MNum 2816)) (ECons (MIter) (ENil))))) (ICons t6091 (ICons t1434 (INil))))) +(let t6093 (Op (Sum (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (MNum 2816) (ECons (MMul (MMul (MIter) (MNum 2816)) (MNum 262144)) (ECons (MMul (MIter) (MNum 2816)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6092 (INil)))) +(let t6094 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6093 (ICons t3377 (INil))))) +(let t6095 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6094 (ICons t3378 (INil))))) +(let t6096 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6095 (ICons t3379 (INil))))) +(let t6097 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6096 (ICons t3380 (INil))))) +(let t6098 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6097 (INil)))) +(let t6099 (Op (Add (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6098 (ICons t3381 (INil))))) +(let t6100 (Op (Recip (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6099 (INil)))) +(let t6101 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6100 (ICons t3382 (INil))))) +(let t6102 (Op (Add (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6101 (ICons t3385 (INil))))) +(let t6103 (Op (Mul (ECons (MVar "s") (ECons (MNum 262144) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 262144)) (ECons (MIter) (ENil)))) (ICons t6102 (ICons t3386 (INil))))) +(let t6104 (Output t6103 12681)) +(let t6105 (Output t4871 10551)) +(let t6106 (Output t4872 10552)) +(let t6107 (Output t5084 10921)) +(let t6108 (Output t5085 10922)) +(let t6109 (Output t5297 11291)) +(let t6110 (Output t5298 11292)) +(let t6111 (Output t5510 11661)) +(let t6112 (Output t5511 11662)) +(let t6113 (Output t5723 12031)) +(let t6114 (Output t5724 12032)) +(let t6115 (Output t5934 12429)) +(let t6116 (Output t5935 12430)) +(let t6117 (Op (LoopOutput 0 0 (F32)) (ICons t3458 (INil)))) +(let t6118 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t6117 (INil)))) +(let t6119 (Output t6118 1587)) +(let t6120 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t6117 (INil)))) +(let t6121 (Output t6120 3828)) +(let t6122 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t6117 (INil)))) +(let t6123 (Output t6122 6069)) +(let t6124 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t6117 (INil)))) +(let t6125 (Output t6124 8310)) +(let t6126 (Op (LoopOutput 0 1 (F32)) (ICons t3471 (INil)))) +(let t6127 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t6126 (INil)))) +(let t6128 (Output t6127 1588)) +(let t6129 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t6126 (INil)))) +(let t6130 (Output t6129 3829)) +(let t6131 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t6126 (INil)))) +(let t6132 (Output t6131 6070)) +(let t6133 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t6126 (INil)))) +(let t6134 (Output t6133 8311)) +(let t6135 (Op (LoopOutput 0 2 (Int)) (ICons t3695 (INil)))) +(let t6136 (Op (LoopOutputSelect 0 2 0 (Int)) (ICons t6135 (INil)))) +(let t6137 (Output t6136 1957)) +(let t6138 (Op (LoopOutputSelect 0 2 1 (Int)) (ICons t6135 (INil)))) +(let t6139 (Output t6138 4198)) +(let t6140 (Op (LoopOutputSelect 0 2 2 (Int)) (ICons t6135 (INil)))) +(let t6141 (Output t6140 6439)) +(let t6142 (Op (LoopOutputSelect 0 2 3 (Int)) (ICons t6135 (INil)))) +(let t6143 (Output t6142 8680)) +(let t6144 (Op (LoopOutput 0 3 (Int)) (ICons t3708 (INil)))) +(let t6145 (Op (LoopOutputSelect 0 3 0 (Int)) (ICons t6144 (INil)))) +(let t6146 (Output t6145 1958)) +(let t6147 (Op (LoopOutputSelect 0 3 1 (Int)) (ICons t6144 (INil)))) +(let t6148 (Output t6147 4199)) +(let t6149 (Op (LoopOutputSelect 0 3 2 (Int)) (ICons t6144 (INil)))) +(let t6150 (Output t6149 6440)) +(let t6151 (Op (LoopOutputSelect 0 3 3 (Int)) (ICons t6144 (INil)))) +(let t6152 (Output t6151 8681)) +(let t6153 (Op (LoopOutput 0 4 (Int)) (ICons t3932 (INil)))) +(let t6154 (Op (LoopOutputSelect 0 4 0 (Int)) (ICons t6153 (INil)))) +(let t6155 (Output t6154 2327)) +(let t6156 (Op (LoopOutputSelect 0 4 1 (Int)) (ICons t6153 (INil)))) +(let t6157 (Output t6156 4568)) +(let t6158 (Op (LoopOutputSelect 0 4 2 (Int)) (ICons t6153 (INil)))) +(let t6159 (Output t6158 6809)) +(let t6160 (Op (LoopOutputSelect 0 4 3 (Int)) (ICons t6153 (INil)))) +(let t6161 (Output t6160 9050)) +(let t6162 (Op (LoopOutput 0 5 (Int)) (ICons t3945 (INil)))) +(let t6163 (Op (LoopOutputSelect 0 5 0 (Int)) (ICons t6162 (INil)))) +(let t6164 (Output t6163 2328)) +(let t6165 (Op (LoopOutputSelect 0 5 1 (Int)) (ICons t6162 (INil)))) +(let t6166 (Output t6165 4569)) +(let t6167 (Op (LoopOutputSelect 0 5 2 (Int)) (ICons t6162 (INil)))) +(let t6168 (Output t6167 6810)) +(let t6169 (Op (LoopOutputSelect 0 5 3 (Int)) (ICons t6162 (INil)))) +(let t6170 (Output t6169 9051)) +(let t6171 (Op (LoopOutput 0 6 (Int)) (ICons t4169 (INil)))) +(let t6172 (Op (LoopOutputSelect 0 6 0 (Int)) (ICons t6171 (INil)))) +(let t6173 (Output t6172 2697)) +(let t6174 (Op (LoopOutputSelect 0 6 1 (Int)) (ICons t6171 (INil)))) +(let t6175 (Output t6174 4938)) +(let t6176 (Op (LoopOutputSelect 0 6 2 (Int)) (ICons t6171 (INil)))) +(let t6177 (Output t6176 7179)) +(let t6178 (Op (LoopOutputSelect 0 6 3 (Int)) (ICons t6171 (INil)))) +(let t6179 (Output t6178 9420)) +(let t6180 (Op (LoopOutput 0 7 (Int)) (ICons t4182 (INil)))) +(let t6181 (Op (LoopOutputSelect 0 7 0 (Int)) (ICons t6180 (INil)))) +(let t6182 (Output t6181 2698)) +(let t6183 (Op (LoopOutputSelect 0 7 1 (Int)) (ICons t6180 (INil)))) +(let t6184 (Output t6183 4939)) +(let t6185 (Op (LoopOutputSelect 0 7 2 (Int)) (ICons t6180 (INil)))) +(let t6186 (Output t6185 7180)) +(let t6187 (Op (LoopOutputSelect 0 7 3 (Int)) (ICons t6180 (INil)))) +(let t6188 (Output t6187 9421)) +(let t6189 (Op (LoopOutput 0 8 (Int)) (ICons t4406 (INil)))) +(let t6190 (Op (LoopOutputSelect 0 8 0 (Int)) (ICons t6189 (INil)))) +(let t6191 (Output t6190 3067)) +(let t6192 (Op (LoopOutputSelect 0 8 1 (Int)) (ICons t6189 (INil)))) +(let t6193 (Output t6192 5308)) +(let t6194 (Op (LoopOutputSelect 0 8 2 (Int)) (ICons t6189 (INil)))) +(let t6195 (Output t6194 7549)) +(let t6196 (Op (LoopOutputSelect 0 8 3 (Int)) (ICons t6189 (INil)))) +(let t6197 (Output t6196 9790)) +(let t6198 (Op (LoopOutput 0 9 (Int)) (ICons t4419 (INil)))) +(let t6199 (Op (LoopOutputSelect 0 9 0 (Int)) (ICons t6198 (INil)))) +(let t6200 (Output t6199 3068)) +(let t6201 (Op (LoopOutputSelect 0 9 1 (Int)) (ICons t6198 (INil)))) +(let t6202 (Output t6201 5309)) +(let t6203 (Op (LoopOutputSelect 0 9 2 (Int)) (ICons t6198 (INil)))) +(let t6204 (Output t6203 7550)) +(let t6205 (Op (LoopOutputSelect 0 9 3 (Int)) (ICons t6198 (INil)))) +(let t6206 (Output t6205 9791)) +(let t6207 (Op (LoopOutput 0 10 (Int)) (ICons t4640 (INil)))) +(let t6208 (Op (LoopOutputSelect 0 10 0 (Int)) (ICons t6207 (INil)))) +(let t6209 (Output t6208 3465)) +(let t6210 (Op (LoopOutputSelect 0 10 1 (Int)) (ICons t6207 (INil)))) +(let t6211 (Output t6210 5706)) +(let t6212 (Op (LoopOutputSelect 0 10 2 (Int)) (ICons t6207 (INil)))) +(let t6213 (Output t6212 7947)) +(let t6214 (Op (LoopOutputSelect 0 10 3 (Int)) (ICons t6207 (INil)))) +(let t6215 (Output t6214 10188)) +(let t6216 (Op (LoopOutput 0 11 (Int)) (ICons t4653 (INil)))) +(let t6217 (Op (LoopOutputSelect 0 11 0 (Int)) (ICons t6216 (INil)))) +(let t6218 (Output t6217 3466)) +(let t6219 (Op (LoopOutputSelect 0 11 1 (Int)) (ICons t6216 (INil)))) +(let t6220 (Output t6219 5707)) +(let t6221 (Op (LoopOutputSelect 0 11 2 (Int)) (ICons t6216 (INil)))) +(let t6222 (Output t6221 7948)) +(let t6223 (Op (LoopOutputSelect 0 11 3 (Int)) (ICons t6216 (INil)))) +(let t6224 (Output t6223 10189)) +(let t6226 (OutputJoin t3 t5)) +(let t6227 (OutputJoin t6226 t7)) +(let t6228 (OutputJoin t6227 t9)) +(let t6229 (OutputJoin t6228 t11)) +(let t6230 (OutputJoin t6229 t13)) +(let t6231 (OutputJoin t6230 t15)) +(let t6232 (OutputJoin t6231 t17)) +(let t6233 (OutputJoin t6232 t19)) +(let t6234 (OutputJoin t6233 t21)) +(let t6235 (OutputJoin t6234 t23)) +(let t6236 (OutputJoin t6235 t25)) +(let t6237 (OutputJoin t6236 t27)) +(let t6238 (OutputJoin t6237 t29)) +(let t6239 (OutputJoin t6238 t31)) +(let t6240 (OutputJoin t6239 t33)) +(let t6241 (OutputJoin t6240 t35)) +(let t6242 (OutputJoin t6241 t37)) +(let t6243 (OutputJoin t6242 t39)) +(let t6244 (OutputJoin t6243 t41)) +(let t6245 (OutputJoin t6244 t43)) +(let t6246 (OutputJoin t6245 t45)) +(let t6247 (OutputJoin t6246 t47)) +(let t6248 (OutputJoin t6247 t49)) +(let t6249 (OutputJoin t6248 t51)) +(let t6250 (OutputJoin t6249 t53)) +(let t6251 (OutputJoin t6250 t55)) +(let t6252 (OutputJoin t6251 t57)) +(let t6253 (OutputJoin t6252 t59)) +(let t6254 (OutputJoin t6253 t61)) +(let t6255 (OutputJoin t6254 t63)) +(let t6256 (OutputJoin t6255 t65)) +(let t6257 (OutputJoin t6256 t67)) +(let t6258 (OutputJoin t6257 t69)) +(let t6259 (OutputJoin t6258 t71)) +(let t6260 (OutputJoin t6259 t73)) +(let t6261 (OutputJoin t6260 t75)) +(let t6262 (OutputJoin t6261 t77)) +(let t6263 (OutputJoin t6262 t79)) +(let t6264 (OutputJoin t6263 t81)) +(let t6265 (OutputJoin t6264 t83)) +(let t6266 (OutputJoin t6265 t85)) +(let t6267 (OutputJoin t6266 t87)) +(let t6268 (OutputJoin t6267 t89)) +(let t6269 (OutputJoin t6268 t91)) +(let t6270 (OutputJoin t6269 t93)) +(let t6271 (OutputJoin t6270 t95)) +(let t6272 (OutputJoin t6271 t97)) +(let t6273 (OutputJoin t6272 t99)) +(let t6274 (OutputJoin t6273 t101)) +(let t6275 (OutputJoin t6274 t103)) +(let t6276 (OutputJoin t6275 t105)) +(let t6277 (OutputJoin t6276 t107)) +(let t6278 (OutputJoin t6277 t109)) +(let t6279 (OutputJoin t6278 t111)) +(let t6280 (OutputJoin t6279 t113)) +(let t6281 (OutputJoin t6280 t115)) +(let t6282 (OutputJoin t6281 t117)) +(let t6283 (OutputJoin t6282 t119)) +(let t6284 (OutputJoin t6283 t121)) +(let t6285 (OutputJoin t6284 t123)) +(let t6286 (OutputJoin t6285 t125)) +(let t6287 (OutputJoin t6286 t127)) +(let t6288 (OutputJoin t6287 t129)) +(let t6289 (OutputJoin t6288 t131)) +(let t6290 (OutputJoin t6289 t133)) +(let t6291 (OutputJoin t6290 t135)) +(let t6292 (OutputJoin t6291 t137)) +(let t6293 (OutputJoin t6292 t139)) +(let t6294 (OutputJoin t6293 t141)) +(let t6295 (OutputJoin t6294 t143)) +(let t6296 (OutputJoin t6295 t145)) +(let t6297 (OutputJoin t6296 t147)) +(let t6298 (OutputJoin t6297 t149)) +(let t6299 (OutputJoin t6298 t151)) +(let t6300 (OutputJoin t6299 t153)) +(let t6301 (OutputJoin t6300 t155)) +(let t6302 (OutputJoin t6301 t157)) +(let t6303 (OutputJoin t6302 t159)) +(let t6304 (OutputJoin t6303 t161)) +(let t6305 (OutputJoin t6304 t163)) +(let t6306 (OutputJoin t6305 t165)) +(let t6307 (OutputJoin t6306 t167)) +(let t6308 (OutputJoin t6307 t169)) +(let t6309 (OutputJoin t6308 t171)) +(let t6310 (OutputJoin t6309 t173)) +(let t6311 (OutputJoin t6310 t175)) +(let t6312 (OutputJoin t6311 t177)) +(let t6313 (OutputJoin t6312 t179)) +(let t6314 (OutputJoin t6313 t181)) +(let t6315 (OutputJoin t6314 t183)) +(let t6316 (OutputJoin t6315 t185)) +(let t6317 (OutputJoin t6316 t187)) +(let t6318 (OutputJoin t6317 t189)) +(let t6319 (OutputJoin t6318 t191)) +(let t6320 (OutputJoin t6319 t193)) +(let t6321 (OutputJoin t6320 t195)) +(let t6322 (OutputJoin t6321 t197)) +(let t6323 (OutputJoin t6322 t199)) +(let t6324 (OutputJoin t6323 t201)) +(let t6325 (OutputJoin t6324 t203)) +(let t6326 (OutputJoin t6325 t205)) +(let t6327 (OutputJoin t6326 t207)) +(let t6328 (OutputJoin t6327 t209)) +(let t6329 (OutputJoin t6328 t211)) +(let t6330 (OutputJoin t6329 t213)) +(let t6331 (OutputJoin t6330 t215)) +(let t6332 (OutputJoin t6331 t217)) +(let t6333 (OutputJoin t6332 t219)) +(let t6334 (OutputJoin t6333 t221)) +(let t6335 (OutputJoin t6334 t223)) +(let t6336 (OutputJoin t6335 t225)) +(let t6337 (OutputJoin t6336 t227)) +(let t6338 (OutputJoin t6337 t229)) +(let t6339 (OutputJoin t6338 t231)) +(let t6340 (OutputJoin t6339 t233)) +(let t6341 (OutputJoin t6340 t235)) +(let t6342 (OutputJoin t6341 t237)) +(let t6343 (OutputJoin t6342 t239)) +(let t6344 (OutputJoin t6343 t241)) +(let t6345 (OutputJoin t6344 t243)) +(let t6346 (OutputJoin t6345 t245)) +(let t6347 (OutputJoin t6346 t247)) +(let t6348 (OutputJoin t6347 t249)) +(let t6349 (OutputJoin t6348 t251)) +(let t6350 (OutputJoin t6349 t253)) +(let t6351 (OutputJoin t6350 t255)) +(let t6352 (OutputJoin t6351 t257)) +(let t6353 (OutputJoin t6352 t259)) +(let t6354 (OutputJoin t6353 t261)) +(let t6355 (OutputJoin t6354 t263)) +(let t6356 (OutputJoin t6355 t265)) +(let t6357 (OutputJoin t6356 t267)) +(let t6358 (OutputJoin t6357 t269)) +(let t6359 (OutputJoin t6358 t271)) +(let t6360 (OutputJoin t6359 t273)) +(let t6361 (OutputJoin t6360 t275)) +(let t6362 (OutputJoin t6361 t277)) +(let t6363 (OutputJoin t6362 t279)) +(let t6364 (OutputJoin t6363 t281)) +(let t6365 (OutputJoin t6364 t283)) +(let t6366 (OutputJoin t6365 t285)) +(let t6367 (OutputJoin t6366 t287)) +(let t6368 (OutputJoin t6367 t289)) +(let t6369 (OutputJoin t6368 t291)) +(let t6370 (OutputJoin t6369 t293)) +(let t6371 (OutputJoin t6370 t295)) +(let t6372 (OutputJoin t6371 t297)) +(let t6373 (OutputJoin t6372 t299)) +(let t6374 (OutputJoin t6373 t301)) +(let t6375 (OutputJoin t6374 t303)) +(let t6376 (OutputJoin t6375 t305)) +(let t6377 (OutputJoin t6376 t307)) +(let t6378 (OutputJoin t6377 t309)) +(let t6379 (OutputJoin t6378 t311)) +(let t6380 (OutputJoin t6379 t313)) +(let t6381 (OutputJoin t6380 t315)) +(let t6382 (OutputJoin t6381 t317)) +(let t6383 (OutputJoin t6382 t319)) +(let t6384 (OutputJoin t6383 t321)) +(let t6385 (OutputJoin t6384 t323)) +(let t6386 (OutputJoin t6385 t325)) +(let t6387 (OutputJoin t6386 t327)) +(let t6388 (OutputJoin t6387 t329)) +(let t6389 (OutputJoin t6388 t331)) +(let t6390 (OutputJoin t6389 t333)) +(let t6391 (OutputJoin t6390 t335)) +(let t6392 (OutputJoin t6391 t337)) +(let t6393 (OutputJoin t6392 t339)) +(let t6394 (OutputJoin t6393 t341)) +(let t6395 (OutputJoin t6394 t343)) +(let t6396 (OutputJoin t6395 t345)) +(let t6397 (OutputJoin t6396 t347)) +(let t6398 (OutputJoin t6397 t349)) +(let t6399 (OutputJoin t6398 t351)) +(let t6400 (OutputJoin t6399 t353)) +(let t6401 (OutputJoin t6400 t355)) +(let t6402 (OutputJoin t6401 t357)) +(let t6403 (OutputJoin t6402 t359)) +(let t6404 (OutputJoin t6403 t361)) +(let t6405 (OutputJoin t6404 t363)) +(let t6406 (OutputJoin t6405 t365)) +(let t6407 (OutputJoin t6406 t367)) +(let t6408 (OutputJoin t6407 t369)) +(let t6409 (OutputJoin t6408 t371)) +(let t6410 (OutputJoin t6409 t373)) +(let t6411 (OutputJoin t6410 t375)) +(let t6412 (OutputJoin t6411 t377)) +(let t6413 (OutputJoin t6412 t379)) +(let t6414 (OutputJoin t6413 t381)) +(let t6415 (OutputJoin t6414 t383)) +(let t6416 (OutputJoin t6415 t385)) +(let t6417 (OutputJoin t6416 t387)) +(let t6418 (OutputJoin t6417 t389)) +(let t6419 (OutputJoin t6418 t391)) +(let t6420 (OutputJoin t6419 t393)) +(let t6421 (OutputJoin t6420 t395)) +(let t6422 (OutputJoin t6421 t397)) +(let t6423 (OutputJoin t6422 t399)) +(let t6424 (OutputJoin t6423 t401)) +(let t6425 (OutputJoin t6424 t403)) +(let t6426 (OutputJoin t6425 t405)) +(let t6427 (OutputJoin t6426 t407)) +(let t6428 (OutputJoin t6427 t409)) +(let t6429 (OutputJoin t6428 t411)) +(let t6430 (OutputJoin t6429 t413)) +(let t6431 (OutputJoin t6430 t415)) +(let t6432 (OutputJoin t6431 t417)) +(let t6433 (OutputJoin t6432 t419)) +(let t6434 (OutputJoin t6433 t421)) +(let t6435 (OutputJoin t6434 t423)) +(let t6436 (OutputJoin t6435 t425)) +(let t6437 (OutputJoin t6436 t427)) +(let t6438 (OutputJoin t6437 t429)) +(let t6439 (OutputJoin t6438 t431)) +(let t6440 (OutputJoin t6439 t433)) +(let t6441 (OutputJoin t6440 t435)) +(let t6442 (OutputJoin t6441 t437)) +(let t6443 (OutputJoin t6442 t439)) +(let t6444 (OutputJoin t6443 t441)) +(let t6445 (OutputJoin t6444 t443)) +(let t6446 (OutputJoin t6445 t445)) +(let t6447 (OutputJoin t6446 t447)) +(let t6448 (OutputJoin t6447 t449)) +(let t6449 (OutputJoin t6448 t451)) +(let t6450 (OutputJoin t6449 t453)) +(let t6451 (OutputJoin t6450 t455)) +(let t6452 (OutputJoin t6451 t457)) +(let t6453 (OutputJoin t6452 t459)) +(let t6454 (OutputJoin t6453 t461)) +(let t6455 (OutputJoin t6454 t463)) +(let t6456 (OutputJoin t6455 t465)) +(let t6457 (OutputJoin t6456 t467)) +(let t6458 (OutputJoin t6457 t469)) +(let t6459 (OutputJoin t6458 t471)) +(let t6460 (OutputJoin t6459 t473)) +(let t6461 (OutputJoin t6460 t475)) +(let t6462 (OutputJoin t6461 t477)) +(let t6463 (OutputJoin t6462 t479)) +(let t6464 (OutputJoin t6463 t481)) +(let t6465 (OutputJoin t6464 t483)) +(let t6466 (OutputJoin t6465 t485)) +(let t6467 (OutputJoin t6466 t487)) +(let t6468 (OutputJoin t6467 t489)) +(let t6469 (OutputJoin t6468 t491)) +(let t6470 (OutputJoin t6469 t493)) +(let t6471 (OutputJoin t6470 t495)) +(let t6472 (OutputJoin t6471 t497)) +(let t6473 (OutputJoin t6472 t499)) +(let t6474 (OutputJoin t6473 t501)) +(let t6475 (OutputJoin t6474 t503)) +(let t6476 (OutputJoin t6475 t505)) +(let t6477 (OutputJoin t6476 t507)) +(let t6478 (OutputJoin t6477 t509)) +(let t6479 (OutputJoin t6478 t511)) +(let t6480 (OutputJoin t6479 t513)) +(let t6481 (OutputJoin t6480 t515)) +(let t6482 (OutputJoin t6481 t517)) +(let t6483 (OutputJoin t6482 t519)) +(let t6484 (OutputJoin t6483 t521)) +(let t6485 (OutputJoin t6484 t523)) +(let t6486 (OutputJoin t6485 t525)) +(let t6487 (OutputJoin t6486 t527)) +(let t6488 (OutputJoin t6487 t529)) +(let t6489 (OutputJoin t6488 t531)) +(let t6490 (OutputJoin t6489 t533)) +(let t6491 (OutputJoin t6490 t535)) +(let t6492 (OutputJoin t6491 t537)) +(let t6493 (OutputJoin t6492 t539)) +(let t6494 (OutputJoin t6493 t541)) +(let t6495 (OutputJoin t6494 t543)) +(let t6496 (OutputJoin t6495 t545)) +(let t6497 (OutputJoin t6496 t547)) +(let t6498 (OutputJoin t6497 t549)) +(let t6499 (OutputJoin t6498 t551)) +(let t6500 (OutputJoin t6499 t553)) +(let t6501 (OutputJoin t6500 t555)) +(let t6502 (OutputJoin t6501 t557)) +(let t6503 (OutputJoin t6502 t559)) +(let t6504 (OutputJoin t6503 t561)) +(let t6505 (OutputJoin t6504 t563)) +(let t6506 (OutputJoin t6505 t565)) +(let t6507 (OutputJoin t6506 t567)) +(let t6508 (OutputJoin t6507 t569)) +(let t6509 (OutputJoin t6508 t571)) +(let t6510 (OutputJoin t6509 t573)) +(let t6511 (OutputJoin t6510 t575)) +(let t6512 (OutputJoin t6511 t577)) +(let t6513 (OutputJoin t6512 t579)) +(let t6514 (OutputJoin t6513 t581)) +(let t6515 (OutputJoin t6514 t583)) +(let t6516 (OutputJoin t6515 t585)) +(let t6517 (OutputJoin t6516 t587)) +(let t6518 (OutputJoin t6517 t589)) +(let t6519 (OutputJoin t6518 t591)) +(let t6520 (OutputJoin t6519 t593)) +(let t6521 (OutputJoin t6520 t595)) +(let t6522 (OutputJoin t6521 t597)) +(let t6523 (OutputJoin t6522 t599)) +(let t6524 (OutputJoin t6523 t601)) +(let t6525 (OutputJoin t6524 t603)) +(let t6526 (OutputJoin t6525 t605)) +(let t6527 (OutputJoin t6526 t607)) +(let t6528 (OutputJoin t6527 t609)) +(let t6529 (OutputJoin t6528 t611)) +(let t6530 (OutputJoin t6529 t613)) +(let t6531 (OutputJoin t6530 t615)) +(let t6532 (OutputJoin t6531 t617)) +(let t6533 (OutputJoin t6532 t619)) +(let t6534 (OutputJoin t6533 t621)) +(let t6535 (OutputJoin t6534 t623)) +(let t6536 (OutputJoin t6535 t625)) +(let t6537 (OutputJoin t6536 t627)) +(let t6538 (OutputJoin t6537 t629)) +(let t6539 (OutputJoin t6538 t631)) +(let t6540 (OutputJoin t6539 t633)) +(let t6541 (OutputJoin t6540 t635)) +(let t6542 (OutputJoin t6541 t637)) +(let t6543 (OutputJoin t6542 t639)) +(let t6544 (OutputJoin t6543 t641)) +(let t6545 (OutputJoin t6544 t643)) +(let t6546 (OutputJoin t6545 t645)) +(let t6547 (OutputJoin t6546 t647)) +(let t6548 (OutputJoin t6547 t649)) +(let t6549 (OutputJoin t6548 t651)) +(let t6550 (OutputJoin t6549 t653)) +(let t6551 (OutputJoin t6550 t655)) +(let t6552 (OutputJoin t6551 t657)) +(let t6553 (OutputJoin t6552 t659)) +(let t6554 (OutputJoin t6553 t661)) +(let t6555 (OutputJoin t6554 t663)) +(let t6556 (OutputJoin t6555 t665)) +(let t6557 (OutputJoin t6556 t667)) +(let t6558 (OutputJoin t6557 t669)) +(let t6559 (OutputJoin t6558 t671)) +(let t6560 (OutputJoin t6559 t673)) +(let t6561 (OutputJoin t6560 t675)) +(let t6562 (OutputJoin t6561 t677)) +(let t6563 (OutputJoin t6562 t679)) +(let t6564 (OutputJoin t6563 t681)) +(let t6565 (OutputJoin t6564 t683)) +(let t6566 (OutputJoin t6565 t685)) +(let t6567 (OutputJoin t6566 t687)) +(let t6568 (OutputJoin t6567 t689)) +(let t6569 (OutputJoin t6568 t691)) +(let t6570 (OutputJoin t6569 t693)) +(let t6571 (OutputJoin t6570 t695)) +(let t6572 (OutputJoin t6571 t697)) +(let t6573 (OutputJoin t6572 t699)) +(let t6574 (OutputJoin t6573 t701)) +(let t6575 (OutputJoin t6574 t703)) +(let t6576 (OutputJoin t6575 t705)) +(let t6577 (OutputJoin t6576 t707)) +(let t6578 (OutputJoin t6577 t709)) +(let t6579 (OutputJoin t6578 t711)) +(let t6580 (OutputJoin t6579 t713)) +(let t6581 (OutputJoin t6580 t715)) +(let t6582 (OutputJoin t6581 t717)) +(let t6583 (OutputJoin t6582 t719)) +(let t6584 (OutputJoin t6583 t721)) +(let t6585 (OutputJoin t6584 t723)) +(let t6586 (OutputJoin t6585 t725)) +(let t6587 (OutputJoin t6586 t727)) +(let t6588 (OutputJoin t6587 t729)) +(let t6589 (OutputJoin t6588 t731)) +(let t6590 (OutputJoin t6589 t733)) +(let t6591 (OutputJoin t6590 t735)) +(let t6592 (OutputJoin t6591 t737)) +(let t6593 (OutputJoin t6592 t739)) +(let t6594 (OutputJoin t6593 t741)) +(let t6595 (OutputJoin t6594 t743)) +(let t6596 (OutputJoin t6595 t745)) +(let t6597 (OutputJoin t6596 t747)) +(let t6598 (OutputJoin t6597 t749)) +(let t6599 (OutputJoin t6598 t751)) +(let t6600 (OutputJoin t6599 t753)) +(let t6601 (OutputJoin t6600 t755)) +(let t6602 (OutputJoin t6601 t757)) +(let t6603 (OutputJoin t6602 t759)) +(let t6604 (OutputJoin t6603 t761)) +(let t6605 (OutputJoin t6604 t763)) +(let t6606 (OutputJoin t6605 t765)) +(let t6607 (OutputJoin t6606 t767)) +(let t6608 (OutputJoin t6607 t769)) +(let t6609 (OutputJoin t6608 t771)) +(let t6610 (OutputJoin t6609 t773)) +(let t6611 (OutputJoin t6610 t775)) +(let t6612 (OutputJoin t6611 t777)) +(let t6613 (OutputJoin t6612 t779)) +(let t6614 (OutputJoin t6613 t781)) +(let t6615 (OutputJoin t6614 t783)) +(let t6616 (OutputJoin t6615 t785)) +(let t6617 (OutputJoin t6616 t787)) +(let t6618 (OutputJoin t6617 t789)) +(let t6619 (OutputJoin t6618 t791)) +(let t6620 (OutputJoin t6619 t793)) +(let t6621 (OutputJoin t6620 t795)) +(let t6622 (OutputJoin t6621 t797)) +(let t6623 (OutputJoin t6622 t799)) +(let t6624 (OutputJoin t6623 t801)) +(let t6625 (OutputJoin t6624 t803)) +(let t6626 (OutputJoin t6625 t805)) +(let t6627 (OutputJoin t6626 t807)) +(let t6628 (OutputJoin t6627 t809)) +(let t6629 (OutputJoin t6628 t811)) +(let t6630 (OutputJoin t6629 t813)) +(let t6631 (OutputJoin t6630 t815)) +(let t6632 (OutputJoin t6631 t817)) +(let t6633 (OutputJoin t6632 t819)) +(let t6634 (OutputJoin t6633 t821)) +(let t6635 (OutputJoin t6634 t823)) +(let t6636 (OutputJoin t6635 t825)) +(let t6637 (OutputJoin t6636 t827)) +(let t6638 (OutputJoin t6637 t829)) +(let t6639 (OutputJoin t6638 t831)) +(let t6640 (OutputJoin t6639 t833)) +(let t6641 (OutputJoin t6640 t835)) +(let t6642 (OutputJoin t6641 t837)) +(let t6643 (OutputJoin t6642 t839)) +(let t6644 (OutputJoin t6643 t841)) +(let t6645 (OutputJoin t6644 t843)) +(let t6646 (OutputJoin t6645 t845)) +(let t6647 (OutputJoin t6646 t847)) +(let t6648 (OutputJoin t6647 t849)) +(let t6649 (OutputJoin t6648 t851)) +(let t6650 (OutputJoin t6649 t853)) +(let t6651 (OutputJoin t6650 t855)) +(let t6652 (OutputJoin t6651 t857)) +(let t6653 (OutputJoin t6652 t859)) +(let t6654 (OutputJoin t6653 t861)) +(let t6655 (OutputJoin t6654 t863)) +(let t6656 (OutputJoin t6655 t865)) +(let t6657 (OutputJoin t6656 t867)) +(let t6658 (OutputJoin t6657 t869)) +(let t6659 (OutputJoin t6658 t871)) +(let t6660 (OutputJoin t6659 t873)) +(let t6661 (OutputJoin t6660 t875)) +(let t6662 (OutputJoin t6661 t877)) +(let t6663 (OutputJoin t6662 t879)) +(let t6664 (OutputJoin t6663 t881)) +(let t6665 (OutputJoin t6664 t883)) +(let t6666 (OutputJoin t6665 t885)) +(let t6667 (OutputJoin t6666 t887)) +(let t6668 (OutputJoin t6667 t889)) +(let t6669 (OutputJoin t6668 t891)) +(let t6670 (OutputJoin t6669 t893)) +(let t6671 (OutputJoin t6670 t895)) +(let t6672 (OutputJoin t6671 t897)) +(let t6673 (OutputJoin t6672 t899)) +(let t6674 (OutputJoin t6673 t901)) +(let t6675 (OutputJoin t6674 t903)) +(let t6676 (OutputJoin t6675 t905)) +(let t6677 (OutputJoin t6676 t907)) +(let t6678 (OutputJoin t6677 t909)) +(let t6679 (OutputJoin t6678 t911)) +(let t6680 (OutputJoin t6679 t913)) +(let t6681 (OutputJoin t6680 t915)) +(let t6682 (OutputJoin t6681 t917)) +(let t6683 (OutputJoin t6682 t919)) +(let t6684 (OutputJoin t6683 t921)) +(let t6685 (OutputJoin t6684 t923)) +(let t6686 (OutputJoin t6685 t925)) +(let t6687 (OutputJoin t6686 t927)) +(let t6688 (OutputJoin t6687 t929)) +(let t6689 (OutputJoin t6688 t931)) +(let t6690 (OutputJoin t6689 t933)) +(let t6691 (OutputJoin t6690 t935)) +(let t6692 (OutputJoin t6691 t937)) +(let t6693 (OutputJoin t6692 t939)) +(let t6694 (OutputJoin t6693 t941)) +(let t6695 (OutputJoin t6694 t943)) +(let t6696 (OutputJoin t6695 t945)) +(let t6697 (OutputJoin t6696 t947)) +(let t6698 (OutputJoin t6697 t949)) +(let t6699 (OutputJoin t6698 t951)) +(let t6700 (OutputJoin t6699 t953)) +(let t6701 (OutputJoin t6700 t955)) +(let t6702 (OutputJoin t6701 t957)) +(let t6703 (OutputJoin t6702 t959)) +(let t6704 (OutputJoin t6703 t961)) +(let t6705 (OutputJoin t6704 t963)) +(let t6706 (OutputJoin t6705 t965)) +(let t6707 (OutputJoin t6706 t967)) +(let t6708 (OutputJoin t6707 t969)) +(let t6709 (OutputJoin t6708 t971)) +(let t6710 (OutputJoin t6709 t973)) +(let t6711 (OutputJoin t6710 t975)) +(let t6712 (OutputJoin t6711 t977)) +(let t6713 (OutputJoin t6712 t979)) +(let t6714 (OutputJoin t6713 t981)) +(let t6715 (OutputJoin t6714 t983)) +(let t6716 (OutputJoin t6715 t985)) +(let t6717 (OutputJoin t6716 t987)) +(let t6718 (OutputJoin t6717 t989)) +(let t6719 (OutputJoin t6718 t991)) +(let t6720 (OutputJoin t6719 t993)) +(let t6721 (OutputJoin t6720 t995)) +(let t6722 (OutputJoin t6721 t997)) +(let t6723 (OutputJoin t6722 t999)) +(let t6724 (OutputJoin t6723 t1001)) +(let t6725 (OutputJoin t6724 t1003)) +(let t6726 (OutputJoin t6725 t1005)) +(let t6727 (OutputJoin t6726 t1007)) +(let t6728 (OutputJoin t6727 t1009)) +(let t6729 (OutputJoin t6728 t1011)) +(let t6730 (OutputJoin t6729 t1013)) +(let t6731 (OutputJoin t6730 t1015)) +(let t6732 (OutputJoin t6731 t1017)) +(let t6733 (OutputJoin t6732 t1019)) +(let t6734 (OutputJoin t6733 t1021)) +(let t6735 (OutputJoin t6734 t1023)) +(let t6736 (OutputJoin t6735 t1025)) +(let t6737 (OutputJoin t6736 t1027)) +(let t6738 (OutputJoin t6737 t1029)) +(let t6739 (OutputJoin t6738 t1031)) +(let t6740 (OutputJoin t6739 t1033)) +(let t6741 (OutputJoin t6740 t1035)) +(let t6742 (OutputJoin t6741 t1037)) +(let t6743 (OutputJoin t6742 t1039)) +(let t6744 (OutputJoin t6743 t1041)) +(let t6745 (OutputJoin t6744 t1043)) +(let t6746 (OutputJoin t6745 t1045)) +(let t6747 (OutputJoin t6746 t1047)) +(let t6748 (OutputJoin t6747 t1049)) +(let t6749 (OutputJoin t6748 t1051)) +(let t6750 (OutputJoin t6749 t1053)) +(let t6751 (OutputJoin t6750 t1055)) +(let t6752 (OutputJoin t6751 t1057)) +(let t6753 (OutputJoin t6752 t1059)) +(let t6754 (OutputJoin t6753 t1061)) +(let t6755 (OutputJoin t6754 t1063)) +(let t6756 (OutputJoin t6755 t1065)) +(let t6757 (OutputJoin t6756 t1067)) +(let t6758 (OutputJoin t6757 t1069)) +(let t6759 (OutputJoin t6758 t1071)) +(let t6760 (OutputJoin t6759 t1073)) +(let t6761 (OutputJoin t6760 t1075)) +(let t6762 (OutputJoin t6761 t1077)) +(let t6763 (OutputJoin t6762 t1079)) +(let t6764 (OutputJoin t6763 t1081)) +(let t6765 (OutputJoin t6764 t1083)) +(let t6766 (OutputJoin t6765 t1085)) +(let t6767 (OutputJoin t6766 t1087)) +(let t6768 (OutputJoin t6767 t1089)) +(let t6769 (OutputJoin t6768 t1091)) +(let t6770 (OutputJoin t6769 t1093)) +(let t6771 (OutputJoin t6770 t1095)) +(let t6772 (OutputJoin t6771 t1097)) +(let t6773 (OutputJoin t6772 t1099)) +(let t6774 (OutputJoin t6773 t1101)) +(let t6775 (OutputJoin t6774 t1103)) +(let t6776 (OutputJoin t6775 t1105)) +(let t6777 (OutputJoin t6776 t1107)) +(let t6778 (OutputJoin t6777 t1109)) +(let t6779 (OutputJoin t6778 t1111)) +(let t6780 (OutputJoin t6779 t1113)) +(let t6781 (OutputJoin t6780 t1115)) +(let t6782 (OutputJoin t6781 t1117)) +(let t6783 (OutputJoin t6782 t1119)) +(let t6784 (OutputJoin t6783 t1121)) +(let t6785 (OutputJoin t6784 t1123)) +(let t6786 (OutputJoin t6785 t1125)) +(let t6787 (OutputJoin t6786 t1127)) +(let t6788 (OutputJoin t6787 t1129)) +(let t6789 (OutputJoin t6788 t1131)) +(let t6790 (OutputJoin t6789 t1133)) +(let t6791 (OutputJoin t6790 t1135)) +(let t6792 (OutputJoin t6791 t1137)) +(let t6793 (OutputJoin t6792 t1139)) +(let t6794 (OutputJoin t6793 t1141)) +(let t6795 (OutputJoin t6794 t1143)) +(let t6796 (OutputJoin t6795 t1145)) +(let t6797 (OutputJoin t6796 t1147)) +(let t6798 (OutputJoin t6797 t1149)) +(let t6799 (OutputJoin t6798 t1151)) +(let t6800 (OutputJoin t6799 t1153)) +(let t6801 (OutputJoin t6800 t1155)) +(let t6802 (OutputJoin t6801 t1157)) +(let t6803 (OutputJoin t6802 t1159)) +(let t6804 (OutputJoin t6803 t1161)) +(let t6805 (OutputJoin t6804 t1163)) +(let t6806 (OutputJoin t6805 t1165)) +(let t6807 (OutputJoin t6806 t1167)) +(let t6808 (OutputJoin t6807 t1169)) +(let t6809 (OutputJoin t6808 t1171)) +(let t6810 (OutputJoin t6809 t1173)) +(let t6811 (OutputJoin t6810 t1175)) +(let t6812 (OutputJoin t6811 t1177)) +(let t6813 (OutputJoin t6812 t1179)) +(let t6814 (OutputJoin t6813 t1181)) +(let t6815 (OutputJoin t6814 t1183)) +(let t6816 (OutputJoin t6815 t1185)) +(let t6817 (OutputJoin t6816 t1187)) +(let t6818 (OutputJoin t6817 t1189)) +(let t6819 (OutputJoin t6818 t1191)) +(let t6820 (OutputJoin t6819 t1193)) +(let t6821 (OutputJoin t6820 t1195)) +(let t6822 (OutputJoin t6821 t1197)) +(let t6823 (OutputJoin t6822 t1199)) +(let t6824 (OutputJoin t6823 t1201)) +(let t6825 (OutputJoin t6824 t1203)) +(let t6826 (OutputJoin t6825 t1205)) +(let t6827 (OutputJoin t6826 t1207)) +(let t6828 (OutputJoin t6827 t1209)) +(let t6829 (OutputJoin t6828 t1211)) +(let t6830 (OutputJoin t6829 t1213)) +(let t6831 (OutputJoin t6830 t1215)) +(let t6832 (OutputJoin t6831 t1217)) +(let t6833 (OutputJoin t6832 t1219)) +(let t6834 (OutputJoin t6833 t1221)) +(let t6835 (OutputJoin t6834 t1223)) +(let t6836 (OutputJoin t6835 t1225)) +(let t6837 (OutputJoin t6836 t1227)) +(let t6838 (OutputJoin t6837 t1229)) +(let t6839 (OutputJoin t6838 t1231)) +(let t6840 (OutputJoin t6839 t1233)) +(let t6841 (OutputJoin t6840 t1235)) +(let t6842 (OutputJoin t6841 t1237)) +(let t6843 (OutputJoin t6842 t1239)) +(let t6844 (OutputJoin t6843 t1241)) +(let t6845 (OutputJoin t6844 t1243)) +(let t6846 (OutputJoin t6845 t1245)) +(let t6847 (OutputJoin t6846 t1247)) +(let t6848 (OutputJoin t6847 t1249)) +(let t6849 (OutputJoin t6848 t1251)) +(let t6850 (OutputJoin t6849 t1253)) +(let t6851 (OutputJoin t6850 t1255)) +(let t6852 (OutputJoin t6851 t1257)) +(let t6853 (OutputJoin t6852 t1259)) +(let t6854 (OutputJoin t6853 t1261)) +(let t6855 (OutputJoin t6854 t1263)) +(let t6856 (OutputJoin t6855 t1265)) +(let t6857 (OutputJoin t6856 t1267)) +(let t6858 (OutputJoin t6857 t1269)) +(let t6859 (OutputJoin t6858 t1271)) +(let t6860 (OutputJoin t6859 t1273)) +(let t6861 (OutputJoin t6860 t1275)) +(let t6862 (OutputJoin t6861 t1277)) +(let t6863 (OutputJoin t6862 t1279)) +(let t6864 (OutputJoin t6863 t1281)) +(let t6865 (OutputJoin t6864 t1283)) +(let t6866 (OutputJoin t6865 t1285)) +(let t6867 (OutputJoin t6866 t1287)) +(let t6868 (OutputJoin t6867 t1289)) +(let t6869 (OutputJoin t6868 t1291)) +(let t6870 (OutputJoin t6869 t1293)) +(let t6871 (OutputJoin t6870 t1295)) +(let t6872 (OutputJoin t6871 t1297)) +(let t6873 (OutputJoin t6872 t1299)) +(let t6874 (OutputJoin t6873 t1301)) +(let t6875 (OutputJoin t6874 t1303)) +(let t6876 (OutputJoin t6875 t1305)) +(let t6877 (OutputJoin t6876 t1307)) +(let t6878 (OutputJoin t6877 t1309)) +(let t6879 (OutputJoin t6878 t1311)) +(let t6880 (OutputJoin t6879 t1313)) +(let t6881 (OutputJoin t6880 t1315)) +(let t6882 (OutputJoin t6881 t1317)) +(let t6883 (OutputJoin t6882 t1319)) +(let t6884 (OutputJoin t6883 t1321)) +(let t6885 (OutputJoin t6884 t1323)) +(let t6886 (OutputJoin t6885 t1325)) +(let t6887 (OutputJoin t6886 t1327)) +(let t6888 (OutputJoin t6887 t1329)) +(let t6889 (OutputJoin t6888 t1331)) +(let t6890 (OutputJoin t6889 t1333)) +(let t6891 (OutputJoin t6890 t1335)) +(let t6892 (OutputJoin t6891 t1337)) +(let t6893 (OutputJoin t6892 t1339)) +(let t6894 (OutputJoin t6893 t1341)) +(let t6895 (OutputJoin t6894 t1343)) +(let t6896 (OutputJoin t6895 t1345)) +(let t6897 (OutputJoin t6896 t1347)) +(let t6898 (OutputJoin t6897 t1349)) +(let t6899 (OutputJoin t6898 t1351)) +(let t6900 (OutputJoin t6899 t1353)) +(let t6901 (OutputJoin t6900 t1355)) +(let t6902 (OutputJoin t6901 t1357)) +(let t6903 (OutputJoin t6902 t1359)) +(let t6904 (OutputJoin t6903 t1361)) +(let t6905 (OutputJoin t6904 t1363)) +(let t6906 (OutputJoin t6905 t1365)) +(let t6907 (OutputJoin t6906 t1367)) +(let t6908 (OutputJoin t6907 t1369)) +(let t6909 (OutputJoin t6908 t1371)) +(let t6910 (OutputJoin t6909 t1373)) +(let t6911 (OutputJoin t6910 t1375)) +(let t6912 (OutputJoin t6911 t1377)) +(let t6913 (OutputJoin t6912 t1379)) +(let t6914 (OutputJoin t6913 t1381)) +(let t6915 (OutputJoin t6914 t1383)) +(let t6916 (OutputJoin t6915 t1385)) +(let t6917 (OutputJoin t6916 t1387)) +(let t6918 (OutputJoin t6917 t1389)) +(let t6919 (OutputJoin t6918 t1391)) +(let t6920 (OutputJoin t6919 t1393)) +(let t6921 (OutputJoin t6920 t1395)) +(let t6922 (OutputJoin t6921 t1397)) +(let t6923 (OutputJoin t6922 t1399)) +(let t6924 (OutputJoin t6923 t1401)) +(let t6925 (OutputJoin t6924 t1403)) +(let t6926 (OutputJoin t6925 t1405)) +(let t6927 (OutputJoin t6926 t1407)) +(let t6928 (OutputJoin t6927 t1409)) +(let t6929 (OutputJoin t6928 t1411)) +(let t6930 (OutputJoin t6929 t1413)) +(let t6931 (OutputJoin t6930 t1415)) +(let t6932 (OutputJoin t6931 t1417)) +(let t6933 (OutputJoin t6932 t1419)) +(let t6934 (OutputJoin t6933 t1421)) +(let t6935 (OutputJoin t6934 t1423)) +(let t6936 (OutputJoin t6935 t1425)) +(let t6937 (OutputJoin t6936 t1427)) +(let t6938 (OutputJoin t6937 t1429)) +(let t6939 (OutputJoin t6938 t1431)) +(let t6940 (OutputJoin t6939 t1433)) +(let t6941 (OutputJoin t6940 t1435)) +(let t6942 (OutputJoin t6941 t1437)) +(let t6943 (OutputJoin t6942 t6104)) +(let t6944 (OutputJoin t6943 t6119)) +(let t6945 (OutputJoin t6944 t6128)) +(let t6946 (OutputJoin t6945 t6137)) +(let t6947 (OutputJoin t6946 t6146)) +(let t6948 (OutputJoin t6947 t6155)) +(let t6949 (OutputJoin t6948 t6164)) +(let t6950 (OutputJoin t6949 t6173)) +(let t6951 (OutputJoin t6950 t6182)) +(let t6952 (OutputJoin t6951 t6191)) +(let t6953 (OutputJoin t6952 t6200)) +(let t6954 (OutputJoin t6953 t6209)) +(let t6955 (OutputJoin t6954 t6218)) +(let t6956 (OutputJoin t6955 t6121)) +(let t6957 (OutputJoin t6956 t6130)) +(let t6958 (OutputJoin t6957 t6139)) +(let t6959 (OutputJoin t6958 t6148)) +(let t6960 (OutputJoin t6959 t6157)) +(let t6961 (OutputJoin t6960 t6166)) +(let t6962 (OutputJoin t6961 t6175)) +(let t6963 (OutputJoin t6962 t6184)) +(let t6964 (OutputJoin t6963 t6193)) +(let t6965 (OutputJoin t6964 t6202)) +(let t6966 (OutputJoin t6965 t6211)) +(let t6967 (OutputJoin t6966 t6220)) +(let t6968 (OutputJoin t6967 t6123)) +(let t6969 (OutputJoin t6968 t6132)) +(let t6970 (OutputJoin t6969 t6141)) +(let t6971 (OutputJoin t6970 t6150)) +(let t6972 (OutputJoin t6971 t6159)) +(let t6973 (OutputJoin t6972 t6168)) +(let t6974 (OutputJoin t6973 t6177)) +(let t6975 (OutputJoin t6974 t6186)) +(let t6976 (OutputJoin t6975 t6195)) +(let t6977 (OutputJoin t6976 t6204)) +(let t6978 (OutputJoin t6977 t6213)) +(let t6979 (OutputJoin t6978 t6222)) +(let t6980 (OutputJoin t6979 t6125)) +(let t6981 (OutputJoin t6980 t6134)) +(let t6982 (OutputJoin t6981 t6143)) +(let t6983 (OutputJoin t6982 t6152)) +(let t6984 (OutputJoin t6983 t6161)) +(let t6985 (OutputJoin t6984 t6170)) +(let t6986 (OutputJoin t6985 t6179)) +(let t6987 (OutputJoin t6986 t6188)) +(let t6988 (OutputJoin t6987 t6197)) +(let t6989 (OutputJoin t6988 t6206)) +(let t6990 (OutputJoin t6989 t6215)) +(let t6991 (OutputJoin t6990 t6224)) +(let t6992 (OutputJoin t6991 t6105)) +(let t6993 (OutputJoin t6992 t6106)) +(let t6994 (OutputJoin t6993 t6107)) +(let t6995 (OutputJoin t6994 t6108)) +(let t6996 (OutputJoin t6995 t6109)) +(let t6997 (OutputJoin t6996 t6110)) +(let t6998 (OutputJoin t6997 t6111)) +(let t6999 (OutputJoin t6998 t6112)) +(let t7000 (OutputJoin t6999 t6113)) +(let t7001 (OutputJoin t7000 t6114)) +(let t7002 (OutputJoin t7001 t6115)) +(let t7003 (OutputJoin t7002 t6116)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/header/luminal-header.egg b/tests/header/luminal-header.egg new file mode 100644 index 00000000..d685b79a --- /dev/null +++ b/tests/header/luminal-header.egg @@ -0,0 +1,6658 @@ +(ruleset matmul_flatten) +(ruleset kernel_lower) +(ruleset direct_kernel) +(ruleset kernel_specialize) +(ruleset buffer_reuse) +(ruleset matmul_backend) +(ruleset glumoe) +(ruleset fusion_pair) +(ruleset fusion_grow) +(ruleset fusion_merge) +(ruleset expr) +(ruleset dtype_prop) +(ruleset cleanup) +(ruleset post_cleanup) + +(datatype* + (Expression + (MNum i64) + (MFloat f64) + (MIter) + (MVar String) + (MAdd Expression Expression) + (MSub Expression Expression) + (MMul Expression Expression) + (MCeilDiv Expression Expression) + (MDiv Expression Expression) + (MMod Expression Expression) + (MMin Expression Expression) + (MMax Expression Expression) + (MAnd Expression Expression) + (MOr Expression Expression) + (MGte Expression Expression) + (MLt Expression Expression) + (MFloorTo Expression Expression) + (MReplace Expression Expression Expression) + ) + (EList + (ECons Expression EList) + (ENil) + (MReplaceList EList Expression Expression) + (ReplaceNthFromEnd EList Expression i64) + (RemoveNthFromEnd EList i64) + (RowMajor EList) + ) + (DType + (F32) + (F16) + (Bf16) + (Int) + (Bool) + (F4E2M1) + (F8E4M3) + (F8E5M2) + (F8UE8M0) + (I4) + (TF32) + ) +) + +(rule ((= ?__rw (MMul ?a ?b))) ((union ?__rw (MMul ?b ?a))) :ruleset expr :name "mul-comm") +(rule ((= ?__rw (MAdd ?a ?b))) ((union ?__rw (MAdd ?b ?a))) :ruleset expr :name "add-comm") +(rule ((= ?e (MAdd (MNum ?a) (MNum ?b))) (= ?ans (+ ?a ?b))) ((union ?e (MNum ?ans)) (subsume (MAdd (MNum ?a) (MNum ?b)))) :ruleset expr) +(rule ((= ?__rw (MSub (MNum ?a) (MNum ?b)))) ((union ?__rw (MNum (- ?a ?b)))) :ruleset expr :name "sub-const") +(rule ((= ?e (MMul (MNum ?a) (MNum ?b))) (= ?prod (* ?a ?b))) ((union ?e (MNum ?prod)) (subsume (MMul (MNum ?a) (MNum ?b)))) :ruleset expr) +(rule ((= ?__rw (MDiv (MNum ?a) (MNum ?b))) (!= 0 ?b) (= 0 (% ?a ?b))) ((union ?__rw (MNum (/ ?a ?b)))) :ruleset expr :name "div-const") +(rule ((= ?__rw (MDiv ?a ?a))) ((union ?__rw (MNum 1))) :ruleset expr :name "div-self") +(rule ((= ?__rw (MCeilDiv (MNum ?a) (MNum ?b))) (!= 0 ?b) (= 0 (% ?a ?b))) ((union ?__rw (MNum (/ ?a ?b)))) :ruleset expr :name "ceildiv-const") +(rule ((= ?__rw (MMax (MNum ?a) (MNum ?b)))) ((union ?__rw (MNum (max ?a ?b)))) :ruleset expr :name "max-const") +(rule ((= ?__rw (MMin (MNum ?a) (MNum ?b)))) ((union ?__rw (MNum (min ?a ?b)))) :ruleset expr :name "min-const") +(rule ((= ?__rw (MAnd (MNum ?a) (MNum ?b)))) ((union ?__rw (MNum (& ?a ?b)))) :ruleset expr :name "and-const") +(rule ((= ?__rw (MFloat -1.0))) ((union ?__rw (MNum -1))) :ruleset expr :name "float-neg1-to-num") +(rule ((= ?__rw (MNum -1))) ((union ?__rw (MFloat -1.0))) :ruleset expr :name "num-neg1-to-float") +(rule ((= ?__rw (MAdd ?a (MNum 0)))) ((union ?__rw ?a)) :ruleset expr :name "add-zero") +(rule ((= ?e (MMul ?a (MNum 1)))) ((union ?e ?a)) :ruleset expr) +(rule ((= ?e (MMul ?a (MNum 0)))) ((union ?e (MNum 0)) (subsume (MMul ?a (MNum 0)))) :ruleset expr) +(rule ((= ?__rw (MDiv ?a (MNum 1)))) ((union ?__rw ?a)) :ruleset expr :name "div-one") +(rule ((= ?__rw (MMod (MMul ?x ?y) ?y))) ((union ?__rw (MNum 0))) :ruleset expr :name "mod-mul-self") +(rule ((= ?__rw (MMod (MMod ?x (MNum ?y)) (MNum ?z))) (>= ?z ?y) (= 0 (% ?y ?z))) ((union ?__rw (MMod ?x (MNum ?y)))) :ruleset expr :name "mod-mod-larger") +(rule ((= ?__rw (MMod (MMod ?x (MNum ?y)) (MNum ?z))) (>= ?y ?z) (= 0 (% ?z ?y))) ((union ?__rw (MMod ?x (MNum ?z)))) :ruleset expr :name "mod-mod-smaller") +(rule ((= ?__rw (MAdd (MMul (MDiv ?z ?x) ?x) (MMod ?z ?x)))) ((union ?__rw ?z)) :ruleset expr :name "merge-dims") +(rule ((= ?__rw (MDiv (MDiv ?a (MNum ?b)) (MNum ?c)))) ((union ?__rw (MDiv ?a (MNum (* ?b ?c))))) :ruleset expr :name "div-div-num") +(rule ((= ?__rw (MAdd (MDiv ?a ?b) ?c))) ((union ?__rw (MDiv (MAdd ?a (MMul ?c ?b)) ?b))) :ruleset expr :name "add-div") +(rule ((= ?__rw (MAdd ?a (MSub ?b ?a)))) ((union ?__rw ?b)) :ruleset expr :name "add-sub-cancel") +(rule ((= ?__rw (MAdd (MSub ?b ?a) ?a))) ((union ?__rw ?b)) :ruleset expr :name "add-sub-cancel2") +(rule ((= ?__rw (MSub ?a ?a))) ((union ?__rw (MNum 0))) :ruleset expr :name "sub-self") +(rule ((= ?__rw (MAdd (MSub ?a (MNum ?b)) (MNum ?c)))) ((union ?__rw (MSub ?a (MNum (- ?b ?c))))) :ruleset expr :name "add-sub-const") +(rule ((= ?__rw (MAdd (MNum ?c) (MSub ?a (MNum ?b))))) ((union ?__rw (MSub ?a (MNum (- ?b ?c))))) :ruleset expr :name "add-sub-const2") +(rule ((= ?__rw (MSub (MAdd ?a (MNum ?b)) (MNum ?c)))) ((union ?__rw (MAdd ?a (MNum (- ?b ?c))))) :ruleset expr :name "sub-add-const") +(rule ((= ?__rw (MSub (MSub ?a (MNum ?b)) (MNum ?c)))) ((union ?__rw (MSub ?a (MNum (+ ?b ?c))))) :ruleset expr :name "sub-sub-const") +(rule ((= ?__rw (MAdd (MMul ?a ?b) (MMul ?a ?c)))) ((union ?__rw (MMul ?a (MAdd ?b ?c)))) :ruleset expr :name "factor") +(rule ((= ?__rw (MAdd ?a ?a))) ((union ?__rw (MMul (MNum 2) ?a))) :ruleset expr :name "double") +(rule ((= ?e (MAdd (MAdd ?a (MNum ?b)) (MNum ?c))) (= ?ans (+ ?b ?c))) ((union ?e (MAdd ?a (MNum ?ans))) (subsume (MAdd (MAdd ?a (MNum ?b)) (MNum ?c)))) :ruleset expr) +(rule ((= ?__rw (MAdd (MAdd (MNum ?b) (MVar ?v)) (MNum ?c)))) ((union ?__rw (MAdd (MVar ?v) (MNum (+ ?b ?c))))) :ruleset expr :name "add-assoc-var") +(rule ((= ?__rw (MAdd (MAdd (MNum ?b) (MMul ?n ?a)) (MNum ?c)))) ((union ?__rw (MAdd (MMul ?n ?a) (MNum (+ ?b ?c))))) :ruleset expr :name "add-assoc-mul") +(rule ((= ?__rw (MAdd (MMul (MNum ?n) ?a) ?a))) ((union ?__rw (MMul (MNum (+ ?n 1)) ?a)) (subsume (MAdd (MMul (MNum ?n) ?a) ?a))) :ruleset expr :name "combine-like-1") +(rule ((= ?__rw (MAdd ?a (MMul (MNum ?n) ?a)))) ((union ?__rw (MMul (MNum (+ ?n 1)) ?a)) (subsume (MAdd ?a (MMul (MNum ?n) ?a)))) :ruleset expr :name "combine-like-2") +(rule ((= ?__rw (MAdd (MMul ?a (MNum ?n)) ?a))) ((union ?__rw (MMul (MNum (+ ?n 1)) ?a)) (subsume (MAdd (MMul ?a (MNum ?n)) ?a))) :ruleset expr :name "combine-like-3") +(rule ((= ?__rw (MAdd ?a (MMul ?a (MNum ?n))))) ((union ?__rw (MMul (MNum (+ ?n 1)) ?a)) (subsume (MAdd ?a (MMul ?a (MNum ?n))))) :ruleset expr :name "combine-like-4") +(rule ((= ?__rw (MAdd (MAdd ?a (MVar ?v)) (MVar ?v)))) ((union ?__rw (MAdd ?a (MMul (MNum 2) (MVar ?v)))) (subsume (MAdd (MAdd ?a (MVar ?v)) (MVar ?v)))) :ruleset expr :name "combine-var-1") +(rule ((= ?__rw (MAdd (MAdd (MVar ?v) ?a) (MVar ?v)))) ((union ?__rw (MAdd ?a (MMul (MNum 2) (MVar ?v)))) (subsume (MAdd (MAdd (MVar ?v) ?a) (MVar ?v)))) :ruleset expr :name "combine-var-2") +(rule ((= ?__rw (MAdd (MAdd (MMul (MNum ?n) ?a) ?b) ?a))) ((union ?__rw (MAdd (MMul (MNum (+ ?n 1)) ?a) ?b)) (subsume (MAdd (MAdd (MMul (MNum ?n) ?a) ?b) ?a))) :ruleset expr :name "accum-1") +(rule ((= ?__rw (MAdd (MAdd ?b (MMul (MNum ?n) ?a)) ?a))) ((union ?__rw (MAdd ?b (MMul (MNum (+ ?n 1)) ?a))) (subsume (MAdd (MAdd ?b (MMul (MNum ?n) ?a)) ?a))) :ruleset expr :name "accum-2") +(rule ((= ?__rw (MReplace ?x ?y ?z)) (= ?x ?y)) ((union ?__rw ?z)) :ruleset expr :name "replace-match") +(rule ((= ?__rw (MReplace (MAdd ?a ?b) ?x ?y))) ((union ?__rw (MAdd (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MAdd") +(rule ((= ?__rw (MReplace (MSub ?a ?b) ?x ?y))) ((union ?__rw (MSub (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MSub") +(rule ((= ?__rw (MReplace (MMul ?a ?b) ?x ?y))) ((union ?__rw (MMul (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MMul") +(rule ((= ?__rw (MReplace (MDiv ?a ?b) ?x ?y))) ((union ?__rw (MDiv (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MDiv") +(rule ((= ?__rw (MReplace (MCeilDiv ?a ?b) ?x ?y))) ((union ?__rw (MCeilDiv (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MCeilDiv") +(rule ((= ?__rw (MReplace (MMod ?a ?b) ?x ?y))) ((union ?__rw (MMod (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MMod") +(rule ((= ?__rw (MReplace (MMin ?a ?b) ?x ?y))) ((union ?__rw (MMin (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MMin") +(rule ((= ?__rw (MReplace (MMax ?a ?b) ?x ?y))) ((union ?__rw (MMax (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MMax") +(rule ((= ?__rw (MReplace (MFloorTo ?a ?b) ?x ?y))) ((union ?__rw (MFloorTo (MReplace ?a ?x ?y) (MReplace ?b ?x ?y)))) :ruleset expr :name "replace-MFloorTo") +(rule ((= ?__rw (MReplace (MNum ?n) ?x ?y))) ((union ?__rw (MNum ?n))) :ruleset expr :name "replace-num") +(rule ((= ?__rw (MReplace (MVar ?z) ?find ?replace)) (!= ?find (MVar ?z))) ((union ?__rw (MVar ?z))) :ruleset expr :name "replace-var-miss") +(rule ((= ?__rw (MReplace (MIter) ?find ?replace)) (!= ?find (MIter))) ((union ?__rw (MIter))) :ruleset expr :name "replace-iter-miss") +(function len (EList) i64 :merge new) +(rule ((= ?e (ENil))) ((set (len ?e) 0)) :ruleset expr) +(rule ((= ?e (ECons ?expr ?list)) (= ?prev_len (len ?list))) ((set (len ?e) (+ ?prev_len 1))) :ruleset expr) +(function nth_from_end (EList i64) Expression :merge new) +(rule ((= ?e (ECons ?expr ?list)) (= ?list_len (len ?list))) ((set (nth_from_end ?e ?list_len) ?expr)) :ruleset expr) +(rule ((= ?e (ECons ?expr ?list)) (= ?other_nth (nth_from_end ?list ?n))) ((set (nth_from_end ?e ?n) ?other_nth)) :ruleset expr) +(function n_elements (EList) Expression :merge new) +(rule ((= ?e (ENil))) ((set (n_elements ?e) (MNum 1))) :ruleset expr) +(rule ((= ?e (ECons ?dim ?other)) (= ?other_elems (n_elements ?other))) ((set (n_elements ?e) (MMul ?dim ?other_elems))) :ruleset expr) +(rule ((= ?other (ECons ?other_dim ?other_other)) (= ?list (ECons ?d ?other)) (= ?e (RowMajor ?list)) (= ?n_elems (n_elements ?other))) ((union ?e (ECons (MMul ?n_elems (MIter)) (RowMajor ?other)))) :ruleset expr) +(rule ((= ?__rw (RowMajor (ECons ?dim (ENil))))) ((union ?__rw (ECons (MIter) (ENil)))) :ruleset expr :name "rowmajor-base") +(rule ((= ?__rw (MReplaceList (ECons ?expr ?list) ?from ?to))) ((union ?__rw (ECons (MReplace ?expr ?from ?to) (MReplaceList ?list ?from ?to)))) :ruleset expr :name "replace-list-cons") +(rule ((= ?e (ReplaceNthFromEnd (ECons ?expr ?list) ?to ?ind)) (= ?ind (len ?list))) ((union ?e (ECons ?to ?list))) :ruleset expr) +(rule ((= ?e (ReplaceNthFromEnd (ECons ?expr ?list) ?to ?ind)) (< ?ind (len ?list))) ((union ?e (ECons ?expr (ReplaceNthFromEnd ?list ?to ?ind)))) :ruleset expr) +(rule ((= ?e (RemoveNthFromEnd (ECons ?expr ?list) ?ind)) (= ?ind (len ?list))) ((union ?e ?list)) :ruleset expr) +(rule ((= ?e (RemoveNthFromEnd (ECons ?expr ?list) ?ind)) (< ?ind (len ?list))) ((union ?e (ECons ?expr (RemoveNthFromEnd ?list ?ind)))) :ruleset expr) + + + (datatype* + (IR + (OutputJoin IR IR) + (Op OpKind IList) + (ConsumedBuffer IR) + (Input i64 String DType) +(Output IR i64) +(LoopStart IR i64 i64 Expression DType) +(LoopEnd IR i64 i64 DType) + ) + (OpKind + (KernelAdd EList EList EList EList DType) +(KernelMul EList EList EList EList DType) +(KernelMod EList EList EList EList DType) +(KernelLessThan EList EList EList EList DType) +(KernelIota Expression Expression) +(KernelGather EList EList EList EList EList DType) +(KernelScatter EList EList EList EList EList EList DType) +(KernelSum EList Expression EList Expression EList DType) +(KernelMax EList Expression EList Expression EList DType) +(KernelExp2 EList EList EList DType) +(KernelLog2 EList EList EList DType) +(KernelSin EList EList EList DType) +(KernelRecip EList EList EList DType) +(KernelSqrt EList EList EList DType) +(KernelConstant f64) +(KernelCast Expression DType DType) +(KernelEmbed EList EList EList Expression) +(KernelMean EList Expression EList Expression EList DType) +(KernelBatchMatVec EList Expression EList Expression EList Expression EList DType) +(KernelBatchMatMul EList Expression EList Expression EList Expression EList DType) +(KernelScatterNoCopy EList EList EList EList EList EList DType) +(KernelSoftmax EList EList EList Expression Expression DType) +(KernelExp EList EList EList DType) +(KernelSigmoid EList EList EList DType) +(FusionStart EList EList DType) +(FusionEnd EList EList DType) +(FusedSin EList EList EList DType) +(FusedSqrt EList EList EList DType) +(FusedExp EList EList EList DType) +(FusedExp2 EList EList EList DType) +(FusedLog2 EList EList EList DType) +(FusedRecip EList EList EList DType) +(FusedAdd EList EList EList EList DType) +(FusedMul EList EList EList EList DType) +(cublaslt Expression Expression Expression String String String String String String Expression Expression Expression Expression Expression Expression Expression Expression Expression DType DType DType DType String String f64 f64 String) +(GLUMoE Expression Expression Expression Expression Expression Expression Expression Expression) +(ComputeAttnMask Expression Expression) +(FlashInferAttention Expression Expression Expression Expression Expression) +(CustomOpKind i64 DType) +(LoopInput i64 i64 DType) +(LoopInputStatic i64 i64 DType) +(LoopOutput i64 i64 DType) +(LoopOutputSelect i64 i64 i64 DType) +(Constant f64) +(Cast Expression DType) +(Iota Expression Expression) +(Exp2 EList EList EList) +(Log2 EList EList EList) +(Sin EList EList EList) +(Recip EList EList EList) +(Sqrt EList EList EList) +(Add EList EList EList EList) +(Mul EList EList EList EList) +(Mod EList EList EList EList) +(LessThan EList EList EList EList) +(Gather EList EList EList EList) +(Scatter EList EList EList EList EList) +(Sum EList Expression EList Expression EList) +(Max EList Expression EList Expression EList) +(Softmax EList EList EList Expression Expression) + ) + (IList + (ICons IR IList) + (INil) + ) + ) + (function dtype (IR) DType :merge new) + + +(ruleset base_cleanup) + + +(rule ((= ?m (MReplace ?a ?b ?c))) ((delete (MReplace ?a ?b ?c))) :ruleset base_cleanup) +(rule ((= ?m (MReplaceList ?a ?b ?c))) ((delete (MReplaceList ?a ?b ?c))) :ruleset base_cleanup) +(rule ((= ?m (ReplaceNthFromEnd ?a ?b ?c))) ((delete (ReplaceNthFromEnd ?a ?b ?c))) :ruleset base_cleanup) +(rule ((= ?m (RemoveNthFromEnd ?a ?b))) ((delete (RemoveNthFromEnd ?a ?b))) :ruleset base_cleanup) +(rule ((= ?m (RowMajor ?x))) ((delete (RowMajor ?x))) :ruleset base_cleanup) +(rule ((= ?m (len ?x))) ((delete (len ?x))) :ruleset base_cleanup) +(rule ((= ?m (nth_from_end ?x ?y))) ((delete (nth_from_end ?x ?y))) :ruleset base_cleanup) +(rule ((= ?m (n_elements ?x))) ((delete (n_elements ?x))) :ruleset base_cleanup) + +(rule ((= ?__rw0 (Op (Add ?v43_shape ?v43_a_strides ?v43_b_strides ?v43_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Add ?v43_shape ?v43_a_strides ?v43_b_strides ?v43_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelAdd ?v43_shape ?v43_a_strides ?v43_b_strides ?v43_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Mul ?v44_shape ?v44_a_strides ?v44_b_strides ?v44_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dt (dtype ?__first_inp))) ((union ?__rw0 (Op (KernelMul ?v44_shape ?v44_a_strides ?v44_b_strides ?v44_out_strides ?__dt) (ICons ?__first_inp ?__tail)))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Mod ?v45_shape ?v45_a_strides ?v45_b_strides ?v45_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Mod ?v45_shape ?v45_a_strides ?v45_b_strides ?v45_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelMod ?v45_shape ?v45_a_strides ?v45_b_strides ?v45_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (LessThan ?v46_shape ?v46_a_strides ?v46_b_strides ?v46_out_strides) (ICons ?__inp_a (ICons ?__inp_b (INil))))) (= ?__dt (dtype ?__inp_a))) ((union ?__rw0 (Op (KernelLessThan ?v46_shape ?v46_a_strides ?v46_b_strides ?v46_out_strides ?__dt) (ICons ?__inp_a (ICons ?__inp_b (INil)))))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Iota ?v47_expr ?v47_range) ?__inputs))) ((union ?__rw0 (Op (KernelIota ?v47_expr ?v47_range) ?__inputs)) (set (dtype (Op (KernelIota ?v47_expr ?v47_range) ?__inputs)) (Int))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Gather ?v48_index_shape ?v48_index_strides ?v48_data_shape ?v48_data_strides) (ICons ?__indexes (ICons ?__data ?__tail)))) (= ?__dt (dtype ?__data))) ((union ?__rw0 (Op (KernelGather ?v48_index_shape ?v48_index_strides ?v48_data_shape ?v48_data_strides (RowMajor ?v48_index_shape) ?__dt) (ICons ?__indexes (ICons ?__data (INil)))))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Scatter ?v49_dest_shape ?v49_dest_strides ?v49_index_shape ?v49_index_strides ?v49_src_strides) (ICons ?__dest (ICons ?__indexes (ICons ?__src (INil)))))) (= ?__dt (dtype ?__src))) ((union ?__rw0 (Op (KernelScatter ?v49_dest_shape ?v49_dest_strides ?v49_index_shape ?v49_index_strides ?v49_src_strides (RowMajor ?v49_dest_shape) ?__dt) (ICons ?__dest (ICons ?__indexes (ICons ?__src (INil))))))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Sum ?v50_shape ?v50_iters ?v50_strides ?v50_iter_stride ?v50_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Sum ?v50_shape ?v50_iters ?v50_strides ?v50_iter_stride ?v50_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelSum ?v50_shape ?v50_iters ?v50_strides ?v50_iter_stride ?v50_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Max ?v51_shape ?v51_iters ?v51_strides ?v51_iter_stride ?v51_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Max ?v51_shape ?v51_iters ?v51_strides ?v51_iter_stride ?v51_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelMax ?v51_shape ?v51_iters ?v51_strides ?v51_iter_stride ?v51_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Exp2 ?v52_shape ?v52_strides ?v52_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Exp2 ?v52_shape ?v52_strides ?v52_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelExp2 ?v52_shape ?v52_strides ?v52_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Log2 ?v53_shape ?v53_strides ?v53_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Log2 ?v53_shape ?v53_strides ?v53_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelLog2 ?v53_shape ?v53_strides ?v53_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Sin ?v54_shape ?v54_strides ?v54_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Sin ?v54_shape ?v54_strides ?v54_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelSin ?v54_shape ?v54_strides ?v54_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Recip ?v55_shape ?v55_strides ?v55_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Recip ?v55_shape ?v55_strides ?v55_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelRecip ?v55_shape ?v55_strides ?v55_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Sqrt ?v56_shape ?v56_strides ?v56_out_strides) ?__inputs)) (= ?__dt (dtype (Op (Sqrt ?v56_shape ?v56_strides ?v56_out_strides) ?__inputs)))) ((union ?__rw0 (Op (KernelSqrt ?v56_shape ?v56_strides ?v56_out_strides ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Constant ?v57_value) ?__inputs))) ((union ?__rw0 (Op (KernelConstant ?v57_value) ?__inputs)) (set (dtype (Op (KernelConstant ?v57_value) ?__inputs)) (F32))) :ruleset kernel_lower) +(rule ((= ?__rw0 (Op (Cast ?v58_size ?v58_dtype) (ICons ?__inp (INil)))) (= ?__in_dt (dtype ?__inp))) ((union ?__rw0 (Op (KernelCast ?v58_size ?__in_dt ?v58_dtype) (ICons ?__inp (INil))))) :ruleset kernel_lower) +(rule + ( + (= ?gather (Op (Gather ?idx_shape ?idx_stride ?embed_shape ?embed_stride) (ICons ?indices (ICons ?embed_table (INil))))) + (= (len ?idx_shape) 2) + (= ?indices (Op (Add ?add_shape ?mul_stride ?iota_stride ?add_out_stride) (ICons ?mul_result (ICons ?iota_result (INil))))) + (= ?mul_result (Op (Mul ?mul_shape ?token_cast_stride ?mul_const_stride ?mul_out_stride) (ICons ?token_ids_cast (ICons ?mul_const (INil))))) + (= ?token_ids_cast (Op (Cast ?cast_size ?cast_dtype) (ICons ?token_ids (INil)))) + (= ?embed_dim (nth_from_end ?embed_shape 0)) + (= ?batch_shape (RemoveNthFromEnd ?idx_shape 0)) + (= ?out_stride_batch (RemoveNthFromEnd ?add_out_stride 0)) + ) + ( + (let ?ke (Op (KernelEmbed ?batch_shape ?token_cast_stride ?out_stride_batch ?embed_dim) (ICons ?token_ids_cast (ICons ?embed_table (INil))))) + (union ?gather ?ke) + (set (dtype ?ke) (F32)) + ) + :ruleset kernel_specialize + :name "kernel embed with cast mul" + ) +(rule + ( + (= ?gather (Op (Gather ?idx_shape ?idx_stride ?embed_shape ?embed_stride) (ICons ?indices (ICons ?embed_table (INil))))) + (= (len ?idx_shape) 2) + (= ?indices (Op (Add ?add_shape ?iota_stride ?mul_stride ?add_out_stride) (ICons ?iota_result (ICons ?mul_result (INil))))) + (= ?mul_result (Op (Mul ?mul_shape ?token_cast_stride ?mul_const_stride ?mul_out_stride) (ICons ?token_ids_cast (ICons ?mul_const (INil))))) + (= ?token_ids_cast (Op (Cast ?cast_size ?cast_dtype) (ICons ?token_ids (INil)))) + (= ?embed_dim (nth_from_end ?embed_shape 0)) + (= ?batch_shape (RemoveNthFromEnd ?idx_shape 0)) + (= ?out_stride_batch (RemoveNthFromEnd ?add_out_stride 0)) + ) + ( + (let ?ke (Op (KernelEmbed ?batch_shape ?token_cast_stride ?out_stride_batch ?embed_dim) (ICons ?token_ids_cast (ICons ?embed_table (INil))))) + (union ?gather ?ke) + (set (dtype ?ke) (F32)) + ) + :ruleset kernel_specialize + :name "kernel embed with cast mul reversed" + ) +(rule + ( + (= ?gather (Op (Gather ?idx_shape ?idx_stride ?embed_shape ?embed_stride) (ICons ?indices (ICons ?embed_table (INil))))) + (= (len ?idx_shape) 2) + (= ?indices (Op (Add ?add_shape ?mul_stride ?iota_stride ?add_out_stride) (ICons ?mul_result (ICons ?iota_result (INil))))) + (= ?mul_result (Op (Mul ?mul_shape ?token_stride ?mul_const_stride ?mul_out_stride) (ICons ?token_ids (ICons ?mul_const (INil))))) + (= ?embed_dim (nth_from_end ?embed_shape 0)) + (= ?batch_shape (RemoveNthFromEnd ?idx_shape 0)) + (= ?out_stride_batch (RemoveNthFromEnd ?add_out_stride 0)) + ) + ( + (let ?ke (Op (KernelEmbed ?batch_shape ?token_stride ?out_stride_batch ?embed_dim) (ICons ?token_ids (ICons ?embed_table (INil))))) + (union ?gather ?ke) + (set (dtype ?ke) (F32)) + ) + :ruleset kernel_specialize + :name "kernel embed with mul" + ) +(rule + ( + (= ?gather (Op (Gather ?idx_shape ?idx_stride ?embed_shape ?embed_stride) (ICons ?indices (ICons ?embed_table (INil))))) + (= (len ?idx_shape) 2) + (= ?indices (Op (Add ?add_shape ?iota_stride ?mul_stride ?add_out_stride) (ICons ?iota_result (ICons ?mul_result (INil))))) + (= ?mul_result (Op (Mul ?mul_shape ?token_stride ?mul_const_stride ?mul_out_stride) (ICons ?token_ids (ICons ?mul_const (INil))))) + (= ?embed_dim (nth_from_end ?embed_shape 0)) + (= ?batch_shape (RemoveNthFromEnd ?idx_shape 0)) + (= ?out_stride_batch (RemoveNthFromEnd ?add_out_stride 0)) + ) + ( + (let ?ke (Op (KernelEmbed ?batch_shape ?token_stride ?out_stride_batch ?embed_dim) (ICons ?token_ids (ICons ?embed_table (INil))))) + (union ?gather ?ke) + (set (dtype ?ke) (F32)) + ) + :ruleset kernel_specialize + :name "kernel embed with mul reversed" + ) +(rule + ( + ; Match Mul node (broadcast multiply) + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Output shape must have 3+ dimensions (batched) + (= ?out_shape (ECons ?batch_or_d0 (ECons ?d1 (ECons ?d2 ?rest)))) + + ; k_stride must be contiguous + (= ?k_stride (MIter)) + + ; Get A's k-dimension stride (second from end in Mul's a_stride) + (= ?a_k_stride (nth_from_end ?a_stride 1)) + + ; Get B's k-dimension stride (second from end in Mul's b_stride) + (= ?b_k_stride (nth_from_end ?b_stride 1)) + + ; A's k stride must be contiguous (row-major A) + (= ?a_k_stride (MIter)) + + ; B's k stride must be contiguous (col-major B) + (= ?b_k_stride (MIter)) + + ; Must be F32 + (= (F32) (dtype ?a)) + (= (F32) (dtype ?b)) + ) + ( + ; Remove the k-dimension from A strides for the kernel + (let ?a_kern_stride (RemoveNthFromEnd ?a_stride 1)) + ; Remove the k-dimension from B strides + (let ?b_kern_stride (RemoveNthFromEnd ?b_stride 1)) + + (let ?bmv (Op (KernelBatchMatVec + ?out_shape ?k + ?a_kern_stride ?a_k_stride + ?b_kern_stride ?b_k_stride + ?sum_out_stride (F32)) (ICons ?a (ICons ?b (INil))))) + (union ?sum ?bmv) + (set (dtype ?bmv) (F32)) + ) + :ruleset matmul_backend + :name "batch mat-vec" + ) +(rule + ( + ; Match Mul node (broadcast multiply) + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Output shape must have 3+ dimensions (batched) + (= ?out_shape (ECons ?batch_or_d0 (ECons ?d1 (ECons ?d2 ?rest)))) + + ; k_stride must be contiguous in the Sum output + (= ?k_stride (MIter)) + + ; K must be > 1 (K=1 is a degenerate outer product, not a real matmul) + (!= ?k (MNum 1)) + + ; Get A's and B's k-dimension strides (no contiguity requirement) + (= ?a_k_stride (nth_from_end ?a_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 1)) + + ; One of A's non-k strides must be 0 (broadcast along n) + (= (MNum 0) (nth_from_end ?a_stride 0)) + + ; One of B's non-k strides must be 0 (broadcast along m) + (= (MNum 0) (nth_from_end ?b_stride 2)) + + ; Must be F32 + (= (F32) (dtype ?a)) + (= (F32) (dtype ?b)) + ) + ( + (let ?a_kern_stride (RemoveNthFromEnd ?a_stride 1)) + (let ?b_kern_stride (RemoveNthFromEnd ?b_stride 1)) + + (let ?bmm (Op (KernelBatchMatMul + ?out_shape ?k + ?a_kern_stride ?a_k_stride + ?b_kern_stride ?b_k_stride + ?sum_out_stride (F32)) (ICons ?a (ICons ?b (INil))))) + (union ?sum ?bmm) + (set (dtype ?bmm) (F32)) + ) + :ruleset matmul_backend + :name "batch matmul" + ) +(relation consumed_buffer_ilist_contains (IList IR)) +(rule + ((= ?list (ICons ?head ?tail))) + ((consumed_buffer_ilist_contains ?list ?head)) + :ruleset cleanup + :name "consumed-buffer-ilist-contains-head" + ) +(rule + ((= ?list (ICons ?head ?tail)) + (consumed_buffer_ilist_contains ?tail ?item)) + ((consumed_buffer_ilist_contains ?list ?item)) + :ruleset cleanup + :name "consumed-buffer-ilist-contains-tail" + ) +(rule + ( + (= ?scatter (Op (KernelScatter ?ds ?dst ?is ?istr ?ss ?os ?dt) + (ICons ?dest (ICons ?indexes (ICons ?src (INil)))))) + (= ?dst ?os) + (= ?dty (dtype ?src)) + ) + ( + (let ?consumed (ConsumedBuffer ?dest)) + (let ?nocopy (Op (KernelScatterNoCopy ?ds ?dst ?is ?istr ?ss ?os ?dt) + (ICons ?consumed (ICons ?indexes (ICons ?src (INil)))))) + (union ?scatter ?nocopy) + (set (dtype ?nocopy) ?dty) + ) + :ruleset buffer_reuse + :name "scatter to scatter-no-copy" + ) +(rule + ((= ?cb (ConsumedBuffer ?a)) + (= ?dt (dtype ?a))) + ((set (dtype ?cb) ?dt)) + :ruleset dtype_prop + :name "consumed-buffer-dtype" + ) +(rule + ((= ?cb (ConsumedBuffer ?a)) + (= ?op1 (Op ?k1 ?ilist1)) + (consumed_buffer_ilist_contains ?ilist1 ?cb) + (= ?op2 (Op ?k2 ?ilist2)) + (!= ?op1 ?op2) + (consumed_buffer_ilist_contains ?ilist2 ?a)) + ((delete (ConsumedBuffer ?a))) + :ruleset cleanup + :name "consumed-buffer-cleanup-shared-op-use" + ) +(rule + ((= ?cb (ConsumedBuffer ?dest)) + (= ?scatter (Op (KernelScatter ?ds ?dst ?is ?istr ?ss ?os ?dt) + (ICons ?dest (ICons ?indexes (ICons ?src (INil)))))) + (= ?nocopy (Op (KernelScatterNoCopy ?ds ?dst ?is ?istr ?ss ?os ?dt) + (ICons ?cb (ICons ?indexes (ICons ?src (INil))))))) + ((delete (Op (KernelScatter ?ds ?dst ?is ?istr ?ss ?os ?dt) + (ICons ?dest (ICons ?indexes (ICons ?src (INil))))))) + :ruleset post_cleanup + :name "scatter-no-copy-dominates-valid-consumed-buffer" + ) +(rule + ((= ?cb (ConsumedBuffer ?a))) + ((union ?cb ?a) + (delete (ConsumedBuffer ?a))) + :ruleset base_cleanup + :name "consumed-buffer-resolve" + ) +(rule ((= ?__rw0 (Op (Softmax ?v59_shape ?v59_in_strides ?v59_out_strides ?v59_reduce_dim ?v59_reduce_stride) ?__inputs)) (= ?__dt (dtype (Op (Softmax ?v59_shape ?v59_in_strides ?v59_out_strides ?v59_reduce_dim ?v59_reduce_stride) ?__inputs)))) ((union ?__rw0 (Op (KernelSoftmax ?v59_shape ?v59_in_strides ?v59_out_strides ?v59_reduce_dim ?v59_reduce_stride ?__dt) ?__inputs))) :ruleset kernel_lower) +(rule + ( + (= ?sm (Op (Softmax ?shape ?in_strides ?out_strides ?reduce_dim ?reduce_stride) ?inputs)) + ) + ( + (let ?ksm (Op (KernelSoftmax ?shape ?in_strides ?out_strides ?reduce_dim ?reduce_stride (F32)) ?inputs)) + (union ?sm ?ksm) + (set (dtype ?ksm) (F32)) + ) + :ruleset kernel_lower + :name "softmax-to-kernel-f32" + ) +(rule + ( + (= ?mul (Op (Mul ?shape ?x_stride ?const_stride ?inter_stride) (ICons ?x (ICons ?exp_const (INil))))) + (= ?exp2 (Op (Exp2 ?shape ?inter_stride ?out_stride) (ICons ?mul (INil)))) + (= ?dt (dtype ?x)) + (= ?cv (Op (Constant ?val) (INil))) + (= ?exp_const ?cv) + (> ?val 1.44) + (< ?val 1.45) + ) + ( + (let ?kexp (Op (KernelExp ?shape ?x_stride ?out_stride ?dt) (ICons ?x (INil)))) + (union ?exp2 ?kexp) + (set (dtype ?kexp) ?dt) + ) + :ruleset direct_kernel + :name "direct-exp-fusion" + ) +(datatype* + (KernelSigmoidScaledState + (MkKernelSigmoidScaledState IR EList EList DType) + ) + ) + (function kernel_sigmoid_scaled (IR) KernelSigmoidScaledState :merge new) + + (rule + ( + (= ?neg1 (Op (Constant ?nv) (INil))) + (< ?nv -0.99) + (> ?nv -1.01) + (= ?neg_x (Op (Mul ?shape ?x_stride ?neg_stride ?neg_out_stride) (ICons ?x (ICons ?neg1 (INil))))) + (= ?log2e (Op (Constant ?lv) (INil))) + (> ?lv 1.44) + (< ?lv 1.45) + (= ?scaled (Op (Mul ?shape ?neg_out_stride ?log2e_stride ?scaled_stride) (ICons ?neg_x (ICons ?log2e (INil))))) + (= ?dt (dtype ?x)) + ) + ( + (set (kernel_sigmoid_scaled ?scaled) + (MkKernelSigmoidScaledState ?x ?shape ?x_stride ?dt)) + ) + :ruleset direct_kernel + :name "direct-sigmoid-scaled-marker" + ) + + (rule + ( + (= ?scaled_state (kernel_sigmoid_scaled ?scaled)) + (= ?scaled_state (MkKernelSigmoidScaledState ?x ?shape ?x_stride ?dt)) + (= ?exp2 (Op (Exp2 ?shape ?scaled_stride ?exp_stride) (ICons ?scaled (INil)))) + (= ?one (Op (Constant ?ov) (INil))) + (> ?ov 0.99) + (< ?ov 1.01) + (= ?plus_one (Op (Add ?shape ?exp_stride ?one_stride ?add_stride) (ICons ?exp2 (ICons ?one (INil))))) + (= ?sig_out (Op (Recip ?shape ?add_stride ?out_stride) (ICons ?plus_one (INil)))) + ) + ( + (let ?ksig (Op (KernelSigmoid ?shape ?x_stride ?out_stride ?dt) (ICons ?x (INil)))) + (union ?sig_out ?ksig) + (set (dtype ?ksig) ?dt) + ) + :ruleset direct_kernel + :name "direct-sigmoid-fusion" + ) +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelSin") +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelExp") +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelExp2") +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelLog2") +(rule ( + (= ?u1 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSin-KernelRecip") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelSin") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelExp") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelExp2") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelLog2") +(rule ( + (= ?u1 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelSqrt-KernelRecip") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelSin") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelExp") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelExp2") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelLog2") +(rule ( + (= ?u1 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp-KernelRecip") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelSin") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelExp") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelExp2") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelLog2") +(rule ( + (= ?u1 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelExp2-KernelRecip") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelSin") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelExp") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelExp2") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelLog2") +(rule ( + (= ?u1 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelLog2-KernelRecip") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelSin") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelSqrt") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelExp") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelExp2") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelLog2") +(rule ( + (= ?u1 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?x (INil)))) + (= ?u2 (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?u1 (INil)))) + ) ( + (let ?fs (Op (FusionStart ?shape ?s ?dt) (ICons ?x (INil)))) + (let ?fu1 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fs (INil)))) + (let ?fu2 (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?fu1 (INil)))) + (let ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu2 (INil)))) + (union ?u2 ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-U-KernelRecip-KernelRecip") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelSin ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedSin ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelSin") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelSqrt ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedSqrt ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelSqrt") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelExp ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedExp ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelExp") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelExp2 ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedExp2 ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelExp2") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelLog2 ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedLog2 ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelLog2") +(rule ( + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelRecip ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedRecip ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Add-KernelRecip") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelSin ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedSin ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelSin") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelSqrt ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedSqrt ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelSqrt") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelExp ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedExp ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelExp") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelExp2 ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedExp2 ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelExp2") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelLog2 ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedLog2 ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelLog2") +(rule ( + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?u (Op (KernelRecip ?shape ?o_s ?o_s ?dt) (ICons ?bin (INil)))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fu (Op (FusedRecip ?shape ?o_s ?o_s ?dt) (ICons ?fbin (INil)))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fu (INil)))) + (union ?u ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-U-Mul-KernelRecip") +(rule ( + (= ?u (Op (KernelSin ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSin ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelSin-Add") +(rule ( + (= ?u (Op (KernelSin ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSin ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelSin-Add") +(rule ( + (= ?u (Op (KernelSin ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSin ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelSin-Mul") +(rule ( + (= ?u (Op (KernelSin ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSin ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelSin-Mul") +(rule ( + (= ?u (Op (KernelSqrt ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSqrt ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelSqrt-Add") +(rule ( + (= ?u (Op (KernelSqrt ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSqrt ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelSqrt-Add") +(rule ( + (= ?u (Op (KernelSqrt ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSqrt ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelSqrt-Mul") +(rule ( + (= ?u (Op (KernelSqrt ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedSqrt ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelSqrt-Mul") +(rule ( + (= ?u (Op (KernelExp ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelExp-Add") +(rule ( + (= ?u (Op (KernelExp ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelExp-Add") +(rule ( + (= ?u (Op (KernelExp ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelExp-Mul") +(rule ( + (= ?u (Op (KernelExp ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelExp-Mul") +(rule ( + (= ?u (Op (KernelExp2 ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelExp2-Add") +(rule ( + (= ?u (Op (KernelExp2 ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelExp2-Add") +(rule ( + (= ?u (Op (KernelExp2 ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelExp2-Mul") +(rule ( + (= ?u (Op (KernelExp2 ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedExp2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelExp2-Mul") +(rule ( + (= ?u (Op (KernelLog2 ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedLog2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelLog2-Add") +(rule ( + (= ?u (Op (KernelLog2 ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedLog2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelLog2-Add") +(rule ( + (= ?u (Op (KernelLog2 ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedLog2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelLog2-Mul") +(rule ( + (= ?u (Op (KernelLog2 ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedLog2 ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelLog2-Mul") +(rule ( + (= ?u (Op (KernelRecip ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedRecip ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelRecip-Add") +(rule ( + (= ?u (Op (KernelRecip ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedRecip ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelRecip-Add") +(rule ( + (= ?u (Op (KernelRecip ?shape ?u_s ?u_s ?dt) (ICons ?a (INil)))) + (= ?bin (Op (KernelMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?u (ICons ?b (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?u_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedRecip ?shape ?u_s ?u_s ?dt) (ICons ?fs_a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?u_s ?b_s ?o_s ?dt) + (ICons ?fu (ICons ?fs_b (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-lhs-KernelRecip-Mul") +(rule ( + (= ?u (Op (KernelRecip ?shape ?u_s ?u_s ?dt) (ICons ?b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?a (ICons ?u (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?u_s ?dt) (ICons ?b (INil)))) + (let ?fu (Op (FusedRecip ?shape ?u_s ?u_s ?dt) (ICons ?fs_b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?u_s ?o_s ?dt) + (ICons ?fs_a (ICons ?fu (INil))))) + (let ?fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?fe) + ) :ruleset fusion_pair :name "pair-fuse-U-B-rhs-KernelRecip-Mul") +(rule ( + (= ?bi (Op (KernelAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelAdd ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?bi (ICons ?c (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedAdd ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?fbi (ICons ?fs_c (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-lhs-Add-Add") +(rule ( + (= ?bi (Op (KernelAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelAdd ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?c (ICons ?bi (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedAdd ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?fs_c (ICons ?fbi (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-rhs-Add-Add") +(rule ( + (= ?bi (Op (KernelAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelMul ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?bi (ICons ?c (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedMul ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?fbi (ICons ?fs_c (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-lhs-Add-Mul") +(rule ( + (= ?bi (Op (KernelAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelMul ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?c (ICons ?bi (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedAdd ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedMul ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?fs_c (ICons ?fbi (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-rhs-Add-Mul") +(rule ( + (= ?bi (Op (KernelMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelAdd ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?bi (ICons ?c (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedAdd ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?fbi (ICons ?fs_c (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-lhs-Mul-Add") +(rule ( + (= ?bi (Op (KernelMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelAdd ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?c (ICons ?bi (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedAdd ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?fs_c (ICons ?fbi (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-rhs-Mul-Add") +(rule ( + (= ?bi (Op (KernelMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelMul ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?bi (ICons ?c (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedMul ?shape ?oi_s ?co_s ?oo_s ?dt) + (ICons ?fbi (ICons ?fs_c (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-lhs-Mul-Mul") +(rule ( + (= ?bi (Op (KernelMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?a (ICons ?b (INil))))) + (= ?bo (Op (KernelMul ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?c (ICons ?bi (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?ai_s ?dt) (ICons ?a (INil)))) + (let ?fs_b (Op (FusionStart ?shape ?bi_s ?dt) (ICons ?b (INil)))) + (let ?fs_c (Op (FusionStart ?shape ?co_s ?dt) (ICons ?c (INil)))) + (let ?fbi (Op (FusedMul ?shape ?ai_s ?bi_s ?oi_s ?dt) + (ICons ?fs_a (ICons ?fs_b (INil))))) + (let ?fbo (Op (FusedMul ?shape ?co_s ?oi_s ?oo_s ?dt) + (ICons ?fs_c (ICons ?fbi (INil))))) + (let ?fe (Op (FusionEnd ?shape ?oo_s ?dt) (ICons ?fbo (INil)))) + (union ?bo ?fe) + ) :ruleset fusion_pair :name "pair-fuse-B-B-rhs-Mul-Mul") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelSin ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedSin ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelSin") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelSqrt ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedSqrt ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelSqrt") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelExp ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedExp ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelExp") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelExp2 ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedExp2 ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelExp2") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelLog2 ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedLog2 ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelLog2") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?inner (INil)))) + (= ?u (Op (KernelRecip ?shape ?s ?s ?dt) (ICons ?fe (INil)))) + ) ( + (let ?fu (Op (FusedRecip ?shape ?s ?s ?dt) (ICons ?inner (INil)))) + (let ?new_fe (Op (FusionEnd ?shape ?s ?dt) (ICons ?fu (INil)))) + (union ?u ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-U-KernelRecip") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fe (ICons ?b (INil))))) + ) ( + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?inner_a (ICons ?fs_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-B-lhs-Add") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?fe (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?inner_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-B-rhs-Add") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fe (ICons ?b (INil))))) + ) ( + (let ?fs_b (Op (FusionStart ?shape ?b_s ?dt) (ICons ?b (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?inner_a (ICons ?fs_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-B-lhs-Mul") +(rule ( + (= ?fe (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?a (ICons ?fe (INil))))) + ) ( + (let ?fs_a (Op (FusionStart ?shape ?a_s ?dt) (ICons ?a (INil)))) + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fs_a (ICons ?inner_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + ) :ruleset fusion_grow :name "grow-FE-B-rhs-Mul") +(rule ( + (= ?fe_a (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (= ?fe_b (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + (= ?bin (Op (KernelAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fe_a (ICons ?fe_b (INil))))) + ) ( + (let ?fbin (Op (FusedAdd ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?inner_a (ICons ?inner_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + (subsume (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (subsume (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + ) :ruleset fusion_merge :name "merge-FE-FE-Add") +(rule ( + (= ?fe_a (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (= ?fe_b (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + (= ?bin (Op (KernelMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?fe_a (ICons ?fe_b (INil))))) + ) ( + (let ?fbin (Op (FusedMul ?shape ?a_s ?b_s ?o_s ?dt) + (ICons ?inner_a (ICons ?inner_b (INil))))) + (let ?new_fe (Op (FusionEnd ?shape ?o_s ?dt) (ICons ?fbin (INil)))) + (union ?bin ?new_fe) + (subsume (Op (FusionEnd ?shape ?a_s ?dt) (ICons ?inner_a (INil)))) + (subsume (Op (FusionEnd ?shape ?b_s ?dt) (ICons ?inner_b (INil)))) + ) :ruleset fusion_merge :name "merge-FE-FE-Mul") +(relation cublaslt_base_dtype (DType)) + (cublaslt_base_dtype (F32)) + (cublaslt_base_dtype (F16)) + (cublaslt_base_dtype (Bf16)) + (cublaslt_base_dtype (TF32)) +; Row-major matmul: C[m,n] = A[m,k] × B[k,n] +; A[m,k] row-major → expand to [m, n, k] with strides [k, 0, MIter] +; B[k,n] row-major → permute to [n,k] then expand to [m, n, k] with strides [0, MIter, n] +; +; Row-major viewed as column-major (swap trick): +; Row-major A[m,k] ≡ column-major [k,m] with lda=k +; Row-major B[k,n] ≡ column-major [n,k] with ldb=n +; Row-major C[m,n] ≡ column-major [n,m] with ldc=n +; +; cuBLAS computes: C_col[n,m] = B_col[n,k] × A_col[k,m] +; cublasSgemm(OP_N, OP_N, n, m, k, α, B, n, A, k, β, C, n) +(rule + ( + ; Match Mul node + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Match exactly 2D output shape + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + ; Match exactly 3D strides [m, n, k] + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + + ; Assert contiguous k stride on output (required for reduction) + (= ?k_stride (MIter)) + + ; Assert A has strides [k*MIter, 0, MIter] (row-major A[m,k] broadcast to [m,n,k]) + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + ; Assert B has strides [0, MIter, n*MIter] (row-major B[k,n] permuted to [n,k] then broadcast to [m,n,k]) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MIter)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; For row-major C = A × B with cuBLAS (column-major): + ; cublasSgemm(OP_N, OP_N, n, m, k, α, B, n, A, k, β, C, n) + (let ?sgemm (Op (cublaslt + ?n ; cuBLAS m = our n (swapped) + ?m ; cuBLAS n = our m (swapped) + ?k ; k unchanged + "N" ; transa = No transpose + "N" ; transb = No transpose + "COL" "COL" "COL" "COL" ; A/B/C/D matrix orders + ?b_k_stride ; lda = B's row stride (resolves to n after z→1) + ?a_m_stride ; ldb = A's row stride (resolves to k after z→1) + ?n ; ldc = n (row-major C[m,n] viewed as col-major [n,m]) + ?n ; ldd = ldc for current row-major output rewrites + (MNum 1) ; batch_count = 1 + (MNum 0) ; stride_a = 0 + (MNum 0) ; stride_b = 0 + (MNum 0) ; stride_c = 0 + (MNum 0) ; stride_d = 0 + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") ; type tuple, alpha, beta + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-major x row-major" +) + +; Batched Row-major × Row-major: C[batch,m,n] = A[batch,m,k] × B[batch,k,n] +; In broadcast [batch, m, n, k] space: +; A row-major per batch: a_k_stride=MIter, a_n_stride=0 +; B row-major per batch: b_n_stride=MIter, b_m_stride=0 +; Leading dimensions may differ from k/n when batch slices are non-contiguous. +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Output shape: [batch, m, n] + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + ; A strides in [batch, m, n, k] + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + ; B strides in [batch, m, n, k] + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + ; A row-major: k=MIter, n=0, m_stride=k*MIter + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + ; B row-major: n=MIter, m=0, k_stride=n*MIter + (= ?b_n_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_k_stride (MMul (MIter) ?n)) + + ; Uniform batch strides (contiguous per batch, no GQA-style repetition) + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?k ?b_k_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; cuBLAS swap: C^T[n,m] = B^T[n,k] × A^T[k,m] per batch + ; cublas(OP_N, OP_N, n, m, k, B, lda=b_k_stride, A, ldb=a_m_stride, C, ldc=n) + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "N" "N" + "COL" "COL" "COL" "COL" + ?b_k_stride ; lda (cuBLAS A = our B, row stride) + ?a_m_stride ; ldb (cuBLAS B = our A, row stride) + ?n ; ldc (contiguous output per batch) + ?n ; ldd + ?batch ; batch_count + ?b_batch_stride ; stride_a (cuBLAS A = our B) + ?a_batch_stride ; stride_b (cuBLAS B = our A) + (MMul ?m ?n) ; stride_c + (MMul ?m ?n) ; stride_d + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt batched row-major × row-major" +) + +; Row-major × Column-major matmul: C[m,n] = A[m,k] × B[k,n] +; A[m,k] row-major → expand to [m, n, k] with strides [k, 0, MIter] +; B[k,n] column-major → expand to [m, n, k] with strides [0, k, MIter] +; +; Row-major viewed as column-major (swap trick): +; Row-major A[m,k] ≡ column-major A^T[k,m] with lda=k +; Column-major B[k,n] is already column-major with ldb=k +; Row-major C[m,n] ≡ column-major C^T[n,m] with ldc=n +; +; C^T[n,m] = (A × B)^T = B^T[n,k] × A^T[k,m] +; cuBLAS: cublasSgemm(OP_T, OP_N, n, m, k, α, B, k, A, k, β, C, n) +(rule + ( + ; Match Mul node + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Match exactly 2D output shape + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + ; Match exactly 3D strides [m, n, k] + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + + ; Assert contiguous k stride on output (required for reduction) + (= ?k_stride (MIter)) + + ; Assert A has strides [k*MIter, 0, MIter] (row-major A[m,k] broadcast to [m,n,k]) + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + ; Assert B has strides [0, k*MIter, MIter] (column-major B[k,n] broadcast to [m,n,k]) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; For row-major A × column-major B with cuBLAS: + ; C^T = B^T × A^T → cublasSgemm(OP_T, OP_N, n, m, k, α, B, k, A, k, β, C, n) + (let ?sgemm (Op (cublaslt + ?n ; cuBLAS m = our n (swapped) + ?m ; cuBLAS n = our m (swapped) + ?k ; k unchanged + "T" ; transa = Transpose (B is column-major, need B^T) + "N" ; transb = No transpose + "COL" "COL" "COL" "COL" ; A/B/C/D matrix orders + ?b_n_stride ; lda = B's column stride (resolves to k after z→1) + ?a_m_stride ; ldb = A's row stride (resolves to k after z→1) + ?n ; ldc = n (row-major C[m,n] viewed as col-major [n,m]) + ?n ; ldd = ldc for current row-major output rewrites + (MNum 1) ; batch_count = 1 + (MNum 0) ; stride_a = 0 + (MNum 0) ; stride_b = 0 + (MNum 0) ; stride_c = 0 + (MNum 0) ; stride_d = 0 + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") ; type tuple, alpha, beta + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-major × column-major" +) + +; Batched Row-major × Column-major: C[batch,m,n] = A[batch,m,k] × B[batch,k,n] +; A row-major per batch: a_k_stride=MIter, a_n_stride=0 +; B column-major per batch: b_k_stride=MIter, b_m_stride=0 +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + ; A row-major: k=MIter, n=0, m_stride=k*MIter + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + ; B column-major: k=MIter, m=0, n_stride=k*MIter + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + ; Uniform batch strides (contiguous per batch) + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; cuBLAS: cublas(OP_T, OP_N, n, m, k, B, lda=b_n_stride, A, ldb=a_m_stride, C, ldc=n) + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride ; lda (cuBLAS A = our B, column stride) + ?a_m_stride ; ldb (cuBLAS B = our A, row stride) + ?n ; ldc + ?n ; ldd + ?batch + ?b_batch_stride ; stride_a (cuBLAS A = our B) + ?a_batch_stride ; stride_b (cuBLAS B = our A) + (MMul ?m ?n) ; stride_c + (MMul ?m ?n) ; stride_d + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt batched row-major × column-major" +) + +; Column-major × Row-major matmul: C[m,n] = A[m,k] × B[k,n] +; A[m,k] column-major → expand to [m, n, k] with strides [MIter, 0, m] +; B[k,n] row-major → permute to [n,k] then expand to [m, n, k] with strides [0, MIter, n] +; +; Row-major viewed as column-major (swap trick): +; Column-major A[m,k] is already column-major with lda=m +; Row-major B[k,n] ≡ column-major B^T[n,k] with ldb=n +; Row-major C[m,n] ≡ column-major C^T[n,m] with ldc=n +; +; C^T[n,m] = (A × B)^T = B^T[n,k] × A^T[k,m] +; cuBLAS: cublasSgemm(OP_N, OP_T, n, m, k, α, B, n, A, m, β, C, n) +(rule + ( + ; Match Mul node + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Match exactly 2D output shape + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + ; Match exactly 3D strides [m, n, k] + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + + ; Assert contiguous k stride on output (required for reduction) + (= ?k_stride (MIter)) + + ; Assert A has strides [MIter, 0, m*MIter] (column-major A[m,k] broadcast to [m,n,k]) + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + ; Assert B has strides [0, MIter, n*MIter] (row-major B[k,n] permuted to [n,k] then broadcast to [m,n,k]) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MIter)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; For column-major A × row-major B with cuBLAS: + ; C^T = B^T × A^T → cublasSgemm(OP_N, OP_T, n, m, k, α, B, n, A, m, β, C, n) + (let ?sgemm (Op (cublaslt + ?n ; cuBLAS m = our n (swapped) + ?m ; cuBLAS n = our m (swapped) + ?k ; k unchanged + "N" ; transa = No transpose (B is row-major, viewed as col-major [n,k]) + "T" ; transb = Transpose (A is column-major [m,k], need A^T[k,m]) + "COL" "COL" "COL" "COL" ; A/B/C/D matrix orders + ?b_k_stride ; lda = B's row stride (resolves to n after z→1) + ?a_k_stride ; ldb = A's column stride (resolves to m after z→1) + ?n ; ldc = n (row-major C[m,n] viewed as col-major [n,m]) + ?n ; ldd = ldc for current row-major output rewrites + (MNum 1) ; batch_count = 1 + (MNum 0) ; stride_a = 0 + (MNum 0) ; stride_b = 0 + (MNum 0) ; stride_c = 0 + (MNum 0) ; stride_d = 0 + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") ; type tuple, alpha, beta + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt column-major × row-major" +) + +; Batched Column-major × Row-major: C[batch,m,n] = A[batch,m,k] × B[batch,k,n] +; A column-major per batch: a_m_stride=MIter, a_n_stride=0 +; B row-major per batch: b_n_stride=MIter, b_m_stride=0 +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + ; A column-major: m=MIter, n=0, k_stride=m*MIter + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + ; B row-major: n=MIter, m=0, k_stride=n*MIter + (= ?b_n_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_k_stride (MMul (MIter) ?n)) + + ; Uniform batch strides (contiguous per batch) + (= ?a_batch_stride (MMul ?k ?a_k_stride)) + (= ?b_batch_stride (MMul ?k ?b_k_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; cuBLAS: cublas(OP_N, OP_T, n, m, k, B, lda=b_k_stride, A, ldb=a_k_stride, C, ldc=n) + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "N" "T" + "COL" "COL" "COL" "COL" + ?b_k_stride ; lda (cuBLAS A = our B, row stride) + ?a_k_stride ; ldb (cuBLAS B = our A, column stride) + ?n ; ldc + ?n ; ldd + ?batch + ?b_batch_stride ; stride_a (cuBLAS A = our B) + ?a_batch_stride ; stride_b (cuBLAS B = our A) + (MMul ?m ?n) ; stride_c + (MMul ?m ?n) ; stride_d + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt batched column-major × row-major" +) + +; Column-major × Column-major matmul: C[m,n] = A[m,k] × B[k,n] +; A[m,k] column-major → expand to [m, n, k] with strides [MIter, 0, m] +; B[k,n] column-major → expand to [m, n, k] with strides [0, k, MIter] +; +; Row-major viewed as column-major (swap trick): +; Column-major A[m,k] is already column-major with lda=m +; Column-major B[k,n] is already column-major with ldb=k +; Row-major C[m,n] ≡ column-major C^T[n,m] with ldc=n +; +; C^T[n,m] = (A × B)^T = B^T[n,k] × A^T[k,m] +; cuBLAS: cublasSgemm(OP_T, OP_T, n, m, k, α, B, k, A, m, β, C, n) +(rule + ( + ; Match Mul node + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + + ; Match Sum that reduces the Mul (k dimension) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Match exactly 2D output shape + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + ; Match exactly 3D strides [m, n, k] + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + + ; Assert contiguous k stride on output (required for reduction) + (= ?k_stride (MIter)) + + ; Assert A has strides [MIter, 0, m*MIter] (column-major A[m,k] broadcast to [m,n,k]) + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + ; Assert B has strides [0, k*MIter, MIter] (column-major B[k,n] broadcast to [m,n,k]) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; For column-major A × column-major B with cuBLAS: + ; C^T = B^T × A^T → cublasSgemm(OP_T, OP_T, n, m, k, α, B, k, A, m, β, C, n) + (let ?sgemm (Op (cublaslt + ?n ; cuBLAS m = our n (swapped) + ?m ; cuBLAS n = our m (swapped) + ?k ; k unchanged + "T" ; transa = Transpose (B is column-major [k,n], need B^T[n,k]) + "T" ; transb = Transpose (A is column-major [m,k], need A^T[k,m]) + "COL" "COL" "COL" "COL" ; A/B/C/D matrix orders + ?b_n_stride ; lda = B's column stride (resolves to k after z→1) + ?a_k_stride ; ldb = A's column stride (resolves to m after z→1) + ?n ; ldc = n (row-major C[m,n] viewed as col-major [n,m]) + ?n ; ldd = ldc for current row-major output rewrites + (MNum 1) ; batch_count = 1 + (MNum 0) ; stride_a = 0 + (MNum 0) ; stride_b = 0 + (MNum 0) ; stride_c = 0 + (MNum 0) ; stride_d = 0 + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") ; type tuple, alpha, beta + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt column-major × column-major" +) + +; Batched Column-major × Column-major: C[batch,m,n] = A[batch,m,k] × B[batch,k,n] +; A column-major per batch: a_m_stride=MIter, a_n_stride=0 +; B column-major per batch: b_k_stride=MIter, b_m_stride=0 +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + ; A column-major: m=MIter, n=0, k_stride=m*MIter + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + ; B column-major: k=MIter, m=0, n_stride=k*MIter + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + ; Uniform batch strides (contiguous per batch) + (= ?a_batch_stride (MMul ?k ?a_k_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + ; cuBLAS: cublas(OP_T, OP_T, n, m, k, B, lda=b_n_stride, A, ldb=a_k_stride, C, ldc=n) + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "T" + "COL" "COL" "COL" "COL" + ?b_n_stride ; lda (cuBLAS A = our B, column stride) + ?a_k_stride ; ldb (cuBLAS B = our A, column stride) + ?n ; ldc + ?n ; ldd + ?batch + ?b_batch_stride ; stride_a (cuBLAS A = our B) + ?a_batch_stride ; stride_b (cuBLAS B = our A) + (MMul ?m ?n) ; stride_c + (MMul ?m ?n) ; stride_d + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt batched column-major × column-major" +) + +; FP8 support is narrower than "any FP8 x any FP8". cuBLASLt's regular FP8 +; matmul table supports these A/B descriptor pairs for F32 outputs: +; E4M3 x E4M3 +; E4M3 x E5M2 +; E5M2 x E4M3 +; and requires TN format on Ada/Hopper-class GPUs. These rules therefore match +; row-major x column-major Luminal matmuls, which the existing COL-order lowering +; describes as descriptor A = logical B, descriptor B = logical A, transa=T, +; transb=N. + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= (F8E4M3) (dtype ?a)) + (= (F8E4M3) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + (F8E4M3) (F8E4M3) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e4m3/e4m3 row-major x column-major f32 output" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= (F8E4M3) (dtype ?a)) + (= (F8E5M2) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + (F8E5M2) (F8E4M3) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e5m2/e4m3 row-major x column-major f32 output" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= (F8E5M2) (dtype ?a)) + (= (F8E4M3) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + (F8E4M3) (F8E5M2) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e4m3/e5m2 row-major x column-major f32 output" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= (F8E4M3) (dtype ?a)) + (= (F8E4M3) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + ?batch + ?b_batch_stride + ?a_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + (F8E4M3) (F8E4M3) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e4m3/e4m3 batched row-major x column-major f32 output" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= (F8E4M3) (dtype ?a)) + (= (F8E5M2) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + ?batch + ?b_batch_stride + ?a_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + (F8E5M2) (F8E4M3) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e5m2/e4m3 batched row-major x column-major f32 output" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + (= ?cast (Op (Cast ?size (F32)) (ICons ?sum (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= (F8E5M2) (dtype ?a)) + (= (F8E4M3) (dtype ?b)) + ) + ( + (let ?sgemm (Op (cublaslt + ?n ?m ?k + "T" "N" + "COL" "COL" "COL" "COL" + ?b_n_stride + ?a_m_stride + ?n + ?n + ?batch + ?b_batch_stride + ?a_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + (F8E4M3) (F8E5M2) (F32) (F32) "32F" "F32" 1.0 0.0 "DEFAULT") + (ICons ?b (ICons ?a (INil))))) + (union ?cast ?sgemm) + (set (dtype ?sgemm) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt fp8 e4m3/e5m2 batched row-major x column-major f32 output" +) + +; Natural cuBLASLt row-order output rewrites. These keep Luminal's logical +; output C[m,n] as a cuBLASLt ROW-ordered D[m,n] instead of using the older +; swapped COL-ordered D[n,m] view. A and B orders mirror their matched logical +; layouts, so this family is the legal base for future ROW-ordered beta fusions. + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MIter)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "ROW" "ROW" "ROW" "ROW" + ?a_m_stride + ?b_k_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order row-major x row-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MMul (MIter) ?k)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MIter)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "ROW" "COL" "ROW" "ROW" + ?a_m_stride + ?b_n_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order row-major x column-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MIter)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "COL" "ROW" "ROW" "ROW" + ?a_k_stride + ?b_k_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order column-major x row-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?out_shape (ECons ?m (ECons ?n (ENil)))) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + + (= ?a_stride (ECons ?a_m_stride (ECons ?a_n_stride (ECons ?a_k_stride (ENil))))) + (= ?b_stride (ECons ?b_m_stride (ECons ?b_n_stride (ECons ?b_k_stride (ENil))))) + (= ?k_stride (MIter)) + + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + (= ?b_k_stride (MIter)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "COL" "COL" "ROW" "ROW" + ?a_k_stride + ?b_n_stride + ?n + ?n + (MNum 1) + (MNum 0) + (MNum 0) + (MNum 0) + (MNum 0) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order column-major x column-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + (= ?b_n_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?k ?b_k_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "ROW" "ROW" "ROW" "ROW" + ?a_m_stride + ?b_k_stride + ?n + ?n + ?batch + ?a_batch_stride + ?b_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched row-major x row-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_k_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_m_stride (MMul (MIter) ?k)) + + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + (= ?a_batch_stride (MMul ?m ?a_m_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "ROW" "COL" "ROW" "ROW" + ?a_m_stride + ?b_n_stride + ?n + ?n + ?batch + ?a_batch_stride + ?b_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched row-major x column-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + (= ?b_n_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_k_stride (MMul (MIter) ?n)) + + (= ?a_batch_stride (MMul ?k ?a_k_stride)) + (= ?b_batch_stride (MMul ?k ?b_k_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "COL" "ROW" "ROW" "ROW" + ?a_k_stride + ?b_k_stride + ?n + ?n + ?batch + ?a_batch_stride + ?b_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched column-major x row-major" +) + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?out_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + (= ?batch (nth_from_end ?out_shape 2)) + (= ?m (nth_from_end ?out_shape 1)) + (= ?n (nth_from_end ?out_shape 0)) + (!= ?m (MNum 0)) + (!= ?n (MNum 0)) + (!= ?k (MNum 1)) + (!= ?batch (MNum 0)) + + (= ?a_batch_stride (nth_from_end ?a_stride 3)) + (= ?a_m_stride (nth_from_end ?a_stride 2)) + (= ?a_n_stride (nth_from_end ?a_stride 1)) + (= ?a_k_stride (nth_from_end ?a_stride 0)) + + (= ?b_batch_stride (nth_from_end ?b_stride 3)) + (= ?b_m_stride (nth_from_end ?b_stride 2)) + (= ?b_n_stride (nth_from_end ?b_stride 1)) + (= ?b_k_stride (nth_from_end ?b_stride 0)) + + (= ?k_stride (MIter)) + + (= ?a_m_stride (MIter)) + (= ?a_n_stride (MNum 0)) + (= ?a_k_stride (MMul (MIter) ?m)) + + (= ?b_k_stride (MIter)) + (= ?b_m_stride (MNum 0)) + (= ?b_n_stride (MMul (MIter) ?k)) + + (= ?a_batch_stride (MMul ?k ?a_k_stride)) + (= ?b_batch_stride (MMul ?n ?b_n_stride)) + + (= ?dt (dtype ?a)) + (= ?dt (dtype ?b)) + (cublaslt_base_dtype ?dt) + ) + ( + (let ?sgemm (Op (cublaslt + ?m ?n ?k + "N" "N" + "COL" "COL" "ROW" "ROW" + ?a_k_stride + ?b_n_stride + ?n + ?n + ?batch + ?a_batch_stride + ?b_batch_stride + (MMul ?m ?n) + (MMul ?m ?n) + ?dt ?dt ?dt ?dt "default" "default" 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + (union ?sum ?sgemm) + (set (dtype ?sgemm) ?dt) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched column-major x column-major" +) + +; Mixed output dtype rewrites for cuBLASLt. +; +; The first mixed mode we need for low-precision matmuls is: +; +; D[f32] = A[fp16/bf16] * B[fp16/bf16] +; +; Luminal graphs express this today as a Cast(F32) around a low-precision +; matmul. cuBLASLt can write the f32 output directly, so expose that candidate +; before beta fusion tries to consume an f32 C input. + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + (F16) (F16) (F16) (F16) + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + ?inputs)) + (= ?cast (Op (Cast ?size (F32)) (ICons ?matmul (INil)))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + (F16) (F16) (F32) (F32) + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + ?inputs)) + (union ?cast ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt f16 matmul cast f32 output" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + (Bf16) (Bf16) (Bf16) (Bf16) + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + ?inputs)) + (= ?cast (Op (Cast ?size (F32)) (ICons ?matmul (INil)))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + (Bf16) (Bf16) (F32) (F32) + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + ?inputs)) + (union ?cast ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt bf16 matmul cast f32 output" +) + +; Scalar alpha/beta rewrites for cuBLASLt. These rules target scalar constants +; expanded across the matmul/add shape, i.e. zero strides on every logical axis. + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?scale (Op (Constant ?alpha) (INil))) + ; alpha=1.0 hash-conses ?fused == ?matmul; the union merges Mul into ?matmul's eclass and saturate diverges. + (!= ?alpha 1.0) + (= ?scaled (Op (Mul ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?scaled_out_strides) + (ICons ?matmul (ICons ?scale (INil))))) + (= ?matmul_strides ?scaled_out_strides) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?scaled ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt 2d alpha scale" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + 1.0 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?scale (Op (Constant ?alpha) (INil))) + ; See 2d alpha scale: alpha=1.0 makes (saturate ...) diverge. + (!= ?alpha 1.0) + (= ?scaled (Op (Mul ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?scaled_out_strides) + (ICons ?matmul (ICons ?scale (INil))))) + (= ?matmul_strides ?scaled_out_strides) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?scaled ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt batched alpha scale" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?beta_node (Op (Constant ?beta) (INil))) + (= ?scaled_c (Op (Mul + (ECons ?m (ECons ?n (ENil))) + ?c_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?scaled_c_out_strides) + (ICons ?c (ICons ?beta_node (INil))))) + + (= ?add (Op (Add + (ECons ?m (ECons ?n (ENil))) + ?matmul_add_strides + ?scaled_c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?scaled_c (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?scaled_c_add_strides ?scaled_c_out_strides) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order 2d scaled c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?beta_node (Op (Constant ?beta) (INil))) + (= ?scaled_c (Op (Mul + (ECons ?m (ECons ?n (ENil))) + ?c_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?scaled_c_out_strides) + (ICons ?c (ICons ?beta_node (INil))))) + + (= ?add (Op (Add + (ECons ?m (ECons ?n (ENil))) + ?scaled_c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?scaled_c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?scaled_c_add_strides ?scaled_c_out_strides) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order 2d scaled c plus matmul beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?beta_node (Op (Constant ?beta) (INil))) + (= ?scaled_c (Op (Mul + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?c_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?scaled_c_out_strides) + (ICons ?c (ICons ?beta_node (INil))))) + + (= ?add (Op (Add + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?matmul_add_strides + ?scaled_c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?scaled_c (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?scaled_c_add_strides ?scaled_c_out_strides) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched scaled c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?beta_node (Op (Constant ?beta) (INil))) + (= ?scaled_c (Op (Mul + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?c_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?scaled_c_out_strides) + (ICons ?c (ICons ?beta_node (INil))))) + + (= ?add (Op (Add + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?scaled_c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?scaled_c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?scaled_c_add_strides ?scaled_c_out_strides) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha ?beta ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched scaled c plus matmul beta" +) + +; Fuse a row-major Add on top of an existing cuBLASLt matmul into +; D = alpha * A * B + beta * C. +; +; The existing matmul rewrites view Luminal's row-major output [m,n] as a +; column-major cuBLASLt matrix [n,m]. A row-major C input with logical strides +; [row_stride, 1] therefore maps to ldc=row_stride. This lets a C slice from a +; wider parent tensor use a larger ldc while D keeps the matmul output layout. +; cuBLASLt requires out-of-place C and D to have the same matrix order, so these +; beta rules only fuse C layouts that map to the current COL-ordered D layout. +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "COL" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?n (ECons ?m (ENil))) + ?matmul_add_strides + ?c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?c (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_add_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "COL" "COL" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt 2d matmul plus c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "COL" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?n (ECons ?m (ENil))) + ?c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_add_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "COL" "COL" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt 2d c plus matmul beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "COL" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?batch (ECons ?n (ECons ?m (ENil)))) + ?matmul_add_strides + ?c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?c (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_add_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "COL" "COL" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt batched matmul plus c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "COL" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?batch (ECons ?n (ECons ?m (ENil)))) + ?c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_add_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "COL" "COL" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt batched c plus matmul beta" +) + +; ROW-ordered D beta fusions. These pair with cublaslt_row_order_rewrite.egg, +; where the cuBLASLt problem dimensions match Luminal's logical output [m,n]. +; A row-major C input with logical strides [row_stride, 1] maps directly to a +; ROW-ordered cuBLASLt C[m,n] descriptor with ldc=row_stride. +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?m (ECons ?n (ENil))) + ?matmul_add_strides + ?c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?c (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_add_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order 2d matmul plus c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?m (ECons ?n (ENil))) + ?c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_add_strides (ECons ?c_row_stride (ECons ?c_col_stride (ENil)))) + (= ?add_out_strides (ECons ?d_row_stride (ECons ?d_col_stride (ENil)))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + (MNum 1) + ?stride_a ?stride_b (MNum 0) ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order 2d c plus matmul beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?matmul_add_strides + ?c_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?c (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_add_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched matmul plus c beta" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?matmul_c_order "ROW" + ?lda ?ldb ?matmul_ldc ?ldd + ?batch + ?stride_a ?stride_b ?matmul_stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 ?epilogue) + (ICons ?a (ICons ?b ?matmul_tail)))) + (!= ?epilogue "RELU") + (!= ?epilogue "RELU_BIAS") + (!= ?epilogue "GELU") + (!= ?epilogue "GELU_BIAS") + + (= ?add (Op (Add + (ECons ?batch (ECons ?m (ECons ?n (ENil)))) + ?c_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?c (ICons ?matmul (INil))))) + + (= ?matmul_add_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_add_strides (ECons ?c_batch_stride (ECons ?c_row_stride (ECons ?c_col_stride (ENil))))) + (= ?add_out_strides (ECons ?d_batch_stride (ECons ?d_row_stride (ECons ?d_col_stride (ENil))))) + (= ?c_col_stride (MIter)) + (!= ?c_row_stride (MNum 0)) + (= ?matmul_add_strides ?add_out_strides) + (= ?c_dtype (dtype ?c)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order "ROW" "ROW" + ?lda ?ldb ?c_row_stride ?ldd + ?batch + ?stride_a ?stride_b ?c_batch_stride ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 1.0 ?epilogue) + (ICons ?a (ICons ?b (ICons ?c ?matmul_tail))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt row-order batched c plus matmul beta" +) + +; cuBLASLt epilogue rewrites. +; +; ReLU in the frontend lowers through maximum_f32(0.0): +; +; (matmul < 0) * 0 + cast(cast((-cast(matmul < 0) + 1) as bool) as f32) * matmul +; +; These rules fuse that expression back into CUBLASLT_EPILOGUE_RELU. + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?zero (Op (Constant 0.0) (INil))) + (= ?neg_one (Op (Constant -1.0) (INil))) + (= ?one (Op (Constant 1.0) (INil))) + + (= ?lt (Op (LessThan + ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?mask_strides) + (ICons ?matmul (ICons ?zero (INil))))) + (= ?lt_f32 (Op (Cast ?size (F32)) (ICons ?lt (INil)))) + + (= ?zeroed (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?zeroed_strides) + (ICons ?lt_f32 (ICons ?zero (INil))))) + + (= ?neg_mask (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?neg_mask_strides) + (ICons ?lt_f32 (ICons ?neg_one (INil))))) + (= ?not_mask_f32 (Op (Add + ?shape + ?neg_mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?not_mask_f32_strides) + (ICons ?neg_mask (ICons ?one (INil))))) + (= ?not_mask_bool (Op (Cast ?size (Bool)) (ICons ?not_mask_f32 (INil)))) + (= ?not_mask (Op (Cast ?size (F32)) (ICons ?not_mask_bool (INil)))) + + (= ?positive (Op (Mul + ?shape + ?not_mask_f32_strides + ?matmul_strides + ?positive_strides) + (ICons ?not_mask (ICons ?matmul (INil))))) + (= ?relu (Op (Add + ?shape + ?zeroed_strides + ?positive_strides + ?relu_strides) + (ICons ?zeroed (ICons ?positive (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "RELU") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?relu ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt 2d relu epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?zero (Op (Constant 0.0) (INil))) + (= ?neg_one (Op (Constant -1.0) (INil))) + (= ?one (Op (Constant 1.0) (INil))) + + (= ?lt (Op (LessThan + ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?mask_strides) + (ICons ?matmul (ICons ?zero (INil))))) + (= ?lt_f32 (Op (Cast ?size (F32)) (ICons ?lt (INil)))) + + (= ?zeroed (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?zeroed_strides) + (ICons ?lt_f32 (ICons ?zero (INil))))) + + (= ?neg_mask (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?neg_mask_strides) + (ICons ?lt_f32 (ICons ?neg_one (INil))))) + (= ?not_mask_f32 (Op (Add + ?shape + ?neg_mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?not_mask_f32_strides) + (ICons ?neg_mask (ICons ?one (INil))))) + (= ?not_mask_bool (Op (Cast ?size (Bool)) (ICons ?not_mask_f32 (INil)))) + (= ?not_mask (Op (Cast ?size (F32)) (ICons ?not_mask_bool (INil)))) + + (= ?positive (Op (Mul + ?shape + ?not_mask_f32_strides + ?matmul_strides + ?positive_strides) + (ICons ?not_mask (ICons ?matmul (INil))))) + (= ?relu (Op (Add + ?shape + ?zeroed_strides + ?positive_strides + ?relu_strides) + (ICons ?zeroed (ICons ?positive (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "RELU") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?relu ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt batched relu epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?zero (Op (Constant 0.0) (INil))) + (= ?neg_one (Op (Constant -1.0) (INil))) + (= ?one (Op (Constant 1.0) (INil))) + + (= ?lt (Op (LessThan + ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?mask_strides) + (ICons ?matmul (ICons ?zero (INil))))) + (= ?lt_f32 (Op (Cast ?size (F32)) (ICons ?lt (INil)))) + + (= ?zeroed (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?zeroed_strides) + (ICons ?lt_f32 (ICons ?zero (INil))))) + + (= ?neg_mask (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?neg_mask_strides) + (ICons ?lt_f32 (ICons ?neg_one (INil))))) + (= ?not_mask_f32 (Op (Add + ?shape + ?neg_mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ENil))) + ?not_mask_f32_strides) + (ICons ?neg_mask (ICons ?one (INil))))) + (= ?not_mask_bool (Op (Cast ?size (Bool)) (ICons ?not_mask_f32 (INil)))) + (= ?not_mask (Op (Cast ?size (F32)) (ICons ?not_mask_bool (INil)))) + + (= ?positive (Op (Mul + ?shape + ?not_mask_f32_strides + ?matmul_strides + ?positive_strides) + (ICons ?not_mask (ICons ?matmul (INil))))) + (= ?relu (Op (Add + ?shape + ?zeroed_strides + ?positive_strides + ?relu_strides) + (ICons ?zeroed (ICons ?positive (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "RELU_BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?relu ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt 2d relu bias epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?zero (Op (Constant 0.0) (INil))) + (= ?neg_one (Op (Constant -1.0) (INil))) + (= ?one (Op (Constant 1.0) (INil))) + + (= ?lt (Op (LessThan + ?shape + ?matmul_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?mask_strides) + (ICons ?matmul (ICons ?zero (INil))))) + (= ?lt_f32 (Op (Cast ?size (F32)) (ICons ?lt (INil)))) + + (= ?zeroed (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?zeroed_strides) + (ICons ?lt_f32 (ICons ?zero (INil))))) + + (= ?neg_mask (Op (Mul + ?shape + ?mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?neg_mask_strides) + (ICons ?lt_f32 (ICons ?neg_one (INil))))) + (= ?not_mask_f32 (Op (Add + ?shape + ?neg_mask_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?not_mask_f32_strides) + (ICons ?neg_mask (ICons ?one (INil))))) + (= ?not_mask_bool (Op (Cast ?size (Bool)) (ICons ?not_mask_f32 (INil)))) + (= ?not_mask (Op (Cast ?size (F32)) (ICons ?not_mask_bool (INil)))) + + (= ?positive (Op (Mul + ?shape + ?not_mask_f32_strides + ?matmul_strides + ?positive_strides) + (ICons ?not_mask (ICons ?matmul (INil))))) + (= ?relu (Op (Add + ?shape + ?zeroed_strides + ?positive_strides + ?relu_strides) + (ICons ?zeroed (ICons ?positive (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "RELU_BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?relu ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt batched relu bias epilogue" +) + +; Canonical tanh-approx GELU can also appear directly as: +; +; x * sigmoid(1.5957691216 * x * (1 + 0.044715 * x * x)) +; +; Match that sigmoid form and fuse it into the cuBLASLt GELU epilogues. + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?gelu_coeff_inner (Op (Constant 0.044715) (INil))) + (= ?gelu_inner_scaled (Op (Mul ?gelu_inner_scaled_shape ?gelu_inner_scaled_a_stride ?gelu_inner_scaled_b_stride ?gelu_inner_scaled_out_stride) (ICons ?matmul (ICons ?gelu_coeff_inner (INil))))) + (= ?gelu_inner_quad (Op (Mul ?gelu_inner_quad_shape ?gelu_inner_quad_a_stride ?gelu_inner_quad_b_stride ?gelu_inner_quad_out_stride) (ICons ?gelu_inner_scaled (ICons ?matmul (INil))))) + (= ?gelu_one (Op (Constant 1.000000) (INil))) + (= ?gelu_poly (Op (Add ?gelu_poly_shape ?gelu_poly_a_stride ?gelu_poly_b_stride ?gelu_poly_out_stride) (ICons ?gelu_inner_quad (ICons ?gelu_one (INil))))) + (= ?gelu_coeff_outer (Op (Constant 1.595769) (INil))) + (= ?gelu_outer_scaled (Op (Mul ?gelu_outer_scaled_shape ?gelu_outer_scaled_a_stride ?gelu_outer_scaled_b_stride ?gelu_outer_scaled_out_stride) (ICons ?matmul (ICons ?gelu_coeff_outer (INil))))) + (= ?gelu_scaled (Op (Mul ?gelu_scaled_shape ?gelu_scaled_a_stride ?gelu_scaled_b_stride ?gelu_scaled_out_stride) (ICons ?gelu_outer_scaled (ICons ?gelu_poly (INil))))) + (= ?neg1 (Op (Constant -1.000000) (INil))) + (= ?gelu_neg (Op (Mul ?gelu_neg_shape ?gelu_neg_a_stride ?gelu_neg_b_stride ?gelu_neg_out_stride) (ICons ?gelu_scaled (ICons ?neg1 (INil))))) + (= ?log2e (Op (Constant 1.442695) (INil))) + (= ?gelu_exp_scaled (Op (Mul ?gelu_exp_scaled_shape ?gelu_exp_scaled_a_stride ?gelu_exp_scaled_b_stride ?gelu_exp_scaled_out_stride) (ICons ?gelu_neg (ICons ?log2e (INil))))) + (= ?gelu_exp2_val (Op (Exp2 ?gelu_exp_shape ?gelu_exp_in_stride ?gelu_exp_out_stride) (ICons ?gelu_exp_scaled (INil)))) + (= ?gelu_plus1 (Op (Add ?gelu_plus1_shape ?gelu_plus1_a_stride ?gelu_plus1_b_stride ?gelu_plus1_out_stride) (ICons ?gelu_exp2_val (ICons ?gelu_one (INil))))) + (= ?gelu_sigmoid (Op (Recip ?gelu_sigmoid_shape ?gelu_sigmoid_in_stride ?gelu_sigmoid_out_stride) (ICons ?gelu_plus1 (INil)))) + (= ?gelu_out (Op (Mul ?gelu_out_shape ?gelu_out_a_stride ?gelu_out_b_stride ?gelu_out_out_stride) (ICons ?matmul (ICons ?gelu_sigmoid (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "GELU") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?gelu_out ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt gelu epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + + (= ?gelu_coeff_inner (Op (Constant 0.044715) (INil))) + (= ?gelu_inner_scaled (Op (Mul ?gelu_inner_scaled_shape ?gelu_inner_scaled_a_stride ?gelu_inner_scaled_b_stride ?gelu_inner_scaled_out_stride) (ICons ?matmul (ICons ?gelu_coeff_inner (INil))))) + (= ?gelu_inner_quad (Op (Mul ?gelu_inner_quad_shape ?gelu_inner_quad_a_stride ?gelu_inner_quad_b_stride ?gelu_inner_quad_out_stride) (ICons ?gelu_inner_scaled (ICons ?matmul (INil))))) + (= ?gelu_one (Op (Constant 1.000000) (INil))) + (= ?gelu_poly (Op (Add ?gelu_poly_shape ?gelu_poly_a_stride ?gelu_poly_b_stride ?gelu_poly_out_stride) (ICons ?gelu_inner_quad (ICons ?gelu_one (INil))))) + (= ?gelu_coeff_outer (Op (Constant 1.595769) (INil))) + (= ?gelu_outer_scaled (Op (Mul ?gelu_outer_scaled_shape ?gelu_outer_scaled_a_stride ?gelu_outer_scaled_b_stride ?gelu_outer_scaled_out_stride) (ICons ?matmul (ICons ?gelu_coeff_outer (INil))))) + (= ?gelu_scaled (Op (Mul ?gelu_scaled_shape ?gelu_scaled_a_stride ?gelu_scaled_b_stride ?gelu_scaled_out_stride) (ICons ?gelu_outer_scaled (ICons ?gelu_poly (INil))))) + (= ?neg1 (Op (Constant -1.000000) (INil))) + (= ?gelu_neg (Op (Mul ?gelu_neg_shape ?gelu_neg_a_stride ?gelu_neg_b_stride ?gelu_neg_out_stride) (ICons ?gelu_scaled (ICons ?neg1 (INil))))) + (= ?log2e (Op (Constant 1.442695) (INil))) + (= ?gelu_exp_scaled (Op (Mul ?gelu_exp_scaled_shape ?gelu_exp_scaled_a_stride ?gelu_exp_scaled_b_stride ?gelu_exp_scaled_out_stride) (ICons ?gelu_neg (ICons ?log2e (INil))))) + (= ?gelu_exp2_val (Op (Exp2 ?gelu_exp_shape ?gelu_exp_in_stride ?gelu_exp_out_stride) (ICons ?gelu_exp_scaled (INil)))) + (= ?gelu_plus1 (Op (Add ?gelu_plus1_shape ?gelu_plus1_a_stride ?gelu_plus1_b_stride ?gelu_plus1_out_stride) (ICons ?gelu_exp2_val (ICons ?gelu_one (INil))))) + (= ?gelu_sigmoid (Op (Recip ?gelu_sigmoid_shape ?gelu_sigmoid_in_stride ?gelu_sigmoid_out_stride) (ICons ?gelu_plus1 (INil)))) + (= ?gelu_out (Op (Mul ?gelu_out_shape ?gelu_out_a_stride ?gelu_out_b_stride ?gelu_out_out_stride) (ICons ?matmul (ICons ?gelu_sigmoid (INil))))) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order ?d_order + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype (F32) + ?compute_type ?scale_dtype + ?alpha 0.0 "GELU_BIAS") + (ICons ?a (ICons ?b ?matmul_tail)))) + (union ?gelu_out ?fused) + (set (dtype ?fused) (F32)) + ) + :ruleset matmul_backend + :name "cublaslt gelu bias epilogue" +) + +; This first slice fuses column-bias adds into CUBLASLT_EPILOGUE_BIAS for the +; older COL-ordered output view. In that view Luminal's logical [m,n] output is +; represented as a cuBLASLt [n,m] matrix, so cuBLASLt's row-broadcast bias maps +; to the common logical column bias of length n. + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + + (= ?add (Op (Add + (ECons ?n (ECons ?m (ENil))) + ?matmul_add_strides + ?bias_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?bias (INil))))) + + (= ?bias_add_strides (ECons (MNum 0) (ECons (MIter) (ENil)))) + (= ?matmul_add_strides ?add_out_strides) + (= ?d_dtype (dtype ?bias)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b (ICons ?bias (INil)))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt 2d matmul plus column bias epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + + (= ?add (Op (Add + (ECons ?n (ECons ?m (ENil))) + ?bias_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?bias (ICons ?matmul (INil))))) + + (= ?bias_add_strides (ECons (MNum 0) (ECons (MIter) (ENil)))) + (= ?matmul_add_strides ?add_out_strides) + (= ?d_dtype (dtype ?bias)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + (MNum 1) + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b (ICons ?bias (INil)))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt 2d column bias plus matmul epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + + (= ?add (Op (Add + (ECons ?batch (ECons ?n (ECons ?m (ENil)))) + ?matmul_add_strides + ?bias_add_strides + ?add_out_strides) + (ICons ?matmul (ICons ?bias (INil))))) + + (= ?bias_add_strides (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil))))) + (= ?matmul_add_strides ?add_out_strides) + (= ?d_dtype (dtype ?bias)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b (ICons ?bias (INil)))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt batched matmul plus column bias epilogue" +) + +(rule + ( + (= ?matmul (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "DEFAULT") + (ICons ?a (ICons ?b (INil))))) + + (= ?add (Op (Add + (ECons ?batch (ECons ?n (ECons ?m (ENil)))) + ?bias_add_strides + ?matmul_add_strides + ?add_out_strides) + (ICons ?bias (ICons ?matmul (INil))))) + + (= ?bias_add_strides (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil))))) + (= ?matmul_add_strides ?add_out_strides) + (= ?d_dtype (dtype ?bias)) + ) + ( + (let ?fused (Op (cublaslt + ?m ?n ?k + ?a_layout ?b_layout + ?a_order ?b_order ?c_order "COL" + ?lda ?ldb ?ldc ?ldd + ?batch + ?stride_a ?stride_b ?stride_c ?stride_d + ?a_dtype ?b_dtype ?c_dtype ?d_dtype + ?compute_type ?scale_dtype + ?alpha 0.0 "BIAS") + (ICons ?a (ICons ?b (ICons ?bias (INil)))))) + (union ?add ?fused) + (set (dtype ?fused) ?d_dtype) + ) + :ruleset matmul_backend + :name "cublaslt batched column bias plus matmul epilogue" +) + +(rule + ((= ?mul (Op (KernelMul ?shape ?as ?bs ?os ?dt) ?inputs)) + (= (MNum 0) (nth_from_end ?as 1)) + (= (MNum 0) (nth_from_end ?bs 2)) + (= ?sum (Op (Sum ?sshape ?sk ?ssi ?sks ?sso) (ICons ?mul (INil)))) + (= ?sum (Op (cublaslt ?cm ?cn ?ck ?cta ?ctb ?cao ?cbo ?cco ?cdo ?clda ?cldb ?cldc ?cldd ?cbc ?csa ?csb ?csc ?csd ?cadt ?cbdt ?ccdt ?cddt ?ccompute ?cscale ?calpha ?cbeta ?cepilogue) ?ci))) + ((delete (Op (KernelMul ?shape ?as ?bs ?os ?dt) ?inputs))) + :ruleset cleanup + ) +(rule + ((= ?mul (Op (KernelMul ?shape ?as ?bs ?os ?dt) ?inputs)) + (= (MNum 0) (nth_from_end ?as 1)) + (= (MNum 0) (nth_from_end ?bs 2)) + (= ?sum (Op (Sum ?sshape ?sk ?ssi ?sks ?sso) (ICons ?mul (INil)))) + (= ?sum (Op (KernelBatchMatMul ?bos ?bk ?bas ?baks ?bbs ?bbks ?bouts ?bdt) ?bi))) + ((delete (Op (KernelMul ?shape ?as ?bs ?os ?dt) ?inputs))) + :ruleset cleanup + ) +(rule + ( + (= ?e (Op (GLUMoE ?gu_io ?dn_io ?gu_matmul_k ?dn_matmul_k ?output_k ?gu_within_range ?dn_within_range ?mode) ?inputs)) + ) + ( + (set (dtype ?e) (F32)) + ) + :ruleset dtype_prop + ) +; GLUMoE: Match the expert computation subgraph of a gated MoE. +; +; One fused op supports two activation modes: +; mode=0: Qwen-style SwiGLU (silu(gate) * up) +; mode=1: Gemma-style GELU (gate * sigmoid(1.595769 * gate * (1 + 0.044715 * gate^2))) +; +; To keep matching fast, we stage through marker states: +; 1) Shared expert index/gather markers +; 2) Shared gate-up matmul marker +; 3) Activation marker (separate swiglu / gemma_gelu paths) +; 4) Down matmul marker (separate swiglu / gemma_gelu paths) +; 5) Final GLUMoE fusion (separate swiglu / gemma_gelu rules) + +(datatype* + (GLUMoEExpertIndexState + (MkGLUMoEExpertIndexState Expression Expression IR) + ) + (GLUMoEExpertGatherState + (MkGLUMoEExpertGatherState Expression Expression IR IR) + ) + (GLUMoEGateUpState + (MkGLUMoEGateUpState Expression Expression Expression IR IR IR) + ) + (GLUMoESwiGLUState + (MkGLUMoESwiGLUState GLUMoEGateUpState) + ) + (GLUMoEGemmaGELUState + (MkGLUMoEGemmaGELUState GLUMoEGateUpState) + ) + (GLUMoESwiGLUDownState + (MkGLUMoESwiGLUDownState Expression Expression Expression GLUMoESwiGLUState IR IR) + ) + (GLUMoEGemmaDownState + (MkGLUMoEGemmaDownState Expression Expression Expression GLUMoEGemmaGELUState IR IR) + ) +) + +(function glumoe_expert_index (IR) GLUMoEExpertIndexState :merge new) +(function glumoe_expert_gather (IR) GLUMoEExpertGatherState :merge new) +(function glumoe_gate_up (IR) GLUMoEGateUpState :merge new) +(function glumoe_swiglu (IR) GLUMoESwiGLUState :merge new) +(function glumoe_gemma_gelu (IR) GLUMoEGemmaGELUState :merge new) +(function glumoe_swiglu_down (IR) GLUMoESwiGLUDownState :merge new) +(function glumoe_gemma_down (IR) GLUMoEGemmaDownState :merge new) + +(rule + ( + (= ?iota_base (Op (Iota ?io ?iota_base_range) (INil))) + (= ?mul_base (Op (Mul ?mul_base_shape ?mul_base_a_stride ?mul_base_b_stride ?mul_base_out_stride) (ICons ?topk_idx (ICons ?iota_base (INil))))) + (= ?iota_within (Op (Iota (MIter) ?iota_within_range) (INil))) + (= ?add_idx (Op (Add ?add_shape ?add_a_stride ?add_b_stride ?add_out_stride) (ICons ?mul_base (ICons ?iota_within (INil))))) + ) + ( + (set (glumoe_expert_index ?add_idx) + (MkGLUMoEExpertIndexState ?io ?iota_within_range ?topk_idx)) + ) + :ruleset glumoe + :name "GLUMoE expert index marker" +) + +(rule + ( + (= ?index_state (glumoe_expert_index ?idx)) + (= ?index_state (MkGLUMoEExpertIndexState ?io ?within_range ?topk_idx)) + (= ?gathered (Op (Gather ?gather_idx_shape ?gather_idx_stride ?gather_data_shape ?gather_data_stride) (ICons ?idx (ICons ?weights (INil))))) + (= ?f32 (Op (Cast ?f32_size (F32)) (ICons ?gathered (INil)))) + ) + ( + (set (glumoe_expert_gather ?f32) + (MkGLUMoEExpertGatherState ?io ?within_range ?topk_idx ?weights)) + ) + :ruleset glumoe + :name "GLUMoE expert gather marker" +) + +(rule + ( + (= ?gather_state (glumoe_expert_gather ?gu_f32)) + (= ?gather_state (MkGLUMoEExpertGatherState ?gu_io ?gu_iota_within_range ?topk_idx ?gate_up_w)) + (= ?gu_matmul_mul (Op (Mul ?gu_matmul_mul_shape ?gu_matmul_a_stride ?gu_matmul_b_stride ?gu_matmul_mul_out_stride) (ICons ?x (ICons ?gu_f32 (INil))))) + (= ?gu_matmul (Op (Sum ?gu_matmul_out_shape ?gu_matmul_k ?gu_matmul_in_stride ?gu_matmul_k_stride ?gu_matmul_out_stride) (ICons ?gu_matmul_mul (INil)))) + ) + ( + (set (glumoe_gate_up ?gu_matmul) + (MkGLUMoEGateUpState ?gu_io ?gu_matmul_k ?gu_iota_within_range ?x ?topk_idx ?gate_up_w)) + ) + :ruleset glumoe + :name "GLUMoE gate-up matmul marker" +) + +; ===== SwiGLU activation marker ===== +(rule + ( + (= ?gate_up_state (glumoe_gate_up ?gu_matmul)) + (= ?gate_up_state (MkGLUMoEGateUpState ?gu_io ?gu_matmul_k ?gu_within_range ?x ?topk_idx ?gate_up_w)) + + (= ?up_iota (Op (Iota ?up_iota_expr ?up_iota_range) (INil))) + (= ?up_slice (Op (Gather ?up_gather_idx_shape ?up_gather_idx_stride ?up_gather_data_shape ?up_gather_data_stride) (ICons ?up_iota (ICons ?gu_matmul (INil))))) + + (= ?neg1 (Op (Constant -1.000000) (INil))) + (= ?neg_gate (Op (Mul ?silu_shape1 ?silu_a_stride1 ?silu_b_stride1 ?silu_out_stride1) (ICons ?gu_matmul (ICons ?neg1 (INil))))) + (= ?log2e (Op (Constant 1.442695) (INil))) + (= ?scaled (Op (Mul ?silu_shape2 ?silu_a_stride2 ?silu_b_stride2 ?silu_out_stride2) (ICons ?neg_gate (ICons ?log2e (INil))))) + (= ?exp2_val (Op (Exp2 ?silu_shape3 ?silu_in_stride3 ?silu_out_stride3) (ICons ?scaled (INil)))) + (= ?one (Op (Constant 1.000000) (INil))) + (= ?plus1 (Op (Add ?silu_shape4 ?silu_a_stride4 ?silu_b_stride4 ?silu_out_stride4) (ICons ?exp2_val (ICons ?one (INil))))) + (= ?sigmoid (Op (Recip ?silu_shape5 ?silu_in_stride5 ?silu_out_stride5) (ICons ?plus1 (INil)))) + (= ?silu_out (Op (Mul ?silu_shape6 ?silu_a_stride6 ?silu_b_stride6 ?silu_out_stride6) (ICons ?gu_matmul (ICons ?sigmoid (INil))))) + (= ?swiglu_out (Op (Mul ?swiglu_shape ?swiglu_a_stride ?swiglu_b_stride ?swiglu_out_stride) (ICons ?silu_out (ICons ?up_slice (INil))))) + ) + ( + (set (glumoe_swiglu ?swiglu_out) (MkGLUMoESwiGLUState ?gate_up_state)) + ) + :ruleset glumoe + :name "GLUMoE swiglu marker" +) + +; ===== Gemma GELU activation marker ===== +(rule + ( + (= ?gate_up_state (glumoe_gate_up ?gu_matmul)) + (= ?gate_up_state (MkGLUMoEGateUpState ?gu_io ?gu_matmul_k ?gu_within_range ?x ?topk_idx ?gate_up_w)) + + (= ?up_iota (Op (Iota ?up_iota_expr ?up_iota_range) (INil))) + (= ?up_slice (Op (Gather ?up_gather_idx_shape ?up_gather_idx_stride ?up_gather_data_shape ?up_gather_data_stride) (ICons ?up_iota (ICons ?gu_matmul (INil))))) + + (= ?gelu_coeff_inner (Op (Constant 0.044715) (INil))) + (= ?gelu_inner_scaled (Op (Mul ?gelu_inner_scaled_shape ?gelu_inner_scaled_a_stride ?gelu_inner_scaled_b_stride ?gelu_inner_scaled_out_stride) (ICons ?gu_matmul (ICons ?gelu_coeff_inner (INil))))) + (= ?gelu_inner_quad (Op (Mul ?gelu_inner_quad_shape ?gelu_inner_quad_a_stride ?gelu_inner_quad_b_stride ?gelu_inner_quad_out_stride) (ICons ?gelu_inner_scaled (ICons ?gu_matmul (INil))))) + (= ?gelu_one (Op (Constant 1.000000) (INil))) + (= ?gelu_poly (Op (Add ?gelu_poly_shape ?gelu_poly_a_stride ?gelu_poly_b_stride ?gelu_poly_out_stride) (ICons ?gelu_inner_quad (ICons ?gelu_one (INil))))) + (= ?gelu_coeff_outer (Op (Constant 1.595769) (INil))) + (= ?gelu_outer_scaled (Op (Mul ?gelu_outer_scaled_shape ?gelu_outer_scaled_a_stride ?gelu_outer_scaled_b_stride ?gelu_outer_scaled_out_stride) (ICons ?gu_matmul (ICons ?gelu_coeff_outer (INil))))) + (= ?gelu_scaled (Op (Mul ?gelu_scaled_shape ?gelu_scaled_a_stride ?gelu_scaled_b_stride ?gelu_scaled_out_stride) (ICons ?gelu_outer_scaled (ICons ?gelu_poly (INil))))) + (= ?neg1 (Op (Constant -1.000000) (INil))) + (= ?gelu_neg (Op (Mul ?gelu_neg_shape ?gelu_neg_a_stride ?gelu_neg_b_stride ?gelu_neg_out_stride) (ICons ?gelu_scaled (ICons ?neg1 (INil))))) + (= ?log2e (Op (Constant 1.442695) (INil))) + (= ?gelu_exp_scaled (Op (Mul ?gelu_exp_scaled_shape ?gelu_exp_scaled_a_stride ?gelu_exp_scaled_b_stride ?gelu_exp_scaled_out_stride) (ICons ?gelu_neg (ICons ?log2e (INil))))) + (= ?gelu_exp2_val (Op (Exp2 ?gelu_exp_shape ?gelu_exp_in_stride ?gelu_exp_out_stride) (ICons ?gelu_exp_scaled (INil)))) + (= ?gelu_plus1 (Op (Add ?gelu_plus1_shape ?gelu_plus1_a_stride ?gelu_plus1_b_stride ?gelu_plus1_out_stride) (ICons ?gelu_exp2_val (ICons ?gelu_one (INil))))) + (= ?gelu_sigmoid (Op (Recip ?gelu_sigmoid_shape ?gelu_sigmoid_in_stride ?gelu_sigmoid_out_stride) (ICons ?gelu_plus1 (INil)))) + (= ?gelu_out (Op (Mul ?gelu_out_shape ?gelu_out_a_stride ?gelu_out_b_stride ?gelu_out_out_stride) (ICons ?gu_matmul (ICons ?gelu_sigmoid (INil))))) + (= ?gemma_out (Op (Mul ?geglu_shape ?geglu_a_stride ?geglu_b_stride ?geglu_out_stride) (ICons ?gelu_out (ICons ?up_slice (INil))))) + ) + ( + (set (glumoe_gemma_gelu ?gemma_out) (MkGLUMoEGemmaGELUState ?gate_up_state)) + ) + :ruleset glumoe + :name "GLUMoE gemma gelu marker" +) + +; ===== SwiGLU down marker ===== +(rule + ( + (= ?swiglu_state (glumoe_swiglu ?swiglu_out)) + (= ?swiglu_state (MkGLUMoESwiGLUState ?gate_up_state)) + + (= ?gather_state (glumoe_expert_gather ?dn_f32)) + (= ?gather_state (MkGLUMoEExpertGatherState ?dn_io ?dn_iota_within_range ?topk_idx ?down_w)) + (= ?dn_matmul_mul (Op (Mul ?dn_matmul_mul_shape ?dn_matmul_a_stride ?dn_matmul_b_stride ?dn_matmul_mul_out_stride) (ICons ?swiglu_out (ICons ?dn_f32 (INil))))) + (= ?dn_matmul (Op (Sum ?dn_matmul_out_shape ?dn_matmul_k ?dn_matmul_in_stride ?dn_matmul_k_stride ?dn_matmul_out_stride) (ICons ?dn_matmul_mul (INil)))) + ) + ( + (set (glumoe_swiglu_down ?dn_matmul) + (MkGLUMoESwiGLUDownState ?dn_io ?dn_matmul_k ?dn_iota_within_range ?swiglu_state ?topk_idx ?down_w)) + ) + :ruleset glumoe + :name "GLUMoE swiglu down marker" +) + +; ===== Gemma GELU down marker ===== +(rule + ( + (= ?gemma_state (glumoe_gemma_gelu ?gemma_out)) + (= ?gemma_state (MkGLUMoEGemmaGELUState ?gate_up_state)) + + (= ?gather_state (glumoe_expert_gather ?dn_f32)) + (= ?gather_state (MkGLUMoEExpertGatherState ?dn_io ?dn_iota_within_range ?topk_idx ?down_w)) + (= ?dn_matmul_mul (Op (Mul ?dn_matmul_mul_shape ?dn_matmul_a_stride ?dn_matmul_b_stride ?dn_matmul_mul_out_stride) (ICons ?gemma_out (ICons ?dn_f32 (INil))))) + (= ?dn_matmul (Op (Sum ?dn_matmul_out_shape ?dn_matmul_k ?dn_matmul_in_stride ?dn_matmul_k_stride ?dn_matmul_out_stride) (ICons ?dn_matmul_mul (INil)))) + ) + ( + (set (glumoe_gemma_down ?dn_matmul) + (MkGLUMoEGemmaDownState ?dn_io ?dn_matmul_k ?dn_iota_within_range ?gemma_state ?topk_idx ?down_w)) + ) + :ruleset glumoe + :name "GLUMoE gemma down marker" +) + +; ===== Final fusion: mode 0 (SwiGLU) ===== +(rule + ( + (= ?down_state (glumoe_swiglu_down ?dn_matmul)) + (= ?down_state (MkGLUMoESwiGLUDownState ?dn_io ?dn_matmul_k ?dn_within_range ?swiglu_state ?topk_idx ?down_w)) + (= ?swiglu_state (MkGLUMoESwiGLUState ?gate_up_state)) + (= ?gate_up_state (MkGLUMoEGateUpState ?gu_io ?gu_matmul_k ?gu_within_range ?x ?topk_idx ?gate_up_w)) + + (= ?weighted (Op (Mul ?weighted_shape ?weighted_a_stride ?weighted_b_stride ?weighted_out_stride) (ICons ?dn_matmul (ICons ?topk_vals (INil))))) + (= ?output (Op (Sum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride) (ICons ?weighted (INil)))) + ) + ( + (let ?glumoe (Op (GLUMoE + ?gu_io ?dn_io ?gu_matmul_k ?dn_matmul_k ?output_k + ?gu_within_range ?dn_within_range (MNum 0)) + (ICons ?x (ICons ?topk_idx (ICons ?topk_vals (ICons ?gate_up_w (ICons ?down_w (ICons ?topk_vals (INil))))))))) + (union ?output ?glumoe) + (subsume (Op (Sum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride) (ICons ?weighted (INil)))) + (subsume (Op (KernelSum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride (F32)) (ICons ?weighted (INil)))) + ) + :ruleset glumoe + :name "GLUMoE fused expert computation (swiglu)" +) + +; ===== Final fusion: mode 1 (Gemma GELU) ===== +(rule + ( + (= ?down_state (glumoe_gemma_down ?dn_matmul)) + (= ?down_state (MkGLUMoEGemmaDownState ?dn_io ?dn_matmul_k ?dn_within_range ?gemma_state ?topk_idx ?down_w)) + (= ?gemma_state (MkGLUMoEGemmaGELUState ?gate_up_state)) + (= ?gate_up_state (MkGLUMoEGateUpState ?gu_io ?gu_matmul_k ?gu_within_range ?x ?topk_idx ?gate_up_w)) + + ; Gemma expert weights: topk_weights = normed_topk * per_expert_scale.gather(topk_idx) + (= ?per_expert_vals (Op (Gather ?scale_gather_idx_shape ?scale_gather_idx_stride ?scale_gather_data_shape ?scale_gather_data_stride) (ICons ?topk_idx (ICons ?per_expert_scale (INil))))) + (= ?topk_row_offsets (Op (Iota ?topk_row_offsets_expr ?topk_row_offsets_range) (INil))) + (= ?topk_flat_idx (Op (Add ?topk_flat_idx_shape ?topk_flat_idx_a_stride ?topk_flat_idx_b_stride ?topk_flat_idx_out_stride) (ICons ?topk_row_offsets (ICons ?topk_idx (INil))))) + (= ?topk_vals (Op (Gather ?topk_vals_gather_idx_shape ?topk_vals_gather_idx_stride ?topk_vals_gather_data_shape ?topk_vals_gather_data_stride) (ICons ?topk_flat_idx (ICons ?routing_weights (INil))))) + (= ?topk_norm (Op (Sum ?topk_norm_shape ?output_k ?topk_norm_in_stride ?topk_norm_k_stride ?topk_norm_out_stride) (ICons ?topk_vals (INil)))) + (= ?topk_norm_factor (Op (Recip ?topk_norm_recip_shape ?topk_norm_recip_in_stride ?topk_norm_recip_out_stride) (ICons ?topk_norm (INil)))) + (= ?normed_topk (Op (Mul ?normed_topk_shape ?normed_topk_a_stride ?normed_topk_b_stride ?normed_topk_out_stride) (ICons ?topk_vals (ICons ?topk_norm_factor (INil))))) + (= ?expert_weights (Op (Mul ?expert_weights_shape ?expert_weights_a_stride ?expert_weights_b_stride ?expert_weights_out_stride) (ICons ?normed_topk (ICons ?per_expert_vals (INil))))) + + (= ?weighted (Op (Mul ?weighted_shape ?weighted_a_stride ?weighted_b_stride ?weighted_out_stride) (ICons ?dn_matmul (ICons ?expert_weights (INil))))) + (= ?output (Op (Sum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride) (ICons ?weighted (INil)))) + ) + ( + (let ?glumoe (Op (GLUMoE + ?gu_io ?dn_io ?gu_matmul_k ?dn_matmul_k ?output_k + ?gu_within_range ?dn_within_range (MNum 1)) + (ICons ?x (ICons ?topk_idx (ICons ?topk_vals (ICons ?gate_up_w (ICons ?down_w (ICons ?per_expert_scale (INil))))))))) + (union ?output ?glumoe) + (subsume (Op (Sum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride) (ICons ?weighted (INil)))) + (subsume (Op (KernelSum ?output_shape ?output_k ?output_in_stride ?output_k_stride ?output_out_stride (F32)) (ICons ?weighted (INil)))) + ) + :ruleset glumoe + :name "GLUMoE fused expert computation (gemma_gelu)" +) + +; FlashInfer batch decode attention rewrite rule. +; +; Matches the paged attention pattern for ANY model with GQA: +; Gather(K_cache) → GQA broadcast → Q*K^T matmul → scale → add mask → softmax → attn*V matmul +; Gather(V_cache) → GQA broadcast ──────────────────────────────────────────→ attn*V matmul +; +; Structural anchors (prevent false matches on MLP/other ops): +; - Gather ops from 2D cache pools (MLP never uses Gather) +; - GQA broadcast via Mul(gathered, Constant(1.0)) with all-zero strides +; - Scale Mul(QK, constant) connecting QK scores to mask Add +; - Mask Add with zero-stride broadcast in first dim (nheads broadcast) +; - Data flow: two sequential matmul+reduce pairs connected through softmax +; +; The egglog rule captures the mask as 5th input. During extract(), a Rust +; function walks the mask's computation chain in the e-graph to locate the +; qo_indptr and kv_indptr Input nodes (validated via the Constant(1e10) anchor +; and structural checks). These are appended as inputs 5 and 6 so FlashInfer +; can build the CSR page table directly — no runtime derivation needed. +; +; Shape dimensions are egglog variables, not pinned constants. +; Dynamic dims "s" (batch/seq) and "c" (context) stay pinned as MVar. + +(rule + ( + ; ── Second matmul: Mul(softmax_out, V_gqa) ── + ; Shape: (nheads, s, hdim, c) — 4D + (= ?mul2 (Op (Mul + (ECons ?nheads (ECons (MVar "s") (ECons ?hdim (ECons (MVar "c") (ENil))))) + ?mul2_a_strides + ?mul2_b_strides + ?mul2_out_strides) + (ICons ?soft (ICons ?v_gqa (INil))))) + + ; ── Second matmul: Sum (reduction over c) → output ── + ; Shape: (nheads, s, hdim) — reduces c + (= ?output (Op (Sum + (ECons ?nheads2 (ECons (MVar "s") (ECons ?hdim2 (ENil)))) + (MVar "c") + ?out_in_strides + (MIter) + ?out_out_strides) + (ICons ?mul2 (INil)))) + + ; ── V GQA broadcast: Mul(V_gathered, 1.0) with zero-stride constant ── + ; Shape: (nheads, c, hdim) — 3D + (= ?v_gqa_const (Op (Constant 1.000000) (INil))) + (= ?v_gqa (Op (Mul + (ECons ?nheads3 (ECons (MVar "c") (ECons ?hdim3 (ENil)))) + ?v_gqa_a_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?v_gqa_out_strides) + (ICons ?v_gathered (ICons ?v_gqa_const (INil))))) + + ; ── V Gather: rows from V_cache (2D) ── + ; Shape: (c, kvdim), Source: (num_slots, kvdim) + (= ?v_gathered (Op (Gather + (ECons (MVar "c") (ECons ?kvdim (ENil))) + ?v_gather_strides + (ECons ?num_slots_v (ECons ?kvdim2 (ENil))) + ?v_src_strides) + (ICons ?v_idx (ICons ?v_cache (INil))))) + + ; ── First matmul: Mul(Q, K_gqa) ── + ; Shape: (nheads, s, c, hdim) — 4D + (= ?mul1 (Op (Mul + (ECons ?nheads4 (ECons (MVar "s") (ECons (MVar "c") (ECons ?hdim4 (ENil))))) + ?mul1_a_strides + ?mul1_b_strides + ?mul1_out_strides) + (ICons ?q (ICons ?k_gqa (INil))))) + + ; ── First matmul: Sum (reduction over hdim) → QK scores ── + ; Shape: (nheads, s, c) — reduces hdim + (= ?qk (Op (Sum + (ECons ?nheads5 (ECons (MVar "s") (ECons (MVar "c") (ENil)))) + ?hdim5 + ?qk_in_strides + (MIter) + ?qk_out_strides) + (ICons ?mul1 (INil)))) + + ; ── Mask Add: Add(scaled_QK, mask) ── + ; Shape: (nheads, s, c) — 3D + ; Mask is broadcast from (s, c) via zero-stride in first dim (nheads). + (= ?masked (Op (Add + (ECons ?nheads8 (ECons (MVar "s") (ECons (MVar "c") (ENil)))) + ?mask_add_a_strides + (ECons (MNum 0) ?mask_rest_strides) + ?mask_add_out_strides) + (ICons ?scaled_qk (ICons ?mask (INil))))) + + ; ── K GQA broadcast: Mul(K_gathered, 1.0) with zero-stride constant ── + ; Shape: (nheads, hdim, c) — 3D + (= ?k_gqa_const (Op (Constant 1.000000) (INil))) + (= ?k_gqa (Op (Mul + (ECons ?nheads6 (ECons ?hdim6 (ECons (MVar "c") (ENil)))) + ?k_gqa_a_strides + (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) + ?k_gqa_out_strides) + (ICons ?k_gathered (ICons ?k_gqa_const (INil))))) + + ; ── K Gather: rows from K_cache (2D) ── + ; Shape: (c, kvdim), Source: (num_slots, kvdim) + (= ?k_gathered (Op (Gather + (ECons (MVar "c") (ECons ?kvdim3 (ENil))) + ?k_gather_strides + (ECons ?num_slots_k (ECons ?kvdim4 (ENil))) + ?k_src_strides) + (ICons ?k_idx (ICons ?k_cache (INil))))) + + ; ── Dtype consistency ── + (= ?dt (dtype ?q)) + (= ?dt (dtype ?k_cache)) + (= ?dt (dtype ?v_cache)) + ) + ( + (let ?fi (Op (FlashInferAttention + ?nheads (MDiv ?kvdim ?hdim) ?hdim (MNum 1) (MVar "s")) + (ICons ?q (ICons ?k_cache (ICons ?v_cache (ICons ?k_idx (ICons ?mask (INil)))))))) + (union ?output ?fi) + (set (dtype ?fi) ?dt) + ) + :ruleset matmul_backend + :name "FlashInfer batch decode attention" +) + +(rule ((= ?__e (Input ?v60_node ?v60_label ?v60_dtype))) ((set (dtype ?__e) ?v60_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Output ?v61_inp ?v61_node)) (= ?__dty (dtype ?v61_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (CustomOpKind ?v62_id ?v62_dtype) ?__inputs))) ((set (dtype ?__e) ?v62_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (LoopStart ?v63_inp ?v63_loop_id ?v63_slot_idx ?v63_iters ?v63_dtype))) ((set (dtype ?__e) ?v63_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (LoopEnd ?v64_inp ?v64_loop_id ?v64_slot_idx ?v64_dtype))) ((set (dtype ?__e) ?v64_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Op (LoopInput ?v65_loop_id ?v65_stream_id ?v65_dtype) ?__inputs))) ((set (dtype ?__e) ?v65_dtype)) :ruleset dtype_prop) + + (relation identical_inputs (IList)) + + ; All four rules live in the `expr` ruleset, which the schedule + ; saturates each iteration. Default-ruleset scheduling only runs + ; each rule once per outer step, which is not enough to propagate + ; `identical_inputs` through an N-element IList. + + ; Base: single-element list is trivially identical. + (rule ((= ?l (ICons ?x (INil)))) + ((identical_inputs ?l)) + :ruleset expr + :name "identical_inputs base") + + ; Inductive: head equals next-head, and the tail starting at next-head is identical. + (rule ((= ?l (ICons ?x (ICons ?x ?tail))) + (identical_inputs (ICons ?x ?tail))) + ((identical_inputs ?l)) + :ruleset expr + :name "identical_inputs ind") + + ; LoopInput with an identical IList is equivalent to LoopInputStatic over a single copy. + (rule ((= ?e (Op (LoopInput ?id ?stream ?dt) (ICons ?x ?cont))) + (identical_inputs (ICons ?x ?cont))) + ((let ?static (Op (LoopInputStatic ?id ?stream ?dt) (ICons ?x (INil)))) + (union ?e ?static)) + :ruleset expr + :name "LoopInput to LoopInputStatic") + + ; LoopInputStatic is equivalent to its single inner value — collapses the boundary + ; wrapper for pattern-matching and extraction purposes. + (rule ((= ?e (Op (LoopInputStatic ?id ?stream ?dt) (ICons ?x (INil))))) + ((union ?e ?x)) + :ruleset expr + :name "LoopInputStatic inline") + +(rule ((= ?__e (Op (LoopInputStatic ?v66_loop_id ?v66_stream_id ?v66_dtype) ?__inputs))) ((set (dtype ?__e) ?v66_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Op (LoopOutput ?v67_loop_id ?v67_stream_id ?v67_dtype) ?__inputs))) ((set (dtype ?__e) ?v67_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Op (LoopOutputSelect ?v68_loop_id ?v68_stream_id ?v68_iter ?v68_dtype) ?__inputs))) ((set (dtype ?__e) ?v68_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Constant ?v69_value) ?__inputs))) ((set (dtype ?__e) (F32))) :ruleset dtype_prop) +(rule ((= ?__e (Op (Cast ?v70_size ?v70_dtype) ?__inputs))) ((set (dtype ?__e) ?v70_dtype)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Iota ?v71_expr ?v71_range) ?__inputs))) ((set (dtype ?__e) (Int))) :ruleset dtype_prop) +(rule ((= ?__e (Op (Exp2 ?v72_shape ?v72_strides ?v72_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Log2 ?v73_shape ?v73_strides ?v73_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Sin ?v74_shape ?v74_strides ?v74_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Recip ?v75_shape ?v75_strides ?v75_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Sqrt ?v76_shape ?v76_strides ?v76_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Add ?v77_shape ?v77_a_strides ?v77_b_strides ?v77_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Add body trips=2 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Add body trips=2 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Add ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Add body trips=3 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Add ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Add body trips=3 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Add ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (let ?u3 (Op (Add ?sh ?as ?bs ?os) (ICons ?u2 (ICons ?s3 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Add body trips=4 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Add ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Add ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Add ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Add ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (let ?u3 (Op (Add ?sh ?as ?bs ?os) (ICons ?s3 (ICons ?u2 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Add body trips=4 state=1" + ) +(rule ((= ?__e (Op (Mul ?v78_shape ?v78_a_strides ?v78_b_strides ?v78_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Mul body trips=2 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Mul body trips=2 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Mul body trips=3 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Mul body trips=3 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (let ?u3 (Op (Mul ?sh ?as ?bs ?os) (ICons ?u2 (ICons ?s3 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Mul body trips=4 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Mul ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (let ?u3 (Op (Mul ?sh ?as ?bs ?os) (ICons ?s3 (ICons ?u2 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Mul body trips=4 state=1" + ) +(rule ((= ?__e (Op (Mod ?v79_shape ?v79_a_strides ?v79_b_strides ?v79_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Mod body trips=2 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll Mod body trips=2 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Mod body trips=3 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll Mod body trips=3 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (let ?u3 (Op (Mod ?sh ?as ?bs ?os) (ICons ?u2 (ICons ?s3 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Mod body trips=4 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (Mod ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (let ?u3 (Op (Mod ?sh ?as ?bs ?os) (ICons ?s3 (ICons ?u2 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll Mod body trips=4 state=1" + ) +(rule ((= ?__e (Op (LessThan ?v80_shape ?v80_a_strides ?v80_b_strides ?v80_out_strides) ?__inputs))) ((set (dtype ?__e) (Bool))) :ruleset dtype_prop) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll LessThan body trips=2 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 2) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (INil))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (union ?le ?u1) + ) + :ruleset expr + :name "unroll LessThan body trips=2 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll LessThan body trips=3 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 3) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (INil)))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (union ?le ?u2) + ) + :ruleset expr + :name "unroll LessThan body trips=3 state=1" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?ls (ICons ?li (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?initial (ICons ?s0 (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u0 (ICons ?s1 (INil))))) + (let ?u2 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u1 (ICons ?s2 (INil))))) + (let ?u3 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?u2 (ICons ?s3 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll LessThan body trips=4 state=0" + ) +(rule + ( + (= ?ls (LoopStart ?initial ?loop_id ?slot_idx (MNum 4) ?dt)) + (= ?li (Op (LoopInput ?loop_id ?stream ?dt) (ICons ?s0 (ICons ?s1 (ICons ?s2 (ICons ?s3 (INil))))))) + (= ?body (Op (LessThan ?sh ?as ?bs ?os) (ICons ?li (ICons ?ls (INil))))) + (= ?le (LoopEnd ?body ?loop_id ?slot_idx ?dt)) + ) + ( + (let ?u0 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s0 (ICons ?initial (INil))))) + (let ?u1 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s1 (ICons ?u0 (INil))))) + (let ?u2 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s2 (ICons ?u1 (INil))))) + (let ?u3 (Op (LessThan ?sh ?as ?bs ?os) (ICons ?s3 (ICons ?u2 (INil))))) + (union ?le ?u3) + ) + :ruleset expr + :name "unroll LessThan body trips=4 state=1" + ) +(rule ((= ?__e (Op (Gather ?v81_index_shape ?v81_index_strides ?v81_data_shape ?v81_data_strides) (ICons ?__indexes (ICons ?__data ?__tail)))) (= ?__dty (dtype ?__data))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Scatter ?v82_dest_shape ?v82_dest_strides ?v82_index_shape ?v82_index_strides ?v82_src_strides) (ICons ?__dest (ICons ?__indexes (ICons ?__src ?__tail))))) (= ?__dty (dtype ?__src))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Sum ?v83_shape ?v83_iters ?v83_strides ?v83_iter_stride ?v83_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +; Squeeze: remove outermost dim=1 from Mul+Sum +; [1, d1, d2, ...] → [d1, d2, ...] via direct union +; +; When the outermost dimension of the Sum output is 1, it can always be +; removed regardless of strides (index 0 contributes 0*stride = 0 to +; every address). This enables downstream 2D matmul rules (cuBLAS) to match. +; The rule fires recursively: 4D → 3D → 2D. +; +; Direct union is safe because the total element count is preserved +; (1*N = N) and downstream ops use their own strides to index into the +; flat buffer, which has the same layout regardless of the leading dim=1. + +(rule + ( + ; Match Mul + Sum pattern (Op wrapper syntax) + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?sum_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Sum output shape starts with 1 + (= ?sum_shape (ECons (MNum 1) ?rest_sum_shape)) + ; Result must have >= 2 dims (don't collapse below 2D) + (!= ?rest_sum_shape (ENil)) + (= ?rest_sum_len (len ?rest_sum_shape)) + (>= ?rest_sum_len 2) + + ; Mul shape also starts with 1 + (= ?mul_shape (ECons (MNum 1) ?rest_mul_shape)) + + ; Destructure all stride lists to drop first element + (= ?a_stride (ECons ?as0 ?rest_as)) + (= ?b_stride (ECons ?bs0 ?rest_bs)) + (= ?mul_out_stride (ECons ?mos0 ?rest_mos)) + (= ?sum_in_stride (ECons ?sis0 ?rest_sis)) + (= ?sum_out_stride (ECons ?sos0 ?rest_sos)) + + ; Get dtype + (= ?dt (dtype ?a)) + ) + ( + ; Create collapsed Mul (drop outermost dim from all lists) + (let ?new_mul (Op (Mul ?rest_mul_shape + ?rest_as + ?rest_bs + ?rest_mos) + (ICons ?a (ICons ?b (INil))))) + + ; Create collapsed Sum + (let ?new_sum (Op (Sum ?rest_sum_shape ?k + ?rest_sis ?k_stride ?rest_sos) + (ICons ?new_mul (INil)))) + + ; Direct union — no wrapper needed + (union ?sum ?new_sum) + + ; Propagate dtype + (set (dtype ?new_mul) ?dt) + (set (dtype ?new_sum) ?dt) + ) + :ruleset matmul_flatten + :name "batch-collapse squeeze dim=1" +) + +; Batch-merge: collapse outermost two dims when A is contiguous, B is broadcast +; [d0, d1, ...] → [d0*d1, ...] via direct union +; +; Preconditions: +; - A's outermost stride is contiguous: a_stride[0] = a_stride[1] * dim[1] +; - B is broadcast on both leading dims: b_stride[0] = 0, b_stride[1] = 0 +; - Output strides are contiguous on the leading dims +; +; Direct union is safe because the total element count is preserved +; (d0*d1 = d0*d1) and the flat buffer layout is identical. + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?sum_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Sum shape has >= 3 dims (result will have >= 2) + (= ?sum_shape (ECons ?sd0 (ECons ?sd1 ?rest_sum_shape))) + (!= ?rest_sum_shape (ENil)) + + ; Mul shape + (= ?mul_shape (ECons ?d0 (ECons ?d1 ?rest_mul_shape))) + + ; A strides: a_s0 = a_s1 * d1 (contiguous) + (= ?a_stride (ECons ?as0 (ECons ?as1 ?rest_as))) + (= ?as0 (MMul ?as1 ?d1)) + + ; B strides: broadcast on both leading dims + (= ?b_stride (ECons (MNum 0) (ECons (MNum 0) ?rest_bs))) + + ; Mul output strides: contiguous (os0 = os1 * d1) + (= ?mul_out_stride (ECons ?mos0 (ECons ?mos1 ?rest_mos))) + (= ?mos0 (MMul ?mos1 ?d1)) + + ; Sum input strides: contiguous leading + (= ?sum_in_stride (ECons ?sis0 (ECons ?sis1 ?rest_sis))) + (= ?sis0 (MMul ?sis1 ?sd1)) + + ; Sum output strides: contiguous leading + (= ?sum_out_stride (ECons ?sos0 (ECons ?sos1 ?rest_sos))) + (= ?sos0 (MMul ?sos1 ?sd1)) + + (= ?dt (dtype ?a)) + ) + ( + ; Merged dimensions + (let ?new_d (MMul ?d0 ?d1)) + (let ?new_sd (MMul ?sd0 ?sd1)) + + ; Collapsed Mul: merged leading dim, A uses as1, B uses 0 + (let ?new_mul (Op (Mul (ECons ?new_d ?rest_mul_shape) + (ECons ?as1 ?rest_as) + (ECons (MNum 0) ?rest_bs) + (ECons ?mos1 ?rest_mos)) + (ICons ?a (ICons ?b (INil))))) + + ; Collapsed Sum + (let ?new_sum (Op (Sum (ECons ?new_sd ?rest_sum_shape) + ?k + (ECons ?sis1 ?rest_sis) + ?k_stride + (ECons ?sos1 ?rest_sos)) + (ICons ?new_mul (INil)))) + + ; Direct union + (union ?sum ?new_sum) + (set (dtype ?new_mul) ?dt) + (set (dtype ?new_sum) ?dt) + ) + :ruleset matmul_flatten + :name "batch-collapse merge A-contiguous B-broadcast" +) + +; Batch-merge: collapse outermost two dims when B is contiguous, A is broadcast +; [d0, d1, ...] → [d0*d1, ...] via direct union +; +; Symmetric case of batch_merge_a_contig: +; - B's outermost stride is contiguous: b_stride[0] = b_stride[1] * dim[1] +; - A is broadcast on both leading dims: a_stride[0] = 0, a_stride[1] = 0 +; - Output strides are contiguous on the leading dims + +(rule + ( + (= ?mul (Op (Mul ?mul_shape ?a_stride ?b_stride ?mul_out_stride) (ICons ?a (ICons ?b (INil))))) + (= ?sum (Op (Sum ?sum_shape ?k ?sum_in_stride ?k_stride ?sum_out_stride) (ICons ?mul (INil)))) + + ; Sum shape has >= 3 dims + (= ?sum_shape (ECons ?sd0 (ECons ?sd1 ?rest_sum_shape))) + (!= ?rest_sum_shape (ENil)) + + ; Mul shape + (= ?mul_shape (ECons ?d0 (ECons ?d1 ?rest_mul_shape))) + + ; A strides: broadcast on both leading dims + (= ?a_stride (ECons (MNum 0) (ECons (MNum 0) ?rest_as))) + + ; B strides: b_s0 = b_s1 * d1 (contiguous) + (= ?b_stride (ECons ?bs0 (ECons ?bs1 ?rest_bs))) + (= ?bs0 (MMul ?bs1 ?d1)) + + ; Mul output strides: contiguous (os0 = os1 * d1) + (= ?mul_out_stride (ECons ?mos0 (ECons ?mos1 ?rest_mos))) + (= ?mos0 (MMul ?mos1 ?d1)) + + ; Sum input strides: contiguous leading + (= ?sum_in_stride (ECons ?sis0 (ECons ?sis1 ?rest_sis))) + (= ?sis0 (MMul ?sis1 ?sd1)) + + ; Sum output strides: contiguous leading + (= ?sum_out_stride (ECons ?sos0 (ECons ?sos1 ?rest_sos))) + (= ?sos0 (MMul ?sos1 ?sd1)) + + (= ?dt (dtype ?a)) + ) + ( + ; Merged dimensions + (let ?new_d (MMul ?d0 ?d1)) + (let ?new_sd (MMul ?sd0 ?sd1)) + + ; Collapsed Mul: merged leading dim, A uses 0, B uses bs1 + (let ?new_mul (Op (Mul (ECons ?new_d ?rest_mul_shape) + (ECons (MNum 0) ?rest_as) + (ECons ?bs1 ?rest_bs) + (ECons ?mos1 ?rest_mos)) + (ICons ?a (ICons ?b (INil))))) + + ; Collapsed Sum + (let ?new_sum (Op (Sum (ECons ?new_sd ?rest_sum_shape) + ?k + (ECons ?sis1 ?rest_sis) + ?k_stride + (ECons ?sos1 ?rest_sos)) + (ICons ?new_mul (INil)))) + + ; Direct union + (union ?sum ?new_sum) + (set (dtype ?new_mul) ?dt) + (set (dtype ?new_sum) ?dt) + ) + :ruleset matmul_flatten + :name "batch-collapse merge B-contiguous A-broadcast" +) + +(rule ((= ?__e (Op (Max ?v84_shape ?v84_iters ?v84_strides ?v84_iter_stride ?v84_out_strides) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) +(rule ((= ?__e (Op (Softmax ?v85_shape ?v85_in_strides ?v85_out_strides ?v85_reduce_dim ?v85_reduce_stride) (ICons ?__first_inp ?__tail))) (= ?__dty (dtype ?__first_inp))) ((set (dtype ?__e) ?__dty)) :ruleset dtype_prop) + +(ruleset cuda_memory_analysis) +(relation cuda_output_bytes (OpKind Expression)) +(relation cuda_local_memory (IR Expression)) + +(rule ((= ?node (Input ?id ?label ?dtype))) + ((cuda_local_memory ?node (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-input") + +(rule ((= ?node (Output ?inp ?id))) + ((cuda_local_memory ?node (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-output") + +(rule ((= ?node (OutputJoin ?a ?b))) + ((cuda_local_memory ?node (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-output-join") + +(rule ((= ?node (Op ?kind ?inputs)) + (cuda_output_bytes ?kind ?bytes)) + ((cuda_local_memory ?node ?bytes)) + :ruleset cuda_memory_analysis + :name "cuda-memory-op-local") + +(rule + ((= ?kind (FusedAdd ?shape ?a_strides ?b_strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedAdd-zero" +) +(rule + ((= ?kind (FusedExp ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedExp-zero" +) +(rule + ((= ?kind (FusedExp2 ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedExp2-zero" +) +(rule + ((= ?kind (FusedLog2 ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedLog2-zero" +) +(rule + ((= ?kind (FusedMul ?shape ?a_strides ?b_strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedMul-zero" +) +(rule + ((= ?kind (FusedRecip ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedRecip-zero" +) +(rule + ((= ?kind (FusedSin ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedSin-zero" +) +(rule + ((= ?kind (FusedSqrt ?shape ?strides ?out_strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusedSqrt-zero" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-F32-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-F16-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-Bf16-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-Int-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-Bool-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-I4-bytes" +) +(rule + ((= ?kind (FusionEnd ?shape ?strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionEnd-TF32-bytes" +) +(rule + ((= ?kind (FusionStart ?shape ?strides ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-FusionStart-zero" +) +(rule + ((= ?kind (GLUMoE ?gu_io ?dn_io ?gu_matmul_k ?dn_matmul_k ?output_k ?gu_within_range ?dn_within_range ?mode))) + ((cuda_output_bytes ?kind (MMul (MMul (MVar "s") ?gu_matmul_k) (MNum 4)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-GLUMoE-f32-glumoe" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-F32-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-F16-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-Bf16-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-Int-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-Bool-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-I4-bytes" +) +(rule + ((= ?kind (KernelAdd ?shape ?a_strides ?b_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelAdd-TF32-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-F32-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-F16-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-Bf16-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-Int-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-Bool-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-I4-bytes" +) +(rule + ((= ?kind (KernelBatchMatMul ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatMul-TF32-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-F32-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-F16-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-Bf16-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-Int-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-Bool-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-I4-bytes" +) +(rule + ((= ?kind (KernelBatchMatVec ?out_shape ?k_dim ?a_stride ?a_k_stride ?b_stride ?b_k_stride ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelBatchMatVec-TF32-bytes" +) +(rule + ((= ?kind (KernelCast ?size (F32) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-F32-bytes" +) +(rule + ((= ?kind (KernelCast ?size (F16) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-F16-bytes" +) +(rule + ((= ?kind (KernelCast ?size (Bf16) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-Bf16-bytes" +) +(rule + ((= ?kind (KernelCast ?size (Int) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-Int-bytes" +) +(rule + ((= ?kind (KernelCast ?size (Bool) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-Bool-bytes" +) +(rule + ((= ?kind (KernelCast ?size (I4) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-I4-bytes" +) +(rule + ((= ?kind (KernelCast ?size (TF32) ?src_dtype))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?size (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelCast-TF32-bytes" +) +(rule + ((= ?kind (KernelConstant ?value))) + ((cuda_output_bytes ?kind (MNum 4))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelConstant-f32-scalar" +) +(rule + ((= ?kind (KernelEmbed ?batch_shape ?token_stride ?out_stride ?embed_dim)) + (= ?__cuda_elems (n_elements ?batch_shape))) + ((cuda_output_bytes ?kind (MMul (MMul ?__cuda_elems ?embed_dim) (MNum 4)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelEmbed-f32-embed" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-F32-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-F16-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-Bf16-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-Int-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-Bool-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-I4-bytes" +) +(rule + ((= ?kind (KernelExp ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp-TF32-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-F32-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-F16-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-Bf16-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-Int-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-Bool-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-I4-bytes" +) +(rule + ((= ?kind (KernelExp2 ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelExp2-TF32-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-F32-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-F16-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-Bf16-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-Int-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-Bool-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-I4-bytes" +) +(rule + ((= ?kind (KernelGather ?out_shape ?index_strides ?data_shape ?data_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?out_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelGather-TF32-bytes" +) +(rule + ((= ?kind (KernelIota ?expr ?range))) + ((cuda_output_bytes ?kind (MMul ?range (MNum 4)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelIota-int-range" +) +(rule + ((= ?kind (KernelLessThan ?shape ?a_strides ?b_strides ?out_strides ?dtype)) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind ?__cuda_elems)) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLessThan-bool-shape" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-F32-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-F16-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-Bf16-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-Int-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-Bool-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-I4-bytes" +) +(rule + ((= ?kind (KernelLog2 ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelLog2-TF32-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-F32-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-F16-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-Bf16-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-Int-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-Bool-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-I4-bytes" +) +(rule + ((= ?kind (KernelMax ?shape ?iters ?strides ?iter_stride ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMax-TF32-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-F32-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-F16-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-Bf16-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-Int-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-Bool-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-I4-bytes" +) +(rule + ((= ?kind (KernelMean ?shape ?iters ?strides ?iter_stride ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMean-TF32-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-F32-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-F16-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-Bf16-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-Int-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-Bool-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-I4-bytes" +) +(rule + ((= ?kind (KernelMod ?shape ?a_strides ?b_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMod-TF32-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-F32-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-F16-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-Bf16-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-Int-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-Bool-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-I4-bytes" +) +(rule + ((= ?kind (KernelMul ?shape ?a_strides ?b_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelMul-TF32-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-F32-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-F16-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-Bf16-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-Int-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-Bool-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-I4-bytes" +) +(rule + ((= ?kind (KernelRecip ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelRecip-TF32-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-F32-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-F16-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-Bf16-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-Int-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-Bool-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-I4-bytes" +) +(rule + ((= ?kind (KernelScatter ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatter-TF32-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-F32-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-F16-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-Bf16-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-Int-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-Bool-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-I4-bytes" +) +(rule + ((= ?kind (KernelScatterNoCopy ?dest_shape ?dest_strides ?index_shape ?index_strides ?src_strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?dest_shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelScatterNoCopy-TF32-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-F32-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-F16-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-Bf16-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-Int-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-Bool-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-I4-bytes" +) +(rule + ((= ?kind (KernelSigmoid ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSigmoid-TF32-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-F32-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-F16-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-Bf16-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-Int-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-Bool-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-I4-bytes" +) +(rule + ((= ?kind (KernelSin ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSin-TF32-bytes" +) +(rule + ((= ?kind (KernelSoftmax ?shape ?in_strides ?out_strides ?reduce_dim ?reduce_stride ?dtype)) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MMul ?__cuda_elems (MNum 4)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSoftmax-f32-shape" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-F32-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-F16-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-Bf16-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-Int-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-Bool-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-I4-bytes" +) +(rule + ((= ?kind (KernelSqrt ?shape ?strides ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSqrt-TF32-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (F32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-F32-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (F16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-F16-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (Bf16))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-Bf16-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (Int))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-Int-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (Bool))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-Bool-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (I4))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-I4-bytes" +) +(rule + ((= ?kind (KernelSum ?shape ?iters ?strides ?iter_stride ?out_strides (TF32))) + (= ?__cuda_elems (n_elements ?shape))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul ?__cuda_elems (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-KernelSum-TF32-bytes" +) +(rule + ((= ?kind (LoopInput ?loop_id ?stream_id ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-LoopInput-zero" +) +(rule + ((= ?kind (LoopInputStatic ?loop_id ?stream_id ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-LoopInputStatic-zero" +) +(rule + ((= ?kind (LoopOutput ?loop_id ?stream_id ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-LoopOutput-zero" +) +(rule + ((= ?kind (LoopOutputSelect ?loop_id ?stream_id ?iter ?dtype))) + ((cuda_output_bytes ?kind (MNum 0))) + :ruleset cuda_memory_analysis + :name "cuda-memory-LoopOutputSelect-zero" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (F32) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-F32-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (F16) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-F16-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (Bf16) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 16)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-Bf16-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (Int) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 32)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-Int-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (Bool) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 8)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-Bool-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (I4) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 4)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-I4-bytes" +) +(rule + ((= ?kind (cublaslt ?m ?n ?k ?a_layout ?b_layout ?a_order ?b_order ?c_order ?d_order ?lda ?ldb ?ldc ?ldd ?batch_count ?stride_a ?stride_b ?stride_c ?stride_d ?a_dtype ?b_dtype ?c_dtype (TF32) ?compute_type ?scale_dtype ?alpha ?beta ?epilogue))) + ((cuda_output_bytes ?kind (MCeilDiv (MMul (MMul (MMul ?batch_count ?m) ?n) (MNum 19)) (MNum 8)))) + :ruleset cuda_memory_analysis + :name "cuda-memory-cublaslt-TF32-bytes" +) diff --git a/tests/integration_test.rs b/tests/integration_test.rs index 19a7a270..4c5320cd 100644 --- a/tests/integration_test.rs +++ b/tests/integration_test.rs @@ -784,6 +784,35 @@ fn test_value_to_classid() { assert_eq!(value, egraph.class_id_to_value(&class_id)); } +#[test] +fn test_serialize_sort_name_with_dash() { + // A sort whose name contains '-' (legal, like the built-in `vec-set`) must + // serialize without panicking, and its class ID must still round-trip. + let mut egraph = EGraph::default(); + let outputs = egraph + .parse_and_run_program( + None, + r#" + (datatype Math-Expr (Lit i64)) + (Lit 5) + (extract (Lit 5)) + "#, + ) + .unwrap(); + let CommandOutput::ExtractBest(termdag, _cost, term) = outputs[0].clone() else { + panic!(); + }; + let expr = termdag.term_to_expr(&term, span!()); + let (sort, value) = egraph.eval_expr(&expr).unwrap(); + assert_eq!(sort.name(), "Math-Expr"); + + let serialize_output = egraph.serialize(SerializeConfig::default()); + assert!(serialize_output.is_complete()); + let class_id = egraph.value_to_class_id(&sort, value); + assert!(serialize_output.egraph.class_data.get(&class_id).is_some()); + assert_eq!(value, egraph.class_id_to_value(&class_id)); +} + #[test] fn test_serialize_617() { let program = " diff --git a/tests/llama.egg b/tests/llama.egg new file mode 100644 index 00000000..2e787068 --- /dev/null +++ b/tests/llama.egg @@ -0,0 +1,1661 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "token_ids" (Int))) +(let t2 (Input 2 "kv_cache.0.k" (F32))) +(let t3 (Output t2 2)) +(let t4 (Input 4 "kv_cache.0.v" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.1.k" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.2.k" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.v" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.3.k" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.v" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.4.k" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "kv_cache.4.v" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "kv_cache.5.k" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "kv_cache.5.v" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "kv_cache.6.k" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "kv_cache.6.v" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "kv_cache.7.k" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "kv_cache.7.v" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "kv_cache.8.k" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "kv_cache.8.v" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "kv_cache.9.k" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "kv_cache.9.v" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "kv_cache.10.k" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "kv_cache.10.v" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "kv_cache.11.k" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "kv_cache.11.v" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "kv_cache.12.k" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "kv_cache.12.v" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "kv_cache.13.k" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "kv_cache.13.v" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "kv_cache.14.k" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "kv_cache.14.v" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "kv_cache.15.k" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "kv_cache.15.v" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "kv_cache.16.k" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "kv_cache.16.v" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "kv_cache.17.k" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "kv_cache.17.v" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "kv_cache.18.k" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "kv_cache.18.v" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "kv_cache.19.k" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "kv_cache.19.v" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "kv_cache.20.k" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "kv_cache.20.v" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "kv_cache.21.k" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "kv_cache.21.v" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "kv_cache.22.k" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "kv_cache.22.v" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "kv_cache.23.k" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "kv_cache.23.v" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "kv_cache.24.k" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "kv_cache.24.v" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "kv_cache.25.k" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "kv_cache.25.v" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "kv_cache.26.k" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "kv_cache.26.v" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "kv_cache.27.k" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "kv_cache.27.v" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "kv_cache.28.k" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "kv_cache.28.v" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "kv_cache.29.k" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "kv_cache.29.v" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "kv_cache.30.k" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "kv_cache.30.v" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "kv_cache.31.k" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "kv_cache.31.v" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "model.layers.0.mlp.up_proj.weight" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "model.layers.0.mlp.gate_proj.weight" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "model.layers.0.mlp.down_proj.weight" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "model.layers.0.input_layernorm.weight" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "model.layers.1.mlp.up_proj.weight" (F32))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "model.layers.1.mlp.gate_proj.weight" (F32))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "model.layers.1.mlp.down_proj.weight" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "model.layers.1.input_layernorm.weight" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "model.layers.2.mlp.up_proj.weight" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "model.layers.2.mlp.gate_proj.weight" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "model.layers.2.mlp.down_proj.weight" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "model.layers.2.input_layernorm.weight" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "model.layers.3.mlp.up_proj.weight" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "model.layers.3.mlp.gate_proj.weight" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "model.layers.3.mlp.down_proj.weight" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.layers.3.input_layernorm.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.layers.4.mlp.up_proj.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.layers.4.mlp.gate_proj.weight" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.layers.4.mlp.down_proj.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.layers.4.input_layernorm.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.layers.5.mlp.up_proj.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.layers.5.mlp.gate_proj.weight" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.layers.5.mlp.down_proj.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.layers.5.self_attn.v_proj.weight" (F32))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.layers.5.input_layernorm.weight" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.layers.6.mlp.up_proj.weight" (F32))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.layers.6.mlp.gate_proj.weight" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.layers.6.mlp.down_proj.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.layers.6.input_layernorm.weight" (F32))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.layers.7.mlp.up_proj.weight" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.layers.7.mlp.gate_proj.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.layers.7.mlp.down_proj.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.layers.7.input_layernorm.weight" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.layers.8.mlp.up_proj.weight" (F32))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.layers.8.mlp.gate_proj.weight" (F32))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.layers.8.mlp.down_proj.weight" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.layers.8.input_layernorm.weight" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.layers.9.mlp.up_proj.weight" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.layers.9.mlp.gate_proj.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.layers.9.mlp.down_proj.weight" (F32))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.layers.9.input_layernorm.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.layers.10.mlp.up_proj.weight" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.layers.10.mlp.gate_proj.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.layers.10.mlp.down_proj.weight" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.layers.10.input_layernorm.weight" (F32))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.layers.11.mlp.up_proj.weight" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.layers.11.mlp.gate_proj.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.layers.11.mlp.down_proj.weight" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.layers.11.self_attn.v_proj.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.layers.11.input_layernorm.weight" (F32))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.layers.12.mlp.up_proj.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.layers.12.mlp.gate_proj.weight" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.layers.12.mlp.down_proj.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t353 (Output t352 352)) +(let t354 (Input 354 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t355 (Output t354 354)) +(let t356 (Input 356 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t357 (Output t356 356)) +(let t358 (Input 358 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t359 (Output t358 358)) +(let t360 (Input 360 "model.layers.12.input_layernorm.weight" (F32))) +(let t361 (Output t360 360)) +(let t362 (Input 362 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t363 (Output t362 362)) +(let t364 (Input 364 "model.layers.13.mlp.up_proj.weight" (F32))) +(let t365 (Output t364 364)) +(let t366 (Input 366 "model.layers.13.mlp.gate_proj.weight" (F32))) +(let t367 (Output t366 366)) +(let t368 (Input 368 "model.layers.13.mlp.down_proj.weight" (F32))) +(let t369 (Output t368 368)) +(let t370 (Input 370 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t371 (Output t370 370)) +(let t372 (Input 372 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t373 (Output t372 372)) +(let t374 (Input 374 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t375 (Output t374 374)) +(let t376 (Input 376 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t377 (Output t376 376)) +(let t378 (Input 378 "model.layers.13.input_layernorm.weight" (F32))) +(let t379 (Output t378 378)) +(let t380 (Input 380 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t381 (Output t380 380)) +(let t382 (Input 382 "model.layers.14.mlp.up_proj.weight" (F32))) +(let t383 (Output t382 382)) +(let t384 (Input 384 "model.layers.14.mlp.gate_proj.weight" (F32))) +(let t385 (Output t384 384)) +(let t386 (Input 386 "model.layers.14.mlp.down_proj.weight" (F32))) +(let t387 (Output t386 386)) +(let t388 (Input 388 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t389 (Output t388 388)) +(let t390 (Input 390 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t391 (Output t390 390)) +(let t392 (Input 392 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t393 (Output t392 392)) +(let t394 (Input 394 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t395 (Output t394 394)) +(let t396 (Input 396 "model.layers.14.input_layernorm.weight" (F32))) +(let t397 (Output t396 396)) +(let t398 (Input 398 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t399 (Output t398 398)) +(let t400 (Input 400 "model.layers.15.mlp.up_proj.weight" (F32))) +(let t401 (Output t400 400)) +(let t402 (Input 402 "model.layers.15.mlp.gate_proj.weight" (F32))) +(let t403 (Output t402 402)) +(let t404 (Input 404 "model.layers.15.mlp.down_proj.weight" (F32))) +(let t405 (Output t404 404)) +(let t406 (Input 406 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t407 (Output t406 406)) +(let t408 (Input 408 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t409 (Output t408 408)) +(let t410 (Input 410 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t411 (Output t410 410)) +(let t412 (Input 412 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t413 (Output t412 412)) +(let t414 (Input 414 "model.layers.15.input_layernorm.weight" (F32))) +(let t415 (Output t414 414)) +(let t416 (Input 416 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t417 (Output t416 416)) +(let t418 (Input 418 "model.layers.16.mlp.up_proj.weight" (F32))) +(let t419 (Output t418 418)) +(let t420 (Input 420 "model.layers.16.mlp.gate_proj.weight" (F32))) +(let t421 (Output t420 420)) +(let t422 (Input 422 "model.layers.16.mlp.down_proj.weight" (F32))) +(let t423 (Output t422 422)) +(let t424 (Input 424 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t425 (Output t424 424)) +(let t426 (Input 426 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t427 (Output t426 426)) +(let t428 (Input 428 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t429 (Output t428 428)) +(let t430 (Input 430 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t431 (Output t430 430)) +(let t432 (Input 432 "model.layers.16.input_layernorm.weight" (F32))) +(let t433 (Output t432 432)) +(let t434 (Input 434 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t435 (Output t434 434)) +(let t436 (Input 436 "model.layers.17.mlp.up_proj.weight" (F32))) +(let t437 (Output t436 436)) +(let t438 (Input 438 "model.layers.17.mlp.gate_proj.weight" (F32))) +(let t439 (Output t438 438)) +(let t440 (Input 440 "model.layers.17.mlp.down_proj.weight" (F32))) +(let t441 (Output t440 440)) +(let t442 (Input 442 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t443 (Output t442 442)) +(let t444 (Input 444 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t445 (Output t444 444)) +(let t446 (Input 446 "model.layers.17.self_attn.v_proj.weight" (F32))) +(let t447 (Output t446 446)) +(let t448 (Input 448 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t449 (Output t448 448)) +(let t450 (Input 450 "model.layers.17.input_layernorm.weight" (F32))) +(let t451 (Output t450 450)) +(let t452 (Input 452 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t453 (Output t452 452)) +(let t454 (Input 454 "model.layers.18.mlp.up_proj.weight" (F32))) +(let t455 (Output t454 454)) +(let t456 (Input 456 "model.layers.18.mlp.gate_proj.weight" (F32))) +(let t457 (Output t456 456)) +(let t458 (Input 458 "model.layers.18.mlp.down_proj.weight" (F32))) +(let t459 (Output t458 458)) +(let t460 (Input 460 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t461 (Output t460 460)) +(let t462 (Input 462 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t463 (Output t462 462)) +(let t464 (Input 464 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t465 (Output t464 464)) +(let t466 (Input 466 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t467 (Output t466 466)) +(let t468 (Input 468 "model.layers.18.input_layernorm.weight" (F32))) +(let t469 (Output t468 468)) +(let t470 (Input 470 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t471 (Output t470 470)) +(let t472 (Input 472 "model.layers.19.mlp.up_proj.weight" (F32))) +(let t473 (Output t472 472)) +(let t474 (Input 474 "model.layers.19.mlp.gate_proj.weight" (F32))) +(let t475 (Output t474 474)) +(let t476 (Input 476 "model.layers.19.mlp.down_proj.weight" (F32))) +(let t477 (Output t476 476)) +(let t478 (Input 478 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t479 (Output t478 478)) +(let t480 (Input 480 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t481 (Output t480 480)) +(let t482 (Input 482 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t483 (Output t482 482)) +(let t484 (Input 484 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t485 (Output t484 484)) +(let t486 (Input 486 "model.layers.19.input_layernorm.weight" (F32))) +(let t487 (Output t486 486)) +(let t488 (Input 488 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t489 (Output t488 488)) +(let t490 (Input 490 "model.layers.20.mlp.up_proj.weight" (F32))) +(let t491 (Output t490 490)) +(let t492 (Input 492 "model.layers.20.mlp.gate_proj.weight" (F32))) +(let t493 (Output t492 492)) +(let t494 (Input 494 "model.layers.20.mlp.down_proj.weight" (F32))) +(let t495 (Output t494 494)) +(let t496 (Input 496 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t497 (Output t496 496)) +(let t498 (Input 498 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t499 (Output t498 498)) +(let t500 (Input 500 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t501 (Output t500 500)) +(let t502 (Input 502 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t503 (Output t502 502)) +(let t504 (Input 504 "model.layers.20.input_layernorm.weight" (F32))) +(let t505 (Output t504 504)) +(let t506 (Input 506 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t507 (Output t506 506)) +(let t508 (Input 508 "model.layers.21.mlp.up_proj.weight" (F32))) +(let t509 (Output t508 508)) +(let t510 (Input 510 "model.layers.21.mlp.gate_proj.weight" (F32))) +(let t511 (Output t510 510)) +(let t512 (Input 512 "model.layers.21.mlp.down_proj.weight" (F32))) +(let t513 (Output t512 512)) +(let t514 (Input 514 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t515 (Output t514 514)) +(let t516 (Input 516 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t517 (Output t516 516)) +(let t518 (Input 518 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t519 (Output t518 518)) +(let t520 (Input 520 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t521 (Output t520 520)) +(let t522 (Input 522 "model.layers.21.input_layernorm.weight" (F32))) +(let t523 (Output t522 522)) +(let t524 (Input 524 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t525 (Output t524 524)) +(let t526 (Input 526 "model.layers.22.mlp.up_proj.weight" (F32))) +(let t527 (Output t526 526)) +(let t528 (Input 528 "model.layers.22.mlp.gate_proj.weight" (F32))) +(let t529 (Output t528 528)) +(let t530 (Input 530 "model.layers.22.mlp.down_proj.weight" (F32))) +(let t531 (Output t530 530)) +(let t532 (Input 532 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t533 (Output t532 532)) +(let t534 (Input 534 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t535 (Output t534 534)) +(let t536 (Input 536 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t537 (Output t536 536)) +(let t538 (Input 538 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t539 (Output t538 538)) +(let t540 (Input 540 "model.layers.22.input_layernorm.weight" (F32))) +(let t541 (Output t540 540)) +(let t542 (Input 542 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t543 (Output t542 542)) +(let t544 (Input 544 "model.layers.23.mlp.up_proj.weight" (F32))) +(let t545 (Output t544 544)) +(let t546 (Input 546 "model.layers.23.mlp.gate_proj.weight" (F32))) +(let t547 (Output t546 546)) +(let t548 (Input 548 "model.layers.23.mlp.down_proj.weight" (F32))) +(let t549 (Output t548 548)) +(let t550 (Input 550 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t551 (Output t550 550)) +(let t552 (Input 552 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t553 (Output t552 552)) +(let t554 (Input 554 "model.layers.23.self_attn.v_proj.weight" (F32))) +(let t555 (Output t554 554)) +(let t556 (Input 556 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t557 (Output t556 556)) +(let t558 (Input 558 "model.layers.23.input_layernorm.weight" (F32))) +(let t559 (Output t558 558)) +(let t560 (Input 560 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t561 (Output t560 560)) +(let t562 (Input 562 "model.layers.24.mlp.up_proj.weight" (F32))) +(let t563 (Output t562 562)) +(let t564 (Input 564 "model.layers.24.mlp.gate_proj.weight" (F32))) +(let t565 (Output t564 564)) +(let t566 (Input 566 "model.layers.24.mlp.down_proj.weight" (F32))) +(let t567 (Output t566 566)) +(let t568 (Input 568 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t569 (Output t568 568)) +(let t570 (Input 570 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t571 (Output t570 570)) +(let t572 (Input 572 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t573 (Output t572 572)) +(let t574 (Input 574 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t575 (Output t574 574)) +(let t576 (Input 576 "model.layers.24.input_layernorm.weight" (F32))) +(let t577 (Output t576 576)) +(let t578 (Input 578 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t579 (Output t578 578)) +(let t580 (Input 580 "model.layers.25.mlp.up_proj.weight" (F32))) +(let t581 (Output t580 580)) +(let t582 (Input 582 "model.layers.25.mlp.gate_proj.weight" (F32))) +(let t583 (Output t582 582)) +(let t584 (Input 584 "model.layers.25.mlp.down_proj.weight" (F32))) +(let t585 (Output t584 584)) +(let t586 (Input 586 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t587 (Output t586 586)) +(let t588 (Input 588 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t589 (Output t588 588)) +(let t590 (Input 590 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t591 (Output t590 590)) +(let t592 (Input 592 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t593 (Output t592 592)) +(let t594 (Input 594 "model.layers.25.input_layernorm.weight" (F32))) +(let t595 (Output t594 594)) +(let t596 (Input 596 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t597 (Output t596 596)) +(let t598 (Input 598 "model.layers.26.mlp.up_proj.weight" (F32))) +(let t599 (Output t598 598)) +(let t600 (Input 600 "model.layers.26.mlp.gate_proj.weight" (F32))) +(let t601 (Output t600 600)) +(let t602 (Input 602 "model.layers.26.mlp.down_proj.weight" (F32))) +(let t603 (Output t602 602)) +(let t604 (Input 604 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t605 (Output t604 604)) +(let t606 (Input 606 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t607 (Output t606 606)) +(let t608 (Input 608 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t609 (Output t608 608)) +(let t610 (Input 610 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t611 (Output t610 610)) +(let t612 (Input 612 "model.layers.26.input_layernorm.weight" (F32))) +(let t613 (Output t612 612)) +(let t614 (Input 614 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t615 (Output t614 614)) +(let t616 (Input 616 "model.layers.27.mlp.up_proj.weight" (F32))) +(let t617 (Output t616 616)) +(let t618 (Input 618 "model.layers.27.mlp.gate_proj.weight" (F32))) +(let t619 (Output t618 618)) +(let t620 (Input 620 "model.layers.27.mlp.down_proj.weight" (F32))) +(let t621 (Output t620 620)) +(let t622 (Input 622 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t623 (Output t622 622)) +(let t624 (Input 624 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t625 (Output t624 624)) +(let t626 (Input 626 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t627 (Output t626 626)) +(let t628 (Input 628 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t629 (Output t628 628)) +(let t630 (Input 630 "model.layers.27.input_layernorm.weight" (F32))) +(let t631 (Output t630 630)) +(let t632 (Input 632 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t633 (Output t632 632)) +(let t634 (Input 634 "model.layers.28.mlp.up_proj.weight" (F32))) +(let t635 (Output t634 634)) +(let t636 (Input 636 "model.layers.28.mlp.gate_proj.weight" (F32))) +(let t637 (Output t636 636)) +(let t638 (Input 638 "model.layers.28.mlp.down_proj.weight" (F32))) +(let t639 (Output t638 638)) +(let t640 (Input 640 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t641 (Output t640 640)) +(let t642 (Input 642 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t643 (Output t642 642)) +(let t644 (Input 644 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t645 (Output t644 644)) +(let t646 (Input 646 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t647 (Output t646 646)) +(let t648 (Input 648 "model.layers.28.input_layernorm.weight" (F32))) +(let t649 (Output t648 648)) +(let t650 (Input 650 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t651 (Output t650 650)) +(let t652 (Input 652 "model.layers.29.mlp.up_proj.weight" (F32))) +(let t653 (Output t652 652)) +(let t654 (Input 654 "model.layers.29.mlp.gate_proj.weight" (F32))) +(let t655 (Output t654 654)) +(let t656 (Input 656 "model.layers.29.mlp.down_proj.weight" (F32))) +(let t657 (Output t656 656)) +(let t658 (Input 658 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t659 (Output t658 658)) +(let t660 (Input 660 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t661 (Output t660 660)) +(let t662 (Input 662 "model.layers.29.self_attn.v_proj.weight" (F32))) +(let t663 (Output t662 662)) +(let t664 (Input 664 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t665 (Output t664 664)) +(let t666 (Input 666 "model.layers.29.input_layernorm.weight" (F32))) +(let t667 (Output t666 666)) +(let t668 (Input 668 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t669 (Output t668 668)) +(let t670 (Input 670 "model.layers.30.mlp.up_proj.weight" (F32))) +(let t671 (Output t670 670)) +(let t672 (Input 672 "model.layers.30.mlp.gate_proj.weight" (F32))) +(let t673 (Output t672 672)) +(let t674 (Input 674 "model.layers.30.mlp.down_proj.weight" (F32))) +(let t675 (Output t674 674)) +(let t676 (Input 676 "model.layers.30.self_attn.q_proj.weight" (F32))) +(let t677 (Output t676 676)) +(let t678 (Input 678 "model.layers.30.self_attn.k_proj.weight" (F32))) +(let t679 (Output t678 678)) +(let t680 (Input 680 "model.layers.30.self_attn.v_proj.weight" (F32))) +(let t681 (Output t680 680)) +(let t682 (Input 682 "model.layers.30.self_attn.o_proj.weight" (F32))) +(let t683 (Output t682 682)) +(let t684 (Input 684 "model.layers.30.input_layernorm.weight" (F32))) +(let t685 (Output t684 684)) +(let t686 (Input 686 "model.layers.30.post_attention_layernorm.weight" (F32))) +(let t687 (Output t686 686)) +(let t688 (Input 688 "model.layers.31.mlp.up_proj.weight" (F32))) +(let t689 (Output t688 688)) +(let t690 (Input 690 "model.layers.31.mlp.gate_proj.weight" (F32))) +(let t691 (Output t690 690)) +(let t692 (Input 692 "model.layers.31.mlp.down_proj.weight" (F32))) +(let t693 (Output t692 692)) +(let t694 (Input 694 "model.layers.31.self_attn.q_proj.weight" (F32))) +(let t695 (Output t694 694)) +(let t696 (Input 696 "model.layers.31.self_attn.k_proj.weight" (F32))) +(let t697 (Output t696 696)) +(let t698 (Input 698 "model.layers.31.self_attn.v_proj.weight" (F32))) +(let t699 (Output t698 698)) +(let t700 (Input 700 "model.layers.31.self_attn.o_proj.weight" (F32))) +(let t701 (Output t700 700)) +(let t702 (Input 702 "model.layers.31.input_layernorm.weight" (F32))) +(let t703 (Output t702 702)) +(let t704 (Input 704 "model.layers.31.post_attention_layernorm.weight" (F32))) +(let t705 (Output t704 704)) +(let t706 (Input 706 "model.norm.weight" (F32))) +(let t707 (Output t706 706)) +(let t708 (Input 708 "lm_head.weight" (F32))) +(let t709 (Output t708 708)) +(let t710 (Input 710 "model.embed_tokens.weight" (F32))) +(let t711 (Output t710 710)) +(let t712 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t713 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t712 (INil))))) +(let t714 (Op (Iota (MIter) (MNum 4096)) (INil))) +(let t715 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t713 (ICons t714 (INil))))) +(let t716 (Op (Gather (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 128256) (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t715 (ICons t710 (INil))))) +(let t717 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t718 (Op (Cast (MNum 1) (F32)) (ICons t717 (INil)))) +(let t719 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t718 (INil)))) +(let t720 (Op (Constant 0.000010) (INil))) +(let t721 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t722 (Op (Cast (MNum 64) (F32)) (ICons t721 (INil)))) +(let t723 (Op (Constant 0.007812) (INil))) +(let t724 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t722 (ICons t723 (INil))))) +(let t725 (Op (Constant 13.122363) (INil))) +(let t726 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t724 (ICons t725 (INil))))) +(let t727 (Op (Constant 1.442695) (INil))) +(let t728 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t726 (ICons t727 (INil))))) +(let t729 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t728 (INil)))) +(let t730 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t729 (INil)))) +(let t731 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t732 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t731 (ICons t730 (INil))))) +(let t733 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t732 (INil)))) +(let t734 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t735 (Op (Constant -1.000000) (INil))) +(let t736 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t733 (ICons t735 (INil))))) +(let t737 (Op (Constant 1.570796) (INil))) +(let t738 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t736 (ICons t737 (INil))))) +(let t739 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t738 (INil)))) +(let t740 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t733 (INil)))) +(let t741 (Op (Constant -1.000000) (INil))) +(let t742 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t743 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t744 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t743 (INil)))) +(let t745 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t746 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t747 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t746 (INil)))) +(let t748 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t749 (Op (Cast (MNum 64) (F32)) (ICons t748 (INil)))) +(let t750 (Op (Constant 0.007812) (INil))) +(let t751 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t749 (ICons t750 (INil))))) +(let t752 (Op (Constant 13.122363) (INil))) +(let t753 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t751 (ICons t752 (INil))))) +(let t754 (Op (Constant 1.442695) (INil))) +(let t755 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t753 (ICons t754 (INil))))) +(let t756 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t755 (INil)))) +(let t757 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t756 (INil)))) +(let t758 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t759 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t758 (ICons t757 (INil))))) +(let t760 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t759 (INil)))) +(let t761 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t762 (Op (Constant -1.000000) (INil))) +(let t763 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t760 (ICons t762 (INil))))) +(let t764 (Op (Constant 1.570796) (INil))) +(let t765 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t763 (ICons t764 (INil))))) +(let t766 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t765 (INil)))) +(let t767 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t760 (INil)))) +(let t768 (Op (Constant -1.000000) (INil))) +(let t769 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t770 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t771 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t770 (INil)))) +(let t772 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t773 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t774 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t773 (INil)))) +(let t775 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t776 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t777 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t775 (ICons t776 (INil))))) +(let t778 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t779 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t780 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t778 (ICons t779 (INil))))) +(let t781 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t782 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t780 (ICons t781 (INil))))) +(let t783 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t784 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t777 (ICons t782 (INil))))) +(let t785 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t784 (ICons t783 (INil))))) +(let t786 (Op (Constant 0.088388) (INil))) +(let t787 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t788 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t787 (INil)))) +(let t789 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t790 (Op (Cast (MNum 1) (F32)) (ICons t789 (INil)))) +(let t791 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t788 (ICons t790 (INil))))) +(let t792 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t793 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t792 (INil)))) +(let t794 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t791 (ICons t793 (INil))))) +(let t795 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t794 (INil)))) +(let t796 (Op (Constant -10000000000.000000) (INil))) +(let t797 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t795 (ICons t796 (INil))))) +(let t798 (Op (Constant -1.000000) (INil))) +(let t799 (Op (Constant 1.442695) (INil))) +(let t800 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t801 (Op (Cast (MNum 1) (F32)) (ICons t800 (INil)))) +(let t802 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t801 (INil)))) +(let t803 (Op (Constant 0.000010) (INil))) +(let t804 (Op (Constant -1.000000) (INil))) +(let t805 (Op (Constant 1.442695) (INil))) +(let t806 (Op (Constant 1.000000) (INil))) +(let t807 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t808 (Op (Cast (MNum 1) (F32)) (ICons t807 (INil)))) +(let t809 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t808 (INil)))) +(let t810 (Op (Constant 0.000010) (INil))) +(let t811 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t812 (Op (Cast (MNum 64) (F32)) (ICons t811 (INil)))) +(let t813 (Op (Constant 0.007812) (INil))) +(let t814 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t812 (ICons t813 (INil))))) +(let t815 (Op (Constant 13.122363) (INil))) +(let t816 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t814 (ICons t815 (INil))))) +(let t817 (Op (Constant 1.442695) (INil))) +(let t818 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t816 (ICons t817 (INil))))) +(let t819 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t818 (INil)))) +(let t820 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t819 (INil)))) +(let t821 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t822 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t821 (ICons t820 (INil))))) +(let t823 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t822 (INil)))) +(let t824 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t825 (Op (Constant -1.000000) (INil))) +(let t826 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t823 (ICons t825 (INil))))) +(let t827 (Op (Constant 1.570796) (INil))) +(let t828 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t826 (ICons t827 (INil))))) +(let t829 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t828 (INil)))) +(let t830 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t823 (INil)))) +(let t831 (Op (Constant -1.000000) (INil))) +(let t832 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t833 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t834 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t833 (INil)))) +(let t835 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t836 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t837 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t836 (INil)))) +(let t838 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t839 (Op (Cast (MNum 64) (F32)) (ICons t838 (INil)))) +(let t840 (Op (Constant 0.007812) (INil))) +(let t841 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t839 (ICons t840 (INil))))) +(let t842 (Op (Constant 13.122363) (INil))) +(let t843 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t841 (ICons t842 (INil))))) +(let t844 (Op (Constant 1.442695) (INil))) +(let t845 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t843 (ICons t844 (INil))))) +(let t846 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t845 (INil)))) +(let t847 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t846 (INil)))) +(let t848 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t849 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t848 (ICons t847 (INil))))) +(let t850 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t849 (INil)))) +(let t851 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t852 (Op (Constant -1.000000) (INil))) +(let t853 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t850 (ICons t852 (INil))))) +(let t854 (Op (Constant 1.570796) (INil))) +(let t855 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t853 (ICons t854 (INil))))) +(let t856 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t855 (INil)))) +(let t857 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t850 (INil)))) +(let t858 (Op (Constant -1.000000) (INil))) +(let t859 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t860 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t861 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t860 (INil)))) +(let t862 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t863 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t864 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t863 (INil)))) +(let t865 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t866 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t867 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t865 (ICons t866 (INil))))) +(let t868 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t869 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t870 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t868 (ICons t869 (INil))))) +(let t871 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t872 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t870 (ICons t871 (INil))))) +(let t873 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t874 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t867 (ICons t872 (INil))))) +(let t875 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t874 (ICons t873 (INil))))) +(let t876 (Op (Constant 0.088388) (INil))) +(let t877 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t878 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t877 (INil)))) +(let t879 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t880 (Op (Cast (MNum 1) (F32)) (ICons t879 (INil)))) +(let t881 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t878 (ICons t880 (INil))))) +(let t882 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t883 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t882 (INil)))) +(let t884 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t881 (ICons t883 (INil))))) +(let t885 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t884 (INil)))) +(let t886 (Op (Constant -10000000000.000000) (INil))) +(let t887 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t885 (ICons t886 (INil))))) +(let t888 (Op (Constant -1.000000) (INil))) +(let t889 (Op (Constant 1.442695) (INil))) +(let t890 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t891 (Op (Cast (MNum 1) (F32)) (ICons t890 (INil)))) +(let t892 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t891 (INil)))) +(let t893 (Op (Constant 0.000010) (INil))) +(let t894 (Op (Constant -1.000000) (INil))) +(let t895 (Op (Constant 1.442695) (INil))) +(let t896 (Op (Constant 1.000000) (INil))) +(let t897 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t898 (Op (Cast (MNum 1) (F32)) (ICons t897 (INil)))) +(let t899 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t898 (INil)))) +(let t900 (Op (Constant 0.000010) (INil))) +(let t901 (LoopStart t716 0 0 (MNum 31) (F32))) +(let t902 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t901 (ICons t901 (INil))))) +(let t903 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t902 (INil)))) +(let t904 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t903 (ICons t719 (INil))))) +(let t905 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t904 (ICons t720 (INil))))) +(let t906 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t905 (INil)))) +(let t907 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t906 (INil)))) +(let t908 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t907 (ICons t901 (INil))))) +(let t909 (Op (LoopInput 0 1 (F32)) (ICons t144 (ICons t162 (ICons t180 (ICons t198 (ICons t216 (ICons t234 (ICons t252 (ICons t270 (ICons t288 (ICons t306 (ICons t324 (ICons t342 (ICons t360 (ICons t378 (ICons t396 (ICons t414 (ICons t432 (ICons t450 (ICons t468 (ICons t486 (ICons t504 (ICons t522 (ICons t540 (ICons t558 (ICons t576 (ICons t594 (ICons t612 (ICons t630 (ICons t648 (ICons t666 (ICons t684 (INil)))))))))))))))))))))))))))))))))) +(let t910 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t908 (ICons t909 (INil))))) +(let t911 (Op (LoopInput 0 2 (F32)) (ICons t136 (ICons t154 (ICons t172 (ICons t190 (ICons t208 (ICons t226 (ICons t244 (ICons t262 (ICons t280 (ICons t298 (ICons t316 (ICons t334 (ICons t352 (ICons t370 (ICons t388 (ICons t406 (ICons t424 (ICons t442 (ICons t460 (ICons t478 (ICons t496 (ICons t514 (ICons t532 (ICons t550 (ICons t568 (ICons t586 (ICons t604 (ICons t622 (ICons t640 (ICons t658 (ICons t676 (INil)))))))))))))))))))))))))))))))))) +(let t912 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t910 (ICons t911 (INil))))) +(let t913 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t912 (INil)))) +(let t914 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t734 (ICons t913 (INil))))) +(let t915 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t913 (ICons t739 (INil))))) +(let t916 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t914 (ICons t740 (INil))))) +(let t917 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t916 (ICons t741 (INil))))) +(let t918 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t915 (ICons t917 (INil))))) +(let t919 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t914 (ICons t739 (INil))))) +(let t920 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t913 (ICons t740 (INil))))) +(let t921 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t919 (ICons t920 (INil))))) +(let t922 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t742 (ICons t918 (INil))))) +(let t923 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t922 (ICons t744 (INil))))) +(let t924 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t745 (ICons t921 (INil))))) +(let t925 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t924 (ICons t747 (INil))))) +(let t926 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t923 (ICons t925 (INil))))) +(let t927 (Op (LoopInput 0 3 (F32)) (ICons t138 (ICons t156 (ICons t174 (ICons t192 (ICons t210 (ICons t228 (ICons t246 (ICons t264 (ICons t282 (ICons t300 (ICons t318 (ICons t336 (ICons t354 (ICons t372 (ICons t390 (ICons t408 (ICons t426 (ICons t444 (ICons t462 (ICons t480 (ICons t498 (ICons t516 (ICons t534 (ICons t552 (ICons t570 (ICons t588 (ICons t606 (ICons t624 (ICons t642 (ICons t660 (ICons t678 (INil)))))))))))))))))))))))))))))))))) +(let t928 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t910 (ICons t927 (INil))))) +(let t929 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t928 (INil)))) +(let t930 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t761 (ICons t929 (INil))))) +(let t931 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t929 (ICons t766 (INil))))) +(let t932 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t930 (ICons t767 (INil))))) +(let t933 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t932 (ICons t768 (INil))))) +(let t934 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t931 (ICons t933 (INil))))) +(let t935 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t930 (ICons t766 (INil))))) +(let t936 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t929 (ICons t767 (INil))))) +(let t937 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t935 (ICons t936 (INil))))) +(let t938 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t769 (ICons t934 (INil))))) +(let t939 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t938 (ICons t771 (INil))))) +(let t940 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t772 (ICons t937 (INil))))) +(let t941 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t940 (ICons t774 (INil))))) +(let t942 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t939 (ICons t941 (INil))))) +(let t943 (Op (LoopInput 0 4 (F32)) (ICons t140 (ICons t158 (ICons t176 (ICons t194 (ICons t212 (ICons t230 (ICons t248 (ICons t266 (ICons t284 (ICons t302 (ICons t320 (ICons t338 (ICons t356 (ICons t374 (ICons t392 (ICons t410 (ICons t428 (ICons t446 (ICons t464 (ICons t482 (ICons t500 (ICons t518 (ICons t536 (ICons t554 (ICons t572 (ICons t590 (ICons t608 (ICons t626 (ICons t644 (ICons t662 (ICons t680 (INil)))))))))))))))))))))))))))))))))) +(let t944 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t910 (ICons t943 (INil))))) +(let t945 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t944 (INil)))) +(let t946 (Op (LoopInput 0 6 (F32)) (ICons t2 (ICons t6 (ICons t10 (ICons t14 (ICons t18 (ICons t22 (ICons t26 (ICons t30 (ICons t34 (ICons t38 (ICons t42 (ICons t46 (ICons t50 (ICons t54 (ICons t58 (ICons t62 (ICons t66 (ICons t70 (ICons t74 (ICons t78 (ICons t82 (ICons t86 (ICons t90 (ICons t94 (ICons t98 (ICons t102 (ICons t106 (ICons t110 (ICons t114 (ICons t118 (ICons t122 (INil)))))))))))))))))))))))))))))))))) +(let t947 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t946 (ICons t785 (ICons t942 (INil)))))) +(let t948 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t926 (ICons t947 (INil))))) +(let t949 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t948 (INil)))) +(let t950 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t949 (ICons t786 (INil))))) +(let t951 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t950 (ICons t797 (INil))))) +(let t952 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t951 (INil)))) +(let t953 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t952 (ICons t798 (INil))))) +(let t954 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t951 (ICons t953 (INil))))) +(let t955 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t954 (ICons t799 (INil))))) +(let t956 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t955 (INil)))) +(let t957 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t956 (INil)))) +(let t958 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t957 (INil)))) +(let t959 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t956 (ICons t958 (INil))))) +(let t960 (Op (LoopInput 0 7 (F32)) (ICons t4 (ICons t8 (ICons t12 (ICons t16 (ICons t20 (ICons t24 (ICons t28 (ICons t32 (ICons t36 (ICons t40 (ICons t44 (ICons t48 (ICons t52 (ICons t56 (ICons t60 (ICons t64 (ICons t68 (ICons t72 (ICons t76 (ICons t80 (ICons t84 (ICons t88 (ICons t92 (ICons t96 (ICons t100 (ICons t104 (ICons t108 (ICons t112 (ICons t116 (ICons t120 (ICons t124 (INil)))))))))))))))))))))))))))))))))) +(let t961 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t960 (ICons t785 (ICons t945 (INil)))))) +(let t962 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t959 (ICons t961 (INil))))) +(let t963 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t962 (INil)))) +(let t964 (Op (LoopInput 0 8 (F32)) (ICons t142 (ICons t160 (ICons t178 (ICons t196 (ICons t214 (ICons t232 (ICons t250 (ICons t268 (ICons t286 (ICons t304 (ICons t322 (ICons t340 (ICons t358 (ICons t376 (ICons t394 (ICons t412 (ICons t430 (ICons t448 (ICons t466 (ICons t484 (ICons t502 (ICons t520 (ICons t538 (ICons t556 (ICons t574 (ICons t592 (ICons t610 (ICons t628 (ICons t646 (ICons t664 (ICons t682 (INil)))))))))))))))))))))))))))))))))) +(let t965 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t963 (ICons t964 (INil))))) +(let t966 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t965 (INil)))) +(let t967 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t901 (ICons t966 (INil))))) +(let t968 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t967 (ICons t967 (INil))))) +(let t969 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t968 (INil)))) +(let t970 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t969 (ICons t802 (INil))))) +(let t971 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t970 (ICons t803 (INil))))) +(let t972 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t971 (INil)))) +(let t973 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t972 (INil)))) +(let t974 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t973 (ICons t967 (INil))))) +(let t975 (Op (LoopInput 0 9 (F32)) (ICons t146 (ICons t164 (ICons t182 (ICons t200 (ICons t218 (ICons t236 (ICons t254 (ICons t272 (ICons t290 (ICons t308 (ICons t326 (ICons t344 (ICons t362 (ICons t380 (ICons t398 (ICons t416 (ICons t434 (ICons t452 (ICons t470 (ICons t488 (ICons t506 (ICons t524 (ICons t542 (ICons t560 (ICons t578 (ICons t596 (ICons t614 (ICons t632 (ICons t650 (ICons t668 (ICons t686 (INil)))))))))))))))))))))))))))))))))) +(let t976 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t974 (ICons t975 (INil))))) +(let t977 (Op (LoopInput 0 10 (F32)) (ICons t132 (ICons t150 (ICons t168 (ICons t186 (ICons t204 (ICons t222 (ICons t240 (ICons t258 (ICons t276 (ICons t294 (ICons t312 (ICons t330 (ICons t348 (ICons t366 (ICons t384 (ICons t402 (ICons t420 (ICons t438 (ICons t456 (ICons t474 (ICons t492 (ICons t510 (ICons t528 (ICons t546 (ICons t564 (ICons t582 (ICons t600 (ICons t618 (ICons t636 (ICons t654 (ICons t672 (INil)))))))))))))))))))))))))))))))))) +(let t978 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t976 (ICons t977 (INil))))) +(let t979 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t978 (INil)))) +(let t980 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t979 (ICons t804 (INil))))) +(let t981 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t980 (ICons t805 (INil))))) +(let t982 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t981 (INil)))) +(let t983 (Op (Add (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t982 (ICons t806 (INil))))) +(let t984 (Op (Recip (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t983 (INil)))) +(let t985 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t979 (ICons t984 (INil))))) +(let t986 (Op (LoopInput 0 11 (F32)) (ICons t130 (ICons t148 (ICons t166 (ICons t184 (ICons t202 (ICons t220 (ICons t238 (ICons t256 (ICons t274 (ICons t292 (ICons t310 (ICons t328 (ICons t346 (ICons t364 (ICons t382 (ICons t400 (ICons t418 (ICons t436 (ICons t454 (ICons t472 (ICons t490 (ICons t508 (ICons t526 (ICons t544 (ICons t562 (ICons t580 (ICons t598 (ICons t616 (ICons t634 (ICons t652 (ICons t670 (INil)))))))))))))))))))))))))))))))))) +(let t987 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t976 (ICons t986 (INil))))) +(let t988 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t987 (INil)))) +(let t989 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t985 (ICons t988 (INil))))) +(let t990 (Op (LoopInput 0 12 (F32)) (ICons t134 (ICons t152 (ICons t170 (ICons t188 (ICons t206 (ICons t224 (ICons t242 (ICons t260 (ICons t278 (ICons t296 (ICons t314 (ICons t332 (ICons t350 (ICons t368 (ICons t386 (ICons t404 (ICons t422 (ICons t440 (ICons t458 (ICons t476 (ICons t494 (ICons t512 (ICons t530 (ICons t548 (ICons t566 (ICons t584 (ICons t602 (ICons t620 (ICons t638 (ICons t656 (ICons t674 (INil)))))))))))))))))))))))))))))))))) +(let t991 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 14336) (ENil)))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))))) (ICons t989 (ICons t990 (INil))))) +(let t992 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 14336) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t991 (INil)))) +(let t993 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t967 (ICons t992 (INil))))) +(let t994 (LoopEnd t993 0 0 (F32))) +(let t995 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t994 (ICons t994 (INil))))) +(let t996 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t995 (INil)))) +(let t997 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t996 (ICons t809 (INil))))) +(let t998 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t997 (ICons t810 (INil))))) +(let t999 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t998 (INil)))) +(let t1000 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t999 (INil)))) +(let t1001 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1000 (ICons t994 (INil))))) +(let t1002 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1001 (ICons t702 (INil))))) +(let t1003 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1002 (ICons t694 (INil))))) +(let t1004 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1003 (INil)))) +(let t1005 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1002 (ICons t696 (INil))))) +(let t1006 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1005 (INil)))) +(let t1007 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1002 (ICons t698 (INil))))) +(let t1008 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1007 (INil)))) +(let t1009 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t824 (ICons t1004 (INil))))) +(let t1010 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1004 (ICons t829 (INil))))) +(let t1011 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1009 (ICons t830 (INil))))) +(let t1012 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1011 (ICons t831 (INil))))) +(let t1013 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1010 (ICons t1012 (INil))))) +(let t1014 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1009 (ICons t829 (INil))))) +(let t1015 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1004 (ICons t830 (INil))))) +(let t1016 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1014 (ICons t1015 (INil))))) +(let t1017 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t832 (ICons t1013 (INil))))) +(let t1018 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1017 (ICons t834 (INil))))) +(let t1019 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t835 (ICons t1016 (INil))))) +(let t1020 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1019 (ICons t837 (INil))))) +(let t1021 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1018 (ICons t1020 (INil))))) +(let t1022 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t851 (ICons t1006 (INil))))) +(let t1023 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1006 (ICons t856 (INil))))) +(let t1024 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1022 (ICons t857 (INil))))) +(let t1025 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1024 (ICons t858 (INil))))) +(let t1026 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1023 (ICons t1025 (INil))))) +(let t1027 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1022 (ICons t856 (INil))))) +(let t1028 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1006 (ICons t857 (INil))))) +(let t1029 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1027 (ICons t1028 (INil))))) +(let t1030 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t859 (ICons t1026 (INil))))) +(let t1031 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1030 (ICons t861 (INil))))) +(let t1032 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t862 (ICons t1029 (INil))))) +(let t1033 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1032 (ICons t864 (INil))))) +(let t1034 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1031 (ICons t1033 (INil))))) +(let t1035 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t126 (ICons t875 (ICons t1034 (INil)))))) +(let t1036 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t128 (ICons t875 (ICons t1008 (INil)))))) +(let t1037 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t1021 (ICons t1035 (INil))))) +(let t1038 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1037 (INil)))) +(let t1039 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1038 (ICons t876 (INil))))) +(let t1040 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1039 (ICons t887 (INil))))) +(let t1041 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1040 (INil)))) +(let t1042 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1041 (ICons t888 (INil))))) +(let t1043 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1040 (ICons t1042 (INil))))) +(let t1044 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1043 (ICons t889 (INil))))) +(let t1045 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1044 (INil)))) +(let t1046 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1045 (INil)))) +(let t1047 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1046 (INil)))) +(let t1048 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1045 (ICons t1047 (INil))))) +(let t1049 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t1048 (ICons t1036 (INil))))) +(let t1050 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1049 (INil)))) +(let t1051 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1050 (ICons t700 (INil))))) +(let t1052 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1051 (INil)))) +(let t1053 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t994 (ICons t1052 (INil))))) +(let t1054 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1053 (ICons t1053 (INil))))) +(let t1055 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1054 (INil)))) +(let t1056 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1055 (ICons t892 (INil))))) +(let t1057 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1056 (ICons t893 (INil))))) +(let t1058 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1057 (INil)))) +(let t1059 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1058 (INil)))) +(let t1060 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1059 (ICons t1053 (INil))))) +(let t1061 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1060 (ICons t704 (INil))))) +(let t1062 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1061 (ICons t690 (INil))))) +(let t1063 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1062 (INil)))) +(let t1064 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1063 (ICons t894 (INil))))) +(let t1065 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1064 (ICons t895 (INil))))) +(let t1066 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1065 (INil)))) +(let t1067 (Op (Add (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1066 (ICons t896 (INil))))) +(let t1068 (Op (Recip (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1067 (INil)))) +(let t1069 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1063 (ICons t1068 (INil))))) +(let t1070 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1061 (ICons t688 (INil))))) +(let t1071 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1070 (INil)))) +(let t1072 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1069 (ICons t1071 (INil))))) +(let t1073 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 14336) (ENil)))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))))) (ICons t1072 (ICons t692 (INil))))) +(let t1074 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 14336) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1073 (INil)))) +(let t1075 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1053 (ICons t1074 (INil))))) +(let t1076 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1075 (ICons t1075 (INil))))) +(let t1077 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1076 (INil)))) +(let t1078 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1077 (ICons t899 (INil))))) +(let t1079 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1078 (ICons t900 (INil))))) +(let t1080 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1079 (INil)))) +(let t1081 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1080 (INil)))) +(let t1082 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1081 (ICons t1075 (INil))))) +(let t1083 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1082 (ICons t706 (INil))))) +(let t1084 (Op (Mul (ECons (MVar "s") (ECons (MNum 128256) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 128256)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1083 (ICons t708 (INil))))) +(let t1085 (Op (Sum (ECons (MVar "s") (ECons (MNum 128256) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 128256)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128256)) (ECons (MIter) (ENil)))) (ICons t1084 (INil)))) +(let t1086 (Output t1085 6202)) +(let t1087 (Output t1035 6127)) +(let t1088 (Output t1036 6128)) +(let t1089 (Op (LoopOutput 0 0 (F32)) (ICons t947 (INil)))) +(let t1090 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t1089 (INil)))) +(let t1091 (Output t1090 826)) +(let t1092 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t1089 (INil)))) +(let t1093 (Output t1092 997)) +(let t1094 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t1089 (INil)))) +(let t1095 (Output t1094 1168)) +(let t1096 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t1089 (INil)))) +(let t1097 (Output t1096 1339)) +(let t1098 (Op (LoopOutputSelect 0 0 4 (F32)) (ICons t1089 (INil)))) +(let t1099 (Output t1098 1510)) +(let t1100 (Op (LoopOutputSelect 0 0 5 (F32)) (ICons t1089 (INil)))) +(let t1101 (Output t1100 1681)) +(let t1102 (Op (LoopOutputSelect 0 0 6 (F32)) (ICons t1089 (INil)))) +(let t1103 (Output t1102 1852)) +(let t1104 (Op (LoopOutputSelect 0 0 7 (F32)) (ICons t1089 (INil)))) +(let t1105 (Output t1104 2023)) +(let t1106 (Op (LoopOutputSelect 0 0 8 (F32)) (ICons t1089 (INil)))) +(let t1107 (Output t1106 2194)) +(let t1108 (Op (LoopOutputSelect 0 0 9 (F32)) (ICons t1089 (INil)))) +(let t1109 (Output t1108 2365)) +(let t1110 (Op (LoopOutputSelect 0 0 10 (F32)) (ICons t1089 (INil)))) +(let t1111 (Output t1110 2536)) +(let t1112 (Op (LoopOutputSelect 0 0 11 (F32)) (ICons t1089 (INil)))) +(let t1113 (Output t1112 2707)) +(let t1114 (Op (LoopOutputSelect 0 0 12 (F32)) (ICons t1089 (INil)))) +(let t1115 (Output t1114 2878)) +(let t1116 (Op (LoopOutputSelect 0 0 13 (F32)) (ICons t1089 (INil)))) +(let t1117 (Output t1116 3049)) +(let t1118 (Op (LoopOutputSelect 0 0 14 (F32)) (ICons t1089 (INil)))) +(let t1119 (Output t1118 3220)) +(let t1120 (Op (LoopOutputSelect 0 0 15 (F32)) (ICons t1089 (INil)))) +(let t1121 (Output t1120 3391)) +(let t1122 (Op (LoopOutputSelect 0 0 16 (F32)) (ICons t1089 (INil)))) +(let t1123 (Output t1122 3562)) +(let t1124 (Op (LoopOutputSelect 0 0 17 (F32)) (ICons t1089 (INil)))) +(let t1125 (Output t1124 3733)) +(let t1126 (Op (LoopOutputSelect 0 0 18 (F32)) (ICons t1089 (INil)))) +(let t1127 (Output t1126 3904)) +(let t1128 (Op (LoopOutputSelect 0 0 19 (F32)) (ICons t1089 (INil)))) +(let t1129 (Output t1128 4075)) +(let t1130 (Op (LoopOutputSelect 0 0 20 (F32)) (ICons t1089 (INil)))) +(let t1131 (Output t1130 4246)) +(let t1132 (Op (LoopOutputSelect 0 0 21 (F32)) (ICons t1089 (INil)))) +(let t1133 (Output t1132 4417)) +(let t1134 (Op (LoopOutputSelect 0 0 22 (F32)) (ICons t1089 (INil)))) +(let t1135 (Output t1134 4588)) +(let t1136 (Op (LoopOutputSelect 0 0 23 (F32)) (ICons t1089 (INil)))) +(let t1137 (Output t1136 4759)) +(let t1138 (Op (LoopOutputSelect 0 0 24 (F32)) (ICons t1089 (INil)))) +(let t1139 (Output t1138 4930)) +(let t1140 (Op (LoopOutputSelect 0 0 25 (F32)) (ICons t1089 (INil)))) +(let t1141 (Output t1140 5101)) +(let t1142 (Op (LoopOutputSelect 0 0 26 (F32)) (ICons t1089 (INil)))) +(let t1143 (Output t1142 5272)) +(let t1144 (Op (LoopOutputSelect 0 0 27 (F32)) (ICons t1089 (INil)))) +(let t1145 (Output t1144 5443)) +(let t1146 (Op (LoopOutputSelect 0 0 28 (F32)) (ICons t1089 (INil)))) +(let t1147 (Output t1146 5614)) +(let t1148 (Op (LoopOutputSelect 0 0 29 (F32)) (ICons t1089 (INil)))) +(let t1149 (Output t1148 5785)) +(let t1150 (Op (LoopOutputSelect 0 0 30 (F32)) (ICons t1089 (INil)))) +(let t1151 (Output t1150 5956)) +(let t1152 (Op (LoopOutput 0 1 (F32)) (ICons t961 (INil)))) +(let t1153 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t1152 (INil)))) +(let t1154 (Output t1153 827)) +(let t1155 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t1152 (INil)))) +(let t1156 (Output t1155 998)) +(let t1157 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t1152 (INil)))) +(let t1158 (Output t1157 1169)) +(let t1159 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t1152 (INil)))) +(let t1160 (Output t1159 1340)) +(let t1161 (Op (LoopOutputSelect 0 1 4 (F32)) (ICons t1152 (INil)))) +(let t1162 (Output t1161 1511)) +(let t1163 (Op (LoopOutputSelect 0 1 5 (F32)) (ICons t1152 (INil)))) +(let t1164 (Output t1163 1682)) +(let t1165 (Op (LoopOutputSelect 0 1 6 (F32)) (ICons t1152 (INil)))) +(let t1166 (Output t1165 1853)) +(let t1167 (Op (LoopOutputSelect 0 1 7 (F32)) (ICons t1152 (INil)))) +(let t1168 (Output t1167 2024)) +(let t1169 (Op (LoopOutputSelect 0 1 8 (F32)) (ICons t1152 (INil)))) +(let t1170 (Output t1169 2195)) +(let t1171 (Op (LoopOutputSelect 0 1 9 (F32)) (ICons t1152 (INil)))) +(let t1172 (Output t1171 2366)) +(let t1173 (Op (LoopOutputSelect 0 1 10 (F32)) (ICons t1152 (INil)))) +(let t1174 (Output t1173 2537)) +(let t1175 (Op (LoopOutputSelect 0 1 11 (F32)) (ICons t1152 (INil)))) +(let t1176 (Output t1175 2708)) +(let t1177 (Op (LoopOutputSelect 0 1 12 (F32)) (ICons t1152 (INil)))) +(let t1178 (Output t1177 2879)) +(let t1179 (Op (LoopOutputSelect 0 1 13 (F32)) (ICons t1152 (INil)))) +(let t1180 (Output t1179 3050)) +(let t1181 (Op (LoopOutputSelect 0 1 14 (F32)) (ICons t1152 (INil)))) +(let t1182 (Output t1181 3221)) +(let t1183 (Op (LoopOutputSelect 0 1 15 (F32)) (ICons t1152 (INil)))) +(let t1184 (Output t1183 3392)) +(let t1185 (Op (LoopOutputSelect 0 1 16 (F32)) (ICons t1152 (INil)))) +(let t1186 (Output t1185 3563)) +(let t1187 (Op (LoopOutputSelect 0 1 17 (F32)) (ICons t1152 (INil)))) +(let t1188 (Output t1187 3734)) +(let t1189 (Op (LoopOutputSelect 0 1 18 (F32)) (ICons t1152 (INil)))) +(let t1190 (Output t1189 3905)) +(let t1191 (Op (LoopOutputSelect 0 1 19 (F32)) (ICons t1152 (INil)))) +(let t1192 (Output t1191 4076)) +(let t1193 (Op (LoopOutputSelect 0 1 20 (F32)) (ICons t1152 (INil)))) +(let t1194 (Output t1193 4247)) +(let t1195 (Op (LoopOutputSelect 0 1 21 (F32)) (ICons t1152 (INil)))) +(let t1196 (Output t1195 4418)) +(let t1197 (Op (LoopOutputSelect 0 1 22 (F32)) (ICons t1152 (INil)))) +(let t1198 (Output t1197 4589)) +(let t1199 (Op (LoopOutputSelect 0 1 23 (F32)) (ICons t1152 (INil)))) +(let t1200 (Output t1199 4760)) +(let t1201 (Op (LoopOutputSelect 0 1 24 (F32)) (ICons t1152 (INil)))) +(let t1202 (Output t1201 4931)) +(let t1203 (Op (LoopOutputSelect 0 1 25 (F32)) (ICons t1152 (INil)))) +(let t1204 (Output t1203 5102)) +(let t1205 (Op (LoopOutputSelect 0 1 26 (F32)) (ICons t1152 (INil)))) +(let t1206 (Output t1205 5273)) +(let t1207 (Op (LoopOutputSelect 0 1 27 (F32)) (ICons t1152 (INil)))) +(let t1208 (Output t1207 5444)) +(let t1209 (Op (LoopOutputSelect 0 1 28 (F32)) (ICons t1152 (INil)))) +(let t1210 (Output t1209 5615)) +(let t1211 (Op (LoopOutputSelect 0 1 29 (F32)) (ICons t1152 (INil)))) +(let t1212 (Output t1211 5786)) +(let t1213 (Op (LoopOutputSelect 0 1 30 (F32)) (ICons t1152 (INil)))) +(let t1214 (Output t1213 5957)) +(let t1216 (OutputJoin t3 t5)) +(let t1217 (OutputJoin t1216 t7)) +(let t1218 (OutputJoin t1217 t9)) +(let t1219 (OutputJoin t1218 t11)) +(let t1220 (OutputJoin t1219 t13)) +(let t1221 (OutputJoin t1220 t15)) +(let t1222 (OutputJoin t1221 t17)) +(let t1223 (OutputJoin t1222 t19)) +(let t1224 (OutputJoin t1223 t21)) +(let t1225 (OutputJoin t1224 t23)) +(let t1226 (OutputJoin t1225 t25)) +(let t1227 (OutputJoin t1226 t27)) +(let t1228 (OutputJoin t1227 t29)) +(let t1229 (OutputJoin t1228 t31)) +(let t1230 (OutputJoin t1229 t33)) +(let t1231 (OutputJoin t1230 t35)) +(let t1232 (OutputJoin t1231 t37)) +(let t1233 (OutputJoin t1232 t39)) +(let t1234 (OutputJoin t1233 t41)) +(let t1235 (OutputJoin t1234 t43)) +(let t1236 (OutputJoin t1235 t45)) +(let t1237 (OutputJoin t1236 t47)) +(let t1238 (OutputJoin t1237 t49)) +(let t1239 (OutputJoin t1238 t51)) +(let t1240 (OutputJoin t1239 t53)) +(let t1241 (OutputJoin t1240 t55)) +(let t1242 (OutputJoin t1241 t57)) +(let t1243 (OutputJoin t1242 t59)) +(let t1244 (OutputJoin t1243 t61)) +(let t1245 (OutputJoin t1244 t63)) +(let t1246 (OutputJoin t1245 t65)) +(let t1247 (OutputJoin t1246 t67)) +(let t1248 (OutputJoin t1247 t69)) +(let t1249 (OutputJoin t1248 t71)) +(let t1250 (OutputJoin t1249 t73)) +(let t1251 (OutputJoin t1250 t75)) +(let t1252 (OutputJoin t1251 t77)) +(let t1253 (OutputJoin t1252 t79)) +(let t1254 (OutputJoin t1253 t81)) +(let t1255 (OutputJoin t1254 t83)) +(let t1256 (OutputJoin t1255 t85)) +(let t1257 (OutputJoin t1256 t87)) +(let t1258 (OutputJoin t1257 t89)) +(let t1259 (OutputJoin t1258 t91)) +(let t1260 (OutputJoin t1259 t93)) +(let t1261 (OutputJoin t1260 t95)) +(let t1262 (OutputJoin t1261 t97)) +(let t1263 (OutputJoin t1262 t99)) +(let t1264 (OutputJoin t1263 t101)) +(let t1265 (OutputJoin t1264 t103)) +(let t1266 (OutputJoin t1265 t105)) +(let t1267 (OutputJoin t1266 t107)) +(let t1268 (OutputJoin t1267 t109)) +(let t1269 (OutputJoin t1268 t111)) +(let t1270 (OutputJoin t1269 t113)) +(let t1271 (OutputJoin t1270 t115)) +(let t1272 (OutputJoin t1271 t117)) +(let t1273 (OutputJoin t1272 t119)) +(let t1274 (OutputJoin t1273 t121)) +(let t1275 (OutputJoin t1274 t123)) +(let t1276 (OutputJoin t1275 t125)) +(let t1277 (OutputJoin t1276 t127)) +(let t1278 (OutputJoin t1277 t129)) +(let t1279 (OutputJoin t1278 t131)) +(let t1280 (OutputJoin t1279 t133)) +(let t1281 (OutputJoin t1280 t135)) +(let t1282 (OutputJoin t1281 t137)) +(let t1283 (OutputJoin t1282 t139)) +(let t1284 (OutputJoin t1283 t141)) +(let t1285 (OutputJoin t1284 t143)) +(let t1286 (OutputJoin t1285 t145)) +(let t1287 (OutputJoin t1286 t147)) +(let t1288 (OutputJoin t1287 t149)) +(let t1289 (OutputJoin t1288 t151)) +(let t1290 (OutputJoin t1289 t153)) +(let t1291 (OutputJoin t1290 t155)) +(let t1292 (OutputJoin t1291 t157)) +(let t1293 (OutputJoin t1292 t159)) +(let t1294 (OutputJoin t1293 t161)) +(let t1295 (OutputJoin t1294 t163)) +(let t1296 (OutputJoin t1295 t165)) +(let t1297 (OutputJoin t1296 t167)) +(let t1298 (OutputJoin t1297 t169)) +(let t1299 (OutputJoin t1298 t171)) +(let t1300 (OutputJoin t1299 t173)) +(let t1301 (OutputJoin t1300 t175)) +(let t1302 (OutputJoin t1301 t177)) +(let t1303 (OutputJoin t1302 t179)) +(let t1304 (OutputJoin t1303 t181)) +(let t1305 (OutputJoin t1304 t183)) +(let t1306 (OutputJoin t1305 t185)) +(let t1307 (OutputJoin t1306 t187)) +(let t1308 (OutputJoin t1307 t189)) +(let t1309 (OutputJoin t1308 t191)) +(let t1310 (OutputJoin t1309 t193)) +(let t1311 (OutputJoin t1310 t195)) +(let t1312 (OutputJoin t1311 t197)) +(let t1313 (OutputJoin t1312 t199)) +(let t1314 (OutputJoin t1313 t201)) +(let t1315 (OutputJoin t1314 t203)) +(let t1316 (OutputJoin t1315 t205)) +(let t1317 (OutputJoin t1316 t207)) +(let t1318 (OutputJoin t1317 t209)) +(let t1319 (OutputJoin t1318 t211)) +(let t1320 (OutputJoin t1319 t213)) +(let t1321 (OutputJoin t1320 t215)) +(let t1322 (OutputJoin t1321 t217)) +(let t1323 (OutputJoin t1322 t219)) +(let t1324 (OutputJoin t1323 t221)) +(let t1325 (OutputJoin t1324 t223)) +(let t1326 (OutputJoin t1325 t225)) +(let t1327 (OutputJoin t1326 t227)) +(let t1328 (OutputJoin t1327 t229)) +(let t1329 (OutputJoin t1328 t231)) +(let t1330 (OutputJoin t1329 t233)) +(let t1331 (OutputJoin t1330 t235)) +(let t1332 (OutputJoin t1331 t237)) +(let t1333 (OutputJoin t1332 t239)) +(let t1334 (OutputJoin t1333 t241)) +(let t1335 (OutputJoin t1334 t243)) +(let t1336 (OutputJoin t1335 t245)) +(let t1337 (OutputJoin t1336 t247)) +(let t1338 (OutputJoin t1337 t249)) +(let t1339 (OutputJoin t1338 t251)) +(let t1340 (OutputJoin t1339 t253)) +(let t1341 (OutputJoin t1340 t255)) +(let t1342 (OutputJoin t1341 t257)) +(let t1343 (OutputJoin t1342 t259)) +(let t1344 (OutputJoin t1343 t261)) +(let t1345 (OutputJoin t1344 t263)) +(let t1346 (OutputJoin t1345 t265)) +(let t1347 (OutputJoin t1346 t267)) +(let t1348 (OutputJoin t1347 t269)) +(let t1349 (OutputJoin t1348 t271)) +(let t1350 (OutputJoin t1349 t273)) +(let t1351 (OutputJoin t1350 t275)) +(let t1352 (OutputJoin t1351 t277)) +(let t1353 (OutputJoin t1352 t279)) +(let t1354 (OutputJoin t1353 t281)) +(let t1355 (OutputJoin t1354 t283)) +(let t1356 (OutputJoin t1355 t285)) +(let t1357 (OutputJoin t1356 t287)) +(let t1358 (OutputJoin t1357 t289)) +(let t1359 (OutputJoin t1358 t291)) +(let t1360 (OutputJoin t1359 t293)) +(let t1361 (OutputJoin t1360 t295)) +(let t1362 (OutputJoin t1361 t297)) +(let t1363 (OutputJoin t1362 t299)) +(let t1364 (OutputJoin t1363 t301)) +(let t1365 (OutputJoin t1364 t303)) +(let t1366 (OutputJoin t1365 t305)) +(let t1367 (OutputJoin t1366 t307)) +(let t1368 (OutputJoin t1367 t309)) +(let t1369 (OutputJoin t1368 t311)) +(let t1370 (OutputJoin t1369 t313)) +(let t1371 (OutputJoin t1370 t315)) +(let t1372 (OutputJoin t1371 t317)) +(let t1373 (OutputJoin t1372 t319)) +(let t1374 (OutputJoin t1373 t321)) +(let t1375 (OutputJoin t1374 t323)) +(let t1376 (OutputJoin t1375 t325)) +(let t1377 (OutputJoin t1376 t327)) +(let t1378 (OutputJoin t1377 t329)) +(let t1379 (OutputJoin t1378 t331)) +(let t1380 (OutputJoin t1379 t333)) +(let t1381 (OutputJoin t1380 t335)) +(let t1382 (OutputJoin t1381 t337)) +(let t1383 (OutputJoin t1382 t339)) +(let t1384 (OutputJoin t1383 t341)) +(let t1385 (OutputJoin t1384 t343)) +(let t1386 (OutputJoin t1385 t345)) +(let t1387 (OutputJoin t1386 t347)) +(let t1388 (OutputJoin t1387 t349)) +(let t1389 (OutputJoin t1388 t351)) +(let t1390 (OutputJoin t1389 t353)) +(let t1391 (OutputJoin t1390 t355)) +(let t1392 (OutputJoin t1391 t357)) +(let t1393 (OutputJoin t1392 t359)) +(let t1394 (OutputJoin t1393 t361)) +(let t1395 (OutputJoin t1394 t363)) +(let t1396 (OutputJoin t1395 t365)) +(let t1397 (OutputJoin t1396 t367)) +(let t1398 (OutputJoin t1397 t369)) +(let t1399 (OutputJoin t1398 t371)) +(let t1400 (OutputJoin t1399 t373)) +(let t1401 (OutputJoin t1400 t375)) +(let t1402 (OutputJoin t1401 t377)) +(let t1403 (OutputJoin t1402 t379)) +(let t1404 (OutputJoin t1403 t381)) +(let t1405 (OutputJoin t1404 t383)) +(let t1406 (OutputJoin t1405 t385)) +(let t1407 (OutputJoin t1406 t387)) +(let t1408 (OutputJoin t1407 t389)) +(let t1409 (OutputJoin t1408 t391)) +(let t1410 (OutputJoin t1409 t393)) +(let t1411 (OutputJoin t1410 t395)) +(let t1412 (OutputJoin t1411 t397)) +(let t1413 (OutputJoin t1412 t399)) +(let t1414 (OutputJoin t1413 t401)) +(let t1415 (OutputJoin t1414 t403)) +(let t1416 (OutputJoin t1415 t405)) +(let t1417 (OutputJoin t1416 t407)) +(let t1418 (OutputJoin t1417 t409)) +(let t1419 (OutputJoin t1418 t411)) +(let t1420 (OutputJoin t1419 t413)) +(let t1421 (OutputJoin t1420 t415)) +(let t1422 (OutputJoin t1421 t417)) +(let t1423 (OutputJoin t1422 t419)) +(let t1424 (OutputJoin t1423 t421)) +(let t1425 (OutputJoin t1424 t423)) +(let t1426 (OutputJoin t1425 t425)) +(let t1427 (OutputJoin t1426 t427)) +(let t1428 (OutputJoin t1427 t429)) +(let t1429 (OutputJoin t1428 t431)) +(let t1430 (OutputJoin t1429 t433)) +(let t1431 (OutputJoin t1430 t435)) +(let t1432 (OutputJoin t1431 t437)) +(let t1433 (OutputJoin t1432 t439)) +(let t1434 (OutputJoin t1433 t441)) +(let t1435 (OutputJoin t1434 t443)) +(let t1436 (OutputJoin t1435 t445)) +(let t1437 (OutputJoin t1436 t447)) +(let t1438 (OutputJoin t1437 t449)) +(let t1439 (OutputJoin t1438 t451)) +(let t1440 (OutputJoin t1439 t453)) +(let t1441 (OutputJoin t1440 t455)) +(let t1442 (OutputJoin t1441 t457)) +(let t1443 (OutputJoin t1442 t459)) +(let t1444 (OutputJoin t1443 t461)) +(let t1445 (OutputJoin t1444 t463)) +(let t1446 (OutputJoin t1445 t465)) +(let t1447 (OutputJoin t1446 t467)) +(let t1448 (OutputJoin t1447 t469)) +(let t1449 (OutputJoin t1448 t471)) +(let t1450 (OutputJoin t1449 t473)) +(let t1451 (OutputJoin t1450 t475)) +(let t1452 (OutputJoin t1451 t477)) +(let t1453 (OutputJoin t1452 t479)) +(let t1454 (OutputJoin t1453 t481)) +(let t1455 (OutputJoin t1454 t483)) +(let t1456 (OutputJoin t1455 t485)) +(let t1457 (OutputJoin t1456 t487)) +(let t1458 (OutputJoin t1457 t489)) +(let t1459 (OutputJoin t1458 t491)) +(let t1460 (OutputJoin t1459 t493)) +(let t1461 (OutputJoin t1460 t495)) +(let t1462 (OutputJoin t1461 t497)) +(let t1463 (OutputJoin t1462 t499)) +(let t1464 (OutputJoin t1463 t501)) +(let t1465 (OutputJoin t1464 t503)) +(let t1466 (OutputJoin t1465 t505)) +(let t1467 (OutputJoin t1466 t507)) +(let t1468 (OutputJoin t1467 t509)) +(let t1469 (OutputJoin t1468 t511)) +(let t1470 (OutputJoin t1469 t513)) +(let t1471 (OutputJoin t1470 t515)) +(let t1472 (OutputJoin t1471 t517)) +(let t1473 (OutputJoin t1472 t519)) +(let t1474 (OutputJoin t1473 t521)) +(let t1475 (OutputJoin t1474 t523)) +(let t1476 (OutputJoin t1475 t525)) +(let t1477 (OutputJoin t1476 t527)) +(let t1478 (OutputJoin t1477 t529)) +(let t1479 (OutputJoin t1478 t531)) +(let t1480 (OutputJoin t1479 t533)) +(let t1481 (OutputJoin t1480 t535)) +(let t1482 (OutputJoin t1481 t537)) +(let t1483 (OutputJoin t1482 t539)) +(let t1484 (OutputJoin t1483 t541)) +(let t1485 (OutputJoin t1484 t543)) +(let t1486 (OutputJoin t1485 t545)) +(let t1487 (OutputJoin t1486 t547)) +(let t1488 (OutputJoin t1487 t549)) +(let t1489 (OutputJoin t1488 t551)) +(let t1490 (OutputJoin t1489 t553)) +(let t1491 (OutputJoin t1490 t555)) +(let t1492 (OutputJoin t1491 t557)) +(let t1493 (OutputJoin t1492 t559)) +(let t1494 (OutputJoin t1493 t561)) +(let t1495 (OutputJoin t1494 t563)) +(let t1496 (OutputJoin t1495 t565)) +(let t1497 (OutputJoin t1496 t567)) +(let t1498 (OutputJoin t1497 t569)) +(let t1499 (OutputJoin t1498 t571)) +(let t1500 (OutputJoin t1499 t573)) +(let t1501 (OutputJoin t1500 t575)) +(let t1502 (OutputJoin t1501 t577)) +(let t1503 (OutputJoin t1502 t579)) +(let t1504 (OutputJoin t1503 t581)) +(let t1505 (OutputJoin t1504 t583)) +(let t1506 (OutputJoin t1505 t585)) +(let t1507 (OutputJoin t1506 t587)) +(let t1508 (OutputJoin t1507 t589)) +(let t1509 (OutputJoin t1508 t591)) +(let t1510 (OutputJoin t1509 t593)) +(let t1511 (OutputJoin t1510 t595)) +(let t1512 (OutputJoin t1511 t597)) +(let t1513 (OutputJoin t1512 t599)) +(let t1514 (OutputJoin t1513 t601)) +(let t1515 (OutputJoin t1514 t603)) +(let t1516 (OutputJoin t1515 t605)) +(let t1517 (OutputJoin t1516 t607)) +(let t1518 (OutputJoin t1517 t609)) +(let t1519 (OutputJoin t1518 t611)) +(let t1520 (OutputJoin t1519 t613)) +(let t1521 (OutputJoin t1520 t615)) +(let t1522 (OutputJoin t1521 t617)) +(let t1523 (OutputJoin t1522 t619)) +(let t1524 (OutputJoin t1523 t621)) +(let t1525 (OutputJoin t1524 t623)) +(let t1526 (OutputJoin t1525 t625)) +(let t1527 (OutputJoin t1526 t627)) +(let t1528 (OutputJoin t1527 t629)) +(let t1529 (OutputJoin t1528 t631)) +(let t1530 (OutputJoin t1529 t633)) +(let t1531 (OutputJoin t1530 t635)) +(let t1532 (OutputJoin t1531 t637)) +(let t1533 (OutputJoin t1532 t639)) +(let t1534 (OutputJoin t1533 t641)) +(let t1535 (OutputJoin t1534 t643)) +(let t1536 (OutputJoin t1535 t645)) +(let t1537 (OutputJoin t1536 t647)) +(let t1538 (OutputJoin t1537 t649)) +(let t1539 (OutputJoin t1538 t651)) +(let t1540 (OutputJoin t1539 t653)) +(let t1541 (OutputJoin t1540 t655)) +(let t1542 (OutputJoin t1541 t657)) +(let t1543 (OutputJoin t1542 t659)) +(let t1544 (OutputJoin t1543 t661)) +(let t1545 (OutputJoin t1544 t663)) +(let t1546 (OutputJoin t1545 t665)) +(let t1547 (OutputJoin t1546 t667)) +(let t1548 (OutputJoin t1547 t669)) +(let t1549 (OutputJoin t1548 t671)) +(let t1550 (OutputJoin t1549 t673)) +(let t1551 (OutputJoin t1550 t675)) +(let t1552 (OutputJoin t1551 t677)) +(let t1553 (OutputJoin t1552 t679)) +(let t1554 (OutputJoin t1553 t681)) +(let t1555 (OutputJoin t1554 t683)) +(let t1556 (OutputJoin t1555 t685)) +(let t1557 (OutputJoin t1556 t687)) +(let t1558 (OutputJoin t1557 t689)) +(let t1559 (OutputJoin t1558 t691)) +(let t1560 (OutputJoin t1559 t693)) +(let t1561 (OutputJoin t1560 t695)) +(let t1562 (OutputJoin t1561 t697)) +(let t1563 (OutputJoin t1562 t699)) +(let t1564 (OutputJoin t1563 t701)) +(let t1565 (OutputJoin t1564 t703)) +(let t1566 (OutputJoin t1565 t705)) +(let t1567 (OutputJoin t1566 t707)) +(let t1568 (OutputJoin t1567 t709)) +(let t1569 (OutputJoin t1568 t711)) +(let t1570 (OutputJoin t1569 t1086)) +(let t1571 (OutputJoin t1570 t1091)) +(let t1572 (OutputJoin t1571 t1154)) +(let t1573 (OutputJoin t1572 t1093)) +(let t1574 (OutputJoin t1573 t1156)) +(let t1575 (OutputJoin t1574 t1095)) +(let t1576 (OutputJoin t1575 t1158)) +(let t1577 (OutputJoin t1576 t1097)) +(let t1578 (OutputJoin t1577 t1160)) +(let t1579 (OutputJoin t1578 t1099)) +(let t1580 (OutputJoin t1579 t1162)) +(let t1581 (OutputJoin t1580 t1101)) +(let t1582 (OutputJoin t1581 t1164)) +(let t1583 (OutputJoin t1582 t1103)) +(let t1584 (OutputJoin t1583 t1166)) +(let t1585 (OutputJoin t1584 t1105)) +(let t1586 (OutputJoin t1585 t1168)) +(let t1587 (OutputJoin t1586 t1107)) +(let t1588 (OutputJoin t1587 t1170)) +(let t1589 (OutputJoin t1588 t1109)) +(let t1590 (OutputJoin t1589 t1172)) +(let t1591 (OutputJoin t1590 t1111)) +(let t1592 (OutputJoin t1591 t1174)) +(let t1593 (OutputJoin t1592 t1113)) +(let t1594 (OutputJoin t1593 t1176)) +(let t1595 (OutputJoin t1594 t1115)) +(let t1596 (OutputJoin t1595 t1178)) +(let t1597 (OutputJoin t1596 t1117)) +(let t1598 (OutputJoin t1597 t1180)) +(let t1599 (OutputJoin t1598 t1119)) +(let t1600 (OutputJoin t1599 t1182)) +(let t1601 (OutputJoin t1600 t1121)) +(let t1602 (OutputJoin t1601 t1184)) +(let t1603 (OutputJoin t1602 t1123)) +(let t1604 (OutputJoin t1603 t1186)) +(let t1605 (OutputJoin t1604 t1125)) +(let t1606 (OutputJoin t1605 t1188)) +(let t1607 (OutputJoin t1606 t1127)) +(let t1608 (OutputJoin t1607 t1190)) +(let t1609 (OutputJoin t1608 t1129)) +(let t1610 (OutputJoin t1609 t1192)) +(let t1611 (OutputJoin t1610 t1131)) +(let t1612 (OutputJoin t1611 t1194)) +(let t1613 (OutputJoin t1612 t1133)) +(let t1614 (OutputJoin t1613 t1196)) +(let t1615 (OutputJoin t1614 t1135)) +(let t1616 (OutputJoin t1615 t1198)) +(let t1617 (OutputJoin t1616 t1137)) +(let t1618 (OutputJoin t1617 t1200)) +(let t1619 (OutputJoin t1618 t1139)) +(let t1620 (OutputJoin t1619 t1202)) +(let t1621 (OutputJoin t1620 t1141)) +(let t1622 (OutputJoin t1621 t1204)) +(let t1623 (OutputJoin t1622 t1143)) +(let t1624 (OutputJoin t1623 t1206)) +(let t1625 (OutputJoin t1624 t1145)) +(let t1626 (OutputJoin t1625 t1208)) +(let t1627 (OutputJoin t1626 t1147)) +(let t1628 (OutputJoin t1627 t1210)) +(let t1629 (OutputJoin t1628 t1149)) +(let t1630 (OutputJoin t1629 t1212)) +(let t1631 (OutputJoin t1630 t1151)) +(let t1632 (OutputJoin t1631 t1214)) +(let t1633 (OutputJoin t1632 t1087)) +(let t1634 (OutputJoin t1633 t1088)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/no_panic.rs b/tests/no_panic.rs new file mode 100644 index 00000000..39283204 --- /dev/null +++ b/tests/no_panic.rs @@ -0,0 +1,140 @@ +//! Regression tests for previously-reachable panics. +//! +//! Each program below used to abort the process with a `panic!`/`unwrap`/ +//! `expect`/`todo!`. They must now fail gracefully instead. Every test calls +//! `parse_and_run_program`, which means a regression (a real panic) would +//! unwind and fail the test binary; returning `Err` is the graceful behavior. + +use egglog::EGraph; + +/// Assert that `program` returns a recoverable error rather than panicking. +fn assert_errs(program: &str) { + let mut egraph = EGraph::default(); + let result = egraph.parse_and_run_program(None, program); + assert!( + result.is_err(), + "expected a recoverable error, got Ok for:\n{program}" + ); +} + +/// Assert that `program` runs to completion without panicking (the result may +/// be `Ok` or `Err`; the point is that the process is not aborted). +fn assert_no_panic(egraph: &mut EGraph, program: &str) { + let _ = egraph.parse_and_run_program(None, program); +} + +#[test] +fn malformed_sort_declarations_error() { + assert_errs("(sort S (Vec))"); + assert_errs("(sort S (Vec i64 i64))"); + assert_errs("(sort S (Set))"); + assert_errs("(sort S (Set i64 i64))"); + assert_errs("(sort S (Pair i64))"); + assert_errs("(sort S (Map i64))"); + assert_errs("(sort S (MultiSet))"); + assert_errs("(sort S (UnstableFn))"); + assert_errs("(sort S (UnstableFn x String))"); + assert_errs("(sort S (UnstableFn (i64) (String)))"); +} + +#[test] +fn partial_primitives_error_instead_of_panicking() { + // Out-of-range / undefined primitive applications produce no value, so + // extracting them errors gracefully instead of panicking. + assert_errs("(sort IV (Vec i64))(let v (vec-of 1 2 3))(extract (vec-set v 10 99))"); + assert_errs("(sort IV (Vec i64))(let v (vec-of 1 2 3))(extract (vec-set v -1 99))"); + assert_errs("(sort IV (Vec i64))(let v (vec-of 1 2 3))(extract (vec-remove v 10))"); + assert_errs("(extract (<< (bigint 5) -3))"); + assert_errs("(extract (>> (bigint 5) -3))"); + assert_errs("(extract (bigrat (bigint 1) (bigint 0)))"); + // NOTE: `log`/`cbrt` of a non-trivial bigrat are intentionally left as + // `todo!` (unimplemented), not partial primitives: returning "no value" + // would wrongly claim e.g. `cbrt 8/1` has no rational root. + assert_errs("(extract (log2 0))"); + assert_errs("(extract (log2 -5))"); + assert_errs("(sort MS (MultiSet i64))(extract (multiset-pick (multiset-of)))"); +} + +#[test] +fn command_execution_errors() { + assert_errs("(sort Math)(constructor Num (i64) Math)(let x (Num 5))(extract x -1)"); + assert_errs( + r#"(datatype Math (Num i64)) + (rule ((= x (Num 1))) ((Num 2)) :name "r") + (rule ((= x (Num 1))) ((Num 3)) :name "r")"#, + ); + assert_errs(r#"(input nonexistent_function "/tmp/nofile_xyz.txt")"#); + assert_errs( + r#"(sort Math)(constructor Num (i64) Math) + (function edge (Math) i64 :merge old) + (input edge "/tmp/nofile_xyz.txt")"#, + ); + assert_errs( + r#"(function edge (i64) i64 :merge old)(input edge "/tmp/does_not_exist_xyz.txt")"#, + ); + assert_errs( + r#"(sort Math)(constructor Num (i64) Math) + (let y (Num 7))(delete (Num 7)) + (output "/tmp/egglog_out_xyz.txt" y)"#, + ); +} + +#[test] +fn unstable_fn_resolution_errors() { + // Unknown target function. + assert_errs( + r#"(sort BinFn (UnstableFn (i64 i64) i64)) + (function holder () BinFn :merge old) + (rule ((= s "+")) ((set (holder) (unstable-fn "this_function_does_not_exist")))) + (run 1)"#, + ); + // First argument is a (string-typed) variable rather than a string literal. + assert_errs( + r#"(sort BinFn (UnstableFn (i64 i64) i64)) + (function holder () BinFn :merge old) + (rule ((= s "+")) ((set (holder) (unstable-fn s)))) + (run 1)"#, + ); +} + +#[test] +fn desugar_and_parse_errors() { + assert_errs("(fail (datatype*))"); + assert_errs(r#"(fail (include "nonexistent_xyz.egg"))"#); + assert_errs("(rewrite 1 2 :subsume)"); +} + +#[test] +fn multiset_index_with_primitive_function_does_not_panic() { + // Passing a primitive-wrapped function to clear-index used to panic; the + // operation now simply does not apply instead of aborting. + let mut egraph = EGraph::default(); + assert_no_panic( + &mut egraph, + r#"(sort MS (MultiSet i64)) + (let m (multiset-of 1 2)) + (unstable-multiset-clear-index m (unstable-fn "multiset-count"))"#, + ); +} + +#[test] +fn prove_exists_without_proofs_errors() { + // `prove-exists` requires proofs to be enabled; without them it must error + // rather than panic. + let mut egraph = EGraph::default(); + let result = egraph.parse_and_run_program(None, "(datatype M (Foo))(Foo)(prove-exists (Foo))"); + assert!(result.is_err()); +} + +#[test] +fn term_encoding_with_escaped_string_does_not_panic() { + // Re-parsing instrumented egglog text that embeds an escaped string literal + // used to panic; it must now run (or error) without aborting. + let mut egraph = EGraph::new_with_term_encoding(); + assert_no_panic( + &mut egraph, + r#"(sort Math)(constructor MkStr (String) Math) + (MkStr "x") + (check (= (MkStr "\"") (MkStr "\"")))"#, + ); +} diff --git a/tests/paged_llama.egg b/tests/paged_llama.egg new file mode 100644 index 00000000..71647de2 --- /dev/null +++ b/tests/paged_llama.egg @@ -0,0 +1,1540 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "q_pos" (Int))) +(let t2 (Input 2 "scatter_idx" (Int))) +(let t3 (Input 3 "gather_idx" (Int))) +(let t4 (Input 4 "attn_mask" (F32))) +(let t5 (Input 5 "kv_cache.0.k" (F32))) +(let t6 (Input 6 "kv_cache.0.v" (F32))) +(let t7 (Input 7 "kv_cache.1.k" (F32))) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Input 9 "kv_cache.2.k" (F32))) +(let t10 (Input 10 "kv_cache.2.v" (F32))) +(let t11 (Input 11 "kv_cache.3.k" (F32))) +(let t12 (Input 12 "kv_cache.3.v" (F32))) +(let t13 (Input 13 "kv_cache.4.k" (F32))) +(let t14 (Input 14 "kv_cache.4.v" (F32))) +(let t15 (Input 15 "kv_cache.5.k" (F32))) +(let t16 (Input 16 "kv_cache.5.v" (F32))) +(let t17 (Input 17 "kv_cache.6.k" (F32))) +(let t18 (Input 18 "kv_cache.6.v" (F32))) +(let t19 (Input 19 "kv_cache.7.k" (F32))) +(let t20 (Input 20 "kv_cache.7.v" (F32))) +(let t21 (Input 21 "kv_cache.8.k" (F32))) +(let t22 (Input 22 "kv_cache.8.v" (F32))) +(let t23 (Input 23 "kv_cache.9.k" (F32))) +(let t24 (Input 24 "kv_cache.9.v" (F32))) +(let t25 (Input 25 "kv_cache.10.k" (F32))) +(let t26 (Input 26 "kv_cache.10.v" (F32))) +(let t27 (Input 27 "kv_cache.11.k" (F32))) +(let t28 (Input 28 "kv_cache.11.v" (F32))) +(let t29 (Input 29 "kv_cache.12.k" (F32))) +(let t30 (Input 30 "kv_cache.12.v" (F32))) +(let t31 (Input 31 "kv_cache.13.k" (F32))) +(let t32 (Input 32 "kv_cache.13.v" (F32))) +(let t33 (Input 33 "kv_cache.14.k" (F32))) +(let t34 (Input 34 "kv_cache.14.v" (F32))) +(let t35 (Input 35 "kv_cache.15.k" (F32))) +(let t36 (Input 36 "kv_cache.15.v" (F32))) +(let t37 (Input 37 "kv_cache.16.k" (F32))) +(let t38 (Input 38 "kv_cache.16.v" (F32))) +(let t39 (Input 39 "kv_cache.17.k" (F32))) +(let t40 (Input 40 "kv_cache.17.v" (F32))) +(let t41 (Input 41 "kv_cache.18.k" (F32))) +(let t42 (Input 42 "kv_cache.18.v" (F32))) +(let t43 (Input 43 "kv_cache.19.k" (F32))) +(let t44 (Input 44 "kv_cache.19.v" (F32))) +(let t45 (Input 45 "kv_cache.20.k" (F32))) +(let t46 (Input 46 "kv_cache.20.v" (F32))) +(let t47 (Input 47 "kv_cache.21.k" (F32))) +(let t48 (Input 48 "kv_cache.21.v" (F32))) +(let t49 (Input 49 "kv_cache.22.k" (F32))) +(let t50 (Input 50 "kv_cache.22.v" (F32))) +(let t51 (Input 51 "kv_cache.23.k" (F32))) +(let t52 (Input 52 "kv_cache.23.v" (F32))) +(let t53 (Input 53 "kv_cache.24.k" (F32))) +(let t54 (Input 54 "kv_cache.24.v" (F32))) +(let t55 (Input 55 "kv_cache.25.k" (F32))) +(let t56 (Input 56 "kv_cache.25.v" (F32))) +(let t57 (Input 57 "kv_cache.26.k" (F32))) +(let t58 (Input 58 "kv_cache.26.v" (F32))) +(let t59 (Input 59 "kv_cache.27.k" (F32))) +(let t60 (Input 60 "kv_cache.27.v" (F32))) +(let t61 (Input 61 "kv_cache.28.k" (F32))) +(let t62 (Input 62 "kv_cache.28.v" (F32))) +(let t63 (Input 63 "kv_cache.29.k" (F32))) +(let t64 (Input 64 "kv_cache.29.v" (F32))) +(let t65 (Input 65 "kv_cache.30.k" (F32))) +(let t66 (Input 66 "kv_cache.30.v" (F32))) +(let t67 (Input 67 "kv_cache.31.k" (F32))) +(let t68 (Input 68 "kv_cache.31.v" (F32))) +(let t69 (Input 69 "model.layers.0.mlp.up_proj.weight" (F32))) +(let t70 (Output t69 69)) +(let t71 (Input 71 "model.layers.0.mlp.gate_proj.weight" (F32))) +(let t72 (Output t71 71)) +(let t73 (Input 73 "model.layers.0.mlp.down_proj.weight" (F32))) +(let t74 (Output t73 73)) +(let t75 (Input 75 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t76 (Output t75 75)) +(let t77 (Input 77 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t78 (Output t77 77)) +(let t79 (Input 79 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t80 (Output t79 79)) +(let t81 (Input 81 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t82 (Output t81 81)) +(let t83 (Input 83 "model.layers.0.input_layernorm.weight" (F32))) +(let t84 (Output t83 83)) +(let t85 (Input 85 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t86 (Output t85 85)) +(let t87 (Input 87 "model.layers.1.mlp.up_proj.weight" (F32))) +(let t88 (Output t87 87)) +(let t89 (Input 89 "model.layers.1.mlp.gate_proj.weight" (F32))) +(let t90 (Output t89 89)) +(let t91 (Input 91 "model.layers.1.mlp.down_proj.weight" (F32))) +(let t92 (Output t91 91)) +(let t93 (Input 93 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t94 (Output t93 93)) +(let t95 (Input 95 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t96 (Output t95 95)) +(let t97 (Input 97 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t98 (Output t97 97)) +(let t99 (Input 99 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t100 (Output t99 99)) +(let t101 (Input 101 "model.layers.1.input_layernorm.weight" (F32))) +(let t102 (Output t101 101)) +(let t103 (Input 103 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t104 (Output t103 103)) +(let t105 (Input 105 "model.layers.2.mlp.up_proj.weight" (F32))) +(let t106 (Output t105 105)) +(let t107 (Input 107 "model.layers.2.mlp.gate_proj.weight" (F32))) +(let t108 (Output t107 107)) +(let t109 (Input 109 "model.layers.2.mlp.down_proj.weight" (F32))) +(let t110 (Output t109 109)) +(let t111 (Input 111 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t112 (Output t111 111)) +(let t113 (Input 113 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t114 (Output t113 113)) +(let t115 (Input 115 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t116 (Output t115 115)) +(let t117 (Input 117 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t118 (Output t117 117)) +(let t119 (Input 119 "model.layers.2.input_layernorm.weight" (F32))) +(let t120 (Output t119 119)) +(let t121 (Input 121 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t122 (Output t121 121)) +(let t123 (Input 123 "model.layers.3.mlp.up_proj.weight" (F32))) +(let t124 (Output t123 123)) +(let t125 (Input 125 "model.layers.3.mlp.gate_proj.weight" (F32))) +(let t126 (Output t125 125)) +(let t127 (Input 127 "model.layers.3.mlp.down_proj.weight" (F32))) +(let t128 (Output t127 127)) +(let t129 (Input 129 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t130 (Output t129 129)) +(let t131 (Input 131 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t132 (Output t131 131)) +(let t133 (Input 133 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t134 (Output t133 133)) +(let t135 (Input 135 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t136 (Output t135 135)) +(let t137 (Input 137 "model.layers.3.input_layernorm.weight" (F32))) +(let t138 (Output t137 137)) +(let t139 (Input 139 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t140 (Output t139 139)) +(let t141 (Input 141 "model.layers.4.mlp.up_proj.weight" (F32))) +(let t142 (Output t141 141)) +(let t143 (Input 143 "model.layers.4.mlp.gate_proj.weight" (F32))) +(let t144 (Output t143 143)) +(let t145 (Input 145 "model.layers.4.mlp.down_proj.weight" (F32))) +(let t146 (Output t145 145)) +(let t147 (Input 147 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t148 (Output t147 147)) +(let t149 (Input 149 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t150 (Output t149 149)) +(let t151 (Input 151 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t152 (Output t151 151)) +(let t153 (Input 153 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t154 (Output t153 153)) +(let t155 (Input 155 "model.layers.4.input_layernorm.weight" (F32))) +(let t156 (Output t155 155)) +(let t157 (Input 157 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t158 (Output t157 157)) +(let t159 (Input 159 "model.layers.5.mlp.up_proj.weight" (F32))) +(let t160 (Output t159 159)) +(let t161 (Input 161 "model.layers.5.mlp.gate_proj.weight" (F32))) +(let t162 (Output t161 161)) +(let t163 (Input 163 "model.layers.5.mlp.down_proj.weight" (F32))) +(let t164 (Output t163 163)) +(let t165 (Input 165 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t166 (Output t165 165)) +(let t167 (Input 167 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t168 (Output t167 167)) +(let t169 (Input 169 "model.layers.5.self_attn.v_proj.weight" (F32))) +(let t170 (Output t169 169)) +(let t171 (Input 171 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t172 (Output t171 171)) +(let t173 (Input 173 "model.layers.5.input_layernorm.weight" (F32))) +(let t174 (Output t173 173)) +(let t175 (Input 175 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t176 (Output t175 175)) +(let t177 (Input 177 "model.layers.6.mlp.up_proj.weight" (F32))) +(let t178 (Output t177 177)) +(let t179 (Input 179 "model.layers.6.mlp.gate_proj.weight" (F32))) +(let t180 (Output t179 179)) +(let t181 (Input 181 "model.layers.6.mlp.down_proj.weight" (F32))) +(let t182 (Output t181 181)) +(let t183 (Input 183 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t184 (Output t183 183)) +(let t185 (Input 185 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t186 (Output t185 185)) +(let t187 (Input 187 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t188 (Output t187 187)) +(let t189 (Input 189 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t190 (Output t189 189)) +(let t191 (Input 191 "model.layers.6.input_layernorm.weight" (F32))) +(let t192 (Output t191 191)) +(let t193 (Input 193 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t194 (Output t193 193)) +(let t195 (Input 195 "model.layers.7.mlp.up_proj.weight" (F32))) +(let t196 (Output t195 195)) +(let t197 (Input 197 "model.layers.7.mlp.gate_proj.weight" (F32))) +(let t198 (Output t197 197)) +(let t199 (Input 199 "model.layers.7.mlp.down_proj.weight" (F32))) +(let t200 (Output t199 199)) +(let t201 (Input 201 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t202 (Output t201 201)) +(let t203 (Input 203 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t204 (Output t203 203)) +(let t205 (Input 205 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t206 (Output t205 205)) +(let t207 (Input 207 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t208 (Output t207 207)) +(let t209 (Input 209 "model.layers.7.input_layernorm.weight" (F32))) +(let t210 (Output t209 209)) +(let t211 (Input 211 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t212 (Output t211 211)) +(let t213 (Input 213 "model.layers.8.mlp.up_proj.weight" (F32))) +(let t214 (Output t213 213)) +(let t215 (Input 215 "model.layers.8.mlp.gate_proj.weight" (F32))) +(let t216 (Output t215 215)) +(let t217 (Input 217 "model.layers.8.mlp.down_proj.weight" (F32))) +(let t218 (Output t217 217)) +(let t219 (Input 219 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t220 (Output t219 219)) +(let t221 (Input 221 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t222 (Output t221 221)) +(let t223 (Input 223 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t224 (Output t223 223)) +(let t225 (Input 225 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t226 (Output t225 225)) +(let t227 (Input 227 "model.layers.8.input_layernorm.weight" (F32))) +(let t228 (Output t227 227)) +(let t229 (Input 229 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t230 (Output t229 229)) +(let t231 (Input 231 "model.layers.9.mlp.up_proj.weight" (F32))) +(let t232 (Output t231 231)) +(let t233 (Input 233 "model.layers.9.mlp.gate_proj.weight" (F32))) +(let t234 (Output t233 233)) +(let t235 (Input 235 "model.layers.9.mlp.down_proj.weight" (F32))) +(let t236 (Output t235 235)) +(let t237 (Input 237 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t238 (Output t237 237)) +(let t239 (Input 239 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t240 (Output t239 239)) +(let t241 (Input 241 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t242 (Output t241 241)) +(let t243 (Input 243 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t244 (Output t243 243)) +(let t245 (Input 245 "model.layers.9.input_layernorm.weight" (F32))) +(let t246 (Output t245 245)) +(let t247 (Input 247 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t248 (Output t247 247)) +(let t249 (Input 249 "model.layers.10.mlp.up_proj.weight" (F32))) +(let t250 (Output t249 249)) +(let t251 (Input 251 "model.layers.10.mlp.gate_proj.weight" (F32))) +(let t252 (Output t251 251)) +(let t253 (Input 253 "model.layers.10.mlp.down_proj.weight" (F32))) +(let t254 (Output t253 253)) +(let t255 (Input 255 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t256 (Output t255 255)) +(let t257 (Input 257 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t258 (Output t257 257)) +(let t259 (Input 259 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t260 (Output t259 259)) +(let t261 (Input 261 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t262 (Output t261 261)) +(let t263 (Input 263 "model.layers.10.input_layernorm.weight" (F32))) +(let t264 (Output t263 263)) +(let t265 (Input 265 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t266 (Output t265 265)) +(let t267 (Input 267 "model.layers.11.mlp.up_proj.weight" (F32))) +(let t268 (Output t267 267)) +(let t269 (Input 269 "model.layers.11.mlp.gate_proj.weight" (F32))) +(let t270 (Output t269 269)) +(let t271 (Input 271 "model.layers.11.mlp.down_proj.weight" (F32))) +(let t272 (Output t271 271)) +(let t273 (Input 273 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t274 (Output t273 273)) +(let t275 (Input 275 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t276 (Output t275 275)) +(let t277 (Input 277 "model.layers.11.self_attn.v_proj.weight" (F32))) +(let t278 (Output t277 277)) +(let t279 (Input 279 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t280 (Output t279 279)) +(let t281 (Input 281 "model.layers.11.input_layernorm.weight" (F32))) +(let t282 (Output t281 281)) +(let t283 (Input 283 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t284 (Output t283 283)) +(let t285 (Input 285 "model.layers.12.mlp.up_proj.weight" (F32))) +(let t286 (Output t285 285)) +(let t287 (Input 287 "model.layers.12.mlp.gate_proj.weight" (F32))) +(let t288 (Output t287 287)) +(let t289 (Input 289 "model.layers.12.mlp.down_proj.weight" (F32))) +(let t290 (Output t289 289)) +(let t291 (Input 291 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t292 (Output t291 291)) +(let t293 (Input 293 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t294 (Output t293 293)) +(let t295 (Input 295 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t296 (Output t295 295)) +(let t297 (Input 297 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t298 (Output t297 297)) +(let t299 (Input 299 "model.layers.12.input_layernorm.weight" (F32))) +(let t300 (Output t299 299)) +(let t301 (Input 301 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t302 (Output t301 301)) +(let t303 (Input 303 "model.layers.13.mlp.up_proj.weight" (F32))) +(let t304 (Output t303 303)) +(let t305 (Input 305 "model.layers.13.mlp.gate_proj.weight" (F32))) +(let t306 (Output t305 305)) +(let t307 (Input 307 "model.layers.13.mlp.down_proj.weight" (F32))) +(let t308 (Output t307 307)) +(let t309 (Input 309 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t310 (Output t309 309)) +(let t311 (Input 311 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t312 (Output t311 311)) +(let t313 (Input 313 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t314 (Output t313 313)) +(let t315 (Input 315 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t316 (Output t315 315)) +(let t317 (Input 317 "model.layers.13.input_layernorm.weight" (F32))) +(let t318 (Output t317 317)) +(let t319 (Input 319 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t320 (Output t319 319)) +(let t321 (Input 321 "model.layers.14.mlp.up_proj.weight" (F32))) +(let t322 (Output t321 321)) +(let t323 (Input 323 "model.layers.14.mlp.gate_proj.weight" (F32))) +(let t324 (Output t323 323)) +(let t325 (Input 325 "model.layers.14.mlp.down_proj.weight" (F32))) +(let t326 (Output t325 325)) +(let t327 (Input 327 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t328 (Output t327 327)) +(let t329 (Input 329 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t330 (Output t329 329)) +(let t331 (Input 331 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t332 (Output t331 331)) +(let t333 (Input 333 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t334 (Output t333 333)) +(let t335 (Input 335 "model.layers.14.input_layernorm.weight" (F32))) +(let t336 (Output t335 335)) +(let t337 (Input 337 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t338 (Output t337 337)) +(let t339 (Input 339 "model.layers.15.mlp.up_proj.weight" (F32))) +(let t340 (Output t339 339)) +(let t341 (Input 341 "model.layers.15.mlp.gate_proj.weight" (F32))) +(let t342 (Output t341 341)) +(let t343 (Input 343 "model.layers.15.mlp.down_proj.weight" (F32))) +(let t344 (Output t343 343)) +(let t345 (Input 345 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t346 (Output t345 345)) +(let t347 (Input 347 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t348 (Output t347 347)) +(let t349 (Input 349 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t350 (Output t349 349)) +(let t351 (Input 351 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t352 (Output t351 351)) +(let t353 (Input 353 "model.layers.15.input_layernorm.weight" (F32))) +(let t354 (Output t353 353)) +(let t355 (Input 355 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t356 (Output t355 355)) +(let t357 (Input 357 "model.layers.16.mlp.up_proj.weight" (F32))) +(let t358 (Output t357 357)) +(let t359 (Input 359 "model.layers.16.mlp.gate_proj.weight" (F32))) +(let t360 (Output t359 359)) +(let t361 (Input 361 "model.layers.16.mlp.down_proj.weight" (F32))) +(let t362 (Output t361 361)) +(let t363 (Input 363 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t364 (Output t363 363)) +(let t365 (Input 365 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t366 (Output t365 365)) +(let t367 (Input 367 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t368 (Output t367 367)) +(let t369 (Input 369 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t370 (Output t369 369)) +(let t371 (Input 371 "model.layers.16.input_layernorm.weight" (F32))) +(let t372 (Output t371 371)) +(let t373 (Input 373 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t374 (Output t373 373)) +(let t375 (Input 375 "model.layers.17.mlp.up_proj.weight" (F32))) +(let t376 (Output t375 375)) +(let t377 (Input 377 "model.layers.17.mlp.gate_proj.weight" (F32))) +(let t378 (Output t377 377)) +(let t379 (Input 379 "model.layers.17.mlp.down_proj.weight" (F32))) +(let t380 (Output t379 379)) +(let t381 (Input 381 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t382 (Output t381 381)) +(let t383 (Input 383 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t384 (Output t383 383)) +(let t385 (Input 385 "model.layers.17.self_attn.v_proj.weight" (F32))) +(let t386 (Output t385 385)) +(let t387 (Input 387 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t388 (Output t387 387)) +(let t389 (Input 389 "model.layers.17.input_layernorm.weight" (F32))) +(let t390 (Output t389 389)) +(let t391 (Input 391 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t392 (Output t391 391)) +(let t393 (Input 393 "model.layers.18.mlp.up_proj.weight" (F32))) +(let t394 (Output t393 393)) +(let t395 (Input 395 "model.layers.18.mlp.gate_proj.weight" (F32))) +(let t396 (Output t395 395)) +(let t397 (Input 397 "model.layers.18.mlp.down_proj.weight" (F32))) +(let t398 (Output t397 397)) +(let t399 (Input 399 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t400 (Output t399 399)) +(let t401 (Input 401 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t402 (Output t401 401)) +(let t403 (Input 403 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t404 (Output t403 403)) +(let t405 (Input 405 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t406 (Output t405 405)) +(let t407 (Input 407 "model.layers.18.input_layernorm.weight" (F32))) +(let t408 (Output t407 407)) +(let t409 (Input 409 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t410 (Output t409 409)) +(let t411 (Input 411 "model.layers.19.mlp.up_proj.weight" (F32))) +(let t412 (Output t411 411)) +(let t413 (Input 413 "model.layers.19.mlp.gate_proj.weight" (F32))) +(let t414 (Output t413 413)) +(let t415 (Input 415 "model.layers.19.mlp.down_proj.weight" (F32))) +(let t416 (Output t415 415)) +(let t417 (Input 417 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t418 (Output t417 417)) +(let t419 (Input 419 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t420 (Output t419 419)) +(let t421 (Input 421 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t422 (Output t421 421)) +(let t423 (Input 423 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t424 (Output t423 423)) +(let t425 (Input 425 "model.layers.19.input_layernorm.weight" (F32))) +(let t426 (Output t425 425)) +(let t427 (Input 427 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t428 (Output t427 427)) +(let t429 (Input 429 "model.layers.20.mlp.up_proj.weight" (F32))) +(let t430 (Output t429 429)) +(let t431 (Input 431 "model.layers.20.mlp.gate_proj.weight" (F32))) +(let t432 (Output t431 431)) +(let t433 (Input 433 "model.layers.20.mlp.down_proj.weight" (F32))) +(let t434 (Output t433 433)) +(let t435 (Input 435 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t436 (Output t435 435)) +(let t437 (Input 437 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t438 (Output t437 437)) +(let t439 (Input 439 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t440 (Output t439 439)) +(let t441 (Input 441 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t442 (Output t441 441)) +(let t443 (Input 443 "model.layers.20.input_layernorm.weight" (F32))) +(let t444 (Output t443 443)) +(let t445 (Input 445 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t446 (Output t445 445)) +(let t447 (Input 447 "model.layers.21.mlp.up_proj.weight" (F32))) +(let t448 (Output t447 447)) +(let t449 (Input 449 "model.layers.21.mlp.gate_proj.weight" (F32))) +(let t450 (Output t449 449)) +(let t451 (Input 451 "model.layers.21.mlp.down_proj.weight" (F32))) +(let t452 (Output t451 451)) +(let t453 (Input 453 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t454 (Output t453 453)) +(let t455 (Input 455 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t456 (Output t455 455)) +(let t457 (Input 457 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t458 (Output t457 457)) +(let t459 (Input 459 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t460 (Output t459 459)) +(let t461 (Input 461 "model.layers.21.input_layernorm.weight" (F32))) +(let t462 (Output t461 461)) +(let t463 (Input 463 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t464 (Output t463 463)) +(let t465 (Input 465 "model.layers.22.mlp.up_proj.weight" (F32))) +(let t466 (Output t465 465)) +(let t467 (Input 467 "model.layers.22.mlp.gate_proj.weight" (F32))) +(let t468 (Output t467 467)) +(let t469 (Input 469 "model.layers.22.mlp.down_proj.weight" (F32))) +(let t470 (Output t469 469)) +(let t471 (Input 471 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t472 (Output t471 471)) +(let t473 (Input 473 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t474 (Output t473 473)) +(let t475 (Input 475 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t476 (Output t475 475)) +(let t477 (Input 477 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t478 (Output t477 477)) +(let t479 (Input 479 "model.layers.22.input_layernorm.weight" (F32))) +(let t480 (Output t479 479)) +(let t481 (Input 481 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t482 (Output t481 481)) +(let t483 (Input 483 "model.layers.23.mlp.up_proj.weight" (F32))) +(let t484 (Output t483 483)) +(let t485 (Input 485 "model.layers.23.mlp.gate_proj.weight" (F32))) +(let t486 (Output t485 485)) +(let t487 (Input 487 "model.layers.23.mlp.down_proj.weight" (F32))) +(let t488 (Output t487 487)) +(let t489 (Input 489 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t490 (Output t489 489)) +(let t491 (Input 491 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t492 (Output t491 491)) +(let t493 (Input 493 "model.layers.23.self_attn.v_proj.weight" (F32))) +(let t494 (Output t493 493)) +(let t495 (Input 495 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t496 (Output t495 495)) +(let t497 (Input 497 "model.layers.23.input_layernorm.weight" (F32))) +(let t498 (Output t497 497)) +(let t499 (Input 499 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t500 (Output t499 499)) +(let t501 (Input 501 "model.layers.24.mlp.up_proj.weight" (F32))) +(let t502 (Output t501 501)) +(let t503 (Input 503 "model.layers.24.mlp.gate_proj.weight" (F32))) +(let t504 (Output t503 503)) +(let t505 (Input 505 "model.layers.24.mlp.down_proj.weight" (F32))) +(let t506 (Output t505 505)) +(let t507 (Input 507 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t508 (Output t507 507)) +(let t509 (Input 509 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t510 (Output t509 509)) +(let t511 (Input 511 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t512 (Output t511 511)) +(let t513 (Input 513 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t514 (Output t513 513)) +(let t515 (Input 515 "model.layers.24.input_layernorm.weight" (F32))) +(let t516 (Output t515 515)) +(let t517 (Input 517 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t518 (Output t517 517)) +(let t519 (Input 519 "model.layers.25.mlp.up_proj.weight" (F32))) +(let t520 (Output t519 519)) +(let t521 (Input 521 "model.layers.25.mlp.gate_proj.weight" (F32))) +(let t522 (Output t521 521)) +(let t523 (Input 523 "model.layers.25.mlp.down_proj.weight" (F32))) +(let t524 (Output t523 523)) +(let t525 (Input 525 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t526 (Output t525 525)) +(let t527 (Input 527 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t528 (Output t527 527)) +(let t529 (Input 529 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t530 (Output t529 529)) +(let t531 (Input 531 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t532 (Output t531 531)) +(let t533 (Input 533 "model.layers.25.input_layernorm.weight" (F32))) +(let t534 (Output t533 533)) +(let t535 (Input 535 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t536 (Output t535 535)) +(let t537 (Input 537 "model.layers.26.mlp.up_proj.weight" (F32))) +(let t538 (Output t537 537)) +(let t539 (Input 539 "model.layers.26.mlp.gate_proj.weight" (F32))) +(let t540 (Output t539 539)) +(let t541 (Input 541 "model.layers.26.mlp.down_proj.weight" (F32))) +(let t542 (Output t541 541)) +(let t543 (Input 543 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t544 (Output t543 543)) +(let t545 (Input 545 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t546 (Output t545 545)) +(let t547 (Input 547 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t548 (Output t547 547)) +(let t549 (Input 549 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t550 (Output t549 549)) +(let t551 (Input 551 "model.layers.26.input_layernorm.weight" (F32))) +(let t552 (Output t551 551)) +(let t553 (Input 553 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t554 (Output t553 553)) +(let t555 (Input 555 "model.layers.27.mlp.up_proj.weight" (F32))) +(let t556 (Output t555 555)) +(let t557 (Input 557 "model.layers.27.mlp.gate_proj.weight" (F32))) +(let t558 (Output t557 557)) +(let t559 (Input 559 "model.layers.27.mlp.down_proj.weight" (F32))) +(let t560 (Output t559 559)) +(let t561 (Input 561 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t562 (Output t561 561)) +(let t563 (Input 563 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t564 (Output t563 563)) +(let t565 (Input 565 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t566 (Output t565 565)) +(let t567 (Input 567 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t568 (Output t567 567)) +(let t569 (Input 569 "model.layers.27.input_layernorm.weight" (F32))) +(let t570 (Output t569 569)) +(let t571 (Input 571 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t572 (Output t571 571)) +(let t573 (Input 573 "model.layers.28.mlp.up_proj.weight" (F32))) +(let t574 (Output t573 573)) +(let t575 (Input 575 "model.layers.28.mlp.gate_proj.weight" (F32))) +(let t576 (Output t575 575)) +(let t577 (Input 577 "model.layers.28.mlp.down_proj.weight" (F32))) +(let t578 (Output t577 577)) +(let t579 (Input 579 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t580 (Output t579 579)) +(let t581 (Input 581 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t582 (Output t581 581)) +(let t583 (Input 583 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t584 (Output t583 583)) +(let t585 (Input 585 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t586 (Output t585 585)) +(let t587 (Input 587 "model.layers.28.input_layernorm.weight" (F32))) +(let t588 (Output t587 587)) +(let t589 (Input 589 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t590 (Output t589 589)) +(let t591 (Input 591 "model.layers.29.mlp.up_proj.weight" (F32))) +(let t592 (Output t591 591)) +(let t593 (Input 593 "model.layers.29.mlp.gate_proj.weight" (F32))) +(let t594 (Output t593 593)) +(let t595 (Input 595 "model.layers.29.mlp.down_proj.weight" (F32))) +(let t596 (Output t595 595)) +(let t597 (Input 597 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t598 (Output t597 597)) +(let t599 (Input 599 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t600 (Output t599 599)) +(let t601 (Input 601 "model.layers.29.self_attn.v_proj.weight" (F32))) +(let t602 (Output t601 601)) +(let t603 (Input 603 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t604 (Output t603 603)) +(let t605 (Input 605 "model.layers.29.input_layernorm.weight" (F32))) +(let t606 (Output t605 605)) +(let t607 (Input 607 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t608 (Output t607 607)) +(let t609 (Input 609 "model.layers.30.mlp.up_proj.weight" (F32))) +(let t610 (Output t609 609)) +(let t611 (Input 611 "model.layers.30.mlp.gate_proj.weight" (F32))) +(let t612 (Output t611 611)) +(let t613 (Input 613 "model.layers.30.mlp.down_proj.weight" (F32))) +(let t614 (Output t613 613)) +(let t615 (Input 615 "model.layers.30.self_attn.q_proj.weight" (F32))) +(let t616 (Output t615 615)) +(let t617 (Input 617 "model.layers.30.self_attn.k_proj.weight" (F32))) +(let t618 (Output t617 617)) +(let t619 (Input 619 "model.layers.30.self_attn.v_proj.weight" (F32))) +(let t620 (Output t619 619)) +(let t621 (Input 621 "model.layers.30.self_attn.o_proj.weight" (F32))) +(let t622 (Output t621 621)) +(let t623 (Input 623 "model.layers.30.input_layernorm.weight" (F32))) +(let t624 (Output t623 623)) +(let t625 (Input 625 "model.layers.30.post_attention_layernorm.weight" (F32))) +(let t626 (Output t625 625)) +(let t627 (Input 627 "model.layers.31.mlp.up_proj.weight" (F32))) +(let t628 (Output t627 627)) +(let t629 (Input 629 "model.layers.31.mlp.gate_proj.weight" (F32))) +(let t630 (Output t629 629)) +(let t631 (Input 631 "model.layers.31.mlp.down_proj.weight" (F32))) +(let t632 (Output t631 631)) +(let t633 (Input 633 "model.layers.31.self_attn.q_proj.weight" (F32))) +(let t634 (Output t633 633)) +(let t635 (Input 635 "model.layers.31.self_attn.k_proj.weight" (F32))) +(let t636 (Output t635 635)) +(let t637 (Input 637 "model.layers.31.self_attn.v_proj.weight" (F32))) +(let t638 (Output t637 637)) +(let t639 (Input 639 "model.layers.31.self_attn.o_proj.weight" (F32))) +(let t640 (Output t639 639)) +(let t641 (Input 641 "model.layers.31.input_layernorm.weight" (F32))) +(let t642 (Output t641 641)) +(let t643 (Input 643 "model.layers.31.post_attention_layernorm.weight" (F32))) +(let t644 (Output t643 643)) +(let t645 (Input 645 "model.embed_tokens.weight" (F32))) +(let t646 (Output t645 645)) +(let t647 (Input 647 "lm_head.weight" (F32))) +(let t648 (Output t647 647)) +(let t649 (Input 649 "model.norm.weight" (F32))) +(let t650 (Output t649 649)) +(let t651 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t652 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t651 (INil))))) +(let t653 (Op (Iota (MIter) (MNum 4096)) (INil))) +(let t654 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t652 (ICons t653 (INil))))) +(let t655 (Op (Gather (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 128256) (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t654 (ICons t645 (INil))))) +(let t656 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t657 (Op (Cast (MNum 1) (F32)) (ICons t656 (INil)))) +(let t658 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t657 (INil)))) +(let t659 (Op (Constant 0.000010) (INil))) +(let t660 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t661 (Op (Cast (MNum 64) (F32)) (ICons t660 (INil)))) +(let t662 (Op (Constant 0.007812) (INil))) +(let t663 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t661 (ICons t662 (INil))))) +(let t664 (Op (Constant 13.122363) (INil))) +(let t665 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t663 (ICons t664 (INil))))) +(let t666 (Op (Constant 1.442695) (INil))) +(let t667 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t665 (ICons t666 (INil))))) +(let t668 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t667 (INil)))) +(let t669 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t668 (INil)))) +(let t670 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t671 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t670 (ICons t669 (INil))))) +(let t672 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t671 (INil)))) +(let t673 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t674 (Op (Constant -1.000000) (INil))) +(let t675 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t672 (ICons t674 (INil))))) +(let t676 (Op (Constant 1.570796) (INil))) +(let t677 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t675 (ICons t676 (INil))))) +(let t678 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t677 (INil)))) +(let t679 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t672 (INil)))) +(let t680 (Op (Constant -1.000000) (INil))) +(let t681 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t682 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t683 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t682 (INil)))) +(let t684 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t685 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t686 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t685 (INil)))) +(let t687 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t688 (Op (Cast (MNum 64) (F32)) (ICons t687 (INil)))) +(let t689 (Op (Constant 0.007812) (INil))) +(let t690 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t688 (ICons t689 (INil))))) +(let t691 (Op (Constant 13.122363) (INil))) +(let t692 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t690 (ICons t691 (INil))))) +(let t693 (Op (Constant 1.442695) (INil))) +(let t694 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t692 (ICons t693 (INil))))) +(let t695 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t694 (INil)))) +(let t696 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t695 (INil)))) +(let t697 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t698 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t697 (ICons t696 (INil))))) +(let t699 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t698 (INil)))) +(let t700 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t701 (Op (Constant -1.000000) (INil))) +(let t702 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t699 (ICons t701 (INil))))) +(let t703 (Op (Constant 1.570796) (INil))) +(let t704 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t702 (ICons t703 (INil))))) +(let t705 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t704 (INil)))) +(let t706 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t699 (INil)))) +(let t707 (Op (Constant -1.000000) (INil))) +(let t708 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t709 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t710 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t709 (INil)))) +(let t711 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t712 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t713 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t712 (INil)))) +(let t714 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t715 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2 (ICons t714 (INil))))) +(let t716 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t717 (Op (Add (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t715 (ICons t716 (INil))))) +(let t718 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t719 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2 (ICons t718 (INil))))) +(let t720 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t721 (Op (Add (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t719 (ICons t720 (INil))))) +(let t722 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t723 (Op (Mul (ECons (MVar "c") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3 (ICons t722 (INil))))) +(let t724 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t725 (Op (Add (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t723 (ICons t724 (INil))))) +(let t726 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t727 (Op (Mul (ECons (MVar "c") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3 (ICons t726 (INil))))) +(let t728 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t729 (Op (Add (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t727 (ICons t728 (INil))))) +(let t730 (Op (Constant 1.000000) (INil))) +(let t731 (Op (Constant 1.000000) (INil))) +(let t732 (Op (Constant 1.000000) (INil))) +(let t733 (Op (Constant 0.088388) (INil))) +(let t734 (Op (Constant -1.000000) (INil))) +(let t735 (Op (Constant 1.442695) (INil))) +(let t736 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t737 (Op (Cast (MNum 1) (F32)) (ICons t736 (INil)))) +(let t738 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t737 (INil)))) +(let t739 (Op (Constant 0.000010) (INil))) +(let t740 (Op (Constant -1.000000) (INil))) +(let t741 (Op (Constant 1.442695) (INil))) +(let t742 (Op (Constant 1.000000) (INil))) +(let t743 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t744 (Op (Cast (MNum 1) (F32)) (ICons t743 (INil)))) +(let t745 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t744 (INil)))) +(let t746 (Op (Constant 0.000010) (INil))) +(let t747 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t748 (Op (Cast (MNum 64) (F32)) (ICons t747 (INil)))) +(let t749 (Op (Constant 0.007812) (INil))) +(let t750 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t748 (ICons t749 (INil))))) +(let t751 (Op (Constant 13.122363) (INil))) +(let t752 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t750 (ICons t751 (INil))))) +(let t753 (Op (Constant 1.442695) (INil))) +(let t754 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t752 (ICons t753 (INil))))) +(let t755 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t754 (INil)))) +(let t756 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t755 (INil)))) +(let t757 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t758 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t757 (ICons t756 (INil))))) +(let t759 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t758 (INil)))) +(let t760 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t761 (Op (Constant -1.000000) (INil))) +(let t762 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t759 (ICons t761 (INil))))) +(let t763 (Op (Constant 1.570796) (INil))) +(let t764 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t762 (ICons t763 (INil))))) +(let t765 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t764 (INil)))) +(let t766 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t759 (INil)))) +(let t767 (Op (Constant -1.000000) (INil))) +(let t768 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t769 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t770 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t769 (INil)))) +(let t771 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t772 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t773 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t772 (INil)))) +(let t774 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t775 (Op (Cast (MNum 64) (F32)) (ICons t774 (INil)))) +(let t776 (Op (Constant 0.007812) (INil))) +(let t777 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t775 (ICons t776 (INil))))) +(let t778 (Op (Constant 13.122363) (INil))) +(let t779 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t777 (ICons t778 (INil))))) +(let t780 (Op (Constant 1.442695) (INil))) +(let t781 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t779 (ICons t780 (INil))))) +(let t782 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t781 (INil)))) +(let t783 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t782 (INil)))) +(let t784 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t785 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t784 (ICons t783 (INil))))) +(let t786 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t785 (INil)))) +(let t787 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t788 (Op (Constant -1.000000) (INil))) +(let t789 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t786 (ICons t788 (INil))))) +(let t790 (Op (Constant 1.570796) (INil))) +(let t791 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t789 (ICons t790 (INil))))) +(let t792 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t791 (INil)))) +(let t793 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t786 (INil)))) +(let t794 (Op (Constant -1.000000) (INil))) +(let t795 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t796 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t797 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t796 (INil)))) +(let t798 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t799 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t800 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t799 (INil)))) +(let t801 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t802 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2 (ICons t801 (INil))))) +(let t803 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t804 (Op (Add (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t802 (ICons t803 (INil))))) +(let t805 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t806 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2 (ICons t805 (INil))))) +(let t807 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t808 (Op (Add (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t806 (ICons t807 (INil))))) +(let t809 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t810 (Op (Mul (ECons (MVar "c") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3 (ICons t809 (INil))))) +(let t811 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t812 (Op (Add (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t810 (ICons t811 (INil))))) +(let t813 (Op (Iota (MNum 1024) (MNum 1)) (INil))) +(let t814 (Op (Mul (ECons (MVar "c") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3 (ICons t813 (INil))))) +(let t815 (Op (Iota (MIter) (MNum 1024)) (INil))) +(let t816 (Op (Add (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t814 (ICons t815 (INil))))) +(let t817 (Op (Constant 1.000000) (INil))) +(let t818 (Op (Constant 1.000000) (INil))) +(let t819 (Op (Constant 1.000000) (INil))) +(let t820 (Op (Constant 0.088388) (INil))) +(let t821 (Op (Constant -1.000000) (INil))) +(let t822 (Op (Constant 1.442695) (INil))) +(let t823 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t824 (Op (Cast (MNum 1) (F32)) (ICons t823 (INil)))) +(let t825 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t824 (INil)))) +(let t826 (Op (Constant 0.000010) (INil))) +(let t827 (Op (Constant -1.000000) (INil))) +(let t828 (Op (Constant 1.442695) (INil))) +(let t829 (Op (Constant 1.000000) (INil))) +(let t830 (Op (Iota (MNum 4096) (MNum 1)) (INil))) +(let t831 (Op (Cast (MNum 1) (F32)) (ICons t830 (INil)))) +(let t832 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t831 (INil)))) +(let t833 (Op (Constant 0.000010) (INil))) +(let t834 (LoopStart t655 0 0 (MNum 31) (F32))) +(let t835 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t834 (ICons t834 (INil))))) +(let t836 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t835 (INil)))) +(let t837 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t836 (ICons t658 (INil))))) +(let t838 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t837 (ICons t659 (INil))))) +(let t839 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t838 (INil)))) +(let t840 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t839 (INil)))) +(let t841 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t840 (ICons t834 (INil))))) +(let t842 (Op (LoopInput 0 1 (F32)) (ICons t83 (ICons t101 (ICons t119 (ICons t137 (ICons t155 (ICons t173 (ICons t191 (ICons t209 (ICons t227 (ICons t245 (ICons t263 (ICons t281 (ICons t299 (ICons t317 (ICons t335 (ICons t353 (ICons t371 (ICons t389 (ICons t407 (ICons t425 (ICons t443 (ICons t461 (ICons t479 (ICons t497 (ICons t515 (ICons t533 (ICons t551 (ICons t569 (ICons t587 (ICons t605 (ICons t623 (INil)))))))))))))))))))))))))))))))))) +(let t843 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t841 (ICons t842 (INil))))) +(let t844 (Op (LoopInput 0 2 (F32)) (ICons t75 (ICons t93 (ICons t111 (ICons t129 (ICons t147 (ICons t165 (ICons t183 (ICons t201 (ICons t219 (ICons t237 (ICons t255 (ICons t273 (ICons t291 (ICons t309 (ICons t327 (ICons t345 (ICons t363 (ICons t381 (ICons t399 (ICons t417 (ICons t435 (ICons t453 (ICons t471 (ICons t489 (ICons t507 (ICons t525 (ICons t543 (ICons t561 (ICons t579 (ICons t597 (ICons t615 (INil)))))))))))))))))))))))))))))))))) +(let t845 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t843 (ICons t844 (INil))))) +(let t846 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t845 (INil)))) +(let t847 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t673 (ICons t846 (INil))))) +(let t848 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t846 (ICons t678 (INil))))) +(let t849 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t847 (ICons t679 (INil))))) +(let t850 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t849 (ICons t680 (INil))))) +(let t851 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t848 (ICons t850 (INil))))) +(let t852 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t847 (ICons t678 (INil))))) +(let t853 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t846 (ICons t679 (INil))))) +(let t854 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t852 (ICons t853 (INil))))) +(let t855 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t681 (ICons t851 (INil))))) +(let t856 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t855 (ICons t683 (INil))))) +(let t857 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t684 (ICons t854 (INil))))) +(let t858 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t857 (ICons t686 (INil))))) +(let t859 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t856 (ICons t858 (INil))))) +(let t860 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t859 (ICons t730 (INil))))) +(let t861 (Op (LoopInput 0 3 (F32)) (ICons t77 (ICons t95 (ICons t113 (ICons t131 (ICons t149 (ICons t167 (ICons t185 (ICons t203 (ICons t221 (ICons t239 (ICons t257 (ICons t275 (ICons t293 (ICons t311 (ICons t329 (ICons t347 (ICons t365 (ICons t383 (ICons t401 (ICons t419 (ICons t437 (ICons t455 (ICons t473 (ICons t491 (ICons t509 (ICons t527 (ICons t545 (ICons t563 (ICons t581 (ICons t599 (ICons t617 (INil)))))))))))))))))))))))))))))))))) +(let t862 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t843 (ICons t861 (INil))))) +(let t863 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t862 (INil)))) +(let t864 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t700 (ICons t863 (INil))))) +(let t865 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t863 (ICons t705 (INil))))) +(let t866 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t864 (ICons t706 (INil))))) +(let t867 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t866 (ICons t707 (INil))))) +(let t868 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t865 (ICons t867 (INil))))) +(let t869 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t864 (ICons t705 (INil))))) +(let t870 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t863 (ICons t706 (INil))))) +(let t871 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t869 (ICons t870 (INil))))) +(let t872 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t708 (ICons t868 (INil))))) +(let t873 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t872 (ICons t710 (INil))))) +(let t874 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t711 (ICons t871 (INil))))) +(let t875 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t874 (ICons t713 (INil))))) +(let t876 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t873 (ICons t875 (INil))))) +(let t877 (Op (LoopInput 0 4 (F32)) (ICons t79 (ICons t97 (ICons t115 (ICons t133 (ICons t151 (ICons t169 (ICons t187 (ICons t205 (ICons t223 (ICons t241 (ICons t259 (ICons t277 (ICons t295 (ICons t313 (ICons t331 (ICons t349 (ICons t367 (ICons t385 (ICons t403 (ICons t421 (ICons t439 (ICons t457 (ICons t475 (ICons t493 (ICons t511 (ICons t529 (ICons t547 (ICons t565 (ICons t583 (ICons t601 (ICons t619 (INil)))))))))))))))))))))))))))))))))) +(let t878 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t843 (ICons t877 (INil))))) +(let t879 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t878 (INil)))) +(let t880 (Op (LoopInput 0 7 (F32)) (ICons t5 (ICons t7 (ICons t9 (ICons t11 (ICons t13 (ICons t15 (ICons t17 (ICons t19 (ICons t21 (ICons t23 (ICons t25 (ICons t27 (ICons t29 (ICons t31 (ICons t33 (ICons t35 (ICons t37 (ICons t39 (ICons t41 (ICons t43 (ICons t45 (ICons t47 (ICons t49 (ICons t51 (ICons t53 (ICons t55 (ICons t57 (ICons t59 (ICons t61 (ICons t63 (ICons t65 (INil)))))))))))))))))))))))))))))))))) +(let t881 (Op (Scatter (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ICons t880 (ICons t717 (ICons t876 (INil)))))) +(let t882 (Op (Gather (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t725 (ICons t881 (INil))))) +(let t883 (Op (Mul (ECons (MNum 32) (ECons (MNum 128) (ECons (MVar "c") (ENil)))) (ECons (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (ECons (MIter) (ECons (MMul (MIter) (MNum 1024)) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t882 (ICons t731 (INil))))) +(let t884 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ECons (MNum 128) (ENil))))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MVar "c")) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t860 (ICons t883 (INil))))) +(let t885 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t884 (INil)))) +(let t886 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t885 (ICons t733 (INil))))) +(let t887 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t886 (ICons t4 (INil))))) +(let t888 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MVar "c") (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t887 (INil)))) +(let t889 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t888 (ICons t734 (INil))))) +(let t890 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t887 (ICons t889 (INil))))) +(let t891 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t890 (ICons t735 (INil))))) +(let t892 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t891 (INil)))) +(let t893 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MVar "c") (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t892 (INil)))) +(let t894 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t893 (INil)))) +(let t895 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t892 (ICons t894 (INil))))) +(let t896 (Op (LoopInput 0 8 (F32)) (ICons t6 (ICons t8 (ICons t10 (ICons t12 (ICons t14 (ICons t16 (ICons t18 (ICons t20 (ICons t22 (ICons t24 (ICons t26 (ICons t28 (ICons t30 (ICons t32 (ICons t34 (ICons t36 (ICons t38 (ICons t40 (ICons t42 (ICons t44 (ICons t46 (ICons t48 (ICons t50 (ICons t52 (ICons t54 (ICons t56 (ICons t58 (ICons t60 (ICons t62 (ICons t64 (ICons t66 (INil)))))))))))))))))))))))))))))))))) +(let t897 (Op (Scatter (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t896 (ICons t721 (ICons t879 (INil)))))) +(let t898 (Op (Gather (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t729 (ICons t897 (INil))))) +(let t899 (Op (Mul (ECons (MNum 32) (ECons (MVar "c") (ECons (MNum 128) (ENil)))) (ECons (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t898 (ICons t732 (INil))))) +(let t900 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MVar "c") (ENil))))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))))) (ICons t895 (ICons t899 (INil))))) +(let t901 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MVar "c") (ECons (MMul (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t900 (INil)))) +(let t902 (Op (LoopInput 0 11 (F32)) (ICons t81 (ICons t99 (ICons t117 (ICons t135 (ICons t153 (ICons t171 (ICons t189 (ICons t207 (ICons t225 (ICons t243 (ICons t261 (ICons t279 (ICons t297 (ICons t315 (ICons t333 (ICons t351 (ICons t369 (ICons t387 (ICons t405 (ICons t423 (ICons t441 (ICons t459 (ICons t477 (ICons t495 (ICons t513 (ICons t531 (ICons t549 (ICons t567 (ICons t585 (ICons t603 (ICons t621 (INil)))))))))))))))))))))))))))))))))) +(let t903 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t901 (ICons t902 (INil))))) +(let t904 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t903 (INil)))) +(let t905 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t834 (ICons t904 (INil))))) +(let t906 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t905 (ICons t905 (INil))))) +(let t907 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t906 (INil)))) +(let t908 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t907 (ICons t738 (INil))))) +(let t909 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t908 (ICons t739 (INil))))) +(let t910 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t909 (INil)))) +(let t911 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t910 (INil)))) +(let t912 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t911 (ICons t905 (INil))))) +(let t913 (Op (LoopInput 0 12 (F32)) (ICons t85 (ICons t103 (ICons t121 (ICons t139 (ICons t157 (ICons t175 (ICons t193 (ICons t211 (ICons t229 (ICons t247 (ICons t265 (ICons t283 (ICons t301 (ICons t319 (ICons t337 (ICons t355 (ICons t373 (ICons t391 (ICons t409 (ICons t427 (ICons t445 (ICons t463 (ICons t481 (ICons t499 (ICons t517 (ICons t535 (ICons t553 (ICons t571 (ICons t589 (ICons t607 (ICons t625 (INil)))))))))))))))))))))))))))))))))) +(let t914 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t912 (ICons t913 (INil))))) +(let t915 (Op (LoopInput 0 13 (F32)) (ICons t71 (ICons t89 (ICons t107 (ICons t125 (ICons t143 (ICons t161 (ICons t179 (ICons t197 (ICons t215 (ICons t233 (ICons t251 (ICons t269 (ICons t287 (ICons t305 (ICons t323 (ICons t341 (ICons t359 (ICons t377 (ICons t395 (ICons t413 (ICons t431 (ICons t449 (ICons t467 (ICons t485 (ICons t503 (ICons t521 (ICons t539 (ICons t557 (ICons t575 (ICons t593 (ICons t611 (INil)))))))))))))))))))))))))))))))))) +(let t916 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t914 (ICons t915 (INil))))) +(let t917 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t916 (INil)))) +(let t918 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t917 (ICons t740 (INil))))) +(let t919 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t918 (ICons t741 (INil))))) +(let t920 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t919 (INil)))) +(let t921 (Op (Add (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t920 (ICons t742 (INil))))) +(let t922 (Op (Recip (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t921 (INil)))) +(let t923 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t917 (ICons t922 (INil))))) +(let t924 (Op (LoopInput 0 14 (F32)) (ICons t69 (ICons t87 (ICons t105 (ICons t123 (ICons t141 (ICons t159 (ICons t177 (ICons t195 (ICons t213 (ICons t231 (ICons t249 (ICons t267 (ICons t285 (ICons t303 (ICons t321 (ICons t339 (ICons t357 (ICons t375 (ICons t393 (ICons t411 (ICons t429 (ICons t447 (ICons t465 (ICons t483 (ICons t501 (ICons t519 (ICons t537 (ICons t555 (ICons t573 (ICons t591 (ICons t609 (INil)))))))))))))))))))))))))))))))))) +(let t925 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t914 (ICons t924 (INil))))) +(let t926 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t925 (INil)))) +(let t927 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t923 (ICons t926 (INil))))) +(let t928 (Op (LoopInput 0 15 (F32)) (ICons t73 (ICons t91 (ICons t109 (ICons t127 (ICons t145 (ICons t163 (ICons t181 (ICons t199 (ICons t217 (ICons t235 (ICons t253 (ICons t271 (ICons t289 (ICons t307 (ICons t325 (ICons t343 (ICons t361 (ICons t379 (ICons t397 (ICons t415 (ICons t433 (ICons t451 (ICons t469 (ICons t487 (ICons t505 (ICons t523 (ICons t541 (ICons t559 (ICons t577 (ICons t595 (ICons t613 (INil)))))))))))))))))))))))))))))))))) +(let t929 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 14336) (ENil)))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))))) (ICons t927 (ICons t928 (INil))))) +(let t930 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 14336) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t929 (INil)))) +(let t931 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t905 (ICons t930 (INil))))) +(let t932 (LoopEnd t931 0 0 (F32))) +(let t933 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t932 (ICons t932 (INil))))) +(let t934 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t933 (INil)))) +(let t935 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t934 (ICons t745 (INil))))) +(let t936 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t935 (ICons t746 (INil))))) +(let t937 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t936 (INil)))) +(let t938 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t937 (INil)))) +(let t939 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t938 (ICons t932 (INil))))) +(let t940 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t939 (ICons t641 (INil))))) +(let t941 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t940 (ICons t633 (INil))))) +(let t942 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t941 (INil)))) +(let t943 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t940 (ICons t635 (INil))))) +(let t944 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t943 (INil)))) +(let t945 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t940 (ICons t637 (INil))))) +(let t946 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 1024)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t945 (INil)))) +(let t947 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t760 (ICons t942 (INil))))) +(let t948 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t942 (ICons t765 (INil))))) +(let t949 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t947 (ICons t766 (INil))))) +(let t950 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t949 (ICons t767 (INil))))) +(let t951 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t948 (ICons t950 (INil))))) +(let t952 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t947 (ICons t765 (INil))))) +(let t953 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t942 (ICons t766 (INil))))) +(let t954 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t952 (ICons t953 (INil))))) +(let t955 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t768 (ICons t951 (INil))))) +(let t956 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t955 (ICons t770 (INil))))) +(let t957 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t771 (ICons t954 (INil))))) +(let t958 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t957 (ICons t773 (INil))))) +(let t959 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t956 (ICons t958 (INil))))) +(let t960 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t787 (ICons t944 (INil))))) +(let t961 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t944 (ICons t792 (INil))))) +(let t962 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t960 (ICons t793 (INil))))) +(let t963 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t962 (ICons t794 (INil))))) +(let t964 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t961 (ICons t963 (INil))))) +(let t965 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t960 (ICons t792 (INil))))) +(let t966 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t944 (ICons t793 (INil))))) +(let t967 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t965 (ICons t966 (INil))))) +(let t968 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t795 (ICons t964 (INil))))) +(let t969 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t968 (ICons t797 (INil))))) +(let t970 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t798 (ICons t967 (INil))))) +(let t971 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t970 (ICons t800 (INil))))) +(let t972 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t969 (ICons t971 (INil))))) +(let t973 (Op (Scatter (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ICons t67 (ICons t804 (ICons t972 (INil)))))) +(let t974 (Op (Scatter (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t68 (ICons t808 (ICons t946 (INil)))))) +(let t975 (Op (Gather (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t812 (ICons t973 (INil))))) +(let t976 (Op (Gather (ECons (MVar "c") (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))) (ECons (MNum 8192) (ECons (MNum 1024) (ENil))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t816 (ICons t974 (INil))))) +(let t977 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t959 (ICons t817 (INil))))) +(let t978 (Op (Mul (ECons (MNum 32) (ECons (MNum 128) (ECons (MVar "c") (ENil)))) (ECons (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (ECons (MIter) (ECons (MMul (MIter) (MNum 1024)) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t975 (ICons t818 (INil))))) +(let t979 (Op (Mul (ECons (MNum 32) (ECons (MVar "c") (ECons (MNum 128) (ENil)))) (ECons (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t976 (ICons t819 (INil))))) +(let t980 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ECons (MNum 128) (ENil))))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MVar "c")) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t977 (ICons t978 (INil))))) +(let t981 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t980 (INil)))) +(let t982 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t981 (ICons t820 (INil))))) +(let t983 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t982 (ICons t4 (INil))))) +(let t984 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MVar "c") (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t983 (INil)))) +(let t985 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t984 (ICons t821 (INil))))) +(let t986 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t983 (ICons t985 (INil))))) +(let t987 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t986 (ICons t822 (INil))))) +(let t988 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t987 (INil)))) +(let t989 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MVar "c") (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t988 (INil)))) +(let t990 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t989 (INil)))) +(let t991 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MVar "c") (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil))))) (ICons t988 (ICons t990 (INil))))) +(let t992 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MVar "c") (ENil))))) (ECons (MMul (MMul (MIter) (MVar "c")) (MVar "s")) (ECons (MMul (MIter) (MVar "c")) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "c")) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ECons (MIter) (ENil)))))) (ICons t991 (ICons t979 (INil))))) +(let t993 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MVar "c") (ECons (MMul (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MVar "c")) (MNum 128)) (ECons (MMul (MIter) (MVar "c")) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t992 (INil)))) +(let t994 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t993 (ICons t639 (INil))))) +(let t995 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 4096)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t994 (INil)))) +(let t996 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t932 (ICons t995 (INil))))) +(let t997 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t996 (ICons t996 (INil))))) +(let t998 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t997 (INil)))) +(let t999 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t998 (ICons t825 (INil))))) +(let t1000 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t999 (ICons t826 (INil))))) +(let t1001 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1000 (INil)))) +(let t1002 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1001 (INil)))) +(let t1003 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1002 (ICons t996 (INil))))) +(let t1004 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1003 (ICons t643 (INil))))) +(let t1005 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1004 (ICons t629 (INil))))) +(let t1006 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1005 (INil)))) +(let t1007 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1006 (ICons t827 (INil))))) +(let t1008 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1007 (ICons t828 (INil))))) +(let t1009 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1008 (INil)))) +(let t1010 (Op (Add (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1009 (ICons t829 (INil))))) +(let t1011 (Op (Recip (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1010 (INil)))) +(let t1012 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1006 (ICons t1011 (INil))))) +(let t1013 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1004 (ICons t627 (INil))))) +(let t1014 (Op (Sum (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 14336)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1013 (INil)))) +(let t1015 (Op (Mul (ECons (MVar "s") (ECons (MNum 14336) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ICons t1012 (ICons t1014 (INil))))) +(let t1016 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 14336) (ENil)))) (ECons (MMul (MIter) (MNum 14336)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ECons (MIter) (ENil))))) (ICons t1015 (ICons t631 (INil))))) +(let t1017 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 14336) (ECons (MMul (MMul (MIter) (MNum 14336)) (MNum 4096)) (ECons (MMul (MIter) (MNum 14336)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1016 (INil)))) +(let t1018 (Op (Add (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t996 (ICons t1017 (INil))))) +(let t1019 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1018 (ICons t1018 (INil))))) +(let t1020 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 4096) (ECons (MMul (MIter) (MNum 4096)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1019 (INil)))) +(let t1021 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1020 (ICons t832 (INil))))) +(let t1022 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1021 (ICons t833 (INil))))) +(let t1023 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1022 (INil)))) +(let t1024 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1023 (INil)))) +(let t1025 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1024 (ICons t1018 (INil))))) +(let t1026 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1025 (ICons t649 (INil))))) +(let t1027 (Op (Mul (ECons (MVar "s") (ECons (MNum 128256) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 128256)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1026 (ICons t647 (INil))))) +(let t1028 (Op (Sum (ECons (MVar "s") (ECons (MNum 128256) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 128256)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128256)) (ECons (MIter) (ENil)))) (ICons t1027 (INil)))) +(let t1029 (Output t1028 6205)) +(let t1030 (Output t973 6121)) +(let t1031 (Output t974 6126)) +(let t1032 (Op (LoopOutput 0 0 (Int)) (ICons t881 (INil)))) +(let t1033 (Op (LoopOutputSelect 0 0 0 (Int)) (ICons t1032 (INil)))) +(let t1034 (Output t1033 758)) +(let t1035 (Op (LoopOutputSelect 0 0 1 (Int)) (ICons t1032 (INil)))) +(let t1036 (Output t1035 931)) +(let t1037 (Op (LoopOutputSelect 0 0 2 (Int)) (ICons t1032 (INil)))) +(let t1038 (Output t1037 1104)) +(let t1039 (Op (LoopOutputSelect 0 0 3 (Int)) (ICons t1032 (INil)))) +(let t1040 (Output t1039 1277)) +(let t1041 (Op (LoopOutputSelect 0 0 4 (Int)) (ICons t1032 (INil)))) +(let t1042 (Output t1041 1450)) +(let t1043 (Op (LoopOutputSelect 0 0 5 (Int)) (ICons t1032 (INil)))) +(let t1044 (Output t1043 1623)) +(let t1045 (Op (LoopOutputSelect 0 0 6 (Int)) (ICons t1032 (INil)))) +(let t1046 (Output t1045 1796)) +(let t1047 (Op (LoopOutputSelect 0 0 7 (Int)) (ICons t1032 (INil)))) +(let t1048 (Output t1047 1969)) +(let t1049 (Op (LoopOutputSelect 0 0 8 (Int)) (ICons t1032 (INil)))) +(let t1050 (Output t1049 2142)) +(let t1051 (Op (LoopOutputSelect 0 0 9 (Int)) (ICons t1032 (INil)))) +(let t1052 (Output t1051 2315)) +(let t1053 (Op (LoopOutputSelect 0 0 10 (Int)) (ICons t1032 (INil)))) +(let t1054 (Output t1053 2488)) +(let t1055 (Op (LoopOutputSelect 0 0 11 (Int)) (ICons t1032 (INil)))) +(let t1056 (Output t1055 2661)) +(let t1057 (Op (LoopOutputSelect 0 0 12 (Int)) (ICons t1032 (INil)))) +(let t1058 (Output t1057 2834)) +(let t1059 (Op (LoopOutputSelect 0 0 13 (Int)) (ICons t1032 (INil)))) +(let t1060 (Output t1059 3007)) +(let t1061 (Op (LoopOutputSelect 0 0 14 (Int)) (ICons t1032 (INil)))) +(let t1062 (Output t1061 3180)) +(let t1063 (Op (LoopOutputSelect 0 0 15 (Int)) (ICons t1032 (INil)))) +(let t1064 (Output t1063 3353)) +(let t1065 (Op (LoopOutputSelect 0 0 16 (Int)) (ICons t1032 (INil)))) +(let t1066 (Output t1065 3526)) +(let t1067 (Op (LoopOutputSelect 0 0 17 (Int)) (ICons t1032 (INil)))) +(let t1068 (Output t1067 3699)) +(let t1069 (Op (LoopOutputSelect 0 0 18 (Int)) (ICons t1032 (INil)))) +(let t1070 (Output t1069 3872)) +(let t1071 (Op (LoopOutputSelect 0 0 19 (Int)) (ICons t1032 (INil)))) +(let t1072 (Output t1071 4045)) +(let t1073 (Op (LoopOutputSelect 0 0 20 (Int)) (ICons t1032 (INil)))) +(let t1074 (Output t1073 4218)) +(let t1075 (Op (LoopOutputSelect 0 0 21 (Int)) (ICons t1032 (INil)))) +(let t1076 (Output t1075 4391)) +(let t1077 (Op (LoopOutputSelect 0 0 22 (Int)) (ICons t1032 (INil)))) +(let t1078 (Output t1077 4564)) +(let t1079 (Op (LoopOutputSelect 0 0 23 (Int)) (ICons t1032 (INil)))) +(let t1080 (Output t1079 4737)) +(let t1081 (Op (LoopOutputSelect 0 0 24 (Int)) (ICons t1032 (INil)))) +(let t1082 (Output t1081 4910)) +(let t1083 (Op (LoopOutputSelect 0 0 25 (Int)) (ICons t1032 (INil)))) +(let t1084 (Output t1083 5083)) +(let t1085 (Op (LoopOutputSelect 0 0 26 (Int)) (ICons t1032 (INil)))) +(let t1086 (Output t1085 5256)) +(let t1087 (Op (LoopOutputSelect 0 0 27 (Int)) (ICons t1032 (INil)))) +(let t1088 (Output t1087 5429)) +(let t1089 (Op (LoopOutputSelect 0 0 28 (Int)) (ICons t1032 (INil)))) +(let t1090 (Output t1089 5602)) +(let t1091 (Op (LoopOutputSelect 0 0 29 (Int)) (ICons t1032 (INil)))) +(let t1092 (Output t1091 5775)) +(let t1093 (Op (LoopOutputSelect 0 0 30 (Int)) (ICons t1032 (INil)))) +(let t1094 (Output t1093 5948)) +(let t1095 (Op (LoopOutput 0 1 (Int)) (ICons t897 (INil)))) +(let t1096 (Op (LoopOutputSelect 0 1 0 (Int)) (ICons t1095 (INil)))) +(let t1097 (Output t1096 763)) +(let t1098 (Op (LoopOutputSelect 0 1 1 (Int)) (ICons t1095 (INil)))) +(let t1099 (Output t1098 936)) +(let t1100 (Op (LoopOutputSelect 0 1 2 (Int)) (ICons t1095 (INil)))) +(let t1101 (Output t1100 1109)) +(let t1102 (Op (LoopOutputSelect 0 1 3 (Int)) (ICons t1095 (INil)))) +(let t1103 (Output t1102 1282)) +(let t1104 (Op (LoopOutputSelect 0 1 4 (Int)) (ICons t1095 (INil)))) +(let t1105 (Output t1104 1455)) +(let t1106 (Op (LoopOutputSelect 0 1 5 (Int)) (ICons t1095 (INil)))) +(let t1107 (Output t1106 1628)) +(let t1108 (Op (LoopOutputSelect 0 1 6 (Int)) (ICons t1095 (INil)))) +(let t1109 (Output t1108 1801)) +(let t1110 (Op (LoopOutputSelect 0 1 7 (Int)) (ICons t1095 (INil)))) +(let t1111 (Output t1110 1974)) +(let t1112 (Op (LoopOutputSelect 0 1 8 (Int)) (ICons t1095 (INil)))) +(let t1113 (Output t1112 2147)) +(let t1114 (Op (LoopOutputSelect 0 1 9 (Int)) (ICons t1095 (INil)))) +(let t1115 (Output t1114 2320)) +(let t1116 (Op (LoopOutputSelect 0 1 10 (Int)) (ICons t1095 (INil)))) +(let t1117 (Output t1116 2493)) +(let t1118 (Op (LoopOutputSelect 0 1 11 (Int)) (ICons t1095 (INil)))) +(let t1119 (Output t1118 2666)) +(let t1120 (Op (LoopOutputSelect 0 1 12 (Int)) (ICons t1095 (INil)))) +(let t1121 (Output t1120 2839)) +(let t1122 (Op (LoopOutputSelect 0 1 13 (Int)) (ICons t1095 (INil)))) +(let t1123 (Output t1122 3012)) +(let t1124 (Op (LoopOutputSelect 0 1 14 (Int)) (ICons t1095 (INil)))) +(let t1125 (Output t1124 3185)) +(let t1126 (Op (LoopOutputSelect 0 1 15 (Int)) (ICons t1095 (INil)))) +(let t1127 (Output t1126 3358)) +(let t1128 (Op (LoopOutputSelect 0 1 16 (Int)) (ICons t1095 (INil)))) +(let t1129 (Output t1128 3531)) +(let t1130 (Op (LoopOutputSelect 0 1 17 (Int)) (ICons t1095 (INil)))) +(let t1131 (Output t1130 3704)) +(let t1132 (Op (LoopOutputSelect 0 1 18 (Int)) (ICons t1095 (INil)))) +(let t1133 (Output t1132 3877)) +(let t1134 (Op (LoopOutputSelect 0 1 19 (Int)) (ICons t1095 (INil)))) +(let t1135 (Output t1134 4050)) +(let t1136 (Op (LoopOutputSelect 0 1 20 (Int)) (ICons t1095 (INil)))) +(let t1137 (Output t1136 4223)) +(let t1138 (Op (LoopOutputSelect 0 1 21 (Int)) (ICons t1095 (INil)))) +(let t1139 (Output t1138 4396)) +(let t1140 (Op (LoopOutputSelect 0 1 22 (Int)) (ICons t1095 (INil)))) +(let t1141 (Output t1140 4569)) +(let t1142 (Op (LoopOutputSelect 0 1 23 (Int)) (ICons t1095 (INil)))) +(let t1143 (Output t1142 4742)) +(let t1144 (Op (LoopOutputSelect 0 1 24 (Int)) (ICons t1095 (INil)))) +(let t1145 (Output t1144 4915)) +(let t1146 (Op (LoopOutputSelect 0 1 25 (Int)) (ICons t1095 (INil)))) +(let t1147 (Output t1146 5088)) +(let t1148 (Op (LoopOutputSelect 0 1 26 (Int)) (ICons t1095 (INil)))) +(let t1149 (Output t1148 5261)) +(let t1150 (Op (LoopOutputSelect 0 1 27 (Int)) (ICons t1095 (INil)))) +(let t1151 (Output t1150 5434)) +(let t1152 (Op (LoopOutputSelect 0 1 28 (Int)) (ICons t1095 (INil)))) +(let t1153 (Output t1152 5607)) +(let t1154 (Op (LoopOutputSelect 0 1 29 (Int)) (ICons t1095 (INil)))) +(let t1155 (Output t1154 5780)) +(let t1156 (Op (LoopOutputSelect 0 1 30 (Int)) (ICons t1095 (INil)))) +(let t1157 (Output t1156 5953)) +(let t1159 (OutputJoin t70 t72)) +(let t1160 (OutputJoin t1159 t74)) +(let t1161 (OutputJoin t1160 t76)) +(let t1162 (OutputJoin t1161 t78)) +(let t1163 (OutputJoin t1162 t80)) +(let t1164 (OutputJoin t1163 t82)) +(let t1165 (OutputJoin t1164 t84)) +(let t1166 (OutputJoin t1165 t86)) +(let t1167 (OutputJoin t1166 t88)) +(let t1168 (OutputJoin t1167 t90)) +(let t1169 (OutputJoin t1168 t92)) +(let t1170 (OutputJoin t1169 t94)) +(let t1171 (OutputJoin t1170 t96)) +(let t1172 (OutputJoin t1171 t98)) +(let t1173 (OutputJoin t1172 t100)) +(let t1174 (OutputJoin t1173 t102)) +(let t1175 (OutputJoin t1174 t104)) +(let t1176 (OutputJoin t1175 t106)) +(let t1177 (OutputJoin t1176 t108)) +(let t1178 (OutputJoin t1177 t110)) +(let t1179 (OutputJoin t1178 t112)) +(let t1180 (OutputJoin t1179 t114)) +(let t1181 (OutputJoin t1180 t116)) +(let t1182 (OutputJoin t1181 t118)) +(let t1183 (OutputJoin t1182 t120)) +(let t1184 (OutputJoin t1183 t122)) +(let t1185 (OutputJoin t1184 t124)) +(let t1186 (OutputJoin t1185 t126)) +(let t1187 (OutputJoin t1186 t128)) +(let t1188 (OutputJoin t1187 t130)) +(let t1189 (OutputJoin t1188 t132)) +(let t1190 (OutputJoin t1189 t134)) +(let t1191 (OutputJoin t1190 t136)) +(let t1192 (OutputJoin t1191 t138)) +(let t1193 (OutputJoin t1192 t140)) +(let t1194 (OutputJoin t1193 t142)) +(let t1195 (OutputJoin t1194 t144)) +(let t1196 (OutputJoin t1195 t146)) +(let t1197 (OutputJoin t1196 t148)) +(let t1198 (OutputJoin t1197 t150)) +(let t1199 (OutputJoin t1198 t152)) +(let t1200 (OutputJoin t1199 t154)) +(let t1201 (OutputJoin t1200 t156)) +(let t1202 (OutputJoin t1201 t158)) +(let t1203 (OutputJoin t1202 t160)) +(let t1204 (OutputJoin t1203 t162)) +(let t1205 (OutputJoin t1204 t164)) +(let t1206 (OutputJoin t1205 t166)) +(let t1207 (OutputJoin t1206 t168)) +(let t1208 (OutputJoin t1207 t170)) +(let t1209 (OutputJoin t1208 t172)) +(let t1210 (OutputJoin t1209 t174)) +(let t1211 (OutputJoin t1210 t176)) +(let t1212 (OutputJoin t1211 t178)) +(let t1213 (OutputJoin t1212 t180)) +(let t1214 (OutputJoin t1213 t182)) +(let t1215 (OutputJoin t1214 t184)) +(let t1216 (OutputJoin t1215 t186)) +(let t1217 (OutputJoin t1216 t188)) +(let t1218 (OutputJoin t1217 t190)) +(let t1219 (OutputJoin t1218 t192)) +(let t1220 (OutputJoin t1219 t194)) +(let t1221 (OutputJoin t1220 t196)) +(let t1222 (OutputJoin t1221 t198)) +(let t1223 (OutputJoin t1222 t200)) +(let t1224 (OutputJoin t1223 t202)) +(let t1225 (OutputJoin t1224 t204)) +(let t1226 (OutputJoin t1225 t206)) +(let t1227 (OutputJoin t1226 t208)) +(let t1228 (OutputJoin t1227 t210)) +(let t1229 (OutputJoin t1228 t212)) +(let t1230 (OutputJoin t1229 t214)) +(let t1231 (OutputJoin t1230 t216)) +(let t1232 (OutputJoin t1231 t218)) +(let t1233 (OutputJoin t1232 t220)) +(let t1234 (OutputJoin t1233 t222)) +(let t1235 (OutputJoin t1234 t224)) +(let t1236 (OutputJoin t1235 t226)) +(let t1237 (OutputJoin t1236 t228)) +(let t1238 (OutputJoin t1237 t230)) +(let t1239 (OutputJoin t1238 t232)) +(let t1240 (OutputJoin t1239 t234)) +(let t1241 (OutputJoin t1240 t236)) +(let t1242 (OutputJoin t1241 t238)) +(let t1243 (OutputJoin t1242 t240)) +(let t1244 (OutputJoin t1243 t242)) +(let t1245 (OutputJoin t1244 t244)) +(let t1246 (OutputJoin t1245 t246)) +(let t1247 (OutputJoin t1246 t248)) +(let t1248 (OutputJoin t1247 t250)) +(let t1249 (OutputJoin t1248 t252)) +(let t1250 (OutputJoin t1249 t254)) +(let t1251 (OutputJoin t1250 t256)) +(let t1252 (OutputJoin t1251 t258)) +(let t1253 (OutputJoin t1252 t260)) +(let t1254 (OutputJoin t1253 t262)) +(let t1255 (OutputJoin t1254 t264)) +(let t1256 (OutputJoin t1255 t266)) +(let t1257 (OutputJoin t1256 t268)) +(let t1258 (OutputJoin t1257 t270)) +(let t1259 (OutputJoin t1258 t272)) +(let t1260 (OutputJoin t1259 t274)) +(let t1261 (OutputJoin t1260 t276)) +(let t1262 (OutputJoin t1261 t278)) +(let t1263 (OutputJoin t1262 t280)) +(let t1264 (OutputJoin t1263 t282)) +(let t1265 (OutputJoin t1264 t284)) +(let t1266 (OutputJoin t1265 t286)) +(let t1267 (OutputJoin t1266 t288)) +(let t1268 (OutputJoin t1267 t290)) +(let t1269 (OutputJoin t1268 t292)) +(let t1270 (OutputJoin t1269 t294)) +(let t1271 (OutputJoin t1270 t296)) +(let t1272 (OutputJoin t1271 t298)) +(let t1273 (OutputJoin t1272 t300)) +(let t1274 (OutputJoin t1273 t302)) +(let t1275 (OutputJoin t1274 t304)) +(let t1276 (OutputJoin t1275 t306)) +(let t1277 (OutputJoin t1276 t308)) +(let t1278 (OutputJoin t1277 t310)) +(let t1279 (OutputJoin t1278 t312)) +(let t1280 (OutputJoin t1279 t314)) +(let t1281 (OutputJoin t1280 t316)) +(let t1282 (OutputJoin t1281 t318)) +(let t1283 (OutputJoin t1282 t320)) +(let t1284 (OutputJoin t1283 t322)) +(let t1285 (OutputJoin t1284 t324)) +(let t1286 (OutputJoin t1285 t326)) +(let t1287 (OutputJoin t1286 t328)) +(let t1288 (OutputJoin t1287 t330)) +(let t1289 (OutputJoin t1288 t332)) +(let t1290 (OutputJoin t1289 t334)) +(let t1291 (OutputJoin t1290 t336)) +(let t1292 (OutputJoin t1291 t338)) +(let t1293 (OutputJoin t1292 t340)) +(let t1294 (OutputJoin t1293 t342)) +(let t1295 (OutputJoin t1294 t344)) +(let t1296 (OutputJoin t1295 t346)) +(let t1297 (OutputJoin t1296 t348)) +(let t1298 (OutputJoin t1297 t350)) +(let t1299 (OutputJoin t1298 t352)) +(let t1300 (OutputJoin t1299 t354)) +(let t1301 (OutputJoin t1300 t356)) +(let t1302 (OutputJoin t1301 t358)) +(let t1303 (OutputJoin t1302 t360)) +(let t1304 (OutputJoin t1303 t362)) +(let t1305 (OutputJoin t1304 t364)) +(let t1306 (OutputJoin t1305 t366)) +(let t1307 (OutputJoin t1306 t368)) +(let t1308 (OutputJoin t1307 t370)) +(let t1309 (OutputJoin t1308 t372)) +(let t1310 (OutputJoin t1309 t374)) +(let t1311 (OutputJoin t1310 t376)) +(let t1312 (OutputJoin t1311 t378)) +(let t1313 (OutputJoin t1312 t380)) +(let t1314 (OutputJoin t1313 t382)) +(let t1315 (OutputJoin t1314 t384)) +(let t1316 (OutputJoin t1315 t386)) +(let t1317 (OutputJoin t1316 t388)) +(let t1318 (OutputJoin t1317 t390)) +(let t1319 (OutputJoin t1318 t392)) +(let t1320 (OutputJoin t1319 t394)) +(let t1321 (OutputJoin t1320 t396)) +(let t1322 (OutputJoin t1321 t398)) +(let t1323 (OutputJoin t1322 t400)) +(let t1324 (OutputJoin t1323 t402)) +(let t1325 (OutputJoin t1324 t404)) +(let t1326 (OutputJoin t1325 t406)) +(let t1327 (OutputJoin t1326 t408)) +(let t1328 (OutputJoin t1327 t410)) +(let t1329 (OutputJoin t1328 t412)) +(let t1330 (OutputJoin t1329 t414)) +(let t1331 (OutputJoin t1330 t416)) +(let t1332 (OutputJoin t1331 t418)) +(let t1333 (OutputJoin t1332 t420)) +(let t1334 (OutputJoin t1333 t422)) +(let t1335 (OutputJoin t1334 t424)) +(let t1336 (OutputJoin t1335 t426)) +(let t1337 (OutputJoin t1336 t428)) +(let t1338 (OutputJoin t1337 t430)) +(let t1339 (OutputJoin t1338 t432)) +(let t1340 (OutputJoin t1339 t434)) +(let t1341 (OutputJoin t1340 t436)) +(let t1342 (OutputJoin t1341 t438)) +(let t1343 (OutputJoin t1342 t440)) +(let t1344 (OutputJoin t1343 t442)) +(let t1345 (OutputJoin t1344 t444)) +(let t1346 (OutputJoin t1345 t446)) +(let t1347 (OutputJoin t1346 t448)) +(let t1348 (OutputJoin t1347 t450)) +(let t1349 (OutputJoin t1348 t452)) +(let t1350 (OutputJoin t1349 t454)) +(let t1351 (OutputJoin t1350 t456)) +(let t1352 (OutputJoin t1351 t458)) +(let t1353 (OutputJoin t1352 t460)) +(let t1354 (OutputJoin t1353 t462)) +(let t1355 (OutputJoin t1354 t464)) +(let t1356 (OutputJoin t1355 t466)) +(let t1357 (OutputJoin t1356 t468)) +(let t1358 (OutputJoin t1357 t470)) +(let t1359 (OutputJoin t1358 t472)) +(let t1360 (OutputJoin t1359 t474)) +(let t1361 (OutputJoin t1360 t476)) +(let t1362 (OutputJoin t1361 t478)) +(let t1363 (OutputJoin t1362 t480)) +(let t1364 (OutputJoin t1363 t482)) +(let t1365 (OutputJoin t1364 t484)) +(let t1366 (OutputJoin t1365 t486)) +(let t1367 (OutputJoin t1366 t488)) +(let t1368 (OutputJoin t1367 t490)) +(let t1369 (OutputJoin t1368 t492)) +(let t1370 (OutputJoin t1369 t494)) +(let t1371 (OutputJoin t1370 t496)) +(let t1372 (OutputJoin t1371 t498)) +(let t1373 (OutputJoin t1372 t500)) +(let t1374 (OutputJoin t1373 t502)) +(let t1375 (OutputJoin t1374 t504)) +(let t1376 (OutputJoin t1375 t506)) +(let t1377 (OutputJoin t1376 t508)) +(let t1378 (OutputJoin t1377 t510)) +(let t1379 (OutputJoin t1378 t512)) +(let t1380 (OutputJoin t1379 t514)) +(let t1381 (OutputJoin t1380 t516)) +(let t1382 (OutputJoin t1381 t518)) +(let t1383 (OutputJoin t1382 t520)) +(let t1384 (OutputJoin t1383 t522)) +(let t1385 (OutputJoin t1384 t524)) +(let t1386 (OutputJoin t1385 t526)) +(let t1387 (OutputJoin t1386 t528)) +(let t1388 (OutputJoin t1387 t530)) +(let t1389 (OutputJoin t1388 t532)) +(let t1390 (OutputJoin t1389 t534)) +(let t1391 (OutputJoin t1390 t536)) +(let t1392 (OutputJoin t1391 t538)) +(let t1393 (OutputJoin t1392 t540)) +(let t1394 (OutputJoin t1393 t542)) +(let t1395 (OutputJoin t1394 t544)) +(let t1396 (OutputJoin t1395 t546)) +(let t1397 (OutputJoin t1396 t548)) +(let t1398 (OutputJoin t1397 t550)) +(let t1399 (OutputJoin t1398 t552)) +(let t1400 (OutputJoin t1399 t554)) +(let t1401 (OutputJoin t1400 t556)) +(let t1402 (OutputJoin t1401 t558)) +(let t1403 (OutputJoin t1402 t560)) +(let t1404 (OutputJoin t1403 t562)) +(let t1405 (OutputJoin t1404 t564)) +(let t1406 (OutputJoin t1405 t566)) +(let t1407 (OutputJoin t1406 t568)) +(let t1408 (OutputJoin t1407 t570)) +(let t1409 (OutputJoin t1408 t572)) +(let t1410 (OutputJoin t1409 t574)) +(let t1411 (OutputJoin t1410 t576)) +(let t1412 (OutputJoin t1411 t578)) +(let t1413 (OutputJoin t1412 t580)) +(let t1414 (OutputJoin t1413 t582)) +(let t1415 (OutputJoin t1414 t584)) +(let t1416 (OutputJoin t1415 t586)) +(let t1417 (OutputJoin t1416 t588)) +(let t1418 (OutputJoin t1417 t590)) +(let t1419 (OutputJoin t1418 t592)) +(let t1420 (OutputJoin t1419 t594)) +(let t1421 (OutputJoin t1420 t596)) +(let t1422 (OutputJoin t1421 t598)) +(let t1423 (OutputJoin t1422 t600)) +(let t1424 (OutputJoin t1423 t602)) +(let t1425 (OutputJoin t1424 t604)) +(let t1426 (OutputJoin t1425 t606)) +(let t1427 (OutputJoin t1426 t608)) +(let t1428 (OutputJoin t1427 t610)) +(let t1429 (OutputJoin t1428 t612)) +(let t1430 (OutputJoin t1429 t614)) +(let t1431 (OutputJoin t1430 t616)) +(let t1432 (OutputJoin t1431 t618)) +(let t1433 (OutputJoin t1432 t620)) +(let t1434 (OutputJoin t1433 t622)) +(let t1435 (OutputJoin t1434 t624)) +(let t1436 (OutputJoin t1435 t626)) +(let t1437 (OutputJoin t1436 t628)) +(let t1438 (OutputJoin t1437 t630)) +(let t1439 (OutputJoin t1438 t632)) +(let t1440 (OutputJoin t1439 t634)) +(let t1441 (OutputJoin t1440 t636)) +(let t1442 (OutputJoin t1441 t638)) +(let t1443 (OutputJoin t1442 t640)) +(let t1444 (OutputJoin t1443 t642)) +(let t1445 (OutputJoin t1444 t644)) +(let t1446 (OutputJoin t1445 t646)) +(let t1447 (OutputJoin t1446 t648)) +(let t1448 (OutputJoin t1447 t650)) +(let t1449 (OutputJoin t1448 t1029)) +(let t1450 (OutputJoin t1449 t1034)) +(let t1451 (OutputJoin t1450 t1097)) +(let t1452 (OutputJoin t1451 t1036)) +(let t1453 (OutputJoin t1452 t1099)) +(let t1454 (OutputJoin t1453 t1038)) +(let t1455 (OutputJoin t1454 t1101)) +(let t1456 (OutputJoin t1455 t1040)) +(let t1457 (OutputJoin t1456 t1103)) +(let t1458 (OutputJoin t1457 t1042)) +(let t1459 (OutputJoin t1458 t1105)) +(let t1460 (OutputJoin t1459 t1044)) +(let t1461 (OutputJoin t1460 t1107)) +(let t1462 (OutputJoin t1461 t1046)) +(let t1463 (OutputJoin t1462 t1109)) +(let t1464 (OutputJoin t1463 t1048)) +(let t1465 (OutputJoin t1464 t1111)) +(let t1466 (OutputJoin t1465 t1050)) +(let t1467 (OutputJoin t1466 t1113)) +(let t1468 (OutputJoin t1467 t1052)) +(let t1469 (OutputJoin t1468 t1115)) +(let t1470 (OutputJoin t1469 t1054)) +(let t1471 (OutputJoin t1470 t1117)) +(let t1472 (OutputJoin t1471 t1056)) +(let t1473 (OutputJoin t1472 t1119)) +(let t1474 (OutputJoin t1473 t1058)) +(let t1475 (OutputJoin t1474 t1121)) +(let t1476 (OutputJoin t1475 t1060)) +(let t1477 (OutputJoin t1476 t1123)) +(let t1478 (OutputJoin t1477 t1062)) +(let t1479 (OutputJoin t1478 t1125)) +(let t1480 (OutputJoin t1479 t1064)) +(let t1481 (OutputJoin t1480 t1127)) +(let t1482 (OutputJoin t1481 t1066)) +(let t1483 (OutputJoin t1482 t1129)) +(let t1484 (OutputJoin t1483 t1068)) +(let t1485 (OutputJoin t1484 t1131)) +(let t1486 (OutputJoin t1485 t1070)) +(let t1487 (OutputJoin t1486 t1133)) +(let t1488 (OutputJoin t1487 t1072)) +(let t1489 (OutputJoin t1488 t1135)) +(let t1490 (OutputJoin t1489 t1074)) +(let t1491 (OutputJoin t1490 t1137)) +(let t1492 (OutputJoin t1491 t1076)) +(let t1493 (OutputJoin t1492 t1139)) +(let t1494 (OutputJoin t1493 t1078)) +(let t1495 (OutputJoin t1494 t1141)) +(let t1496 (OutputJoin t1495 t1080)) +(let t1497 (OutputJoin t1496 t1143)) +(let t1498 (OutputJoin t1497 t1082)) +(let t1499 (OutputJoin t1498 t1145)) +(let t1500 (OutputJoin t1499 t1084)) +(let t1501 (OutputJoin t1500 t1147)) +(let t1502 (OutputJoin t1501 t1086)) +(let t1503 (OutputJoin t1502 t1149)) +(let t1504 (OutputJoin t1503 t1088)) +(let t1505 (OutputJoin t1504 t1151)) +(let t1506 (OutputJoin t1505 t1090)) +(let t1507 (OutputJoin t1506 t1153)) +(let t1508 (OutputJoin t1507 t1092)) +(let t1509 (OutputJoin t1508 t1155)) +(let t1510 (OutputJoin t1509 t1094)) +(let t1511 (OutputJoin t1510 t1157)) +(let t1512 (OutputJoin t1511 t1030)) +(let t1513 (OutputJoin t1512 t1031)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/qwen.egg b/tests/qwen.egg new file mode 100644 index 00000000..0d33b035 --- /dev/null +++ b/tests/qwen.egg @@ -0,0 +1,2080 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "token_ids" (Int))) +(let t2 (Input 2 "kv_cache.0.k" (F32))) +(let t3 (Output t2 2)) +(let t4 (Input 4 "kv_cache.0.v" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.1.k" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.2.k" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.v" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.3.k" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.v" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.4.k" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "kv_cache.4.v" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "kv_cache.5.k" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "kv_cache.5.v" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "kv_cache.6.k" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "kv_cache.6.v" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "kv_cache.7.k" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "kv_cache.7.v" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "kv_cache.8.k" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "kv_cache.8.v" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "kv_cache.9.k" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "kv_cache.9.v" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "kv_cache.10.k" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "kv_cache.10.v" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "kv_cache.11.k" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "kv_cache.11.v" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "kv_cache.12.k" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "kv_cache.12.v" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "kv_cache.13.k" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "kv_cache.13.v" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "kv_cache.14.k" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "kv_cache.14.v" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "kv_cache.15.k" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "kv_cache.15.v" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "kv_cache.16.k" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "kv_cache.16.v" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "kv_cache.17.k" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "kv_cache.17.v" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "kv_cache.18.k" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "kv_cache.18.v" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "kv_cache.19.k" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "kv_cache.19.v" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "kv_cache.20.k" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "kv_cache.20.v" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "kv_cache.21.k" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "kv_cache.21.v" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "kv_cache.22.k" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "kv_cache.22.v" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "kv_cache.23.k" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "kv_cache.23.v" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "kv_cache.24.k" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "kv_cache.24.v" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "kv_cache.25.k" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "kv_cache.25.v" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "kv_cache.26.k" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "kv_cache.26.v" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "kv_cache.27.k" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "kv_cache.27.v" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "kv_cache.28.k" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "kv_cache.28.v" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "kv_cache.29.k" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "kv_cache.29.v" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "kv_cache.30.k" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "kv_cache.30.v" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "kv_cache.31.k" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "kv_cache.31.v" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "kv_cache.32.k" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "kv_cache.32.v" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "kv_cache.33.k" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "kv_cache.33.v" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "kv_cache.34.k" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "kv_cache.34.v" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "kv_cache.35.k" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "kv_cache.35.v" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "model.layers.0.mlp.up_proj.weight" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "model.layers.0.mlp.gate_proj.weight" (F32))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "model.layers.0.mlp.down_proj.weight" (F32))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "model.layers.0.self_attn.q_norm.weight" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "model.layers.0.self_attn.k_norm.weight" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "model.layers.0.input_layernorm.weight" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "model.layers.1.mlp.up_proj.weight" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "model.layers.1.mlp.gate_proj.weight" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "model.layers.1.mlp.down_proj.weight" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "model.layers.1.self_attn.q_norm.weight" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "model.layers.1.self_attn.k_norm.weight" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "model.layers.1.input_layernorm.weight" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "model.layers.2.mlp.up_proj.weight" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "model.layers.2.mlp.gate_proj.weight" (F32))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.layers.2.mlp.down_proj.weight" (F32))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.layers.2.self_attn.q_norm.weight" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.layers.2.self_attn.k_norm.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.layers.2.input_layernorm.weight" (F32))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.layers.3.mlp.up_proj.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.layers.3.mlp.gate_proj.weight" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.layers.3.mlp.down_proj.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.layers.3.self_attn.q_norm.weight" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.layers.3.self_attn.k_norm.weight" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.layers.3.input_layernorm.weight" (F32))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.layers.4.mlp.up_proj.weight" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.layers.4.mlp.gate_proj.weight" (F32))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.layers.4.mlp.down_proj.weight" (F32))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.layers.4.self_attn.q_norm.weight" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.layers.4.self_attn.k_norm.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.layers.4.input_layernorm.weight" (F32))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.layers.5.mlp.up_proj.weight" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.layers.5.mlp.gate_proj.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.layers.5.mlp.down_proj.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.layers.5.self_attn.v_proj.weight" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.layers.5.self_attn.q_norm.weight" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.layers.5.self_attn.k_norm.weight" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.layers.5.input_layernorm.weight" (F32))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.layers.6.mlp.up_proj.weight" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.layers.6.mlp.gate_proj.weight" (F32))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.layers.6.mlp.down_proj.weight" (F32))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.layers.6.self_attn.q_norm.weight" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.layers.6.self_attn.k_norm.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.layers.6.input_layernorm.weight" (F32))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.layers.7.mlp.up_proj.weight" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.layers.7.mlp.gate_proj.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.layers.7.mlp.down_proj.weight" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.layers.7.self_attn.q_norm.weight" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.layers.7.self_attn.k_norm.weight" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.layers.7.input_layernorm.weight" (F32))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.layers.8.mlp.up_proj.weight" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.layers.8.mlp.gate_proj.weight" (F32))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.layers.8.mlp.down_proj.weight" (F32))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.layers.8.self_attn.q_norm.weight" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.layers.8.self_attn.k_norm.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.layers.8.input_layernorm.weight" (F32))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.layers.9.mlp.up_proj.weight" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.layers.9.mlp.gate_proj.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.layers.9.mlp.down_proj.weight" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t353 (Output t352 352)) +(let t354 (Input 354 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t355 (Output t354 354)) +(let t356 (Input 356 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t357 (Output t356 356)) +(let t358 (Input 358 "model.layers.9.self_attn.q_norm.weight" (F32))) +(let t359 (Output t358 358)) +(let t360 (Input 360 "model.layers.9.self_attn.k_norm.weight" (F32))) +(let t361 (Output t360 360)) +(let t362 (Input 362 "model.layers.9.input_layernorm.weight" (F32))) +(let t363 (Output t362 362)) +(let t364 (Input 364 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t365 (Output t364 364)) +(let t366 (Input 366 "model.layers.10.mlp.up_proj.weight" (F32))) +(let t367 (Output t366 366)) +(let t368 (Input 368 "model.layers.10.mlp.gate_proj.weight" (F32))) +(let t369 (Output t368 368)) +(let t370 (Input 370 "model.layers.10.mlp.down_proj.weight" (F32))) +(let t371 (Output t370 370)) +(let t372 (Input 372 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t373 (Output t372 372)) +(let t374 (Input 374 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t375 (Output t374 374)) +(let t376 (Input 376 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t377 (Output t376 376)) +(let t378 (Input 378 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t379 (Output t378 378)) +(let t380 (Input 380 "model.layers.10.self_attn.q_norm.weight" (F32))) +(let t381 (Output t380 380)) +(let t382 (Input 382 "model.layers.10.self_attn.k_norm.weight" (F32))) +(let t383 (Output t382 382)) +(let t384 (Input 384 "model.layers.10.input_layernorm.weight" (F32))) +(let t385 (Output t384 384)) +(let t386 (Input 386 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t387 (Output t386 386)) +(let t388 (Input 388 "model.layers.11.mlp.up_proj.weight" (F32))) +(let t389 (Output t388 388)) +(let t390 (Input 390 "model.layers.11.mlp.gate_proj.weight" (F32))) +(let t391 (Output t390 390)) +(let t392 (Input 392 "model.layers.11.mlp.down_proj.weight" (F32))) +(let t393 (Output t392 392)) +(let t394 (Input 394 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t395 (Output t394 394)) +(let t396 (Input 396 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t397 (Output t396 396)) +(let t398 (Input 398 "model.layers.11.self_attn.v_proj.weight" (F32))) +(let t399 (Output t398 398)) +(let t400 (Input 400 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t401 (Output t400 400)) +(let t402 (Input 402 "model.layers.11.self_attn.q_norm.weight" (F32))) +(let t403 (Output t402 402)) +(let t404 (Input 404 "model.layers.11.self_attn.k_norm.weight" (F32))) +(let t405 (Output t404 404)) +(let t406 (Input 406 "model.layers.11.input_layernorm.weight" (F32))) +(let t407 (Output t406 406)) +(let t408 (Input 408 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t409 (Output t408 408)) +(let t410 (Input 410 "model.layers.12.mlp.up_proj.weight" (F32))) +(let t411 (Output t410 410)) +(let t412 (Input 412 "model.layers.12.mlp.gate_proj.weight" (F32))) +(let t413 (Output t412 412)) +(let t414 (Input 414 "model.layers.12.mlp.down_proj.weight" (F32))) +(let t415 (Output t414 414)) +(let t416 (Input 416 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t417 (Output t416 416)) +(let t418 (Input 418 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t419 (Output t418 418)) +(let t420 (Input 420 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t421 (Output t420 420)) +(let t422 (Input 422 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t423 (Output t422 422)) +(let t424 (Input 424 "model.layers.12.self_attn.q_norm.weight" (F32))) +(let t425 (Output t424 424)) +(let t426 (Input 426 "model.layers.12.self_attn.k_norm.weight" (F32))) +(let t427 (Output t426 426)) +(let t428 (Input 428 "model.layers.12.input_layernorm.weight" (F32))) +(let t429 (Output t428 428)) +(let t430 (Input 430 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t431 (Output t430 430)) +(let t432 (Input 432 "model.layers.13.mlp.up_proj.weight" (F32))) +(let t433 (Output t432 432)) +(let t434 (Input 434 "model.layers.13.mlp.gate_proj.weight" (F32))) +(let t435 (Output t434 434)) +(let t436 (Input 436 "model.layers.13.mlp.down_proj.weight" (F32))) +(let t437 (Output t436 436)) +(let t438 (Input 438 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t439 (Output t438 438)) +(let t440 (Input 440 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t441 (Output t440 440)) +(let t442 (Input 442 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t443 (Output t442 442)) +(let t444 (Input 444 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t445 (Output t444 444)) +(let t446 (Input 446 "model.layers.13.self_attn.q_norm.weight" (F32))) +(let t447 (Output t446 446)) +(let t448 (Input 448 "model.layers.13.self_attn.k_norm.weight" (F32))) +(let t449 (Output t448 448)) +(let t450 (Input 450 "model.layers.13.input_layernorm.weight" (F32))) +(let t451 (Output t450 450)) +(let t452 (Input 452 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t453 (Output t452 452)) +(let t454 (Input 454 "model.layers.14.mlp.up_proj.weight" (F32))) +(let t455 (Output t454 454)) +(let t456 (Input 456 "model.layers.14.mlp.gate_proj.weight" (F32))) +(let t457 (Output t456 456)) +(let t458 (Input 458 "model.layers.14.mlp.down_proj.weight" (F32))) +(let t459 (Output t458 458)) +(let t460 (Input 460 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t461 (Output t460 460)) +(let t462 (Input 462 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t463 (Output t462 462)) +(let t464 (Input 464 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t465 (Output t464 464)) +(let t466 (Input 466 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t467 (Output t466 466)) +(let t468 (Input 468 "model.layers.14.self_attn.q_norm.weight" (F32))) +(let t469 (Output t468 468)) +(let t470 (Input 470 "model.layers.14.self_attn.k_norm.weight" (F32))) +(let t471 (Output t470 470)) +(let t472 (Input 472 "model.layers.14.input_layernorm.weight" (F32))) +(let t473 (Output t472 472)) +(let t474 (Input 474 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t475 (Output t474 474)) +(let t476 (Input 476 "model.layers.15.mlp.up_proj.weight" (F32))) +(let t477 (Output t476 476)) +(let t478 (Input 478 "model.layers.15.mlp.gate_proj.weight" (F32))) +(let t479 (Output t478 478)) +(let t480 (Input 480 "model.layers.15.mlp.down_proj.weight" (F32))) +(let t481 (Output t480 480)) +(let t482 (Input 482 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t483 (Output t482 482)) +(let t484 (Input 484 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t485 (Output t484 484)) +(let t486 (Input 486 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t487 (Output t486 486)) +(let t488 (Input 488 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t489 (Output t488 488)) +(let t490 (Input 490 "model.layers.15.self_attn.q_norm.weight" (F32))) +(let t491 (Output t490 490)) +(let t492 (Input 492 "model.layers.15.self_attn.k_norm.weight" (F32))) +(let t493 (Output t492 492)) +(let t494 (Input 494 "model.layers.15.input_layernorm.weight" (F32))) +(let t495 (Output t494 494)) +(let t496 (Input 496 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t497 (Output t496 496)) +(let t498 (Input 498 "model.layers.16.mlp.up_proj.weight" (F32))) +(let t499 (Output t498 498)) +(let t500 (Input 500 "model.layers.16.mlp.gate_proj.weight" (F32))) +(let t501 (Output t500 500)) +(let t502 (Input 502 "model.layers.16.mlp.down_proj.weight" (F32))) +(let t503 (Output t502 502)) +(let t504 (Input 504 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t505 (Output t504 504)) +(let t506 (Input 506 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t507 (Output t506 506)) +(let t508 (Input 508 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t509 (Output t508 508)) +(let t510 (Input 510 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t511 (Output t510 510)) +(let t512 (Input 512 "model.layers.16.self_attn.q_norm.weight" (F32))) +(let t513 (Output t512 512)) +(let t514 (Input 514 "model.layers.16.self_attn.k_norm.weight" (F32))) +(let t515 (Output t514 514)) +(let t516 (Input 516 "model.layers.16.input_layernorm.weight" (F32))) +(let t517 (Output t516 516)) +(let t518 (Input 518 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t519 (Output t518 518)) +(let t520 (Input 520 "model.layers.17.mlp.up_proj.weight" (F32))) +(let t521 (Output t520 520)) +(let t522 (Input 522 "model.layers.17.mlp.gate_proj.weight" (F32))) +(let t523 (Output t522 522)) +(let t524 (Input 524 "model.layers.17.mlp.down_proj.weight" (F32))) +(let t525 (Output t524 524)) +(let t526 (Input 526 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t527 (Output t526 526)) +(let t528 (Input 528 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t529 (Output t528 528)) +(let t530 (Input 530 "model.layers.17.self_attn.v_proj.weight" (F32))) +(let t531 (Output t530 530)) +(let t532 (Input 532 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t533 (Output t532 532)) +(let t534 (Input 534 "model.layers.17.self_attn.q_norm.weight" (F32))) +(let t535 (Output t534 534)) +(let t536 (Input 536 "model.layers.17.self_attn.k_norm.weight" (F32))) +(let t537 (Output t536 536)) +(let t538 (Input 538 "model.layers.17.input_layernorm.weight" (F32))) +(let t539 (Output t538 538)) +(let t540 (Input 540 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t541 (Output t540 540)) +(let t542 (Input 542 "model.layers.18.mlp.up_proj.weight" (F32))) +(let t543 (Output t542 542)) +(let t544 (Input 544 "model.layers.18.mlp.gate_proj.weight" (F32))) +(let t545 (Output t544 544)) +(let t546 (Input 546 "model.layers.18.mlp.down_proj.weight" (F32))) +(let t547 (Output t546 546)) +(let t548 (Input 548 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t549 (Output t548 548)) +(let t550 (Input 550 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t551 (Output t550 550)) +(let t552 (Input 552 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t553 (Output t552 552)) +(let t554 (Input 554 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t555 (Output t554 554)) +(let t556 (Input 556 "model.layers.18.self_attn.q_norm.weight" (F32))) +(let t557 (Output t556 556)) +(let t558 (Input 558 "model.layers.18.self_attn.k_norm.weight" (F32))) +(let t559 (Output t558 558)) +(let t560 (Input 560 "model.layers.18.input_layernorm.weight" (F32))) +(let t561 (Output t560 560)) +(let t562 (Input 562 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t563 (Output t562 562)) +(let t564 (Input 564 "model.layers.19.mlp.up_proj.weight" (F32))) +(let t565 (Output t564 564)) +(let t566 (Input 566 "model.layers.19.mlp.gate_proj.weight" (F32))) +(let t567 (Output t566 566)) +(let t568 (Input 568 "model.layers.19.mlp.down_proj.weight" (F32))) +(let t569 (Output t568 568)) +(let t570 (Input 570 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t571 (Output t570 570)) +(let t572 (Input 572 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t573 (Output t572 572)) +(let t574 (Input 574 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t575 (Output t574 574)) +(let t576 (Input 576 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t577 (Output t576 576)) +(let t578 (Input 578 "model.layers.19.self_attn.q_norm.weight" (F32))) +(let t579 (Output t578 578)) +(let t580 (Input 580 "model.layers.19.self_attn.k_norm.weight" (F32))) +(let t581 (Output t580 580)) +(let t582 (Input 582 "model.layers.19.input_layernorm.weight" (F32))) +(let t583 (Output t582 582)) +(let t584 (Input 584 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t585 (Output t584 584)) +(let t586 (Input 586 "model.layers.20.mlp.up_proj.weight" (F32))) +(let t587 (Output t586 586)) +(let t588 (Input 588 "model.layers.20.mlp.gate_proj.weight" (F32))) +(let t589 (Output t588 588)) +(let t590 (Input 590 "model.layers.20.mlp.down_proj.weight" (F32))) +(let t591 (Output t590 590)) +(let t592 (Input 592 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t593 (Output t592 592)) +(let t594 (Input 594 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t595 (Output t594 594)) +(let t596 (Input 596 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t597 (Output t596 596)) +(let t598 (Input 598 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t599 (Output t598 598)) +(let t600 (Input 600 "model.layers.20.self_attn.q_norm.weight" (F32))) +(let t601 (Output t600 600)) +(let t602 (Input 602 "model.layers.20.self_attn.k_norm.weight" (F32))) +(let t603 (Output t602 602)) +(let t604 (Input 604 "model.layers.20.input_layernorm.weight" (F32))) +(let t605 (Output t604 604)) +(let t606 (Input 606 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t607 (Output t606 606)) +(let t608 (Input 608 "model.layers.21.mlp.up_proj.weight" (F32))) +(let t609 (Output t608 608)) +(let t610 (Input 610 "model.layers.21.mlp.gate_proj.weight" (F32))) +(let t611 (Output t610 610)) +(let t612 (Input 612 "model.layers.21.mlp.down_proj.weight" (F32))) +(let t613 (Output t612 612)) +(let t614 (Input 614 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t615 (Output t614 614)) +(let t616 (Input 616 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t617 (Output t616 616)) +(let t618 (Input 618 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t619 (Output t618 618)) +(let t620 (Input 620 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t621 (Output t620 620)) +(let t622 (Input 622 "model.layers.21.self_attn.q_norm.weight" (F32))) +(let t623 (Output t622 622)) +(let t624 (Input 624 "model.layers.21.self_attn.k_norm.weight" (F32))) +(let t625 (Output t624 624)) +(let t626 (Input 626 "model.layers.21.input_layernorm.weight" (F32))) +(let t627 (Output t626 626)) +(let t628 (Input 628 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t629 (Output t628 628)) +(let t630 (Input 630 "model.layers.22.mlp.up_proj.weight" (F32))) +(let t631 (Output t630 630)) +(let t632 (Input 632 "model.layers.22.mlp.gate_proj.weight" (F32))) +(let t633 (Output t632 632)) +(let t634 (Input 634 "model.layers.22.mlp.down_proj.weight" (F32))) +(let t635 (Output t634 634)) +(let t636 (Input 636 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t637 (Output t636 636)) +(let t638 (Input 638 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t639 (Output t638 638)) +(let t640 (Input 640 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t641 (Output t640 640)) +(let t642 (Input 642 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t643 (Output t642 642)) +(let t644 (Input 644 "model.layers.22.self_attn.q_norm.weight" (F32))) +(let t645 (Output t644 644)) +(let t646 (Input 646 "model.layers.22.self_attn.k_norm.weight" (F32))) +(let t647 (Output t646 646)) +(let t648 (Input 648 "model.layers.22.input_layernorm.weight" (F32))) +(let t649 (Output t648 648)) +(let t650 (Input 650 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t651 (Output t650 650)) +(let t652 (Input 652 "model.layers.23.mlp.up_proj.weight" (F32))) +(let t653 (Output t652 652)) +(let t654 (Input 654 "model.layers.23.mlp.gate_proj.weight" (F32))) +(let t655 (Output t654 654)) +(let t656 (Input 656 "model.layers.23.mlp.down_proj.weight" (F32))) +(let t657 (Output t656 656)) +(let t658 (Input 658 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t659 (Output t658 658)) +(let t660 (Input 660 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t661 (Output t660 660)) +(let t662 (Input 662 "model.layers.23.self_attn.v_proj.weight" (F32))) +(let t663 (Output t662 662)) +(let t664 (Input 664 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t665 (Output t664 664)) +(let t666 (Input 666 "model.layers.23.self_attn.q_norm.weight" (F32))) +(let t667 (Output t666 666)) +(let t668 (Input 668 "model.layers.23.self_attn.k_norm.weight" (F32))) +(let t669 (Output t668 668)) +(let t670 (Input 670 "model.layers.23.input_layernorm.weight" (F32))) +(let t671 (Output t670 670)) +(let t672 (Input 672 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t673 (Output t672 672)) +(let t674 (Input 674 "model.layers.24.mlp.up_proj.weight" (F32))) +(let t675 (Output t674 674)) +(let t676 (Input 676 "model.layers.24.mlp.gate_proj.weight" (F32))) +(let t677 (Output t676 676)) +(let t678 (Input 678 "model.layers.24.mlp.down_proj.weight" (F32))) +(let t679 (Output t678 678)) +(let t680 (Input 680 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t681 (Output t680 680)) +(let t682 (Input 682 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t683 (Output t682 682)) +(let t684 (Input 684 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t685 (Output t684 684)) +(let t686 (Input 686 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t687 (Output t686 686)) +(let t688 (Input 688 "model.layers.24.self_attn.q_norm.weight" (F32))) +(let t689 (Output t688 688)) +(let t690 (Input 690 "model.layers.24.self_attn.k_norm.weight" (F32))) +(let t691 (Output t690 690)) +(let t692 (Input 692 "model.layers.24.input_layernorm.weight" (F32))) +(let t693 (Output t692 692)) +(let t694 (Input 694 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t695 (Output t694 694)) +(let t696 (Input 696 "model.layers.25.mlp.up_proj.weight" (F32))) +(let t697 (Output t696 696)) +(let t698 (Input 698 "model.layers.25.mlp.gate_proj.weight" (F32))) +(let t699 (Output t698 698)) +(let t700 (Input 700 "model.layers.25.mlp.down_proj.weight" (F32))) +(let t701 (Output t700 700)) +(let t702 (Input 702 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t703 (Output t702 702)) +(let t704 (Input 704 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t705 (Output t704 704)) +(let t706 (Input 706 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t707 (Output t706 706)) +(let t708 (Input 708 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t709 (Output t708 708)) +(let t710 (Input 710 "model.layers.25.self_attn.q_norm.weight" (F32))) +(let t711 (Output t710 710)) +(let t712 (Input 712 "model.layers.25.self_attn.k_norm.weight" (F32))) +(let t713 (Output t712 712)) +(let t714 (Input 714 "model.layers.25.input_layernorm.weight" (F32))) +(let t715 (Output t714 714)) +(let t716 (Input 716 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t717 (Output t716 716)) +(let t718 (Input 718 "model.layers.26.mlp.up_proj.weight" (F32))) +(let t719 (Output t718 718)) +(let t720 (Input 720 "model.layers.26.mlp.gate_proj.weight" (F32))) +(let t721 (Output t720 720)) +(let t722 (Input 722 "model.layers.26.mlp.down_proj.weight" (F32))) +(let t723 (Output t722 722)) +(let t724 (Input 724 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t725 (Output t724 724)) +(let t726 (Input 726 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t727 (Output t726 726)) +(let t728 (Input 728 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t729 (Output t728 728)) +(let t730 (Input 730 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t731 (Output t730 730)) +(let t732 (Input 732 "model.layers.26.self_attn.q_norm.weight" (F32))) +(let t733 (Output t732 732)) +(let t734 (Input 734 "model.layers.26.self_attn.k_norm.weight" (F32))) +(let t735 (Output t734 734)) +(let t736 (Input 736 "model.layers.26.input_layernorm.weight" (F32))) +(let t737 (Output t736 736)) +(let t738 (Input 738 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t739 (Output t738 738)) +(let t740 (Input 740 "model.layers.27.mlp.up_proj.weight" (F32))) +(let t741 (Output t740 740)) +(let t742 (Input 742 "model.layers.27.mlp.gate_proj.weight" (F32))) +(let t743 (Output t742 742)) +(let t744 (Input 744 "model.layers.27.mlp.down_proj.weight" (F32))) +(let t745 (Output t744 744)) +(let t746 (Input 746 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t747 (Output t746 746)) +(let t748 (Input 748 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t749 (Output t748 748)) +(let t750 (Input 750 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t751 (Output t750 750)) +(let t752 (Input 752 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t753 (Output t752 752)) +(let t754 (Input 754 "model.layers.27.self_attn.q_norm.weight" (F32))) +(let t755 (Output t754 754)) +(let t756 (Input 756 "model.layers.27.self_attn.k_norm.weight" (F32))) +(let t757 (Output t756 756)) +(let t758 (Input 758 "model.layers.27.input_layernorm.weight" (F32))) +(let t759 (Output t758 758)) +(let t760 (Input 760 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t761 (Output t760 760)) +(let t762 (Input 762 "model.layers.28.mlp.up_proj.weight" (F32))) +(let t763 (Output t762 762)) +(let t764 (Input 764 "model.layers.28.mlp.gate_proj.weight" (F32))) +(let t765 (Output t764 764)) +(let t766 (Input 766 "model.layers.28.mlp.down_proj.weight" (F32))) +(let t767 (Output t766 766)) +(let t768 (Input 768 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t769 (Output t768 768)) +(let t770 (Input 770 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t771 (Output t770 770)) +(let t772 (Input 772 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t773 (Output t772 772)) +(let t774 (Input 774 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t775 (Output t774 774)) +(let t776 (Input 776 "model.layers.28.self_attn.q_norm.weight" (F32))) +(let t777 (Output t776 776)) +(let t778 (Input 778 "model.layers.28.self_attn.k_norm.weight" (F32))) +(let t779 (Output t778 778)) +(let t780 (Input 780 "model.layers.28.input_layernorm.weight" (F32))) +(let t781 (Output t780 780)) +(let t782 (Input 782 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t783 (Output t782 782)) +(let t784 (Input 784 "model.layers.29.mlp.up_proj.weight" (F32))) +(let t785 (Output t784 784)) +(let t786 (Input 786 "model.layers.29.mlp.gate_proj.weight" (F32))) +(let t787 (Output t786 786)) +(let t788 (Input 788 "model.layers.29.mlp.down_proj.weight" (F32))) +(let t789 (Output t788 788)) +(let t790 (Input 790 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t791 (Output t790 790)) +(let t792 (Input 792 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t793 (Output t792 792)) +(let t794 (Input 794 "model.layers.29.self_attn.v_proj.weight" (F32))) +(let t795 (Output t794 794)) +(let t796 (Input 796 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t797 (Output t796 796)) +(let t798 (Input 798 "model.layers.29.self_attn.q_norm.weight" (F32))) +(let t799 (Output t798 798)) +(let t800 (Input 800 "model.layers.29.self_attn.k_norm.weight" (F32))) +(let t801 (Output t800 800)) +(let t802 (Input 802 "model.layers.29.input_layernorm.weight" (F32))) +(let t803 (Output t802 802)) +(let t804 (Input 804 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t805 (Output t804 804)) +(let t806 (Input 806 "model.layers.30.mlp.up_proj.weight" (F32))) +(let t807 (Output t806 806)) +(let t808 (Input 808 "model.layers.30.mlp.gate_proj.weight" (F32))) +(let t809 (Output t808 808)) +(let t810 (Input 810 "model.layers.30.mlp.down_proj.weight" (F32))) +(let t811 (Output t810 810)) +(let t812 (Input 812 "model.layers.30.self_attn.q_proj.weight" (F32))) +(let t813 (Output t812 812)) +(let t814 (Input 814 "model.layers.30.self_attn.k_proj.weight" (F32))) +(let t815 (Output t814 814)) +(let t816 (Input 816 "model.layers.30.self_attn.v_proj.weight" (F32))) +(let t817 (Output t816 816)) +(let t818 (Input 818 "model.layers.30.self_attn.o_proj.weight" (F32))) +(let t819 (Output t818 818)) +(let t820 (Input 820 "model.layers.30.self_attn.q_norm.weight" (F32))) +(let t821 (Output t820 820)) +(let t822 (Input 822 "model.layers.30.self_attn.k_norm.weight" (F32))) +(let t823 (Output t822 822)) +(let t824 (Input 824 "model.layers.30.input_layernorm.weight" (F32))) +(let t825 (Output t824 824)) +(let t826 (Input 826 "model.layers.30.post_attention_layernorm.weight" (F32))) +(let t827 (Output t826 826)) +(let t828 (Input 828 "model.layers.31.mlp.up_proj.weight" (F32))) +(let t829 (Output t828 828)) +(let t830 (Input 830 "model.layers.31.mlp.gate_proj.weight" (F32))) +(let t831 (Output t830 830)) +(let t832 (Input 832 "model.layers.31.mlp.down_proj.weight" (F32))) +(let t833 (Output t832 832)) +(let t834 (Input 834 "model.layers.31.self_attn.q_proj.weight" (F32))) +(let t835 (Output t834 834)) +(let t836 (Input 836 "model.layers.31.self_attn.k_proj.weight" (F32))) +(let t837 (Output t836 836)) +(let t838 (Input 838 "model.layers.31.self_attn.v_proj.weight" (F32))) +(let t839 (Output t838 838)) +(let t840 (Input 840 "model.layers.31.self_attn.o_proj.weight" (F32))) +(let t841 (Output t840 840)) +(let t842 (Input 842 "model.layers.31.self_attn.q_norm.weight" (F32))) +(let t843 (Output t842 842)) +(let t844 (Input 844 "model.layers.31.self_attn.k_norm.weight" (F32))) +(let t845 (Output t844 844)) +(let t846 (Input 846 "model.layers.31.input_layernorm.weight" (F32))) +(let t847 (Output t846 846)) +(let t848 (Input 848 "model.layers.31.post_attention_layernorm.weight" (F32))) +(let t849 (Output t848 848)) +(let t850 (Input 850 "model.layers.32.mlp.up_proj.weight" (F32))) +(let t851 (Output t850 850)) +(let t852 (Input 852 "model.layers.32.mlp.gate_proj.weight" (F32))) +(let t853 (Output t852 852)) +(let t854 (Input 854 "model.layers.32.mlp.down_proj.weight" (F32))) +(let t855 (Output t854 854)) +(let t856 (Input 856 "model.layers.32.self_attn.q_proj.weight" (F32))) +(let t857 (Output t856 856)) +(let t858 (Input 858 "model.layers.32.self_attn.k_proj.weight" (F32))) +(let t859 (Output t858 858)) +(let t860 (Input 860 "model.layers.32.self_attn.v_proj.weight" (F32))) +(let t861 (Output t860 860)) +(let t862 (Input 862 "model.layers.32.self_attn.o_proj.weight" (F32))) +(let t863 (Output t862 862)) +(let t864 (Input 864 "model.layers.32.self_attn.q_norm.weight" (F32))) +(let t865 (Output t864 864)) +(let t866 (Input 866 "model.layers.32.self_attn.k_norm.weight" (F32))) +(let t867 (Output t866 866)) +(let t868 (Input 868 "model.layers.32.input_layernorm.weight" (F32))) +(let t869 (Output t868 868)) +(let t870 (Input 870 "model.layers.32.post_attention_layernorm.weight" (F32))) +(let t871 (Output t870 870)) +(let t872 (Input 872 "model.layers.33.mlp.up_proj.weight" (F32))) +(let t873 (Output t872 872)) +(let t874 (Input 874 "model.layers.33.mlp.gate_proj.weight" (F32))) +(let t875 (Output t874 874)) +(let t876 (Input 876 "model.layers.33.mlp.down_proj.weight" (F32))) +(let t877 (Output t876 876)) +(let t878 (Input 878 "model.layers.33.self_attn.q_proj.weight" (F32))) +(let t879 (Output t878 878)) +(let t880 (Input 880 "model.layers.33.self_attn.k_proj.weight" (F32))) +(let t881 (Output t880 880)) +(let t882 (Input 882 "model.layers.33.self_attn.v_proj.weight" (F32))) +(let t883 (Output t882 882)) +(let t884 (Input 884 "model.layers.33.self_attn.o_proj.weight" (F32))) +(let t885 (Output t884 884)) +(let t886 (Input 886 "model.layers.33.self_attn.q_norm.weight" (F32))) +(let t887 (Output t886 886)) +(let t888 (Input 888 "model.layers.33.self_attn.k_norm.weight" (F32))) +(let t889 (Output t888 888)) +(let t890 (Input 890 "model.layers.33.input_layernorm.weight" (F32))) +(let t891 (Output t890 890)) +(let t892 (Input 892 "model.layers.33.post_attention_layernorm.weight" (F32))) +(let t893 (Output t892 892)) +(let t894 (Input 894 "model.layers.34.mlp.up_proj.weight" (F32))) +(let t895 (Output t894 894)) +(let t896 (Input 896 "model.layers.34.mlp.gate_proj.weight" (F32))) +(let t897 (Output t896 896)) +(let t898 (Input 898 "model.layers.34.mlp.down_proj.weight" (F32))) +(let t899 (Output t898 898)) +(let t900 (Input 900 "model.layers.34.self_attn.q_proj.weight" (F32))) +(let t901 (Output t900 900)) +(let t902 (Input 902 "model.layers.34.self_attn.k_proj.weight" (F32))) +(let t903 (Output t902 902)) +(let t904 (Input 904 "model.layers.34.self_attn.v_proj.weight" (F32))) +(let t905 (Output t904 904)) +(let t906 (Input 906 "model.layers.34.self_attn.o_proj.weight" (F32))) +(let t907 (Output t906 906)) +(let t908 (Input 908 "model.layers.34.self_attn.q_norm.weight" (F32))) +(let t909 (Output t908 908)) +(let t910 (Input 910 "model.layers.34.self_attn.k_norm.weight" (F32))) +(let t911 (Output t910 910)) +(let t912 (Input 912 "model.layers.34.input_layernorm.weight" (F32))) +(let t913 (Output t912 912)) +(let t914 (Input 914 "model.layers.34.post_attention_layernorm.weight" (F32))) +(let t915 (Output t914 914)) +(let t916 (Input 916 "model.layers.35.mlp.up_proj.weight" (F32))) +(let t917 (Output t916 916)) +(let t918 (Input 918 "model.layers.35.mlp.gate_proj.weight" (F32))) +(let t919 (Output t918 918)) +(let t920 (Input 920 "model.layers.35.mlp.down_proj.weight" (F32))) +(let t921 (Output t920 920)) +(let t922 (Input 922 "model.layers.35.self_attn.q_proj.weight" (F32))) +(let t923 (Output t922 922)) +(let t924 (Input 924 "model.layers.35.self_attn.k_proj.weight" (F32))) +(let t925 (Output t924 924)) +(let t926 (Input 926 "model.layers.35.self_attn.v_proj.weight" (F32))) +(let t927 (Output t926 926)) +(let t928 (Input 928 "model.layers.35.self_attn.o_proj.weight" (F32))) +(let t929 (Output t928 928)) +(let t930 (Input 930 "model.layers.35.self_attn.q_norm.weight" (F32))) +(let t931 (Output t930 930)) +(let t932 (Input 932 "model.layers.35.self_attn.k_norm.weight" (F32))) +(let t933 (Output t932 932)) +(let t934 (Input 934 "model.layers.35.input_layernorm.weight" (F32))) +(let t935 (Output t934 934)) +(let t936 (Input 936 "model.layers.35.post_attention_layernorm.weight" (F32))) +(let t937 (Output t936 936)) +(let t938 (Input 938 "model.norm.weight" (F32))) +(let t939 (Output t938 938)) +(let t940 (Input 940 "model.embed_tokens.weight" (F32))) +(let t941 (Output t940 940)) +(let t942 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t943 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t942 (INil))))) +(let t944 (Op (Iota (MIter) (MNum 2560)) (INil))) +(let t945 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t943 (ICons t944 (INil))))) +(let t946 (Op (Gather (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 151936) (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t945 (ICons t940 (INil))))) +(let t947 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t948 (Op (Cast (MNum 1) (F32)) (ICons t947 (INil)))) +(let t949 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t948 (INil)))) +(let t950 (Op (Constant 0.000001) (INil))) +(let t951 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t952 (Op (Cast (MNum 1) (F32)) (ICons t951 (INil)))) +(let t953 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t952 (INil)))) +(let t954 (Op (Constant 0.000001) (INil))) +(let t955 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t956 (Op (Cast (MNum 1) (F32)) (ICons t955 (INil)))) +(let t957 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t956 (INil)))) +(let t958 (Op (Constant 0.000001) (INil))) +(let t959 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t960 (Op (Cast (MNum 64) (F32)) (ICons t959 (INil)))) +(let t961 (Op (Constant 0.007812) (INil))) +(let t962 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t960 (ICons t961 (INil))))) +(let t963 (Op (Constant 13.815511) (INil))) +(let t964 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t962 (ICons t963 (INil))))) +(let t965 (Op (Constant 1.442695) (INil))) +(let t966 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t964 (ICons t965 (INil))))) +(let t967 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t966 (INil)))) +(let t968 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t967 (INil)))) +(let t969 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t970 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t969 (ICons t968 (INil))))) +(let t971 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t970 (INil)))) +(let t972 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t973 (Op (Constant -1.000000) (INil))) +(let t974 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t971 (ICons t973 (INil))))) +(let t975 (Op (Constant 1.570796) (INil))) +(let t976 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t974 (ICons t975 (INil))))) +(let t977 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t976 (INil)))) +(let t978 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t971 (INil)))) +(let t979 (Op (Constant -1.000000) (INil))) +(let t980 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t981 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t982 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t981 (INil)))) +(let t983 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t984 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t985 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t984 (INil)))) +(let t986 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t987 (Op (Cast (MNum 64) (F32)) (ICons t986 (INil)))) +(let t988 (Op (Constant 0.007812) (INil))) +(let t989 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t987 (ICons t988 (INil))))) +(let t990 (Op (Constant 13.815511) (INil))) +(let t991 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t989 (ICons t990 (INil))))) +(let t992 (Op (Constant 1.442695) (INil))) +(let t993 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t991 (ICons t992 (INil))))) +(let t994 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t993 (INil)))) +(let t995 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t994 (INil)))) +(let t996 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t997 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t996 (ICons t995 (INil))))) +(let t998 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t997 (INil)))) +(let t999 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t1000 (Op (Constant -1.000000) (INil))) +(let t1001 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t998 (ICons t1000 (INil))))) +(let t1002 (Op (Constant 1.570796) (INil))) +(let t1003 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1001 (ICons t1002 (INil))))) +(let t1004 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1003 (INil)))) +(let t1005 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t998 (INil)))) +(let t1006 (Op (Constant -1.000000) (INil))) +(let t1007 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1008 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1009 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1008 (INil)))) +(let t1010 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1011 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1012 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1011 (INil)))) +(let t1013 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1014 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t1015 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1013 (ICons t1014 (INil))))) +(let t1016 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1017 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1018 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1016 (ICons t1017 (INil))))) +(let t1019 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1020 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1018 (ICons t1019 (INil))))) +(let t1021 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1022 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1015 (ICons t1020 (INil))))) +(let t1023 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1022 (ICons t1021 (INil))))) +(let t1024 (Op (Constant 0.088388) (INil))) +(let t1025 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1026 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1025 (INil)))) +(let t1027 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1028 (Op (Cast (MNum 1) (F32)) (ICons t1027 (INil)))) +(let t1029 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1026 (ICons t1028 (INil))))) +(let t1030 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1031 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1030 (INil)))) +(let t1032 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1029 (ICons t1031 (INil))))) +(let t1033 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1032 (INil)))) +(let t1034 (Op (Constant -10000000000.000000) (INil))) +(let t1035 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1033 (ICons t1034 (INil))))) +(let t1036 (Op (Constant -1.000000) (INil))) +(let t1037 (Op (Constant 1.442695) (INil))) +(let t1038 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1039 (Op (Cast (MNum 1) (F32)) (ICons t1038 (INil)))) +(let t1040 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1039 (INil)))) +(let t1041 (Op (Constant 0.000001) (INil))) +(let t1042 (Op (Constant -1.000000) (INil))) +(let t1043 (Op (Constant 1.442695) (INil))) +(let t1044 (Op (Constant 1.000000) (INil))) +(let t1045 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1046 (Op (Cast (MNum 1) (F32)) (ICons t1045 (INil)))) +(let t1047 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1046 (INil)))) +(let t1048 (Op (Constant 0.000001) (INil))) +(let t1049 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1050 (Op (Cast (MNum 1) (F32)) (ICons t1049 (INil)))) +(let t1051 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1050 (INil)))) +(let t1052 (Op (Constant 0.000001) (INil))) +(let t1053 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1054 (Op (Cast (MNum 1) (F32)) (ICons t1053 (INil)))) +(let t1055 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1054 (INil)))) +(let t1056 (Op (Constant 0.000001) (INil))) +(let t1057 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1058 (Op (Cast (MNum 64) (F32)) (ICons t1057 (INil)))) +(let t1059 (Op (Constant 0.007812) (INil))) +(let t1060 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1058 (ICons t1059 (INil))))) +(let t1061 (Op (Constant 13.815511) (INil))) +(let t1062 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1060 (ICons t1061 (INil))))) +(let t1063 (Op (Constant 1.442695) (INil))) +(let t1064 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1062 (ICons t1063 (INil))))) +(let t1065 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1064 (INil)))) +(let t1066 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1065 (INil)))) +(let t1067 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1068 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1067 (ICons t1066 (INil))))) +(let t1069 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1068 (INil)))) +(let t1070 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t1071 (Op (Constant -1.000000) (INil))) +(let t1072 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1069 (ICons t1071 (INil))))) +(let t1073 (Op (Constant 1.570796) (INil))) +(let t1074 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1072 (ICons t1073 (INil))))) +(let t1075 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1074 (INil)))) +(let t1076 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1069 (INil)))) +(let t1077 (Op (Constant -1.000000) (INil))) +(let t1078 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1079 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1080 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1079 (INil)))) +(let t1081 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1082 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1083 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1082 (INil)))) +(let t1084 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1085 (Op (Cast (MNum 64) (F32)) (ICons t1084 (INil)))) +(let t1086 (Op (Constant 0.007812) (INil))) +(let t1087 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1085 (ICons t1086 (INil))))) +(let t1088 (Op (Constant 13.815511) (INil))) +(let t1089 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1087 (ICons t1088 (INil))))) +(let t1090 (Op (Constant 1.442695) (INil))) +(let t1091 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1089 (ICons t1090 (INil))))) +(let t1092 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1091 (INil)))) +(let t1093 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1092 (INil)))) +(let t1094 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1095 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1094 (ICons t1093 (INil))))) +(let t1096 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1095 (INil)))) +(let t1097 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 64))) (INil))) +(let t1098 (Op (Constant -1.000000) (INil))) +(let t1099 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1096 (ICons t1098 (INil))))) +(let t1100 (Op (Constant 1.570796) (INil))) +(let t1101 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1099 (ICons t1100 (INil))))) +(let t1102 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1101 (INil)))) +(let t1103 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1096 (INil)))) +(let t1104 (Op (Constant -1.000000) (INil))) +(let t1105 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1106 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1107 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1106 (INil)))) +(let t1108 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1109 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 8) (MVar "s")) (MNum 128))) (INil))) +(let t1110 (Op (Cast (MMax (MMul (MMul (MNum 8) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1109 (INil)))) +(let t1111 (Op (Iota (MIter) (MNum 8)) (INil))) +(let t1112 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t1113 (Op (Mul (ECons (MNum 8) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1111 (ICons t1112 (INil))))) +(let t1114 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1115 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1116 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1114 (ICons t1115 (INil))))) +(let t1117 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1118 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1116 (ICons t1117 (INil))))) +(let t1119 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1120 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1113 (ICons t1118 (INil))))) +(let t1121 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1120 (ICons t1119 (INil))))) +(let t1122 (Op (Constant 0.088388) (INil))) +(let t1123 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1124 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1123 (INil)))) +(let t1125 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1126 (Op (Cast (MNum 1) (F32)) (ICons t1125 (INil)))) +(let t1127 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1124 (ICons t1126 (INil))))) +(let t1128 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1129 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1128 (INil)))) +(let t1130 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1127 (ICons t1129 (INil))))) +(let t1131 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1130 (INil)))) +(let t1132 (Op (Constant -10000000000.000000) (INil))) +(let t1133 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1131 (ICons t1132 (INil))))) +(let t1134 (Op (Constant -1.000000) (INil))) +(let t1135 (Op (Constant 1.442695) (INil))) +(let t1136 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1137 (Op (Cast (MNum 1) (F32)) (ICons t1136 (INil)))) +(let t1138 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1137 (INil)))) +(let t1139 (Op (Constant 0.000001) (INil))) +(let t1140 (Op (Constant -1.000000) (INil))) +(let t1141 (Op (Constant 1.442695) (INil))) +(let t1142 (Op (Constant 1.000000) (INil))) +(let t1143 (Op (Iota (MNum 2560) (MNum 1)) (INil))) +(let t1144 (Op (Cast (MNum 1) (F32)) (ICons t1143 (INil)))) +(let t1145 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1144 (INil)))) +(let t1146 (Op (Constant 0.000001) (INil))) +(let t1147 (LoopStart t946 0 0 (MNum 35) (F32))) +(let t1148 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1147 (ICons t1147 (INil))))) +(let t1149 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1148 (INil)))) +(let t1150 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1149 (ICons t949 (INil))))) +(let t1151 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1150 (ICons t950 (INil))))) +(let t1152 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1151 (INil)))) +(let t1153 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1152 (INil)))) +(let t1154 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1153 (ICons t1147 (INil))))) +(let t1155 (Op (LoopInput 0 1 (F32)) (ICons t164 (ICons t186 (ICons t208 (ICons t230 (ICons t252 (ICons t274 (ICons t296 (ICons t318 (ICons t340 (ICons t362 (ICons t384 (ICons t406 (ICons t428 (ICons t450 (ICons t472 (ICons t494 (ICons t516 (ICons t538 (ICons t560 (ICons t582 (ICons t604 (ICons t626 (ICons t648 (ICons t670 (ICons t692 (ICons t714 (ICons t736 (ICons t758 (ICons t780 (ICons t802 (ICons t824 (ICons t846 (ICons t868 (ICons t890 (ICons t912 (INil)))))))))))))))))))))))))))))))))))))) +(let t1156 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1154 (ICons t1155 (INil))))) +(let t1157 (Op (LoopInput 0 2 (F32)) (ICons t152 (ICons t174 (ICons t196 (ICons t218 (ICons t240 (ICons t262 (ICons t284 (ICons t306 (ICons t328 (ICons t350 (ICons t372 (ICons t394 (ICons t416 (ICons t438 (ICons t460 (ICons t482 (ICons t504 (ICons t526 (ICons t548 (ICons t570 (ICons t592 (ICons t614 (ICons t636 (ICons t658 (ICons t680 (ICons t702 (ICons t724 (ICons t746 (ICons t768 (ICons t790 (ICons t812 (ICons t834 (ICons t856 (ICons t878 (ICons t900 (INil)))))))))))))))))))))))))))))))))))))) +(let t1158 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1156 (ICons t1157 (INil))))) +(let t1159 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1158 (INil)))) +(let t1160 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1159 (ICons t1159 (INil))))) +(let t1161 (Op (Sum (ECons (MVar "s") (ECons (MNum 32) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1160 (INil)))) +(let t1162 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1161 (ICons t953 (INil))))) +(let t1163 (Op (Add (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1162 (ICons t954 (INil))))) +(let t1164 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1163 (INil)))) +(let t1165 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1164 (INil)))) +(let t1166 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1165 (ICons t1159 (INil))))) +(let t1167 (Op (LoopInput 0 3 (F32)) (ICons t154 (ICons t176 (ICons t198 (ICons t220 (ICons t242 (ICons t264 (ICons t286 (ICons t308 (ICons t330 (ICons t352 (ICons t374 (ICons t396 (ICons t418 (ICons t440 (ICons t462 (ICons t484 (ICons t506 (ICons t528 (ICons t550 (ICons t572 (ICons t594 (ICons t616 (ICons t638 (ICons t660 (ICons t682 (ICons t704 (ICons t726 (ICons t748 (ICons t770 (ICons t792 (ICons t814 (ICons t836 (ICons t858 (ICons t880 (ICons t902 (INil)))))))))))))))))))))))))))))))))))))) +(let t1168 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1156 (ICons t1167 (INil))))) +(let t1169 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1168 (INil)))) +(let t1170 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1169 (ICons t1169 (INil))))) +(let t1171 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1170 (INil)))) +(let t1172 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1171 (ICons t957 (INil))))) +(let t1173 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1172 (ICons t958 (INil))))) +(let t1174 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1173 (INil)))) +(let t1175 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1174 (INil)))) +(let t1176 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1175 (ICons t1169 (INil))))) +(let t1177 (Op (LoopInput 0 4 (F32)) (ICons t156 (ICons t178 (ICons t200 (ICons t222 (ICons t244 (ICons t266 (ICons t288 (ICons t310 (ICons t332 (ICons t354 (ICons t376 (ICons t398 (ICons t420 (ICons t442 (ICons t464 (ICons t486 (ICons t508 (ICons t530 (ICons t552 (ICons t574 (ICons t596 (ICons t618 (ICons t640 (ICons t662 (ICons t684 (ICons t706 (ICons t728 (ICons t750 (ICons t772 (ICons t794 (ICons t816 (ICons t838 (ICons t860 (ICons t882 (ICons t904 (INil)))))))))))))))))))))))))))))))))))))) +(let t1178 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1156 (ICons t1177 (INil))))) +(let t1179 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1178 (INil)))) +(let t1180 (Op (LoopInput 0 5 (F32)) (ICons t160 (ICons t182 (ICons t204 (ICons t226 (ICons t248 (ICons t270 (ICons t292 (ICons t314 (ICons t336 (ICons t358 (ICons t380 (ICons t402 (ICons t424 (ICons t446 (ICons t468 (ICons t490 (ICons t512 (ICons t534 (ICons t556 (ICons t578 (ICons t600 (ICons t622 (ICons t644 (ICons t666 (ICons t688 (ICons t710 (ICons t732 (ICons t754 (ICons t776 (ICons t798 (ICons t820 (ICons t842 (ICons t864 (ICons t886 (ICons t908 (INil)))))))))))))))))))))))))))))))))))))) +(let t1181 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1166 (ICons t1180 (INil))))) +(let t1182 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil))))) (ICons t972 (ICons t1181 (INil))))) +(let t1183 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1181 (ICons t977 (INil))))) +(let t1184 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1182 (ICons t978 (INil))))) +(let t1185 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1184 (ICons t979 (INil))))) +(let t1186 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1183 (ICons t1185 (INil))))) +(let t1187 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1182 (ICons t977 (INil))))) +(let t1188 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1181 (ICons t978 (INil))))) +(let t1189 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1187 (ICons t1188 (INil))))) +(let t1190 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t980 (ICons t1186 (INil))))) +(let t1191 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1190 (ICons t982 (INil))))) +(let t1192 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t983 (ICons t1189 (INil))))) +(let t1193 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1192 (ICons t985 (INil))))) +(let t1194 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1191 (ICons t1193 (INil))))) +(let t1195 (Op (LoopInput 0 6 (F32)) (ICons t162 (ICons t184 (ICons t206 (ICons t228 (ICons t250 (ICons t272 (ICons t294 (ICons t316 (ICons t338 (ICons t360 (ICons t382 (ICons t404 (ICons t426 (ICons t448 (ICons t470 (ICons t492 (ICons t514 (ICons t536 (ICons t558 (ICons t580 (ICons t602 (ICons t624 (ICons t646 (ICons t668 (ICons t690 (ICons t712 (ICons t734 (ICons t756 (ICons t778 (ICons t800 (ICons t822 (ICons t844 (ICons t866 (ICons t888 (ICons t910 (INil)))))))))))))))))))))))))))))))))))))) +(let t1196 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1176 (ICons t1195 (INil))))) +(let t1197 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t999 (ICons t1196 (INil))))) +(let t1198 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1196 (ICons t1004 (INil))))) +(let t1199 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1197 (ICons t1005 (INil))))) +(let t1200 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1199 (ICons t1006 (INil))))) +(let t1201 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1198 (ICons t1200 (INil))))) +(let t1202 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1197 (ICons t1004 (INil))))) +(let t1203 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1196 (ICons t1005 (INil))))) +(let t1204 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1202 (ICons t1203 (INil))))) +(let t1205 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1007 (ICons t1201 (INil))))) +(let t1206 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1205 (ICons t1009 (INil))))) +(let t1207 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1010 (ICons t1204 (INil))))) +(let t1208 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1207 (ICons t1012 (INil))))) +(let t1209 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1206 (ICons t1208 (INil))))) +(let t1210 (Op (LoopInput 0 8 (F32)) (ICons t2 (ICons t6 (ICons t10 (ICons t14 (ICons t18 (ICons t22 (ICons t26 (ICons t30 (ICons t34 (ICons t38 (ICons t42 (ICons t46 (ICons t50 (ICons t54 (ICons t58 (ICons t62 (ICons t66 (ICons t70 (ICons t74 (ICons t78 (ICons t82 (ICons t86 (ICons t90 (ICons t94 (ICons t98 (ICons t102 (ICons t106 (ICons t110 (ICons t114 (ICons t118 (ICons t122 (ICons t126 (ICons t130 (ICons t134 (ICons t138 (INil)))))))))))))))))))))))))))))))))))))) +(let t1211 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t1210 (ICons t1023 (ICons t1209 (INil)))))) +(let t1212 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t1194 (ICons t1211 (INil))))) +(let t1213 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1212 (INil)))) +(let t1214 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1213 (ICons t1024 (INil))))) +(let t1215 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1214 (ICons t1035 (INil))))) +(let t1216 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1215 (INil)))) +(let t1217 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1216 (ICons t1036 (INil))))) +(let t1218 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1215 (ICons t1217 (INil))))) +(let t1219 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1218 (ICons t1037 (INil))))) +(let t1220 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1219 (INil)))) +(let t1221 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1220 (INil)))) +(let t1222 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1221 (INil)))) +(let t1223 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1220 (ICons t1222 (INil))))) +(let t1224 (Op (LoopInput 0 9 (F32)) (ICons t4 (ICons t8 (ICons t12 (ICons t16 (ICons t20 (ICons t24 (ICons t28 (ICons t32 (ICons t36 (ICons t40 (ICons t44 (ICons t48 (ICons t52 (ICons t56 (ICons t60 (ICons t64 (ICons t68 (ICons t72 (ICons t76 (ICons t80 (ICons t84 (ICons t88 (ICons t92 (ICons t96 (ICons t100 (ICons t104 (ICons t108 (ICons t112 (ICons t116 (ICons t120 (ICons t124 (ICons t128 (ICons t132 (ICons t136 (ICons t140 (INil)))))))))))))))))))))))))))))))))))))) +(let t1225 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t1224 (ICons t1023 (ICons t1179 (INil)))))) +(let t1226 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t1223 (ICons t1225 (INil))))) +(let t1227 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1226 (INil)))) +(let t1228 (Op (LoopInput 0 10 (F32)) (ICons t158 (ICons t180 (ICons t202 (ICons t224 (ICons t246 (ICons t268 (ICons t290 (ICons t312 (ICons t334 (ICons t356 (ICons t378 (ICons t400 (ICons t422 (ICons t444 (ICons t466 (ICons t488 (ICons t510 (ICons t532 (ICons t554 (ICons t576 (ICons t598 (ICons t620 (ICons t642 (ICons t664 (ICons t686 (ICons t708 (ICons t730 (ICons t752 (ICons t774 (ICons t796 (ICons t818 (ICons t840 (ICons t862 (ICons t884 (ICons t906 (INil)))))))))))))))))))))))))))))))))))))) +(let t1229 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2560)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1227 (ICons t1228 (INil))))) +(let t1230 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2560)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1229 (INil)))) +(let t1231 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1147 (ICons t1230 (INil))))) +(let t1232 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1231 (ICons t1231 (INil))))) +(let t1233 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1232 (INil)))) +(let t1234 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1233 (ICons t1040 (INil))))) +(let t1235 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1234 (ICons t1041 (INil))))) +(let t1236 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1235 (INil)))) +(let t1237 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1236 (INil)))) +(let t1238 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1237 (ICons t1231 (INil))))) +(let t1239 (Op (LoopInput 0 11 (F32)) (ICons t166 (ICons t188 (ICons t210 (ICons t232 (ICons t254 (ICons t276 (ICons t298 (ICons t320 (ICons t342 (ICons t364 (ICons t386 (ICons t408 (ICons t430 (ICons t452 (ICons t474 (ICons t496 (ICons t518 (ICons t540 (ICons t562 (ICons t584 (ICons t606 (ICons t628 (ICons t650 (ICons t672 (ICons t694 (ICons t716 (ICons t738 (ICons t760 (ICons t782 (ICons t804 (ICons t826 (ICons t848 (ICons t870 (ICons t892 (ICons t914 (INil)))))))))))))))))))))))))))))))))))))) +(let t1240 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1238 (ICons t1239 (INil))))) +(let t1241 (Op (LoopInput 0 12 (F32)) (ICons t148 (ICons t170 (ICons t192 (ICons t214 (ICons t236 (ICons t258 (ICons t280 (ICons t302 (ICons t324 (ICons t346 (ICons t368 (ICons t390 (ICons t412 (ICons t434 (ICons t456 (ICons t478 (ICons t500 (ICons t522 (ICons t544 (ICons t566 (ICons t588 (ICons t610 (ICons t632 (ICons t654 (ICons t676 (ICons t698 (ICons t720 (ICons t742 (ICons t764 (ICons t786 (ICons t808 (ICons t830 (ICons t852 (ICons t874 (ICons t896 (INil)))))))))))))))))))))))))))))))))))))) +(let t1242 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1240 (ICons t1241 (INil))))) +(let t1243 (Op (Sum (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1242 (INil)))) +(let t1244 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1243 (ICons t1042 (INil))))) +(let t1245 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1244 (ICons t1043 (INil))))) +(let t1246 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1245 (INil)))) +(let t1247 (Op (Add (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1246 (ICons t1044 (INil))))) +(let t1248 (Op (Recip (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1247 (INil)))) +(let t1249 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1243 (ICons t1248 (INil))))) +(let t1250 (Op (LoopInput 0 13 (F32)) (ICons t146 (ICons t168 (ICons t190 (ICons t212 (ICons t234 (ICons t256 (ICons t278 (ICons t300 (ICons t322 (ICons t344 (ICons t366 (ICons t388 (ICons t410 (ICons t432 (ICons t454 (ICons t476 (ICons t498 (ICons t520 (ICons t542 (ICons t564 (ICons t586 (ICons t608 (ICons t630 (ICons t652 (ICons t674 (ICons t696 (ICons t718 (ICons t740 (ICons t762 (ICons t784 (ICons t806 (ICons t828 (ICons t850 (ICons t872 (ICons t894 (INil)))))))))))))))))))))))))))))))))))))) +(let t1251 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1240 (ICons t1250 (INil))))) +(let t1252 (Op (Sum (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1251 (INil)))) +(let t1253 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1249 (ICons t1252 (INil))))) +(let t1254 (Op (LoopInput 0 14 (F32)) (ICons t150 (ICons t172 (ICons t194 (ICons t216 (ICons t238 (ICons t260 (ICons t282 (ICons t304 (ICons t326 (ICons t348 (ICons t370 (ICons t392 (ICons t414 (ICons t436 (ICons t458 (ICons t480 (ICons t502 (ICons t524 (ICons t546 (ICons t568 (ICons t590 (ICons t612 (ICons t634 (ICons t656 (ICons t678 (ICons t700 (ICons t722 (ICons t744 (ICons t766 (ICons t788 (ICons t810 (ICons t832 (ICons t854 (ICons t876 (ICons t898 (INil)))))))))))))))))))))))))))))))))))))) +(let t1255 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 9728) (ENil)))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 9728)) (MNum 2560)) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))))) (ICons t1253 (ICons t1254 (INil))))) +(let t1256 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 9728) (ECons (MMul (MMul (MIter) (MNum 9728)) (MNum 2560)) (ECons (MMul (MIter) (MNum 9728)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1255 (INil)))) +(let t1257 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1231 (ICons t1256 (INil))))) +(let t1258 (LoopEnd t1257 0 0 (F32))) +(let t1259 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1258 (ICons t1258 (INil))))) +(let t1260 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1259 (INil)))) +(let t1261 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1260 (ICons t1047 (INil))))) +(let t1262 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1261 (ICons t1048 (INil))))) +(let t1263 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1262 (INil)))) +(let t1264 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1263 (INil)))) +(let t1265 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1264 (ICons t1258 (INil))))) +(let t1266 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1265 (ICons t934 (INil))))) +(let t1267 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1266 (ICons t922 (INil))))) +(let t1268 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1267 (INil)))) +(let t1269 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1266 (ICons t924 (INil))))) +(let t1270 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1269 (INil)))) +(let t1271 (Op (Mul (ECons (MVar "s") (ECons (MNum 1024) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1266 (ICons t926 (INil))))) +(let t1272 (Op (Sum (ECons (MVar "s") (ECons (MNum 1024) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 1024)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil)))) (ICons t1271 (INil)))) +(let t1273 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1268 (ICons t1268 (INil))))) +(let t1274 (Op (Sum (ECons (MVar "s") (ECons (MNum 32) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1273 (INil)))) +(let t1275 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1274 (ICons t1051 (INil))))) +(let t1276 (Op (Add (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1275 (ICons t1052 (INil))))) +(let t1277 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1276 (INil)))) +(let t1278 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1277 (INil)))) +(let t1279 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1278 (ICons t1268 (INil))))) +(let t1280 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1279 (ICons t930 (INil))))) +(let t1281 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1270 (ICons t1270 (INil))))) +(let t1282 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1281 (INil)))) +(let t1283 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1282 (ICons t1055 (INil))))) +(let t1284 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1283 (ICons t1056 (INil))))) +(let t1285 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1284 (INil)))) +(let t1286 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1285 (INil)))) +(let t1287 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 1024)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1286 (ICons t1270 (INil))))) +(let t1288 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1287 (ICons t932 (INil))))) +(let t1289 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil))))) (ICons t1070 (ICons t1280 (INil))))) +(let t1290 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1280 (ICons t1075 (INil))))) +(let t1291 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1289 (ICons t1076 (INil))))) +(let t1292 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1291 (ICons t1077 (INil))))) +(let t1293 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1290 (ICons t1292 (INil))))) +(let t1294 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1289 (ICons t1075 (INil))))) +(let t1295 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1280 (ICons t1076 (INil))))) +(let t1296 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1294 (ICons t1295 (INil))))) +(let t1297 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1078 (ICons t1293 (INil))))) +(let t1298 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1297 (ICons t1080 (INil))))) +(let t1299 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1081 (ICons t1296 (INil))))) +(let t1300 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1299 (ICons t1083 (INil))))) +(let t1301 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1298 (ICons t1300 (INil))))) +(let t1302 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil))))) (ICons t1097 (ICons t1288 (INil))))) +(let t1303 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1288 (ICons t1102 (INil))))) +(let t1304 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1302 (ICons t1103 (INil))))) +(let t1305 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1304 (ICons t1104 (INil))))) +(let t1306 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1303 (ICons t1305 (INil))))) +(let t1307 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1302 (ICons t1102 (INil))))) +(let t1308 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 8)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1288 (ICons t1103 (INil))))) +(let t1309 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1307 (ICons t1308 (INil))))) +(let t1310 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1105 (ICons t1306 (INil))))) +(let t1311 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1310 (ICons t1107 (INil))))) +(let t1312 (Op (Gather (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1108 (ICons t1309 (INil))))) +(let t1313 (Op (Mul (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1312 (ICons t1110 (INil))))) +(let t1314 (Op (Add (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1311 (ICons t1313 (INil))))) +(let t1315 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t142 (ICons t1121 (ICons t1314 (INil)))))) +(let t1316 (Op (Scatter (ECons (MNum 8) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 8) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 1024)) (ECons (MIter) (ENil))))) (ICons t144 (ICons t1121 (ICons t1272 (INil)))))) +(let t1317 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t1301 (ICons t1315 (INil))))) +(let t1318 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1317 (INil)))) +(let t1319 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1318 (ICons t1122 (INil))))) +(let t1320 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1319 (ICons t1133 (INil))))) +(let t1321 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1320 (INil)))) +(let t1322 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1321 (ICons t1134 (INil))))) +(let t1323 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1320 (ICons t1322 (INil))))) +(let t1324 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1323 (ICons t1135 (INil))))) +(let t1325 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1324 (INil)))) +(let t1326 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1325 (INil)))) +(let t1327 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1326 (INil)))) +(let t1328 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1325 (ICons t1327 (INil))))) +(let t1329 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 4)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t1328 (ICons t1316 (INil))))) +(let t1330 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1329 (INil)))) +(let t1331 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2560)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1330 (ICons t928 (INil))))) +(let t1332 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2560)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1331 (INil)))) +(let t1333 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1258 (ICons t1332 (INil))))) +(let t1334 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1333 (ICons t1333 (INil))))) +(let t1335 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1334 (INil)))) +(let t1336 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1335 (ICons t1138 (INil))))) +(let t1337 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1336 (ICons t1139 (INil))))) +(let t1338 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1337 (INil)))) +(let t1339 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1338 (INil)))) +(let t1340 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1339 (ICons t1333 (INil))))) +(let t1341 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1340 (ICons t936 (INil))))) +(let t1342 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1341 (ICons t918 (INil))))) +(let t1343 (Op (Sum (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1342 (INil)))) +(let t1344 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1343 (ICons t1140 (INil))))) +(let t1345 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1344 (ICons t1141 (INil))))) +(let t1346 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1345 (INil)))) +(let t1347 (Op (Add (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1346 (ICons t1142 (INil))))) +(let t1348 (Op (Recip (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1347 (INil)))) +(let t1349 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1343 (ICons t1348 (INil))))) +(let t1350 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1341 (ICons t916 (INil))))) +(let t1351 (Op (Sum (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 9728)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1350 (INil)))) +(let t1352 (Op (Mul (ECons (MVar "s") (ECons (MNum 9728) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ICons t1349 (ICons t1351 (INil))))) +(let t1353 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ECons (MNum 9728) (ENil)))) (ECons (MMul (MIter) (MNum 9728)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 9728)) (MNum 2560)) (ECons (MMul (MIter) (MNum 9728)) (ECons (MIter) (ENil))))) (ICons t1352 (ICons t920 (INil))))) +(let t1354 (Op (Sum (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (MNum 9728) (ECons (MMul (MMul (MIter) (MNum 9728)) (MNum 2560)) (ECons (MMul (MIter) (MNum 9728)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1353 (INil)))) +(let t1355 (Op (Add (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1333 (ICons t1354 (INil))))) +(let t1356 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1355 (ICons t1355 (INil))))) +(let t1357 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2560) (ECons (MMul (MIter) (MNum 2560)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1356 (INil)))) +(let t1358 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1357 (ICons t1145 (INil))))) +(let t1359 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1358 (ICons t1146 (INil))))) +(let t1360 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1359 (INil)))) +(let t1361 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1360 (INil)))) +(let t1362 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1361 (ICons t1355 (INil))))) +(let t1363 (Op (Mul (ECons (MVar "s") (ECons (MNum 2560) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ICons t1362 (ICons t938 (INil))))) +(let t1364 (Op (Mul (ECons (MVar "s") (ECons (MNum 151936) (ECons (MNum 2560) (ENil)))) (ECons (MMul (MIter) (MNum 2560)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 151936)) (ECons (MMul (MIter) (MNum 2560)) (ECons (MIter) (ENil))))) (ICons t1363 (ICons t940 (INil))))) +(let t1365 (Op (Sum (ECons (MVar "s") (ECons (MNum 151936) (ENil))) (MNum 2560) (ECons (MMul (MMul (MIter) (MNum 2560)) (MNum 151936)) (ECons (MMul (MIter) (MNum 2560)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 151936)) (ECons (MIter) (ENil)))) (ICons t1364 (INil)))) +(let t1366 (Output t1365 7980)) +(let t1367 (Output t1315 7905)) +(let t1368 (Output t1316 7906)) +(let t1369 (Op (LoopOutput 0 0 (F32)) (ICons t1211 (INil)))) +(let t1370 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t1369 (INil)))) +(let t1371 (Output t1370 1080)) +(let t1372 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t1369 (INil)))) +(let t1373 (Output t1372 1275)) +(let t1374 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t1369 (INil)))) +(let t1375 (Output t1374 1470)) +(let t1376 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t1369 (INil)))) +(let t1377 (Output t1376 1665)) +(let t1378 (Op (LoopOutputSelect 0 0 4 (F32)) (ICons t1369 (INil)))) +(let t1379 (Output t1378 1860)) +(let t1380 (Op (LoopOutputSelect 0 0 5 (F32)) (ICons t1369 (INil)))) +(let t1381 (Output t1380 2055)) +(let t1382 (Op (LoopOutputSelect 0 0 6 (F32)) (ICons t1369 (INil)))) +(let t1383 (Output t1382 2250)) +(let t1384 (Op (LoopOutputSelect 0 0 7 (F32)) (ICons t1369 (INil)))) +(let t1385 (Output t1384 2445)) +(let t1386 (Op (LoopOutputSelect 0 0 8 (F32)) (ICons t1369 (INil)))) +(let t1387 (Output t1386 2640)) +(let t1388 (Op (LoopOutputSelect 0 0 9 (F32)) (ICons t1369 (INil)))) +(let t1389 (Output t1388 2835)) +(let t1390 (Op (LoopOutputSelect 0 0 10 (F32)) (ICons t1369 (INil)))) +(let t1391 (Output t1390 3030)) +(let t1392 (Op (LoopOutputSelect 0 0 11 (F32)) (ICons t1369 (INil)))) +(let t1393 (Output t1392 3225)) +(let t1394 (Op (LoopOutputSelect 0 0 12 (F32)) (ICons t1369 (INil)))) +(let t1395 (Output t1394 3420)) +(let t1396 (Op (LoopOutputSelect 0 0 13 (F32)) (ICons t1369 (INil)))) +(let t1397 (Output t1396 3615)) +(let t1398 (Op (LoopOutputSelect 0 0 14 (F32)) (ICons t1369 (INil)))) +(let t1399 (Output t1398 3810)) +(let t1400 (Op (LoopOutputSelect 0 0 15 (F32)) (ICons t1369 (INil)))) +(let t1401 (Output t1400 4005)) +(let t1402 (Op (LoopOutputSelect 0 0 16 (F32)) (ICons t1369 (INil)))) +(let t1403 (Output t1402 4200)) +(let t1404 (Op (LoopOutputSelect 0 0 17 (F32)) (ICons t1369 (INil)))) +(let t1405 (Output t1404 4395)) +(let t1406 (Op (LoopOutputSelect 0 0 18 (F32)) (ICons t1369 (INil)))) +(let t1407 (Output t1406 4590)) +(let t1408 (Op (LoopOutputSelect 0 0 19 (F32)) (ICons t1369 (INil)))) +(let t1409 (Output t1408 4785)) +(let t1410 (Op (LoopOutputSelect 0 0 20 (F32)) (ICons t1369 (INil)))) +(let t1411 (Output t1410 4980)) +(let t1412 (Op (LoopOutputSelect 0 0 21 (F32)) (ICons t1369 (INil)))) +(let t1413 (Output t1412 5175)) +(let t1414 (Op (LoopOutputSelect 0 0 22 (F32)) (ICons t1369 (INil)))) +(let t1415 (Output t1414 5370)) +(let t1416 (Op (LoopOutputSelect 0 0 23 (F32)) (ICons t1369 (INil)))) +(let t1417 (Output t1416 5565)) +(let t1418 (Op (LoopOutputSelect 0 0 24 (F32)) (ICons t1369 (INil)))) +(let t1419 (Output t1418 5760)) +(let t1420 (Op (LoopOutputSelect 0 0 25 (F32)) (ICons t1369 (INil)))) +(let t1421 (Output t1420 5955)) +(let t1422 (Op (LoopOutputSelect 0 0 26 (F32)) (ICons t1369 (INil)))) +(let t1423 (Output t1422 6150)) +(let t1424 (Op (LoopOutputSelect 0 0 27 (F32)) (ICons t1369 (INil)))) +(let t1425 (Output t1424 6345)) +(let t1426 (Op (LoopOutputSelect 0 0 28 (F32)) (ICons t1369 (INil)))) +(let t1427 (Output t1426 6540)) +(let t1428 (Op (LoopOutputSelect 0 0 29 (F32)) (ICons t1369 (INil)))) +(let t1429 (Output t1428 6735)) +(let t1430 (Op (LoopOutputSelect 0 0 30 (F32)) (ICons t1369 (INil)))) +(let t1431 (Output t1430 6930)) +(let t1432 (Op (LoopOutputSelect 0 0 31 (F32)) (ICons t1369 (INil)))) +(let t1433 (Output t1432 7125)) +(let t1434 (Op (LoopOutputSelect 0 0 32 (F32)) (ICons t1369 (INil)))) +(let t1435 (Output t1434 7320)) +(let t1436 (Op (LoopOutputSelect 0 0 33 (F32)) (ICons t1369 (INil)))) +(let t1437 (Output t1436 7515)) +(let t1438 (Op (LoopOutputSelect 0 0 34 (F32)) (ICons t1369 (INil)))) +(let t1439 (Output t1438 7710)) +(let t1440 (Op (LoopOutput 0 1 (F32)) (ICons t1225 (INil)))) +(let t1441 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t1440 (INil)))) +(let t1442 (Output t1441 1081)) +(let t1443 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t1440 (INil)))) +(let t1444 (Output t1443 1276)) +(let t1445 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t1440 (INil)))) +(let t1446 (Output t1445 1471)) +(let t1447 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t1440 (INil)))) +(let t1448 (Output t1447 1666)) +(let t1449 (Op (LoopOutputSelect 0 1 4 (F32)) (ICons t1440 (INil)))) +(let t1450 (Output t1449 1861)) +(let t1451 (Op (LoopOutputSelect 0 1 5 (F32)) (ICons t1440 (INil)))) +(let t1452 (Output t1451 2056)) +(let t1453 (Op (LoopOutputSelect 0 1 6 (F32)) (ICons t1440 (INil)))) +(let t1454 (Output t1453 2251)) +(let t1455 (Op (LoopOutputSelect 0 1 7 (F32)) (ICons t1440 (INil)))) +(let t1456 (Output t1455 2446)) +(let t1457 (Op (LoopOutputSelect 0 1 8 (F32)) (ICons t1440 (INil)))) +(let t1458 (Output t1457 2641)) +(let t1459 (Op (LoopOutputSelect 0 1 9 (F32)) (ICons t1440 (INil)))) +(let t1460 (Output t1459 2836)) +(let t1461 (Op (LoopOutputSelect 0 1 10 (F32)) (ICons t1440 (INil)))) +(let t1462 (Output t1461 3031)) +(let t1463 (Op (LoopOutputSelect 0 1 11 (F32)) (ICons t1440 (INil)))) +(let t1464 (Output t1463 3226)) +(let t1465 (Op (LoopOutputSelect 0 1 12 (F32)) (ICons t1440 (INil)))) +(let t1466 (Output t1465 3421)) +(let t1467 (Op (LoopOutputSelect 0 1 13 (F32)) (ICons t1440 (INil)))) +(let t1468 (Output t1467 3616)) +(let t1469 (Op (LoopOutputSelect 0 1 14 (F32)) (ICons t1440 (INil)))) +(let t1470 (Output t1469 3811)) +(let t1471 (Op (LoopOutputSelect 0 1 15 (F32)) (ICons t1440 (INil)))) +(let t1472 (Output t1471 4006)) +(let t1473 (Op (LoopOutputSelect 0 1 16 (F32)) (ICons t1440 (INil)))) +(let t1474 (Output t1473 4201)) +(let t1475 (Op (LoopOutputSelect 0 1 17 (F32)) (ICons t1440 (INil)))) +(let t1476 (Output t1475 4396)) +(let t1477 (Op (LoopOutputSelect 0 1 18 (F32)) (ICons t1440 (INil)))) +(let t1478 (Output t1477 4591)) +(let t1479 (Op (LoopOutputSelect 0 1 19 (F32)) (ICons t1440 (INil)))) +(let t1480 (Output t1479 4786)) +(let t1481 (Op (LoopOutputSelect 0 1 20 (F32)) (ICons t1440 (INil)))) +(let t1482 (Output t1481 4981)) +(let t1483 (Op (LoopOutputSelect 0 1 21 (F32)) (ICons t1440 (INil)))) +(let t1484 (Output t1483 5176)) +(let t1485 (Op (LoopOutputSelect 0 1 22 (F32)) (ICons t1440 (INil)))) +(let t1486 (Output t1485 5371)) +(let t1487 (Op (LoopOutputSelect 0 1 23 (F32)) (ICons t1440 (INil)))) +(let t1488 (Output t1487 5566)) +(let t1489 (Op (LoopOutputSelect 0 1 24 (F32)) (ICons t1440 (INil)))) +(let t1490 (Output t1489 5761)) +(let t1491 (Op (LoopOutputSelect 0 1 25 (F32)) (ICons t1440 (INil)))) +(let t1492 (Output t1491 5956)) +(let t1493 (Op (LoopOutputSelect 0 1 26 (F32)) (ICons t1440 (INil)))) +(let t1494 (Output t1493 6151)) +(let t1495 (Op (LoopOutputSelect 0 1 27 (F32)) (ICons t1440 (INil)))) +(let t1496 (Output t1495 6346)) +(let t1497 (Op (LoopOutputSelect 0 1 28 (F32)) (ICons t1440 (INil)))) +(let t1498 (Output t1497 6541)) +(let t1499 (Op (LoopOutputSelect 0 1 29 (F32)) (ICons t1440 (INil)))) +(let t1500 (Output t1499 6736)) +(let t1501 (Op (LoopOutputSelect 0 1 30 (F32)) (ICons t1440 (INil)))) +(let t1502 (Output t1501 6931)) +(let t1503 (Op (LoopOutputSelect 0 1 31 (F32)) (ICons t1440 (INil)))) +(let t1504 (Output t1503 7126)) +(let t1505 (Op (LoopOutputSelect 0 1 32 (F32)) (ICons t1440 (INil)))) +(let t1506 (Output t1505 7321)) +(let t1507 (Op (LoopOutputSelect 0 1 33 (F32)) (ICons t1440 (INil)))) +(let t1508 (Output t1507 7516)) +(let t1509 (Op (LoopOutputSelect 0 1 34 (F32)) (ICons t1440 (INil)))) +(let t1510 (Output t1509 7711)) +(let t1512 (OutputJoin t3 t5)) +(let t1513 (OutputJoin t1512 t7)) +(let t1514 (OutputJoin t1513 t9)) +(let t1515 (OutputJoin t1514 t11)) +(let t1516 (OutputJoin t1515 t13)) +(let t1517 (OutputJoin t1516 t15)) +(let t1518 (OutputJoin t1517 t17)) +(let t1519 (OutputJoin t1518 t19)) +(let t1520 (OutputJoin t1519 t21)) +(let t1521 (OutputJoin t1520 t23)) +(let t1522 (OutputJoin t1521 t25)) +(let t1523 (OutputJoin t1522 t27)) +(let t1524 (OutputJoin t1523 t29)) +(let t1525 (OutputJoin t1524 t31)) +(let t1526 (OutputJoin t1525 t33)) +(let t1527 (OutputJoin t1526 t35)) +(let t1528 (OutputJoin t1527 t37)) +(let t1529 (OutputJoin t1528 t39)) +(let t1530 (OutputJoin t1529 t41)) +(let t1531 (OutputJoin t1530 t43)) +(let t1532 (OutputJoin t1531 t45)) +(let t1533 (OutputJoin t1532 t47)) +(let t1534 (OutputJoin t1533 t49)) +(let t1535 (OutputJoin t1534 t51)) +(let t1536 (OutputJoin t1535 t53)) +(let t1537 (OutputJoin t1536 t55)) +(let t1538 (OutputJoin t1537 t57)) +(let t1539 (OutputJoin t1538 t59)) +(let t1540 (OutputJoin t1539 t61)) +(let t1541 (OutputJoin t1540 t63)) +(let t1542 (OutputJoin t1541 t65)) +(let t1543 (OutputJoin t1542 t67)) +(let t1544 (OutputJoin t1543 t69)) +(let t1545 (OutputJoin t1544 t71)) +(let t1546 (OutputJoin t1545 t73)) +(let t1547 (OutputJoin t1546 t75)) +(let t1548 (OutputJoin t1547 t77)) +(let t1549 (OutputJoin t1548 t79)) +(let t1550 (OutputJoin t1549 t81)) +(let t1551 (OutputJoin t1550 t83)) +(let t1552 (OutputJoin t1551 t85)) +(let t1553 (OutputJoin t1552 t87)) +(let t1554 (OutputJoin t1553 t89)) +(let t1555 (OutputJoin t1554 t91)) +(let t1556 (OutputJoin t1555 t93)) +(let t1557 (OutputJoin t1556 t95)) +(let t1558 (OutputJoin t1557 t97)) +(let t1559 (OutputJoin t1558 t99)) +(let t1560 (OutputJoin t1559 t101)) +(let t1561 (OutputJoin t1560 t103)) +(let t1562 (OutputJoin t1561 t105)) +(let t1563 (OutputJoin t1562 t107)) +(let t1564 (OutputJoin t1563 t109)) +(let t1565 (OutputJoin t1564 t111)) +(let t1566 (OutputJoin t1565 t113)) +(let t1567 (OutputJoin t1566 t115)) +(let t1568 (OutputJoin t1567 t117)) +(let t1569 (OutputJoin t1568 t119)) +(let t1570 (OutputJoin t1569 t121)) +(let t1571 (OutputJoin t1570 t123)) +(let t1572 (OutputJoin t1571 t125)) +(let t1573 (OutputJoin t1572 t127)) +(let t1574 (OutputJoin t1573 t129)) +(let t1575 (OutputJoin t1574 t131)) +(let t1576 (OutputJoin t1575 t133)) +(let t1577 (OutputJoin t1576 t135)) +(let t1578 (OutputJoin t1577 t137)) +(let t1579 (OutputJoin t1578 t139)) +(let t1580 (OutputJoin t1579 t141)) +(let t1581 (OutputJoin t1580 t143)) +(let t1582 (OutputJoin t1581 t145)) +(let t1583 (OutputJoin t1582 t147)) +(let t1584 (OutputJoin t1583 t149)) +(let t1585 (OutputJoin t1584 t151)) +(let t1586 (OutputJoin t1585 t153)) +(let t1587 (OutputJoin t1586 t155)) +(let t1588 (OutputJoin t1587 t157)) +(let t1589 (OutputJoin t1588 t159)) +(let t1590 (OutputJoin t1589 t161)) +(let t1591 (OutputJoin t1590 t163)) +(let t1592 (OutputJoin t1591 t165)) +(let t1593 (OutputJoin t1592 t167)) +(let t1594 (OutputJoin t1593 t169)) +(let t1595 (OutputJoin t1594 t171)) +(let t1596 (OutputJoin t1595 t173)) +(let t1597 (OutputJoin t1596 t175)) +(let t1598 (OutputJoin t1597 t177)) +(let t1599 (OutputJoin t1598 t179)) +(let t1600 (OutputJoin t1599 t181)) +(let t1601 (OutputJoin t1600 t183)) +(let t1602 (OutputJoin t1601 t185)) +(let t1603 (OutputJoin t1602 t187)) +(let t1604 (OutputJoin t1603 t189)) +(let t1605 (OutputJoin t1604 t191)) +(let t1606 (OutputJoin t1605 t193)) +(let t1607 (OutputJoin t1606 t195)) +(let t1608 (OutputJoin t1607 t197)) +(let t1609 (OutputJoin t1608 t199)) +(let t1610 (OutputJoin t1609 t201)) +(let t1611 (OutputJoin t1610 t203)) +(let t1612 (OutputJoin t1611 t205)) +(let t1613 (OutputJoin t1612 t207)) +(let t1614 (OutputJoin t1613 t209)) +(let t1615 (OutputJoin t1614 t211)) +(let t1616 (OutputJoin t1615 t213)) +(let t1617 (OutputJoin t1616 t215)) +(let t1618 (OutputJoin t1617 t217)) +(let t1619 (OutputJoin t1618 t219)) +(let t1620 (OutputJoin t1619 t221)) +(let t1621 (OutputJoin t1620 t223)) +(let t1622 (OutputJoin t1621 t225)) +(let t1623 (OutputJoin t1622 t227)) +(let t1624 (OutputJoin t1623 t229)) +(let t1625 (OutputJoin t1624 t231)) +(let t1626 (OutputJoin t1625 t233)) +(let t1627 (OutputJoin t1626 t235)) +(let t1628 (OutputJoin t1627 t237)) +(let t1629 (OutputJoin t1628 t239)) +(let t1630 (OutputJoin t1629 t241)) +(let t1631 (OutputJoin t1630 t243)) +(let t1632 (OutputJoin t1631 t245)) +(let t1633 (OutputJoin t1632 t247)) +(let t1634 (OutputJoin t1633 t249)) +(let t1635 (OutputJoin t1634 t251)) +(let t1636 (OutputJoin t1635 t253)) +(let t1637 (OutputJoin t1636 t255)) +(let t1638 (OutputJoin t1637 t257)) +(let t1639 (OutputJoin t1638 t259)) +(let t1640 (OutputJoin t1639 t261)) +(let t1641 (OutputJoin t1640 t263)) +(let t1642 (OutputJoin t1641 t265)) +(let t1643 (OutputJoin t1642 t267)) +(let t1644 (OutputJoin t1643 t269)) +(let t1645 (OutputJoin t1644 t271)) +(let t1646 (OutputJoin t1645 t273)) +(let t1647 (OutputJoin t1646 t275)) +(let t1648 (OutputJoin t1647 t277)) +(let t1649 (OutputJoin t1648 t279)) +(let t1650 (OutputJoin t1649 t281)) +(let t1651 (OutputJoin t1650 t283)) +(let t1652 (OutputJoin t1651 t285)) +(let t1653 (OutputJoin t1652 t287)) +(let t1654 (OutputJoin t1653 t289)) +(let t1655 (OutputJoin t1654 t291)) +(let t1656 (OutputJoin t1655 t293)) +(let t1657 (OutputJoin t1656 t295)) +(let t1658 (OutputJoin t1657 t297)) +(let t1659 (OutputJoin t1658 t299)) +(let t1660 (OutputJoin t1659 t301)) +(let t1661 (OutputJoin t1660 t303)) +(let t1662 (OutputJoin t1661 t305)) +(let t1663 (OutputJoin t1662 t307)) +(let t1664 (OutputJoin t1663 t309)) +(let t1665 (OutputJoin t1664 t311)) +(let t1666 (OutputJoin t1665 t313)) +(let t1667 (OutputJoin t1666 t315)) +(let t1668 (OutputJoin t1667 t317)) +(let t1669 (OutputJoin t1668 t319)) +(let t1670 (OutputJoin t1669 t321)) +(let t1671 (OutputJoin t1670 t323)) +(let t1672 (OutputJoin t1671 t325)) +(let t1673 (OutputJoin t1672 t327)) +(let t1674 (OutputJoin t1673 t329)) +(let t1675 (OutputJoin t1674 t331)) +(let t1676 (OutputJoin t1675 t333)) +(let t1677 (OutputJoin t1676 t335)) +(let t1678 (OutputJoin t1677 t337)) +(let t1679 (OutputJoin t1678 t339)) +(let t1680 (OutputJoin t1679 t341)) +(let t1681 (OutputJoin t1680 t343)) +(let t1682 (OutputJoin t1681 t345)) +(let t1683 (OutputJoin t1682 t347)) +(let t1684 (OutputJoin t1683 t349)) +(let t1685 (OutputJoin t1684 t351)) +(let t1686 (OutputJoin t1685 t353)) +(let t1687 (OutputJoin t1686 t355)) +(let t1688 (OutputJoin t1687 t357)) +(let t1689 (OutputJoin t1688 t359)) +(let t1690 (OutputJoin t1689 t361)) +(let t1691 (OutputJoin t1690 t363)) +(let t1692 (OutputJoin t1691 t365)) +(let t1693 (OutputJoin t1692 t367)) +(let t1694 (OutputJoin t1693 t369)) +(let t1695 (OutputJoin t1694 t371)) +(let t1696 (OutputJoin t1695 t373)) +(let t1697 (OutputJoin t1696 t375)) +(let t1698 (OutputJoin t1697 t377)) +(let t1699 (OutputJoin t1698 t379)) +(let t1700 (OutputJoin t1699 t381)) +(let t1701 (OutputJoin t1700 t383)) +(let t1702 (OutputJoin t1701 t385)) +(let t1703 (OutputJoin t1702 t387)) +(let t1704 (OutputJoin t1703 t389)) +(let t1705 (OutputJoin t1704 t391)) +(let t1706 (OutputJoin t1705 t393)) +(let t1707 (OutputJoin t1706 t395)) +(let t1708 (OutputJoin t1707 t397)) +(let t1709 (OutputJoin t1708 t399)) +(let t1710 (OutputJoin t1709 t401)) +(let t1711 (OutputJoin t1710 t403)) +(let t1712 (OutputJoin t1711 t405)) +(let t1713 (OutputJoin t1712 t407)) +(let t1714 (OutputJoin t1713 t409)) +(let t1715 (OutputJoin t1714 t411)) +(let t1716 (OutputJoin t1715 t413)) +(let t1717 (OutputJoin t1716 t415)) +(let t1718 (OutputJoin t1717 t417)) +(let t1719 (OutputJoin t1718 t419)) +(let t1720 (OutputJoin t1719 t421)) +(let t1721 (OutputJoin t1720 t423)) +(let t1722 (OutputJoin t1721 t425)) +(let t1723 (OutputJoin t1722 t427)) +(let t1724 (OutputJoin t1723 t429)) +(let t1725 (OutputJoin t1724 t431)) +(let t1726 (OutputJoin t1725 t433)) +(let t1727 (OutputJoin t1726 t435)) +(let t1728 (OutputJoin t1727 t437)) +(let t1729 (OutputJoin t1728 t439)) +(let t1730 (OutputJoin t1729 t441)) +(let t1731 (OutputJoin t1730 t443)) +(let t1732 (OutputJoin t1731 t445)) +(let t1733 (OutputJoin t1732 t447)) +(let t1734 (OutputJoin t1733 t449)) +(let t1735 (OutputJoin t1734 t451)) +(let t1736 (OutputJoin t1735 t453)) +(let t1737 (OutputJoin t1736 t455)) +(let t1738 (OutputJoin t1737 t457)) +(let t1739 (OutputJoin t1738 t459)) +(let t1740 (OutputJoin t1739 t461)) +(let t1741 (OutputJoin t1740 t463)) +(let t1742 (OutputJoin t1741 t465)) +(let t1743 (OutputJoin t1742 t467)) +(let t1744 (OutputJoin t1743 t469)) +(let t1745 (OutputJoin t1744 t471)) +(let t1746 (OutputJoin t1745 t473)) +(let t1747 (OutputJoin t1746 t475)) +(let t1748 (OutputJoin t1747 t477)) +(let t1749 (OutputJoin t1748 t479)) +(let t1750 (OutputJoin t1749 t481)) +(let t1751 (OutputJoin t1750 t483)) +(let t1752 (OutputJoin t1751 t485)) +(let t1753 (OutputJoin t1752 t487)) +(let t1754 (OutputJoin t1753 t489)) +(let t1755 (OutputJoin t1754 t491)) +(let t1756 (OutputJoin t1755 t493)) +(let t1757 (OutputJoin t1756 t495)) +(let t1758 (OutputJoin t1757 t497)) +(let t1759 (OutputJoin t1758 t499)) +(let t1760 (OutputJoin t1759 t501)) +(let t1761 (OutputJoin t1760 t503)) +(let t1762 (OutputJoin t1761 t505)) +(let t1763 (OutputJoin t1762 t507)) +(let t1764 (OutputJoin t1763 t509)) +(let t1765 (OutputJoin t1764 t511)) +(let t1766 (OutputJoin t1765 t513)) +(let t1767 (OutputJoin t1766 t515)) +(let t1768 (OutputJoin t1767 t517)) +(let t1769 (OutputJoin t1768 t519)) +(let t1770 (OutputJoin t1769 t521)) +(let t1771 (OutputJoin t1770 t523)) +(let t1772 (OutputJoin t1771 t525)) +(let t1773 (OutputJoin t1772 t527)) +(let t1774 (OutputJoin t1773 t529)) +(let t1775 (OutputJoin t1774 t531)) +(let t1776 (OutputJoin t1775 t533)) +(let t1777 (OutputJoin t1776 t535)) +(let t1778 (OutputJoin t1777 t537)) +(let t1779 (OutputJoin t1778 t539)) +(let t1780 (OutputJoin t1779 t541)) +(let t1781 (OutputJoin t1780 t543)) +(let t1782 (OutputJoin t1781 t545)) +(let t1783 (OutputJoin t1782 t547)) +(let t1784 (OutputJoin t1783 t549)) +(let t1785 (OutputJoin t1784 t551)) +(let t1786 (OutputJoin t1785 t553)) +(let t1787 (OutputJoin t1786 t555)) +(let t1788 (OutputJoin t1787 t557)) +(let t1789 (OutputJoin t1788 t559)) +(let t1790 (OutputJoin t1789 t561)) +(let t1791 (OutputJoin t1790 t563)) +(let t1792 (OutputJoin t1791 t565)) +(let t1793 (OutputJoin t1792 t567)) +(let t1794 (OutputJoin t1793 t569)) +(let t1795 (OutputJoin t1794 t571)) +(let t1796 (OutputJoin t1795 t573)) +(let t1797 (OutputJoin t1796 t575)) +(let t1798 (OutputJoin t1797 t577)) +(let t1799 (OutputJoin t1798 t579)) +(let t1800 (OutputJoin t1799 t581)) +(let t1801 (OutputJoin t1800 t583)) +(let t1802 (OutputJoin t1801 t585)) +(let t1803 (OutputJoin t1802 t587)) +(let t1804 (OutputJoin t1803 t589)) +(let t1805 (OutputJoin t1804 t591)) +(let t1806 (OutputJoin t1805 t593)) +(let t1807 (OutputJoin t1806 t595)) +(let t1808 (OutputJoin t1807 t597)) +(let t1809 (OutputJoin t1808 t599)) +(let t1810 (OutputJoin t1809 t601)) +(let t1811 (OutputJoin t1810 t603)) +(let t1812 (OutputJoin t1811 t605)) +(let t1813 (OutputJoin t1812 t607)) +(let t1814 (OutputJoin t1813 t609)) +(let t1815 (OutputJoin t1814 t611)) +(let t1816 (OutputJoin t1815 t613)) +(let t1817 (OutputJoin t1816 t615)) +(let t1818 (OutputJoin t1817 t617)) +(let t1819 (OutputJoin t1818 t619)) +(let t1820 (OutputJoin t1819 t621)) +(let t1821 (OutputJoin t1820 t623)) +(let t1822 (OutputJoin t1821 t625)) +(let t1823 (OutputJoin t1822 t627)) +(let t1824 (OutputJoin t1823 t629)) +(let t1825 (OutputJoin t1824 t631)) +(let t1826 (OutputJoin t1825 t633)) +(let t1827 (OutputJoin t1826 t635)) +(let t1828 (OutputJoin t1827 t637)) +(let t1829 (OutputJoin t1828 t639)) +(let t1830 (OutputJoin t1829 t641)) +(let t1831 (OutputJoin t1830 t643)) +(let t1832 (OutputJoin t1831 t645)) +(let t1833 (OutputJoin t1832 t647)) +(let t1834 (OutputJoin t1833 t649)) +(let t1835 (OutputJoin t1834 t651)) +(let t1836 (OutputJoin t1835 t653)) +(let t1837 (OutputJoin t1836 t655)) +(let t1838 (OutputJoin t1837 t657)) +(let t1839 (OutputJoin t1838 t659)) +(let t1840 (OutputJoin t1839 t661)) +(let t1841 (OutputJoin t1840 t663)) +(let t1842 (OutputJoin t1841 t665)) +(let t1843 (OutputJoin t1842 t667)) +(let t1844 (OutputJoin t1843 t669)) +(let t1845 (OutputJoin t1844 t671)) +(let t1846 (OutputJoin t1845 t673)) +(let t1847 (OutputJoin t1846 t675)) +(let t1848 (OutputJoin t1847 t677)) +(let t1849 (OutputJoin t1848 t679)) +(let t1850 (OutputJoin t1849 t681)) +(let t1851 (OutputJoin t1850 t683)) +(let t1852 (OutputJoin t1851 t685)) +(let t1853 (OutputJoin t1852 t687)) +(let t1854 (OutputJoin t1853 t689)) +(let t1855 (OutputJoin t1854 t691)) +(let t1856 (OutputJoin t1855 t693)) +(let t1857 (OutputJoin t1856 t695)) +(let t1858 (OutputJoin t1857 t697)) +(let t1859 (OutputJoin t1858 t699)) +(let t1860 (OutputJoin t1859 t701)) +(let t1861 (OutputJoin t1860 t703)) +(let t1862 (OutputJoin t1861 t705)) +(let t1863 (OutputJoin t1862 t707)) +(let t1864 (OutputJoin t1863 t709)) +(let t1865 (OutputJoin t1864 t711)) +(let t1866 (OutputJoin t1865 t713)) +(let t1867 (OutputJoin t1866 t715)) +(let t1868 (OutputJoin t1867 t717)) +(let t1869 (OutputJoin t1868 t719)) +(let t1870 (OutputJoin t1869 t721)) +(let t1871 (OutputJoin t1870 t723)) +(let t1872 (OutputJoin t1871 t725)) +(let t1873 (OutputJoin t1872 t727)) +(let t1874 (OutputJoin t1873 t729)) +(let t1875 (OutputJoin t1874 t731)) +(let t1876 (OutputJoin t1875 t733)) +(let t1877 (OutputJoin t1876 t735)) +(let t1878 (OutputJoin t1877 t737)) +(let t1879 (OutputJoin t1878 t739)) +(let t1880 (OutputJoin t1879 t741)) +(let t1881 (OutputJoin t1880 t743)) +(let t1882 (OutputJoin t1881 t745)) +(let t1883 (OutputJoin t1882 t747)) +(let t1884 (OutputJoin t1883 t749)) +(let t1885 (OutputJoin t1884 t751)) +(let t1886 (OutputJoin t1885 t753)) +(let t1887 (OutputJoin t1886 t755)) +(let t1888 (OutputJoin t1887 t757)) +(let t1889 (OutputJoin t1888 t759)) +(let t1890 (OutputJoin t1889 t761)) +(let t1891 (OutputJoin t1890 t763)) +(let t1892 (OutputJoin t1891 t765)) +(let t1893 (OutputJoin t1892 t767)) +(let t1894 (OutputJoin t1893 t769)) +(let t1895 (OutputJoin t1894 t771)) +(let t1896 (OutputJoin t1895 t773)) +(let t1897 (OutputJoin t1896 t775)) +(let t1898 (OutputJoin t1897 t777)) +(let t1899 (OutputJoin t1898 t779)) +(let t1900 (OutputJoin t1899 t781)) +(let t1901 (OutputJoin t1900 t783)) +(let t1902 (OutputJoin t1901 t785)) +(let t1903 (OutputJoin t1902 t787)) +(let t1904 (OutputJoin t1903 t789)) +(let t1905 (OutputJoin t1904 t791)) +(let t1906 (OutputJoin t1905 t793)) +(let t1907 (OutputJoin t1906 t795)) +(let t1908 (OutputJoin t1907 t797)) +(let t1909 (OutputJoin t1908 t799)) +(let t1910 (OutputJoin t1909 t801)) +(let t1911 (OutputJoin t1910 t803)) +(let t1912 (OutputJoin t1911 t805)) +(let t1913 (OutputJoin t1912 t807)) +(let t1914 (OutputJoin t1913 t809)) +(let t1915 (OutputJoin t1914 t811)) +(let t1916 (OutputJoin t1915 t813)) +(let t1917 (OutputJoin t1916 t815)) +(let t1918 (OutputJoin t1917 t817)) +(let t1919 (OutputJoin t1918 t819)) +(let t1920 (OutputJoin t1919 t821)) +(let t1921 (OutputJoin t1920 t823)) +(let t1922 (OutputJoin t1921 t825)) +(let t1923 (OutputJoin t1922 t827)) +(let t1924 (OutputJoin t1923 t829)) +(let t1925 (OutputJoin t1924 t831)) +(let t1926 (OutputJoin t1925 t833)) +(let t1927 (OutputJoin t1926 t835)) +(let t1928 (OutputJoin t1927 t837)) +(let t1929 (OutputJoin t1928 t839)) +(let t1930 (OutputJoin t1929 t841)) +(let t1931 (OutputJoin t1930 t843)) +(let t1932 (OutputJoin t1931 t845)) +(let t1933 (OutputJoin t1932 t847)) +(let t1934 (OutputJoin t1933 t849)) +(let t1935 (OutputJoin t1934 t851)) +(let t1936 (OutputJoin t1935 t853)) +(let t1937 (OutputJoin t1936 t855)) +(let t1938 (OutputJoin t1937 t857)) +(let t1939 (OutputJoin t1938 t859)) +(let t1940 (OutputJoin t1939 t861)) +(let t1941 (OutputJoin t1940 t863)) +(let t1942 (OutputJoin t1941 t865)) +(let t1943 (OutputJoin t1942 t867)) +(let t1944 (OutputJoin t1943 t869)) +(let t1945 (OutputJoin t1944 t871)) +(let t1946 (OutputJoin t1945 t873)) +(let t1947 (OutputJoin t1946 t875)) +(let t1948 (OutputJoin t1947 t877)) +(let t1949 (OutputJoin t1948 t879)) +(let t1950 (OutputJoin t1949 t881)) +(let t1951 (OutputJoin t1950 t883)) +(let t1952 (OutputJoin t1951 t885)) +(let t1953 (OutputJoin t1952 t887)) +(let t1954 (OutputJoin t1953 t889)) +(let t1955 (OutputJoin t1954 t891)) +(let t1956 (OutputJoin t1955 t893)) +(let t1957 (OutputJoin t1956 t895)) +(let t1958 (OutputJoin t1957 t897)) +(let t1959 (OutputJoin t1958 t899)) +(let t1960 (OutputJoin t1959 t901)) +(let t1961 (OutputJoin t1960 t903)) +(let t1962 (OutputJoin t1961 t905)) +(let t1963 (OutputJoin t1962 t907)) +(let t1964 (OutputJoin t1963 t909)) +(let t1965 (OutputJoin t1964 t911)) +(let t1966 (OutputJoin t1965 t913)) +(let t1967 (OutputJoin t1966 t915)) +(let t1968 (OutputJoin t1967 t917)) +(let t1969 (OutputJoin t1968 t919)) +(let t1970 (OutputJoin t1969 t921)) +(let t1971 (OutputJoin t1970 t923)) +(let t1972 (OutputJoin t1971 t925)) +(let t1973 (OutputJoin t1972 t927)) +(let t1974 (OutputJoin t1973 t929)) +(let t1975 (OutputJoin t1974 t931)) +(let t1976 (OutputJoin t1975 t933)) +(let t1977 (OutputJoin t1976 t935)) +(let t1978 (OutputJoin t1977 t937)) +(let t1979 (OutputJoin t1978 t939)) +(let t1980 (OutputJoin t1979 t941)) +(let t1981 (OutputJoin t1980 t1366)) +(let t1982 (OutputJoin t1981 t1371)) +(let t1983 (OutputJoin t1982 t1442)) +(let t1984 (OutputJoin t1983 t1373)) +(let t1985 (OutputJoin t1984 t1444)) +(let t1986 (OutputJoin t1985 t1375)) +(let t1987 (OutputJoin t1986 t1446)) +(let t1988 (OutputJoin t1987 t1377)) +(let t1989 (OutputJoin t1988 t1448)) +(let t1990 (OutputJoin t1989 t1379)) +(let t1991 (OutputJoin t1990 t1450)) +(let t1992 (OutputJoin t1991 t1381)) +(let t1993 (OutputJoin t1992 t1452)) +(let t1994 (OutputJoin t1993 t1383)) +(let t1995 (OutputJoin t1994 t1454)) +(let t1996 (OutputJoin t1995 t1385)) +(let t1997 (OutputJoin t1996 t1456)) +(let t1998 (OutputJoin t1997 t1387)) +(let t1999 (OutputJoin t1998 t1458)) +(let t2000 (OutputJoin t1999 t1389)) +(let t2001 (OutputJoin t2000 t1460)) +(let t2002 (OutputJoin t2001 t1391)) +(let t2003 (OutputJoin t2002 t1462)) +(let t2004 (OutputJoin t2003 t1393)) +(let t2005 (OutputJoin t2004 t1464)) +(let t2006 (OutputJoin t2005 t1395)) +(let t2007 (OutputJoin t2006 t1466)) +(let t2008 (OutputJoin t2007 t1397)) +(let t2009 (OutputJoin t2008 t1468)) +(let t2010 (OutputJoin t2009 t1399)) +(let t2011 (OutputJoin t2010 t1470)) +(let t2012 (OutputJoin t2011 t1401)) +(let t2013 (OutputJoin t2012 t1472)) +(let t2014 (OutputJoin t2013 t1403)) +(let t2015 (OutputJoin t2014 t1474)) +(let t2016 (OutputJoin t2015 t1405)) +(let t2017 (OutputJoin t2016 t1476)) +(let t2018 (OutputJoin t2017 t1407)) +(let t2019 (OutputJoin t2018 t1478)) +(let t2020 (OutputJoin t2019 t1409)) +(let t2021 (OutputJoin t2020 t1480)) +(let t2022 (OutputJoin t2021 t1411)) +(let t2023 (OutputJoin t2022 t1482)) +(let t2024 (OutputJoin t2023 t1413)) +(let t2025 (OutputJoin t2024 t1484)) +(let t2026 (OutputJoin t2025 t1415)) +(let t2027 (OutputJoin t2026 t1486)) +(let t2028 (OutputJoin t2027 t1417)) +(let t2029 (OutputJoin t2028 t1488)) +(let t2030 (OutputJoin t2029 t1419)) +(let t2031 (OutputJoin t2030 t1490)) +(let t2032 (OutputJoin t2031 t1421)) +(let t2033 (OutputJoin t2032 t1492)) +(let t2034 (OutputJoin t2033 t1423)) +(let t2035 (OutputJoin t2034 t1494)) +(let t2036 (OutputJoin t2035 t1425)) +(let t2037 (OutputJoin t2036 t1496)) +(let t2038 (OutputJoin t2037 t1427)) +(let t2039 (OutputJoin t2038 t1498)) +(let t2040 (OutputJoin t2039 t1429)) +(let t2041 (OutputJoin t2040 t1500)) +(let t2042 (OutputJoin t2041 t1431)) +(let t2043 (OutputJoin t2042 t1502)) +(let t2044 (OutputJoin t2043 t1433)) +(let t2045 (OutputJoin t2044 t1504)) +(let t2046 (OutputJoin t2045 t1435)) +(let t2047 (OutputJoin t2046 t1506)) +(let t2048 (OutputJoin t2047 t1437)) +(let t2049 (OutputJoin t2048 t1508)) +(let t2050 (OutputJoin t2049 t1439)) +(let t2051 (OutputJoin t2050 t1510)) +(let t2052 (OutputJoin t2051 t1367)) +(let t2053 (OutputJoin t2052 t1368)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/qwen3_moe.egg b/tests/qwen3_moe.egg new file mode 100644 index 00000000..74421d97 --- /dev/null +++ b/tests/qwen3_moe.egg @@ -0,0 +1,2715 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "input" (Int))) +(let t1 (Input 1 "pos_ids" (Int))) +(let t2 (Input 2 "kv_cache.0.k" (F32))) +(let t3 (Output t2 2)) +(let t4 (Input 4 "kv_cache.0.v" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.1.k" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.v" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.2.k" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.v" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.3.k" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.v" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.4.k" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "kv_cache.4.v" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "kv_cache.5.k" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "kv_cache.5.v" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "kv_cache.6.k" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "kv_cache.6.v" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "kv_cache.7.k" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "kv_cache.7.v" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "kv_cache.8.k" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "kv_cache.8.v" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "kv_cache.9.k" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "kv_cache.9.v" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "kv_cache.10.k" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "kv_cache.10.v" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "kv_cache.11.k" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "kv_cache.11.v" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "kv_cache.12.k" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "kv_cache.12.v" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "kv_cache.13.k" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "kv_cache.13.v" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "kv_cache.14.k" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "kv_cache.14.v" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "kv_cache.15.k" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "kv_cache.15.v" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "kv_cache.16.k" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "kv_cache.16.v" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "kv_cache.17.k" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "kv_cache.17.v" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "kv_cache.18.k" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "kv_cache.18.v" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "kv_cache.19.k" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "kv_cache.19.v" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "kv_cache.20.k" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "kv_cache.20.v" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "kv_cache.21.k" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "kv_cache.21.v" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "kv_cache.22.k" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "kv_cache.22.v" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "kv_cache.23.k" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "kv_cache.23.v" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "kv_cache.24.k" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "kv_cache.24.v" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "kv_cache.25.k" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "kv_cache.25.v" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "kv_cache.26.k" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "kv_cache.26.v" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "kv_cache.27.k" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "kv_cache.27.v" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "kv_cache.28.k" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "kv_cache.28.v" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "kv_cache.29.k" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "kv_cache.29.v" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "kv_cache.30.k" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "kv_cache.30.v" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "kv_cache.31.k" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "kv_cache.31.v" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "kv_cache.32.k" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "kv_cache.32.v" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "kv_cache.33.k" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "kv_cache.33.v" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "kv_cache.34.k" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "kv_cache.34.v" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "kv_cache.35.k" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "kv_cache.35.v" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "kv_cache.36.k" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "kv_cache.36.v" (F32))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "kv_cache.37.k" (F32))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "kv_cache.37.v" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "kv_cache.38.k" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "kv_cache.38.v" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "kv_cache.39.k" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "kv_cache.39.v" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "kv_cache.40.k" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "kv_cache.40.v" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "kv_cache.41.k" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "kv_cache.41.v" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "kv_cache.42.k" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "kv_cache.42.v" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "kv_cache.43.k" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "kv_cache.43.v" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "kv_cache.44.k" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "kv_cache.44.v" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "kv_cache.45.k" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "kv_cache.45.v" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "kv_cache.46.k" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "kv_cache.46.v" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "kv_cache.47.k" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "kv_cache.47.v" (F32))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.layers.0.self_attn.q_proj.weight" (F32))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.layers.0.self_attn.k_proj.weight" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.layers.0.self_attn.v_proj.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.layers.0.self_attn.o_proj.weight" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.layers.0.self_attn.q_norm.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.layers.0.self_attn.k_norm.weight" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.layers.0.mlp.gate.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.layers.0.mlp.gate_up_weights" (Bf16))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.layers.0.mlp.down_weights" (Bf16))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.layers.0.input_layernorm.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.layers.0.post_attention_layernorm.weight" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.layers.1.self_attn.q_proj.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.layers.1.self_attn.k_proj.weight" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.layers.1.self_attn.v_proj.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.layers.1.self_attn.o_proj.weight" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.layers.1.self_attn.q_norm.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.layers.1.self_attn.k_norm.weight" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.layers.1.mlp.gate.weight" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.layers.1.mlp.gate_up_weights" (Bf16))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.layers.1.mlp.down_weights" (Bf16))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.layers.1.input_layernorm.weight" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.layers.1.post_attention_layernorm.weight" (F32))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.layers.2.self_attn.q_proj.weight" (F32))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.layers.2.self_attn.k_proj.weight" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.layers.2.self_attn.v_proj.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.layers.2.self_attn.o_proj.weight" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.layers.2.self_attn.q_norm.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.layers.2.self_attn.k_norm.weight" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.layers.2.mlp.gate.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.layers.2.mlp.gate_up_weights" (Bf16))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.layers.2.mlp.down_weights" (Bf16))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.layers.2.input_layernorm.weight" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.layers.2.post_attention_layernorm.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.layers.3.self_attn.q_proj.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.layers.3.self_attn.k_proj.weight" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.layers.3.self_attn.v_proj.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.layers.3.self_attn.o_proj.weight" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.layers.3.self_attn.q_norm.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.layers.3.self_attn.k_norm.weight" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.layers.3.mlp.gate.weight" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.layers.3.mlp.gate_up_weights" (Bf16))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.layers.3.mlp.down_weights" (Bf16))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.layers.3.input_layernorm.weight" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.layers.3.post_attention_layernorm.weight" (F32))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.layers.4.self_attn.q_proj.weight" (F32))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.layers.4.self_attn.k_proj.weight" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.layers.4.self_attn.v_proj.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.layers.4.self_attn.o_proj.weight" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.layers.4.self_attn.q_norm.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.layers.4.self_attn.k_norm.weight" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.layers.4.mlp.gate.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.layers.4.mlp.gate_up_weights" (Bf16))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.layers.4.mlp.down_weights" (Bf16))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.layers.4.input_layernorm.weight" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.layers.4.post_attention_layernorm.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.layers.5.self_attn.q_proj.weight" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.layers.5.self_attn.k_proj.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.layers.5.self_attn.v_proj.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.layers.5.self_attn.o_proj.weight" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.layers.5.self_attn.q_norm.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.layers.5.self_attn.k_norm.weight" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.layers.5.mlp.gate.weight" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.layers.5.mlp.gate_up_weights" (Bf16))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.layers.5.mlp.down_weights" (Bf16))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.layers.5.input_layernorm.weight" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.layers.5.post_attention_layernorm.weight" (F32))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.layers.6.self_attn.q_proj.weight" (F32))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.layers.6.self_attn.k_proj.weight" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.layers.6.self_attn.v_proj.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.layers.6.self_attn.o_proj.weight" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.layers.6.self_attn.q_norm.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.layers.6.self_attn.k_norm.weight" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.layers.6.mlp.gate.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.layers.6.mlp.gate_up_weights" (Bf16))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.layers.6.mlp.down_weights" (Bf16))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.layers.6.input_layernorm.weight" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.layers.6.post_attention_layernorm.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.layers.7.self_attn.q_proj.weight" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.layers.7.self_attn.k_proj.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.layers.7.self_attn.v_proj.weight" (F32))) +(let t353 (Output t352 352)) +(let t354 (Input 354 "model.layers.7.self_attn.o_proj.weight" (F32))) +(let t355 (Output t354 354)) +(let t356 (Input 356 "model.layers.7.self_attn.q_norm.weight" (F32))) +(let t357 (Output t356 356)) +(let t358 (Input 358 "model.layers.7.self_attn.k_norm.weight" (F32))) +(let t359 (Output t358 358)) +(let t360 (Input 360 "model.layers.7.mlp.gate.weight" (F32))) +(let t361 (Output t360 360)) +(let t362 (Input 362 "model.layers.7.mlp.gate_up_weights" (Bf16))) +(let t363 (Output t362 362)) +(let t364 (Input 364 "model.layers.7.mlp.down_weights" (Bf16))) +(let t365 (Output t364 364)) +(let t366 (Input 366 "model.layers.7.input_layernorm.weight" (F32))) +(let t367 (Output t366 366)) +(let t368 (Input 368 "model.layers.7.post_attention_layernorm.weight" (F32))) +(let t369 (Output t368 368)) +(let t370 (Input 370 "model.layers.8.self_attn.q_proj.weight" (F32))) +(let t371 (Output t370 370)) +(let t372 (Input 372 "model.layers.8.self_attn.k_proj.weight" (F32))) +(let t373 (Output t372 372)) +(let t374 (Input 374 "model.layers.8.self_attn.v_proj.weight" (F32))) +(let t375 (Output t374 374)) +(let t376 (Input 376 "model.layers.8.self_attn.o_proj.weight" (F32))) +(let t377 (Output t376 376)) +(let t378 (Input 378 "model.layers.8.self_attn.q_norm.weight" (F32))) +(let t379 (Output t378 378)) +(let t380 (Input 380 "model.layers.8.self_attn.k_norm.weight" (F32))) +(let t381 (Output t380 380)) +(let t382 (Input 382 "model.layers.8.mlp.gate.weight" (F32))) +(let t383 (Output t382 382)) +(let t384 (Input 384 "model.layers.8.mlp.gate_up_weights" (Bf16))) +(let t385 (Output t384 384)) +(let t386 (Input 386 "model.layers.8.mlp.down_weights" (Bf16))) +(let t387 (Output t386 386)) +(let t388 (Input 388 "model.layers.8.input_layernorm.weight" (F32))) +(let t389 (Output t388 388)) +(let t390 (Input 390 "model.layers.8.post_attention_layernorm.weight" (F32))) +(let t391 (Output t390 390)) +(let t392 (Input 392 "model.layers.9.self_attn.q_proj.weight" (F32))) +(let t393 (Output t392 392)) +(let t394 (Input 394 "model.layers.9.self_attn.k_proj.weight" (F32))) +(let t395 (Output t394 394)) +(let t396 (Input 396 "model.layers.9.self_attn.v_proj.weight" (F32))) +(let t397 (Output t396 396)) +(let t398 (Input 398 "model.layers.9.self_attn.o_proj.weight" (F32))) +(let t399 (Output t398 398)) +(let t400 (Input 400 "model.layers.9.self_attn.q_norm.weight" (F32))) +(let t401 (Output t400 400)) +(let t402 (Input 402 "model.layers.9.self_attn.k_norm.weight" (F32))) +(let t403 (Output t402 402)) +(let t404 (Input 404 "model.layers.9.mlp.gate.weight" (F32))) +(let t405 (Output t404 404)) +(let t406 (Input 406 "model.layers.9.mlp.gate_up_weights" (Bf16))) +(let t407 (Output t406 406)) +(let t408 (Input 408 "model.layers.9.mlp.down_weights" (Bf16))) +(let t409 (Output t408 408)) +(let t410 (Input 410 "model.layers.9.input_layernorm.weight" (F32))) +(let t411 (Output t410 410)) +(let t412 (Input 412 "model.layers.9.post_attention_layernorm.weight" (F32))) +(let t413 (Output t412 412)) +(let t414 (Input 414 "model.layers.10.self_attn.q_proj.weight" (F32))) +(let t415 (Output t414 414)) +(let t416 (Input 416 "model.layers.10.self_attn.k_proj.weight" (F32))) +(let t417 (Output t416 416)) +(let t418 (Input 418 "model.layers.10.self_attn.v_proj.weight" (F32))) +(let t419 (Output t418 418)) +(let t420 (Input 420 "model.layers.10.self_attn.o_proj.weight" (F32))) +(let t421 (Output t420 420)) +(let t422 (Input 422 "model.layers.10.self_attn.q_norm.weight" (F32))) +(let t423 (Output t422 422)) +(let t424 (Input 424 "model.layers.10.self_attn.k_norm.weight" (F32))) +(let t425 (Output t424 424)) +(let t426 (Input 426 "model.layers.10.mlp.gate.weight" (F32))) +(let t427 (Output t426 426)) +(let t428 (Input 428 "model.layers.10.mlp.gate_up_weights" (Bf16))) +(let t429 (Output t428 428)) +(let t430 (Input 430 "model.layers.10.mlp.down_weights" (Bf16))) +(let t431 (Output t430 430)) +(let t432 (Input 432 "model.layers.10.input_layernorm.weight" (F32))) +(let t433 (Output t432 432)) +(let t434 (Input 434 "model.layers.10.post_attention_layernorm.weight" (F32))) +(let t435 (Output t434 434)) +(let t436 (Input 436 "model.layers.11.self_attn.q_proj.weight" (F32))) +(let t437 (Output t436 436)) +(let t438 (Input 438 "model.layers.11.self_attn.k_proj.weight" (F32))) +(let t439 (Output t438 438)) +(let t440 (Input 440 "model.layers.11.self_attn.v_proj.weight" (F32))) +(let t441 (Output t440 440)) +(let t442 (Input 442 "model.layers.11.self_attn.o_proj.weight" (F32))) +(let t443 (Output t442 442)) +(let t444 (Input 444 "model.layers.11.self_attn.q_norm.weight" (F32))) +(let t445 (Output t444 444)) +(let t446 (Input 446 "model.layers.11.self_attn.k_norm.weight" (F32))) +(let t447 (Output t446 446)) +(let t448 (Input 448 "model.layers.11.mlp.gate.weight" (F32))) +(let t449 (Output t448 448)) +(let t450 (Input 450 "model.layers.11.mlp.gate_up_weights" (Bf16))) +(let t451 (Output t450 450)) +(let t452 (Input 452 "model.layers.11.mlp.down_weights" (Bf16))) +(let t453 (Output t452 452)) +(let t454 (Input 454 "model.layers.11.input_layernorm.weight" (F32))) +(let t455 (Output t454 454)) +(let t456 (Input 456 "model.layers.11.post_attention_layernorm.weight" (F32))) +(let t457 (Output t456 456)) +(let t458 (Input 458 "model.layers.12.self_attn.q_proj.weight" (F32))) +(let t459 (Output t458 458)) +(let t460 (Input 460 "model.layers.12.self_attn.k_proj.weight" (F32))) +(let t461 (Output t460 460)) +(let t462 (Input 462 "model.layers.12.self_attn.v_proj.weight" (F32))) +(let t463 (Output t462 462)) +(let t464 (Input 464 "model.layers.12.self_attn.o_proj.weight" (F32))) +(let t465 (Output t464 464)) +(let t466 (Input 466 "model.layers.12.self_attn.q_norm.weight" (F32))) +(let t467 (Output t466 466)) +(let t468 (Input 468 "model.layers.12.self_attn.k_norm.weight" (F32))) +(let t469 (Output t468 468)) +(let t470 (Input 470 "model.layers.12.mlp.gate.weight" (F32))) +(let t471 (Output t470 470)) +(let t472 (Input 472 "model.layers.12.mlp.gate_up_weights" (Bf16))) +(let t473 (Output t472 472)) +(let t474 (Input 474 "model.layers.12.mlp.down_weights" (Bf16))) +(let t475 (Output t474 474)) +(let t476 (Input 476 "model.layers.12.input_layernorm.weight" (F32))) +(let t477 (Output t476 476)) +(let t478 (Input 478 "model.layers.12.post_attention_layernorm.weight" (F32))) +(let t479 (Output t478 478)) +(let t480 (Input 480 "model.layers.13.self_attn.q_proj.weight" (F32))) +(let t481 (Output t480 480)) +(let t482 (Input 482 "model.layers.13.self_attn.k_proj.weight" (F32))) +(let t483 (Output t482 482)) +(let t484 (Input 484 "model.layers.13.self_attn.v_proj.weight" (F32))) +(let t485 (Output t484 484)) +(let t486 (Input 486 "model.layers.13.self_attn.o_proj.weight" (F32))) +(let t487 (Output t486 486)) +(let t488 (Input 488 "model.layers.13.self_attn.q_norm.weight" (F32))) +(let t489 (Output t488 488)) +(let t490 (Input 490 "model.layers.13.self_attn.k_norm.weight" (F32))) +(let t491 (Output t490 490)) +(let t492 (Input 492 "model.layers.13.mlp.gate.weight" (F32))) +(let t493 (Output t492 492)) +(let t494 (Input 494 "model.layers.13.mlp.gate_up_weights" (Bf16))) +(let t495 (Output t494 494)) +(let t496 (Input 496 "model.layers.13.mlp.down_weights" (Bf16))) +(let t497 (Output t496 496)) +(let t498 (Input 498 "model.layers.13.input_layernorm.weight" (F32))) +(let t499 (Output t498 498)) +(let t500 (Input 500 "model.layers.13.post_attention_layernorm.weight" (F32))) +(let t501 (Output t500 500)) +(let t502 (Input 502 "model.layers.14.self_attn.q_proj.weight" (F32))) +(let t503 (Output t502 502)) +(let t504 (Input 504 "model.layers.14.self_attn.k_proj.weight" (F32))) +(let t505 (Output t504 504)) +(let t506 (Input 506 "model.layers.14.self_attn.v_proj.weight" (F32))) +(let t507 (Output t506 506)) +(let t508 (Input 508 "model.layers.14.self_attn.o_proj.weight" (F32))) +(let t509 (Output t508 508)) +(let t510 (Input 510 "model.layers.14.self_attn.q_norm.weight" (F32))) +(let t511 (Output t510 510)) +(let t512 (Input 512 "model.layers.14.self_attn.k_norm.weight" (F32))) +(let t513 (Output t512 512)) +(let t514 (Input 514 "model.layers.14.mlp.gate.weight" (F32))) +(let t515 (Output t514 514)) +(let t516 (Input 516 "model.layers.14.mlp.gate_up_weights" (Bf16))) +(let t517 (Output t516 516)) +(let t518 (Input 518 "model.layers.14.mlp.down_weights" (Bf16))) +(let t519 (Output t518 518)) +(let t520 (Input 520 "model.layers.14.input_layernorm.weight" (F32))) +(let t521 (Output t520 520)) +(let t522 (Input 522 "model.layers.14.post_attention_layernorm.weight" (F32))) +(let t523 (Output t522 522)) +(let t524 (Input 524 "model.layers.15.self_attn.q_proj.weight" (F32))) +(let t525 (Output t524 524)) +(let t526 (Input 526 "model.layers.15.self_attn.k_proj.weight" (F32))) +(let t527 (Output t526 526)) +(let t528 (Input 528 "model.layers.15.self_attn.v_proj.weight" (F32))) +(let t529 (Output t528 528)) +(let t530 (Input 530 "model.layers.15.self_attn.o_proj.weight" (F32))) +(let t531 (Output t530 530)) +(let t532 (Input 532 "model.layers.15.self_attn.q_norm.weight" (F32))) +(let t533 (Output t532 532)) +(let t534 (Input 534 "model.layers.15.self_attn.k_norm.weight" (F32))) +(let t535 (Output t534 534)) +(let t536 (Input 536 "model.layers.15.mlp.gate.weight" (F32))) +(let t537 (Output t536 536)) +(let t538 (Input 538 "model.layers.15.mlp.gate_up_weights" (Bf16))) +(let t539 (Output t538 538)) +(let t540 (Input 540 "model.layers.15.mlp.down_weights" (Bf16))) +(let t541 (Output t540 540)) +(let t542 (Input 542 "model.layers.15.input_layernorm.weight" (F32))) +(let t543 (Output t542 542)) +(let t544 (Input 544 "model.layers.15.post_attention_layernorm.weight" (F32))) +(let t545 (Output t544 544)) +(let t546 (Input 546 "model.layers.16.self_attn.q_proj.weight" (F32))) +(let t547 (Output t546 546)) +(let t548 (Input 548 "model.layers.16.self_attn.k_proj.weight" (F32))) +(let t549 (Output t548 548)) +(let t550 (Input 550 "model.layers.16.self_attn.v_proj.weight" (F32))) +(let t551 (Output t550 550)) +(let t552 (Input 552 "model.layers.16.self_attn.o_proj.weight" (F32))) +(let t553 (Output t552 552)) +(let t554 (Input 554 "model.layers.16.self_attn.q_norm.weight" (F32))) +(let t555 (Output t554 554)) +(let t556 (Input 556 "model.layers.16.self_attn.k_norm.weight" (F32))) +(let t557 (Output t556 556)) +(let t558 (Input 558 "model.layers.16.mlp.gate.weight" (F32))) +(let t559 (Output t558 558)) +(let t560 (Input 560 "model.layers.16.mlp.gate_up_weights" (Bf16))) +(let t561 (Output t560 560)) +(let t562 (Input 562 "model.layers.16.mlp.down_weights" (Bf16))) +(let t563 (Output t562 562)) +(let t564 (Input 564 "model.layers.16.input_layernorm.weight" (F32))) +(let t565 (Output t564 564)) +(let t566 (Input 566 "model.layers.16.post_attention_layernorm.weight" (F32))) +(let t567 (Output t566 566)) +(let t568 (Input 568 "model.layers.17.self_attn.q_proj.weight" (F32))) +(let t569 (Output t568 568)) +(let t570 (Input 570 "model.layers.17.self_attn.k_proj.weight" (F32))) +(let t571 (Output t570 570)) +(let t572 (Input 572 "model.layers.17.self_attn.v_proj.weight" (F32))) +(let t573 (Output t572 572)) +(let t574 (Input 574 "model.layers.17.self_attn.o_proj.weight" (F32))) +(let t575 (Output t574 574)) +(let t576 (Input 576 "model.layers.17.self_attn.q_norm.weight" (F32))) +(let t577 (Output t576 576)) +(let t578 (Input 578 "model.layers.17.self_attn.k_norm.weight" (F32))) +(let t579 (Output t578 578)) +(let t580 (Input 580 "model.layers.17.mlp.gate.weight" (F32))) +(let t581 (Output t580 580)) +(let t582 (Input 582 "model.layers.17.mlp.gate_up_weights" (Bf16))) +(let t583 (Output t582 582)) +(let t584 (Input 584 "model.layers.17.mlp.down_weights" (Bf16))) +(let t585 (Output t584 584)) +(let t586 (Input 586 "model.layers.17.input_layernorm.weight" (F32))) +(let t587 (Output t586 586)) +(let t588 (Input 588 "model.layers.17.post_attention_layernorm.weight" (F32))) +(let t589 (Output t588 588)) +(let t590 (Input 590 "model.layers.18.self_attn.q_proj.weight" (F32))) +(let t591 (Output t590 590)) +(let t592 (Input 592 "model.layers.18.self_attn.k_proj.weight" (F32))) +(let t593 (Output t592 592)) +(let t594 (Input 594 "model.layers.18.self_attn.v_proj.weight" (F32))) +(let t595 (Output t594 594)) +(let t596 (Input 596 "model.layers.18.self_attn.o_proj.weight" (F32))) +(let t597 (Output t596 596)) +(let t598 (Input 598 "model.layers.18.self_attn.q_norm.weight" (F32))) +(let t599 (Output t598 598)) +(let t600 (Input 600 "model.layers.18.self_attn.k_norm.weight" (F32))) +(let t601 (Output t600 600)) +(let t602 (Input 602 "model.layers.18.mlp.gate.weight" (F32))) +(let t603 (Output t602 602)) +(let t604 (Input 604 "model.layers.18.mlp.gate_up_weights" (Bf16))) +(let t605 (Output t604 604)) +(let t606 (Input 606 "model.layers.18.mlp.down_weights" (Bf16))) +(let t607 (Output t606 606)) +(let t608 (Input 608 "model.layers.18.input_layernorm.weight" (F32))) +(let t609 (Output t608 608)) +(let t610 (Input 610 "model.layers.18.post_attention_layernorm.weight" (F32))) +(let t611 (Output t610 610)) +(let t612 (Input 612 "model.layers.19.self_attn.q_proj.weight" (F32))) +(let t613 (Output t612 612)) +(let t614 (Input 614 "model.layers.19.self_attn.k_proj.weight" (F32))) +(let t615 (Output t614 614)) +(let t616 (Input 616 "model.layers.19.self_attn.v_proj.weight" (F32))) +(let t617 (Output t616 616)) +(let t618 (Input 618 "model.layers.19.self_attn.o_proj.weight" (F32))) +(let t619 (Output t618 618)) +(let t620 (Input 620 "model.layers.19.self_attn.q_norm.weight" (F32))) +(let t621 (Output t620 620)) +(let t622 (Input 622 "model.layers.19.self_attn.k_norm.weight" (F32))) +(let t623 (Output t622 622)) +(let t624 (Input 624 "model.layers.19.mlp.gate.weight" (F32))) +(let t625 (Output t624 624)) +(let t626 (Input 626 "model.layers.19.mlp.gate_up_weights" (Bf16))) +(let t627 (Output t626 626)) +(let t628 (Input 628 "model.layers.19.mlp.down_weights" (Bf16))) +(let t629 (Output t628 628)) +(let t630 (Input 630 "model.layers.19.input_layernorm.weight" (F32))) +(let t631 (Output t630 630)) +(let t632 (Input 632 "model.layers.19.post_attention_layernorm.weight" (F32))) +(let t633 (Output t632 632)) +(let t634 (Input 634 "model.layers.20.self_attn.q_proj.weight" (F32))) +(let t635 (Output t634 634)) +(let t636 (Input 636 "model.layers.20.self_attn.k_proj.weight" (F32))) +(let t637 (Output t636 636)) +(let t638 (Input 638 "model.layers.20.self_attn.v_proj.weight" (F32))) +(let t639 (Output t638 638)) +(let t640 (Input 640 "model.layers.20.self_attn.o_proj.weight" (F32))) +(let t641 (Output t640 640)) +(let t642 (Input 642 "model.layers.20.self_attn.q_norm.weight" (F32))) +(let t643 (Output t642 642)) +(let t644 (Input 644 "model.layers.20.self_attn.k_norm.weight" (F32))) +(let t645 (Output t644 644)) +(let t646 (Input 646 "model.layers.20.mlp.gate.weight" (F32))) +(let t647 (Output t646 646)) +(let t648 (Input 648 "model.layers.20.mlp.gate_up_weights" (Bf16))) +(let t649 (Output t648 648)) +(let t650 (Input 650 "model.layers.20.mlp.down_weights" (Bf16))) +(let t651 (Output t650 650)) +(let t652 (Input 652 "model.layers.20.input_layernorm.weight" (F32))) +(let t653 (Output t652 652)) +(let t654 (Input 654 "model.layers.20.post_attention_layernorm.weight" (F32))) +(let t655 (Output t654 654)) +(let t656 (Input 656 "model.layers.21.self_attn.q_proj.weight" (F32))) +(let t657 (Output t656 656)) +(let t658 (Input 658 "model.layers.21.self_attn.k_proj.weight" (F32))) +(let t659 (Output t658 658)) +(let t660 (Input 660 "model.layers.21.self_attn.v_proj.weight" (F32))) +(let t661 (Output t660 660)) +(let t662 (Input 662 "model.layers.21.self_attn.o_proj.weight" (F32))) +(let t663 (Output t662 662)) +(let t664 (Input 664 "model.layers.21.self_attn.q_norm.weight" (F32))) +(let t665 (Output t664 664)) +(let t666 (Input 666 "model.layers.21.self_attn.k_norm.weight" (F32))) +(let t667 (Output t666 666)) +(let t668 (Input 668 "model.layers.21.mlp.gate.weight" (F32))) +(let t669 (Output t668 668)) +(let t670 (Input 670 "model.layers.21.mlp.gate_up_weights" (Bf16))) +(let t671 (Output t670 670)) +(let t672 (Input 672 "model.layers.21.mlp.down_weights" (Bf16))) +(let t673 (Output t672 672)) +(let t674 (Input 674 "model.layers.21.input_layernorm.weight" (F32))) +(let t675 (Output t674 674)) +(let t676 (Input 676 "model.layers.21.post_attention_layernorm.weight" (F32))) +(let t677 (Output t676 676)) +(let t678 (Input 678 "model.layers.22.self_attn.q_proj.weight" (F32))) +(let t679 (Output t678 678)) +(let t680 (Input 680 "model.layers.22.self_attn.k_proj.weight" (F32))) +(let t681 (Output t680 680)) +(let t682 (Input 682 "model.layers.22.self_attn.v_proj.weight" (F32))) +(let t683 (Output t682 682)) +(let t684 (Input 684 "model.layers.22.self_attn.o_proj.weight" (F32))) +(let t685 (Output t684 684)) +(let t686 (Input 686 "model.layers.22.self_attn.q_norm.weight" (F32))) +(let t687 (Output t686 686)) +(let t688 (Input 688 "model.layers.22.self_attn.k_norm.weight" (F32))) +(let t689 (Output t688 688)) +(let t690 (Input 690 "model.layers.22.mlp.gate.weight" (F32))) +(let t691 (Output t690 690)) +(let t692 (Input 692 "model.layers.22.mlp.gate_up_weights" (Bf16))) +(let t693 (Output t692 692)) +(let t694 (Input 694 "model.layers.22.mlp.down_weights" (Bf16))) +(let t695 (Output t694 694)) +(let t696 (Input 696 "model.layers.22.input_layernorm.weight" (F32))) +(let t697 (Output t696 696)) +(let t698 (Input 698 "model.layers.22.post_attention_layernorm.weight" (F32))) +(let t699 (Output t698 698)) +(let t700 (Input 700 "model.layers.23.self_attn.q_proj.weight" (F32))) +(let t701 (Output t700 700)) +(let t702 (Input 702 "model.layers.23.self_attn.k_proj.weight" (F32))) +(let t703 (Output t702 702)) +(let t704 (Input 704 "model.layers.23.self_attn.v_proj.weight" (F32))) +(let t705 (Output t704 704)) +(let t706 (Input 706 "model.layers.23.self_attn.o_proj.weight" (F32))) +(let t707 (Output t706 706)) +(let t708 (Input 708 "model.layers.23.self_attn.q_norm.weight" (F32))) +(let t709 (Output t708 708)) +(let t710 (Input 710 "model.layers.23.self_attn.k_norm.weight" (F32))) +(let t711 (Output t710 710)) +(let t712 (Input 712 "model.layers.23.mlp.gate.weight" (F32))) +(let t713 (Output t712 712)) +(let t714 (Input 714 "model.layers.23.mlp.gate_up_weights" (Bf16))) +(let t715 (Output t714 714)) +(let t716 (Input 716 "model.layers.23.mlp.down_weights" (Bf16))) +(let t717 (Output t716 716)) +(let t718 (Input 718 "model.layers.23.input_layernorm.weight" (F32))) +(let t719 (Output t718 718)) +(let t720 (Input 720 "model.layers.23.post_attention_layernorm.weight" (F32))) +(let t721 (Output t720 720)) +(let t722 (Input 722 "model.layers.24.self_attn.q_proj.weight" (F32))) +(let t723 (Output t722 722)) +(let t724 (Input 724 "model.layers.24.self_attn.k_proj.weight" (F32))) +(let t725 (Output t724 724)) +(let t726 (Input 726 "model.layers.24.self_attn.v_proj.weight" (F32))) +(let t727 (Output t726 726)) +(let t728 (Input 728 "model.layers.24.self_attn.o_proj.weight" (F32))) +(let t729 (Output t728 728)) +(let t730 (Input 730 "model.layers.24.self_attn.q_norm.weight" (F32))) +(let t731 (Output t730 730)) +(let t732 (Input 732 "model.layers.24.self_attn.k_norm.weight" (F32))) +(let t733 (Output t732 732)) +(let t734 (Input 734 "model.layers.24.mlp.gate.weight" (F32))) +(let t735 (Output t734 734)) +(let t736 (Input 736 "model.layers.24.mlp.gate_up_weights" (Bf16))) +(let t737 (Output t736 736)) +(let t738 (Input 738 "model.layers.24.mlp.down_weights" (Bf16))) +(let t739 (Output t738 738)) +(let t740 (Input 740 "model.layers.24.input_layernorm.weight" (F32))) +(let t741 (Output t740 740)) +(let t742 (Input 742 "model.layers.24.post_attention_layernorm.weight" (F32))) +(let t743 (Output t742 742)) +(let t744 (Input 744 "model.layers.25.self_attn.q_proj.weight" (F32))) +(let t745 (Output t744 744)) +(let t746 (Input 746 "model.layers.25.self_attn.k_proj.weight" (F32))) +(let t747 (Output t746 746)) +(let t748 (Input 748 "model.layers.25.self_attn.v_proj.weight" (F32))) +(let t749 (Output t748 748)) +(let t750 (Input 750 "model.layers.25.self_attn.o_proj.weight" (F32))) +(let t751 (Output t750 750)) +(let t752 (Input 752 "model.layers.25.self_attn.q_norm.weight" (F32))) +(let t753 (Output t752 752)) +(let t754 (Input 754 "model.layers.25.self_attn.k_norm.weight" (F32))) +(let t755 (Output t754 754)) +(let t756 (Input 756 "model.layers.25.mlp.gate.weight" (F32))) +(let t757 (Output t756 756)) +(let t758 (Input 758 "model.layers.25.mlp.gate_up_weights" (Bf16))) +(let t759 (Output t758 758)) +(let t760 (Input 760 "model.layers.25.mlp.down_weights" (Bf16))) +(let t761 (Output t760 760)) +(let t762 (Input 762 "model.layers.25.input_layernorm.weight" (F32))) +(let t763 (Output t762 762)) +(let t764 (Input 764 "model.layers.25.post_attention_layernorm.weight" (F32))) +(let t765 (Output t764 764)) +(let t766 (Input 766 "model.layers.26.self_attn.q_proj.weight" (F32))) +(let t767 (Output t766 766)) +(let t768 (Input 768 "model.layers.26.self_attn.k_proj.weight" (F32))) +(let t769 (Output t768 768)) +(let t770 (Input 770 "model.layers.26.self_attn.v_proj.weight" (F32))) +(let t771 (Output t770 770)) +(let t772 (Input 772 "model.layers.26.self_attn.o_proj.weight" (F32))) +(let t773 (Output t772 772)) +(let t774 (Input 774 "model.layers.26.self_attn.q_norm.weight" (F32))) +(let t775 (Output t774 774)) +(let t776 (Input 776 "model.layers.26.self_attn.k_norm.weight" (F32))) +(let t777 (Output t776 776)) +(let t778 (Input 778 "model.layers.26.mlp.gate.weight" (F32))) +(let t779 (Output t778 778)) +(let t780 (Input 780 "model.layers.26.mlp.gate_up_weights" (Bf16))) +(let t781 (Output t780 780)) +(let t782 (Input 782 "model.layers.26.mlp.down_weights" (Bf16))) +(let t783 (Output t782 782)) +(let t784 (Input 784 "model.layers.26.input_layernorm.weight" (F32))) +(let t785 (Output t784 784)) +(let t786 (Input 786 "model.layers.26.post_attention_layernorm.weight" (F32))) +(let t787 (Output t786 786)) +(let t788 (Input 788 "model.layers.27.self_attn.q_proj.weight" (F32))) +(let t789 (Output t788 788)) +(let t790 (Input 790 "model.layers.27.self_attn.k_proj.weight" (F32))) +(let t791 (Output t790 790)) +(let t792 (Input 792 "model.layers.27.self_attn.v_proj.weight" (F32))) +(let t793 (Output t792 792)) +(let t794 (Input 794 "model.layers.27.self_attn.o_proj.weight" (F32))) +(let t795 (Output t794 794)) +(let t796 (Input 796 "model.layers.27.self_attn.q_norm.weight" (F32))) +(let t797 (Output t796 796)) +(let t798 (Input 798 "model.layers.27.self_attn.k_norm.weight" (F32))) +(let t799 (Output t798 798)) +(let t800 (Input 800 "model.layers.27.mlp.gate.weight" (F32))) +(let t801 (Output t800 800)) +(let t802 (Input 802 "model.layers.27.mlp.gate_up_weights" (Bf16))) +(let t803 (Output t802 802)) +(let t804 (Input 804 "model.layers.27.mlp.down_weights" (Bf16))) +(let t805 (Output t804 804)) +(let t806 (Input 806 "model.layers.27.input_layernorm.weight" (F32))) +(let t807 (Output t806 806)) +(let t808 (Input 808 "model.layers.27.post_attention_layernorm.weight" (F32))) +(let t809 (Output t808 808)) +(let t810 (Input 810 "model.layers.28.self_attn.q_proj.weight" (F32))) +(let t811 (Output t810 810)) +(let t812 (Input 812 "model.layers.28.self_attn.k_proj.weight" (F32))) +(let t813 (Output t812 812)) +(let t814 (Input 814 "model.layers.28.self_attn.v_proj.weight" (F32))) +(let t815 (Output t814 814)) +(let t816 (Input 816 "model.layers.28.self_attn.o_proj.weight" (F32))) +(let t817 (Output t816 816)) +(let t818 (Input 818 "model.layers.28.self_attn.q_norm.weight" (F32))) +(let t819 (Output t818 818)) +(let t820 (Input 820 "model.layers.28.self_attn.k_norm.weight" (F32))) +(let t821 (Output t820 820)) +(let t822 (Input 822 "model.layers.28.mlp.gate.weight" (F32))) +(let t823 (Output t822 822)) +(let t824 (Input 824 "model.layers.28.mlp.gate_up_weights" (Bf16))) +(let t825 (Output t824 824)) +(let t826 (Input 826 "model.layers.28.mlp.down_weights" (Bf16))) +(let t827 (Output t826 826)) +(let t828 (Input 828 "model.layers.28.input_layernorm.weight" (F32))) +(let t829 (Output t828 828)) +(let t830 (Input 830 "model.layers.28.post_attention_layernorm.weight" (F32))) +(let t831 (Output t830 830)) +(let t832 (Input 832 "model.layers.29.self_attn.q_proj.weight" (F32))) +(let t833 (Output t832 832)) +(let t834 (Input 834 "model.layers.29.self_attn.k_proj.weight" (F32))) +(let t835 (Output t834 834)) +(let t836 (Input 836 "model.layers.29.self_attn.v_proj.weight" (F32))) +(let t837 (Output t836 836)) +(let t838 (Input 838 "model.layers.29.self_attn.o_proj.weight" (F32))) +(let t839 (Output t838 838)) +(let t840 (Input 840 "model.layers.29.self_attn.q_norm.weight" (F32))) +(let t841 (Output t840 840)) +(let t842 (Input 842 "model.layers.29.self_attn.k_norm.weight" (F32))) +(let t843 (Output t842 842)) +(let t844 (Input 844 "model.layers.29.mlp.gate.weight" (F32))) +(let t845 (Output t844 844)) +(let t846 (Input 846 "model.layers.29.mlp.gate_up_weights" (Bf16))) +(let t847 (Output t846 846)) +(let t848 (Input 848 "model.layers.29.mlp.down_weights" (Bf16))) +(let t849 (Output t848 848)) +(let t850 (Input 850 "model.layers.29.input_layernorm.weight" (F32))) +(let t851 (Output t850 850)) +(let t852 (Input 852 "model.layers.29.post_attention_layernorm.weight" (F32))) +(let t853 (Output t852 852)) +(let t854 (Input 854 "model.layers.30.self_attn.q_proj.weight" (F32))) +(let t855 (Output t854 854)) +(let t856 (Input 856 "model.layers.30.self_attn.k_proj.weight" (F32))) +(let t857 (Output t856 856)) +(let t858 (Input 858 "model.layers.30.self_attn.v_proj.weight" (F32))) +(let t859 (Output t858 858)) +(let t860 (Input 860 "model.layers.30.self_attn.o_proj.weight" (F32))) +(let t861 (Output t860 860)) +(let t862 (Input 862 "model.layers.30.self_attn.q_norm.weight" (F32))) +(let t863 (Output t862 862)) +(let t864 (Input 864 "model.layers.30.self_attn.k_norm.weight" (F32))) +(let t865 (Output t864 864)) +(let t866 (Input 866 "model.layers.30.mlp.gate.weight" (F32))) +(let t867 (Output t866 866)) +(let t868 (Input 868 "model.layers.30.mlp.gate_up_weights" (Bf16))) +(let t869 (Output t868 868)) +(let t870 (Input 870 "model.layers.30.mlp.down_weights" (Bf16))) +(let t871 (Output t870 870)) +(let t872 (Input 872 "model.layers.30.input_layernorm.weight" (F32))) +(let t873 (Output t872 872)) +(let t874 (Input 874 "model.layers.30.post_attention_layernorm.weight" (F32))) +(let t875 (Output t874 874)) +(let t876 (Input 876 "model.layers.31.self_attn.q_proj.weight" (F32))) +(let t877 (Output t876 876)) +(let t878 (Input 878 "model.layers.31.self_attn.k_proj.weight" (F32))) +(let t879 (Output t878 878)) +(let t880 (Input 880 "model.layers.31.self_attn.v_proj.weight" (F32))) +(let t881 (Output t880 880)) +(let t882 (Input 882 "model.layers.31.self_attn.o_proj.weight" (F32))) +(let t883 (Output t882 882)) +(let t884 (Input 884 "model.layers.31.self_attn.q_norm.weight" (F32))) +(let t885 (Output t884 884)) +(let t886 (Input 886 "model.layers.31.self_attn.k_norm.weight" (F32))) +(let t887 (Output t886 886)) +(let t888 (Input 888 "model.layers.31.mlp.gate.weight" (F32))) +(let t889 (Output t888 888)) +(let t890 (Input 890 "model.layers.31.mlp.gate_up_weights" (Bf16))) +(let t891 (Output t890 890)) +(let t892 (Input 892 "model.layers.31.mlp.down_weights" (Bf16))) +(let t893 (Output t892 892)) +(let t894 (Input 894 "model.layers.31.input_layernorm.weight" (F32))) +(let t895 (Output t894 894)) +(let t896 (Input 896 "model.layers.31.post_attention_layernorm.weight" (F32))) +(let t897 (Output t896 896)) +(let t898 (Input 898 "model.layers.32.self_attn.q_proj.weight" (F32))) +(let t899 (Output t898 898)) +(let t900 (Input 900 "model.layers.32.self_attn.k_proj.weight" (F32))) +(let t901 (Output t900 900)) +(let t902 (Input 902 "model.layers.32.self_attn.v_proj.weight" (F32))) +(let t903 (Output t902 902)) +(let t904 (Input 904 "model.layers.32.self_attn.o_proj.weight" (F32))) +(let t905 (Output t904 904)) +(let t906 (Input 906 "model.layers.32.self_attn.q_norm.weight" (F32))) +(let t907 (Output t906 906)) +(let t908 (Input 908 "model.layers.32.self_attn.k_norm.weight" (F32))) +(let t909 (Output t908 908)) +(let t910 (Input 910 "model.layers.32.mlp.gate.weight" (F32))) +(let t911 (Output t910 910)) +(let t912 (Input 912 "model.layers.32.mlp.gate_up_weights" (Bf16))) +(let t913 (Output t912 912)) +(let t914 (Input 914 "model.layers.32.mlp.down_weights" (Bf16))) +(let t915 (Output t914 914)) +(let t916 (Input 916 "model.layers.32.input_layernorm.weight" (F32))) +(let t917 (Output t916 916)) +(let t918 (Input 918 "model.layers.32.post_attention_layernorm.weight" (F32))) +(let t919 (Output t918 918)) +(let t920 (Input 920 "model.layers.33.self_attn.q_proj.weight" (F32))) +(let t921 (Output t920 920)) +(let t922 (Input 922 "model.layers.33.self_attn.k_proj.weight" (F32))) +(let t923 (Output t922 922)) +(let t924 (Input 924 "model.layers.33.self_attn.v_proj.weight" (F32))) +(let t925 (Output t924 924)) +(let t926 (Input 926 "model.layers.33.self_attn.o_proj.weight" (F32))) +(let t927 (Output t926 926)) +(let t928 (Input 928 "model.layers.33.self_attn.q_norm.weight" (F32))) +(let t929 (Output t928 928)) +(let t930 (Input 930 "model.layers.33.self_attn.k_norm.weight" (F32))) +(let t931 (Output t930 930)) +(let t932 (Input 932 "model.layers.33.mlp.gate.weight" (F32))) +(let t933 (Output t932 932)) +(let t934 (Input 934 "model.layers.33.mlp.gate_up_weights" (Bf16))) +(let t935 (Output t934 934)) +(let t936 (Input 936 "model.layers.33.mlp.down_weights" (Bf16))) +(let t937 (Output t936 936)) +(let t938 (Input 938 "model.layers.33.input_layernorm.weight" (F32))) +(let t939 (Output t938 938)) +(let t940 (Input 940 "model.layers.33.post_attention_layernorm.weight" (F32))) +(let t941 (Output t940 940)) +(let t942 (Input 942 "model.layers.34.self_attn.q_proj.weight" (F32))) +(let t943 (Output t942 942)) +(let t944 (Input 944 "model.layers.34.self_attn.k_proj.weight" (F32))) +(let t945 (Output t944 944)) +(let t946 (Input 946 "model.layers.34.self_attn.v_proj.weight" (F32))) +(let t947 (Output t946 946)) +(let t948 (Input 948 "model.layers.34.self_attn.o_proj.weight" (F32))) +(let t949 (Output t948 948)) +(let t950 (Input 950 "model.layers.34.self_attn.q_norm.weight" (F32))) +(let t951 (Output t950 950)) +(let t952 (Input 952 "model.layers.34.self_attn.k_norm.weight" (F32))) +(let t953 (Output t952 952)) +(let t954 (Input 954 "model.layers.34.mlp.gate.weight" (F32))) +(let t955 (Output t954 954)) +(let t956 (Input 956 "model.layers.34.mlp.gate_up_weights" (Bf16))) +(let t957 (Output t956 956)) +(let t958 (Input 958 "model.layers.34.mlp.down_weights" (Bf16))) +(let t959 (Output t958 958)) +(let t960 (Input 960 "model.layers.34.input_layernorm.weight" (F32))) +(let t961 (Output t960 960)) +(let t962 (Input 962 "model.layers.34.post_attention_layernorm.weight" (F32))) +(let t963 (Output t962 962)) +(let t964 (Input 964 "model.layers.35.self_attn.q_proj.weight" (F32))) +(let t965 (Output t964 964)) +(let t966 (Input 966 "model.layers.35.self_attn.k_proj.weight" (F32))) +(let t967 (Output t966 966)) +(let t968 (Input 968 "model.layers.35.self_attn.v_proj.weight" (F32))) +(let t969 (Output t968 968)) +(let t970 (Input 970 "model.layers.35.self_attn.o_proj.weight" (F32))) +(let t971 (Output t970 970)) +(let t972 (Input 972 "model.layers.35.self_attn.q_norm.weight" (F32))) +(let t973 (Output t972 972)) +(let t974 (Input 974 "model.layers.35.self_attn.k_norm.weight" (F32))) +(let t975 (Output t974 974)) +(let t976 (Input 976 "model.layers.35.mlp.gate.weight" (F32))) +(let t977 (Output t976 976)) +(let t978 (Input 978 "model.layers.35.mlp.gate_up_weights" (Bf16))) +(let t979 (Output t978 978)) +(let t980 (Input 980 "model.layers.35.mlp.down_weights" (Bf16))) +(let t981 (Output t980 980)) +(let t982 (Input 982 "model.layers.35.input_layernorm.weight" (F32))) +(let t983 (Output t982 982)) +(let t984 (Input 984 "model.layers.35.post_attention_layernorm.weight" (F32))) +(let t985 (Output t984 984)) +(let t986 (Input 986 "model.layers.36.self_attn.q_proj.weight" (F32))) +(let t987 (Output t986 986)) +(let t988 (Input 988 "model.layers.36.self_attn.k_proj.weight" (F32))) +(let t989 (Output t988 988)) +(let t990 (Input 990 "model.layers.36.self_attn.v_proj.weight" (F32))) +(let t991 (Output t990 990)) +(let t992 (Input 992 "model.layers.36.self_attn.o_proj.weight" (F32))) +(let t993 (Output t992 992)) +(let t994 (Input 994 "model.layers.36.self_attn.q_norm.weight" (F32))) +(let t995 (Output t994 994)) +(let t996 (Input 996 "model.layers.36.self_attn.k_norm.weight" (F32))) +(let t997 (Output t996 996)) +(let t998 (Input 998 "model.layers.36.mlp.gate.weight" (F32))) +(let t999 (Output t998 998)) +(let t1000 (Input 1000 "model.layers.36.mlp.gate_up_weights" (Bf16))) +(let t1001 (Output t1000 1000)) +(let t1002 (Input 1002 "model.layers.36.mlp.down_weights" (Bf16))) +(let t1003 (Output t1002 1002)) +(let t1004 (Input 1004 "model.layers.36.input_layernorm.weight" (F32))) +(let t1005 (Output t1004 1004)) +(let t1006 (Input 1006 "model.layers.36.post_attention_layernorm.weight" (F32))) +(let t1007 (Output t1006 1006)) +(let t1008 (Input 1008 "model.layers.37.self_attn.q_proj.weight" (F32))) +(let t1009 (Output t1008 1008)) +(let t1010 (Input 1010 "model.layers.37.self_attn.k_proj.weight" (F32))) +(let t1011 (Output t1010 1010)) +(let t1012 (Input 1012 "model.layers.37.self_attn.v_proj.weight" (F32))) +(let t1013 (Output t1012 1012)) +(let t1014 (Input 1014 "model.layers.37.self_attn.o_proj.weight" (F32))) +(let t1015 (Output t1014 1014)) +(let t1016 (Input 1016 "model.layers.37.self_attn.q_norm.weight" (F32))) +(let t1017 (Output t1016 1016)) +(let t1018 (Input 1018 "model.layers.37.self_attn.k_norm.weight" (F32))) +(let t1019 (Output t1018 1018)) +(let t1020 (Input 1020 "model.layers.37.mlp.gate.weight" (F32))) +(let t1021 (Output t1020 1020)) +(let t1022 (Input 1022 "model.layers.37.mlp.gate_up_weights" (Bf16))) +(let t1023 (Output t1022 1022)) +(let t1024 (Input 1024 "model.layers.37.mlp.down_weights" (Bf16))) +(let t1025 (Output t1024 1024)) +(let t1026 (Input 1026 "model.layers.37.input_layernorm.weight" (F32))) +(let t1027 (Output t1026 1026)) +(let t1028 (Input 1028 "model.layers.37.post_attention_layernorm.weight" (F32))) +(let t1029 (Output t1028 1028)) +(let t1030 (Input 1030 "model.layers.38.self_attn.q_proj.weight" (F32))) +(let t1031 (Output t1030 1030)) +(let t1032 (Input 1032 "model.layers.38.self_attn.k_proj.weight" (F32))) +(let t1033 (Output t1032 1032)) +(let t1034 (Input 1034 "model.layers.38.self_attn.v_proj.weight" (F32))) +(let t1035 (Output t1034 1034)) +(let t1036 (Input 1036 "model.layers.38.self_attn.o_proj.weight" (F32))) +(let t1037 (Output t1036 1036)) +(let t1038 (Input 1038 "model.layers.38.self_attn.q_norm.weight" (F32))) +(let t1039 (Output t1038 1038)) +(let t1040 (Input 1040 "model.layers.38.self_attn.k_norm.weight" (F32))) +(let t1041 (Output t1040 1040)) +(let t1042 (Input 1042 "model.layers.38.mlp.gate.weight" (F32))) +(let t1043 (Output t1042 1042)) +(let t1044 (Input 1044 "model.layers.38.mlp.gate_up_weights" (Bf16))) +(let t1045 (Output t1044 1044)) +(let t1046 (Input 1046 "model.layers.38.mlp.down_weights" (Bf16))) +(let t1047 (Output t1046 1046)) +(let t1048 (Input 1048 "model.layers.38.input_layernorm.weight" (F32))) +(let t1049 (Output t1048 1048)) +(let t1050 (Input 1050 "model.layers.38.post_attention_layernorm.weight" (F32))) +(let t1051 (Output t1050 1050)) +(let t1052 (Input 1052 "model.layers.39.self_attn.q_proj.weight" (F32))) +(let t1053 (Output t1052 1052)) +(let t1054 (Input 1054 "model.layers.39.self_attn.k_proj.weight" (F32))) +(let t1055 (Output t1054 1054)) +(let t1056 (Input 1056 "model.layers.39.self_attn.v_proj.weight" (F32))) +(let t1057 (Output t1056 1056)) +(let t1058 (Input 1058 "model.layers.39.self_attn.o_proj.weight" (F32))) +(let t1059 (Output t1058 1058)) +(let t1060 (Input 1060 "model.layers.39.self_attn.q_norm.weight" (F32))) +(let t1061 (Output t1060 1060)) +(let t1062 (Input 1062 "model.layers.39.self_attn.k_norm.weight" (F32))) +(let t1063 (Output t1062 1062)) +(let t1064 (Input 1064 "model.layers.39.mlp.gate.weight" (F32))) +(let t1065 (Output t1064 1064)) +(let t1066 (Input 1066 "model.layers.39.mlp.gate_up_weights" (Bf16))) +(let t1067 (Output t1066 1066)) +(let t1068 (Input 1068 "model.layers.39.mlp.down_weights" (Bf16))) +(let t1069 (Output t1068 1068)) +(let t1070 (Input 1070 "model.layers.39.input_layernorm.weight" (F32))) +(let t1071 (Output t1070 1070)) +(let t1072 (Input 1072 "model.layers.39.post_attention_layernorm.weight" (F32))) +(let t1073 (Output t1072 1072)) +(let t1074 (Input 1074 "model.layers.40.self_attn.q_proj.weight" (F32))) +(let t1075 (Output t1074 1074)) +(let t1076 (Input 1076 "model.layers.40.self_attn.k_proj.weight" (F32))) +(let t1077 (Output t1076 1076)) +(let t1078 (Input 1078 "model.layers.40.self_attn.v_proj.weight" (F32))) +(let t1079 (Output t1078 1078)) +(let t1080 (Input 1080 "model.layers.40.self_attn.o_proj.weight" (F32))) +(let t1081 (Output t1080 1080)) +(let t1082 (Input 1082 "model.layers.40.self_attn.q_norm.weight" (F32))) +(let t1083 (Output t1082 1082)) +(let t1084 (Input 1084 "model.layers.40.self_attn.k_norm.weight" (F32))) +(let t1085 (Output t1084 1084)) +(let t1086 (Input 1086 "model.layers.40.mlp.gate.weight" (F32))) +(let t1087 (Output t1086 1086)) +(let t1088 (Input 1088 "model.layers.40.mlp.gate_up_weights" (Bf16))) +(let t1089 (Output t1088 1088)) +(let t1090 (Input 1090 "model.layers.40.mlp.down_weights" (Bf16))) +(let t1091 (Output t1090 1090)) +(let t1092 (Input 1092 "model.layers.40.input_layernorm.weight" (F32))) +(let t1093 (Output t1092 1092)) +(let t1094 (Input 1094 "model.layers.40.post_attention_layernorm.weight" (F32))) +(let t1095 (Output t1094 1094)) +(let t1096 (Input 1096 "model.layers.41.self_attn.q_proj.weight" (F32))) +(let t1097 (Output t1096 1096)) +(let t1098 (Input 1098 "model.layers.41.self_attn.k_proj.weight" (F32))) +(let t1099 (Output t1098 1098)) +(let t1100 (Input 1100 "model.layers.41.self_attn.v_proj.weight" (F32))) +(let t1101 (Output t1100 1100)) +(let t1102 (Input 1102 "model.layers.41.self_attn.o_proj.weight" (F32))) +(let t1103 (Output t1102 1102)) +(let t1104 (Input 1104 "model.layers.41.self_attn.q_norm.weight" (F32))) +(let t1105 (Output t1104 1104)) +(let t1106 (Input 1106 "model.layers.41.self_attn.k_norm.weight" (F32))) +(let t1107 (Output t1106 1106)) +(let t1108 (Input 1108 "model.layers.41.mlp.gate.weight" (F32))) +(let t1109 (Output t1108 1108)) +(let t1110 (Input 1110 "model.layers.41.mlp.gate_up_weights" (Bf16))) +(let t1111 (Output t1110 1110)) +(let t1112 (Input 1112 "model.layers.41.mlp.down_weights" (Bf16))) +(let t1113 (Output t1112 1112)) +(let t1114 (Input 1114 "model.layers.41.input_layernorm.weight" (F32))) +(let t1115 (Output t1114 1114)) +(let t1116 (Input 1116 "model.layers.41.post_attention_layernorm.weight" (F32))) +(let t1117 (Output t1116 1116)) +(let t1118 (Input 1118 "model.layers.42.self_attn.q_proj.weight" (F32))) +(let t1119 (Output t1118 1118)) +(let t1120 (Input 1120 "model.layers.42.self_attn.k_proj.weight" (F32))) +(let t1121 (Output t1120 1120)) +(let t1122 (Input 1122 "model.layers.42.self_attn.v_proj.weight" (F32))) +(let t1123 (Output t1122 1122)) +(let t1124 (Input 1124 "model.layers.42.self_attn.o_proj.weight" (F32))) +(let t1125 (Output t1124 1124)) +(let t1126 (Input 1126 "model.layers.42.self_attn.q_norm.weight" (F32))) +(let t1127 (Output t1126 1126)) +(let t1128 (Input 1128 "model.layers.42.self_attn.k_norm.weight" (F32))) +(let t1129 (Output t1128 1128)) +(let t1130 (Input 1130 "model.layers.42.mlp.gate.weight" (F32))) +(let t1131 (Output t1130 1130)) +(let t1132 (Input 1132 "model.layers.42.mlp.gate_up_weights" (Bf16))) +(let t1133 (Output t1132 1132)) +(let t1134 (Input 1134 "model.layers.42.mlp.down_weights" (Bf16))) +(let t1135 (Output t1134 1134)) +(let t1136 (Input 1136 "model.layers.42.input_layernorm.weight" (F32))) +(let t1137 (Output t1136 1136)) +(let t1138 (Input 1138 "model.layers.42.post_attention_layernorm.weight" (F32))) +(let t1139 (Output t1138 1138)) +(let t1140 (Input 1140 "model.layers.43.self_attn.q_proj.weight" (F32))) +(let t1141 (Output t1140 1140)) +(let t1142 (Input 1142 "model.layers.43.self_attn.k_proj.weight" (F32))) +(let t1143 (Output t1142 1142)) +(let t1144 (Input 1144 "model.layers.43.self_attn.v_proj.weight" (F32))) +(let t1145 (Output t1144 1144)) +(let t1146 (Input 1146 "model.layers.43.self_attn.o_proj.weight" (F32))) +(let t1147 (Output t1146 1146)) +(let t1148 (Input 1148 "model.layers.43.self_attn.q_norm.weight" (F32))) +(let t1149 (Output t1148 1148)) +(let t1150 (Input 1150 "model.layers.43.self_attn.k_norm.weight" (F32))) +(let t1151 (Output t1150 1150)) +(let t1152 (Input 1152 "model.layers.43.mlp.gate.weight" (F32))) +(let t1153 (Output t1152 1152)) +(let t1154 (Input 1154 "model.layers.43.mlp.gate_up_weights" (Bf16))) +(let t1155 (Output t1154 1154)) +(let t1156 (Input 1156 "model.layers.43.mlp.down_weights" (Bf16))) +(let t1157 (Output t1156 1156)) +(let t1158 (Input 1158 "model.layers.43.input_layernorm.weight" (F32))) +(let t1159 (Output t1158 1158)) +(let t1160 (Input 1160 "model.layers.43.post_attention_layernorm.weight" (F32))) +(let t1161 (Output t1160 1160)) +(let t1162 (Input 1162 "model.layers.44.self_attn.q_proj.weight" (F32))) +(let t1163 (Output t1162 1162)) +(let t1164 (Input 1164 "model.layers.44.self_attn.k_proj.weight" (F32))) +(let t1165 (Output t1164 1164)) +(let t1166 (Input 1166 "model.layers.44.self_attn.v_proj.weight" (F32))) +(let t1167 (Output t1166 1166)) +(let t1168 (Input 1168 "model.layers.44.self_attn.o_proj.weight" (F32))) +(let t1169 (Output t1168 1168)) +(let t1170 (Input 1170 "model.layers.44.self_attn.q_norm.weight" (F32))) +(let t1171 (Output t1170 1170)) +(let t1172 (Input 1172 "model.layers.44.self_attn.k_norm.weight" (F32))) +(let t1173 (Output t1172 1172)) +(let t1174 (Input 1174 "model.layers.44.mlp.gate.weight" (F32))) +(let t1175 (Output t1174 1174)) +(let t1176 (Input 1176 "model.layers.44.mlp.gate_up_weights" (Bf16))) +(let t1177 (Output t1176 1176)) +(let t1178 (Input 1178 "model.layers.44.mlp.down_weights" (Bf16))) +(let t1179 (Output t1178 1178)) +(let t1180 (Input 1180 "model.layers.44.input_layernorm.weight" (F32))) +(let t1181 (Output t1180 1180)) +(let t1182 (Input 1182 "model.layers.44.post_attention_layernorm.weight" (F32))) +(let t1183 (Output t1182 1182)) +(let t1184 (Input 1184 "model.layers.45.self_attn.q_proj.weight" (F32))) +(let t1185 (Output t1184 1184)) +(let t1186 (Input 1186 "model.layers.45.self_attn.k_proj.weight" (F32))) +(let t1187 (Output t1186 1186)) +(let t1188 (Input 1188 "model.layers.45.self_attn.v_proj.weight" (F32))) +(let t1189 (Output t1188 1188)) +(let t1190 (Input 1190 "model.layers.45.self_attn.o_proj.weight" (F32))) +(let t1191 (Output t1190 1190)) +(let t1192 (Input 1192 "model.layers.45.self_attn.q_norm.weight" (F32))) +(let t1193 (Output t1192 1192)) +(let t1194 (Input 1194 "model.layers.45.self_attn.k_norm.weight" (F32))) +(let t1195 (Output t1194 1194)) +(let t1196 (Input 1196 "model.layers.45.mlp.gate.weight" (F32))) +(let t1197 (Output t1196 1196)) +(let t1198 (Input 1198 "model.layers.45.mlp.gate_up_weights" (Bf16))) +(let t1199 (Output t1198 1198)) +(let t1200 (Input 1200 "model.layers.45.mlp.down_weights" (Bf16))) +(let t1201 (Output t1200 1200)) +(let t1202 (Input 1202 "model.layers.45.input_layernorm.weight" (F32))) +(let t1203 (Output t1202 1202)) +(let t1204 (Input 1204 "model.layers.45.post_attention_layernorm.weight" (F32))) +(let t1205 (Output t1204 1204)) +(let t1206 (Input 1206 "model.layers.46.self_attn.q_proj.weight" (F32))) +(let t1207 (Output t1206 1206)) +(let t1208 (Input 1208 "model.layers.46.self_attn.k_proj.weight" (F32))) +(let t1209 (Output t1208 1208)) +(let t1210 (Input 1210 "model.layers.46.self_attn.v_proj.weight" (F32))) +(let t1211 (Output t1210 1210)) +(let t1212 (Input 1212 "model.layers.46.self_attn.o_proj.weight" (F32))) +(let t1213 (Output t1212 1212)) +(let t1214 (Input 1214 "model.layers.46.self_attn.q_norm.weight" (F32))) +(let t1215 (Output t1214 1214)) +(let t1216 (Input 1216 "model.layers.46.self_attn.k_norm.weight" (F32))) +(let t1217 (Output t1216 1216)) +(let t1218 (Input 1218 "model.layers.46.mlp.gate.weight" (F32))) +(let t1219 (Output t1218 1218)) +(let t1220 (Input 1220 "model.layers.46.mlp.gate_up_weights" (Bf16))) +(let t1221 (Output t1220 1220)) +(let t1222 (Input 1222 "model.layers.46.mlp.down_weights" (Bf16))) +(let t1223 (Output t1222 1222)) +(let t1224 (Input 1224 "model.layers.46.input_layernorm.weight" (F32))) +(let t1225 (Output t1224 1224)) +(let t1226 (Input 1226 "model.layers.46.post_attention_layernorm.weight" (F32))) +(let t1227 (Output t1226 1226)) +(let t1228 (Input 1228 "model.layers.47.self_attn.q_proj.weight" (F32))) +(let t1229 (Output t1228 1228)) +(let t1230 (Input 1230 "model.layers.47.self_attn.k_proj.weight" (F32))) +(let t1231 (Output t1230 1230)) +(let t1232 (Input 1232 "model.layers.47.self_attn.v_proj.weight" (F32))) +(let t1233 (Output t1232 1232)) +(let t1234 (Input 1234 "model.layers.47.self_attn.o_proj.weight" (F32))) +(let t1235 (Output t1234 1234)) +(let t1236 (Input 1236 "model.layers.47.self_attn.q_norm.weight" (F32))) +(let t1237 (Output t1236 1236)) +(let t1238 (Input 1238 "model.layers.47.self_attn.k_norm.weight" (F32))) +(let t1239 (Output t1238 1238)) +(let t1240 (Input 1240 "model.layers.47.mlp.gate.weight" (F32))) +(let t1241 (Output t1240 1240)) +(let t1242 (Input 1242 "model.layers.47.mlp.gate_up_weights" (Bf16))) +(let t1243 (Output t1242 1242)) +(let t1244 (Input 1244 "model.layers.47.mlp.down_weights" (Bf16))) +(let t1245 (Output t1244 1244)) +(let t1246 (Input 1246 "model.layers.47.input_layernorm.weight" (F32))) +(let t1247 (Output t1246 1246)) +(let t1248 (Input 1248 "model.layers.47.post_attention_layernorm.weight" (F32))) +(let t1249 (Output t1248 1248)) +(let t1250 (Input 1250 "model.norm.weight" (F32))) +(let t1251 (Output t1250 1250)) +(let t1252 (Input 1252 "model.embed_tokens.weight" (F32))) +(let t1253 (Output t1252 1252)) +(let t1254 (Input 1254 "lm_head.weight" (F32))) +(let t1255 (Output t1254 1254)) +(let t1256 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1257 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t0 (ICons t1256 (INil))))) +(let t1258 (Op (Iota (MIter) (MNum 2048)) (INil))) +(let t1259 (Op (Add (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1257 (ICons t1258 (INil))))) +(let t1260 (Op (Gather (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 151936) (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1259 (ICons t1252 (INil))))) +(let t1261 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1262 (Op (Cast (MNum 1) (F32)) (ICons t1261 (INil)))) +(let t1263 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1262 (INil)))) +(let t1264 (Op (Constant 0.000001) (INil))) +(let t1265 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1266 (Op (Cast (MNum 1) (F32)) (ICons t1265 (INil)))) +(let t1267 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1266 (INil)))) +(let t1268 (Op (Constant 0.000001) (INil))) +(let t1269 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1270 (Op (Cast (MNum 1) (F32)) (ICons t1269 (INil)))) +(let t1271 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1270 (INil)))) +(let t1272 (Op (Constant 0.000001) (INil))) +(let t1273 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1274 (Op (Cast (MNum 64) (F32)) (ICons t1273 (INil)))) +(let t1275 (Op (Constant 0.007812) (INil))) +(let t1276 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1274 (ICons t1275 (INil))))) +(let t1277 (Op (Constant 13.815511) (INil))) +(let t1278 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1276 (ICons t1277 (INil))))) +(let t1279 (Op (Constant 1.442695) (INil))) +(let t1280 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1278 (ICons t1279 (INil))))) +(let t1281 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1280 (INil)))) +(let t1282 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1281 (INil)))) +(let t1283 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1284 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1283 (ICons t1282 (INil))))) +(let t1285 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1284 (INil)))) +(let t1286 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t1287 (Op (Constant -1.000000) (INil))) +(let t1288 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1285 (ICons t1287 (INil))))) +(let t1289 (Op (Constant 1.570796) (INil))) +(let t1290 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1288 (ICons t1289 (INil))))) +(let t1291 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1290 (INil)))) +(let t1292 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1285 (INil)))) +(let t1293 (Op (Constant -1.000000) (INil))) +(let t1294 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1295 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1296 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1295 (INil)))) +(let t1297 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1298 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1299 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1298 (INil)))) +(let t1300 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1301 (Op (Cast (MNum 64) (F32)) (ICons t1300 (INil)))) +(let t1302 (Op (Constant 0.007812) (INil))) +(let t1303 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1301 (ICons t1302 (INil))))) +(let t1304 (Op (Constant 13.815511) (INil))) +(let t1305 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1303 (ICons t1304 (INil))))) +(let t1306 (Op (Constant 1.442695) (INil))) +(let t1307 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1305 (ICons t1306 (INil))))) +(let t1308 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1307 (INil)))) +(let t1309 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1308 (INil)))) +(let t1310 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1311 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1310 (ICons t1309 (INil))))) +(let t1312 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1311 (INil)))) +(let t1313 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 64))) (INil))) +(let t1314 (Op (Constant -1.000000) (INil))) +(let t1315 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1312 (ICons t1314 (INil))))) +(let t1316 (Op (Constant 1.570796) (INil))) +(let t1317 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1315 (ICons t1316 (INil))))) +(let t1318 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1317 (INil)))) +(let t1319 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1312 (INil)))) +(let t1320 (Op (Constant -1.000000) (INil))) +(let t1321 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1322 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1323 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1322 (INil)))) +(let t1324 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1325 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1326 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1325 (INil)))) +(let t1327 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1328 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t1329 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1327 (ICons t1328 (INil))))) +(let t1330 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1331 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1332 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1330 (ICons t1331 (INil))))) +(let t1333 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1334 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1332 (ICons t1333 (INil))))) +(let t1335 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1336 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1329 (ICons t1334 (INil))))) +(let t1337 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1336 (ICons t1335 (INil))))) +(let t1338 (Op (Constant 0.088388) (INil))) +(let t1339 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1340 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1339 (INil)))) +(let t1341 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1342 (Op (Cast (MNum 1) (F32)) (ICons t1341 (INil)))) +(let t1343 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1340 (ICons t1342 (INil))))) +(let t1344 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1345 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1344 (INil)))) +(let t1346 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1343 (ICons t1345 (INil))))) +(let t1347 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1346 (INil)))) +(let t1348 (Op (Constant -10000000000.000000) (INil))) +(let t1349 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1347 (ICons t1348 (INil))))) +(let t1350 (Op (Constant -1.000000) (INil))) +(let t1351 (Op (Constant 1.442695) (INil))) +(let t1352 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1353 (Op (Cast (MNum 1) (F32)) (ICons t1352 (INil)))) +(let t1354 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1353 (INil)))) +(let t1355 (Op (Constant 0.000001) (INil))) +(let t1356 (Op (Constant -1.000000) (INil))) +(let t1357 (Op (Constant 1.442695) (INil))) +(let t1358 (Op (Constant 0.000000) (INil))) +(let t1359 (Op (Constant 0.000000) (INil))) +(let t1360 (Op (Constant 0.000000) (INil))) +(let t1361 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1362 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t1363 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t1364 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t1365 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t1366 (Op (Iota (MNum 3145728) (MNum 1)) (INil))) +(let t1367 (Op (Iota (MIter) (MNum 3145728)) (INil))) +(let t1368 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 768)) (MNum 768)) (MMul (MMod (MDiv (MIter) (MNum 768)) (MNum 8)) (MNum 1536))) (MMul (MDiv (MIter) (MNum 6144)) (MNum 12288))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 768))) (INil))) +(let t1369 (Op (Constant -1.000000) (INil))) +(let t1370 (Op (Constant 1.442695) (INil))) +(let t1371 (Op (Constant 1.000000) (INil))) +(let t1372 (Op (Iota (MNum 1572864) (MNum 1)) (INil))) +(let t1373 (Op (Iota (MIter) (MNum 1572864)) (INil))) +(let t1374 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1375 (Op (Cast (MNum 1) (F32)) (ICons t1374 (INil)))) +(let t1376 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1375 (INil)))) +(let t1377 (Op (Constant 0.000001) (INil))) +(let t1378 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1379 (Op (Cast (MNum 1) (F32)) (ICons t1378 (INil)))) +(let t1380 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1379 (INil)))) +(let t1381 (Op (Constant 0.000001) (INil))) +(let t1382 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1383 (Op (Cast (MNum 1) (F32)) (ICons t1382 (INil)))) +(let t1384 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1383 (INil)))) +(let t1385 (Op (Constant 0.000001) (INil))) +(let t1386 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1387 (Op (Cast (MNum 64) (F32)) (ICons t1386 (INil)))) +(let t1388 (Op (Constant 0.007812) (INil))) +(let t1389 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1387 (ICons t1388 (INil))))) +(let t1390 (Op (Constant 13.815511) (INil))) +(let t1391 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1389 (ICons t1390 (INil))))) +(let t1392 (Op (Constant 1.442695) (INil))) +(let t1393 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1391 (ICons t1392 (INil))))) +(let t1394 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1393 (INil)))) +(let t1395 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1394 (INil)))) +(let t1396 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1397 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1396 (ICons t1395 (INil))))) +(let t1398 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1397 (INil)))) +(let t1399 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 64))) (INil))) +(let t1400 (Op (Constant -1.000000) (INil))) +(let t1401 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1398 (ICons t1400 (INil))))) +(let t1402 (Op (Constant 1.570796) (INil))) +(let t1403 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1401 (ICons t1402 (INil))))) +(let t1404 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1403 (INil)))) +(let t1405 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1398 (INil)))) +(let t1406 (Op (Constant -1.000000) (INil))) +(let t1407 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1408 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1409 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1408 (INil)))) +(let t1410 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1411 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 32) (MVar "s")) (MNum 128))) (INil))) +(let t1412 (Op (Cast (MMax (MMul (MMul (MNum 32) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1411 (INil)))) +(let t1413 (Op (Iota (MMul (MIter) (MNum 2)) (MNum 64)) (INil))) +(let t1414 (Op (Cast (MNum 64) (F32)) (ICons t1413 (INil)))) +(let t1415 (Op (Constant 0.007812) (INil))) +(let t1416 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1414 (ICons t1415 (INil))))) +(let t1417 (Op (Constant 13.815511) (INil))) +(let t1418 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1416 (ICons t1417 (INil))))) +(let t1419 (Op (Constant 1.442695) (INil))) +(let t1420 (Op (Mul (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1418 (ICons t1419 (INil))))) +(let t1421 (Op (Exp2 (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1420 (INil)))) +(let t1422 (Op (Recip (ECons (MNum 64) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1421 (INil)))) +(let t1423 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1 (INil)))) +(let t1424 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ECons (MNum 1) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ECons (MIter) (ENil))))) (ICons t1423 (ICons t1422 (INil))))) +(let t1425 (Op (Sum (ECons (MVar "s") (ECons (MNum 64) (ENil))) (MNum 1) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1424 (INil)))) +(let t1426 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 64)) (MNum 64)) (MMul (MMod (MDiv (MIter) (MNum 64)) (MVar "s")) (MNum 128))) (MMul (MDiv (MIter) (MMul (MNum 64) (MVar "s"))) (MMul (MNum 128) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 64))) (INil))) +(let t1427 (Op (Constant -1.000000) (INil))) +(let t1428 (Op (Mul (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1425 (ICons t1427 (INil))))) +(let t1429 (Op (Constant 1.570796) (INil))) +(let t1430 (Op (Add (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1428 (ICons t1429 (INil))))) +(let t1431 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1430 (INil)))) +(let t1432 (Op (Sin (ECons (MVar "s") (ECons (MNum 64) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ICons t1425 (INil)))) +(let t1433 (Op (Constant -1.000000) (INil))) +(let t1434 (Op (Iota (MAdd (MAdd (MMin (MMod (MIter) (MNum 128)) (MNum 63)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1435 (Op (Iota (MLt (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1436 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1435 (INil)))) +(let t1437 (Op (Iota (MAdd (MAdd (MMax (MSub (MMod (MIter) (MNum 128)) (MNum 64)) (MNum 0)) (MMul (MMod (MDiv (MIter) (MNum 128)) (MVar "s")) (MNum 64))) (MMul (MDiv (MIter) (MMul (MNum 128) (MVar "s"))) (MMul (MNum 64) (MVar "s")))) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1438 (Op (Iota (MGte (MMod (MIter) (MNum 128)) (MNum 64)) (MMul (MMul (MNum 4) (MVar "s")) (MNum 128))) (INil))) +(let t1439 (Op (Cast (MMax (MMul (MMul (MNum 4) (MVar "s")) (MNum 128)) (MNum 1)) (F32)) (ICons t1438 (INil)))) +(let t1440 (Op (Iota (MIter) (MNum 4)) (INil))) +(let t1441 (Op (Iota (MNum 524288) (MNum 1)) (INil))) +(let t1442 (Op (Mul (ECons (MNum 4) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1440 (ICons t1441 (INil))))) +(let t1443 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1444 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1445 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1443 (ICons t1444 (INil))))) +(let t1446 (Op (Iota (MNum 128) (MNum 1)) (INil))) +(let t1447 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1445 (ICons t1446 (INil))))) +(let t1448 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1449 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1442 (ICons t1447 (INil))))) +(let t1450 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1449 (ICons t1448 (INil))))) +(let t1451 (Op (Constant 0.088388) (INil))) +(let t1452 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t1453 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t1452 (INil)))) +(let t1454 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t1455 (Op (Cast (MNum 1) (F32)) (ICons t1454 (INil)))) +(let t1456 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1453 (ICons t1455 (INil))))) +(let t1457 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t1458 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t1457 (INil)))) +(let t1459 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t1456 (ICons t1458 (INil))))) +(let t1460 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t1459 (INil)))) +(let t1461 (Op (Constant -10000000000.000000) (INil))) +(let t1462 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t1460 (ICons t1461 (INil))))) +(let t1463 (Op (Constant -1.000000) (INil))) +(let t1464 (Op (Constant 1.442695) (INil))) +(let t1465 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1466 (Op (Cast (MNum 1) (F32)) (ICons t1465 (INil)))) +(let t1467 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1466 (INil)))) +(let t1468 (Op (Constant 0.000001) (INil))) +(let t1469 (Op (Constant -1.000000) (INil))) +(let t1470 (Op (Constant 1.442695) (INil))) +(let t1471 (Op (Constant 0.000000) (INil))) +(let t1472 (Op (Constant 0.000000) (INil))) +(let t1473 (Op (Constant 0.000000) (INil))) +(let t1474 (Op (Iota (MIter) (MNum 128)) (INil))) +(let t1475 (Op (Iota (MNum 0) (MNum 128)) (INil))) +(let t1476 (Op (Iota (MNum 1) (MNum 1)) (INil))) +(let t1477 (Op (Iota (MMul (MIter) (MNum 128)) (MVar "s")) (INil))) +(let t1478 (Op (Iota (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MMul (MVar "s") (MNum 8))) (INil))) +(let t1479 (Op (Iota (MNum 3145728) (MNum 1)) (INil))) +(let t1480 (Op (Iota (MIter) (MNum 3145728)) (INil))) +(let t1481 (Op (Iota (MAdd (MAdd (MAdd (MMod (MIter) (MNum 768)) (MNum 768)) (MMul (MMod (MDiv (MIter) (MNum 768)) (MNum 8)) (MNum 1536))) (MMul (MDiv (MIter) (MNum 6144)) (MNum 12288))) (MMul (MMul (MVar "s") (MNum 8)) (MNum 768))) (INil))) +(let t1482 (Op (Constant -1.000000) (INil))) +(let t1483 (Op (Constant 1.442695) (INil))) +(let t1484 (Op (Constant 1.000000) (INil))) +(let t1485 (Op (Iota (MNum 1572864) (MNum 1)) (INil))) +(let t1486 (Op (Iota (MIter) (MNum 1572864)) (INil))) +(let t1487 (Op (Iota (MNum 2048) (MNum 1)) (INil))) +(let t1488 (Op (Cast (MNum 1) (F32)) (ICons t1487 (INil)))) +(let t1489 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1488 (INil)))) +(let t1490 (Op (Constant 0.000001) (INil))) +(let t1491 (LoopStart t1260 0 0 (MNum 47) (F32))) +(let t1492 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1491 (ICons t1491 (INil))))) +(let t1493 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2048) (ECons (MMul (MIter) (MNum 2048)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1492 (INil)))) +(let t1494 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1493 (ICons t1263 (INil))))) +(let t1495 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1494 (ICons t1264 (INil))))) +(let t1496 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1495 (INil)))) +(let t1497 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1496 (INil)))) +(let t1498 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1497 (ICons t1491 (INil))))) +(let t1499 (Op (LoopInput 0 1 (F32)) (ICons t212 (ICons t234 (ICons t256 (ICons t278 (ICons t300 (ICons t322 (ICons t344 (ICons t366 (ICons t388 (ICons t410 (ICons t432 (ICons t454 (ICons t476 (ICons t498 (ICons t520 (ICons t542 (ICons t564 (ICons t586 (ICons t608 (ICons t630 (ICons t652 (ICons t674 (ICons t696 (ICons t718 (ICons t740 (ICons t762 (ICons t784 (ICons t806 (ICons t828 (ICons t850 (ICons t872 (ICons t894 (ICons t916 (ICons t938 (ICons t960 (ICons t982 (ICons t1004 (ICons t1026 (ICons t1048 (ICons t1070 (ICons t1092 (ICons t1114 (ICons t1136 (ICons t1158 (ICons t1180 (ICons t1202 (ICons t1224 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1500 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1498 (ICons t1499 (INil))))) +(let t1501 (Op (LoopInput 0 2 (F32)) (ICons t194 (ICons t216 (ICons t238 (ICons t260 (ICons t282 (ICons t304 (ICons t326 (ICons t348 (ICons t370 (ICons t392 (ICons t414 (ICons t436 (ICons t458 (ICons t480 (ICons t502 (ICons t524 (ICons t546 (ICons t568 (ICons t590 (ICons t612 (ICons t634 (ICons t656 (ICons t678 (ICons t700 (ICons t722 (ICons t744 (ICons t766 (ICons t788 (ICons t810 (ICons t832 (ICons t854 (ICons t876 (ICons t898 (ICons t920 (ICons t942 (ICons t964 (ICons t986 (ICons t1008 (ICons t1030 (ICons t1052 (ICons t1074 (ICons t1096 (ICons t1118 (ICons t1140 (ICons t1162 (ICons t1184 (ICons t1206 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1502 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1500 (ICons t1501 (INil))))) +(let t1503 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1502 (INil)))) +(let t1504 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1503 (ICons t1503 (INil))))) +(let t1505 (Op (Sum (ECons (MVar "s") (ECons (MNum 32) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1504 (INil)))) +(let t1506 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1505 (ICons t1267 (INil))))) +(let t1507 (Op (Add (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1506 (ICons t1268 (INil))))) +(let t1508 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1507 (INil)))) +(let t1509 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1508 (INil)))) +(let t1510 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1509 (ICons t1503 (INil))))) +(let t1511 (Op (LoopInput 0 3 (F32)) (ICons t196 (ICons t218 (ICons t240 (ICons t262 (ICons t284 (ICons t306 (ICons t328 (ICons t350 (ICons t372 (ICons t394 (ICons t416 (ICons t438 (ICons t460 (ICons t482 (ICons t504 (ICons t526 (ICons t548 (ICons t570 (ICons t592 (ICons t614 (ICons t636 (ICons t658 (ICons t680 (ICons t702 (ICons t724 (ICons t746 (ICons t768 (ICons t790 (ICons t812 (ICons t834 (ICons t856 (ICons t878 (ICons t900 (ICons t922 (ICons t944 (ICons t966 (ICons t988 (ICons t1010 (ICons t1032 (ICons t1054 (ICons t1076 (ICons t1098 (ICons t1120 (ICons t1142 (ICons t1164 (ICons t1186 (ICons t1208 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1512 (Op (Mul (ECons (MVar "s") (ECons (MNum 512) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1500 (ICons t1511 (INil))))) +(let t1513 (Op (Sum (ECons (MVar "s") (ECons (MNum 512) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ICons t1512 (INil)))) +(let t1514 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1513 (ICons t1513 (INil))))) +(let t1515 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1514 (INil)))) +(let t1516 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1515 (ICons t1271 (INil))))) +(let t1517 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1516 (ICons t1272 (INil))))) +(let t1518 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1517 (INil)))) +(let t1519 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1518 (INil)))) +(let t1520 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1519 (ICons t1513 (INil))))) +(let t1521 (Op (LoopInput 0 4 (F32)) (ICons t198 (ICons t220 (ICons t242 (ICons t264 (ICons t286 (ICons t308 (ICons t330 (ICons t352 (ICons t374 (ICons t396 (ICons t418 (ICons t440 (ICons t462 (ICons t484 (ICons t506 (ICons t528 (ICons t550 (ICons t572 (ICons t594 (ICons t616 (ICons t638 (ICons t660 (ICons t682 (ICons t704 (ICons t726 (ICons t748 (ICons t770 (ICons t792 (ICons t814 (ICons t836 (ICons t858 (ICons t880 (ICons t902 (ICons t924 (ICons t946 (ICons t968 (ICons t990 (ICons t1012 (ICons t1034 (ICons t1056 (ICons t1078 (ICons t1100 (ICons t1122 (ICons t1144 (ICons t1166 (ICons t1188 (ICons t1210 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1522 (Op (Mul (ECons (MVar "s") (ECons (MNum 512) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1500 (ICons t1521 (INil))))) +(let t1523 (Op (Sum (ECons (MVar "s") (ECons (MNum 512) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ICons t1522 (INil)))) +(let t1524 (Op (LoopInput 0 5 (F32)) (ICons t202 (ICons t224 (ICons t246 (ICons t268 (ICons t290 (ICons t312 (ICons t334 (ICons t356 (ICons t378 (ICons t400 (ICons t422 (ICons t444 (ICons t466 (ICons t488 (ICons t510 (ICons t532 (ICons t554 (ICons t576 (ICons t598 (ICons t620 (ICons t642 (ICons t664 (ICons t686 (ICons t708 (ICons t730 (ICons t752 (ICons t774 (ICons t796 (ICons t818 (ICons t840 (ICons t862 (ICons t884 (ICons t906 (ICons t928 (ICons t950 (ICons t972 (ICons t994 (ICons t1016 (ICons t1038 (ICons t1060 (ICons t1082 (ICons t1104 (ICons t1126 (ICons t1148 (ICons t1170 (ICons t1192 (ICons t1214 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1525 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1510 (ICons t1524 (INil))))) +(let t1526 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil))))) (ICons t1286 (ICons t1525 (INil))))) +(let t1527 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1525 (ICons t1291 (INil))))) +(let t1528 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1526 (ICons t1292 (INil))))) +(let t1529 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1528 (ICons t1293 (INil))))) +(let t1530 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1527 (ICons t1529 (INil))))) +(let t1531 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1526 (ICons t1291 (INil))))) +(let t1532 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1525 (ICons t1292 (INil))))) +(let t1533 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1531 (ICons t1532 (INil))))) +(let t1534 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1294 (ICons t1530 (INil))))) +(let t1535 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1534 (ICons t1296 (INil))))) +(let t1536 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1297 (ICons t1533 (INil))))) +(let t1537 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1536 (ICons t1299 (INil))))) +(let t1538 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1535 (ICons t1537 (INil))))) +(let t1539 (Op (LoopInput 0 6 (F32)) (ICons t204 (ICons t226 (ICons t248 (ICons t270 (ICons t292 (ICons t314 (ICons t336 (ICons t358 (ICons t380 (ICons t402 (ICons t424 (ICons t446 (ICons t468 (ICons t490 (ICons t512 (ICons t534 (ICons t556 (ICons t578 (ICons t600 (ICons t622 (ICons t644 (ICons t666 (ICons t688 (ICons t710 (ICons t732 (ICons t754 (ICons t776 (ICons t798 (ICons t820 (ICons t842 (ICons t864 (ICons t886 (ICons t908 (ICons t930 (ICons t952 (ICons t974 (ICons t996 (ICons t1018 (ICons t1040 (ICons t1062 (ICons t1084 (ICons t1106 (ICons t1128 (ICons t1150 (ICons t1172 (ICons t1194 (ICons t1216 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1540 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1520 (ICons t1539 (INil))))) +(let t1541 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1313 (ICons t1540 (INil))))) +(let t1542 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1540 (ICons t1318 (INil))))) +(let t1543 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1541 (ICons t1319 (INil))))) +(let t1544 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1543 (ICons t1320 (INil))))) +(let t1545 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1542 (ICons t1544 (INil))))) +(let t1546 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1541 (ICons t1318 (INil))))) +(let t1547 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1540 (ICons t1319 (INil))))) +(let t1548 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1546 (ICons t1547 (INil))))) +(let t1549 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1321 (ICons t1545 (INil))))) +(let t1550 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1549 (ICons t1323 (INil))))) +(let t1551 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1324 (ICons t1548 (INil))))) +(let t1552 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1551 (ICons t1326 (INil))))) +(let t1553 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1550 (ICons t1552 (INil))))) +(let t1554 (Op (LoopInput 0 8 (F32)) (ICons t2 (ICons t6 (ICons t10 (ICons t14 (ICons t18 (ICons t22 (ICons t26 (ICons t30 (ICons t34 (ICons t38 (ICons t42 (ICons t46 (ICons t50 (ICons t54 (ICons t58 (ICons t62 (ICons t66 (ICons t70 (ICons t74 (ICons t78 (ICons t82 (ICons t86 (ICons t90 (ICons t94 (ICons t98 (ICons t102 (ICons t106 (ICons t110 (ICons t114 (ICons t118 (ICons t122 (ICons t126 (ICons t130 (ICons t134 (ICons t138 (ICons t142 (ICons t146 (ICons t150 (ICons t154 (ICons t158 (ICons t162 (ICons t166 (ICons t170 (ICons t174 (ICons t178 (ICons t182 (ICons t186 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1555 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t1554 (ICons t1337 (ICons t1553 (INil)))))) +(let t1556 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t1538 (ICons t1555 (INil))))) +(let t1557 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1556 (INil)))) +(let t1558 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1557 (ICons t1338 (INil))))) +(let t1559 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1558 (ICons t1349 (INil))))) +(let t1560 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1559 (INil)))) +(let t1561 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1560 (ICons t1350 (INil))))) +(let t1562 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1559 (ICons t1561 (INil))))) +(let t1563 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1562 (ICons t1351 (INil))))) +(let t1564 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1563 (INil)))) +(let t1565 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1564 (INil)))) +(let t1566 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1565 (INil)))) +(let t1567 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1564 (ICons t1566 (INil))))) +(let t1568 (Op (LoopInput 0 9 (F32)) (ICons t4 (ICons t8 (ICons t12 (ICons t16 (ICons t20 (ICons t24 (ICons t28 (ICons t32 (ICons t36 (ICons t40 (ICons t44 (ICons t48 (ICons t52 (ICons t56 (ICons t60 (ICons t64 (ICons t68 (ICons t72 (ICons t76 (ICons t80 (ICons t84 (ICons t88 (ICons t92 (ICons t96 (ICons t100 (ICons t104 (ICons t108 (ICons t112 (ICons t116 (ICons t120 (ICons t124 (ICons t128 (ICons t132 (ICons t136 (ICons t140 (ICons t144 (ICons t148 (ICons t152 (ICons t156 (ICons t160 (ICons t164 (ICons t168 (ICons t172 (ICons t176 (ICons t180 (ICons t184 (ICons t188 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1569 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t1568 (ICons t1337 (ICons t1523 (INil)))))) +(let t1570 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t1567 (ICons t1569 (INil))))) +(let t1571 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1570 (INil)))) +(let t1572 (Op (LoopInput 0 10 (F32)) (ICons t200 (ICons t222 (ICons t244 (ICons t266 (ICons t288 (ICons t310 (ICons t332 (ICons t354 (ICons t376 (ICons t398 (ICons t420 (ICons t442 (ICons t464 (ICons t486 (ICons t508 (ICons t530 (ICons t552 (ICons t574 (ICons t596 (ICons t618 (ICons t640 (ICons t662 (ICons t684 (ICons t706 (ICons t728 (ICons t750 (ICons t772 (ICons t794 (ICons t816 (ICons t838 (ICons t860 (ICons t882 (ICons t904 (ICons t926 (ICons t948 (ICons t970 (ICons t992 (ICons t1014 (ICons t1036 (ICons t1058 (ICons t1080 (ICons t1102 (ICons t1124 (ICons t1146 (ICons t1168 (ICons t1190 (ICons t1212 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1573 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2048)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1571 (ICons t1572 (INil))))) +(let t1574 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2048)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1573 (INil)))) +(let t1575 (Op (Add (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1491 (ICons t1574 (INil))))) +(let t1576 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1575 (ICons t1575 (INil))))) +(let t1577 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2048) (ECons (MMul (MIter) (MNum 2048)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1576 (INil)))) +(let t1578 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1577 (ICons t1354 (INil))))) +(let t1579 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1578 (ICons t1355 (INil))))) +(let t1580 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1579 (INil)))) +(let t1581 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1580 (INil)))) +(let t1582 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1581 (ICons t1575 (INil))))) +(let t1583 (Op (LoopInput 0 11 (F32)) (ICons t214 (ICons t236 (ICons t258 (ICons t280 (ICons t302 (ICons t324 (ICons t346 (ICons t368 (ICons t390 (ICons t412 (ICons t434 (ICons t456 (ICons t478 (ICons t500 (ICons t522 (ICons t544 (ICons t566 (ICons t588 (ICons t610 (ICons t632 (ICons t654 (ICons t676 (ICons t698 (ICons t720 (ICons t742 (ICons t764 (ICons t786 (ICons t808 (ICons t830 (ICons t852 (ICons t874 (ICons t896 (ICons t918 (ICons t940 (ICons t962 (ICons t984 (ICons t1006 (ICons t1028 (ICons t1050 (ICons t1072 (ICons t1094 (ICons t1116 (ICons t1138 (ICons t1160 (ICons t1182 (ICons t1204 (ICons t1226 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1584 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1582 (ICons t1583 (INil))))) +(let t1585 (Op (LoopInput 0 12 (F32)) (ICons t206 (ICons t228 (ICons t250 (ICons t272 (ICons t294 (ICons t316 (ICons t338 (ICons t360 (ICons t382 (ICons t404 (ICons t426 (ICons t448 (ICons t470 (ICons t492 (ICons t514 (ICons t536 (ICons t558 (ICons t580 (ICons t602 (ICons t624 (ICons t646 (ICons t668 (ICons t690 (ICons t712 (ICons t734 (ICons t756 (ICons t778 (ICons t800 (ICons t822 (ICons t844 (ICons t866 (ICons t888 (ICons t910 (ICons t932 (ICons t954 (ICons t976 (ICons t998 (ICons t1020 (ICons t1042 (ICons t1064 (ICons t1086 (ICons t1108 (ICons t1130 (ICons t1152 (ICons t1174 (ICons t1196 (ICons t1218 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1586 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 128)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1584 (ICons t1585 (INil))))) +(let t1587 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 128)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1586 (INil)))) +(let t1588 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1587 (INil)))) +(let t1589 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1588 (ICons t1356 (INil))))) +(let t1590 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1587 (ICons t1589 (INil))))) +(let t1591 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1590 (ICons t1357 (INil))))) +(let t1592 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1591 (INil)))) +(let t1593 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1592 (INil)))) +(let t1594 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1593 (INil)))) +(let t1595 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1592 (ICons t1594 (INil))))) +(let t1596 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1595 (ICons t1358 (INil))))) +(let t1597 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1595 (ICons t1359 (INil))))) +(let t1598 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1597 (ICons t1596 (INil))))) +(let t1599 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t1598 (INil)))) +(let t1600 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1599 (ICons t1360 (INil))))) +(let t1601 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1600 (INil)))) +(let t1602 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t1601 (INil)))) +(let t1603 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1602 (ICons t1363 (INil))))) +(let t1604 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1364 (ICons t1603 (INil))))) +(let t1605 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t1362 (ICons t1604 (ICons t1361 (INil)))))) +(let t1606 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1365 (ICons t1605 (INil))))) +(let t1607 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1606 (ICons t1595 (INil))))) +(let t1608 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1605 (ICons t1366 (INil))))) +(let t1609 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ECons (MNum 2048) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ICons t1608 (ICons t1367 (INil))))) +(let t1610 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1605 (ICons t1372 (INil))))) +(let t1611 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ECons (MNum 768) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))))) (ICons t1610 (ICons t1373 (INil))))) +(let t1612 (Op (LoopInput 0 13 (Bf16)) (ICons t208 (ICons t230 (ICons t252 (ICons t274 (ICons t296 (ICons t318 (ICons t340 (ICons t362 (ICons t384 (ICons t406 (ICons t428 (ICons t450 (ICons t472 (ICons t494 (ICons t516 (ICons t538 (ICons t560 (ICons t582 (ICons t604 (ICons t626 (ICons t648 (ICons t670 (ICons t692 (ICons t714 (ICons t736 (ICons t758 (ICons t780 (ICons t802 (ICons t824 (ICons t846 (ICons t868 (ICons t890 (ICons t912 (ICons t934 (ICons t956 (ICons t978 (ICons t1000 (ICons t1022 (ICons t1044 (ICons t1066 (ICons t1088 (ICons t1110 (ICons t1132 (ICons t1154 (ICons t1176 (ICons t1198 (ICons t1220 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1613 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ECons (MNum 2048) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1536) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1609 (ICons t1612 (INil))))) +(let t1614 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1536)) (MNum 2048)) (MNum 1)) (F32)) (ICons t1613 (INil)))) +(let t1615 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1536) (ECons (MNum 2048) (ENil)))))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))))) (ICons t1584 (ICons t1614 (INil))))) +(let t1616 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1536) (ENil))))) (MNum 2048) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))))) (ICons t1615 (INil)))) +(let t1617 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t1368 (ICons t1616 (INil))))) +(let t1618 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1616 (ICons t1369 (INil))))) +(let t1619 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1618 (ICons t1370 (INil))))) +(let t1620 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1619 (INil)))) +(let t1621 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1620 (ICons t1371 (INil))))) +(let t1622 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1621 (INil)))) +(let t1623 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1616 (ICons t1622 (INil))))) +(let t1624 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1623 (ICons t1617 (INil))))) +(let t1625 (Op (LoopInput 0 14 (Bf16)) (ICons t210 (ICons t232 (ICons t254 (ICons t276 (ICons t298 (ICons t320 (ICons t342 (ICons t364 (ICons t386 (ICons t408 (ICons t430 (ICons t452 (ICons t474 (ICons t496 (ICons t518 (ICons t540 (ICons t562 (ICons t584 (ICons t606 (ICons t628 (ICons t650 (ICons t672 (ICons t694 (ICons t716 (ICons t738 (ICons t760 (ICons t782 (ICons t804 (ICons t826 (ICons t848 (ICons t870 (ICons t892 (ICons t914 (ICons t936 (ICons t958 (ICons t980 (ICons t1002 (ICons t1024 (ICons t1046 (ICons t1068 (ICons t1090 (ICons t1112 (ICons t1134 (ICons t1156 (ICons t1178 (ICons t1200 (ICons t1222 (INil)))))))))))))))))))))))))))))))))))))))))))))))))) +(let t1626 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ECons (MNum 768) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2048) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1611 (ICons t1625 (INil))))) +(let t1627 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2048)) (MNum 768)) (MNum 1)) (F32)) (ICons t1626 (INil)))) +(let t1628 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2048) (ECons (MNum 768) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))))) (ICons t1624 (ICons t1627 (INil))))) +(let t1629 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2048) (ENil))))) (MNum 768) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ICons t1628 (INil)))) +(let t1630 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1629 (ICons t1607 (INil))))) +(let t1631 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1630 (INil)))) +(let t1632 (Op (Add (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1575 (ICons t1631 (INil))))) +(let t1633 (LoopEnd t1632 0 0 (F32))) +(let t1634 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1633 (ICons t1633 (INil))))) +(let t1635 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2048) (ECons (MMul (MIter) (MNum 2048)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1634 (INil)))) +(let t1636 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1635 (ICons t1376 (INil))))) +(let t1637 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1636 (ICons t1377 (INil))))) +(let t1638 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1637 (INil)))) +(let t1639 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1638 (INil)))) +(let t1640 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1639 (ICons t1633 (INil))))) +(let t1641 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1640 (ICons t1246 (INil))))) +(let t1642 (Op (Mul (ECons (MVar "s") (ECons (MNum 4096) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1641 (ICons t1228 (INil))))) +(let t1643 (Op (Sum (ECons (MVar "s") (ECons (MNum 4096) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 4096)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ICons t1642 (INil)))) +(let t1644 (Op (Mul (ECons (MVar "s") (ECons (MNum 512) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1641 (ICons t1230 (INil))))) +(let t1645 (Op (Sum (ECons (MVar "s") (ECons (MNum 512) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ICons t1644 (INil)))) +(let t1646 (Op (Mul (ECons (MVar "s") (ECons (MNum 512) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1641 (ICons t1232 (INil))))) +(let t1647 (Op (Sum (ECons (MVar "s") (ECons (MNum 512) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 512)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil)))) (ICons t1646 (INil)))) +(let t1648 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1643 (ICons t1643 (INil))))) +(let t1649 (Op (Sum (ECons (MVar "s") (ECons (MNum 32) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1648 (INil)))) +(let t1650 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1649 (ICons t1380 (INil))))) +(let t1651 (Op (Add (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1650 (ICons t1381 (INil))))) +(let t1652 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1651 (INil)))) +(let t1653 (Op (Recip (ECons (MVar "s") (ECons (MNum 32) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ENil)))) (ICons t1652 (INil)))) +(let t1654 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 32)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1653 (ICons t1643 (INil))))) +(let t1655 (Op (Mul (ECons (MVar "s") (ECons (MNum 32) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1654 (ICons t1236 (INil))))) +(let t1656 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1645 (ICons t1645 (INil))))) +(let t1657 (Op (Sum (ECons (MVar "s") (ECons (MNum 4) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1656 (INil)))) +(let t1658 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1657 (ICons t1384 (INil))))) +(let t1659 (Op (Add (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1658 (ICons t1385 (INil))))) +(let t1660 (Op (Sqrt (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1659 (INil)))) +(let t1661 (Op (Recip (ECons (MVar "s") (ECons (MNum 4) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ENil)))) (ICons t1660 (INil)))) +(let t1662 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 4)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MIter) (MNum 512)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1661 (ICons t1645 (INil))))) +(let t1663 (Op (Mul (ECons (MVar "s") (ECons (MNum 4) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1662 (ICons t1238 (INil))))) +(let t1664 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil))))) (ICons t1399 (ICons t1655 (INil))))) +(let t1665 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1655 (ICons t1404 (INil))))) +(let t1666 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1664 (ICons t1405 (INil))))) +(let t1667 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1666 (ICons t1406 (INil))))) +(let t1668 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1665 (ICons t1667 (INil))))) +(let t1669 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1664 (ICons t1404 (INil))))) +(let t1670 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 32)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1655 (ICons t1405 (INil))))) +(let t1671 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1669 (ICons t1670 (INil))))) +(let t1672 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1407 (ICons t1668 (INil))))) +(let t1673 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1672 (ICons t1409 (INil))))) +(let t1674 (Op (Gather (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1410 (ICons t1671 (INil))))) +(let t1675 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1674 (ICons t1412 (INil))))) +(let t1676 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1673 (ICons t1675 (INil))))) +(let t1677 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil))))) (ICons t1426 (ICons t1663 (INil))))) +(let t1678 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1663 (ICons t1431 (INil))))) +(let t1679 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1677 (ICons t1432 (INil))))) +(let t1680 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1679 (ICons t1433 (INil))))) +(let t1681 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1678 (ICons t1680 (INil))))) +(let t1682 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1677 (ICons t1431 (INil))))) +(let t1683 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1663 (ICons t1432 (INil))))) +(let t1684 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1682 (ICons t1683 (INil))))) +(let t1685 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1434 (ICons t1681 (INil))))) +(let t1686 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1685 (ICons t1436 (INil))))) +(let t1687 (Op (Gather (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t1437 (ICons t1684 (INil))))) +(let t1688 (Op (Mul (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1687 (ICons t1439 (INil))))) +(let t1689 (Op (Add (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1686 (ICons t1688 (INil))))) +(let t1690 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ICons t190 (ICons t1450 (ICons t1689 (INil)))))) +(let t1691 (Op (Scatter (ECons (MNum 4) (ECons (MNum 4096) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 4096)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 4) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 512)) (ECons (MIter) (ENil))))) (ICons t192 (ICons t1450 (ICons t1647 (INil)))))) +(let t1692 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 128) (ENil))))) (ECons (MMul (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))))) (ICons t1676 (ICons t1690 (INil))))) +(let t1693 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 128) (ECons (MMul (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 128)) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 128)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1692 (INil)))) +(let t1694 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1693 (ICons t1451 (INil))))) +(let t1695 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1694 (ICons t1462 (INil))))) +(let t1696 (Op (Max (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1695 (INil)))) +(let t1697 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1696 (ICons t1463 (INil))))) +(let t1698 (Op (Add (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1695 (ICons t1697 (INil))))) +(let t1699 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1698 (ICons t1464 (INil))))) +(let t1700 (Op (Exp2 (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1699 (INil)))) +(let t1701 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ENil))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t1700 (INil)))) +(let t1702 (Op (Recip (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1701 (INil)))) +(let t1703 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t1700 (ICons t1702 (INil))))) +(let t1704 (Op (Mul (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ECons (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MDiv (MIter) (MNum 8)) (MNum 128)) (MNum 4096)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 128)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t1703 (ICons t1691 (INil))))) +(let t1705 (Op (Sum (ECons (MNum 32) (ECons (MVar "s") (ECons (MNum 128) (ENil)))) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (MNum 128)) (ECons (MMul (MIter) (MMin (MNum 4096) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 128)) (MVar "s")) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1704 (INil)))) +(let t1706 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ECons (MNum 4096) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 128)) (MNum 128)) (MVar "s")) (MMod (MIter) (MNum 128))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2048)) (ECons (MMul (MIter) (MNum 4096)) (ECons (MIter) (ENil))))) (ICons t1705 (ICons t1234 (INil))))) +(let t1707 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 4096) (ECons (MMul (MMul (MIter) (MNum 4096)) (MNum 2048)) (ECons (MMul (MIter) (MNum 4096)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1706 (INil)))) +(let t1708 (Op (Add (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1633 (ICons t1707 (INil))))) +(let t1709 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1708 (ICons t1708 (INil))))) +(let t1710 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2048) (ECons (MMul (MIter) (MNum 2048)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1709 (INil)))) +(let t1711 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1710 (ICons t1467 (INil))))) +(let t1712 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1711 (ICons t1468 (INil))))) +(let t1713 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1712 (INil)))) +(let t1714 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1713 (INil)))) +(let t1715 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1714 (ICons t1708 (INil))))) +(let t1716 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1715 (ICons t1248 (INil))))) +(let t1717 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 128)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1716 (ICons t1240 (INil))))) +(let t1718 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 128)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1717 (INil)))) +(let t1719 (Op (Max (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1718 (INil)))) +(let t1720 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1719 (ICons t1469 (INil))))) +(let t1721 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1718 (ICons t1720 (INil))))) +(let t1722 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1721 (ICons t1470 (INil))))) +(let t1723 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1722 (INil)))) +(let t1724 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 128) (ECons (MMul (MIter) (MNum 128)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1723 (INil)))) +(let t1725 (Op (Recip (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1724 (INil)))) +(let t1726 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1723 (ICons t1725 (INil))))) +(let t1727 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1726 (ICons t1471 (INil))))) +(let t1728 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MIter) (MNum 128)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1726 (ICons t1472 (INil))))) +(let t1729 (Op (LessThan (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1728 (ICons t1727 (INil))))) +(let t1730 (Op (Cast (MMax (MMul (MMul (MVar "s") (MNum 128)) (MNum 128)) (MNum 1)) (F32)) (ICons t1729 (INil)))) +(let t1731 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ECons (MNum 128) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))))) (ICons t1730 (ICons t1473 (INil))))) +(let t1732 (Op (Sum (ECons (MVar "s") (ECons (MNum 128) (ENil))) (MNum 128) (ECons (MMul (MMul (MIter) (MNum 128)) (MNum 128)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 128)) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1731 (INil)))) +(let t1733 (Op (Cast (MMax (MMul (MVar "s") (MNum 128)) (MNum 1)) (Int)) (ICons t1732 (INil)))) +(let t1734 (Op (Mul (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1733 (ICons t1476 (INil))))) +(let t1735 (Op (Add (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1477 (ICons t1734 (INil))))) +(let t1736 (Op (Scatter (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ICons t1475 (ICons t1735 (ICons t1474 (INil)))))) +(let t1737 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1478 (ICons t1736 (INil))))) +(let t1738 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil))) (ECons (MVar "s") (ECons (MNum 128) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil)))) (ICons t1737 (ICons t1726 (INil))))) +(let t1739 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1736 (ICons t1479 (INil))))) +(let t1740 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ECons (MNum 2048) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ICons t1739 (ICons t1480 (INil))))) +(let t1741 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ECons (MNum 2048) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 1536) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1740 (ICons t1242 (INil))))) +(let t1742 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 1536)) (MNum 2048)) (MNum 1)) (F32)) (ICons t1741 (INil)))) +(let t1743 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1536) (ECons (MNum 2048) (ENil)))))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))))) (ICons t1716 (ICons t1742 (INil))))) +(let t1744 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 1536) (ENil))))) (MNum 2048) (ECons (MMul (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 1536)) (ECons (MMul (MIter) (MNum 2048)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))))) (ICons t1743 (INil)))) +(let t1745 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t1481 (ICons t1744 (INil))))) +(let t1746 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1744 (ICons t1482 (INil))))) +(let t1747 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1746 (ICons t1483 (INil))))) +(let t1748 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1747 (INil)))) +(let t1749 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1748 (ICons t1484 (INil))))) +(let t1750 (Op (Recip (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1749 (INil)))) +(let t1751 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 8)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1744 (ICons t1750 (INil))))) +(let t1752 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1751 (ICons t1745 (INil))))) +(let t1753 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ENil))) (ECons (MMul (MIter) (MNum 128)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ENil)))) (ICons t1736 (ICons t1485 (INil))))) +(let t1754 (Op (Add (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ECons (MNum 768) (ENil))))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil))))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))))) (ICons t1753 (ICons t1486 (INil))))) +(let t1755 (Op (Gather (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ECons (MNum 768) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ECons (MNum 128) (ECons (MNum 2048) (ECons (MNum 768) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))) (ICons t1754 (ICons t1244 (INil))))) +(let t1756 (Op (Cast (MMax (MMul (MMul (MMul (MVar "s") (MNum 8)) (MNum 2048)) (MNum 768)) (MNum 1)) (F32)) (ICons t1755 (INil)))) +(let t1757 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2048) (ECons (MNum 768) (ENil)))))) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 8)) (ECons (MMul (MIter) (MNum 768)) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil)))))) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ECons (MIter) (ENil))))))) (ICons t1752 (ICons t1756 (INil))))) +(let t1758 (Op (Sum (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 1) (ECons (MNum 2048) (ENil))))) (MNum 768) (ECons (MMul (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (MNum 8)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MMul (MIter) (MNum 768)) (MNum 2048)) (ECons (MMul (MIter) (MNum 768)) (ENil))))) (MIter) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))))) (ICons t1757 (INil)))) +(let t1759 (Op (Mul (ECons (MVar "s") (ECons (MNum 8) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 8)) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1758 (ICons t1738 (INil))))) +(let t1760 (Op (Sum (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (MNum 8) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 8)) (ECons (MIter) (ENil))) (MMul (MIter) (MNum 2048)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1759 (INil)))) +(let t1761 (Op (Add (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1708 (ICons t1760 (INil))))) +(let t1762 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1761 (ICons t1761 (INil))))) +(let t1763 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 2048) (ECons (MMul (MIter) (MNum 2048)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1762 (INil)))) +(let t1764 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1763 (ICons t1489 (INil))))) +(let t1765 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1764 (ICons t1490 (INil))))) +(let t1766 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1765 (INil)))) +(let t1767 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1766 (INil)))) +(let t1768 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1767 (ICons t1761 (INil))))) +(let t1769 (Op (Mul (ECons (MVar "s") (ECons (MNum 2048) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ICons t1768 (ICons t1250 (INil))))) +(let t1770 (Op (Mul (ECons (MVar "s") (ECons (MNum 151936) (ECons (MNum 2048) (ENil)))) (ECons (MMul (MIter) (MNum 2048)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 151936)) (ECons (MMul (MIter) (MNum 2048)) (ECons (MIter) (ENil))))) (ICons t1769 (ICons t1254 (INil))))) +(let t1771 (Op (Sum (ECons (MVar "s") (ECons (MNum 151936) (ENil))) (MNum 2048) (ECons (MMul (MMul (MIter) (MNum 2048)) (MNum 151936)) (ECons (MMul (MIter) (MNum 2048)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 151936)) (ECons (MIter) (ENil)))) (ICons t1770 (INil)))) +(let t1772 (Output t1771 12842)) +(let t1773 (Output t1690 12721)) +(let t1774 (Output t1691 12722)) +(let t1775 (Op (LoopOutput 0 0 (F32)) (ICons t1555 (INil)))) +(let t1776 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t1775 (INil)))) +(let t1777 (Output t1776 1394)) +(let t1778 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t1775 (INil)))) +(let t1779 (Output t1778 1635)) +(let t1780 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t1775 (INil)))) +(let t1781 (Output t1780 1876)) +(let t1782 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t1775 (INil)))) +(let t1783 (Output t1782 2117)) +(let t1784 (Op (LoopOutputSelect 0 0 4 (F32)) (ICons t1775 (INil)))) +(let t1785 (Output t1784 2358)) +(let t1786 (Op (LoopOutputSelect 0 0 5 (F32)) (ICons t1775 (INil)))) +(let t1787 (Output t1786 2599)) +(let t1788 (Op (LoopOutputSelect 0 0 6 (F32)) (ICons t1775 (INil)))) +(let t1789 (Output t1788 2840)) +(let t1790 (Op (LoopOutputSelect 0 0 7 (F32)) (ICons t1775 (INil)))) +(let t1791 (Output t1790 3081)) +(let t1792 (Op (LoopOutputSelect 0 0 8 (F32)) (ICons t1775 (INil)))) +(let t1793 (Output t1792 3322)) +(let t1794 (Op (LoopOutputSelect 0 0 9 (F32)) (ICons t1775 (INil)))) +(let t1795 (Output t1794 3563)) +(let t1796 (Op (LoopOutputSelect 0 0 10 (F32)) (ICons t1775 (INil)))) +(let t1797 (Output t1796 3804)) +(let t1798 (Op (LoopOutputSelect 0 0 11 (F32)) (ICons t1775 (INil)))) +(let t1799 (Output t1798 4045)) +(let t1800 (Op (LoopOutputSelect 0 0 12 (F32)) (ICons t1775 (INil)))) +(let t1801 (Output t1800 4286)) +(let t1802 (Op (LoopOutputSelect 0 0 13 (F32)) (ICons t1775 (INil)))) +(let t1803 (Output t1802 4527)) +(let t1804 (Op (LoopOutputSelect 0 0 14 (F32)) (ICons t1775 (INil)))) +(let t1805 (Output t1804 4768)) +(let t1806 (Op (LoopOutputSelect 0 0 15 (F32)) (ICons t1775 (INil)))) +(let t1807 (Output t1806 5009)) +(let t1808 (Op (LoopOutputSelect 0 0 16 (F32)) (ICons t1775 (INil)))) +(let t1809 (Output t1808 5250)) +(let t1810 (Op (LoopOutputSelect 0 0 17 (F32)) (ICons t1775 (INil)))) +(let t1811 (Output t1810 5491)) +(let t1812 (Op (LoopOutputSelect 0 0 18 (F32)) (ICons t1775 (INil)))) +(let t1813 (Output t1812 5732)) +(let t1814 (Op (LoopOutputSelect 0 0 19 (F32)) (ICons t1775 (INil)))) +(let t1815 (Output t1814 5973)) +(let t1816 (Op (LoopOutputSelect 0 0 20 (F32)) (ICons t1775 (INil)))) +(let t1817 (Output t1816 6214)) +(let t1818 (Op (LoopOutputSelect 0 0 21 (F32)) (ICons t1775 (INil)))) +(let t1819 (Output t1818 6455)) +(let t1820 (Op (LoopOutputSelect 0 0 22 (F32)) (ICons t1775 (INil)))) +(let t1821 (Output t1820 6696)) +(let t1822 (Op (LoopOutputSelect 0 0 23 (F32)) (ICons t1775 (INil)))) +(let t1823 (Output t1822 6937)) +(let t1824 (Op (LoopOutputSelect 0 0 24 (F32)) (ICons t1775 (INil)))) +(let t1825 (Output t1824 7178)) +(let t1826 (Op (LoopOutputSelect 0 0 25 (F32)) (ICons t1775 (INil)))) +(let t1827 (Output t1826 7419)) +(let t1828 (Op (LoopOutputSelect 0 0 26 (F32)) (ICons t1775 (INil)))) +(let t1829 (Output t1828 7660)) +(let t1830 (Op (LoopOutputSelect 0 0 27 (F32)) (ICons t1775 (INil)))) +(let t1831 (Output t1830 7901)) +(let t1832 (Op (LoopOutputSelect 0 0 28 (F32)) (ICons t1775 (INil)))) +(let t1833 (Output t1832 8142)) +(let t1834 (Op (LoopOutputSelect 0 0 29 (F32)) (ICons t1775 (INil)))) +(let t1835 (Output t1834 8383)) +(let t1836 (Op (LoopOutputSelect 0 0 30 (F32)) (ICons t1775 (INil)))) +(let t1837 (Output t1836 8624)) +(let t1838 (Op (LoopOutputSelect 0 0 31 (F32)) (ICons t1775 (INil)))) +(let t1839 (Output t1838 8865)) +(let t1840 (Op (LoopOutputSelect 0 0 32 (F32)) (ICons t1775 (INil)))) +(let t1841 (Output t1840 9106)) +(let t1842 (Op (LoopOutputSelect 0 0 33 (F32)) (ICons t1775 (INil)))) +(let t1843 (Output t1842 9347)) +(let t1844 (Op (LoopOutputSelect 0 0 34 (F32)) (ICons t1775 (INil)))) +(let t1845 (Output t1844 9588)) +(let t1846 (Op (LoopOutputSelect 0 0 35 (F32)) (ICons t1775 (INil)))) +(let t1847 (Output t1846 9829)) +(let t1848 (Op (LoopOutputSelect 0 0 36 (F32)) (ICons t1775 (INil)))) +(let t1849 (Output t1848 10070)) +(let t1850 (Op (LoopOutputSelect 0 0 37 (F32)) (ICons t1775 (INil)))) +(let t1851 (Output t1850 10311)) +(let t1852 (Op (LoopOutputSelect 0 0 38 (F32)) (ICons t1775 (INil)))) +(let t1853 (Output t1852 10552)) +(let t1854 (Op (LoopOutputSelect 0 0 39 (F32)) (ICons t1775 (INil)))) +(let t1855 (Output t1854 10793)) +(let t1856 (Op (LoopOutputSelect 0 0 40 (F32)) (ICons t1775 (INil)))) +(let t1857 (Output t1856 11034)) +(let t1858 (Op (LoopOutputSelect 0 0 41 (F32)) (ICons t1775 (INil)))) +(let t1859 (Output t1858 11275)) +(let t1860 (Op (LoopOutputSelect 0 0 42 (F32)) (ICons t1775 (INil)))) +(let t1861 (Output t1860 11516)) +(let t1862 (Op (LoopOutputSelect 0 0 43 (F32)) (ICons t1775 (INil)))) +(let t1863 (Output t1862 11757)) +(let t1864 (Op (LoopOutputSelect 0 0 44 (F32)) (ICons t1775 (INil)))) +(let t1865 (Output t1864 11998)) +(let t1866 (Op (LoopOutputSelect 0 0 45 (F32)) (ICons t1775 (INil)))) +(let t1867 (Output t1866 12239)) +(let t1868 (Op (LoopOutputSelect 0 0 46 (F32)) (ICons t1775 (INil)))) +(let t1869 (Output t1868 12480)) +(let t1870 (Op (LoopOutput 0 1 (F32)) (ICons t1569 (INil)))) +(let t1871 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t1870 (INil)))) +(let t1872 (Output t1871 1395)) +(let t1873 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t1870 (INil)))) +(let t1874 (Output t1873 1636)) +(let t1875 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t1870 (INil)))) +(let t1876 (Output t1875 1877)) +(let t1877 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t1870 (INil)))) +(let t1878 (Output t1877 2118)) +(let t1879 (Op (LoopOutputSelect 0 1 4 (F32)) (ICons t1870 (INil)))) +(let t1880 (Output t1879 2359)) +(let t1881 (Op (LoopOutputSelect 0 1 5 (F32)) (ICons t1870 (INil)))) +(let t1882 (Output t1881 2600)) +(let t1883 (Op (LoopOutputSelect 0 1 6 (F32)) (ICons t1870 (INil)))) +(let t1884 (Output t1883 2841)) +(let t1885 (Op (LoopOutputSelect 0 1 7 (F32)) (ICons t1870 (INil)))) +(let t1886 (Output t1885 3082)) +(let t1887 (Op (LoopOutputSelect 0 1 8 (F32)) (ICons t1870 (INil)))) +(let t1888 (Output t1887 3323)) +(let t1889 (Op (LoopOutputSelect 0 1 9 (F32)) (ICons t1870 (INil)))) +(let t1890 (Output t1889 3564)) +(let t1891 (Op (LoopOutputSelect 0 1 10 (F32)) (ICons t1870 (INil)))) +(let t1892 (Output t1891 3805)) +(let t1893 (Op (LoopOutputSelect 0 1 11 (F32)) (ICons t1870 (INil)))) +(let t1894 (Output t1893 4046)) +(let t1895 (Op (LoopOutputSelect 0 1 12 (F32)) (ICons t1870 (INil)))) +(let t1896 (Output t1895 4287)) +(let t1897 (Op (LoopOutputSelect 0 1 13 (F32)) (ICons t1870 (INil)))) +(let t1898 (Output t1897 4528)) +(let t1899 (Op (LoopOutputSelect 0 1 14 (F32)) (ICons t1870 (INil)))) +(let t1900 (Output t1899 4769)) +(let t1901 (Op (LoopOutputSelect 0 1 15 (F32)) (ICons t1870 (INil)))) +(let t1902 (Output t1901 5010)) +(let t1903 (Op (LoopOutputSelect 0 1 16 (F32)) (ICons t1870 (INil)))) +(let t1904 (Output t1903 5251)) +(let t1905 (Op (LoopOutputSelect 0 1 17 (F32)) (ICons t1870 (INil)))) +(let t1906 (Output t1905 5492)) +(let t1907 (Op (LoopOutputSelect 0 1 18 (F32)) (ICons t1870 (INil)))) +(let t1908 (Output t1907 5733)) +(let t1909 (Op (LoopOutputSelect 0 1 19 (F32)) (ICons t1870 (INil)))) +(let t1910 (Output t1909 5974)) +(let t1911 (Op (LoopOutputSelect 0 1 20 (F32)) (ICons t1870 (INil)))) +(let t1912 (Output t1911 6215)) +(let t1913 (Op (LoopOutputSelect 0 1 21 (F32)) (ICons t1870 (INil)))) +(let t1914 (Output t1913 6456)) +(let t1915 (Op (LoopOutputSelect 0 1 22 (F32)) (ICons t1870 (INil)))) +(let t1916 (Output t1915 6697)) +(let t1917 (Op (LoopOutputSelect 0 1 23 (F32)) (ICons t1870 (INil)))) +(let t1918 (Output t1917 6938)) +(let t1919 (Op (LoopOutputSelect 0 1 24 (F32)) (ICons t1870 (INil)))) +(let t1920 (Output t1919 7179)) +(let t1921 (Op (LoopOutputSelect 0 1 25 (F32)) (ICons t1870 (INil)))) +(let t1922 (Output t1921 7420)) +(let t1923 (Op (LoopOutputSelect 0 1 26 (F32)) (ICons t1870 (INil)))) +(let t1924 (Output t1923 7661)) +(let t1925 (Op (LoopOutputSelect 0 1 27 (F32)) (ICons t1870 (INil)))) +(let t1926 (Output t1925 7902)) +(let t1927 (Op (LoopOutputSelect 0 1 28 (F32)) (ICons t1870 (INil)))) +(let t1928 (Output t1927 8143)) +(let t1929 (Op (LoopOutputSelect 0 1 29 (F32)) (ICons t1870 (INil)))) +(let t1930 (Output t1929 8384)) +(let t1931 (Op (LoopOutputSelect 0 1 30 (F32)) (ICons t1870 (INil)))) +(let t1932 (Output t1931 8625)) +(let t1933 (Op (LoopOutputSelect 0 1 31 (F32)) (ICons t1870 (INil)))) +(let t1934 (Output t1933 8866)) +(let t1935 (Op (LoopOutputSelect 0 1 32 (F32)) (ICons t1870 (INil)))) +(let t1936 (Output t1935 9107)) +(let t1937 (Op (LoopOutputSelect 0 1 33 (F32)) (ICons t1870 (INil)))) +(let t1938 (Output t1937 9348)) +(let t1939 (Op (LoopOutputSelect 0 1 34 (F32)) (ICons t1870 (INil)))) +(let t1940 (Output t1939 9589)) +(let t1941 (Op (LoopOutputSelect 0 1 35 (F32)) (ICons t1870 (INil)))) +(let t1942 (Output t1941 9830)) +(let t1943 (Op (LoopOutputSelect 0 1 36 (F32)) (ICons t1870 (INil)))) +(let t1944 (Output t1943 10071)) +(let t1945 (Op (LoopOutputSelect 0 1 37 (F32)) (ICons t1870 (INil)))) +(let t1946 (Output t1945 10312)) +(let t1947 (Op (LoopOutputSelect 0 1 38 (F32)) (ICons t1870 (INil)))) +(let t1948 (Output t1947 10553)) +(let t1949 (Op (LoopOutputSelect 0 1 39 (F32)) (ICons t1870 (INil)))) +(let t1950 (Output t1949 10794)) +(let t1951 (Op (LoopOutputSelect 0 1 40 (F32)) (ICons t1870 (INil)))) +(let t1952 (Output t1951 11035)) +(let t1953 (Op (LoopOutputSelect 0 1 41 (F32)) (ICons t1870 (INil)))) +(let t1954 (Output t1953 11276)) +(let t1955 (Op (LoopOutputSelect 0 1 42 (F32)) (ICons t1870 (INil)))) +(let t1956 (Output t1955 11517)) +(let t1957 (Op (LoopOutputSelect 0 1 43 (F32)) (ICons t1870 (INil)))) +(let t1958 (Output t1957 11758)) +(let t1959 (Op (LoopOutputSelect 0 1 44 (F32)) (ICons t1870 (INil)))) +(let t1960 (Output t1959 11999)) +(let t1961 (Op (LoopOutputSelect 0 1 45 (F32)) (ICons t1870 (INil)))) +(let t1962 (Output t1961 12240)) +(let t1963 (Op (LoopOutputSelect 0 1 46 (F32)) (ICons t1870 (INil)))) +(let t1964 (Output t1963 12481)) +(let t1966 (OutputJoin t3 t5)) +(let t1967 (OutputJoin t1966 t7)) +(let t1968 (OutputJoin t1967 t9)) +(let t1969 (OutputJoin t1968 t11)) +(let t1970 (OutputJoin t1969 t13)) +(let t1971 (OutputJoin t1970 t15)) +(let t1972 (OutputJoin t1971 t17)) +(let t1973 (OutputJoin t1972 t19)) +(let t1974 (OutputJoin t1973 t21)) +(let t1975 (OutputJoin t1974 t23)) +(let t1976 (OutputJoin t1975 t25)) +(let t1977 (OutputJoin t1976 t27)) +(let t1978 (OutputJoin t1977 t29)) +(let t1979 (OutputJoin t1978 t31)) +(let t1980 (OutputJoin t1979 t33)) +(let t1981 (OutputJoin t1980 t35)) +(let t1982 (OutputJoin t1981 t37)) +(let t1983 (OutputJoin t1982 t39)) +(let t1984 (OutputJoin t1983 t41)) +(let t1985 (OutputJoin t1984 t43)) +(let t1986 (OutputJoin t1985 t45)) +(let t1987 (OutputJoin t1986 t47)) +(let t1988 (OutputJoin t1987 t49)) +(let t1989 (OutputJoin t1988 t51)) +(let t1990 (OutputJoin t1989 t53)) +(let t1991 (OutputJoin t1990 t55)) +(let t1992 (OutputJoin t1991 t57)) +(let t1993 (OutputJoin t1992 t59)) +(let t1994 (OutputJoin t1993 t61)) +(let t1995 (OutputJoin t1994 t63)) +(let t1996 (OutputJoin t1995 t65)) +(let t1997 (OutputJoin t1996 t67)) +(let t1998 (OutputJoin t1997 t69)) +(let t1999 (OutputJoin t1998 t71)) +(let t2000 (OutputJoin t1999 t73)) +(let t2001 (OutputJoin t2000 t75)) +(let t2002 (OutputJoin t2001 t77)) +(let t2003 (OutputJoin t2002 t79)) +(let t2004 (OutputJoin t2003 t81)) +(let t2005 (OutputJoin t2004 t83)) +(let t2006 (OutputJoin t2005 t85)) +(let t2007 (OutputJoin t2006 t87)) +(let t2008 (OutputJoin t2007 t89)) +(let t2009 (OutputJoin t2008 t91)) +(let t2010 (OutputJoin t2009 t93)) +(let t2011 (OutputJoin t2010 t95)) +(let t2012 (OutputJoin t2011 t97)) +(let t2013 (OutputJoin t2012 t99)) +(let t2014 (OutputJoin t2013 t101)) +(let t2015 (OutputJoin t2014 t103)) +(let t2016 (OutputJoin t2015 t105)) +(let t2017 (OutputJoin t2016 t107)) +(let t2018 (OutputJoin t2017 t109)) +(let t2019 (OutputJoin t2018 t111)) +(let t2020 (OutputJoin t2019 t113)) +(let t2021 (OutputJoin t2020 t115)) +(let t2022 (OutputJoin t2021 t117)) +(let t2023 (OutputJoin t2022 t119)) +(let t2024 (OutputJoin t2023 t121)) +(let t2025 (OutputJoin t2024 t123)) +(let t2026 (OutputJoin t2025 t125)) +(let t2027 (OutputJoin t2026 t127)) +(let t2028 (OutputJoin t2027 t129)) +(let t2029 (OutputJoin t2028 t131)) +(let t2030 (OutputJoin t2029 t133)) +(let t2031 (OutputJoin t2030 t135)) +(let t2032 (OutputJoin t2031 t137)) +(let t2033 (OutputJoin t2032 t139)) +(let t2034 (OutputJoin t2033 t141)) +(let t2035 (OutputJoin t2034 t143)) +(let t2036 (OutputJoin t2035 t145)) +(let t2037 (OutputJoin t2036 t147)) +(let t2038 (OutputJoin t2037 t149)) +(let t2039 (OutputJoin t2038 t151)) +(let t2040 (OutputJoin t2039 t153)) +(let t2041 (OutputJoin t2040 t155)) +(let t2042 (OutputJoin t2041 t157)) +(let t2043 (OutputJoin t2042 t159)) +(let t2044 (OutputJoin t2043 t161)) +(let t2045 (OutputJoin t2044 t163)) +(let t2046 (OutputJoin t2045 t165)) +(let t2047 (OutputJoin t2046 t167)) +(let t2048 (OutputJoin t2047 t169)) +(let t2049 (OutputJoin t2048 t171)) +(let t2050 (OutputJoin t2049 t173)) +(let t2051 (OutputJoin t2050 t175)) +(let t2052 (OutputJoin t2051 t177)) +(let t2053 (OutputJoin t2052 t179)) +(let t2054 (OutputJoin t2053 t181)) +(let t2055 (OutputJoin t2054 t183)) +(let t2056 (OutputJoin t2055 t185)) +(let t2057 (OutputJoin t2056 t187)) +(let t2058 (OutputJoin t2057 t189)) +(let t2059 (OutputJoin t2058 t191)) +(let t2060 (OutputJoin t2059 t193)) +(let t2061 (OutputJoin t2060 t195)) +(let t2062 (OutputJoin t2061 t197)) +(let t2063 (OutputJoin t2062 t199)) +(let t2064 (OutputJoin t2063 t201)) +(let t2065 (OutputJoin t2064 t203)) +(let t2066 (OutputJoin t2065 t205)) +(let t2067 (OutputJoin t2066 t207)) +(let t2068 (OutputJoin t2067 t209)) +(let t2069 (OutputJoin t2068 t211)) +(let t2070 (OutputJoin t2069 t213)) +(let t2071 (OutputJoin t2070 t215)) +(let t2072 (OutputJoin t2071 t217)) +(let t2073 (OutputJoin t2072 t219)) +(let t2074 (OutputJoin t2073 t221)) +(let t2075 (OutputJoin t2074 t223)) +(let t2076 (OutputJoin t2075 t225)) +(let t2077 (OutputJoin t2076 t227)) +(let t2078 (OutputJoin t2077 t229)) +(let t2079 (OutputJoin t2078 t231)) +(let t2080 (OutputJoin t2079 t233)) +(let t2081 (OutputJoin t2080 t235)) +(let t2082 (OutputJoin t2081 t237)) +(let t2083 (OutputJoin t2082 t239)) +(let t2084 (OutputJoin t2083 t241)) +(let t2085 (OutputJoin t2084 t243)) +(let t2086 (OutputJoin t2085 t245)) +(let t2087 (OutputJoin t2086 t247)) +(let t2088 (OutputJoin t2087 t249)) +(let t2089 (OutputJoin t2088 t251)) +(let t2090 (OutputJoin t2089 t253)) +(let t2091 (OutputJoin t2090 t255)) +(let t2092 (OutputJoin t2091 t257)) +(let t2093 (OutputJoin t2092 t259)) +(let t2094 (OutputJoin t2093 t261)) +(let t2095 (OutputJoin t2094 t263)) +(let t2096 (OutputJoin t2095 t265)) +(let t2097 (OutputJoin t2096 t267)) +(let t2098 (OutputJoin t2097 t269)) +(let t2099 (OutputJoin t2098 t271)) +(let t2100 (OutputJoin t2099 t273)) +(let t2101 (OutputJoin t2100 t275)) +(let t2102 (OutputJoin t2101 t277)) +(let t2103 (OutputJoin t2102 t279)) +(let t2104 (OutputJoin t2103 t281)) +(let t2105 (OutputJoin t2104 t283)) +(let t2106 (OutputJoin t2105 t285)) +(let t2107 (OutputJoin t2106 t287)) +(let t2108 (OutputJoin t2107 t289)) +(let t2109 (OutputJoin t2108 t291)) +(let t2110 (OutputJoin t2109 t293)) +(let t2111 (OutputJoin t2110 t295)) +(let t2112 (OutputJoin t2111 t297)) +(let t2113 (OutputJoin t2112 t299)) +(let t2114 (OutputJoin t2113 t301)) +(let t2115 (OutputJoin t2114 t303)) +(let t2116 (OutputJoin t2115 t305)) +(let t2117 (OutputJoin t2116 t307)) +(let t2118 (OutputJoin t2117 t309)) +(let t2119 (OutputJoin t2118 t311)) +(let t2120 (OutputJoin t2119 t313)) +(let t2121 (OutputJoin t2120 t315)) +(let t2122 (OutputJoin t2121 t317)) +(let t2123 (OutputJoin t2122 t319)) +(let t2124 (OutputJoin t2123 t321)) +(let t2125 (OutputJoin t2124 t323)) +(let t2126 (OutputJoin t2125 t325)) +(let t2127 (OutputJoin t2126 t327)) +(let t2128 (OutputJoin t2127 t329)) +(let t2129 (OutputJoin t2128 t331)) +(let t2130 (OutputJoin t2129 t333)) +(let t2131 (OutputJoin t2130 t335)) +(let t2132 (OutputJoin t2131 t337)) +(let t2133 (OutputJoin t2132 t339)) +(let t2134 (OutputJoin t2133 t341)) +(let t2135 (OutputJoin t2134 t343)) +(let t2136 (OutputJoin t2135 t345)) +(let t2137 (OutputJoin t2136 t347)) +(let t2138 (OutputJoin t2137 t349)) +(let t2139 (OutputJoin t2138 t351)) +(let t2140 (OutputJoin t2139 t353)) +(let t2141 (OutputJoin t2140 t355)) +(let t2142 (OutputJoin t2141 t357)) +(let t2143 (OutputJoin t2142 t359)) +(let t2144 (OutputJoin t2143 t361)) +(let t2145 (OutputJoin t2144 t363)) +(let t2146 (OutputJoin t2145 t365)) +(let t2147 (OutputJoin t2146 t367)) +(let t2148 (OutputJoin t2147 t369)) +(let t2149 (OutputJoin t2148 t371)) +(let t2150 (OutputJoin t2149 t373)) +(let t2151 (OutputJoin t2150 t375)) +(let t2152 (OutputJoin t2151 t377)) +(let t2153 (OutputJoin t2152 t379)) +(let t2154 (OutputJoin t2153 t381)) +(let t2155 (OutputJoin t2154 t383)) +(let t2156 (OutputJoin t2155 t385)) +(let t2157 (OutputJoin t2156 t387)) +(let t2158 (OutputJoin t2157 t389)) +(let t2159 (OutputJoin t2158 t391)) +(let t2160 (OutputJoin t2159 t393)) +(let t2161 (OutputJoin t2160 t395)) +(let t2162 (OutputJoin t2161 t397)) +(let t2163 (OutputJoin t2162 t399)) +(let t2164 (OutputJoin t2163 t401)) +(let t2165 (OutputJoin t2164 t403)) +(let t2166 (OutputJoin t2165 t405)) +(let t2167 (OutputJoin t2166 t407)) +(let t2168 (OutputJoin t2167 t409)) +(let t2169 (OutputJoin t2168 t411)) +(let t2170 (OutputJoin t2169 t413)) +(let t2171 (OutputJoin t2170 t415)) +(let t2172 (OutputJoin t2171 t417)) +(let t2173 (OutputJoin t2172 t419)) +(let t2174 (OutputJoin t2173 t421)) +(let t2175 (OutputJoin t2174 t423)) +(let t2176 (OutputJoin t2175 t425)) +(let t2177 (OutputJoin t2176 t427)) +(let t2178 (OutputJoin t2177 t429)) +(let t2179 (OutputJoin t2178 t431)) +(let t2180 (OutputJoin t2179 t433)) +(let t2181 (OutputJoin t2180 t435)) +(let t2182 (OutputJoin t2181 t437)) +(let t2183 (OutputJoin t2182 t439)) +(let t2184 (OutputJoin t2183 t441)) +(let t2185 (OutputJoin t2184 t443)) +(let t2186 (OutputJoin t2185 t445)) +(let t2187 (OutputJoin t2186 t447)) +(let t2188 (OutputJoin t2187 t449)) +(let t2189 (OutputJoin t2188 t451)) +(let t2190 (OutputJoin t2189 t453)) +(let t2191 (OutputJoin t2190 t455)) +(let t2192 (OutputJoin t2191 t457)) +(let t2193 (OutputJoin t2192 t459)) +(let t2194 (OutputJoin t2193 t461)) +(let t2195 (OutputJoin t2194 t463)) +(let t2196 (OutputJoin t2195 t465)) +(let t2197 (OutputJoin t2196 t467)) +(let t2198 (OutputJoin t2197 t469)) +(let t2199 (OutputJoin t2198 t471)) +(let t2200 (OutputJoin t2199 t473)) +(let t2201 (OutputJoin t2200 t475)) +(let t2202 (OutputJoin t2201 t477)) +(let t2203 (OutputJoin t2202 t479)) +(let t2204 (OutputJoin t2203 t481)) +(let t2205 (OutputJoin t2204 t483)) +(let t2206 (OutputJoin t2205 t485)) +(let t2207 (OutputJoin t2206 t487)) +(let t2208 (OutputJoin t2207 t489)) +(let t2209 (OutputJoin t2208 t491)) +(let t2210 (OutputJoin t2209 t493)) +(let t2211 (OutputJoin t2210 t495)) +(let t2212 (OutputJoin t2211 t497)) +(let t2213 (OutputJoin t2212 t499)) +(let t2214 (OutputJoin t2213 t501)) +(let t2215 (OutputJoin t2214 t503)) +(let t2216 (OutputJoin t2215 t505)) +(let t2217 (OutputJoin t2216 t507)) +(let t2218 (OutputJoin t2217 t509)) +(let t2219 (OutputJoin t2218 t511)) +(let t2220 (OutputJoin t2219 t513)) +(let t2221 (OutputJoin t2220 t515)) +(let t2222 (OutputJoin t2221 t517)) +(let t2223 (OutputJoin t2222 t519)) +(let t2224 (OutputJoin t2223 t521)) +(let t2225 (OutputJoin t2224 t523)) +(let t2226 (OutputJoin t2225 t525)) +(let t2227 (OutputJoin t2226 t527)) +(let t2228 (OutputJoin t2227 t529)) +(let t2229 (OutputJoin t2228 t531)) +(let t2230 (OutputJoin t2229 t533)) +(let t2231 (OutputJoin t2230 t535)) +(let t2232 (OutputJoin t2231 t537)) +(let t2233 (OutputJoin t2232 t539)) +(let t2234 (OutputJoin t2233 t541)) +(let t2235 (OutputJoin t2234 t543)) +(let t2236 (OutputJoin t2235 t545)) +(let t2237 (OutputJoin t2236 t547)) +(let t2238 (OutputJoin t2237 t549)) +(let t2239 (OutputJoin t2238 t551)) +(let t2240 (OutputJoin t2239 t553)) +(let t2241 (OutputJoin t2240 t555)) +(let t2242 (OutputJoin t2241 t557)) +(let t2243 (OutputJoin t2242 t559)) +(let t2244 (OutputJoin t2243 t561)) +(let t2245 (OutputJoin t2244 t563)) +(let t2246 (OutputJoin t2245 t565)) +(let t2247 (OutputJoin t2246 t567)) +(let t2248 (OutputJoin t2247 t569)) +(let t2249 (OutputJoin t2248 t571)) +(let t2250 (OutputJoin t2249 t573)) +(let t2251 (OutputJoin t2250 t575)) +(let t2252 (OutputJoin t2251 t577)) +(let t2253 (OutputJoin t2252 t579)) +(let t2254 (OutputJoin t2253 t581)) +(let t2255 (OutputJoin t2254 t583)) +(let t2256 (OutputJoin t2255 t585)) +(let t2257 (OutputJoin t2256 t587)) +(let t2258 (OutputJoin t2257 t589)) +(let t2259 (OutputJoin t2258 t591)) +(let t2260 (OutputJoin t2259 t593)) +(let t2261 (OutputJoin t2260 t595)) +(let t2262 (OutputJoin t2261 t597)) +(let t2263 (OutputJoin t2262 t599)) +(let t2264 (OutputJoin t2263 t601)) +(let t2265 (OutputJoin t2264 t603)) +(let t2266 (OutputJoin t2265 t605)) +(let t2267 (OutputJoin t2266 t607)) +(let t2268 (OutputJoin t2267 t609)) +(let t2269 (OutputJoin t2268 t611)) +(let t2270 (OutputJoin t2269 t613)) +(let t2271 (OutputJoin t2270 t615)) +(let t2272 (OutputJoin t2271 t617)) +(let t2273 (OutputJoin t2272 t619)) +(let t2274 (OutputJoin t2273 t621)) +(let t2275 (OutputJoin t2274 t623)) +(let t2276 (OutputJoin t2275 t625)) +(let t2277 (OutputJoin t2276 t627)) +(let t2278 (OutputJoin t2277 t629)) +(let t2279 (OutputJoin t2278 t631)) +(let t2280 (OutputJoin t2279 t633)) +(let t2281 (OutputJoin t2280 t635)) +(let t2282 (OutputJoin t2281 t637)) +(let t2283 (OutputJoin t2282 t639)) +(let t2284 (OutputJoin t2283 t641)) +(let t2285 (OutputJoin t2284 t643)) +(let t2286 (OutputJoin t2285 t645)) +(let t2287 (OutputJoin t2286 t647)) +(let t2288 (OutputJoin t2287 t649)) +(let t2289 (OutputJoin t2288 t651)) +(let t2290 (OutputJoin t2289 t653)) +(let t2291 (OutputJoin t2290 t655)) +(let t2292 (OutputJoin t2291 t657)) +(let t2293 (OutputJoin t2292 t659)) +(let t2294 (OutputJoin t2293 t661)) +(let t2295 (OutputJoin t2294 t663)) +(let t2296 (OutputJoin t2295 t665)) +(let t2297 (OutputJoin t2296 t667)) +(let t2298 (OutputJoin t2297 t669)) +(let t2299 (OutputJoin t2298 t671)) +(let t2300 (OutputJoin t2299 t673)) +(let t2301 (OutputJoin t2300 t675)) +(let t2302 (OutputJoin t2301 t677)) +(let t2303 (OutputJoin t2302 t679)) +(let t2304 (OutputJoin t2303 t681)) +(let t2305 (OutputJoin t2304 t683)) +(let t2306 (OutputJoin t2305 t685)) +(let t2307 (OutputJoin t2306 t687)) +(let t2308 (OutputJoin t2307 t689)) +(let t2309 (OutputJoin t2308 t691)) +(let t2310 (OutputJoin t2309 t693)) +(let t2311 (OutputJoin t2310 t695)) +(let t2312 (OutputJoin t2311 t697)) +(let t2313 (OutputJoin t2312 t699)) +(let t2314 (OutputJoin t2313 t701)) +(let t2315 (OutputJoin t2314 t703)) +(let t2316 (OutputJoin t2315 t705)) +(let t2317 (OutputJoin t2316 t707)) +(let t2318 (OutputJoin t2317 t709)) +(let t2319 (OutputJoin t2318 t711)) +(let t2320 (OutputJoin t2319 t713)) +(let t2321 (OutputJoin t2320 t715)) +(let t2322 (OutputJoin t2321 t717)) +(let t2323 (OutputJoin t2322 t719)) +(let t2324 (OutputJoin t2323 t721)) +(let t2325 (OutputJoin t2324 t723)) +(let t2326 (OutputJoin t2325 t725)) +(let t2327 (OutputJoin t2326 t727)) +(let t2328 (OutputJoin t2327 t729)) +(let t2329 (OutputJoin t2328 t731)) +(let t2330 (OutputJoin t2329 t733)) +(let t2331 (OutputJoin t2330 t735)) +(let t2332 (OutputJoin t2331 t737)) +(let t2333 (OutputJoin t2332 t739)) +(let t2334 (OutputJoin t2333 t741)) +(let t2335 (OutputJoin t2334 t743)) +(let t2336 (OutputJoin t2335 t745)) +(let t2337 (OutputJoin t2336 t747)) +(let t2338 (OutputJoin t2337 t749)) +(let t2339 (OutputJoin t2338 t751)) +(let t2340 (OutputJoin t2339 t753)) +(let t2341 (OutputJoin t2340 t755)) +(let t2342 (OutputJoin t2341 t757)) +(let t2343 (OutputJoin t2342 t759)) +(let t2344 (OutputJoin t2343 t761)) +(let t2345 (OutputJoin t2344 t763)) +(let t2346 (OutputJoin t2345 t765)) +(let t2347 (OutputJoin t2346 t767)) +(let t2348 (OutputJoin t2347 t769)) +(let t2349 (OutputJoin t2348 t771)) +(let t2350 (OutputJoin t2349 t773)) +(let t2351 (OutputJoin t2350 t775)) +(let t2352 (OutputJoin t2351 t777)) +(let t2353 (OutputJoin t2352 t779)) +(let t2354 (OutputJoin t2353 t781)) +(let t2355 (OutputJoin t2354 t783)) +(let t2356 (OutputJoin t2355 t785)) +(let t2357 (OutputJoin t2356 t787)) +(let t2358 (OutputJoin t2357 t789)) +(let t2359 (OutputJoin t2358 t791)) +(let t2360 (OutputJoin t2359 t793)) +(let t2361 (OutputJoin t2360 t795)) +(let t2362 (OutputJoin t2361 t797)) +(let t2363 (OutputJoin t2362 t799)) +(let t2364 (OutputJoin t2363 t801)) +(let t2365 (OutputJoin t2364 t803)) +(let t2366 (OutputJoin t2365 t805)) +(let t2367 (OutputJoin t2366 t807)) +(let t2368 (OutputJoin t2367 t809)) +(let t2369 (OutputJoin t2368 t811)) +(let t2370 (OutputJoin t2369 t813)) +(let t2371 (OutputJoin t2370 t815)) +(let t2372 (OutputJoin t2371 t817)) +(let t2373 (OutputJoin t2372 t819)) +(let t2374 (OutputJoin t2373 t821)) +(let t2375 (OutputJoin t2374 t823)) +(let t2376 (OutputJoin t2375 t825)) +(let t2377 (OutputJoin t2376 t827)) +(let t2378 (OutputJoin t2377 t829)) +(let t2379 (OutputJoin t2378 t831)) +(let t2380 (OutputJoin t2379 t833)) +(let t2381 (OutputJoin t2380 t835)) +(let t2382 (OutputJoin t2381 t837)) +(let t2383 (OutputJoin t2382 t839)) +(let t2384 (OutputJoin t2383 t841)) +(let t2385 (OutputJoin t2384 t843)) +(let t2386 (OutputJoin t2385 t845)) +(let t2387 (OutputJoin t2386 t847)) +(let t2388 (OutputJoin t2387 t849)) +(let t2389 (OutputJoin t2388 t851)) +(let t2390 (OutputJoin t2389 t853)) +(let t2391 (OutputJoin t2390 t855)) +(let t2392 (OutputJoin t2391 t857)) +(let t2393 (OutputJoin t2392 t859)) +(let t2394 (OutputJoin t2393 t861)) +(let t2395 (OutputJoin t2394 t863)) +(let t2396 (OutputJoin t2395 t865)) +(let t2397 (OutputJoin t2396 t867)) +(let t2398 (OutputJoin t2397 t869)) +(let t2399 (OutputJoin t2398 t871)) +(let t2400 (OutputJoin t2399 t873)) +(let t2401 (OutputJoin t2400 t875)) +(let t2402 (OutputJoin t2401 t877)) +(let t2403 (OutputJoin t2402 t879)) +(let t2404 (OutputJoin t2403 t881)) +(let t2405 (OutputJoin t2404 t883)) +(let t2406 (OutputJoin t2405 t885)) +(let t2407 (OutputJoin t2406 t887)) +(let t2408 (OutputJoin t2407 t889)) +(let t2409 (OutputJoin t2408 t891)) +(let t2410 (OutputJoin t2409 t893)) +(let t2411 (OutputJoin t2410 t895)) +(let t2412 (OutputJoin t2411 t897)) +(let t2413 (OutputJoin t2412 t899)) +(let t2414 (OutputJoin t2413 t901)) +(let t2415 (OutputJoin t2414 t903)) +(let t2416 (OutputJoin t2415 t905)) +(let t2417 (OutputJoin t2416 t907)) +(let t2418 (OutputJoin t2417 t909)) +(let t2419 (OutputJoin t2418 t911)) +(let t2420 (OutputJoin t2419 t913)) +(let t2421 (OutputJoin t2420 t915)) +(let t2422 (OutputJoin t2421 t917)) +(let t2423 (OutputJoin t2422 t919)) +(let t2424 (OutputJoin t2423 t921)) +(let t2425 (OutputJoin t2424 t923)) +(let t2426 (OutputJoin t2425 t925)) +(let t2427 (OutputJoin t2426 t927)) +(let t2428 (OutputJoin t2427 t929)) +(let t2429 (OutputJoin t2428 t931)) +(let t2430 (OutputJoin t2429 t933)) +(let t2431 (OutputJoin t2430 t935)) +(let t2432 (OutputJoin t2431 t937)) +(let t2433 (OutputJoin t2432 t939)) +(let t2434 (OutputJoin t2433 t941)) +(let t2435 (OutputJoin t2434 t943)) +(let t2436 (OutputJoin t2435 t945)) +(let t2437 (OutputJoin t2436 t947)) +(let t2438 (OutputJoin t2437 t949)) +(let t2439 (OutputJoin t2438 t951)) +(let t2440 (OutputJoin t2439 t953)) +(let t2441 (OutputJoin t2440 t955)) +(let t2442 (OutputJoin t2441 t957)) +(let t2443 (OutputJoin t2442 t959)) +(let t2444 (OutputJoin t2443 t961)) +(let t2445 (OutputJoin t2444 t963)) +(let t2446 (OutputJoin t2445 t965)) +(let t2447 (OutputJoin t2446 t967)) +(let t2448 (OutputJoin t2447 t969)) +(let t2449 (OutputJoin t2448 t971)) +(let t2450 (OutputJoin t2449 t973)) +(let t2451 (OutputJoin t2450 t975)) +(let t2452 (OutputJoin t2451 t977)) +(let t2453 (OutputJoin t2452 t979)) +(let t2454 (OutputJoin t2453 t981)) +(let t2455 (OutputJoin t2454 t983)) +(let t2456 (OutputJoin t2455 t985)) +(let t2457 (OutputJoin t2456 t987)) +(let t2458 (OutputJoin t2457 t989)) +(let t2459 (OutputJoin t2458 t991)) +(let t2460 (OutputJoin t2459 t993)) +(let t2461 (OutputJoin t2460 t995)) +(let t2462 (OutputJoin t2461 t997)) +(let t2463 (OutputJoin t2462 t999)) +(let t2464 (OutputJoin t2463 t1001)) +(let t2465 (OutputJoin t2464 t1003)) +(let t2466 (OutputJoin t2465 t1005)) +(let t2467 (OutputJoin t2466 t1007)) +(let t2468 (OutputJoin t2467 t1009)) +(let t2469 (OutputJoin t2468 t1011)) +(let t2470 (OutputJoin t2469 t1013)) +(let t2471 (OutputJoin t2470 t1015)) +(let t2472 (OutputJoin t2471 t1017)) +(let t2473 (OutputJoin t2472 t1019)) +(let t2474 (OutputJoin t2473 t1021)) +(let t2475 (OutputJoin t2474 t1023)) +(let t2476 (OutputJoin t2475 t1025)) +(let t2477 (OutputJoin t2476 t1027)) +(let t2478 (OutputJoin t2477 t1029)) +(let t2479 (OutputJoin t2478 t1031)) +(let t2480 (OutputJoin t2479 t1033)) +(let t2481 (OutputJoin t2480 t1035)) +(let t2482 (OutputJoin t2481 t1037)) +(let t2483 (OutputJoin t2482 t1039)) +(let t2484 (OutputJoin t2483 t1041)) +(let t2485 (OutputJoin t2484 t1043)) +(let t2486 (OutputJoin t2485 t1045)) +(let t2487 (OutputJoin t2486 t1047)) +(let t2488 (OutputJoin t2487 t1049)) +(let t2489 (OutputJoin t2488 t1051)) +(let t2490 (OutputJoin t2489 t1053)) +(let t2491 (OutputJoin t2490 t1055)) +(let t2492 (OutputJoin t2491 t1057)) +(let t2493 (OutputJoin t2492 t1059)) +(let t2494 (OutputJoin t2493 t1061)) +(let t2495 (OutputJoin t2494 t1063)) +(let t2496 (OutputJoin t2495 t1065)) +(let t2497 (OutputJoin t2496 t1067)) +(let t2498 (OutputJoin t2497 t1069)) +(let t2499 (OutputJoin t2498 t1071)) +(let t2500 (OutputJoin t2499 t1073)) +(let t2501 (OutputJoin t2500 t1075)) +(let t2502 (OutputJoin t2501 t1077)) +(let t2503 (OutputJoin t2502 t1079)) +(let t2504 (OutputJoin t2503 t1081)) +(let t2505 (OutputJoin t2504 t1083)) +(let t2506 (OutputJoin t2505 t1085)) +(let t2507 (OutputJoin t2506 t1087)) +(let t2508 (OutputJoin t2507 t1089)) +(let t2509 (OutputJoin t2508 t1091)) +(let t2510 (OutputJoin t2509 t1093)) +(let t2511 (OutputJoin t2510 t1095)) +(let t2512 (OutputJoin t2511 t1097)) +(let t2513 (OutputJoin t2512 t1099)) +(let t2514 (OutputJoin t2513 t1101)) +(let t2515 (OutputJoin t2514 t1103)) +(let t2516 (OutputJoin t2515 t1105)) +(let t2517 (OutputJoin t2516 t1107)) +(let t2518 (OutputJoin t2517 t1109)) +(let t2519 (OutputJoin t2518 t1111)) +(let t2520 (OutputJoin t2519 t1113)) +(let t2521 (OutputJoin t2520 t1115)) +(let t2522 (OutputJoin t2521 t1117)) +(let t2523 (OutputJoin t2522 t1119)) +(let t2524 (OutputJoin t2523 t1121)) +(let t2525 (OutputJoin t2524 t1123)) +(let t2526 (OutputJoin t2525 t1125)) +(let t2527 (OutputJoin t2526 t1127)) +(let t2528 (OutputJoin t2527 t1129)) +(let t2529 (OutputJoin t2528 t1131)) +(let t2530 (OutputJoin t2529 t1133)) +(let t2531 (OutputJoin t2530 t1135)) +(let t2532 (OutputJoin t2531 t1137)) +(let t2533 (OutputJoin t2532 t1139)) +(let t2534 (OutputJoin t2533 t1141)) +(let t2535 (OutputJoin t2534 t1143)) +(let t2536 (OutputJoin t2535 t1145)) +(let t2537 (OutputJoin t2536 t1147)) +(let t2538 (OutputJoin t2537 t1149)) +(let t2539 (OutputJoin t2538 t1151)) +(let t2540 (OutputJoin t2539 t1153)) +(let t2541 (OutputJoin t2540 t1155)) +(let t2542 (OutputJoin t2541 t1157)) +(let t2543 (OutputJoin t2542 t1159)) +(let t2544 (OutputJoin t2543 t1161)) +(let t2545 (OutputJoin t2544 t1163)) +(let t2546 (OutputJoin t2545 t1165)) +(let t2547 (OutputJoin t2546 t1167)) +(let t2548 (OutputJoin t2547 t1169)) +(let t2549 (OutputJoin t2548 t1171)) +(let t2550 (OutputJoin t2549 t1173)) +(let t2551 (OutputJoin t2550 t1175)) +(let t2552 (OutputJoin t2551 t1177)) +(let t2553 (OutputJoin t2552 t1179)) +(let t2554 (OutputJoin t2553 t1181)) +(let t2555 (OutputJoin t2554 t1183)) +(let t2556 (OutputJoin t2555 t1185)) +(let t2557 (OutputJoin t2556 t1187)) +(let t2558 (OutputJoin t2557 t1189)) +(let t2559 (OutputJoin t2558 t1191)) +(let t2560 (OutputJoin t2559 t1193)) +(let t2561 (OutputJoin t2560 t1195)) +(let t2562 (OutputJoin t2561 t1197)) +(let t2563 (OutputJoin t2562 t1199)) +(let t2564 (OutputJoin t2563 t1201)) +(let t2565 (OutputJoin t2564 t1203)) +(let t2566 (OutputJoin t2565 t1205)) +(let t2567 (OutputJoin t2566 t1207)) +(let t2568 (OutputJoin t2567 t1209)) +(let t2569 (OutputJoin t2568 t1211)) +(let t2570 (OutputJoin t2569 t1213)) +(let t2571 (OutputJoin t2570 t1215)) +(let t2572 (OutputJoin t2571 t1217)) +(let t2573 (OutputJoin t2572 t1219)) +(let t2574 (OutputJoin t2573 t1221)) +(let t2575 (OutputJoin t2574 t1223)) +(let t2576 (OutputJoin t2575 t1225)) +(let t2577 (OutputJoin t2576 t1227)) +(let t2578 (OutputJoin t2577 t1229)) +(let t2579 (OutputJoin t2578 t1231)) +(let t2580 (OutputJoin t2579 t1233)) +(let t2581 (OutputJoin t2580 t1235)) +(let t2582 (OutputJoin t2581 t1237)) +(let t2583 (OutputJoin t2582 t1239)) +(let t2584 (OutputJoin t2583 t1241)) +(let t2585 (OutputJoin t2584 t1243)) +(let t2586 (OutputJoin t2585 t1245)) +(let t2587 (OutputJoin t2586 t1247)) +(let t2588 (OutputJoin t2587 t1249)) +(let t2589 (OutputJoin t2588 t1251)) +(let t2590 (OutputJoin t2589 t1253)) +(let t2591 (OutputJoin t2590 t1255)) +(let t2592 (OutputJoin t2591 t1772)) +(let t2593 (OutputJoin t2592 t1777)) +(let t2594 (OutputJoin t2593 t1872)) +(let t2595 (OutputJoin t2594 t1779)) +(let t2596 (OutputJoin t2595 t1874)) +(let t2597 (OutputJoin t2596 t1781)) +(let t2598 (OutputJoin t2597 t1876)) +(let t2599 (OutputJoin t2598 t1783)) +(let t2600 (OutputJoin t2599 t1878)) +(let t2601 (OutputJoin t2600 t1785)) +(let t2602 (OutputJoin t2601 t1880)) +(let t2603 (OutputJoin t2602 t1787)) +(let t2604 (OutputJoin t2603 t1882)) +(let t2605 (OutputJoin t2604 t1789)) +(let t2606 (OutputJoin t2605 t1884)) +(let t2607 (OutputJoin t2606 t1791)) +(let t2608 (OutputJoin t2607 t1886)) +(let t2609 (OutputJoin t2608 t1793)) +(let t2610 (OutputJoin t2609 t1888)) +(let t2611 (OutputJoin t2610 t1795)) +(let t2612 (OutputJoin t2611 t1890)) +(let t2613 (OutputJoin t2612 t1797)) +(let t2614 (OutputJoin t2613 t1892)) +(let t2615 (OutputJoin t2614 t1799)) +(let t2616 (OutputJoin t2615 t1894)) +(let t2617 (OutputJoin t2616 t1801)) +(let t2618 (OutputJoin t2617 t1896)) +(let t2619 (OutputJoin t2618 t1803)) +(let t2620 (OutputJoin t2619 t1898)) +(let t2621 (OutputJoin t2620 t1805)) +(let t2622 (OutputJoin t2621 t1900)) +(let t2623 (OutputJoin t2622 t1807)) +(let t2624 (OutputJoin t2623 t1902)) +(let t2625 (OutputJoin t2624 t1809)) +(let t2626 (OutputJoin t2625 t1904)) +(let t2627 (OutputJoin t2626 t1811)) +(let t2628 (OutputJoin t2627 t1906)) +(let t2629 (OutputJoin t2628 t1813)) +(let t2630 (OutputJoin t2629 t1908)) +(let t2631 (OutputJoin t2630 t1815)) +(let t2632 (OutputJoin t2631 t1910)) +(let t2633 (OutputJoin t2632 t1817)) +(let t2634 (OutputJoin t2633 t1912)) +(let t2635 (OutputJoin t2634 t1819)) +(let t2636 (OutputJoin t2635 t1914)) +(let t2637 (OutputJoin t2636 t1821)) +(let t2638 (OutputJoin t2637 t1916)) +(let t2639 (OutputJoin t2638 t1823)) +(let t2640 (OutputJoin t2639 t1918)) +(let t2641 (OutputJoin t2640 t1825)) +(let t2642 (OutputJoin t2641 t1920)) +(let t2643 (OutputJoin t2642 t1827)) +(let t2644 (OutputJoin t2643 t1922)) +(let t2645 (OutputJoin t2644 t1829)) +(let t2646 (OutputJoin t2645 t1924)) +(let t2647 (OutputJoin t2646 t1831)) +(let t2648 (OutputJoin t2647 t1926)) +(let t2649 (OutputJoin t2648 t1833)) +(let t2650 (OutputJoin t2649 t1928)) +(let t2651 (OutputJoin t2650 t1835)) +(let t2652 (OutputJoin t2651 t1930)) +(let t2653 (OutputJoin t2652 t1837)) +(let t2654 (OutputJoin t2653 t1932)) +(let t2655 (OutputJoin t2654 t1839)) +(let t2656 (OutputJoin t2655 t1934)) +(let t2657 (OutputJoin t2656 t1841)) +(let t2658 (OutputJoin t2657 t1936)) +(let t2659 (OutputJoin t2658 t1843)) +(let t2660 (OutputJoin t2659 t1938)) +(let t2661 (OutputJoin t2660 t1845)) +(let t2662 (OutputJoin t2661 t1940)) +(let t2663 (OutputJoin t2662 t1847)) +(let t2664 (OutputJoin t2663 t1942)) +(let t2665 (OutputJoin t2664 t1849)) +(let t2666 (OutputJoin t2665 t1944)) +(let t2667 (OutputJoin t2666 t1851)) +(let t2668 (OutputJoin t2667 t1946)) +(let t2669 (OutputJoin t2668 t1853)) +(let t2670 (OutputJoin t2669 t1948)) +(let t2671 (OutputJoin t2670 t1855)) +(let t2672 (OutputJoin t2671 t1950)) +(let t2673 (OutputJoin t2672 t1857)) +(let t2674 (OutputJoin t2673 t1952)) +(let t2675 (OutputJoin t2674 t1859)) +(let t2676 (OutputJoin t2675 t1954)) +(let t2677 (OutputJoin t2676 t1861)) +(let t2678 (OutputJoin t2677 t1956)) +(let t2679 (OutputJoin t2678 t1863)) +(let t2680 (OutputJoin t2679 t1958)) +(let t2681 (OutputJoin t2680 t1865)) +(let t2682 (OutputJoin t2681 t1960)) +(let t2683 (OutputJoin t2682 t1867)) +(let t2684 (OutputJoin t2683 t1962)) +(let t2685 (OutputJoin t2684 t1869)) +(let t2686 (OutputJoin t2685 t1964)) +(let t2687 (OutputJoin t2686 t1773)) +(let t2688 (OutputJoin t2687 t1774)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) diff --git a/tests/snapshots/files__shared_snapshot_eggcc_2mm.snap b/tests/snapshots/files__shared_snapshot_eggcc_2mm.snap index 95284022..ef90d2fd 100644 --- a/tests/snapshots/files__shared_snapshot_eggcc_2mm.snap +++ b/tests/snapshots/files__shared_snapshot_eggcc_2mm.snap @@ -185,7 +185,7 @@ expression: snapshot_content_across_treatments (Shl 1) (Shr 1) (Single 957) - (Smaller 1826) + (Smaller 1803) (Smax 1) (Smin 1) (StateT 1) @@ -195,7 +195,7 @@ expression: snapshot_content_across_treatments (SuffixAt-List 0) (SuffixAt-List 0) (Switch 0) - (TCPair 2744) + (TCPair 2741) (TCons 318) (TLConcat 1649) (TNil 1) @@ -203,7 +203,7 @@ expression: snapshot_content_across_treatments (TermArg 1) (TermBop 134) (TermCall 0) - (TermConcat 1907) + (TermConcat 1904) (TermCons 0) (TermConst 22) (TermEmpty 0) diff --git a/tests/snapshots/files__shared_snapshot_llama.snap b/tests/snapshots/files__shared_snapshot_llama.snap new file mode 100644 index 00000000..5e858c34 --- /dev/null +++ b/tests/snapshots/files__shared_snapshot_llama.snap @@ -0,0 +1,133 @@ +--- +source: tests/files.rs +expression: snapshot_content_across_treatments +--- +((Add 13) + (Bf16 1) + (Bool 1) + (Cast 7) + (ComputeAttnMask 0) + (Constant 9) + (ConsumedBuffer 0) + (CustomOpKind 0) + (ECons 119) + (ENil 1) + (Exp2 3) + (F16 1) + (F32 1) + (F4E2M1 0) + (F8E4M3 0) + (F8E5M2 0) + (F8UE8M0 0) + (FlashInferAttention 0) + (FusedAdd 13) + (FusedExp 3) + (FusedExp2 3) + (FusedLog2 0) + (FusedMul 20) + (FusedRecip 3) + (FusedSin 1) + (FusedSqrt 1) + (FusionEnd 12) + (FusionStart 30) + (GLUMoE 0) + (Gather 5) + (I4 0) + (ICons 1301) + (INil 1) + (Input 357) + (Int 1) + (Iota 20) + (KernelAdd 14) + (KernelBatchMatMul 0) + (KernelBatchMatVec 0) + (KernelCast 7) + (KernelConstant 9) + (KernelEmbed 0) + (KernelExp 3) + (KernelExp2 3) + (KernelGather 5) + (KernelIota 20) + (KernelLessThan 1) + (KernelLog2 0) + (KernelMax 1) + (KernelMean 0) + (KernelMod 0) + (KernelMul 31) + (KernelRecip 5) + (KernelScatter 2) + (KernelScatterNoCopy 0) + (KernelSigmoid 1) + (KernelSin 1) + (KernelSoftmax 0) + (KernelSqrt 1) + (KernelSum 10) + (LessThan 1) + (Log2 0) + (LoopEnd 1) + (LoopInput 11) + (LoopInputStatic 0) + (LoopOutput 2) + (LoopOutputSelect 62) + (LoopStart 1) + (MAdd 18) + (MAnd 0) + (MCeilDiv 11) + (MDiv 5) + (MFloat 0) + (MFloorTo 0) + (MGte 1) + (MIter 1) + (MLt 1) + (MMax 6) + (MMin 2) + (MMod 4) + (MMul 308) + (MNum 19) + (MOr 0) + (MReplace 0) + (MReplaceList 0) + (MSub 1) + (MVar 2) + (Max 1) + (MkGLUMoEExpertGatherState 0) + (MkGLUMoEExpertIndexState 1) + (MkGLUMoEGateUpState 0) + (MkGLUMoEGemmaDownState 0) + (MkGLUMoEGemmaGELUState 0) + (MkGLUMoESwiGLUDownState 0) + (MkGLUMoESwiGLUState 0) + (MkKernelSigmoidScaledState 2) + (Mod 0) + (Mul 31) + (Op 1249) + (Output 420) + (OutputJoin 419) + (Recip 5) + (RemoveNthFromEnd 0) + (ReplaceNthFromEnd 0) + (RowMajor 0) + (Scatter 2) + (Sin 1) + (Softmax 0) + (Sqrt 1) + (Sum 10) + (TF32 1) + (consumed_buffer_ilist_contains 6804) + (cublaslt 14) + (cublaslt_base_dtype 4) + (cuda_local_memory 1782) + (cuda_output_bytes 199) + (dtype 1089) + (glumoe_expert_gather 0) + (glumoe_expert_index 1) + (glumoe_gate_up 0) + (glumoe_gemma_down 0) + (glumoe_gemma_gelu 0) + (glumoe_swiglu 0) + (glumoe_swiglu_down 0) + (identical_inputs 591) + (kernel_sigmoid_scaled 2) + (len 0) + (n_elements 0) + (nth_from_end 0)) diff --git a/tests/snapshots/files__shared_snapshot_paged_llama.snap b/tests/snapshots/files__shared_snapshot_paged_llama.snap new file mode 100644 index 00000000..b7f81d5a --- /dev/null +++ b/tests/snapshots/files__shared_snapshot_paged_llama.snap @@ -0,0 +1,133 @@ +--- +source: tests/files.rs +expression: snapshot_content_across_treatments +--- +((Add 13) + (Bf16 1) + (Bool 0) + (Cast 5) + (ComputeAttnMask 0) + (Constant 8) + (ConsumedBuffer 0) + (CustomOpKind 0) + (ECons 116) + (ENil 1) + (Exp2 3) + (F16 1) + (F32 1) + (F4E2M1 0) + (F8E4M3 0) + (F8E5M2 0) + (F8UE8M0 0) + (FlashInferAttention 1) + (FusedAdd 10) + (FusedExp 3) + (FusedExp2 3) + (FusedLog2 0) + (FusedMul 19) + (FusedRecip 3) + (FusedSin 1) + (FusedSqrt 1) + (FusionEnd 10) + (FusionStart 25) + (GLUMoE 0) + (Gather 6) + (I4 0) + (ICons 1306) + (INil 1) + (Input 360) + (Int 1) + (Iota 15) + (KernelAdd 13) + (KernelBatchMatMul 0) + (KernelBatchMatVec 0) + (KernelCast 5) + (KernelConstant 8) + (KernelEmbed 0) + (KernelExp 3) + (KernelExp2 3) + (KernelGather 6) + (KernelIota 15) + (KernelLessThan 0) + (KernelLog2 0) + (KernelMax 1) + (KernelMean 0) + (KernelMod 0) + (KernelMul 33) + (KernelRecip 5) + (KernelScatter 2) + (KernelScatterNoCopy 2) + (KernelSigmoid 1) + (KernelSin 1) + (KernelSoftmax 0) + (KernelSqrt 1) + (KernelSum 10) + (LessThan 0) + (Log2 0) + (LoopEnd 1) + (LoopInput 11) + (LoopInputStatic 0) + (LoopOutput 2) + (LoopOutputSelect 62) + (LoopStart 1) + (MAdd 16) + (MAnd 0) + (MCeilDiv 11) + (MDiv 6) + (MFloat 0) + (MFloorTo 0) + (MGte 1) + (MIter 1) + (MLt 1) + (MMax 4) + (MMin 1) + (MMod 4) + (MMul 283) + (MNum 20) + (MOr 0) + (MReplace 0) + (MReplaceList 0) + (MSub 1) + (MVar 2) + (Max 1) + (MkGLUMoEExpertGatherState 0) + (MkGLUMoEExpertIndexState 3) + (MkGLUMoEGateUpState 0) + (MkGLUMoEGemmaDownState 0) + (MkGLUMoEGemmaGELUState 0) + (MkGLUMoESwiGLUDownState 0) + (MkGLUMoESwiGLUState 0) + (MkKernelSigmoidScaledState 2) + (Mod 0) + (Mul 33) + (Op 1235) + (Output 356) + (OutputJoin 355) + (Recip 5) + (RemoveNthFromEnd 0) + (ReplaceNthFromEnd 0) + (RowMajor 0) + (Scatter 2) + (Sin 1) + (Softmax 0) + (Sqrt 1) + (Sum 10) + (TF32 1) + (consumed_buffer_ilist_contains 6846) + (cublaslt 16) + (cublaslt_base_dtype 4) + (cuda_local_memory 1641) + (cuda_output_bytes 184) + (dtype 1024) + (glumoe_expert_gather 0) + (glumoe_expert_index 3) + (glumoe_gate_up 0) + (glumoe_gemma_down 0) + (glumoe_gemma_gelu 0) + (glumoe_swiglu 0) + (glumoe_swiglu_down 0) + (identical_inputs 581) + (kernel_sigmoid_scaled 2) + (len 0) + (n_elements 0) + (nth_from_end 0)) diff --git a/tests/snapshots/files__shared_snapshot_qwen.snap b/tests/snapshots/files__shared_snapshot_qwen.snap new file mode 100644 index 00000000..59902380 --- /dev/null +++ b/tests/snapshots/files__shared_snapshot_qwen.snap @@ -0,0 +1,133 @@ +--- +source: tests/files.rs +expression: snapshot_content_across_treatments +--- +((Add 15) + (Bf16 1) + (Bool 1) + (Cast 7) + (ComputeAttnMask 0) + (Constant 9) + (ConsumedBuffer 0) + (CustomOpKind 0) + (ECons 148) + (ENil 1) + (Exp2 3) + (F16 1) + (F32 1) + (F4E2M1 0) + (F8E4M3 0) + (F8E5M2 0) + (F8UE8M0 0) + (FlashInferAttention 0) + (FusedAdd 15) + (FusedExp 3) + (FusedExp2 3) + (FusedLog2 0) + (FusedMul 26) + (FusedRecip 5) + (FusedSin 1) + (FusedSqrt 3) + (FusionEnd 16) + (FusionStart 40) + (GLUMoE 0) + (Gather 5) + (I4 0) + (ICons 1541) + (INil 1) + (Input 472) + (Int 1) + (Iota 20) + (KernelAdd 16) + (KernelBatchMatMul 0) + (KernelBatchMatVec 0) + (KernelCast 7) + (KernelConstant 9) + (KernelEmbed 0) + (KernelExp 3) + (KernelExp2 3) + (KernelGather 5) + (KernelIota 20) + (KernelLessThan 1) + (KernelLog2 0) + (KernelMax 1) + (KernelMean 0) + (KernelMod 0) + (KernelMul 39) + (KernelRecip 9) + (KernelScatter 2) + (KernelScatterNoCopy 0) + (KernelSigmoid 1) + (KernelSin 1) + (KernelSoftmax 0) + (KernelSqrt 3) + (KernelSum 13) + (LessThan 1) + (Log2 0) + (LoopEnd 1) + (LoopInput 13) + (LoopInputStatic 0) + (LoopOutput 2) + (LoopOutputSelect 70) + (LoopStart 1) + (MAdd 18) + (MAnd 0) + (MCeilDiv 12) + (MDiv 5) + (MFloat 0) + (MFloorTo 0) + (MGte 1) + (MIter 1) + (MLt 1) + (MMax 6) + (MMin 2) + (MMod 4) + (MMul 367) + (MNum 21) + (MOr 0) + (MReplace 0) + (MReplaceList 0) + (MSub 1) + (MVar 2) + (Max 1) + (MkGLUMoEExpertGatherState 0) + (MkGLUMoEExpertIndexState 1) + (MkGLUMoEGateUpState 0) + (MkGLUMoEGemmaDownState 0) + (MkGLUMoEGemmaGELUState 0) + (MkGLUMoESwiGLUDownState 0) + (MkGLUMoESwiGLUState 0) + (MkKernelSigmoidScaledState 2) + (Mod 0) + (Mul 39) + (Op 1429) + (Output 543) + (OutputJoin 542) + (Recip 9) + (RemoveNthFromEnd 0) + (ReplaceNthFromEnd 0) + (RowMajor 0) + (Scatter 2) + (Sin 1) + (Softmax 0) + (Sqrt 3) + (Sum 13) + (TF32 1) + (consumed_buffer_ilist_contains 9700) + (cublaslt 14) + (cublaslt_base_dtype 4) + (cuda_local_memory 2226) + (cuda_output_bytes 231) + (dtype 1372) + (glumoe_expert_gather 0) + (glumoe_expert_index 1) + (glumoe_gate_up 0) + (glumoe_gemma_down 0) + (glumoe_gemma_gelu 0) + (glumoe_swiglu 0) + (glumoe_swiglu_down 0) + (identical_inputs 683) + (kernel_sigmoid_scaled 2) + (len 0) + (n_elements 0) + (nth_from_end 0)) diff --git a/tests/snapshots/files__shared_snapshot_qwen3_moe.snap b/tests/snapshots/files__shared_snapshot_qwen3_moe.snap new file mode 100644 index 00000000..bd495f77 --- /dev/null +++ b/tests/snapshots/files__shared_snapshot_qwen3_moe.snap @@ -0,0 +1,133 @@ +--- +source: tests/files.rs +expression: snapshot_content_across_treatments +--- +((Add 23) + (Bf16 1) + (Bool 1) + (Cast 11) + (ComputeAttnMask 0) + (Constant 10) + (ConsumedBuffer 0) + (CustomOpKind 0) + (ECons 218) + (ENil 1) + (Exp2 4) + (F16 1) + (F32 1) + (F4E2M1 0) + (F8E4M3 0) + (F8E5M2 0) + (F8UE8M0 0) + (FlashInferAttention 0) + (FusedAdd 17) + (FusedExp 4) + (FusedExp2 4) + (FusedLog2 0) + (FusedMul 32) + (FusedRecip 5) + (FusedSin 1) + (FusedSqrt 3) + (FusionEnd 18) + (FusionStart 47) + (GLUMoE 1) + (Gather 9) + (I4 0) + (ICons 1876) + (INil 1) + (Input 629) + (Int 1) + (Iota 29) + (KernelAdd 24) + (KernelBatchMatMul 0) + (KernelBatchMatVec 0) + (KernelCast 11) + (KernelConstant 10) + (KernelEmbed 0) + (KernelExp 4) + (KernelExp2 4) + (KernelGather 9) + (KernelIota 29) + (KernelLessThan 2) + (KernelLog2 0) + (KernelMax 2) + (KernelMean 0) + (KernelMod 0) + (KernelMul 48) + (KernelRecip 10) + (KernelScatter 3) + (KernelScatterNoCopy 0) + (KernelSigmoid 1) + (KernelSin 1) + (KernelSoftmax 0) + (KernelSqrt 3) + (KernelSum 17) + (LessThan 2) + (Log2 0) + (LoopEnd 1) + (LoopInput 13) + (LoopInputStatic 0) + (LoopOutput 2) + (LoopOutputSelect 94) + (LoopStart 1) + (MAdd 24) + (MAnd 0) + (MCeilDiv 15) + (MDiv 7) + (MFloat 0) + (MFloorTo 0) + (MGte 1) + (MIter 1) + (MLt 1) + (MMax 10) + (MMin 2) + (MMod 6) + (MMul 522) + (MNum 32) + (MOr 0) + (MReplace 0) + (MReplaceList 0) + (MSub 1) + (MVar 2) + (Max 2) + (MkGLUMoEExpertGatherState 4) + (MkGLUMoEExpertIndexState 5) + (MkGLUMoEGateUpState 4) + (MkGLUMoEGemmaDownState 0) + (MkGLUMoEGemmaGELUState 0) + (MkGLUMoESwiGLUDownState 2) + (MkGLUMoESwiGLUState 2) + (MkKernelSigmoidScaledState 2) + (Mod 0) + (Mul 47) + (Op 1687) + (Output 724) + (OutputJoin 723) + (Recip 10) + (RemoveNthFromEnd 0) + (ReplaceNthFromEnd 0) + (RowMajor 0) + (Scatter 3) + (Sin 1) + (Softmax 0) + (Sqrt 3) + (Sum 17) + (TF32 1) + (consumed_buffer_ilist_contains 16447) + (cublaslt 10) + (cublaslt_base_dtype 4) + (cuda_local_memory 2845) + (cuda_output_bytes 283) + (dtype 1806) + (glumoe_expert_gather 4) + (glumoe_expert_index 5) + (glumoe_gate_up 4) + (glumoe_gemma_down 0) + (glumoe_gemma_gelu 0) + (glumoe_swiglu 2) + (glumoe_swiglu_down 2) + (identical_inputs 784) + (kernel_sigmoid_scaled 2) + (len 0) + (n_elements 0) + (nth_from_end 0)) diff --git a/tests/snapshots/files__shared_snapshot_whisper.snap b/tests/snapshots/files__shared_snapshot_whisper.snap new file mode 100644 index 00000000..1338d913 --- /dev/null +++ b/tests/snapshots/files__shared_snapshot_whisper.snap @@ -0,0 +1,133 @@ +--- +source: tests/files.rs +expression: snapshot_content_across_treatments +--- +((Add 21) + (Bf16 1) + (Bool 1) + (Cast 6) + (ComputeAttnMask 0) + (Constant 8) + (ConsumedBuffer 0) + (CustomOpKind 0) + (ECons 191) + (ENil 1) + (Exp2 7) + (F16 1) + (F32 1) + (F4E2M1 0) + (F8E4M3 0) + (F8E5M2 0) + (F8UE8M0 0) + (FlashInferAttention 0) + (FusedAdd 20) + (FusedExp 7) + (FusedExp2 7) + (FusedLog2 0) + (FusedMul 34) + (FusedRecip 6) + (FusedSin 0) + (FusedSqrt 2) + (FusionEnd 13) + (FusionStart 40) + (GLUMoE 0) + (Gather 6) + (I4 0) + (ICons 4596) + (INil 1) + (Input 178) + (Int 1) + (Iota 15) + (KernelAdd 22) + (KernelBatchMatMul 0) + (KernelBatchMatVec 0) + (KernelCast 6) + (KernelConstant 8) + (KernelEmbed 0) + (KernelExp 7) + (KernelExp2 7) + (KernelGather 6) + (KernelIota 15) + (KernelLessThan 1) + (KernelLog2 0) + (KernelMax 3) + (KernelMean 0) + (KernelMod 0) + (KernelMul 55) + (KernelRecip 11) + (KernelScatter 1) + (KernelScatterNoCopy 0) + (KernelSigmoid 4) + (KernelSin 0) + (KernelSoftmax 0) + (KernelSqrt 2) + (KernelSum 20) + (LessThan 1) + (Log2 0) + (LoopEnd 2) + (LoopInput 26) + (LoopInputStatic 0) + (LoopOutput 2) + (LoopOutputSelect 8) + (LoopStart 2) + (MAdd 20) + (MAnd 0) + (MCeilDiv 11) + (MDiv 6) + (MFloat 0) + (MFloorTo 0) + (MGte 1) + (MIter 1) + (MLt 1) + (MMax 4) + (MMin 2) + (MMod 5) + (MMul 442) + (MNum 34) + (MOr 0) + (MReplace 0) + (MReplaceList 0) + (MSub 1) + (MVar 2) + (Max 3) + (MkGLUMoEExpertGatherState 0) + (MkGLUMoEExpertIndexState 2) + (MkGLUMoEGateUpState 0) + (MkGLUMoEGemmaDownState 0) + (MkGLUMoEGemmaGELUState 0) + (MkGLUMoESwiGLUDownState 0) + (MkGLUMoESwiGLUState 0) + (MkKernelSigmoidScaledState 7) + (Mod 0) + (Mul 55) + (Op 5142) + (Output 185) + (OutputJoin 184) + (Recip 11) + (RemoveNthFromEnd 0) + (ReplaceNthFromEnd 0) + (RowMajor 0) + (Scatter 1) + (Sin 0) + (Softmax 0) + (Sqrt 2) + (Sum 20) + (TF32 1) + (consumed_buffer_ilist_contains 6605) + (cublaslt 23) + (cublaslt_base_dtype 4) + (cuda_local_memory 2982) + (cuda_output_bytes 204) + (dtype 899) + (glumoe_expert_gather 0) + (glumoe_expert_index 2) + (glumoe_gate_up 0) + (glumoe_gemma_down 0) + (glumoe_gemma_gelu 0) + (glumoe_swiglu 0) + (glumoe_swiglu_down 0) + (identical_inputs 2701) + (kernel_sigmoid_scaled 7) + (len 0) + (n_elements 0) + (nth_from_end 0)) diff --git a/tests/typed_primitive.rs b/tests/typed_primitive.rs index 159e2c92..f60b432c 100644 --- a/tests/typed_primitive.rs +++ b/tests/typed_primitive.rs @@ -15,12 +15,39 @@ use egglog::add_primitive; use egglog::ast::Span; use egglog::constraint::{SimpleTypeConstraint, TypeConstraint}; +use egglog::scheduler::{Matches, Scheduler}; use egglog::sort::{I64Sort, S, StringSort}; use egglog::{ - EGraph, FullPrim, FullState, Primitive, PurePrim, PureState, RawValues, Read, ReadPrim, - ReadState, Value, WritePrim, WriteState, prelude::*, + EGraph, Error, FullPrim, FullState, Primitive, PurePrim, PureState, RawValues, Read, ReadPrim, + ReadState, TypeError, Value, WritePrim, WriteState, prelude::*, }; +/// Assert that `result` failed with `TypeError::AmbiguousPrimitive`. Both direct +/// primitive calls and `unstable-fn` targets report duplicate registrations +/// through this one variant. +#[track_caller] +fn assert_ambiguous_primitive(result: Result) { + assert!( + matches!( + result, + Err(Error::TypeError(TypeError::AmbiguousPrimitive { .. })) + ), + "expected TypeError::AmbiguousPrimitive, got: {result:?}" + ); +} + +/// A scheduler that fires every match. Used by the scheduled-compilation +/// regression test; the rule there fails to compile before any match is +/// produced, so `filter_matches` is never actually reached. +#[derive(Clone)] +struct ChooseAllScheduler; +impl Scheduler for ChooseAllScheduler { + fn filter_matches(&mut self, _rule: &str, _ruleset: &str, matches: &mut Matches) -> bool { + matches.choose_all(); + false + } +} + // --- shared test fixtures --- /// A pure primitive that adds two i64s. Trivially safe in every context. @@ -489,15 +516,83 @@ fn merge_primitives_use_write_context() { /// Direct primitive resolution requires exactly one matching registration for /// `(name, signature, context)`. Two independently registered pure primitives /// both carry valid runtime ids for every context, so a same-signature direct -/// call is ambiguous instead of silently picking one registration. +/// call is ambiguous. Resolution now reports a graceful `TypeError` instead of +/// panicking. +#[test] +fn two_same_signature_registrations_error_on_use() { + let mut egraph = EGraph::default(); + egraph.add_pure_primitive(PureAdd("dup-add"), None); + egraph.add_pure_primitive(PureAdd("dup-add"), None); + + assert_ambiguous_primitive(egraph.parse_and_run_program(None, "(check (= (dup-add 1 2) 3))")); +} + +/// A duplicate same-signature primitive used on a rule's left-hand side (query) +/// is ambiguous in the query (`Pure`) context and reports a graceful error. +#[test] +fn duplicate_primitive_in_rule_query_errors() { + let mut egraph = EGraph::default(); + egraph.add_pure_primitive(PureAdd("dup-add"), None); + egraph.add_pure_primitive(PureAdd("dup-add"), None); + + assert_ambiguous_primitive(egraph.parse_and_run_program( + None, + "(relation R (i64))\n\ + (rule ((R x) (= y (dup-add x x))) ((R y)))", + )); +} + +/// A duplicate same-signature primitive used on a rule's right-hand side +/// (action) is ambiguous in the action (`Write`) context and reports a graceful +/// error. #[test] -#[should_panic(expected = "Ambiguous primitive resolution")] -fn two_same_signature_registrations_panic_on_use() { +fn duplicate_primitive_in_rule_action_errors() { let mut egraph = EGraph::default(); egraph.add_pure_primitive(PureAdd("dup-add"), None); egraph.add_pure_primitive(PureAdd("dup-add"), None); - let _ = egraph.parse_and_run_program(None, "(check (= (dup-add 1 2) 3))"); + assert_ambiguous_primitive(egraph.parse_and_run_program( + None, + "(relation R (i64))\n\ + (function out (i64) i64 :no-merge)\n\ + (rule ((R x)) ((set (out x) (dup-add x x))))", + )); +} + +/// Scheduled rules are re-lowered lazily inside `step_rules_with_scheduler`, so +/// an ambiguity introduced after the rule is defined (here by a second +/// registration of `dup-echo`) only surfaces during scheduled compilation. That +/// compilation happens after the scheduler has taken `rulesets`/`schedulers` out +/// of the EGraph, so this also guards that those fields are restored on error: +/// a second step must reproduce the same graceful error rather than fail with a +/// spurious "no such ruleset". +#[test] +fn duplicate_primitive_in_scheduled_rule_errors_and_restores() { + let mut egraph = EGraph::default(); + // One registration: the rule below lowers cleanly when it is defined. + egraph.add_pure_primitive(PureEcho("dup-echo"), None); + egraph + .parse_and_run_program( + None, + "(sort Fn (UnstableFn (i64) i64))\n\ + (ruleset test)\n\ + (relation R (i64))\n\ + (relation S (i64))\n\ + (rule ((R x)) ((let f (unstable-fn \"dup-echo\")) (S (unstable-app f x))) \ + :ruleset test :name \"uses-dup\")\n\ + (R 0)", + ) + .unwrap(); + + // A second registration makes `dup-echo` ambiguous. + egraph.add_pure_primitive(PureEcho("dup-echo"), None); + let scheduler_id = egraph.add_scheduler(Box::new(ChooseAllScheduler)); + + assert_ambiguous_primitive(egraph.step_rules_with_scheduler(scheduler_id, "test")); + + // If `rulesets`/`schedulers` were not restored, this would fail with a + // "no such ruleset" error instead of reproducing the ambiguity. + assert_ambiguous_primitive(egraph.step_rules_with_scheduler(scheduler_id, "test")); } /// Registering a primitive whose argument type has no corresponding sort must @@ -514,18 +609,20 @@ fn missing_sort_panics_with_type_name() { /// per application context, and duplicate same-signature registrations are /// ambiguous for every context where more than one runtime id matches. #[test] -#[should_panic(expected = "Ambiguous primitive resolution")] -fn unstable_fn_duplicate_primitive_registration_panics_on_build() { +fn unstable_fn_duplicate_primitive_registration_errors_on_build() { let mut egraph = EGraph::default(); egraph.add_pure_primitive(PureEcho("dup-echo"), None); egraph.add_pure_primitive(PureEcho("dup-echo"), None); - let _ = egraph.parse_and_run_program( + // Duplicate same-signature registrations are ambiguous; building the + // `unstable-fn` reference now surfaces the same `TypeError::AmbiguousPrimitive` + // as a direct call instead of panicking. + assert_ambiguous_primitive(egraph.parse_and_run_program( None, "(sort Fn (UnstableFn (i64) i64))\n\ (let $f (unstable-fn \"dup-echo\"))\n\ (check (= (unstable-app $f 7) 7))", - ); + )); } // --- 4x4 unstable-app dispatch matrix --- diff --git a/tests/whisper.egg b/tests/whisper.egg new file mode 100644 index 00000000..908f221e --- /dev/null +++ b/tests/whisper.egg @@ -0,0 +1,1268 @@ +(include "tests/header/luminal-header.egg") +(let t0 (Input 0 "mel" (F32))) +(let t1 (Output t0 0)) +(let t2 (Input 2 "input" (Int))) +(let t3 (Input 3 "pos_ids" (Int))) +(let t4 (Input 4 "kv_cache.0.k" (F32))) +(let t5 (Output t4 4)) +(let t6 (Input 6 "kv_cache.0.v" (F32))) +(let t7 (Output t6 6)) +(let t8 (Input 8 "kv_cache.1.k" (F32))) +(let t9 (Output t8 8)) +(let t10 (Input 10 "kv_cache.1.v" (F32))) +(let t11 (Output t10 10)) +(let t12 (Input 12 "kv_cache.2.k" (F32))) +(let t13 (Output t12 12)) +(let t14 (Input 14 "kv_cache.2.v" (F32))) +(let t15 (Output t14 14)) +(let t16 (Input 16 "kv_cache.3.k" (F32))) +(let t17 (Output t16 16)) +(let t18 (Input 18 "kv_cache.3.v" (F32))) +(let t19 (Output t18 18)) +(let t20 (Input 20 "model.encoder.conv1.weight" (F32))) +(let t21 (Output t20 20)) +(let t22 (Input 22 "model.encoder.conv1.bias" (F32))) +(let t23 (Output t22 22)) +(let t24 (Input 24 "model.encoder.conv2.weight" (F32))) +(let t25 (Output t24 24)) +(let t26 (Input 26 "model.encoder.conv2.bias" (F32))) +(let t27 (Output t26 26)) +(let t28 (Input 28 "model.encoder.embed_positions.weight" (F32))) +(let t29 (Output t28 28)) +(let t30 (Input 30 "model.encoder.layers.0.self_attn.q_proj.weight" (F32))) +(let t31 (Output t30 30)) +(let t32 (Input 32 "model.encoder.layers.0.self_attn.q_proj.bias" (F32))) +(let t33 (Output t32 32)) +(let t34 (Input 34 "model.encoder.layers.0.self_attn.k_proj.weight" (F32))) +(let t35 (Output t34 34)) +(let t36 (Input 36 "model.encoder.layers.0.self_attn.v_proj.weight" (F32))) +(let t37 (Output t36 36)) +(let t38 (Input 38 "model.encoder.layers.0.self_attn.v_proj.bias" (F32))) +(let t39 (Output t38 38)) +(let t40 (Input 40 "model.encoder.layers.0.self_attn.out_proj.weight" (F32))) +(let t41 (Output t40 40)) +(let t42 (Input 42 "model.encoder.layers.0.self_attn.out_proj.bias" (F32))) +(let t43 (Output t42 42)) +(let t44 (Input 44 "model.encoder.layers.0.self_attn_layer_norm.weight" (F32))) +(let t45 (Output t44 44)) +(let t46 (Input 46 "model.encoder.layers.0.self_attn_layer_norm.bias" (F32))) +(let t47 (Output t46 46)) +(let t48 (Input 48 "model.encoder.layers.0.fc1.weight" (F32))) +(let t49 (Output t48 48)) +(let t50 (Input 50 "model.encoder.layers.0.fc1.bias" (F32))) +(let t51 (Output t50 50)) +(let t52 (Input 52 "model.encoder.layers.0.fc2.weight" (F32))) +(let t53 (Output t52 52)) +(let t54 (Input 54 "model.encoder.layers.0.fc2.bias" (F32))) +(let t55 (Output t54 54)) +(let t56 (Input 56 "model.encoder.layers.0.final_layer_norm.weight" (F32))) +(let t57 (Output t56 56)) +(let t58 (Input 58 "model.encoder.layers.0.final_layer_norm.bias" (F32))) +(let t59 (Output t58 58)) +(let t60 (Input 60 "model.encoder.layers.1.self_attn.q_proj.weight" (F32))) +(let t61 (Output t60 60)) +(let t62 (Input 62 "model.encoder.layers.1.self_attn.q_proj.bias" (F32))) +(let t63 (Output t62 62)) +(let t64 (Input 64 "model.encoder.layers.1.self_attn.k_proj.weight" (F32))) +(let t65 (Output t64 64)) +(let t66 (Input 66 "model.encoder.layers.1.self_attn.v_proj.weight" (F32))) +(let t67 (Output t66 66)) +(let t68 (Input 68 "model.encoder.layers.1.self_attn.v_proj.bias" (F32))) +(let t69 (Output t68 68)) +(let t70 (Input 70 "model.encoder.layers.1.self_attn.out_proj.weight" (F32))) +(let t71 (Output t70 70)) +(let t72 (Input 72 "model.encoder.layers.1.self_attn.out_proj.bias" (F32))) +(let t73 (Output t72 72)) +(let t74 (Input 74 "model.encoder.layers.1.self_attn_layer_norm.weight" (F32))) +(let t75 (Output t74 74)) +(let t76 (Input 76 "model.encoder.layers.1.self_attn_layer_norm.bias" (F32))) +(let t77 (Output t76 76)) +(let t78 (Input 78 "model.encoder.layers.1.fc1.weight" (F32))) +(let t79 (Output t78 78)) +(let t80 (Input 80 "model.encoder.layers.1.fc1.bias" (F32))) +(let t81 (Output t80 80)) +(let t82 (Input 82 "model.encoder.layers.1.fc2.weight" (F32))) +(let t83 (Output t82 82)) +(let t84 (Input 84 "model.encoder.layers.1.fc2.bias" (F32))) +(let t85 (Output t84 84)) +(let t86 (Input 86 "model.encoder.layers.1.final_layer_norm.weight" (F32))) +(let t87 (Output t86 86)) +(let t88 (Input 88 "model.encoder.layers.1.final_layer_norm.bias" (F32))) +(let t89 (Output t88 88)) +(let t90 (Input 90 "model.encoder.layers.2.self_attn.q_proj.weight" (F32))) +(let t91 (Output t90 90)) +(let t92 (Input 92 "model.encoder.layers.2.self_attn.q_proj.bias" (F32))) +(let t93 (Output t92 92)) +(let t94 (Input 94 "model.encoder.layers.2.self_attn.k_proj.weight" (F32))) +(let t95 (Output t94 94)) +(let t96 (Input 96 "model.encoder.layers.2.self_attn.v_proj.weight" (F32))) +(let t97 (Output t96 96)) +(let t98 (Input 98 "model.encoder.layers.2.self_attn.v_proj.bias" (F32))) +(let t99 (Output t98 98)) +(let t100 (Input 100 "model.encoder.layers.2.self_attn.out_proj.weight" (F32))) +(let t101 (Output t100 100)) +(let t102 (Input 102 "model.encoder.layers.2.self_attn.out_proj.bias" (F32))) +(let t103 (Output t102 102)) +(let t104 (Input 104 "model.encoder.layers.2.self_attn_layer_norm.weight" (F32))) +(let t105 (Output t104 104)) +(let t106 (Input 106 "model.encoder.layers.2.self_attn_layer_norm.bias" (F32))) +(let t107 (Output t106 106)) +(let t108 (Input 108 "model.encoder.layers.2.fc1.weight" (F32))) +(let t109 (Output t108 108)) +(let t110 (Input 110 "model.encoder.layers.2.fc1.bias" (F32))) +(let t111 (Output t110 110)) +(let t112 (Input 112 "model.encoder.layers.2.fc2.weight" (F32))) +(let t113 (Output t112 112)) +(let t114 (Input 114 "model.encoder.layers.2.fc2.bias" (F32))) +(let t115 (Output t114 114)) +(let t116 (Input 116 "model.encoder.layers.2.final_layer_norm.weight" (F32))) +(let t117 (Output t116 116)) +(let t118 (Input 118 "model.encoder.layers.2.final_layer_norm.bias" (F32))) +(let t119 (Output t118 118)) +(let t120 (Input 120 "model.encoder.layers.3.self_attn.q_proj.weight" (F32))) +(let t121 (Output t120 120)) +(let t122 (Input 122 "model.encoder.layers.3.self_attn.q_proj.bias" (F32))) +(let t123 (Output t122 122)) +(let t124 (Input 124 "model.encoder.layers.3.self_attn.k_proj.weight" (F32))) +(let t125 (Output t124 124)) +(let t126 (Input 126 "model.encoder.layers.3.self_attn.v_proj.weight" (F32))) +(let t127 (Output t126 126)) +(let t128 (Input 128 "model.encoder.layers.3.self_attn.v_proj.bias" (F32))) +(let t129 (Output t128 128)) +(let t130 (Input 130 "model.encoder.layers.3.self_attn.out_proj.weight" (F32))) +(let t131 (Output t130 130)) +(let t132 (Input 132 "model.encoder.layers.3.self_attn.out_proj.bias" (F32))) +(let t133 (Output t132 132)) +(let t134 (Input 134 "model.encoder.layers.3.self_attn_layer_norm.weight" (F32))) +(let t135 (Output t134 134)) +(let t136 (Input 136 "model.encoder.layers.3.self_attn_layer_norm.bias" (F32))) +(let t137 (Output t136 136)) +(let t138 (Input 138 "model.encoder.layers.3.fc1.weight" (F32))) +(let t139 (Output t138 138)) +(let t140 (Input 140 "model.encoder.layers.3.fc1.bias" (F32))) +(let t141 (Output t140 140)) +(let t142 (Input 142 "model.encoder.layers.3.fc2.weight" (F32))) +(let t143 (Output t142 142)) +(let t144 (Input 144 "model.encoder.layers.3.fc2.bias" (F32))) +(let t145 (Output t144 144)) +(let t146 (Input 146 "model.encoder.layers.3.final_layer_norm.weight" (F32))) +(let t147 (Output t146 146)) +(let t148 (Input 148 "model.encoder.layers.3.final_layer_norm.bias" (F32))) +(let t149 (Output t148 148)) +(let t150 (Input 150 "model.encoder.layer_norm.weight" (F32))) +(let t151 (Output t150 150)) +(let t152 (Input 152 "model.encoder.layer_norm.bias" (F32))) +(let t153 (Output t152 152)) +(let t154 (Input 154 "model.decoder.embed_tokens.weight" (F32))) +(let t155 (Output t154 154)) +(let t156 (Input 156 "model.decoder.embed_positions.weight" (F32))) +(let t157 (Output t156 156)) +(let t158 (Input 158 "model.decoder.layers.0.self_attn.q_proj.weight" (F32))) +(let t159 (Output t158 158)) +(let t160 (Input 160 "model.decoder.layers.0.self_attn.q_proj.bias" (F32))) +(let t161 (Output t160 160)) +(let t162 (Input 162 "model.decoder.layers.0.self_attn.k_proj.weight" (F32))) +(let t163 (Output t162 162)) +(let t164 (Input 164 "model.decoder.layers.0.self_attn.v_proj.weight" (F32))) +(let t165 (Output t164 164)) +(let t166 (Input 166 "model.decoder.layers.0.self_attn.v_proj.bias" (F32))) +(let t167 (Output t166 166)) +(let t168 (Input 168 "model.decoder.layers.0.self_attn.out_proj.weight" (F32))) +(let t169 (Output t168 168)) +(let t170 (Input 170 "model.decoder.layers.0.self_attn.out_proj.bias" (F32))) +(let t171 (Output t170 170)) +(let t172 (Input 172 "model.decoder.layers.0.self_attn_layer_norm.weight" (F32))) +(let t173 (Output t172 172)) +(let t174 (Input 174 "model.decoder.layers.0.self_attn_layer_norm.bias" (F32))) +(let t175 (Output t174 174)) +(let t176 (Input 176 "model.decoder.layers.0.encoder_attn.q_proj.weight" (F32))) +(let t177 (Output t176 176)) +(let t178 (Input 178 "model.decoder.layers.0.encoder_attn.q_proj.bias" (F32))) +(let t179 (Output t178 178)) +(let t180 (Input 180 "model.decoder.layers.0.encoder_attn.k_proj.weight" (F32))) +(let t181 (Output t180 180)) +(let t182 (Input 182 "model.decoder.layers.0.encoder_attn.v_proj.weight" (F32))) +(let t183 (Output t182 182)) +(let t184 (Input 184 "model.decoder.layers.0.encoder_attn.v_proj.bias" (F32))) +(let t185 (Output t184 184)) +(let t186 (Input 186 "model.decoder.layers.0.encoder_attn.out_proj.weight" (F32))) +(let t187 (Output t186 186)) +(let t188 (Input 188 "model.decoder.layers.0.encoder_attn.out_proj.bias" (F32))) +(let t189 (Output t188 188)) +(let t190 (Input 190 "model.decoder.layers.0.encoder_attn_layer_norm.weight" (F32))) +(let t191 (Output t190 190)) +(let t192 (Input 192 "model.decoder.layers.0.encoder_attn_layer_norm.bias" (F32))) +(let t193 (Output t192 192)) +(let t194 (Input 194 "model.decoder.layers.0.fc1.weight" (F32))) +(let t195 (Output t194 194)) +(let t196 (Input 196 "model.decoder.layers.0.fc1.bias" (F32))) +(let t197 (Output t196 196)) +(let t198 (Input 198 "model.decoder.layers.0.fc2.weight" (F32))) +(let t199 (Output t198 198)) +(let t200 (Input 200 "model.decoder.layers.0.fc2.bias" (F32))) +(let t201 (Output t200 200)) +(let t202 (Input 202 "model.decoder.layers.0.final_layer_norm.weight" (F32))) +(let t203 (Output t202 202)) +(let t204 (Input 204 "model.decoder.layers.0.final_layer_norm.bias" (F32))) +(let t205 (Output t204 204)) +(let t206 (Input 206 "model.decoder.layers.1.self_attn.q_proj.weight" (F32))) +(let t207 (Output t206 206)) +(let t208 (Input 208 "model.decoder.layers.1.self_attn.q_proj.bias" (F32))) +(let t209 (Output t208 208)) +(let t210 (Input 210 "model.decoder.layers.1.self_attn.k_proj.weight" (F32))) +(let t211 (Output t210 210)) +(let t212 (Input 212 "model.decoder.layers.1.self_attn.v_proj.weight" (F32))) +(let t213 (Output t212 212)) +(let t214 (Input 214 "model.decoder.layers.1.self_attn.v_proj.bias" (F32))) +(let t215 (Output t214 214)) +(let t216 (Input 216 "model.decoder.layers.1.self_attn.out_proj.weight" (F32))) +(let t217 (Output t216 216)) +(let t218 (Input 218 "model.decoder.layers.1.self_attn.out_proj.bias" (F32))) +(let t219 (Output t218 218)) +(let t220 (Input 220 "model.decoder.layers.1.self_attn_layer_norm.weight" (F32))) +(let t221 (Output t220 220)) +(let t222 (Input 222 "model.decoder.layers.1.self_attn_layer_norm.bias" (F32))) +(let t223 (Output t222 222)) +(let t224 (Input 224 "model.decoder.layers.1.encoder_attn.q_proj.weight" (F32))) +(let t225 (Output t224 224)) +(let t226 (Input 226 "model.decoder.layers.1.encoder_attn.q_proj.bias" (F32))) +(let t227 (Output t226 226)) +(let t228 (Input 228 "model.decoder.layers.1.encoder_attn.k_proj.weight" (F32))) +(let t229 (Output t228 228)) +(let t230 (Input 230 "model.decoder.layers.1.encoder_attn.v_proj.weight" (F32))) +(let t231 (Output t230 230)) +(let t232 (Input 232 "model.decoder.layers.1.encoder_attn.v_proj.bias" (F32))) +(let t233 (Output t232 232)) +(let t234 (Input 234 "model.decoder.layers.1.encoder_attn.out_proj.weight" (F32))) +(let t235 (Output t234 234)) +(let t236 (Input 236 "model.decoder.layers.1.encoder_attn.out_proj.bias" (F32))) +(let t237 (Output t236 236)) +(let t238 (Input 238 "model.decoder.layers.1.encoder_attn_layer_norm.weight" (F32))) +(let t239 (Output t238 238)) +(let t240 (Input 240 "model.decoder.layers.1.encoder_attn_layer_norm.bias" (F32))) +(let t241 (Output t240 240)) +(let t242 (Input 242 "model.decoder.layers.1.fc1.weight" (F32))) +(let t243 (Output t242 242)) +(let t244 (Input 244 "model.decoder.layers.1.fc1.bias" (F32))) +(let t245 (Output t244 244)) +(let t246 (Input 246 "model.decoder.layers.1.fc2.weight" (F32))) +(let t247 (Output t246 246)) +(let t248 (Input 248 "model.decoder.layers.1.fc2.bias" (F32))) +(let t249 (Output t248 248)) +(let t250 (Input 250 "model.decoder.layers.1.final_layer_norm.weight" (F32))) +(let t251 (Output t250 250)) +(let t252 (Input 252 "model.decoder.layers.1.final_layer_norm.bias" (F32))) +(let t253 (Output t252 252)) +(let t254 (Input 254 "model.decoder.layers.2.self_attn.q_proj.weight" (F32))) +(let t255 (Output t254 254)) +(let t256 (Input 256 "model.decoder.layers.2.self_attn.q_proj.bias" (F32))) +(let t257 (Output t256 256)) +(let t258 (Input 258 "model.decoder.layers.2.self_attn.k_proj.weight" (F32))) +(let t259 (Output t258 258)) +(let t260 (Input 260 "model.decoder.layers.2.self_attn.v_proj.weight" (F32))) +(let t261 (Output t260 260)) +(let t262 (Input 262 "model.decoder.layers.2.self_attn.v_proj.bias" (F32))) +(let t263 (Output t262 262)) +(let t264 (Input 264 "model.decoder.layers.2.self_attn.out_proj.weight" (F32))) +(let t265 (Output t264 264)) +(let t266 (Input 266 "model.decoder.layers.2.self_attn.out_proj.bias" (F32))) +(let t267 (Output t266 266)) +(let t268 (Input 268 "model.decoder.layers.2.self_attn_layer_norm.weight" (F32))) +(let t269 (Output t268 268)) +(let t270 (Input 270 "model.decoder.layers.2.self_attn_layer_norm.bias" (F32))) +(let t271 (Output t270 270)) +(let t272 (Input 272 "model.decoder.layers.2.encoder_attn.q_proj.weight" (F32))) +(let t273 (Output t272 272)) +(let t274 (Input 274 "model.decoder.layers.2.encoder_attn.q_proj.bias" (F32))) +(let t275 (Output t274 274)) +(let t276 (Input 276 "model.decoder.layers.2.encoder_attn.k_proj.weight" (F32))) +(let t277 (Output t276 276)) +(let t278 (Input 278 "model.decoder.layers.2.encoder_attn.v_proj.weight" (F32))) +(let t279 (Output t278 278)) +(let t280 (Input 280 "model.decoder.layers.2.encoder_attn.v_proj.bias" (F32))) +(let t281 (Output t280 280)) +(let t282 (Input 282 "model.decoder.layers.2.encoder_attn.out_proj.weight" (F32))) +(let t283 (Output t282 282)) +(let t284 (Input 284 "model.decoder.layers.2.encoder_attn.out_proj.bias" (F32))) +(let t285 (Output t284 284)) +(let t286 (Input 286 "model.decoder.layers.2.encoder_attn_layer_norm.weight" (F32))) +(let t287 (Output t286 286)) +(let t288 (Input 288 "model.decoder.layers.2.encoder_attn_layer_norm.bias" (F32))) +(let t289 (Output t288 288)) +(let t290 (Input 290 "model.decoder.layers.2.fc1.weight" (F32))) +(let t291 (Output t290 290)) +(let t292 (Input 292 "model.decoder.layers.2.fc1.bias" (F32))) +(let t293 (Output t292 292)) +(let t294 (Input 294 "model.decoder.layers.2.fc2.weight" (F32))) +(let t295 (Output t294 294)) +(let t296 (Input 296 "model.decoder.layers.2.fc2.bias" (F32))) +(let t297 (Output t296 296)) +(let t298 (Input 298 "model.decoder.layers.2.final_layer_norm.weight" (F32))) +(let t299 (Output t298 298)) +(let t300 (Input 300 "model.decoder.layers.2.final_layer_norm.bias" (F32))) +(let t301 (Output t300 300)) +(let t302 (Input 302 "model.decoder.layers.3.self_attn.q_proj.weight" (F32))) +(let t303 (Output t302 302)) +(let t304 (Input 304 "model.decoder.layers.3.self_attn.q_proj.bias" (F32))) +(let t305 (Output t304 304)) +(let t306 (Input 306 "model.decoder.layers.3.self_attn.k_proj.weight" (F32))) +(let t307 (Output t306 306)) +(let t308 (Input 308 "model.decoder.layers.3.self_attn.v_proj.weight" (F32))) +(let t309 (Output t308 308)) +(let t310 (Input 310 "model.decoder.layers.3.self_attn.v_proj.bias" (F32))) +(let t311 (Output t310 310)) +(let t312 (Input 312 "model.decoder.layers.3.self_attn.out_proj.weight" (F32))) +(let t313 (Output t312 312)) +(let t314 (Input 314 "model.decoder.layers.3.self_attn.out_proj.bias" (F32))) +(let t315 (Output t314 314)) +(let t316 (Input 316 "model.decoder.layers.3.self_attn_layer_norm.weight" (F32))) +(let t317 (Output t316 316)) +(let t318 (Input 318 "model.decoder.layers.3.self_attn_layer_norm.bias" (F32))) +(let t319 (Output t318 318)) +(let t320 (Input 320 "model.decoder.layers.3.encoder_attn.q_proj.weight" (F32))) +(let t321 (Output t320 320)) +(let t322 (Input 322 "model.decoder.layers.3.encoder_attn.q_proj.bias" (F32))) +(let t323 (Output t322 322)) +(let t324 (Input 324 "model.decoder.layers.3.encoder_attn.k_proj.weight" (F32))) +(let t325 (Output t324 324)) +(let t326 (Input 326 "model.decoder.layers.3.encoder_attn.v_proj.weight" (F32))) +(let t327 (Output t326 326)) +(let t328 (Input 328 "model.decoder.layers.3.encoder_attn.v_proj.bias" (F32))) +(let t329 (Output t328 328)) +(let t330 (Input 330 "model.decoder.layers.3.encoder_attn.out_proj.weight" (F32))) +(let t331 (Output t330 330)) +(let t332 (Input 332 "model.decoder.layers.3.encoder_attn.out_proj.bias" (F32))) +(let t333 (Output t332 332)) +(let t334 (Input 334 "model.decoder.layers.3.encoder_attn_layer_norm.weight" (F32))) +(let t335 (Output t334 334)) +(let t336 (Input 336 "model.decoder.layers.3.encoder_attn_layer_norm.bias" (F32))) +(let t337 (Output t336 336)) +(let t338 (Input 338 "model.decoder.layers.3.fc1.weight" (F32))) +(let t339 (Output t338 338)) +(let t340 (Input 340 "model.decoder.layers.3.fc1.bias" (F32))) +(let t341 (Output t340 340)) +(let t342 (Input 342 "model.decoder.layers.3.fc2.weight" (F32))) +(let t343 (Output t342 342)) +(let t344 (Input 344 "model.decoder.layers.3.fc2.bias" (F32))) +(let t345 (Output t344 344)) +(let t346 (Input 346 "model.decoder.layers.3.final_layer_norm.weight" (F32))) +(let t347 (Output t346 346)) +(let t348 (Input 348 "model.decoder.layers.3.final_layer_norm.bias" (F32))) +(let t349 (Output t348 348)) +(let t350 (Input 350 "model.decoder.layer_norm.weight" (F32))) +(let t351 (Output t350 350)) +(let t352 (Input 352 "model.decoder.layer_norm.bias" (F32))) +(let t353 (Output t352 352)) +(let t354 (Op (Iota (MAdd (MMin (MMax (MSub (MMod (MIter) (MNum 3002)) (MNum 1)) (MNum 0)) (MNum 2999)) (MMul (MDiv (MIter) (MNum 3002)) (MNum 3000))) (MNum 240160)) (INil))) +(let t355 (Op (Gather (ECons (MNum 80) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MNum 80) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t354 (ICons t0 (INil))))) +(let t356 (Op (Iota (MMul (MGte (MMod (MIter) (MNum 3002)) (MNum 1)) (MLt (MMod (MIter) (MNum 3002)) (MNum 3001))) (MNum 240160)) (INil))) +(let t357 (Op (Cast (MNum 240160) (F32)) (ICons t356 (INil)))) +(let t358 (Op (Mul (ECons (MNum 80) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil)))) (ICons t355 (ICons t357 (INil))))) +(let t359 (Op (Iota (MAdd (MAdd (MMod (MIter) (MNum 3)) (MMod (MDiv (MIter) (MNum 3)) (MNum 3000))) (MMul (MDiv (MIter) (MNum 9000)) (MNum 3002))) (MNum 720000)) (INil))) +(let t360 (Op (Gather (ECons (MNum 80) (ECons (MNum 3000) (ECons (MNum 1) (ECons (MNum 3) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 3)) (MNum 3000)) (ECons (MMul (MIter) (MNum 3)) (ECons (MMul (MIter) (MNum 3)) (ECons (MIter) (ENil))))) (ECons (MNum 80) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil)))) (ICons t359 (ICons t358 (INil))))) +(let t361 (Op (Mul (ECons (MNum 3000) (ECons (MNum 384) (ECons (MNum 240) (ENil)))) (ECons (MMul (MIter) (MNum 3)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 3)) (MNum 3)) (MNum 3000)) (MMod (MIter) (MNum 3))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 240)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 240)) (MNum 384)) (ECons (MMul (MIter) (MNum 240)) (ECons (MIter) (ENil))))) (ICons t360 (ICons t20 (INil))))) +(let t362 (Op (Sum (ECons (MNum 3000) (ECons (MNum 384) (ENil))) (MNum 240) (ECons (MMul (MMul (MIter) (MNum 240)) (MNum 384)) (ECons (MMul (MIter) (MNum 240)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t361 (INil)))) +(let t363 (Op (Add (ECons (MNum 3000) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t362 (ICons t22 (INil))))) +(let t364 (Op (Constant 1.595769) (INil))) +(let t365 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t363 (ICons t364 (INil))))) +(let t366 (Op (Constant 0.044715) (INil))) +(let t367 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t363 (ICons t366 (INil))))) +(let t368 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t367 (ICons t363 (INil))))) +(let t369 (Op (Constant 1.000000) (INil))) +(let t370 (Op (Add (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t368 (ICons t369 (INil))))) +(let t371 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t365 (ICons t370 (INil))))) +(let t372 (Op (Constant -1.000000) (INil))) +(let t373 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t371 (ICons t372 (INil))))) +(let t374 (Op (Constant 1.442695) (INil))) +(let t375 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t373 (ICons t374 (INil))))) +(let t376 (Op (Exp2 (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t375 (INil)))) +(let t377 (Op (Constant 1.000000) (INil))) +(let t378 (Op (Add (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t376 (ICons t377 (INil))))) +(let t379 (Op (Recip (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t378 (INil)))) +(let t380 (Op (Mul (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t363 (ICons t379 (INil))))) +(let t381 (Op (Iota (MAdd (MMin (MMax (MSub (MMod (MIter) (MNum 3002)) (MNum 1)) (MNum 0)) (MNum 2999)) (MMul (MDiv (MIter) (MNum 3002)) (MNum 3000))) (MNum 1152768)) (INil))) +(let t382 (Op (Gather (ECons (MNum 384) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MNum 384) (ECons (MNum 3000) (ENil))) (ECons (MMul (MIter) (MNum 3000)) (ECons (MIter) (ENil)))) (ICons t381 (ICons t380 (INil))))) +(let t383 (Op (Iota (MMul (MGte (MMod (MIter) (MNum 3002)) (MNum 1)) (MLt (MMod (MIter) (MNum 3002)) (MNum 3001))) (MNum 1152768)) (INil))) +(let t384 (Op (Cast (MNum 1152768) (F32)) (ICons t383 (INil)))) +(let t385 (Op (Mul (ECons (MNum 384) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil)))) (ICons t382 (ICons t384 (INil))))) +(let t386 (Op (Iota (MAdd (MAdd (MMod (MIter) (MNum 3)) (MMul (MMod (MDiv (MIter) (MNum 3)) (MDiv (MNum 3001) (MNum 2))) (MNum 2))) (MMul (MDiv (MIter) (MMul (MNum 3) (MDiv (MNum 3001) (MNum 2)))) (MNum 3002))) (MMul (MMul (MNum 384) (MDiv (MNum 3001) (MNum 2))) (MNum 3))) (INil))) +(let t387 (Op (Gather (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1) (ECons (MNum 3) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 3)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 3)) (ECons (MMul (MIter) (MNum 3)) (ECons (MIter) (ENil))))) (ECons (MNum 384) (ECons (MNum 3002) (ENil))) (ECons (MMul (MIter) (MNum 3002)) (ECons (MIter) (ENil)))) (ICons t386 (ICons t385 (INil))))) +(let t388 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 1152) (ENil)))) (ECons (MMul (MIter) (MNum 3)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 3)) (MNum 3)) (MDiv (MNum 3001) (MNum 2))) (MMod (MIter) (MNum 3))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1152)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1152)) (MNum 384)) (ECons (MMul (MIter) (MNum 1152)) (ECons (MIter) (ENil))))) (ICons t387 (ICons t24 (INil))))) +(let t389 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 1152) (ECons (MMul (MMul (MIter) (MNum 1152)) (MNum 384)) (ECons (MMul (MIter) (MNum 1152)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t388 (INil)))) +(let t390 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t389 (ICons t26 (INil))))) +(let t391 (Op (Constant 1.595769) (INil))) +(let t392 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t390 (ICons t391 (INil))))) +(let t393 (Op (Constant 0.044715) (INil))) +(let t394 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t390 (ICons t393 (INil))))) +(let t395 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t394 (ICons t390 (INil))))) +(let t396 (Op (Constant 1.000000) (INil))) +(let t397 (Op (Add (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t395 (ICons t396 (INil))))) +(let t398 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t392 (ICons t397 (INil))))) +(let t399 (Op (Constant -1.000000) (INil))) +(let t400 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t398 (ICons t399 (INil))))) +(let t401 (Op (Constant 1.442695) (INil))) +(let t402 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t400 (ICons t401 (INil))))) +(let t403 (Op (Exp2 (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t402 (INil)))) +(let t404 (Op (Constant 1.000000) (INil))) +(let t405 (Op (Add (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t403 (ICons t404 (INil))))) +(let t406 (Op (Recip (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t405 (INil)))) +(let t407 (Op (Mul (ECons (MNum 384) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t390 (ICons t406 (INil))))) +(let t408 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t407 (ICons t28 (INil))))) +(let t409 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t408 (INil)))) +(let t410 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t411 (Op (Cast (MNum 1) (F32)) (ICons t410 (INil)))) +(let t412 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t411 (INil)))) +(let t413 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t409 (ICons t412 (INil))))) +(let t414 (Op (Constant -1.000000) (INil))) +(let t415 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t413 (ICons t414 (INil))))) +(let t416 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t408 (ICons t415 (INil))))) +(let t417 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t416 (ICons t416 (INil))))) +(let t418 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t417 (INil)))) +(let t419 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t420 (Op (Cast (MNum 1) (F32)) (ICons t419 (INil)))) +(let t421 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t420 (INil)))) +(let t422 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t418 (ICons t421 (INil))))) +(let t423 (Op (Constant 0.000010) (INil))) +(let t424 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t422 (ICons t423 (INil))))) +(let t425 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t424 (INil)))) +(let t426 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t425 (INil)))) +(let t427 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t426 (ICons t416 (INil))))) +(let t428 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t427 (ICons t44 (INil))))) +(let t429 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t428 (ICons t46 (INil))))) +(let t430 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t429 (ICons t30 (INil))))) +(let t431 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t430 (INil)))) +(let t432 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t431 (ICons t32 (INil))))) +(let t433 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t429 (ICons t34 (INil))))) +(let t434 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t433 (INil)))) +(let t435 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t429 (ICons t36 (INil))))) +(let t436 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t435 (INil)))) +(let t437 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t436 (ICons t38 (INil))))) +(let t438 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t432 (ICons t434 (INil))))) +(let t439 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t438 (INil)))) +(let t440 (Op (Constant 0.125000) (INil))) +(let t441 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t439 (ICons t440 (INil))))) +(let t442 (Op (Max (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t441 (INil)))) +(let t443 (Op (Constant -1.000000) (INil))) +(let t444 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t442 (ICons t443 (INil))))) +(let t445 (Op (Add (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t441 (ICons t444 (INil))))) +(let t446 (Op (Constant 1.442695) (INil))) +(let t447 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t445 (ICons t446 (INil))))) +(let t448 (Op (Exp2 (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t447 (INil)))) +(let t449 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t448 (INil)))) +(let t450 (Op (Recip (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t449 (INil)))) +(let t451 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t448 (ICons t450 (INil))))) +(let t452 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))))) (ICons t451 (ICons t437 (INil))))) +(let t453 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil)))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t452 (INil)))) +(let t454 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t453 (ICons t40 (INil))))) +(let t455 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t454 (INil)))) +(let t456 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t455 (ICons t42 (INil))))) +(let t457 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t408 (ICons t456 (INil))))) +(let t458 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t457 (INil)))) +(let t459 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t460 (Op (Cast (MNum 1) (F32)) (ICons t459 (INil)))) +(let t461 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t460 (INil)))) +(let t462 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t458 (ICons t461 (INil))))) +(let t463 (Op (Constant -1.000000) (INil))) +(let t464 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t462 (ICons t463 (INil))))) +(let t465 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t457 (ICons t464 (INil))))) +(let t466 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t465 (ICons t465 (INil))))) +(let t467 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t466 (INil)))) +(let t468 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t469 (Op (Cast (MNum 1) (F32)) (ICons t468 (INil)))) +(let t470 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t469 (INil)))) +(let t471 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t467 (ICons t470 (INil))))) +(let t472 (Op (Constant 0.000010) (INil))) +(let t473 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t471 (ICons t472 (INil))))) +(let t474 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t473 (INil)))) +(let t475 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t474 (INil)))) +(let t476 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t475 (ICons t465 (INil))))) +(let t477 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t476 (ICons t56 (INil))))) +(let t478 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t477 (ICons t58 (INil))))) +(let t479 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t478 (ICons t48 (INil))))) +(let t480 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t479 (INil)))) +(let t481 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t480 (ICons t50 (INil))))) +(let t482 (Op (Constant 1.595769) (INil))) +(let t483 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t481 (ICons t482 (INil))))) +(let t484 (Op (Constant 0.044715) (INil))) +(let t485 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t481 (ICons t484 (INil))))) +(let t486 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t485 (ICons t481 (INil))))) +(let t487 (Op (Constant 1.000000) (INil))) +(let t488 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t486 (ICons t487 (INil))))) +(let t489 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t483 (ICons t488 (INil))))) +(let t490 (Op (Constant -1.000000) (INil))) +(let t491 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t489 (ICons t490 (INil))))) +(let t492 (Op (Constant 1.442695) (INil))) +(let t493 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t491 (ICons t492 (INil))))) +(let t494 (Op (Exp2 (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t493 (INil)))) +(let t495 (Op (Constant 1.000000) (INil))) +(let t496 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t494 (ICons t495 (INil))))) +(let t497 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t496 (INil)))) +(let t498 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t481 (ICons t497 (INil))))) +(let t499 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t498 (ICons t52 (INil))))) +(let t500 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 1536) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t499 (INil)))) +(let t501 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t500 (ICons t54 (INil))))) +(let t502 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t457 (ICons t501 (INil))))) +(let t503 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t502 (INil)))) +(let t504 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t505 (Op (Cast (MNum 1) (F32)) (ICons t504 (INil)))) +(let t506 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t505 (INil)))) +(let t507 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t503 (ICons t506 (INil))))) +(let t508 (Op (Constant -1.000000) (INil))) +(let t509 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t507 (ICons t508 (INil))))) +(let t510 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t502 (ICons t509 (INil))))) +(let t511 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t510 (ICons t510 (INil))))) +(let t512 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t511 (INil)))) +(let t513 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t514 (Op (Cast (MNum 1) (F32)) (ICons t513 (INil)))) +(let t515 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t514 (INil)))) +(let t516 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t512 (ICons t515 (INil))))) +(let t517 (Op (Constant 0.000010) (INil))) +(let t518 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t516 (ICons t517 (INil))))) +(let t519 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t518 (INil)))) +(let t520 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t519 (INil)))) +(let t521 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t520 (ICons t510 (INil))))) +(let t522 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t521 (ICons t74 (INil))))) +(let t523 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t522 (ICons t76 (INil))))) +(let t524 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t523 (ICons t60 (INil))))) +(let t525 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t524 (INil)))) +(let t526 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t525 (ICons t62 (INil))))) +(let t527 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t523 (ICons t64 (INil))))) +(let t528 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t527 (INil)))) +(let t529 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t523 (ICons t66 (INil))))) +(let t530 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t529 (INil)))) +(let t531 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t530 (ICons t68 (INil))))) +(let t532 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t526 (ICons t528 (INil))))) +(let t533 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t532 (INil)))) +(let t534 (Op (Constant 0.125000) (INil))) +(let t535 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t533 (ICons t534 (INil))))) +(let t536 (Op (Max (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t535 (INil)))) +(let t537 (Op (Constant -1.000000) (INil))) +(let t538 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t536 (ICons t537 (INil))))) +(let t539 (Op (Add (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t535 (ICons t538 (INil))))) +(let t540 (Op (Constant 1.442695) (INil))) +(let t541 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t539 (ICons t540 (INil))))) +(let t542 (Op (Exp2 (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t541 (INil)))) +(let t543 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t542 (INil)))) +(let t544 (Op (Recip (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t543 (INil)))) +(let t545 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t542 (ICons t544 (INil))))) +(let t546 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))))) (ICons t545 (ICons t531 (INil))))) +(let t547 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil)))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t546 (INil)))) +(let t548 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t547 (ICons t70 (INil))))) +(let t549 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t548 (INil)))) +(let t550 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t549 (ICons t72 (INil))))) +(let t551 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t502 (ICons t550 (INil))))) +(let t552 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t551 (INil)))) +(let t553 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t554 (Op (Cast (MNum 1) (F32)) (ICons t553 (INil)))) +(let t555 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t554 (INil)))) +(let t556 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t552 (ICons t555 (INil))))) +(let t557 (Op (Constant -1.000000) (INil))) +(let t558 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t556 (ICons t557 (INil))))) +(let t559 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t551 (ICons t558 (INil))))) +(let t560 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t559 (ICons t559 (INil))))) +(let t561 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t560 (INil)))) +(let t562 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t563 (Op (Cast (MNum 1) (F32)) (ICons t562 (INil)))) +(let t564 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t563 (INil)))) +(let t565 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t561 (ICons t564 (INil))))) +(let t566 (Op (Constant 0.000010) (INil))) +(let t567 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t565 (ICons t566 (INil))))) +(let t568 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t567 (INil)))) +(let t569 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t568 (INil)))) +(let t570 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t569 (ICons t559 (INil))))) +(let t571 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t570 (ICons t86 (INil))))) +(let t572 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t571 (ICons t88 (INil))))) +(let t573 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t572 (ICons t78 (INil))))) +(let t574 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t573 (INil)))) +(let t575 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t574 (ICons t80 (INil))))) +(let t576 (Op (Constant 1.595769) (INil))) +(let t577 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t575 (ICons t576 (INil))))) +(let t578 (Op (Constant 0.044715) (INil))) +(let t579 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t575 (ICons t578 (INil))))) +(let t580 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t579 (ICons t575 (INil))))) +(let t581 (Op (Constant 1.000000) (INil))) +(let t582 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t580 (ICons t581 (INil))))) +(let t583 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t577 (ICons t582 (INil))))) +(let t584 (Op (Constant -1.000000) (INil))) +(let t585 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t583 (ICons t584 (INil))))) +(let t586 (Op (Constant 1.442695) (INil))) +(let t587 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t585 (ICons t586 (INil))))) +(let t588 (Op (Exp2 (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t587 (INil)))) +(let t589 (Op (Constant 1.000000) (INil))) +(let t590 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t588 (ICons t589 (INil))))) +(let t591 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t590 (INil)))) +(let t592 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t575 (ICons t591 (INil))))) +(let t593 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t592 (ICons t82 (INil))))) +(let t594 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 1536) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t593 (INil)))) +(let t595 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t594 (ICons t84 (INil))))) +(let t596 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t551 (ICons t595 (INil))))) +(let t597 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t596 (INil)))) +(let t598 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t599 (Op (Cast (MNum 1) (F32)) (ICons t598 (INil)))) +(let t600 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t599 (INil)))) +(let t601 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t597 (ICons t600 (INil))))) +(let t602 (Op (Constant -1.000000) (INil))) +(let t603 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t601 (ICons t602 (INil))))) +(let t604 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t596 (ICons t603 (INil))))) +(let t605 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t604 (ICons t604 (INil))))) +(let t606 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t605 (INil)))) +(let t607 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t608 (Op (Cast (MNum 1) (F32)) (ICons t607 (INil)))) +(let t609 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t608 (INil)))) +(let t610 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t606 (ICons t609 (INil))))) +(let t611 (Op (Constant 0.000010) (INil))) +(let t612 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t610 (ICons t611 (INil))))) +(let t613 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t612 (INil)))) +(let t614 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t613 (INil)))) +(let t615 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t614 (ICons t604 (INil))))) +(let t616 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t615 (ICons t104 (INil))))) +(let t617 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t616 (ICons t106 (INil))))) +(let t618 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t617 (ICons t90 (INil))))) +(let t619 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t618 (INil)))) +(let t620 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t619 (ICons t92 (INil))))) +(let t621 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t617 (ICons t94 (INil))))) +(let t622 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t621 (INil)))) +(let t623 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t617 (ICons t96 (INil))))) +(let t624 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t623 (INil)))) +(let t625 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t624 (ICons t98 (INil))))) +(let t626 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t620 (ICons t622 (INil))))) +(let t627 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t626 (INil)))) +(let t628 (Op (Constant 0.125000) (INil))) +(let t629 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t627 (ICons t628 (INil))))) +(let t630 (Op (Max (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t629 (INil)))) +(let t631 (Op (Constant -1.000000) (INil))) +(let t632 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t630 (ICons t631 (INil))))) +(let t633 (Op (Add (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t629 (ICons t632 (INil))))) +(let t634 (Op (Constant 1.442695) (INil))) +(let t635 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t633 (ICons t634 (INil))))) +(let t636 (Op (Exp2 (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t635 (INil)))) +(let t637 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t636 (INil)))) +(let t638 (Op (Recip (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t637 (INil)))) +(let t639 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t636 (ICons t638 (INil))))) +(let t640 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))))) (ICons t639 (ICons t625 (INil))))) +(let t641 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil)))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t640 (INil)))) +(let t642 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t641 (ICons t100 (INil))))) +(let t643 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t642 (INil)))) +(let t644 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t643 (ICons t102 (INil))))) +(let t645 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t596 (ICons t644 (INil))))) +(let t646 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t645 (INil)))) +(let t647 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t648 (Op (Cast (MNum 1) (F32)) (ICons t647 (INil)))) +(let t649 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t648 (INil)))) +(let t650 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t646 (ICons t649 (INil))))) +(let t651 (Op (Constant -1.000000) (INil))) +(let t652 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t650 (ICons t651 (INil))))) +(let t653 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t645 (ICons t652 (INil))))) +(let t654 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t653 (ICons t653 (INil))))) +(let t655 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t654 (INil)))) +(let t656 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t657 (Op (Cast (MNum 1) (F32)) (ICons t656 (INil)))) +(let t658 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t657 (INil)))) +(let t659 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t655 (ICons t658 (INil))))) +(let t660 (Op (Constant 0.000010) (INil))) +(let t661 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t659 (ICons t660 (INil))))) +(let t662 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t661 (INil)))) +(let t663 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t662 (INil)))) +(let t664 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t663 (ICons t653 (INil))))) +(let t665 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t664 (ICons t116 (INil))))) +(let t666 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t665 (ICons t118 (INil))))) +(let t667 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t666 (ICons t108 (INil))))) +(let t668 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t667 (INil)))) +(let t669 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t668 (ICons t110 (INil))))) +(let t670 (Op (Constant 1.595769) (INil))) +(let t671 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t669 (ICons t670 (INil))))) +(let t672 (Op (Constant 0.044715) (INil))) +(let t673 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t669 (ICons t672 (INil))))) +(let t674 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t673 (ICons t669 (INil))))) +(let t675 (Op (Constant 1.000000) (INil))) +(let t676 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t674 (ICons t675 (INil))))) +(let t677 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t671 (ICons t676 (INil))))) +(let t678 (Op (Constant -1.000000) (INil))) +(let t679 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t677 (ICons t678 (INil))))) +(let t680 (Op (Constant 1.442695) (INil))) +(let t681 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t679 (ICons t680 (INil))))) +(let t682 (Op (Exp2 (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t681 (INil)))) +(let t683 (Op (Constant 1.000000) (INil))) +(let t684 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t682 (ICons t683 (INil))))) +(let t685 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t684 (INil)))) +(let t686 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t669 (ICons t685 (INil))))) +(let t687 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t686 (ICons t112 (INil))))) +(let t688 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 1536) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t687 (INil)))) +(let t689 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t688 (ICons t114 (INil))))) +(let t690 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t645 (ICons t689 (INil))))) +(let t691 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t690 (INil)))) +(let t692 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t693 (Op (Cast (MNum 1) (F32)) (ICons t692 (INil)))) +(let t694 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t693 (INil)))) +(let t695 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t691 (ICons t694 (INil))))) +(let t696 (Op (Constant -1.000000) (INil))) +(let t697 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t695 (ICons t696 (INil))))) +(let t698 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t690 (ICons t697 (INil))))) +(let t699 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t698 (ICons t698 (INil))))) +(let t700 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t699 (INil)))) +(let t701 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t702 (Op (Cast (MNum 1) (F32)) (ICons t701 (INil)))) +(let t703 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t702 (INil)))) +(let t704 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t700 (ICons t703 (INil))))) +(let t705 (Op (Constant 0.000010) (INil))) +(let t706 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t704 (ICons t705 (INil))))) +(let t707 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t706 (INil)))) +(let t708 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t707 (INil)))) +(let t709 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t708 (ICons t698 (INil))))) +(let t710 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t709 (ICons t134 (INil))))) +(let t711 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t710 (ICons t136 (INil))))) +(let t712 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t711 (ICons t120 (INil))))) +(let t713 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t712 (INil)))) +(let t714 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t713 (ICons t122 (INil))))) +(let t715 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t711 (ICons t124 (INil))))) +(let t716 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t715 (INil)))) +(let t717 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t711 (ICons t126 (INil))))) +(let t718 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t717 (INil)))) +(let t719 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t718 (ICons t128 (INil))))) +(let t720 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t714 (ICons t716 (INil))))) +(let t721 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t720 (INil)))) +(let t722 (Op (Constant 0.125000) (INil))) +(let t723 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t721 (ICons t722 (INil))))) +(let t724 (Op (Max (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t723 (INil)))) +(let t725 (Op (Constant -1.000000) (INil))) +(let t726 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t724 (ICons t725 (INil))))) +(let t727 (Op (Add (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t723 (ICons t726 (INil))))) +(let t728 (Op (Constant 1.442695) (INil))) +(let t729 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t727 (ICons t728 (INil))))) +(let t730 (Op (Exp2 (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t729 (INil)))) +(let t731 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ICons t730 (INil)))) +(let t732 (Op (Recip (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t731 (INil)))) +(let t733 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t730 (ICons t732 (INil))))) +(let t734 (Op (Mul (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))))) (ICons t733 (ICons t719 (INil))))) +(let t735 (Op (Sum (ECons (MNum 6) (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil)))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t734 (INil)))) +(let t736 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t735 (ICons t130 (INil))))) +(let t737 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t736 (INil)))) +(let t738 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t737 (ICons t132 (INil))))) +(let t739 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t690 (ICons t738 (INil))))) +(let t740 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t739 (INil)))) +(let t741 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t742 (Op (Cast (MNum 1) (F32)) (ICons t741 (INil)))) +(let t743 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t742 (INil)))) +(let t744 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t740 (ICons t743 (INil))))) +(let t745 (Op (Constant -1.000000) (INil))) +(let t746 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t744 (ICons t745 (INil))))) +(let t747 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t739 (ICons t746 (INil))))) +(let t748 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t747 (ICons t747 (INil))))) +(let t749 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t748 (INil)))) +(let t750 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t751 (Op (Cast (MNum 1) (F32)) (ICons t750 (INil)))) +(let t752 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t751 (INil)))) +(let t753 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t749 (ICons t752 (INil))))) +(let t754 (Op (Constant 0.000010) (INil))) +(let t755 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t753 (ICons t754 (INil))))) +(let t756 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t755 (INil)))) +(let t757 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t756 (INil)))) +(let t758 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t757 (ICons t747 (INil))))) +(let t759 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t758 (ICons t146 (INil))))) +(let t760 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t759 (ICons t148 (INil))))) +(let t761 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t760 (ICons t138 (INil))))) +(let t762 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t761 (INil)))) +(let t763 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t762 (ICons t140 (INil))))) +(let t764 (Op (Constant 1.595769) (INil))) +(let t765 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t763 (ICons t764 (INil))))) +(let t766 (Op (Constant 0.044715) (INil))) +(let t767 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t763 (ICons t766 (INil))))) +(let t768 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t767 (ICons t763 (INil))))) +(let t769 (Op (Constant 1.000000) (INil))) +(let t770 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t768 (ICons t769 (INil))))) +(let t771 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t765 (ICons t770 (INil))))) +(let t772 (Op (Constant -1.000000) (INil))) +(let t773 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t771 (ICons t772 (INil))))) +(let t774 (Op (Constant 1.442695) (INil))) +(let t775 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t773 (ICons t774 (INil))))) +(let t776 (Op (Exp2 (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t775 (INil)))) +(let t777 (Op (Constant 1.000000) (INil))) +(let t778 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t776 (ICons t777 (INil))))) +(let t779 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t778 (INil)))) +(let t780 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t763 (ICons t779 (INil))))) +(let t781 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t780 (ICons t142 (INil))))) +(let t782 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 1536) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t781 (INil)))) +(let t783 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t782 (ICons t144 (INil))))) +(let t784 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t739 (ICons t783 (INil))))) +(let t785 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t784 (INil)))) +(let t786 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t787 (Op (Cast (MNum 1) (F32)) (ICons t786 (INil)))) +(let t788 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t787 (INil)))) +(let t789 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t785 (ICons t788 (INil))))) +(let t790 (Op (Constant -1.000000) (INil))) +(let t791 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t789 (ICons t790 (INil))))) +(let t792 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t784 (ICons t791 (INil))))) +(let t793 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t792 (ICons t792 (INil))))) +(let t794 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t793 (INil)))) +(let t795 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t796 (Op (Cast (MNum 1) (F32)) (ICons t795 (INil)))) +(let t797 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t796 (INil)))) +(let t798 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t794 (ICons t797 (INil))))) +(let t799 (Op (Constant 0.000010) (INil))) +(let t800 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t798 (ICons t799 (INil))))) +(let t801 (Op (Sqrt (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t800 (INil)))) +(let t802 (Op (Recip (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t801 (INil)))) +(let t803 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t802 (ICons t792 (INil))))) +(let t804 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t803 (ICons t150 (INil))))) +(let t805 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t804 (ICons t152 (INil))))) +(let t806 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t807 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t2 (ICons t806 (INil))))) +(let t808 (Op (Iota (MIter) (MNum 384)) (INil))) +(let t809 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t807 (ICons t808 (INil))))) +(let t810 (Op (Gather (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 51864) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t809 (ICons t154 (INil))))) +(let t811 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t812 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t3 (ICons t811 (INil))))) +(let t813 (Op (Iota (MIter) (MNum 384)) (INil))) +(let t814 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t812 (ICons t813 (INil))))) +(let t815 (Op (Gather (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 448) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t814 (ICons t156 (INil))))) +(let t816 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t817 (Op (Cast (MNum 1) (F32)) (ICons t816 (INil)))) +(let t818 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t817 (INil)))) +(let t819 (Op (Constant -1.000000) (INil))) +(let t820 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t821 (Op (Cast (MNum 1) (F32)) (ICons t820 (INil)))) +(let t822 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t821 (INil)))) +(let t823 (Op (Constant 0.000010) (INil))) +(let t824 (Op (Iota (MIter) (MNum 6)) (INil))) +(let t825 (Op (Iota (MNum 28672) (MNum 1)) (INil))) +(let t826 (Op (Mul (ECons (MNum 6) (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t824 (ICons t825 (INil))))) +(let t827 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t828 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t829 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t827 (ICons t828 (INil))))) +(let t830 (Op (Iota (MNum 64) (MNum 1)) (INil))) +(let t831 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t829 (ICons t830 (INil))))) +(let t832 (Op (Iota (MIter) (MNum 64)) (INil))) +(let t833 (Op (Add (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MIter) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t826 (ICons t831 (INil))))) +(let t834 (Op (Add (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t833 (ICons t832 (INil))))) +(let t835 (Op (Constant 0.125000) (INil))) +(let t836 (Op (Iota (MIter) (MVar "s")) (INil))) +(let t837 (Op (Cast (MMax (MVar "s") (MNum 1)) (F32)) (ICons t836 (INil)))) +(let t838 (Op (Iota (MVar "p") (MNum 1)) (INil))) +(let t839 (Op (Cast (MNum 1) (F32)) (ICons t838 (INil)))) +(let t840 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t837 (ICons t839 (INil))))) +(let t841 (Op (Iota (MIter) (MAdd (MVar "p") (MVar "s"))) (INil))) +(let t842 (Op (Cast (MMax (MAdd (MVar "p") (MVar "s")) (MNum 1)) (F32)) (ICons t841 (INil)))) +(let t843 (Op (LessThan (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ICons t840 (ICons t842 (INil))))) +(let t844 (Op (Cast (MMax (MMul (MVar "s") (MAdd (MVar "p") (MVar "s"))) (MNum 1)) (F32)) (ICons t843 (INil)))) +(let t845 (Op (Constant -10000000000.000000) (INil))) +(let t846 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MAdd (MVar "p") (MVar "s")) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil))))) (ICons t844 (ICons t845 (INil))))) +(let t847 (Op (Constant -1.000000) (INil))) +(let t848 (Op (Constant 1.442695) (INil))) +(let t849 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t850 (Op (Cast (MNum 1) (F32)) (ICons t849 (INil)))) +(let t851 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t850 (INil)))) +(let t852 (Op (Constant -1.000000) (INil))) +(let t853 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t854 (Op (Cast (MNum 1) (F32)) (ICons t853 (INil)))) +(let t855 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t854 (INil)))) +(let t856 (Op (Constant 0.000010) (INil))) +(let t857 (Op (Constant 0.125000) (INil))) +(let t858 (Op (Constant -1.000000) (INil))) +(let t859 (Op (Constant 1.442695) (INil))) +(let t860 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t861 (Op (Cast (MNum 1) (F32)) (ICons t860 (INil)))) +(let t862 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t861 (INil)))) +(let t863 (Op (Constant -1.000000) (INil))) +(let t864 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t865 (Op (Cast (MNum 1) (F32)) (ICons t864 (INil)))) +(let t866 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t865 (INil)))) +(let t867 (Op (Constant 0.000010) (INil))) +(let t868 (Op (Constant 1.595769) (INil))) +(let t869 (Op (Constant 0.044715) (INil))) +(let t870 (Op (Constant 1.000000) (INil))) +(let t871 (Op (Constant -1.000000) (INil))) +(let t872 (Op (Constant 1.442695) (INil))) +(let t873 (Op (Constant 1.000000) (INil))) +(let t874 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t875 (Op (Cast (MNum 1) (F32)) (ICons t874 (INil)))) +(let t876 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t875 (INil)))) +(let t877 (Op (Constant -1.000000) (INil))) +(let t878 (Op (Iota (MNum 384) (MNum 1)) (INil))) +(let t879 (Op (Cast (MNum 1) (F32)) (ICons t878 (INil)))) +(let t880 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t879 (INil)))) +(let t881 (Op (Constant 0.000010) (INil))) +(let t882 (LoopStart t810 0 0 (MNum 4) (F32))) +(let t883 (LoopStart t815 0 1 (MNum 4) (F32))) +(let t884 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t882 (ICons t883 (INil))))) +(let t885 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t884 (INil)))) +(let t886 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t885 (ICons t818 (INil))))) +(let t887 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t886 (ICons t819 (INil))))) +(let t888 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t884 (ICons t887 (INil))))) +(let t889 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t888 (ICons t888 (INil))))) +(let t890 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t889 (INil)))) +(let t891 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t890 (ICons t822 (INil))))) +(let t892 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t891 (ICons t823 (INil))))) +(let t893 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t892 (INil)))) +(let t894 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t893 (INil)))) +(let t895 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t894 (ICons t888 (INil))))) +(let t896 (Op (LoopInput 0 2 (F32)) (ICons t172 (ICons t220 (ICons t268 (ICons t316 (INil))))))) +(let t897 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t895 (ICons t896 (INil))))) +(let t898 (Op (LoopInput 0 3 (F32)) (ICons t174 (ICons t222 (ICons t270 (ICons t318 (INil))))))) +(let t899 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t897 (ICons t898 (INil))))) +(let t900 (Op (LoopInput 0 4 (F32)) (ICons t158 (ICons t206 (ICons t254 (ICons t302 (INil))))))) +(let t901 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t899 (ICons t900 (INil))))) +(let t902 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t901 (INil)))) +(let t903 (Op (LoopInput 0 5 (F32)) (ICons t160 (ICons t208 (ICons t256 (ICons t304 (INil))))))) +(let t904 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t902 (ICons t903 (INil))))) +(let t905 (Op (LoopInput 0 6 (F32)) (ICons t162 (ICons t210 (ICons t258 (ICons t306 (INil))))))) +(let t906 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t899 (ICons t905 (INil))))) +(let t907 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t906 (INil)))) +(let t908 (Op (LoopInput 0 7 (F32)) (ICons t164 (ICons t212 (ICons t260 (ICons t308 (INil))))))) +(let t909 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t899 (ICons t908 (INil))))) +(let t910 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t909 (INil)))) +(let t911 (Op (LoopInput 0 8 (F32)) (ICons t166 (ICons t214 (ICons t262 (ICons t310 (INil))))))) +(let t912 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t910 (ICons t911 (INil))))) +(let t913 (Op (LoopInput 0 9 (F32)) (ICons t4 (ICons t8 (ICons t12 (ICons t16 (INil))))))) +(let t914 (Op (Scatter (ECons (MNum 6) (ECons (MNum 448) (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MNum 448)) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t913 (ICons t834 (ICons t907 (INil)))))) +(let t915 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 64)) (MNum 448)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 64)) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t904 (ICons t914 (INil))))) +(let t916 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 64)) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t915 (INil)))) +(let t917 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t916 (ICons t835 (INil))))) +(let t918 (Op (Add (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (MVar "s")) (ECons (MMul (MIter) (MAdd (MVar "p") (MVar "s"))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t917 (ICons t846 (INil))))) +(let t919 (Op (Max (ECons (MNum 6) (ECons (MVar "s") (ENil))) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t918 (INil)))) +(let t920 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t919 (ICons t847 (INil))))) +(let t921 (Op (Add (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t918 (ICons t920 (INil))))) +(let t922 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t921 (ICons t848 (INil))))) +(let t923 (Op (Exp2 (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t922 (INil)))) +(let t924 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ENil))) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t923 (INil)))) +(let t925 (Op (Recip (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t924 (INil)))) +(let t926 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil))))) (ICons t923 (ICons t925 (INil))))) +(let t927 (Op (LoopInput 0 10 (F32)) (ICons t6 (ICons t10 (ICons t14 (ICons t18 (INil))))))) +(let t928 (Op (Scatter (ECons (MNum 6) (ECons (MNum 448) (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MNum 448)) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t927 (ICons t834 (ICons t912 (INil)))))) +(let t929 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ECons (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ENil))))) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MVar "s")) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MIter) (MNum 64)) (MNum 448)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 64)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MNum 64)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MNum 64)) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ECons (MIter) (ENil)))))) (ICons t926 (ICons t928 (INil))))) +(let t930 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s"))) (ECons (MMul (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MNum 64)) (MVar "s")) (ECons (MMul (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (MNum 64)) (ECons (MMul (MIter) (MMin (MNum 448) (MAdd (MVar "p") (MVar "s")))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t929 (INil)))) +(let t931 (Op (LoopInput 0 11 (F32)) (ICons t168 (ICons t216 (ICons t264 (ICons t312 (INil))))))) +(let t932 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MVar "s")) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t930 (ICons t931 (INil))))) +(let t933 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t932 (INil)))) +(let t934 (Op (LoopInput 0 12 (F32)) (ICons t170 (ICons t218 (ICons t266 (ICons t314 (INil))))))) +(let t935 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t933 (ICons t934 (INil))))) +(let t936 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t884 (ICons t935 (INil))))) +(let t937 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t936 (INil)))) +(let t938 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t937 (ICons t851 (INil))))) +(let t939 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t938 (ICons t852 (INil))))) +(let t940 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t936 (ICons t939 (INil))))) +(let t941 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t940 (ICons t940 (INil))))) +(let t942 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t941 (INil)))) +(let t943 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t942 (ICons t855 (INil))))) +(let t944 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t943 (ICons t856 (INil))))) +(let t945 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t944 (INil)))) +(let t946 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t945 (INil)))) +(let t947 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t946 (ICons t940 (INil))))) +(let t948 (Op (LoopInput 0 13 (F32)) (ICons t190 (ICons t238 (ICons t286 (ICons t334 (INil))))))) +(let t949 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t947 (ICons t948 (INil))))) +(let t950 (Op (LoopInput 0 14 (F32)) (ICons t192 (ICons t240 (ICons t288 (ICons t336 (INil))))))) +(let t951 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t949 (ICons t950 (INil))))) +(let t952 (Op (LoopInput 0 15 (F32)) (ICons t176 (ICons t224 (ICons t272 (ICons t320 (INil))))))) +(let t953 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t951 (ICons t952 (INil))))) +(let t954 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t953 (INil)))) +(let t955 (Op (LoopInput 0 16 (F32)) (ICons t178 (ICons t226 (ICons t274 (ICons t322 (INil))))))) +(let t956 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t954 (ICons t955 (INil))))) +(let t957 (Op (LoopInput 0 18 (F32)) (ICons t180 (ICons t228 (ICons t276 (ICons t324 (INil))))))) +(let t958 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t805 (ICons t957 (INil))))) +(let t959 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t958 (INil)))) +(let t960 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 64) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil)))))) (ICons t956 (ICons t959 (INil))))) +(let t961 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (MNum 64) (ECons (MMul (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MMul (MIter) (MNum 64)) (MDiv (MNum 3001) (MNum 2))) (ECons (MMul (MIter) (MNum 64)) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t960 (INil)))) +(let t962 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t961 (ICons t857 (INil))))) +(let t963 (Op (Max (ECons (MNum 6) (ECons (MVar "s") (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t962 (INil)))) +(let t964 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t963 (ICons t858 (INil))))) +(let t965 (Op (Add (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t962 (ICons t964 (INil))))) +(let t966 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MNum 0) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t965 (ICons t859 (INil))))) +(let t967 (Op (Exp2 (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t966 (INil)))) +(let t968 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ENil))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil))) (MIter) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ENil)))) (ICons t967 (INil)))) +(let t969 (Op (Recip (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MIter) (MVar "s")) (ECons (MIter) (ECons (MNum 0) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t968 (INil)))) +(let t970 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MDiv (MNum 3001) (MNum 2)) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil))))) (ICons t967 (ICons t969 (INil))))) +(let t971 (Op (LoopInput 0 19 (F32)) (ICons t182 (ICons t230 (ICons t278 (ICons t326 (INil))))))) +(let t972 (Op (Mul (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t805 (ICons t971 (INil))))) +(let t973 (Op (Sum (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t972 (INil)))) +(let t974 (Op (LoopInput 0 20 (F32)) (ICons t184 (ICons t232 (ICons t280 (ICons t328 (INil))))))) +(let t975 (Op (Add (ECons (MDiv (MNum 3001) (MNum 2)) (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t973 (ICons t974 (INil))))) +(let t976 (Op (Mul (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ECons (MDiv (MNum 3001) (MNum 2)) (ENil))))) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MVar "s")) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MNum 0) (ECons (MIter) (ENil))))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MIter) (ECons (MMul (MIter) (MNum 384)) (ENil))))) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MVar "s")) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ECons (MIter) (ENil)))))) (ICons t970 (ICons t975 (INil))))) +(let t977 (Op (Sum (ECons (MNum 6) (ECons (MVar "s") (ECons (MNum 64) (ENil)))) (MDiv (MNum 3001) (MNum 2)) (ECons (MMul (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (MVar "s")) (ECons (MMul (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (MNum 64)) (ECons (MMul (MIter) (MDiv (MNum 3001) (MNum 2))) (ENil)))) (MIter) (ECons (MMul (MMul (MIter) (MNum 64)) (MVar "s")) (ECons (MMul (MIter) (MNum 64)) (ECons (MIter) (ENil))))) (ICons t976 (INil)))) +(let t978 (Op (LoopInput 0 21 (F32)) (ICons t186 (ICons t234 (ICons t282 (ICons t330 (INil))))))) +(let t979 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 64)) (ECons (MNum 0) (ECons (MAdd (MMul (MMul (MDiv (MIter) (MNum 64)) (MNum 64)) (MVar "s")) (MMod (MIter) (MNum 64))) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t977 (ICons t978 (INil))))) +(let t980 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 384)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t979 (INil)))) +(let t981 (Op (LoopInput 0 22 (F32)) (ICons t188 (ICons t236 (ICons t284 (ICons t332 (INil))))))) +(let t982 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t980 (ICons t981 (INil))))) +(let t983 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t936 (ICons t982 (INil))))) +(let t984 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t983 (INil)))) +(let t985 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t984 (ICons t862 (INil))))) +(let t986 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t985 (ICons t863 (INil))))) +(let t987 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t983 (ICons t986 (INil))))) +(let t988 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t987 (ICons t987 (INil))))) +(let t989 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t988 (INil)))) +(let t990 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t989 (ICons t866 (INil))))) +(let t991 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t990 (ICons t867 (INil))))) +(let t992 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t991 (INil)))) +(let t993 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t992 (INil)))) +(let t994 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t993 (ICons t987 (INil))))) +(let t995 (LoopEnd t983 0 0 (F32))) +(let t996 (Op (LoopInput 0 23 (F32)) (ICons t202 (ICons t250 (ICons t298 (ICons t346 (INil))))))) +(let t997 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t994 (ICons t996 (INil))))) +(let t998 (Op (LoopInput 0 24 (F32)) (ICons t204 (ICons t252 (ICons t300 (ICons t348 (INil))))))) +(let t999 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t997 (ICons t998 (INil))))) +(let t1000 (Op (LoopInput 0 25 (F32)) (ICons t194 (ICons t242 (ICons t290 (ICons t338 (INil))))))) +(let t1001 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t999 (ICons t1000 (INil))))) +(let t1002 (Op (Sum (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 1536)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1001 (INil)))) +(let t1003 (Op (LoopInput 0 26 (F32)) (ICons t196 (ICons t244 (ICons t292 (ICons t340 (INil))))))) +(let t1004 (Op (Add (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1002 (ICons t1003 (INil))))) +(let t1005 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1004 (ICons t868 (INil))))) +(let t1006 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1004 (ICons t869 (INil))))) +(let t1007 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1006 (ICons t1004 (INil))))) +(let t1008 (Op (Add (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1007 (ICons t870 (INil))))) +(let t1009 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1005 (ICons t1008 (INil))))) +(let t1010 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1009 (ICons t871 (INil))))) +(let t1011 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1010 (ICons t872 (INil))))) +(let t1012 (Op (Exp2 (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1011 (INil)))) +(let t1013 (Op (Add (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1012 (ICons t873 (INil))))) +(let t1014 (Op (Recip (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1013 (INil)))) +(let t1015 (Op (Mul (ECons (MVar "s") (ECons (MNum 1536) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ICons t1004 (ICons t1014 (INil))))) +(let t1016 (Op (LoopInput 0 27 (F32)) (ICons t198 (ICons t246 (ICons t294 (ICons t342 (INil))))))) +(let t1017 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ECons (MNum 1536) (ENil)))) (ECons (MMul (MIter) (MNum 1536)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ECons (MIter) (ENil))))) (ICons t1015 (ICons t1016 (INil))))) +(let t1018 (Op (Sum (ECons (MVar "s") (ECons (MNum 384) (ENil))) (MNum 1536) (ECons (MMul (MMul (MIter) (MNum 1536)) (MNum 384)) (ECons (MMul (MIter) (MNum 1536)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1017 (INil)))) +(let t1019 (Op (LoopInput 0 28 (F32)) (ICons t200 (ICons t248 (ICons t296 (ICons t344 (INil))))))) +(let t1020 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1018 (ICons t1019 (INil))))) +(let t1021 (LoopEnd t1020 0 1 (F32))) +(let t1022 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t995 (ICons t1021 (INil))))) +(let t1023 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1022 (INil)))) +(let t1024 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1023 (ICons t876 (INil))))) +(let t1025 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MNum 0) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1024 (ICons t877 (INil))))) +(let t1026 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1022 (ICons t1025 (INil))))) +(let t1027 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1026 (ICons t1026 (INil))))) +(let t1028 (Op (Sum (ECons (MVar "s") (ENil)) (MNum 384) (ECons (MMul (MIter) (MNum 384)) (ENil)) (MIter) (ECons (MIter) (ENil))) (ICons t1027 (INil)))) +(let t1029 (Op (Mul (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1028 (ICons t880 (INil))))) +(let t1030 (Op (Add (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MNum 0) (ENil)) (ECons (MIter) (ENil))) (ICons t1029 (ICons t881 (INil))))) +(let t1031 (Op (Sqrt (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1030 (INil)))) +(let t1032 (Op (Recip (ECons (MVar "s") (ENil)) (ECons (MIter) (ENil)) (ECons (MIter) (ENil))) (ICons t1031 (INil)))) +(let t1033 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MIter) (ECons (MNum 0) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1032 (ICons t1026 (INil))))) +(let t1034 (Op (Mul (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1033 (ICons t350 (INil))))) +(let t1035 (Op (Add (ECons (MVar "s") (ECons (MNum 384) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))) (ECons (MNum 0) (ECons (MIter) (ENil))) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ICons t1034 (ICons t352 (INil))))) +(let t1036 (Op (Mul (ECons (MVar "s") (ECons (MNum 51864) (ECons (MNum 384) (ENil)))) (ECons (MMul (MIter) (MNum 384)) (ECons (MNum 0) (ECons (MIter) (ENil)))) (ECons (MNum 0) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil)))) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 51864)) (ECons (MMul (MIter) (MNum 384)) (ECons (MIter) (ENil))))) (ICons t1035 (ICons t154 (INil))))) +(let t1037 (Op (Sum (ECons (MVar "s") (ECons (MNum 51864) (ENil))) (MNum 384) (ECons (MMul (MMul (MIter) (MNum 384)) (MNum 51864)) (ECons (MMul (MIter) (MNum 384)) (ENil))) (MIter) (ECons (MMul (MIter) (MNum 51864)) (ECons (MIter) (ENil)))) (ICons t1036 (INil)))) +(let t1038 (Output t1037 1511)) +(let t1039 (Op (LoopOutput 0 0 (F32)) (ICons t914 (INil)))) +(let t1040 (Op (LoopOutputSelect 0 0 0 (F32)) (ICons t1039 (INil)))) +(let t1041 (Output t1040 857)) +(let t1042 (Op (LoopOutputSelect 0 0 1 (F32)) (ICons t1039 (INil)))) +(let t1043 (Output t1042 1025)) +(let t1044 (Op (LoopOutputSelect 0 0 2 (F32)) (ICons t1039 (INil)))) +(let t1045 (Output t1044 1193)) +(let t1046 (Op (LoopOutputSelect 0 0 3 (F32)) (ICons t1039 (INil)))) +(let t1047 (Output t1046 1361)) +(let t1048 (Op (LoopOutput 0 1 (F32)) (ICons t928 (INil)))) +(let t1049 (Op (LoopOutputSelect 0 1 0 (F32)) (ICons t1048 (INil)))) +(let t1050 (Output t1049 858)) +(let t1051 (Op (LoopOutputSelect 0 1 1 (F32)) (ICons t1048 (INil)))) +(let t1052 (Output t1051 1026)) +(let t1053 (Op (LoopOutputSelect 0 1 2 (F32)) (ICons t1048 (INil)))) +(let t1054 (Output t1053 1194)) +(let t1055 (Op (LoopOutputSelect 0 1 3 (F32)) (ICons t1048 (INil)))) +(let t1056 (Output t1055 1362)) +(let t1058 (OutputJoin t1 t5)) +(let t1059 (OutputJoin t1058 t7)) +(let t1060 (OutputJoin t1059 t9)) +(let t1061 (OutputJoin t1060 t11)) +(let t1062 (OutputJoin t1061 t13)) +(let t1063 (OutputJoin t1062 t15)) +(let t1064 (OutputJoin t1063 t17)) +(let t1065 (OutputJoin t1064 t19)) +(let t1066 (OutputJoin t1065 t21)) +(let t1067 (OutputJoin t1066 t23)) +(let t1068 (OutputJoin t1067 t25)) +(let t1069 (OutputJoin t1068 t27)) +(let t1070 (OutputJoin t1069 t29)) +(let t1071 (OutputJoin t1070 t31)) +(let t1072 (OutputJoin t1071 t33)) +(let t1073 (OutputJoin t1072 t35)) +(let t1074 (OutputJoin t1073 t37)) +(let t1075 (OutputJoin t1074 t39)) +(let t1076 (OutputJoin t1075 t41)) +(let t1077 (OutputJoin t1076 t43)) +(let t1078 (OutputJoin t1077 t45)) +(let t1079 (OutputJoin t1078 t47)) +(let t1080 (OutputJoin t1079 t49)) +(let t1081 (OutputJoin t1080 t51)) +(let t1082 (OutputJoin t1081 t53)) +(let t1083 (OutputJoin t1082 t55)) +(let t1084 (OutputJoin t1083 t57)) +(let t1085 (OutputJoin t1084 t59)) +(let t1086 (OutputJoin t1085 t61)) +(let t1087 (OutputJoin t1086 t63)) +(let t1088 (OutputJoin t1087 t65)) +(let t1089 (OutputJoin t1088 t67)) +(let t1090 (OutputJoin t1089 t69)) +(let t1091 (OutputJoin t1090 t71)) +(let t1092 (OutputJoin t1091 t73)) +(let t1093 (OutputJoin t1092 t75)) +(let t1094 (OutputJoin t1093 t77)) +(let t1095 (OutputJoin t1094 t79)) +(let t1096 (OutputJoin t1095 t81)) +(let t1097 (OutputJoin t1096 t83)) +(let t1098 (OutputJoin t1097 t85)) +(let t1099 (OutputJoin t1098 t87)) +(let t1100 (OutputJoin t1099 t89)) +(let t1101 (OutputJoin t1100 t91)) +(let t1102 (OutputJoin t1101 t93)) +(let t1103 (OutputJoin t1102 t95)) +(let t1104 (OutputJoin t1103 t97)) +(let t1105 (OutputJoin t1104 t99)) +(let t1106 (OutputJoin t1105 t101)) +(let t1107 (OutputJoin t1106 t103)) +(let t1108 (OutputJoin t1107 t105)) +(let t1109 (OutputJoin t1108 t107)) +(let t1110 (OutputJoin t1109 t109)) +(let t1111 (OutputJoin t1110 t111)) +(let t1112 (OutputJoin t1111 t113)) +(let t1113 (OutputJoin t1112 t115)) +(let t1114 (OutputJoin t1113 t117)) +(let t1115 (OutputJoin t1114 t119)) +(let t1116 (OutputJoin t1115 t121)) +(let t1117 (OutputJoin t1116 t123)) +(let t1118 (OutputJoin t1117 t125)) +(let t1119 (OutputJoin t1118 t127)) +(let t1120 (OutputJoin t1119 t129)) +(let t1121 (OutputJoin t1120 t131)) +(let t1122 (OutputJoin t1121 t133)) +(let t1123 (OutputJoin t1122 t135)) +(let t1124 (OutputJoin t1123 t137)) +(let t1125 (OutputJoin t1124 t139)) +(let t1126 (OutputJoin t1125 t141)) +(let t1127 (OutputJoin t1126 t143)) +(let t1128 (OutputJoin t1127 t145)) +(let t1129 (OutputJoin t1128 t147)) +(let t1130 (OutputJoin t1129 t149)) +(let t1131 (OutputJoin t1130 t151)) +(let t1132 (OutputJoin t1131 t153)) +(let t1133 (OutputJoin t1132 t155)) +(let t1134 (OutputJoin t1133 t157)) +(let t1135 (OutputJoin t1134 t159)) +(let t1136 (OutputJoin t1135 t161)) +(let t1137 (OutputJoin t1136 t163)) +(let t1138 (OutputJoin t1137 t165)) +(let t1139 (OutputJoin t1138 t167)) +(let t1140 (OutputJoin t1139 t169)) +(let t1141 (OutputJoin t1140 t171)) +(let t1142 (OutputJoin t1141 t173)) +(let t1143 (OutputJoin t1142 t175)) +(let t1144 (OutputJoin t1143 t177)) +(let t1145 (OutputJoin t1144 t179)) +(let t1146 (OutputJoin t1145 t181)) +(let t1147 (OutputJoin t1146 t183)) +(let t1148 (OutputJoin t1147 t185)) +(let t1149 (OutputJoin t1148 t187)) +(let t1150 (OutputJoin t1149 t189)) +(let t1151 (OutputJoin t1150 t191)) +(let t1152 (OutputJoin t1151 t193)) +(let t1153 (OutputJoin t1152 t195)) +(let t1154 (OutputJoin t1153 t197)) +(let t1155 (OutputJoin t1154 t199)) +(let t1156 (OutputJoin t1155 t201)) +(let t1157 (OutputJoin t1156 t203)) +(let t1158 (OutputJoin t1157 t205)) +(let t1159 (OutputJoin t1158 t207)) +(let t1160 (OutputJoin t1159 t209)) +(let t1161 (OutputJoin t1160 t211)) +(let t1162 (OutputJoin t1161 t213)) +(let t1163 (OutputJoin t1162 t215)) +(let t1164 (OutputJoin t1163 t217)) +(let t1165 (OutputJoin t1164 t219)) +(let t1166 (OutputJoin t1165 t221)) +(let t1167 (OutputJoin t1166 t223)) +(let t1168 (OutputJoin t1167 t225)) +(let t1169 (OutputJoin t1168 t227)) +(let t1170 (OutputJoin t1169 t229)) +(let t1171 (OutputJoin t1170 t231)) +(let t1172 (OutputJoin t1171 t233)) +(let t1173 (OutputJoin t1172 t235)) +(let t1174 (OutputJoin t1173 t237)) +(let t1175 (OutputJoin t1174 t239)) +(let t1176 (OutputJoin t1175 t241)) +(let t1177 (OutputJoin t1176 t243)) +(let t1178 (OutputJoin t1177 t245)) +(let t1179 (OutputJoin t1178 t247)) +(let t1180 (OutputJoin t1179 t249)) +(let t1181 (OutputJoin t1180 t251)) +(let t1182 (OutputJoin t1181 t253)) +(let t1183 (OutputJoin t1182 t255)) +(let t1184 (OutputJoin t1183 t257)) +(let t1185 (OutputJoin t1184 t259)) +(let t1186 (OutputJoin t1185 t261)) +(let t1187 (OutputJoin t1186 t263)) +(let t1188 (OutputJoin t1187 t265)) +(let t1189 (OutputJoin t1188 t267)) +(let t1190 (OutputJoin t1189 t269)) +(let t1191 (OutputJoin t1190 t271)) +(let t1192 (OutputJoin t1191 t273)) +(let t1193 (OutputJoin t1192 t275)) +(let t1194 (OutputJoin t1193 t277)) +(let t1195 (OutputJoin t1194 t279)) +(let t1196 (OutputJoin t1195 t281)) +(let t1197 (OutputJoin t1196 t283)) +(let t1198 (OutputJoin t1197 t285)) +(let t1199 (OutputJoin t1198 t287)) +(let t1200 (OutputJoin t1199 t289)) +(let t1201 (OutputJoin t1200 t291)) +(let t1202 (OutputJoin t1201 t293)) +(let t1203 (OutputJoin t1202 t295)) +(let t1204 (OutputJoin t1203 t297)) +(let t1205 (OutputJoin t1204 t299)) +(let t1206 (OutputJoin t1205 t301)) +(let t1207 (OutputJoin t1206 t303)) +(let t1208 (OutputJoin t1207 t305)) +(let t1209 (OutputJoin t1208 t307)) +(let t1210 (OutputJoin t1209 t309)) +(let t1211 (OutputJoin t1210 t311)) +(let t1212 (OutputJoin t1211 t313)) +(let t1213 (OutputJoin t1212 t315)) +(let t1214 (OutputJoin t1213 t317)) +(let t1215 (OutputJoin t1214 t319)) +(let t1216 (OutputJoin t1215 t321)) +(let t1217 (OutputJoin t1216 t323)) +(let t1218 (OutputJoin t1217 t325)) +(let t1219 (OutputJoin t1218 t327)) +(let t1220 (OutputJoin t1219 t329)) +(let t1221 (OutputJoin t1220 t331)) +(let t1222 (OutputJoin t1221 t333)) +(let t1223 (OutputJoin t1222 t335)) +(let t1224 (OutputJoin t1223 t337)) +(let t1225 (OutputJoin t1224 t339)) +(let t1226 (OutputJoin t1225 t341)) +(let t1227 (OutputJoin t1226 t343)) +(let t1228 (OutputJoin t1227 t345)) +(let t1229 (OutputJoin t1228 t347)) +(let t1230 (OutputJoin t1229 t349)) +(let t1231 (OutputJoin t1230 t351)) +(let t1232 (OutputJoin t1231 t353)) +(let t1233 (OutputJoin t1232 t1038)) +(let t1234 (OutputJoin t1233 t1041)) +(let t1235 (OutputJoin t1234 t1050)) +(let t1236 (OutputJoin t1235 t1043)) +(let t1237 (OutputJoin t1236 t1052)) +(let t1238 (OutputJoin t1237 t1045)) +(let t1239 (OutputJoin t1238 t1054)) +(let t1240 (OutputJoin t1239 t1047)) +(let t1241 (OutputJoin t1240 t1056)) + +(run-schedule (saturate (seq + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run matmul_flatten) + (run kernel_lower) + (run direct_kernel) + (run kernel_specialize) + (run buffer_reuse) + (run matmul_backend) + (run glumoe) + (run fusion_pair) + )) + (saturate (seq + (saturate expr) + (saturate dtype_prop) + (run fusion_grow) + (run fusion_merge) + )) + ))) +(run-schedule (saturate expr)) +(run-schedule (saturate cleanup)) +(run-schedule (saturate post_cleanup)) +(run-schedule (saturate base_cleanup)) +(run-schedule (saturate cuda_memory_analysis)) From 5da0a5c84607a7da471191b797ffb67098c097b1 Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Sat, 1 Aug 2026 00:36:41 +0000 Subject: [PATCH 4/7] Finish the upstream merge: port the panics upstream turned into errors The merge kept this branch's rewritten `fail` desugaring, `input_file`, and rule registration, so upstream's no-panic conversions had to be reapplied on top of them: an `include` or an empty expansion inside `(fail ...)`, an unknown `(input ...)` target, and a duplicate rule name now return an error. `parallel_execution_keeps_split_phase_timing_unavailable` and the experimental `files` bench move to the per-e-graph thread pool. Co-Authored-By: Claude Opus 5 --- egglog-experimental/benches/files.rs | 5 +- .../core-relations/src/free_join/execute.rs | 4 +- egglog/core-relations/src/tests.rs | 82 +++++++++---------- egglog/src/ast/desugar.rs | 8 ++ egglog/src/lib.rs | 7 +- 5 files changed, 57 insertions(+), 49 deletions(-) diff --git a/egglog-experimental/benches/files.rs b/egglog-experimental/benches/files.rs index fd1a7750..f20f9fb7 100644 --- a/egglog-experimental/benches/files.rs +++ b/egglog-experimental/benches/files.rs @@ -3,7 +3,7 @@ use std::{ path::{Path, PathBuf}, }; -use egglog_experimental::{EGraph, new_experimental_egraph_with_proofs}; +use egglog_experimental::new_experimental_egraph_with_proofs; const CODSPEED_FILES: &[&str] = &[ "egglog/tests/web-demo/rw-analysis.egg", @@ -53,6 +53,8 @@ fn benchmark_cases() -> Vec { #[divan::bench(args = benchmark_cases())] fn files(case: &BenchCase) { let mut egraph = new_experimental_egraph_with_proofs(); + // Benchmark the serial path, independent of the host's core count. + egraph.set_num_threads(1); egraph .parse_and_run_program(Some(case.filename.clone()), &case.program) .unwrap_or_else(|err| panic!("{} failed: {err}", case.path.display())); @@ -60,6 +62,5 @@ fn files(case: &BenchCase) { } fn main() { - EGraph::set_num_threads(1); divan::main(); } diff --git a/egglog/core-relations/src/free_join/execute.rs b/egglog/core-relations/src/free_join/execute.rs index 7fa3afec..83ca6727 100644 --- a/egglog/core-relations/src/free_join/execute.rs +++ b/egglog/core-relations/src/free_join/execute.rs @@ -1225,9 +1225,7 @@ impl<'a> JoinState<'a> { table: get_occurrence_index_from_tableinfo(info, &cols), } } else { - DynamicIndex::DynamicOccurrence( - trie_node.get_cached_occurrence_index(&cols, info), - ) + DynamicIndex::DynamicOccurrence(trie_node.get_cached_occurrence_index(&cols, info)) }; return Prober { node: trie_node, diff --git a/egglog/core-relations/src/tests.rs b/egglog/core-relations/src/tests.rs index aa082f98..b06895af 100644 --- a/egglog/core-relations/src/tests.rs +++ b/egglog/core-relations/src/tests.rs @@ -218,50 +218,46 @@ fn phase_timing_is_available_for_an_empty_ruleset() { #[test] fn parallel_execution_keeps_split_phase_timing_unavailable() { - rayon::ThreadPoolBuilder::new() - .num_threads(4) - .build() - .unwrap() - .install(|| { - let mut db = Database::default(); - let new_relation = || { - SortedWritesTable::new( - 1, - 1, - None, - vec![], - Box::new(|_, left, right, _| { - assert_eq!(left, right, "merge not supported"); - false - }), - ) - }; - let input = db.add_table(new_relation(), iter::empty(), iter::empty()); - let output = db.add_table(new_relation(), iter::empty(), iter::empty()); - { - let mut input_buffer = db.new_buffer(input); - for value in 0..10_001 { - input_buffer.stage_insert(&[Value::new(value)]); - } + egglog_concurrency::ThreadPool::new(4).install(|| { + let mut db = Database::default(); + let new_relation = || { + SortedWritesTable::new( + 1, + 1, + None, + vec![], + Box::new(|_, left, right, _| { + assert_eq!(left, right, "merge not supported"); + false + }), + ) + }; + let input = db.add_table(new_relation(), iter::empty(), iter::empty()); + let output = db.add_table(new_relation(), iter::empty(), iter::empty()); + { + let mut input_buffer = db.new_buffer(input); + for value in 0..10_001 { + input_buffer.stage_insert(&[Value::new(value)]); } - db.merge_all(); - - let mut rules = RuleSetBuilder::new(&mut db); - let mut query = rules.new_rule(); - let value = query.new_var_named("value"); - query.add_atom(input, &[value.into()], &[]).unwrap(); - let mut action = query.build(); - action.insert(output, &[value.into()]).unwrap(); - action.build_with_description("copy"); - let rule_set = rules.build(); - - let report = db.run_rule_set(&rule_set, ReportLevel::TimeOnly); - - let PreMergeTiming::Combined { elapsed } = report.pre_merge else { - panic!("parallel execution must report combined timing"); - }; - assert!(elapsed > std::time::Duration::ZERO); - }); + } + db.merge_all(); + + let mut rules = RuleSetBuilder::new(&mut db); + let mut query = rules.new_rule(); + let value = query.new_var_named("value"); + query.add_atom(input, &[value.into()], &[]).unwrap(); + let mut action = query.build(); + action.insert(output, &[value.into()]).unwrap(); + action.build_with_description("copy"); + let rule_set = rules.build(); + + let report = db.run_rule_set(&rule_set, ReportLevel::TimeOnly); + + let PreMergeTiming::Combined { elapsed } = report.pre_merge else { + panic!("parallel execution must report combined timing"); + }; + assert!(elapsed > std::time::Duration::ZERO); + }); } #[test] diff --git a/egglog/src/ast/desugar.rs b/egglog/src/ast/desugar.rs index e7164dfe..077a214a 100644 --- a/egglog/src/ast/desugar.rs +++ b/egglog/src/ast/desugar.rs @@ -217,6 +217,14 @@ pub(crate) fn desugar_command( // one `fail`, so the assertion covers all of them. let mut desugared = vec![]; for cmd in cmds { + if let Command::Include(..) = cmd { + // `include` is expanded before desugaring, so it never reaches + // here from a top-level program; only a wrapped one can. + return Err(Error::DesugarError( + span.clone(), + "include is not allowed inside (fail ...)".to_string(), + )); + } desugared.extend(desugar_command(cmd, parser, proof_testing)?); } if desugared.is_empty() { diff --git a/egglog/src/lib.rs b/egglog/src/lib.rs index 244b573d..9a1557bf 100644 --- a/egglog/src/lib.rs +++ b/egglog/src/lib.rs @@ -2394,7 +2394,12 @@ impl EGraph { let function_type = self .type_info .get_func_type(func_name) - .unwrap_or_else(|| panic!("Unrecognized function name {func_name}")) + .ok_or_else(|| { + Error::TypeError(TypeError::UnboundFunction( + func_name.to_owned(), + span.clone(), + )) + })? .clone(); let parsed_contents = Self::read_input_file(self.fact_directory.as_deref(), &function_type, &span, &file)?; From d771599dd9f242f75b360dcf499474ddefb1a6e1 Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Thu, 6 Aug 2026 17:23:59 +0000 Subject: [PATCH 5/7] Qualify the Arc doc link so rustdoc can resolve it Upstream's IndexCatalog doc links [`Arc`], but Arc is not imported in hash_index, so `make rust-doc-links` fails under -D warnings. Upstream does not run rustdoc with --document-private-items, so it never sees this. --- egglog/core-relations/src/hash_index/mod.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/egglog/core-relations/src/hash_index/mod.rs b/egglog/core-relations/src/hash_index/mod.rs index c2dd422f..80d324e4 100644 --- a/egglog/core-relations/src/hash_index/mod.rs +++ b/egglog/core-relations/src/hash_index/mod.rs @@ -857,7 +857,8 @@ fn hash_key(key: &[Value]) -> u64 { /// Implemented as an read-optimized key-value arrays, which should be faster /// than concurrent hashmaps as long as # indices is smaller than say 64. /// -/// For simplicity we assume the index can be cloned cheaply, e.g., it's behind an [`Arc`]. +/// For simplicity we assume the index can be cloned cheaply, e.g., it's behind an +/// [`Arc`](std::sync::Arc). #[derive(Default)] pub struct IndexCatalog { data: ReadOptimizedLock>, From 2ebd34829c3762771465d2c0f74689db0e76da6c Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Fri, 7 Aug 2026 16:16:59 +0000 Subject: [PATCH 6/7] Run downstream entry points under the e-graph's own thread pool Upstream's per-e-graph thread count (#910) meets three downstream seams this merge created: - `with_execution_state_tracked` and `get_container_value` called `self.db` directly, so they ran under the ambient pool while their siblings wrapped in `install_thread_pool`. - `with_term_encoding` built its typechecker from a bare `EGraph::default()`, dropping the caller's thread count; the three sibling paths all inherit it. - `with_num_threads`'s doc still described the removed global rayon pool, under a `# Panics` heading with no body. Restored upstream's text. --- egglog/egglog-bridge/src/lib.rs | 11 ++++++++--- egglog/src/lib.rs | 9 ++------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/egglog/egglog-bridge/src/lib.rs b/egglog/egglog-bridge/src/lib.rs index 6ab68a42..7711c220 100644 --- a/egglog/egglog-bridge/src/lib.rs +++ b/egglog/egglog-bridge/src/lib.rs @@ -345,8 +345,12 @@ impl EGraph { /// Intern the given container value into the EGraph. pub fn get_container_value(&mut self, val: C) -> Value { self.register_container_ty::(); - self.db - .with_execution_state(|state| state.clone().container_values().register_val(val, state)) + let thread_pool = self.thread_pool(); + install_thread_pool(thread_pool, || { + self.db.with_execution_state(|state| { + state.clone().container_values().register_val(val, state) + }) + }) } /// Register the given [`ContainerValue`] type with this EGraph. @@ -1299,7 +1303,8 @@ impl EGraph { &self, f: impl FnOnce(&mut ExecutionState<'_>) -> R, ) -> (R, bool) { - self.db.with_execution_state_tracked(f) + let thread_pool = self.thread_pool(); + install_thread_pool(thread_pool, || self.db.with_execution_state_tracked(f)) } /// Flush the pending update buffers to the EGraph. diff --git a/egglog/src/lib.rs b/egglog/src/lib.rs index 98bf4e29..cc7a04b7 100644 --- a/egglog/src/lib.rs +++ b/egglog/src/lib.rs @@ -660,7 +660,8 @@ impl EGraph { /// union-find. Re-typechecking after the encoder runs uses a default /// (bridge-backed) e-graph, so this backend need not implement typechecking. pub fn with_term_encoding(mut self) -> Self { - self.enable_term_encoding(EGraph::default()); + let typechecker = EGraph::default().with_num_threads(self.num_threads()); + self.enable_term_encoding(typechecker); self } @@ -698,12 +699,6 @@ impl EGraph { self } - /// Set the number of threads used for parallel operations. - /// - /// This is a helper that simply configures the global rayon thread pool. It can only be called - /// once per process; subsequent calls will be ignored. - /// - /// # Panics /// Return a copy of this e-graph configured with `num_threads`. pub fn with_num_threads(mut self, num_threads: usize) -> Self { self.set_num_threads(num_threads); From 452628f2d6939f5c677a3e01152e0aba70e0484c Mon Sep 17 00:00:00 2001 From: Oliver Flatt Date: Fri, 7 Aug 2026 20:01:52 +0000 Subject: [PATCH 7/7] Drop the #44 rebuild-cost work so this merge stands alone This branch was cut on top of #44, so its diff carried that PR's `uf_clear` knob and rebuild-cost measurement. None of it is needed to merge upstream, and reviewing the two together conflates them. Removes the `EGGLOG_UF_CLEAR` switch and its generated ruleset, rule, and schedule step; the `EGGLOG_REBUILD_TRACE` logging in `table/rebuild.rs`; and `rebuild_cost.md` with the paragraph citing it. `proof_encoding.rs`, `proof_encoding.md`, and `rebuild_cost.md` now match `main` exactly. Re-apply on top once #44 lands. --- egglog/core-relations/src/table/rebuild.rs | 16 -- egglog/src/proofs/proof_encoding.md | 5 - egglog/src/proofs/proof_encoding.rs | 30 +--- egglog/src/proofs/proof_encoding_helpers.rs | 25 +-- egglog/src/proofs/rebuild_cost.md | 159 -------------------- 5 files changed, 3 insertions(+), 232 deletions(-) delete mode 100644 egglog/src/proofs/rebuild_cost.md diff --git a/egglog/core-relations/src/table/rebuild.rs b/egglog/core-relations/src/table/rebuild.rs index 3f742e6c..64334c3b 100644 --- a/egglog/core-relations/src/table/rebuild.rs +++ b/egglog/core-relations/src/table/rebuild.rs @@ -60,22 +60,6 @@ impl SortedWritesTable { // Incremental rebuilds are possible if we can scan the subset of the columns that are // relevant. let to_scan = self.subset_tracker.recent_updates(table_id, table); - if std::env::var_os("EGGLOG_REBUILD_TRACE").is_some() { - log::info!( - "REBUILD_TRACE branch={} diff={} table_size={}", - if incremental_rebuild( - to_scan.size(), - self.data.next_row().index(), - parallelize_rebuild(to_scan.size()) - ) { - "incremental" - } else { - "fullscan" - }, - to_scan.size(), - self.data.next_row().index() - ); - } if incremental_rebuild( to_scan.size(), self.data.next_row().index(), diff --git a/egglog/src/proofs/proof_encoding.md b/egglog/src/proofs/proof_encoding.md index e2fc1c8d..71e98e9d 100644 --- a/egglog/src/proofs/proof_encoding.md +++ b/egglog/src/proofs/proof_encoding.md @@ -312,11 +312,6 @@ lookup — and keep the `:naive` rule in [Containers](#containers). Subsumption markers (`@to_subsume_`) are re-keyed to their leaders by their own per-column rules, so a subsumed row stays subsumed after its children move. -This rule is always the incremental shape. Native instead picks per table, per -round, between that and scanning the whole table, and on the benchmark suite it -almost always scans. What that costs, and why emptying `@UF` each iteration does -not recover it, is measured in `rebuild_cost.md`. - # Globals *Before the term encoding*, [`crate::ast::remove_globals`] desugars every global diff --git a/egglog/src/proofs/proof_encoding.rs b/egglog/src/proofs/proof_encoding.rs index 5d4b93d4..bb8a3d23 100644 --- a/egglog/src/proofs/proof_encoding.rs +++ b/egglog/src/proofs/proof_encoding.rs @@ -1,6 +1,6 @@ #[doc = include_str!("proof_encoding.md")] use crate::proofs::proof_encoding_helpers::{ - Composition, EncodingNames, HeadColumn, Justification, Skeleton, uf_clear_enabled, + Composition, EncodingNames, HeadColumn, Justification, Skeleton, }; use crate::proofs::proof_head::{ Head, HeadPlan, HeadPosition, HeadProof, HeadRun, ProofAlgebra, constructor_operand, @@ -783,22 +783,6 @@ impl<'a> ProofInstrumentor<'a> { (String::new(), "()".to_string()) }; - // Under the clear knob, every edge of this table is dropped once maintenance - // has finished consuming it. `:naive` because the ruleset's own delta is - // empty on the run that must see the whole table. - let clear_rule = if uf_clear_enabled() { - let clear_name = self.egraph.parser.symbol_gen.fresh("uf_clear_rule"); - let clear_ruleset = self.proof_names().uf_clear_ruleset_name.clone(); - format!( - "(rule ((= (values {b} {pb}) ({uf_name} {a}))) - ((delete ({uf_name} {a}))) - :ruleset {clear_ruleset} :naive :name \"{clear_name}\") - " - ) - } else { - String::new() - }; - let code = format!( "{packed_decl} (function {uf_name} ({sort_name}) ({sort_name} {proof_type}) :merge {uf_merge} :unextractable :internal-hidden :internal-identity-vals 1) @@ -809,7 +793,6 @@ impl<'a> ProofInstrumentor<'a> { (set ({uf_name} {a}) (values {c} {compressed_proof}))) :ruleset {path_compress_ruleset_name} :name \"{fresh_name}\") - {clear_rule} " ); @@ -2155,22 +2138,13 @@ impl<'a> ProofInstrumentor<'a> { let subsume_ruleset = self.proof_names().subsume_ruleset_name.clone(); // The `@UF` `:merge` resolves conflicting parents itself, so only // `path_compress` (flattening chains) remains as UF maintenance. - // - // The clear runs last, once the saturated rebuild has canonicalized every - // row that any later query, `delete`, or `subsume` can reach — so the edges - // it drops are ones nothing reads again. - let clear_step = if uf_clear_enabled() { - format!(" {}", self.proof_names().uf_clear_ruleset_name) - } else { - String::new() - }; self.parse_schedule(format!( "(seq (saturate {rebuilding_cleanup_ruleset} (saturate {path_compress_ruleset}) {rebuilding_ruleset}) - {subsume_ruleset}{clear_step})" + {subsume_ruleset})" )) } diff --git a/egglog/src/proofs/proof_encoding_helpers.rs b/egglog/src/proofs/proof_encoding_helpers.rs index 94b6b0ba..7ca33c7e 100644 --- a/egglog/src/proofs/proof_encoding_helpers.rs +++ b/egglog/src/proofs/proof_encoding_helpers.rs @@ -68,7 +68,6 @@ pub(crate) struct EncodingNames { pub(crate) rebuilding_ruleset_name: String, pub(crate) rebuilding_cleanup_ruleset_name: String, pub(crate) subsume_ruleset_name: String, - pub(crate) uf_clear_ruleset_name: String, // Per-function fresh names pub(crate) view_name: HashMap, pub(crate) subsumed_name: HashMap, @@ -450,7 +449,6 @@ impl EncodingNames { rebuilding_ruleset_name: symbol_gen.fresh("rebuilding"), rebuilding_cleanup_ruleset_name: symbol_gen.fresh("rebuilding_cleanup"), subsume_ruleset_name: symbol_gen.fresh("subsume_ruleset"), - uf_clear_ruleset_name: symbol_gen.fresh("uf_clear"), view_name: HashMap::default(), subsumed_name: HashMap::default(), subsume_declared: HashSet::default(), @@ -458,19 +456,6 @@ impl EncodingNames { } } -/// Whether maintenance empties every `@UF_` table at the end of each run, -/// keeping only the edges a later iteration's rebuild will read. Set -/// `EGGLOG_UF_CLEAR=1` to enable. -/// -/// Off by default because it does not pay: the rebuild rule already reads only -/// the `@UF` delta, so the rows this drops are ones its join never visits. It -/// also loses the ability to canonicalize a value from an earlier iteration, -/// which [`crate::extract::find_canonical`] needs, and lets a rule that -/// re-derives one union per iteration keep `saturate` from terminating. -pub(crate) fn uf_clear_enabled() -> bool { - matches!(std::env::var("EGGLOG_UF_CLEAR").as_deref(), Ok("1")) -} - impl ProofInstrumentor<'_> { pub(crate) fn uf_name(&mut self, sort: &str) -> String { if let Some(name) = self.egraph.proof_state.uf_parent.get(sort) { @@ -601,19 +586,11 @@ impl ProofInstrumentor<'_> { /// Header commands for term encoding, setting up rulesets. pub(crate) fn term_header(&mut self) -> Vec { - let uf_clear = if uf_clear_enabled() { - format!( - "\n (ruleset {})", - self.proof_names().uf_clear_ruleset_name - ) - } else { - String::new() - }; let str = format!( "(ruleset {}) (ruleset {}) (ruleset {}) - (ruleset {}){uf_clear}", + (ruleset {})", self.proof_names().path_compress_ruleset_name, self.proof_names().rebuilding_ruleset_name, self.proof_names().rebuilding_cleanup_ruleset_name, diff --git a/egglog/src/proofs/rebuild_cost.md b/egglog/src/proofs/rebuild_cost.md deleted file mode 100644 index 17d66b47..00000000 --- a/egglog/src/proofs/rebuild_cost.md +++ /dev/null @@ -1,159 +0,0 @@ -# Where the encoding's rebuild time goes - -Measurements against `5cc4dc1` (PR #39's head), serial (`--threads 1`), release, -`bench.py` with 3–6 rounds per endpoint. Two questions: is clearing `@UF` every -iteration worth it, and what makes the encoded rebuild slower than native's. - -## Clearing `@UF` every iteration does not pay - -The union-find's only readers are the maintenance rules, so once the rebuild loop -saturates every row a query, `delete`, or `subsume` can reach is canonical and the -edges that got it there are dead. Deleting them is *sound* — with a -delete-everything ruleset running last in the maintenance schedule, all 801 -`--test files` cases pass and every proof snapshot is byte-identical. - -It is not *faster*, at 6 rounds: - -| | baseline | clear | ratio | -| --- | ---: | ---: | ---: | -| `math-microbenchmark` wall | 4483 ms | 4511 ms | 1.006 | -| `eggcc-2mm-pass1` wall | 9709 ms | 9971 ms | 1.027 | -| `eggcc-2mm-pass1` peak RSS | 525 MiB | 568 MiB | 1.082 | - -Per ruleset, the clear costs `+134 ms` while `@parent` saves `-27 ms`, and -`@rebuilding` does not move outside noise. The reason is that the rebuild rule is -`:unsafe-seminaive` and its driving `@UF` atom is therefore already restricted to -the delta: the rows a clear removes are ones the join never visits. `@parent` -joins `@UF` against itself, so its full side does shrink — which is the whole of -the measured win, and it is 0.6% of one benchmark. - -The ceiling is low regardless. Time in `@parent` on the baseline is 3.0% of wall -on `math-microbenchmark`, 1.2% on `herbie`, and 0.2% on `eggcc-2mm-pass1`, so a -clear that cost nothing could not win more than that. - -Two things also break, which is why the knob is off by default: - -- **Canonicalizing a value from an earlier iteration stops working.** - `find_canonical` and proof extraction's fall-back read `@UF` outside rebuilding - to resolve a value that predates this iteration. Surface syntax never needs it - (queries read views, which are canonical, and `(extract e)` interns `e` first), - but a Rust-API caller holding a `Value` across a union does, and native - resolves those. -- **`saturate` can stop terminating.** `(rule ((Same x y)) ((union x y)) :naive)` - under `(saturate ...)` terminates normally and hangs with the clear on: once - `x` and `y` are canonically equal the re-firing rule writes the self-edge - `v -> v`, which `:internal-identity-vals 1` normally makes an idempotent - no-op. After a clear the row is absent, so the re-`set` is a fresh insert and - the loop always reports a change. Adding `(!= x y)` fixes that program, and - suppressing self-edges at the source would fix the class — a `@UF` row whose - key is its own parent carries no information, since a term with no row is - already its own representative. - -A whole-table `clear_table` fast path (already present end to end, from -`Database::clear_table` through `EGraph::clear_function`) would remove the -`+134 ms` but not the reason there is nothing to win, and would not help the -termination case at all, where the change is reported by the re-*insert*. - -## The encoded rebuild is ~4.5x native's, and always takes the incremental branch - -Encoded proofs against native (`--treatment proofs` vs `off`), fastest of 3: - -| file | native | proofs | ratio | native rebuild | `@rebuilding`+`@parent` | -| --- | ---: | ---: | ---: | ---: | ---: | -| `math-microbenchmark` | 1035 ms | 4502 ms | 4.35x | 386 ms | 1679 ms | -| `eggcc-2mm-pass1` | 2717 ms | 9783 ms | 3.60x | 581 ms | 2682 ms | -| `herbie` | 130 ms | 564 ms | 4.34x | 5 ms | 47 ms | -| `hardboiled_conv1d_32` | 323 ms | 1127 ms | 3.49x | 0 ms | 33 ms | -| `luminal-llama` | 1120 ms | 8238 ms | 7.35x | 6 ms | 13 ms | - -Rebuild excess is 30–37% of the encoding's total overhead on the two files where -rebuilding matters, and search is the larger half of it: rebuild search on -`math-microbenchmark` is 890 ms, itself 2.3x native's entire rebuild. As a share -of all search time, maintenance is 79% on `math-microbenchmark`, 55% on `herbie`, -21% on `eggcc-2mm-pass1` — and 0.5% on `luminal-llama`, whose 7.35x is the worst -of the set and has nothing to do with rebuilding. - -Rebuild is not the whole of the search gap, and on most files it is not even the -larger part. Search time only, native against encoded: - -| file | native | encoded | of which user rules | of which maintenance | -| --- | ---: | ---: | ---: | ---: | -| `luminal-llama` | 28 ms | 1683 ms | **1674 ms** | 9 ms | -| `eggcc-2mm-pass1` | 1659 ms | 2933 ms | **2323 ms** | 609 ms | -| `hardboiled_conv1d_32` | ~0 ms | 317 ms | **300 ms** | 16 ms | -| `math-microbenchmark` | 221 ms | 1129 ms | 240 ms | **890 ms** | -| `herbie` | 16 ms | 42 ms | 19 ms | 23 ms | - -Maintenance dominates search on `math-microbenchmark` and `herbie` only. Elsewhere -the cost is in the rewritten *user* queries — most sharply on `luminal-llama`, -where encoded user-rule search is 60x native's entire search while its rebuild is -9 ms. Whatever the encoded rebuild is made to cost, that file does not improve. -The two are separate problems and the rest of this note is about the smaller one. - -The user-rule cost is **not** join width. Comparing the two desugared programs -suggests it is — `matmul_backend`'s bodies go from a median of 13 top-level forms -to 38 — but that comparison is invalid. `GenericExprExt::to_query` in `core.rs` -flattens every nested `Call` into one atom per subterm, so native's - -```text -(= ?cast (Op (Cast ?size (F32)) (ICons ?matmul (INil)))) -``` - -compiles to the same four atoms the encoding writes out longhand. Native's -desugared *text* keeps the nesting; the encoding's does not. On the rule -`"cublaslt bf16 matmul cast f32 output"` both come to eleven real atoms — -`Op`, `cublaslt`, four `Bf16`, `Op`, `Cast`, `F32`, `ICons`, `INil` — and the -encoding adds two `(= ?matmul )` aliases a compiler substitutes away. -Body shape and atom count therefore match, and the 60x is elsewhere. - -What differs per atom is that a view read binds a proof column as well as the -e-class, so every tuple is one column wider. That is not obviously a 60x. - -The leading untested explanation is rebuild churn feeding seminaive. The rebuild -rule `delete`s and re-`set`s a view row, and it does so per -`@UF`-delta-times-occurrence match rather than per row that actually moved, so one -firing rewrites a row whose canonical form may equal what was already there. Each -re-inserted row is a fresh delta for *every user rule reading that view*, so -user-rule search would scale with how much the rebuild rewrites rather than with -the rules' own selectivity. That would also explain why the effect is worst on the -file with the most view rows. Measuring view-row re-insertions per round against -native's is the next step. - -Native picks per table, per round, between scanning only the recently-updated -subset and scanning the whole table, at `diff > table_size / 8` -(`core-relations/src/table/rebuild.rs`). Tracing that choice: - -| workload | decisions | fullscan | median `diff/table_size` | -| --- | ---: | ---: | ---: | -| `math-microbenchmark` | 429 | **93.2%** | 1.000 | -| `eggcc-2mm-pass1` | 336340 | **99.8%** | 0.800 | - -So native almost always scans, and the encoding has no way to: its rebuild rule -is driven by the `@UF` delta joined against a declared occurrence index, and an -index atom is probed rather than scanned by construction. On these workloads the -encoding therefore pays twice — maintaining an index native would not consult, -then probing it per delta row instead of making one sequential pass. - -Scanning the index is not the fix: `(any 0 1 2)` holds one entry per row *per -listed column*, so scanning it visits each row three times. The scan has to be -over the view, which makes it a different rule body rather than a different plan -for the same rule — no cost-based planner change can reach it. - -The shape that scan wants already exists in the encoding, as the container -rebuild rule: `:naive`, canonicalize in the body, guard on the column having -moved. Two ways to choose between the shapes, neither needing the backend to -recognize a rule: - -- A body guard that is cheap and fails fast — a primitive comparing the `@UF` - delta against the view's size, ordered first so a losing round never reaches - the scan. -- A per-view scan rule per column (which is what the index-driven rule replaced), - costing one scan per column rather than one per view. - -The higher-ceiling option is a bulk view-rebuild primitive that does the scan and -the canonicalization in Rust and mints the proof rows itself, which is what -`proof_container_rebuild.rs` already does for containers. That is the only option -that also removes the interpreted-join overhead, rather than trading one join -shape for another. - -`EGGLOG_REBUILD_TRACE=1` prints native's per-table branch and its two inputs.