kumi 0.0.23 → 0.0.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (166) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +8 -0
  3. data/README.md +2 -2
  4. data/golden/array_element/expected/schema_ruby.rb +1 -1
  5. data/golden/array_index/expected/schema_ruby.rb +1 -1
  6. data/golden/array_operations/expected/schema_ruby.rb +1 -1
  7. data/golden/cascade_logic/expected/lir_02_inlined.txt +8 -8
  8. data/golden/cascade_logic/expected/schema_ruby.rb +1 -1
  9. data/golden/chained_fusion/expected/lir_02_inlined.txt +36 -36
  10. data/golden/chained_fusion/expected/lir_03_cse.txt +23 -23
  11. data/golden/chained_fusion/expected/lir_04_1_loop_fusion.txt +25 -25
  12. data/golden/chained_fusion/expected/lir_04_loop_invcm.txt +23 -23
  13. data/golden/chained_fusion/expected/lir_06_const_prop.txt +23 -23
  14. data/golden/chained_fusion/expected/schema_javascript.mjs +23 -23
  15. data/golden/chained_fusion/expected/schema_ruby.rb +28 -28
  16. data/golden/element_arrays/expected/schema_ruby.rb +1 -1
  17. data/golden/empty_and_null_inputs/expected/lir_02_inlined.txt +18 -18
  18. data/golden/empty_and_null_inputs/expected/lir_03_cse.txt +17 -17
  19. data/golden/empty_and_null_inputs/expected/lir_04_1_loop_fusion.txt +17 -17
  20. data/golden/empty_and_null_inputs/expected/lir_04_loop_invcm.txt +17 -17
  21. data/golden/empty_and_null_inputs/expected/lir_06_const_prop.txt +17 -17
  22. data/golden/empty_and_null_inputs/expected/schema_javascript.mjs +13 -13
  23. data/golden/empty_and_null_inputs/expected/schema_ruby.rb +18 -18
  24. data/golden/game_of_life/expected/lir_00_unoptimized.txt +33 -33
  25. data/golden/game_of_life/expected/lir_01_hoist_scalar_references.txt +33 -33
  26. data/golden/game_of_life/expected/lir_02_inlined.txt +1370 -1370
  27. data/golden/game_of_life/expected/lir_03_cse.txt +448 -448
  28. data/golden/game_of_life/expected/lir_04_1_loop_fusion.txt +448 -448
  29. data/golden/game_of_life/expected/lir_04_loop_invcm.txt +448 -448
  30. data/golden/game_of_life/expected/lir_06_const_prop.txt +448 -448
  31. data/golden/game_of_life/expected/schema_javascript.mjs +85 -85
  32. data/golden/game_of_life/expected/schema_ruby.rb +86 -86
  33. data/golden/hash_keys/expected/schema_ruby.rb +1 -1
  34. data/golden/hash_keys/schema.kumi +4 -5
  35. data/golden/hash_value/expected/schema_ruby.rb +1 -1
  36. data/golden/hierarchical_complex/expected/lir_02_inlined.txt +15 -15
  37. data/golden/hierarchical_complex/expected/lir_03_cse.txt +1 -1
  38. data/golden/hierarchical_complex/expected/lir_04_1_loop_fusion.txt +1 -1
  39. data/golden/hierarchical_complex/expected/lir_04_loop_invcm.txt +1 -1
  40. data/golden/hierarchical_complex/expected/lir_06_const_prop.txt +1 -1
  41. data/golden/hierarchical_complex/expected/schema_javascript.mjs +1 -1
  42. data/golden/hierarchical_complex/expected/schema_ruby.rb +2 -2
  43. data/golden/inline_rename_scope_leak/expected/ast.txt +48 -0
  44. data/golden/inline_rename_scope_leak/expected/input_plan.txt +10 -0
  45. data/golden/inline_rename_scope_leak/expected/lir_00_unoptimized.txt +35 -0
  46. data/golden/inline_rename_scope_leak/expected/lir_01_hoist_scalar_references.txt +35 -0
  47. data/golden/inline_rename_scope_leak/expected/lir_02_inlined.txt +49 -0
  48. data/golden/inline_rename_scope_leak/expected/lir_03_cse.txt +49 -0
  49. data/golden/inline_rename_scope_leak/expected/lir_04_1_loop_fusion.txt +49 -0
  50. data/golden/inline_rename_scope_leak/expected/lir_04_loop_invcm.txt +49 -0
  51. data/golden/inline_rename_scope_leak/expected/lir_06_const_prop.txt +49 -0
  52. data/golden/inline_rename_scope_leak/expected/nast.txt +31 -0
  53. data/golden/inline_rename_scope_leak/expected/schema_javascript.mjs +51 -0
  54. data/golden/inline_rename_scope_leak/expected/schema_ruby.rb +82 -0
  55. data/golden/inline_rename_scope_leak/expected/snast.txt +31 -0
  56. data/golden/inline_rename_scope_leak/expected.json +7 -0
  57. data/golden/inline_rename_scope_leak/input.json +4 -0
  58. data/golden/inline_rename_scope_leak/schema.kumi +24 -0
  59. data/golden/input_reference/expected/schema_ruby.rb +1 -1
  60. data/golden/interleaved_fusion/expected/lir_02_inlined.txt +35 -35
  61. data/golden/interleaved_fusion/expected/lir_03_cse.txt +26 -26
  62. data/golden/interleaved_fusion/expected/lir_04_1_loop_fusion.txt +27 -26
  63. data/golden/interleaved_fusion/expected/lir_04_loop_invcm.txt +26 -26
  64. data/golden/interleaved_fusion/expected/lir_06_const_prop.txt +26 -26
  65. data/golden/interleaved_fusion/expected/schema_javascript.mjs +23 -23
  66. data/golden/interleaved_fusion/expected/schema_ruby.rb +29 -29
  67. data/golden/let_inline/expected/schema_ruby.rb +1 -1
  68. data/golden/loop_fusion/expected/lir_02_inlined.txt +17 -17
  69. data/golden/loop_fusion/expected/lir_03_cse.txt +14 -14
  70. data/golden/loop_fusion/expected/lir_04_1_loop_fusion.txt +14 -14
  71. data/golden/loop_fusion/expected/lir_04_loop_invcm.txt +14 -14
  72. data/golden/loop_fusion/expected/lir_06_const_prop.txt +14 -14
  73. data/golden/loop_fusion/expected/schema_javascript.mjs +12 -12
  74. data/golden/loop_fusion/expected/schema_ruby.rb +16 -16
  75. data/golden/min_reduce_scope/expected/schema_ruby.rb +1 -1
  76. data/golden/mixed_dimensions/expected/lir_02_inlined.txt +5 -5
  77. data/golden/mixed_dimensions/expected/lir_03_cse.txt +5 -5
  78. data/golden/mixed_dimensions/expected/lir_04_1_loop_fusion.txt +5 -5
  79. data/golden/mixed_dimensions/expected/lir_04_loop_invcm.txt +5 -5
  80. data/golden/mixed_dimensions/expected/lir_06_const_prop.txt +5 -5
  81. data/golden/mixed_dimensions/expected/schema_javascript.mjs +3 -3
  82. data/golden/mixed_dimensions/expected/schema_ruby.rb +6 -6
  83. data/golden/multirank_hoisting/expected/lir_02_inlined.txt +48 -48
  84. data/golden/multirank_hoisting/expected/lir_03_cse.txt +35 -35
  85. data/golden/multirank_hoisting/expected/lir_04_1_loop_fusion.txt +35 -35
  86. data/golden/multirank_hoisting/expected/lir_04_loop_invcm.txt +35 -35
  87. data/golden/multirank_hoisting/expected/lir_06_const_prop.txt +35 -35
  88. data/golden/multirank_hoisting/expected/schema_javascript.mjs +34 -34
  89. data/golden/multirank_hoisting/expected/schema_ruby.rb +36 -36
  90. data/golden/nested_hash/expected/schema_ruby.rb +1 -1
  91. data/golden/reduction_broadcast/expected/lir_02_inlined.txt +30 -30
  92. data/golden/reduction_broadcast/expected/lir_03_cse.txt +22 -22
  93. data/golden/reduction_broadcast/expected/lir_04_1_loop_fusion.txt +22 -22
  94. data/golden/reduction_broadcast/expected/lir_04_loop_invcm.txt +22 -22
  95. data/golden/reduction_broadcast/expected/lir_06_const_prop.txt +22 -22
  96. data/golden/reduction_broadcast/expected/schema_javascript.mjs +18 -18
  97. data/golden/reduction_broadcast/expected/schema_ruby.rb +23 -23
  98. data/golden/roll/expected/lir_00_unoptimized.txt +8 -8
  99. data/golden/roll/expected/lir_01_hoist_scalar_references.txt +8 -8
  100. data/golden/roll/expected/lir_02_inlined.txt +8 -8
  101. data/golden/roll/expected/lir_03_cse.txt +8 -8
  102. data/golden/roll/expected/lir_04_1_loop_fusion.txt +8 -8
  103. data/golden/roll/expected/lir_04_loop_invcm.txt +8 -8
  104. data/golden/roll/expected/lir_06_const_prop.txt +8 -8
  105. data/golden/roll/expected/schema_ruby.rb +1 -1
  106. data/golden/shift/expected/lir_00_unoptimized.txt +12 -12
  107. data/golden/shift/expected/lir_01_hoist_scalar_references.txt +12 -12
  108. data/golden/shift/expected/lir_02_inlined.txt +12 -12
  109. data/golden/shift/expected/lir_03_cse.txt +12 -12
  110. data/golden/shift/expected/lir_04_1_loop_fusion.txt +12 -12
  111. data/golden/shift/expected/lir_04_loop_invcm.txt +12 -12
  112. data/golden/shift/expected/lir_06_const_prop.txt +12 -12
  113. data/golden/shift/expected/schema_ruby.rb +1 -1
  114. data/golden/shift_2d/expected/lir_00_unoptimized.txt +48 -48
  115. data/golden/shift_2d/expected/lir_01_hoist_scalar_references.txt +48 -48
  116. data/golden/shift_2d/expected/lir_02_inlined.txt +48 -48
  117. data/golden/shift_2d/expected/lir_03_cse.txt +48 -48
  118. data/golden/shift_2d/expected/lir_04_1_loop_fusion.txt +48 -48
  119. data/golden/shift_2d/expected/lir_04_loop_invcm.txt +48 -48
  120. data/golden/shift_2d/expected/lir_06_const_prop.txt +48 -48
  121. data/golden/shift_2d/expected/schema_ruby.rb +1 -1
  122. data/golden/simple_math/expected/schema_ruby.rb +1 -1
  123. data/golden/streaming_basics/expected/lir_02_inlined.txt +25 -25
  124. data/golden/streaming_basics/expected/lir_03_cse.txt +13 -13
  125. data/golden/streaming_basics/expected/lir_04_1_loop_fusion.txt +13 -13
  126. data/golden/streaming_basics/expected/lir_04_loop_invcm.txt +13 -13
  127. data/golden/streaming_basics/expected/lir_06_const_prop.txt +13 -13
  128. data/golden/streaming_basics/expected/schema_javascript.mjs +13 -13
  129. data/golden/streaming_basics/expected/schema_ruby.rb +14 -14
  130. data/golden/tuples/expected/lir_00_unoptimized.txt +4 -4
  131. data/golden/tuples/expected/lir_01_hoist_scalar_references.txt +4 -4
  132. data/golden/tuples/expected/lir_02_inlined.txt +4 -4
  133. data/golden/tuples/expected/lir_03_cse.txt +4 -4
  134. data/golden/tuples/expected/lir_04_1_loop_fusion.txt +4 -4
  135. data/golden/tuples/expected/lir_04_loop_invcm.txt +4 -4
  136. data/golden/tuples/expected/lir_06_const_prop.txt +4 -4
  137. data/golden/tuples/expected/schema_ruby.rb +1 -1
  138. data/golden/tuples_and_arrays/expected/lir_00_unoptimized.txt +1 -1
  139. data/golden/tuples_and_arrays/expected/lir_01_hoist_scalar_references.txt +1 -1
  140. data/golden/tuples_and_arrays/expected/lir_02_inlined.txt +17 -17
  141. data/golden/tuples_and_arrays/expected/lir_03_cse.txt +14 -14
  142. data/golden/tuples_and_arrays/expected/lir_04_1_loop_fusion.txt +14 -14
  143. data/golden/tuples_and_arrays/expected/lir_04_loop_invcm.txt +14 -14
  144. data/golden/tuples_and_arrays/expected/lir_06_const_prop.txt +14 -14
  145. data/golden/tuples_and_arrays/expected/schema_javascript.mjs +13 -13
  146. data/golden/tuples_and_arrays/expected/schema_ruby.rb +14 -14
  147. data/golden/us_tax_2024/expected/ast.txt +865 -0
  148. data/golden/us_tax_2024/expected/input_plan.txt +61 -0
  149. data/golden/us_tax_2024/expected/lir_00_unoptimized.txt +901 -0
  150. data/golden/us_tax_2024/expected/lir_01_hoist_scalar_references.txt +901 -0
  151. data/golden/us_tax_2024/expected/lir_02_inlined.txt +5178 -0
  152. data/golden/us_tax_2024/expected/lir_03_cse.txt +2499 -0
  153. data/golden/us_tax_2024/expected/lir_04_1_loop_fusion.txt +2519 -0
  154. data/golden/us_tax_2024/expected/lir_04_loop_invcm.txt +2499 -0
  155. data/golden/us_tax_2024/expected/lir_06_const_prop.txt +2499 -0
  156. data/golden/us_tax_2024/expected/nast.txt +976 -0
  157. data/golden/us_tax_2024/expected/schema_javascript.mjs +584 -0
  158. data/golden/us_tax_2024/expected/schema_ruby.rb +639 -0
  159. data/golden/us_tax_2024/expected/snast.txt +976 -0
  160. data/golden/us_tax_2024/expected.json +1 -0
  161. data/golden/us_tax_2024/input.json +168 -0
  162. data/golden/us_tax_2024/schema.kumi +203 -0
  163. data/golden/with_constants/expected/schema_ruby.rb +1 -1
  164. data/lib/kumi/core/analyzer/passes/lir/inline_declarations_pass.rb +227 -107
  165. data/lib/kumi/version.rb +1 -1
  166. metadata +33 -1
data/golden/game_of_life/expected/lir_02_inlined.txt CHANGED
@@ -11,7 +11,7 @@
11
11
  %t6 = load_input "rows" :: array
12
12
  loop rows id=L3 in %t6 as el=%rows_el_7, idx=%rows_i_8
13
13
  loop col id=L4 in %rows_el_7 as el=%col_el_9, idx=%col_i_10
14
- %t11 = Length %t6 :: integer
14
+ %t11 = length %t6 :: integer
15
15
  %t12 = const -1 :: integer
16
16
  %t13 = call core.sub(%rows_i_8, %t12) :: integer
17
17
  %t14 = const 0 :: integer
@@ -22,12 +22,12 @@
22
22
  %t19 = call core.sub(%t11, %t18) :: integer
23
23
  %t20 = const 0 :: integer
24
24
  %t21 = call core.clamp(%t13, %t20, %t19) :: integer
25
- %t22 = Gather %t6, %t21 :: any
26
- %t23 = Length %t22 :: integer
25
+ %t22 = gather %t6, %t21 :: any
26
+ %t23 = length %t22 :: integer
27
27
  %t24 = call core.mod(%col_i_10, %t23) :: integer
28
28
  %t25 = call core.add(%t24, %t23) :: integer
29
29
  %t26 = call core.mod(%t25, %t23) :: integer
30
- %t27 = Gather %t22, %t26 :: integer
30
+ %t27 = gather %t22, %t26 :: integer
31
31
  %t28 = const 0 :: integer
32
32
  %t29 = select %t17, %t27, %t28 :: integer
33
33
  yield %t29
@@ -38,7 +38,7 @@
38
38
  %t30 = load_input "rows" :: array
39
39
  loop rows id=L5 in %t30 as el=%rows_el_31, idx=%rows_i_32
40
40
  loop col id=L6 in %rows_el_31 as el=%col_el_33, idx=%col_i_34
41
- %t35 = Length %t30 :: integer
41
+ %t35 = length %t30 :: integer
42
42
  %t36 = const 1 :: integer
43
43
  %t37 = call core.sub(%rows_i_32, %t36) :: integer
44
44
  %t38 = const 0 :: integer
@@ -49,12 +49,12 @@
49
49
  %t43 = call core.sub(%t35, %t42) :: integer
50
50
  %t44 = const 0 :: integer
51
51
  %t45 = call core.clamp(%t37, %t44, %t43) :: integer
52
- %t46 = Gather %t30, %t45 :: any
53
- %t47 = Length %t46 :: integer
52
+ %t46 = gather %t30, %t45 :: any
53
+ %t47 = length %t46 :: integer
54
54
  %t48 = call core.mod(%col_i_34, %t47) :: integer
55
55
  %t49 = call core.add(%t48, %t47) :: integer
56
56
  %t50 = call core.mod(%t49, %t47) :: integer
57
- %t51 = Gather %t46, %t50 :: integer
57
+ %t51 = gather %t46, %t50 :: integer
58
58
  %t52 = const 0 :: integer
59
59
  %t53 = select %t41, %t51, %t52 :: integer
60
60
  yield %t53
@@ -65,12 +65,12 @@
65
65
  %t54 = load_input "rows" :: array
66
66
  loop rows id=L7 in %t54 as el=%rows_el_55, idx=%rows_i_56
67
67
  loop col id=L8 in %rows_el_55 as el=%col_el_57, idx=%col_i_58
68
- %t59 = Length %t54 :: integer
68
+ %t59 = length %t54 :: integer
69
69
  %t60 = call core.mod(%rows_i_56, %t59) :: integer
70
70
  %t61 = call core.add(%t60, %t59) :: integer
71
71
  %t62 = call core.mod(%t61, %t59) :: integer
72
- %t63 = Gather %t54, %t62 :: any
73
- %t64 = Length %t63 :: integer
72
+ %t63 = gather %t54, %t62 :: any
73
+ %t64 = length %t63 :: integer
74
74
  %t65 = const -1 :: integer
75
75
  %t66 = call core.sub(%col_i_58, %t65) :: integer
76
76
  %t67 = const 0 :: integer
@@ -81,7 +81,7 @@
81
81
  %t72 = call core.sub(%t64, %t71) :: integer
82
82
  %t73 = const 0 :: integer
83
83
  %t74 = call core.clamp(%t66, %t73, %t72) :: integer
84
- %t75 = Gather %t63, %t74 :: integer
84
+ %t75 = gather %t63, %t74 :: integer
85
85
  %t76 = const 0 :: integer
86
86
  %t77 = select %t70, %t75, %t76 :: integer
87
87
  yield %t77
@@ -92,12 +92,12 @@
92
92
  %t78 = load_input "rows" :: array
93
93
  loop rows id=L9 in %t78 as el=%rows_el_79, idx=%rows_i_80
94
94
  loop col id=L10 in %rows_el_79 as el=%col_el_81, idx=%col_i_82
95
- %t83 = Length %t78 :: integer
95
+ %t83 = length %t78 :: integer
96
96
  %t84 = call core.mod(%rows_i_80, %t83) :: integer
97
97
  %t85 = call core.add(%t84, %t83) :: integer
98
98
  %t86 = call core.mod(%t85, %t83) :: integer
99
- %t87 = Gather %t78, %t86 :: any
100
- %t88 = Length %t87 :: integer
99
+ %t87 = gather %t78, %t86 :: any
100
+ %t88 = length %t87 :: integer
101
101
  %t89 = const 1 :: integer
102
102
  %t90 = call core.sub(%col_i_82, %t89) :: integer
103
103
  %t91 = const 0 :: integer
@@ -108,7 +108,7 @@
108
108
  %t96 = call core.sub(%t88, %t95) :: integer
109
109
  %t97 = const 0 :: integer
110
110
  %t98 = call core.clamp(%t90, %t97, %t96) :: integer
111
- %t99 = Gather %t87, %t98 :: integer
111
+ %t99 = gather %t87, %t98 :: integer
112
112
  %t100 = const 0 :: integer
113
113
  %t101 = select %t94, %t99, %t100 :: integer
114
114
  yield %t101
@@ -119,7 +119,7 @@
119
119
  %t102 = load_input "rows" :: array
120
120
  loop rows id=L11 in %t102 as el=%rows_el_103, idx=%rows_i_104
121
121
  loop col id=L12 in %rows_el_103 as el=%col_el_105, idx=%col_i_106
122
- %t107 = Length %t102 :: integer
122
+ %t107 = length %t102 :: integer
123
123
  %t108 = const -1 :: integer
124
124
  %t109 = call core.sub(%rows_i_104, %t108) :: integer
125
125
  %t110 = const 0 :: integer
@@ -130,8 +130,8 @@
130
130
  %t115 = call core.sub(%t107, %t114) :: integer
131
131
  %t116 = const 0 :: integer
132
132
  %t117 = call core.clamp(%t109, %t116, %t115) :: integer
133
- %t118 = Gather %t102, %t117 :: any
134
- %t119 = Length %t118 :: integer
133
+ %t118 = gather %t102, %t117 :: any
134
+ %t119 = length %t118 :: integer
135
135
  %t120 = const -1 :: integer
136
136
  %t121 = call core.sub(%col_i_106, %t120) :: integer
137
137
  %t122 = const 0 :: integer
@@ -143,7 +143,7 @@
143
143
  %t128 = call core.sub(%t119, %t127) :: integer
144
144
  %t129 = const 0 :: integer
145
145
  %t130 = call core.clamp(%t121, %t129, %t128) :: integer
146
- %t131 = Gather %t118, %t130 :: integer
146
+ %t131 = gather %t118, %t130 :: integer
147
147
  %t132 = const 0 :: integer
148
148
  %t133 = select %t126, %t131, %t132 :: integer
149
149
  yield %t133
@@ -154,7 +154,7 @@
154
154
  %t134 = load_input "rows" :: array
155
155
  loop rows id=L13 in %t134 as el=%rows_el_135, idx=%rows_i_136
156
156
  loop col id=L14 in %rows_el_135 as el=%col_el_137, idx=%col_i_138
157
- %t139 = Length %t134 :: integer
157
+ %t139 = length %t134 :: integer
158
158
  %t140 = const -1 :: integer
159
159
  %t141 = call core.sub(%rows_i_136, %t140) :: integer
160
160
  %t142 = const 0 :: integer
@@ -165,8 +165,8 @@
165
165
  %t147 = call core.sub(%t139, %t146) :: integer
166
166
  %t148 = const 0 :: integer
167
167
  %t149 = call core.clamp(%t141, %t148, %t147) :: integer
168
- %t150 = Gather %t134, %t149 :: any
169
- %t151 = Length %t150 :: integer
168
+ %t150 = gather %t134, %t149 :: any
169
+ %t151 = length %t150 :: integer
170
170
  %t152 = const 1 :: integer
171
171
  %t153 = call core.sub(%col_i_138, %t152) :: integer
172
172
  %t154 = const 0 :: integer
@@ -178,7 +178,7 @@
178
178
  %t160 = call core.sub(%t151, %t159) :: integer
179
179
  %t161 = const 0 :: integer
180
180
  %t162 = call core.clamp(%t153, %t161, %t160) :: integer
181
- %t163 = Gather %t150, %t162 :: integer
181
+ %t163 = gather %t150, %t162 :: integer
182
182
  %t164 = const 0 :: integer
183
183
  %t165 = select %t158, %t163, %t164 :: integer
184
184
  yield %t165
@@ -189,7 +189,7 @@
189
189
  %t166 = load_input "rows" :: array
190
190
  loop rows id=L15 in %t166 as el=%rows_el_167, idx=%rows_i_168
191
191
  loop col id=L16 in %rows_el_167 as el=%col_el_169, idx=%col_i_170
192
- %t171 = Length %t166 :: integer
192
+ %t171 = length %t166 :: integer
193
193
  %t172 = const 1 :: integer
194
194
  %t173 = call core.sub(%rows_i_168, %t172) :: integer
195
195
  %t174 = const 0 :: integer
@@ -200,8 +200,8 @@
200
200
  %t179 = call core.sub(%t171, %t178) :: integer
201
201
  %t180 = const 0 :: integer
202
202
  %t181 = call core.clamp(%t173, %t180, %t179) :: integer
203
- %t182 = Gather %t166, %t181 :: any
204
- %t183 = Length %t182 :: integer
203
+ %t182 = gather %t166, %t181 :: any
204
+ %t183 = length %t182 :: integer
205
205
  %t184 = const -1 :: integer
206
206
  %t185 = call core.sub(%col_i_170, %t184) :: integer
207
207
  %t186 = const 0 :: integer
@@ -213,7 +213,7 @@
213
213
  %t192 = call core.sub(%t183, %t191) :: integer
214
214
  %t193 = const 0 :: integer
215
215
  %t194 = call core.clamp(%t185, %t193, %t192) :: integer
216
- %t195 = Gather %t182, %t194 :: integer
216
+ %t195 = gather %t182, %t194 :: integer
217
217
  %t196 = const 0 :: integer
218
218
  %t197 = select %t190, %t195, %t196 :: integer
219
219
  yield %t197
@@ -224,7 +224,7 @@
224
224
  %t198 = load_input "rows" :: array
225
225
  loop rows id=L17 in %t198 as el=%rows_el_199, idx=%rows_i_200
226
226
  loop col id=L18 in %rows_el_199 as el=%col_el_201, idx=%col_i_202
227
- %t203 = Length %t198 :: integer
227
+ %t203 = length %t198 :: integer
228
228
  %t204 = const 1 :: integer
229
229
  %t205 = call core.sub(%rows_i_200, %t204) :: integer
230
230
  %t206 = const 0 :: integer
@@ -235,8 +235,8 @@
235
235
  %t211 = call core.sub(%t203, %t210) :: integer
236
236
  %t212 = const 0 :: integer
237
237
  %t213 = call core.clamp(%t205, %t212, %t211) :: integer
238
- %t214 = Gather %t198, %t213 :: any
239
- %t215 = Length %t214 :: integer
238
+ %t214 = gather %t198, %t213 :: any
239
+ %t215 = length %t214 :: integer
240
240
  %t216 = const 1 :: integer
241
241
  %t217 = call core.sub(%col_i_202, %t216) :: integer
242
242
  %t218 = const 0 :: integer
@@ -248,7 +248,7 @@
248
248
  %t224 = call core.sub(%t215, %t223) :: integer
249
249
  %t225 = const 0 :: integer
250
250
  %t226 = call core.clamp(%t217, %t225, %t224) :: integer
251
- %t227 = Gather %t214, %t226 :: integer
251
+ %t227 = gather %t214, %t226 :: integer
252
252
  %t228 = const 0 :: integer
253
253
  %t229 = select %t222, %t227, %t228 :: integer
254
254
  yield %t229
@@ -260,7 +260,7 @@
260
260
  loop rows id=L19 in %t230 as el=%rows_el_231, idx=%rows_i_232
261
261
  loop col id=L20 in %rows_el_231 as el=%col_el_233, idx=%col_i_234
262
262
  %t294 = load_input "rows" :: array
263
- %t295 = Length %t294 :: integer
263
+ %t295 = length %t294 :: integer
264
264
  %t296 = const -1 :: integer
265
265
  %t297 = call core.sub(%rows_i_232, %t296) :: integer
266
266
  %t298 = const 0 :: integer
@@ -271,16 +271,16 @@
271
271
  %t303 = call core.sub(%t295, %t302) :: integer
272
272
  %t304 = const 0 :: integer
273
273
  %t305 = call core.clamp(%t297, %t304, %t303) :: integer
274
- %t306 = Gather %t294, %t305 :: any
275
- %t307 = Length %t306 :: integer
274
+ %t306 = gather %t294, %t305 :: any
275
+ %t307 = length %t306 :: integer
276
276
  %t308 = call core.mod(%col_i_234, %t307) :: integer
277
277
  %t309 = call core.add(%t308, %t307) :: integer
278
278
  %t310 = call core.mod(%t309, %t307) :: integer
279
- %t311 = Gather %t306, %t310 :: integer
279
+ %t311 = gather %t306, %t310 :: integer
280
280
  %t312 = const 0 :: integer
281
281
  %t313 = select %t301, %t311, %t312 :: integer
282
282
  %t314 = load_input "rows" :: array
283
- %t315 = Length %t314 :: integer
283
+ %t315 = length %t314 :: integer
284
284
  %t316 = const 1 :: integer
285
285
  %t317 = call core.sub(%rows_i_232, %t316) :: integer
286
286
  %t318 = const 0 :: integer
@@ -291,21 +291,21 @@
291
291
  %t323 = call core.sub(%t315, %t322) :: integer
292
292
  %t324 = const 0 :: integer
293
293
  %t325 = call core.clamp(%t317, %t324, %t323) :: integer
294
- %t326 = Gather %t314, %t325 :: any
295
- %t327 = Length %t326 :: integer
294
+ %t326 = gather %t314, %t325 :: any
295
+ %t327 = length %t326 :: integer
296
296
  %t328 = call core.mod(%col_i_234, %t327) :: integer
297
297
  %t329 = call core.add(%t328, %t327) :: integer
298
298
  %t330 = call core.mod(%t329, %t327) :: integer
299
- %t331 = Gather %t326, %t330 :: integer
299
+ %t331 = gather %t326, %t330 :: integer
300
300
  %t332 = const 0 :: integer
301
301
  %t333 = select %t321, %t331, %t332 :: integer
302
302
  %t334 = load_input "rows" :: array
303
- %t335 = Length %t334 :: integer
303
+ %t335 = length %t334 :: integer
304
304
  %t336 = call core.mod(%rows_i_232, %t335) :: integer
305
305
  %t337 = call core.add(%t336, %t335) :: integer
306
306
  %t338 = call core.mod(%t337, %t335) :: integer
307
- %t339 = Gather %t334, %t338 :: any
308
- %t340 = Length %t339 :: integer
307
+ %t339 = gather %t334, %t338 :: any
308
+ %t340 = length %t339 :: integer
309
309
  %t341 = const -1 :: integer
310
310
  %t342 = call core.sub(%col_i_234, %t341) :: integer
311
311
  %t343 = const 0 :: integer
@@ -316,16 +316,16 @@
316
316
  %t348 = call core.sub(%t340, %t347) :: integer
317
317
  %t349 = const 0 :: integer
318
318
  %t350 = call core.clamp(%t342, %t349, %t348) :: integer
319
- %t351 = Gather %t339, %t350 :: integer
319
+ %t351 = gather %t339, %t350 :: integer
320
320
  %t352 = const 0 :: integer
321
321
  %t353 = select %t346, %t351, %t352 :: integer
322
322
  %t354 = load_input "rows" :: array
323
- %t355 = Length %t354 :: integer
323
+ %t355 = length %t354 :: integer
324
324
  %t356 = call core.mod(%rows_i_232, %t355) :: integer
325
325
  %t357 = call core.add(%t356, %t355) :: integer
326
326
  %t358 = call core.mod(%t357, %t355) :: integer
327
- %t359 = Gather %t354, %t358 :: any
328
- %t360 = Length %t359 :: integer
327
+ %t359 = gather %t354, %t358 :: any
328
+ %t360 = length %t359 :: integer
329
329
  %t361 = const 1 :: integer
330
330
  %t362 = call core.sub(%col_i_234, %t361) :: integer
331
331
  %t363 = const 0 :: integer
@@ -336,11 +336,11 @@
336
336
  %t368 = call core.sub(%t360, %t367) :: integer
337
337
  %t369 = const 0 :: integer
338
338
  %t370 = call core.clamp(%t362, %t369, %t368) :: integer
339
- %t371 = Gather %t359, %t370 :: integer
339
+ %t371 = gather %t359, %t370 :: integer
340
340
  %t372 = const 0 :: integer
341
341
  %t373 = select %t366, %t371, %t372 :: integer
342
342
  %t374 = load_input "rows" :: array
343
- %t375 = Length %t374 :: integer
343
+ %t375 = length %t374 :: integer
344
344
  %t376 = const -1 :: integer
345
345
  %t377 = call core.sub(%rows_i_232, %t376) :: integer
346
346
  %t378 = const 0 :: integer
@@ -351,8 +351,8 @@
351
351
  %t383 = call core.sub(%t375, %t382) :: integer
352
352
  %t384 = const 0 :: integer
353
353
  %t385 = call core.clamp(%t377, %t384, %t383) :: integer
354
- %t386 = Gather %t374, %t385 :: any
355
- %t387 = Length %t386 :: integer
354
+ %t386 = gather %t374, %t385 :: any
355
+ %t387 = length %t386 :: integer
356
356
  %t388 = const -1 :: integer
357
357
  %t389 = call core.sub(%col_i_234, %t388) :: integer
358
358
  %t390 = const 0 :: integer
@@ -364,11 +364,11 @@
364
364
  %t396 = call core.sub(%t387, %t395) :: integer
365
365
  %t397 = const 0 :: integer
366
366
  %t398 = call core.clamp(%t389, %t397, %t396) :: integer
367
- %t399 = Gather %t386, %t398 :: integer
367
+ %t399 = gather %t386, %t398 :: integer
368
368
  %t400 = const 0 :: integer
369
369
  %t401 = select %t394, %t399, %t400 :: integer
370
370
  %t402 = load_input "rows" :: array
371
- %t403 = Length %t402 :: integer
371
+ %t403 = length %t402 :: integer
372
372
  %t404 = const -1 :: integer
373
373
  %t405 = call core.sub(%rows_i_232, %t404) :: integer
374
374
  %t406 = const 0 :: integer
@@ -379,8 +379,8 @@
379
379
  %t411 = call core.sub(%t403, %t410) :: integer
380
380
  %t412 = const 0 :: integer
381
381
  %t413 = call core.clamp(%t405, %t412, %t411) :: integer
382
- %t414 = Gather %t402, %t413 :: any
383
- %t415 = Length %t414 :: integer
382
+ %t414 = gather %t402, %t413 :: any
383
+ %t415 = length %t414 :: integer
384
384
  %t416 = const 1 :: integer
385
385
  %t417 = call core.sub(%col_i_234, %t416) :: integer
386
386
  %t418 = const 0 :: integer
@@ -392,11 +392,11 @@
392
392
  %t424 = call core.sub(%t415, %t423) :: integer
393
393
  %t425 = const 0 :: integer
394
394
  %t426 = call core.clamp(%t417, %t425, %t424) :: integer
395
- %t427 = Gather %t414, %t426 :: integer
395
+ %t427 = gather %t414, %t426 :: integer
396
396
  %t428 = const 0 :: integer
397
397
  %t429 = select %t422, %t427, %t428 :: integer
398
398
  %t430 = load_input "rows" :: array
399
- %t431 = Length %t430 :: integer
399
+ %t431 = length %t430 :: integer
400
400
  %t432 = const 1 :: integer
401
401
  %t433 = call core.sub(%rows_i_232, %t432) :: integer
402
402
  %t434 = const 0 :: integer
@@ -407,8 +407,8 @@
407
407
  %t439 = call core.sub(%t431, %t438) :: integer
408
408
  %t440 = const 0 :: integer
409
409
  %t441 = call core.clamp(%t433, %t440, %t439) :: integer
410
- %t442 = Gather %t430, %t441 :: any
411
- %t443 = Length %t442 :: integer
410
+ %t442 = gather %t430, %t441 :: any
411
+ %t443 = length %t442 :: integer
412
412
  %t444 = const -1 :: integer
413
413
  %t445 = call core.sub(%col_i_234, %t444) :: integer
414
414
  %t446 = const 0 :: integer
@@ -420,11 +420,11 @@
420
420
  %t452 = call core.sub(%t443, %t451) :: integer
421
421
  %t453 = const 0 :: integer
422
422
  %t454 = call core.clamp(%t445, %t453, %t452) :: integer
423
- %t455 = Gather %t442, %t454 :: integer
423
+ %t455 = gather %t442, %t454 :: integer
424
424
  %t456 = const 0 :: integer
425
425
  %t457 = select %t450, %t455, %t456 :: integer
426
426
  %t458 = load_input "rows" :: array
427
- %t459 = Length %t458 :: integer
427
+ %t459 = length %t458 :: integer
428
428
  %t460 = const 1 :: integer
429
429
  %t461 = call core.sub(%rows_i_232, %t460) :: integer
430
430
  %t462 = const 0 :: integer
@@ -435,8 +435,8 @@
435
435
  %t467 = call core.sub(%t459, %t466) :: integer
436
436
  %t468 = const 0 :: integer
437
437
  %t469 = call core.clamp(%t461, %t468, %t467) :: integer
438
- %t470 = Gather %t458, %t469 :: any
439
- %t471 = Length %t470 :: integer
438
+ %t470 = gather %t458, %t469 :: any
439
+ %t471 = length %t470 :: integer
440
440
  %t472 = const 1 :: integer
441
441
  %t473 = call core.sub(%col_i_234, %t472) :: integer
442
442
  %t474 = const 0 :: integer
@@ -448,11 +448,11 @@
448
448
  %t480 = call core.sub(%t471, %t479) :: integer
449
449
  %t481 = const 0 :: integer
450
450
  %t482 = call core.clamp(%t473, %t481, %t480) :: integer
451
- %t483 = Gather %t470, %t482 :: integer
451
+ %t483 = gather %t470, %t482 :: integer
452
452
  %t484 = const 0 :: integer
453
453
  %t485 = select %t478, %t483, %t484 :: integer
454
454
  %t243 = make_tuple(%t313, %t333, %t353, %t373, %t401, %t429, %t457, %t485) :: tuple<integer>
455
- %t244 = Fold %t243 fn="agg.sum" ::
455
+ %t244 = fold %t243 fn="agg.sum" ::
456
456
  yield %t244
457
457
  end_loop
458
458
  end_loop
@@ -473,200 +473,200 @@
473
473
  loop rows id=L23 in %t253 as el=%rows_el_254, idx=%rows_i_255
474
474
  loop col id=L24 in %rows_el_254 as el=%col_el_256, idx=%col_i_257
475
475
  %t487 = load_input "rows" :: array
476
- %t529 = load_input "rows" :: array
477
- %t530 = Length %t529 :: integer
478
- %t531 = const -1 :: integer
479
- %t532 = call core.sub(%rows_i_255, %t531) :: integer
480
- %t533 = const 0 :: integer
481
- %t534 = call core.gte(%t532, %t533) :: boolean
482
- %t535 = call core.lt(%t532, %t530) :: boolean
483
- %t536 = call core.and(%t534, %t535) :: boolean
484
- %t537 = const 1 :: integer
485
- %t538 = call core.sub(%t530, %t537) :: integer
486
- %t539 = const 0 :: integer
487
- %t540 = call core.clamp(%t532, %t539, %t538) :: integer
488
- %t541 = Gather %t529, %t540 :: any
489
- %t542 = Length %t541 :: integer
490
- %t543 = call core.mod(%col_i_257, %t542) :: integer
491
- %t544 = call core.add(%t543, %t542) :: integer
492
- %t545 = call core.mod(%t544, %t542) :: integer
493
- %t546 = Gather %t541, %t545 :: integer
476
+ %t498 = load_input "rows" :: array
477
+ %t499 = length %t498 :: integer
478
+ %t500 = const -1 :: integer
479
+ %t501 = call core.sub(%rows_i_255, %t500) :: integer
480
+ %t502 = const 0 :: integer
481
+ %t503 = call core.gte(%t501, %t502) :: boolean
482
+ %t504 = call core.lt(%t501, %t499) :: boolean
483
+ %t505 = call core.and(%t503, %t504) :: boolean
484
+ %t506 = const 1 :: integer
485
+ %t507 = call core.sub(%t499, %t506) :: integer
486
+ %t508 = const 0 :: integer
487
+ %t509 = call core.clamp(%t501, %t508, %t507) :: integer
488
+ %t510 = gather %t498, %t509 :: any
489
+ %t511 = length %t510 :: integer
490
+ %t512 = call core.mod(%col_i_257, %t511) :: integer
491
+ %t513 = call core.add(%t512, %t511) :: integer
492
+ %t514 = call core.mod(%t513, %t511) :: integer
493
+ %t515 = gather %t510, %t514 :: integer
494
+ %t516 = const 0 :: integer
495
+ %t517 = select %t505, %t515, %t516 :: integer
496
+ %t518 = load_input "rows" :: array
497
+ %t519 = length %t518 :: integer
498
+ %t520 = const 1 :: integer
499
+ %t521 = call core.sub(%rows_i_255, %t520) :: integer
500
+ %t522 = const 0 :: integer
501
+ %t523 = call core.gte(%t521, %t522) :: boolean
502
+ %t524 = call core.lt(%t521, %t519) :: boolean
503
+ %t525 = call core.and(%t523, %t524) :: boolean
504
+ %t526 = const 1 :: integer
505
+ %t527 = call core.sub(%t519, %t526) :: integer
506
+ %t528 = const 0 :: integer
507
+ %t529 = call core.clamp(%t521, %t528, %t527) :: integer
508
+ %t530 = gather %t518, %t529 :: any
509
+ %t531 = length %t530 :: integer
510
+ %t532 = call core.mod(%col_i_257, %t531) :: integer
511
+ %t533 = call core.add(%t532, %t531) :: integer
512
+ %t534 = call core.mod(%t533, %t531) :: integer
513
+ %t535 = gather %t530, %t534 :: integer
514
+ %t536 = const 0 :: integer
515
+ %t537 = select %t525, %t535, %t536 :: integer
516
+ %t538 = load_input "rows" :: array
517
+ %t539 = length %t538 :: integer
518
+ %t540 = call core.mod(%rows_i_255, %t539) :: integer
519
+ %t541 = call core.add(%t540, %t539) :: integer
520
+ %t542 = call core.mod(%t541, %t539) :: integer
521
+ %t543 = gather %t538, %t542 :: any
522
+ %t544 = length %t543 :: integer
523
+ %t545 = const -1 :: integer
524
+ %t546 = call core.sub(%col_i_257, %t545) :: integer
494
525
  %t547 = const 0 :: integer
495
- %t548 = select %t536, %t546, %t547 :: integer
496
- %t549 = load_input "rows" :: array
497
- %t550 = Length %t549 :: integer
526
+ %t548 = call core.gte(%t546, %t547) :: boolean
527
+ %t549 = call core.lt(%t546, %t544) :: boolean
528
+ %t550 = call core.and(%t548, %t549) :: boolean
498
529
  %t551 = const 1 :: integer
499
- %t552 = call core.sub(%rows_i_255, %t551) :: integer
530
+ %t552 = call core.sub(%t544, %t551) :: integer
500
531
  %t553 = const 0 :: integer
501
- %t554 = call core.gte(%t552, %t553) :: boolean
502
- %t555 = call core.lt(%t552, %t550) :: boolean
503
- %t556 = call core.and(%t554, %t555) :: boolean
504
- %t557 = const 1 :: integer
505
- %t558 = call core.sub(%t550, %t557) :: integer
506
- %t559 = const 0 :: integer
507
- %t560 = call core.clamp(%t552, %t559, %t558) :: integer
508
- %t561 = Gather %t549, %t560 :: any
509
- %t562 = Length %t561 :: integer
510
- %t563 = call core.mod(%col_i_257, %t562) :: integer
511
- %t564 = call core.add(%t563, %t562) :: integer
512
- %t565 = call core.mod(%t564, %t562) :: integer
513
- %t566 = Gather %t561, %t565 :: integer
532
+ %t554 = call core.clamp(%t546, %t553, %t552) :: integer
533
+ %t555 = gather %t543, %t554 :: integer
534
+ %t556 = const 0 :: integer
535
+ %t557 = select %t550, %t555, %t556 :: integer
536
+ %t558 = load_input "rows" :: array
537
+ %t559 = length %t558 :: integer
538
+ %t560 = call core.mod(%rows_i_255, %t559) :: integer
539
+ %t561 = call core.add(%t560, %t559) :: integer
540
+ %t562 = call core.mod(%t561, %t559) :: integer
541
+ %t563 = gather %t558, %t562 :: any
542
+ %t564 = length %t563 :: integer
543
+ %t565 = const 1 :: integer
544
+ %t566 = call core.sub(%col_i_257, %t565) :: integer
514
545
  %t567 = const 0 :: integer
515
- %t568 = select %t556, %t566, %t567 :: integer
516
- %t569 = load_input "rows" :: array
517
- %t570 = Length %t569 :: integer
518
- %t571 = call core.mod(%rows_i_255, %t570) :: integer
519
- %t572 = call core.add(%t571, %t570) :: integer
520
- %t573 = call core.mod(%t572, %t570) :: integer
521
- %t574 = Gather %t569, %t573 :: any
522
- %t575 = Length %t574 :: integer
523
- %t576 = const -1 :: integer
524
- %t577 = call core.sub(%col_i_257, %t576) :: integer
525
- %t578 = const 0 :: integer
526
- %t579 = call core.gte(%t577, %t578) :: boolean
527
- %t580 = call core.lt(%t577, %t575) :: boolean
528
- %t581 = call core.and(%t579, %t580) :: boolean
529
- %t582 = const 1 :: integer
530
- %t583 = call core.sub(%t575, %t582) :: integer
531
- %t584 = const 0 :: integer
532
- %t585 = call core.clamp(%t577, %t584, %t583) :: integer
533
- %t586 = Gather %t574, %t585 :: integer
534
- %t587 = const 0 :: integer
535
- %t588 = select %t581, %t586, %t587 :: integer
536
- %t589 = load_input "rows" :: array
537
- %t590 = Length %t589 :: integer
538
- %t591 = call core.mod(%rows_i_255, %t590) :: integer
539
- %t592 = call core.add(%t591, %t590) :: integer
540
- %t593 = call core.mod(%t592, %t590) :: integer
541
- %t594 = Gather %t589, %t593 :: any
542
- %t595 = Length %t594 :: integer
543
- %t596 = const 1 :: integer
544
- %t597 = call core.sub(%col_i_257, %t596) :: integer
545
- %t598 = const 0 :: integer
546
- %t599 = call core.gte(%t597, %t598) :: boolean
547
- %t600 = call core.lt(%t597, %t595) :: boolean
548
- %t601 = call core.and(%t599, %t600) :: boolean
549
- %t602 = const 1 :: integer
550
- %t603 = call core.sub(%t595, %t602) :: integer
546
+ %t568 = call core.gte(%t566, %t567) :: boolean
547
+ %t569 = call core.lt(%t566, %t564) :: boolean
548
+ %t570 = call core.and(%t568, %t569) :: boolean
549
+ %t571 = const 1 :: integer
550
+ %t572 = call core.sub(%t564, %t571) :: integer
551
+ %t573 = const 0 :: integer
552
+ %t574 = call core.clamp(%t566, %t573, %t572) :: integer
553
+ %t575 = gather %t563, %t574 :: integer
554
+ %t576 = const 0 :: integer
555
+ %t577 = select %t570, %t575, %t576 :: integer
556
+ %t578 = load_input "rows" :: array
557
+ %t579 = length %t578 :: integer
558
+ %t580 = const -1 :: integer
559
+ %t581 = call core.sub(%rows_i_255, %t580) :: integer
560
+ %t582 = const 0 :: integer
561
+ %t583 = call core.gte(%t581, %t582) :: boolean
562
+ %t584 = call core.lt(%t581, %t579) :: boolean
563
+ %t585 = call core.and(%t583, %t584) :: boolean
564
+ %t586 = const 1 :: integer
565
+ %t587 = call core.sub(%t579, %t586) :: integer
566
+ %t588 = const 0 :: integer
567
+ %t589 = call core.clamp(%t581, %t588, %t587) :: integer
568
+ %t590 = gather %t578, %t589 :: any
569
+ %t591 = length %t590 :: integer
570
+ %t592 = const -1 :: integer
571
+ %t593 = call core.sub(%col_i_257, %t592) :: integer
572
+ %t594 = const 0 :: integer
573
+ %t595 = call core.gte(%t593, %t594) :: boolean
574
+ %t596 = call core.lt(%t593, %t591) :: boolean
575
+ %t597 = call core.and(%t595, %t596) :: boolean
576
+ %t598 = call core.and(%t585, %t597) :: boolean
577
+ %t599 = const 1 :: integer
578
+ %t600 = call core.sub(%t591, %t599) :: integer
579
+ %t601 = const 0 :: integer
580
+ %t602 = call core.clamp(%t593, %t601, %t600) :: integer
581
+ %t603 = gather %t590, %t602 :: integer
551
582
  %t604 = const 0 :: integer
552
- %t605 = call core.clamp(%t597, %t604, %t603) :: integer
553
- %t606 = Gather %t594, %t605 :: integer
554
- %t607 = const 0 :: integer
555
- %t608 = select %t601, %t606, %t607 :: integer
556
- %t609 = load_input "rows" :: array
557
- %t610 = Length %t609 :: integer
558
- %t611 = const -1 :: integer
559
- %t612 = call core.sub(%rows_i_255, %t611) :: integer
560
- %t613 = const 0 :: integer
561
- %t614 = call core.gte(%t612, %t613) :: boolean
562
- %t615 = call core.lt(%t612, %t610) :: boolean
563
- %t616 = call core.and(%t614, %t615) :: boolean
564
- %t617 = const 1 :: integer
565
- %t618 = call core.sub(%t610, %t617) :: integer
566
- %t619 = const 0 :: integer
567
- %t620 = call core.clamp(%t612, %t619, %t618) :: integer
568
- %t621 = Gather %t609, %t620 :: any
569
- %t622 = Length %t621 :: integer
570
- %t623 = const -1 :: integer
571
- %t624 = call core.sub(%col_i_257, %t623) :: integer
572
- %t625 = const 0 :: integer
573
- %t626 = call core.gte(%t624, %t625) :: boolean
574
- %t627 = call core.lt(%t624, %t622) :: boolean
575
- %t628 = call core.and(%t626, %t627) :: boolean
576
- %t629 = call core.and(%t616, %t628) :: boolean
577
- %t630 = const 1 :: integer
578
- %t631 = call core.sub(%t622, %t630) :: integer
583
+ %t605 = select %t598, %t603, %t604 :: integer
584
+ %t606 = load_input "rows" :: array
585
+ %t607 = length %t606 :: integer
586
+ %t608 = const -1 :: integer
587
+ %t609 = call core.sub(%rows_i_255, %t608) :: integer
588
+ %t610 = const 0 :: integer
589
+ %t611 = call core.gte(%t609, %t610) :: boolean
590
+ %t612 = call core.lt(%t609, %t607) :: boolean
591
+ %t613 = call core.and(%t611, %t612) :: boolean
592
+ %t614 = const 1 :: integer
593
+ %t615 = call core.sub(%t607, %t614) :: integer
594
+ %t616 = const 0 :: integer
595
+ %t617 = call core.clamp(%t609, %t616, %t615) :: integer
596
+ %t618 = gather %t606, %t617 :: any
597
+ %t619 = length %t618 :: integer
598
+ %t620 = const 1 :: integer
599
+ %t621 = call core.sub(%col_i_257, %t620) :: integer
600
+ %t622 = const 0 :: integer
601
+ %t623 = call core.gte(%t621, %t622) :: boolean
602
+ %t624 = call core.lt(%t621, %t619) :: boolean
603
+ %t625 = call core.and(%t623, %t624) :: boolean
604
+ %t626 = call core.and(%t613, %t625) :: boolean
605
+ %t627 = const 1 :: integer
606
+ %t628 = call core.sub(%t619, %t627) :: integer
607
+ %t629 = const 0 :: integer
608
+ %t630 = call core.clamp(%t621, %t629, %t628) :: integer
609
+ %t631 = gather %t618, %t630 :: integer
579
610
  %t632 = const 0 :: integer
580
- %t633 = call core.clamp(%t624, %t632, %t631) :: integer
581
- %t634 = Gather %t621, %t633 :: integer
582
- %t635 = const 0 :: integer
583
- %t636 = select %t629, %t634, %t635 :: integer
584
- %t637 = load_input "rows" :: array
585
- %t638 = Length %t637 :: integer
586
- %t639 = const -1 :: integer
587
- %t640 = call core.sub(%rows_i_255, %t639) :: integer
588
- %t641 = const 0 :: integer
589
- %t642 = call core.gte(%t640, %t641) :: boolean
590
- %t643 = call core.lt(%t640, %t638) :: boolean
591
- %t644 = call core.and(%t642, %t643) :: boolean
592
- %t645 = const 1 :: integer
593
- %t646 = call core.sub(%t638, %t645) :: integer
594
- %t647 = const 0 :: integer
595
- %t648 = call core.clamp(%t640, %t647, %t646) :: integer
596
- %t649 = Gather %t637, %t648 :: any
597
- %t650 = Length %t649 :: integer
598
- %t651 = const 1 :: integer
599
- %t652 = call core.sub(%col_i_257, %t651) :: integer
600
- %t653 = const 0 :: integer
601
- %t654 = call core.gte(%t652, %t653) :: boolean
602
- %t655 = call core.lt(%t652, %t650) :: boolean
603
- %t656 = call core.and(%t654, %t655) :: boolean
604
- %t657 = call core.and(%t644, %t656) :: boolean
605
- %t658 = const 1 :: integer
606
- %t659 = call core.sub(%t650, %t658) :: integer
611
+ %t633 = select %t626, %t631, %t632 :: integer
612
+ %t634 = load_input "rows" :: array
613
+ %t635 = length %t634 :: integer
614
+ %t636 = const 1 :: integer
615
+ %t637 = call core.sub(%rows_i_255, %t636) :: integer
616
+ %t638 = const 0 :: integer
617
+ %t639 = call core.gte(%t637, %t638) :: boolean
618
+ %t640 = call core.lt(%t637, %t635) :: boolean
619
+ %t641 = call core.and(%t639, %t640) :: boolean
620
+ %t642 = const 1 :: integer
621
+ %t643 = call core.sub(%t635, %t642) :: integer
622
+ %t644 = const 0 :: integer
623
+ %t645 = call core.clamp(%t637, %t644, %t643) :: integer
624
+ %t646 = gather %t634, %t645 :: any
625
+ %t647 = length %t646 :: integer
626
+ %t648 = const -1 :: integer
627
+ %t649 = call core.sub(%col_i_257, %t648) :: integer
628
+ %t650 = const 0 :: integer
629
+ %t651 = call core.gte(%t649, %t650) :: boolean
630
+ %t652 = call core.lt(%t649, %t647) :: boolean
631
+ %t653 = call core.and(%t651, %t652) :: boolean
632
+ %t654 = call core.and(%t641, %t653) :: boolean
633
+ %t655 = const 1 :: integer
634
+ %t656 = call core.sub(%t647, %t655) :: integer
635
+ %t657 = const 0 :: integer
636
+ %t658 = call core.clamp(%t649, %t657, %t656) :: integer
637
+ %t659 = gather %t646, %t658 :: integer
607
638
  %t660 = const 0 :: integer
608
- %t661 = call core.clamp(%t652, %t660, %t659) :: integer
609
- %t662 = Gather %t649, %t661 :: integer
610
- %t663 = const 0 :: integer
611
- %t664 = select %t657, %t662, %t663 :: integer
612
- %t665 = load_input "rows" :: array
613
- %t666 = Length %t665 :: integer
614
- %t667 = const 1 :: integer
615
- %t668 = call core.sub(%rows_i_255, %t667) :: integer
616
- %t669 = const 0 :: integer
617
- %t670 = call core.gte(%t668, %t669) :: boolean
618
- %t671 = call core.lt(%t668, %t666) :: boolean
619
- %t672 = call core.and(%t670, %t671) :: boolean
620
- %t673 = const 1 :: integer
621
- %t674 = call core.sub(%t666, %t673) :: integer
622
- %t675 = const 0 :: integer
623
- %t676 = call core.clamp(%t668, %t675, %t674) :: integer
624
- %t677 = Gather %t665, %t676 :: any
625
- %t678 = Length %t677 :: integer
626
- %t679 = const -1 :: integer
627
- %t680 = call core.sub(%col_i_257, %t679) :: integer
628
- %t681 = const 0 :: integer
629
- %t682 = call core.gte(%t680, %t681) :: boolean
630
- %t683 = call core.lt(%t680, %t678) :: boolean
631
- %t684 = call core.and(%t682, %t683) :: boolean
632
- %t685 = call core.and(%t672, %t684) :: boolean
633
- %t686 = const 1 :: integer
634
- %t687 = call core.sub(%t678, %t686) :: integer
639
+ %t661 = select %t654, %t659, %t660 :: integer
640
+ %t662 = load_input "rows" :: array
641
+ %t663 = length %t662 :: integer
642
+ %t664 = const 1 :: integer
643
+ %t665 = call core.sub(%rows_i_255, %t664) :: integer
644
+ %t666 = const 0 :: integer
645
+ %t667 = call core.gte(%t665, %t666) :: boolean
646
+ %t668 = call core.lt(%t665, %t663) :: boolean
647
+ %t669 = call core.and(%t667, %t668) :: boolean
648
+ %t670 = const 1 :: integer
649
+ %t671 = call core.sub(%t663, %t670) :: integer
650
+ %t672 = const 0 :: integer
651
+ %t673 = call core.clamp(%t665, %t672, %t671) :: integer
652
+ %t674 = gather %t662, %t673 :: any
653
+ %t675 = length %t674 :: integer
654
+ %t676 = const 1 :: integer
655
+ %t677 = call core.sub(%col_i_257, %t676) :: integer
656
+ %t678 = const 0 :: integer
657
+ %t679 = call core.gte(%t677, %t678) :: boolean
658
+ %t680 = call core.lt(%t677, %t675) :: boolean
659
+ %t681 = call core.and(%t679, %t680) :: boolean
660
+ %t682 = call core.and(%t669, %t681) :: boolean
661
+ %t683 = const 1 :: integer
662
+ %t684 = call core.sub(%t675, %t683) :: integer
663
+ %t685 = const 0 :: integer
664
+ %t686 = call core.clamp(%t677, %t685, %t684) :: integer
665
+ %t687 = gather %t674, %t686 :: integer
635
666
  %t688 = const 0 :: integer
636
- %t689 = call core.clamp(%t680, %t688, %t687) :: integer
637
- %t690 = Gather %t677, %t689 :: integer
638
- %t691 = const 0 :: integer
639
- %t692 = select %t685, %t690, %t691 :: integer
640
- %t693 = load_input "rows" :: array
641
- %t694 = Length %t693 :: integer
642
- %t695 = const 1 :: integer
643
- %t696 = call core.sub(%rows_i_255, %t695) :: integer
644
- %t697 = const 0 :: integer
645
- %t698 = call core.gte(%t696, %t697) :: boolean
646
- %t699 = call core.lt(%t696, %t694) :: boolean
647
- %t700 = call core.and(%t698, %t699) :: boolean
648
- %t701 = const 1 :: integer
649
- %t702 = call core.sub(%t694, %t701) :: integer
650
- %t703 = const 0 :: integer
651
- %t704 = call core.clamp(%t696, %t703, %t702) :: integer
652
- %t705 = Gather %t693, %t704 :: any
653
- %t706 = Length %t705 :: integer
654
- %t707 = const 1 :: integer
655
- %t708 = call core.sub(%col_i_257, %t707) :: integer
656
- %t709 = const 0 :: integer
657
- %t710 = call core.gte(%t708, %t709) :: boolean
658
- %t711 = call core.lt(%t708, %t706) :: boolean
659
- %t712 = call core.and(%t710, %t711) :: boolean
660
- %t713 = call core.and(%t700, %t712) :: boolean
661
- %t714 = const 1 :: integer
662
- %t715 = call core.sub(%t706, %t714) :: integer
663
- %t716 = const 0 :: integer
664
- %t717 = call core.clamp(%t708, %t716, %t715) :: integer
665
- %t718 = Gather %t705, %t717 :: integer
666
- %t719 = const 0 :: integer
667
- %t720 = select %t713, %t718, %t719 :: integer
668
- %t496 = make_tuple(%t548, %t568, %t588, %t608, %t636, %t664, %t692, %t720) :: tuple<integer>
669
- %t497 = Fold %t496 fn="agg.sum" ::
667
+ %t689 = select %t682, %t687, %t688 :: integer
668
+ %t496 = make_tuple(%t517, %t537, %t557, %t577, %t605, %t633, %t661, %t689) :: tuple<integer>
669
+ %t497 = fold %t496 fn="agg.sum" ::
670
670
  %t259 = const 3 :: integer
671
671
  %t260 = call core.eq(%t497, %t259) :: boolean
672
672
  yield %t260
@@ -677,10 +677,30 @@
677
677
  %t261 = load_input "rows" :: array
678
678
  loop rows id=L25 in %t261 as el=%rows_el_262, idx=%rows_i_263
679
679
  loop col id=L26 in %rows_el_262 as el=%col_el_264, idx=%col_i_265
680
- %t498 = load_input "rows" :: array
680
+ %t690 = load_input "rows" :: array
681
+ %t701 = load_input "rows" :: array
682
+ %t702 = length %t701 :: integer
683
+ %t703 = const -1 :: integer
684
+ %t704 = call core.sub(%rows_i_263, %t703) :: integer
685
+ %t705 = const 0 :: integer
686
+ %t706 = call core.gte(%t704, %t705) :: boolean
687
+ %t707 = call core.lt(%t704, %t702) :: boolean
688
+ %t708 = call core.and(%t706, %t707) :: boolean
689
+ %t709 = const 1 :: integer
690
+ %t710 = call core.sub(%t702, %t709) :: integer
691
+ %t711 = const 0 :: integer
692
+ %t712 = call core.clamp(%t704, %t711, %t710) :: integer
693
+ %t713 = gather %t701, %t712 :: any
694
+ %t714 = length %t713 :: integer
695
+ %t715 = call core.mod(%col_i_265, %t714) :: integer
696
+ %t716 = call core.add(%t715, %t714) :: integer
697
+ %t717 = call core.mod(%t716, %t714) :: integer
698
+ %t718 = gather %t713, %t717 :: integer
699
+ %t719 = const 0 :: integer
700
+ %t720 = select %t708, %t718, %t719 :: integer
681
701
  %t721 = load_input "rows" :: array
682
- %t722 = Length %t721 :: integer
683
- %t723 = const -1 :: integer
702
+ %t722 = length %t721 :: integer
703
+ %t723 = const 1 :: integer
684
704
  %t724 = call core.sub(%rows_i_263, %t723) :: integer
685
705
  %t725 = const 0 :: integer
686
706
  %t726 = call core.gte(%t724, %t725) :: boolean
@@ -690,42 +710,42 @@
690
710
  %t730 = call core.sub(%t722, %t729) :: integer
691
711
  %t731 = const 0 :: integer
692
712
  %t732 = call core.clamp(%t724, %t731, %t730) :: integer
693
- %t733 = Gather %t721, %t732 :: any
694
- %t734 = Length %t733 :: integer
713
+ %t733 = gather %t721, %t732 :: any
714
+ %t734 = length %t733 :: integer
695
715
  %t735 = call core.mod(%col_i_265, %t734) :: integer
696
716
  %t736 = call core.add(%t735, %t734) :: integer
697
717
  %t737 = call core.mod(%t736, %t734) :: integer
698
- %t738 = Gather %t733, %t737 :: integer
718
+ %t738 = gather %t733, %t737 :: integer
699
719
  %t739 = const 0 :: integer
700
720
  %t740 = select %t728, %t738, %t739 :: integer
701
721
  %t741 = load_input "rows" :: array
702
- %t742 = Length %t741 :: integer
703
- %t743 = const 1 :: integer
704
- %t744 = call core.sub(%rows_i_263, %t743) :: integer
705
- %t745 = const 0 :: integer
706
- %t746 = call core.gte(%t744, %t745) :: boolean
707
- %t747 = call core.lt(%t744, %t742) :: boolean
708
- %t748 = call core.and(%t746, %t747) :: boolean
709
- %t749 = const 1 :: integer
710
- %t750 = call core.sub(%t742, %t749) :: integer
711
- %t751 = const 0 :: integer
712
- %t752 = call core.clamp(%t744, %t751, %t750) :: integer
713
- %t753 = Gather %t741, %t752 :: any
714
- %t754 = Length %t753 :: integer
715
- %t755 = call core.mod(%col_i_265, %t754) :: integer
716
- %t756 = call core.add(%t755, %t754) :: integer
717
- %t757 = call core.mod(%t756, %t754) :: integer
718
- %t758 = Gather %t753, %t757 :: integer
722
+ %t742 = length %t741 :: integer
723
+ %t743 = call core.mod(%rows_i_263, %t742) :: integer
724
+ %t744 = call core.add(%t743, %t742) :: integer
725
+ %t745 = call core.mod(%t744, %t742) :: integer
726
+ %t746 = gather %t741, %t745 :: any
727
+ %t747 = length %t746 :: integer
728
+ %t748 = const -1 :: integer
729
+ %t749 = call core.sub(%col_i_265, %t748) :: integer
730
+ %t750 = const 0 :: integer
731
+ %t751 = call core.gte(%t749, %t750) :: boolean
732
+ %t752 = call core.lt(%t749, %t747) :: boolean
733
+ %t753 = call core.and(%t751, %t752) :: boolean
734
+ %t754 = const 1 :: integer
735
+ %t755 = call core.sub(%t747, %t754) :: integer
736
+ %t756 = const 0 :: integer
737
+ %t757 = call core.clamp(%t749, %t756, %t755) :: integer
738
+ %t758 = gather %t746, %t757 :: integer
719
739
  %t759 = const 0 :: integer
720
- %t760 = select %t748, %t758, %t759 :: integer
740
+ %t760 = select %t753, %t758, %t759 :: integer
721
741
  %t761 = load_input "rows" :: array
722
- %t762 = Length %t761 :: integer
742
+ %t762 = length %t761 :: integer
723
743
  %t763 = call core.mod(%rows_i_263, %t762) :: integer
724
744
  %t764 = call core.add(%t763, %t762) :: integer
725
745
  %t765 = call core.mod(%t764, %t762) :: integer
726
- %t766 = Gather %t761, %t765 :: any
727
- %t767 = Length %t766 :: integer
728
- %t768 = const -1 :: integer
746
+ %t766 = gather %t761, %t765 :: any
747
+ %t767 = length %t766 :: integer
748
+ %t768 = const 1 :: integer
729
749
  %t769 = call core.sub(%col_i_265, %t768) :: integer
730
750
  %t770 = const 0 :: integer
731
751
  %t771 = call core.gte(%t769, %t770) :: boolean
@@ -735,145 +755,125 @@
735
755
  %t775 = call core.sub(%t767, %t774) :: integer
736
756
  %t776 = const 0 :: integer
737
757
  %t777 = call core.clamp(%t769, %t776, %t775) :: integer
738
- %t778 = Gather %t766, %t777 :: integer
758
+ %t778 = gather %t766, %t777 :: integer
739
759
  %t779 = const 0 :: integer
740
760
  %t780 = select %t773, %t778, %t779 :: integer
741
761
  %t781 = load_input "rows" :: array
742
- %t782 = Length %t781 :: integer
743
- %t783 = call core.mod(%rows_i_263, %t782) :: integer
744
- %t784 = call core.add(%t783, %t782) :: integer
745
- %t785 = call core.mod(%t784, %t782) :: integer
746
- %t786 = Gather %t781, %t785 :: any
747
- %t787 = Length %t786 :: integer
748
- %t788 = const 1 :: integer
749
- %t789 = call core.sub(%col_i_265, %t788) :: integer
750
- %t790 = const 0 :: integer
751
- %t791 = call core.gte(%t789, %t790) :: boolean
752
- %t792 = call core.lt(%t789, %t787) :: boolean
753
- %t793 = call core.and(%t791, %t792) :: boolean
754
- %t794 = const 1 :: integer
755
- %t795 = call core.sub(%t787, %t794) :: integer
756
- %t796 = const 0 :: integer
757
- %t797 = call core.clamp(%t789, %t796, %t795) :: integer
758
- %t798 = Gather %t786, %t797 :: integer
759
- %t799 = const 0 :: integer
760
- %t800 = select %t793, %t798, %t799 :: integer
761
- %t801 = load_input "rows" :: array
762
- %t802 = Length %t801 :: integer
763
- %t803 = const -1 :: integer
764
- %t804 = call core.sub(%rows_i_263, %t803) :: integer
765
- %t805 = const 0 :: integer
766
- %t806 = call core.gte(%t804, %t805) :: boolean
767
- %t807 = call core.lt(%t804, %t802) :: boolean
768
- %t808 = call core.and(%t806, %t807) :: boolean
769
- %t809 = const 1 :: integer
770
- %t810 = call core.sub(%t802, %t809) :: integer
771
- %t811 = const 0 :: integer
772
- %t812 = call core.clamp(%t804, %t811, %t810) :: integer
773
- %t813 = Gather %t801, %t812 :: any
774
- %t814 = Length %t813 :: integer
775
- %t815 = const -1 :: integer
776
- %t816 = call core.sub(%col_i_265, %t815) :: integer
777
- %t817 = const 0 :: integer
778
- %t818 = call core.gte(%t816, %t817) :: boolean
779
- %t819 = call core.lt(%t816, %t814) :: boolean
780
- %t820 = call core.and(%t818, %t819) :: boolean
781
- %t821 = call core.and(%t808, %t820) :: boolean
782
- %t822 = const 1 :: integer
783
- %t823 = call core.sub(%t814, %t822) :: integer
784
- %t824 = const 0 :: integer
785
- %t825 = call core.clamp(%t816, %t824, %t823) :: integer
786
- %t826 = Gather %t813, %t825 :: integer
787
- %t827 = const 0 :: integer
788
- %t828 = select %t821, %t826, %t827 :: integer
789
- %t829 = load_input "rows" :: array
790
- %t830 = Length %t829 :: integer
791
- %t831 = const -1 :: integer
792
- %t832 = call core.sub(%rows_i_263, %t831) :: integer
793
- %t833 = const 0 :: integer
794
- %t834 = call core.gte(%t832, %t833) :: boolean
795
- %t835 = call core.lt(%t832, %t830) :: boolean
796
- %t836 = call core.and(%t834, %t835) :: boolean
797
- %t837 = const 1 :: integer
798
- %t838 = call core.sub(%t830, %t837) :: integer
799
- %t839 = const 0 :: integer
800
- %t840 = call core.clamp(%t832, %t839, %t838) :: integer
801
- %t841 = Gather %t829, %t840 :: any
802
- %t842 = Length %t841 :: integer
803
- %t843 = const 1 :: integer
804
- %t844 = call core.sub(%col_i_265, %t843) :: integer
805
- %t845 = const 0 :: integer
806
- %t846 = call core.gte(%t844, %t845) :: boolean
807
- %t847 = call core.lt(%t844, %t842) :: boolean
808
- %t848 = call core.and(%t846, %t847) :: boolean
809
- %t849 = call core.and(%t836, %t848) :: boolean
810
- %t850 = const 1 :: integer
811
- %t851 = call core.sub(%t842, %t850) :: integer
812
- %t852 = const 0 :: integer
813
- %t853 = call core.clamp(%t844, %t852, %t851) :: integer
814
- %t854 = Gather %t841, %t853 :: integer
815
- %t855 = const 0 :: integer
816
- %t856 = select %t849, %t854, %t855 :: integer
817
- %t857 = load_input "rows" :: array
818
- %t858 = Length %t857 :: integer
819
- %t859 = const 1 :: integer
820
- %t860 = call core.sub(%rows_i_263, %t859) :: integer
821
- %t861 = const 0 :: integer
822
- %t862 = call core.gte(%t860, %t861) :: boolean
823
- %t863 = call core.lt(%t860, %t858) :: boolean
824
- %t864 = call core.and(%t862, %t863) :: boolean
825
- %t865 = const 1 :: integer
826
- %t866 = call core.sub(%t858, %t865) :: integer
827
- %t867 = const 0 :: integer
828
- %t868 = call core.clamp(%t860, %t867, %t866) :: integer
829
- %t869 = Gather %t857, %t868 :: any
830
- %t870 = Length %t869 :: integer
831
- %t871 = const -1 :: integer
832
- %t872 = call core.sub(%col_i_265, %t871) :: integer
833
- %t873 = const 0 :: integer
834
- %t874 = call core.gte(%t872, %t873) :: boolean
835
- %t875 = call core.lt(%t872, %t870) :: boolean
836
- %t876 = call core.and(%t874, %t875) :: boolean
837
- %t877 = call core.and(%t864, %t876) :: boolean
838
- %t878 = const 1 :: integer
839
- %t879 = call core.sub(%t870, %t878) :: integer
840
- %t880 = const 0 :: integer
841
- %t881 = call core.clamp(%t872, %t880, %t879) :: integer
842
- %t882 = Gather %t869, %t881 :: integer
843
- %t883 = const 0 :: integer
844
- %t884 = select %t877, %t882, %t883 :: integer
845
- %t885 = load_input "rows" :: array
846
- %t886 = Length %t885 :: integer
847
- %t887 = const 1 :: integer
848
- %t888 = call core.sub(%rows_i_263, %t887) :: integer
849
- %t889 = const 0 :: integer
850
- %t890 = call core.gte(%t888, %t889) :: boolean
851
- %t891 = call core.lt(%t888, %t886) :: boolean
852
- %t892 = call core.and(%t890, %t891) :: boolean
853
- %t893 = const 1 :: integer
854
- %t894 = call core.sub(%t886, %t893) :: integer
855
- %t895 = const 0 :: integer
856
- %t896 = call core.clamp(%t888, %t895, %t894) :: integer
857
- %t897 = Gather %t885, %t896 :: any
858
- %t898 = Length %t897 :: integer
859
- %t899 = const 1 :: integer
860
- %t900 = call core.sub(%col_i_265, %t899) :: integer
861
- %t901 = const 0 :: integer
862
- %t902 = call core.gte(%t900, %t901) :: boolean
863
- %t903 = call core.lt(%t900, %t898) :: boolean
864
- %t904 = call core.and(%t902, %t903) :: boolean
865
- %t905 = call core.and(%t892, %t904) :: boolean
866
- %t906 = const 1 :: integer
867
- %t907 = call core.sub(%t898, %t906) :: integer
868
- %t908 = const 0 :: integer
869
- %t909 = call core.clamp(%t900, %t908, %t907) :: integer
870
- %t910 = Gather %t897, %t909 :: integer
871
- %t911 = const 0 :: integer
872
- %t912 = select %t905, %t910, %t911 :: integer
873
- %t507 = make_tuple(%t740, %t760, %t780, %t800, %t828, %t856, %t884, %t912) :: tuple<integer>
874
- %t508 = Fold %t507 fn="agg.sum" ::
762
+ %t782 = length %t781 :: integer
763
+ %t783 = const -1 :: integer
764
+ %t784 = call core.sub(%rows_i_263, %t783) :: integer
765
+ %t785 = const 0 :: integer
766
+ %t786 = call core.gte(%t784, %t785) :: boolean
767
+ %t787 = call core.lt(%t784, %t782) :: boolean
768
+ %t788 = call core.and(%t786, %t787) :: boolean
769
+ %t789 = const 1 :: integer
770
+ %t790 = call core.sub(%t782, %t789) :: integer
771
+ %t791 = const 0 :: integer
772
+ %t792 = call core.clamp(%t784, %t791, %t790) :: integer
773
+ %t793 = gather %t781, %t792 :: any
774
+ %t794 = length %t793 :: integer
775
+ %t795 = const -1 :: integer
776
+ %t796 = call core.sub(%col_i_265, %t795) :: integer
777
+ %t797 = const 0 :: integer
778
+ %t798 = call core.gte(%t796, %t797) :: boolean
779
+ %t799 = call core.lt(%t796, %t794) :: boolean
780
+ %t800 = call core.and(%t798, %t799) :: boolean
781
+ %t801 = call core.and(%t788, %t800) :: boolean
782
+ %t802 = const 1 :: integer
783
+ %t803 = call core.sub(%t794, %t802) :: integer
784
+ %t804 = const 0 :: integer
785
+ %t805 = call core.clamp(%t796, %t804, %t803) :: integer
786
+ %t806 = gather %t793, %t805 :: integer
787
+ %t807 = const 0 :: integer
788
+ %t808 = select %t801, %t806, %t807 :: integer
789
+ %t809 = load_input "rows" :: array
790
+ %t810 = length %t809 :: integer
791
+ %t811 = const -1 :: integer
792
+ %t812 = call core.sub(%rows_i_263, %t811) :: integer
793
+ %t813 = const 0 :: integer
794
+ %t814 = call core.gte(%t812, %t813) :: boolean
795
+ %t815 = call core.lt(%t812, %t810) :: boolean
796
+ %t816 = call core.and(%t814, %t815) :: boolean
797
+ %t817 = const 1 :: integer
798
+ %t818 = call core.sub(%t810, %t817) :: integer
799
+ %t819 = const 0 :: integer
800
+ %t820 = call core.clamp(%t812, %t819, %t818) :: integer
801
+ %t821 = gather %t809, %t820 :: any
802
+ %t822 = length %t821 :: integer
803
+ %t823 = const 1 :: integer
804
+ %t824 = call core.sub(%col_i_265, %t823) :: integer
805
+ %t825 = const 0 :: integer
806
+ %t826 = call core.gte(%t824, %t825) :: boolean
807
+ %t827 = call core.lt(%t824, %t822) :: boolean
808
+ %t828 = call core.and(%t826, %t827) :: boolean
809
+ %t829 = call core.and(%t816, %t828) :: boolean
810
+ %t830 = const 1 :: integer
811
+ %t831 = call core.sub(%t822, %t830) :: integer
812
+ %t832 = const 0 :: integer
813
+ %t833 = call core.clamp(%t824, %t832, %t831) :: integer
814
+ %t834 = gather %t821, %t833 :: integer
815
+ %t835 = const 0 :: integer
816
+ %t836 = select %t829, %t834, %t835 :: integer
817
+ %t837 = load_input "rows" :: array
818
+ %t838 = length %t837 :: integer
819
+ %t839 = const 1 :: integer
820
+ %t840 = call core.sub(%rows_i_263, %t839) :: integer
821
+ %t841 = const 0 :: integer
822
+ %t842 = call core.gte(%t840, %t841) :: boolean
823
+ %t843 = call core.lt(%t840, %t838) :: boolean
824
+ %t844 = call core.and(%t842, %t843) :: boolean
825
+ %t845 = const 1 :: integer
826
+ %t846 = call core.sub(%t838, %t845) :: integer
827
+ %t847 = const 0 :: integer
828
+ %t848 = call core.clamp(%t840, %t847, %t846) :: integer
829
+ %t849 = gather %t837, %t848 :: any
830
+ %t850 = length %t849 :: integer
831
+ %t851 = const -1 :: integer
832
+ %t852 = call core.sub(%col_i_265, %t851) :: integer
833
+ %t853 = const 0 :: integer
834
+ %t854 = call core.gte(%t852, %t853) :: boolean
835
+ %t855 = call core.lt(%t852, %t850) :: boolean
836
+ %t856 = call core.and(%t854, %t855) :: boolean
837
+ %t857 = call core.and(%t844, %t856) :: boolean
838
+ %t858 = const 1 :: integer
839
+ %t859 = call core.sub(%t850, %t858) :: integer
840
+ %t860 = const 0 :: integer
841
+ %t861 = call core.clamp(%t852, %t860, %t859) :: integer
842
+ %t862 = gather %t849, %t861 :: integer
843
+ %t863 = const 0 :: integer
844
+ %t864 = select %t857, %t862, %t863 :: integer
845
+ %t865 = load_input "rows" :: array
846
+ %t866 = length %t865 :: integer
847
+ %t867 = const 1 :: integer
848
+ %t868 = call core.sub(%rows_i_263, %t867) :: integer
849
+ %t869 = const 0 :: integer
850
+ %t870 = call core.gte(%t868, %t869) :: boolean
851
+ %t871 = call core.lt(%t868, %t866) :: boolean
852
+ %t872 = call core.and(%t870, %t871) :: boolean
853
+ %t873 = const 1 :: integer
854
+ %t874 = call core.sub(%t866, %t873) :: integer
855
+ %t875 = const 0 :: integer
856
+ %t876 = call core.clamp(%t868, %t875, %t874) :: integer
857
+ %t877 = gather %t865, %t876 :: any
858
+ %t878 = length %t877 :: integer
859
+ %t879 = const 1 :: integer
860
+ %t880 = call core.sub(%col_i_265, %t879) :: integer
861
+ %t881 = const 0 :: integer
862
+ %t882 = call core.gte(%t880, %t881) :: boolean
863
+ %t883 = call core.lt(%t880, %t878) :: boolean
864
+ %t884 = call core.and(%t882, %t883) :: boolean
865
+ %t885 = call core.and(%t872, %t884) :: boolean
866
+ %t886 = const 1 :: integer
867
+ %t887 = call core.sub(%t878, %t886) :: integer
868
+ %t888 = const 0 :: integer
869
+ %t889 = call core.clamp(%t880, %t888, %t887) :: integer
870
+ %t890 = gather %t877, %t889 :: integer
871
+ %t891 = const 0 :: integer
872
+ %t892 = select %t885, %t890, %t891 :: integer
873
+ %t699 = make_tuple(%t720, %t740, %t760, %t780, %t808, %t836, %t864, %t892) :: tuple<integer>
874
+ %t700 = fold %t699 fn="agg.sum" ::
875
875
  %t267 = const 2 :: integer
876
- %t268 = call core.eq(%t508, %t267) :: boolean
876
+ %t268 = call core.eq(%t700, %t267) :: boolean
877
877
  yield %t268
878
878
  end_loop
879
879
  end_loop
@@ -882,209 +882,209 @@
882
882
  %t269 = load_input "rows" :: array
883
883
  loop rows id=L27 in %t269 as el=%rows_el_270, idx=%rows_i_271
884
884
  loop col id=L28 in %rows_el_270 as el=%col_el_272, idx=%col_i_273
885
- %t509 = load_input "rows" :: array
886
- %t913 = load_input "rows" :: array
887
- %t914 = load_input "rows" :: array
888
- %t915 = Length %t914 :: integer
889
- %t916 = const -1 :: integer
890
- %t917 = call core.sub(%rows_i_271, %t916) :: integer
885
+ %t893 = load_input "rows" :: array
886
+ %t897 = load_input "rows" :: array
887
+ %t908 = load_input "rows" :: array
888
+ %t909 = length %t908 :: integer
889
+ %t910 = const -1 :: integer
890
+ %t911 = call core.sub(%rows_i_271, %t910) :: integer
891
+ %t912 = const 0 :: integer
892
+ %t913 = call core.gte(%t911, %t912) :: boolean
893
+ %t914 = call core.lt(%t911, %t909) :: boolean
894
+ %t915 = call core.and(%t913, %t914) :: boolean
895
+ %t916 = const 1 :: integer
896
+ %t917 = call core.sub(%t909, %t916) :: integer
891
897
  %t918 = const 0 :: integer
892
- %t919 = call core.gte(%t917, %t918) :: boolean
893
- %t920 = call core.lt(%t917, %t915) :: boolean
894
- %t921 = call core.and(%t919, %t920) :: boolean
895
- %t922 = const 1 :: integer
896
- %t923 = call core.sub(%t915, %t922) :: integer
897
- %t924 = const 0 :: integer
898
- %t925 = call core.clamp(%t917, %t924, %t923) :: integer
899
- %t926 = Gather %t914, %t925 :: any
900
- %t927 = Length %t926 :: integer
901
- %t928 = call core.mod(%col_i_273, %t927) :: integer
902
- %t929 = call core.add(%t928, %t927) :: integer
903
- %t930 = call core.mod(%t929, %t927) :: integer
904
- %t931 = Gather %t926, %t930 :: integer
898
+ %t919 = call core.clamp(%t911, %t918, %t917) :: integer
899
+ %t920 = gather %t908, %t919 :: any
900
+ %t921 = length %t920 :: integer
901
+ %t922 = call core.mod(%col_i_273, %t921) :: integer
902
+ %t923 = call core.add(%t922, %t921) :: integer
903
+ %t924 = call core.mod(%t923, %t921) :: integer
904
+ %t925 = gather %t920, %t924 :: integer
905
+ %t926 = const 0 :: integer
906
+ %t927 = select %t915, %t925, %t926 :: integer
907
+ %t928 = load_input "rows" :: array
908
+ %t929 = length %t928 :: integer
909
+ %t930 = const 1 :: integer
910
+ %t931 = call core.sub(%rows_i_271, %t930) :: integer
905
911
  %t932 = const 0 :: integer
906
- %t933 = select %t921, %t931, %t932 :: integer
907
- %t934 = load_input "rows" :: array
908
- %t935 = Length %t934 :: integer
912
+ %t933 = call core.gte(%t931, %t932) :: boolean
913
+ %t934 = call core.lt(%t931, %t929) :: boolean
914
+ %t935 = call core.and(%t933, %t934) :: boolean
909
915
  %t936 = const 1 :: integer
910
- %t937 = call core.sub(%rows_i_271, %t936) :: integer
916
+ %t937 = call core.sub(%t929, %t936) :: integer
911
917
  %t938 = const 0 :: integer
912
- %t939 = call core.gte(%t937, %t938) :: boolean
913
- %t940 = call core.lt(%t937, %t935) :: boolean
914
- %t941 = call core.and(%t939, %t940) :: boolean
915
- %t942 = const 1 :: integer
916
- %t943 = call core.sub(%t935, %t942) :: integer
917
- %t944 = const 0 :: integer
918
- %t945 = call core.clamp(%t937, %t944, %t943) :: integer
919
- %t946 = Gather %t934, %t945 :: any
920
- %t947 = Length %t946 :: integer
921
- %t948 = call core.mod(%col_i_273, %t947) :: integer
922
- %t949 = call core.add(%t948, %t947) :: integer
923
- %t950 = call core.mod(%t949, %t947) :: integer
924
- %t951 = Gather %t946, %t950 :: integer
925
- %t952 = const 0 :: integer
926
- %t953 = select %t941, %t951, %t952 :: integer
927
- %t954 = load_input "rows" :: array
928
- %t955 = Length %t954 :: integer
929
- %t956 = call core.mod(%rows_i_271, %t955) :: integer
930
- %t957 = call core.add(%t956, %t955) :: integer
931
- %t958 = call core.mod(%t957, %t955) :: integer
932
- %t959 = Gather %t954, %t958 :: any
933
- %t960 = Length %t959 :: integer
934
- %t961 = const -1 :: integer
935
- %t962 = call core.sub(%col_i_273, %t961) :: integer
918
+ %t939 = call core.clamp(%t931, %t938, %t937) :: integer
919
+ %t940 = gather %t928, %t939 :: any
920
+ %t941 = length %t940 :: integer
921
+ %t942 = call core.mod(%col_i_273, %t941) :: integer
922
+ %t943 = call core.add(%t942, %t941) :: integer
923
+ %t944 = call core.mod(%t943, %t941) :: integer
924
+ %t945 = gather %t940, %t944 :: integer
925
+ %t946 = const 0 :: integer
926
+ %t947 = select %t935, %t945, %t946 :: integer
927
+ %t948 = load_input "rows" :: array
928
+ %t949 = length %t948 :: integer
929
+ %t950 = call core.mod(%rows_i_271, %t949) :: integer
930
+ %t951 = call core.add(%t950, %t949) :: integer
931
+ %t952 = call core.mod(%t951, %t949) :: integer
932
+ %t953 = gather %t948, %t952 :: any
933
+ %t954 = length %t953 :: integer
934
+ %t955 = const -1 :: integer
935
+ %t956 = call core.sub(%col_i_273, %t955) :: integer
936
+ %t957 = const 0 :: integer
937
+ %t958 = call core.gte(%t956, %t957) :: boolean
938
+ %t959 = call core.lt(%t956, %t954) :: boolean
939
+ %t960 = call core.and(%t958, %t959) :: boolean
940
+ %t961 = const 1 :: integer
941
+ %t962 = call core.sub(%t954, %t961) :: integer
936
942
  %t963 = const 0 :: integer
937
- %t964 = call core.gte(%t962, %t963) :: boolean
938
- %t965 = call core.lt(%t962, %t960) :: boolean
939
- %t966 = call core.and(%t964, %t965) :: boolean
940
- %t967 = const 1 :: integer
941
- %t968 = call core.sub(%t960, %t967) :: integer
942
- %t969 = const 0 :: integer
943
- %t970 = call core.clamp(%t962, %t969, %t968) :: integer
944
- %t971 = Gather %t959, %t970 :: integer
945
- %t972 = const 0 :: integer
946
- %t973 = select %t966, %t971, %t972 :: integer
947
- %t974 = load_input "rows" :: array
948
- %t975 = Length %t974 :: integer
949
- %t976 = call core.mod(%rows_i_271, %t975) :: integer
950
- %t977 = call core.add(%t976, %t975) :: integer
951
- %t978 = call core.mod(%t977, %t975) :: integer
952
- %t979 = Gather %t974, %t978 :: any
953
- %t980 = Length %t979 :: integer
943
+ %t964 = call core.clamp(%t956, %t963, %t962) :: integer
944
+ %t965 = gather %t953, %t964 :: integer
945
+ %t966 = const 0 :: integer
946
+ %t967 = select %t960, %t965, %t966 :: integer
947
+ %t968 = load_input "rows" :: array
948
+ %t969 = length %t968 :: integer
949
+ %t970 = call core.mod(%rows_i_271, %t969) :: integer
950
+ %t971 = call core.add(%t970, %t969) :: integer
951
+ %t972 = call core.mod(%t971, %t969) :: integer
952
+ %t973 = gather %t968, %t972 :: any
953
+ %t974 = length %t973 :: integer
954
+ %t975 = const 1 :: integer
955
+ %t976 = call core.sub(%col_i_273, %t975) :: integer
956
+ %t977 = const 0 :: integer
957
+ %t978 = call core.gte(%t976, %t977) :: boolean
958
+ %t979 = call core.lt(%t976, %t974) :: boolean
959
+ %t980 = call core.and(%t978, %t979) :: boolean
954
960
  %t981 = const 1 :: integer
955
- %t982 = call core.sub(%col_i_273, %t981) :: integer
961
+ %t982 = call core.sub(%t974, %t981) :: integer
956
962
  %t983 = const 0 :: integer
957
- %t984 = call core.gte(%t982, %t983) :: boolean
958
- %t985 = call core.lt(%t982, %t980) :: boolean
959
- %t986 = call core.and(%t984, %t985) :: boolean
960
- %t987 = const 1 :: integer
961
- %t988 = call core.sub(%t980, %t987) :: integer
962
- %t989 = const 0 :: integer
963
- %t990 = call core.clamp(%t982, %t989, %t988) :: integer
964
- %t991 = Gather %t979, %t990 :: integer
963
+ %t984 = call core.clamp(%t976, %t983, %t982) :: integer
964
+ %t985 = gather %t973, %t984 :: integer
965
+ %t986 = const 0 :: integer
966
+ %t987 = select %t980, %t985, %t986 :: integer
967
+ %t988 = load_input "rows" :: array
968
+ %t989 = length %t988 :: integer
969
+ %t990 = const -1 :: integer
970
+ %t991 = call core.sub(%rows_i_271, %t990) :: integer
965
971
  %t992 = const 0 :: integer
966
- %t993 = select %t986, %t991, %t992 :: integer
967
- %t994 = load_input "rows" :: array
968
- %t995 = Length %t994 :: integer
969
- %t996 = const -1 :: integer
970
- %t997 = call core.sub(%rows_i_271, %t996) :: integer
972
+ %t993 = call core.gte(%t991, %t992) :: boolean
973
+ %t994 = call core.lt(%t991, %t989) :: boolean
974
+ %t995 = call core.and(%t993, %t994) :: boolean
975
+ %t996 = const 1 :: integer
976
+ %t997 = call core.sub(%t989, %t996) :: integer
971
977
  %t998 = const 0 :: integer
972
- %t999 = call core.gte(%t997, %t998) :: boolean
973
- %t1000 = call core.lt(%t997, %t995) :: boolean
974
- %t1001 = call core.and(%t999, %t1000) :: boolean
975
- %t1002 = const 1 :: integer
976
- %t1003 = call core.sub(%t995, %t1002) :: integer
978
+ %t999 = call core.clamp(%t991, %t998, %t997) :: integer
979
+ %t1000 = gather %t988, %t999 :: any
980
+ %t1001 = length %t1000 :: integer
981
+ %t1002 = const -1 :: integer
982
+ %t1003 = call core.sub(%col_i_273, %t1002) :: integer
977
983
  %t1004 = const 0 :: integer
978
- %t1005 = call core.clamp(%t997, %t1004, %t1003) :: integer
979
- %t1006 = Gather %t994, %t1005 :: any
980
- %t1007 = Length %t1006 :: integer
981
- %t1008 = const -1 :: integer
982
- %t1009 = call core.sub(%col_i_273, %t1008) :: integer
983
- %t1010 = const 0 :: integer
984
- %t1011 = call core.gte(%t1009, %t1010) :: boolean
985
- %t1012 = call core.lt(%t1009, %t1007) :: boolean
986
- %t1013 = call core.and(%t1011, %t1012) :: boolean
987
- %t1014 = call core.and(%t1001, %t1013) :: boolean
988
- %t1015 = const 1 :: integer
989
- %t1016 = call core.sub(%t1007, %t1015) :: integer
990
- %t1017 = const 0 :: integer
991
- %t1018 = call core.clamp(%t1009, %t1017, %t1016) :: integer
992
- %t1019 = Gather %t1006, %t1018 :: integer
984
+ %t1005 = call core.gte(%t1003, %t1004) :: boolean
985
+ %t1006 = call core.lt(%t1003, %t1001) :: boolean
986
+ %t1007 = call core.and(%t1005, %t1006) :: boolean
987
+ %t1008 = call core.and(%t995, %t1007) :: boolean
988
+ %t1009 = const 1 :: integer
989
+ %t1010 = call core.sub(%t1001, %t1009) :: integer
990
+ %t1011 = const 0 :: integer
991
+ %t1012 = call core.clamp(%t1003, %t1011, %t1010) :: integer
992
+ %t1013 = gather %t1000, %t1012 :: integer
993
+ %t1014 = const 0 :: integer
994
+ %t1015 = select %t1008, %t1013, %t1014 :: integer
995
+ %t1016 = load_input "rows" :: array
996
+ %t1017 = length %t1016 :: integer
997
+ %t1018 = const -1 :: integer
998
+ %t1019 = call core.sub(%rows_i_271, %t1018) :: integer
993
999
  %t1020 = const 0 :: integer
994
- %t1021 = select %t1014, %t1019, %t1020 :: integer
995
- %t1022 = load_input "rows" :: array
996
- %t1023 = Length %t1022 :: integer
997
- %t1024 = const -1 :: integer
998
- %t1025 = call core.sub(%rows_i_271, %t1024) :: integer
1000
+ %t1021 = call core.gte(%t1019, %t1020) :: boolean
1001
+ %t1022 = call core.lt(%t1019, %t1017) :: boolean
1002
+ %t1023 = call core.and(%t1021, %t1022) :: boolean
1003
+ %t1024 = const 1 :: integer
1004
+ %t1025 = call core.sub(%t1017, %t1024) :: integer
999
1005
  %t1026 = const 0 :: integer
1000
- %t1027 = call core.gte(%t1025, %t1026) :: boolean
1001
- %t1028 = call core.lt(%t1025, %t1023) :: boolean
1002
- %t1029 = call core.and(%t1027, %t1028) :: boolean
1006
+ %t1027 = call core.clamp(%t1019, %t1026, %t1025) :: integer
1007
+ %t1028 = gather %t1016, %t1027 :: any
1008
+ %t1029 = length %t1028 :: integer
1003
1009
  %t1030 = const 1 :: integer
1004
- %t1031 = call core.sub(%t1023, %t1030) :: integer
1010
+ %t1031 = call core.sub(%col_i_273, %t1030) :: integer
1005
1011
  %t1032 = const 0 :: integer
1006
- %t1033 = call core.clamp(%t1025, %t1032, %t1031) :: integer
1007
- %t1034 = Gather %t1022, %t1033 :: any
1008
- %t1035 = Length %t1034 :: integer
1009
- %t1036 = const 1 :: integer
1010
- %t1037 = call core.sub(%col_i_273, %t1036) :: integer
1011
- %t1038 = const 0 :: integer
1012
- %t1039 = call core.gte(%t1037, %t1038) :: boolean
1013
- %t1040 = call core.lt(%t1037, %t1035) :: boolean
1014
- %t1041 = call core.and(%t1039, %t1040) :: boolean
1015
- %t1042 = call core.and(%t1029, %t1041) :: boolean
1016
- %t1043 = const 1 :: integer
1017
- %t1044 = call core.sub(%t1035, %t1043) :: integer
1018
- %t1045 = const 0 :: integer
1019
- %t1046 = call core.clamp(%t1037, %t1045, %t1044) :: integer
1020
- %t1047 = Gather %t1034, %t1046 :: integer
1012
+ %t1033 = call core.gte(%t1031, %t1032) :: boolean
1013
+ %t1034 = call core.lt(%t1031, %t1029) :: boolean
1014
+ %t1035 = call core.and(%t1033, %t1034) :: boolean
1015
+ %t1036 = call core.and(%t1023, %t1035) :: boolean
1016
+ %t1037 = const 1 :: integer
1017
+ %t1038 = call core.sub(%t1029, %t1037) :: integer
1018
+ %t1039 = const 0 :: integer
1019
+ %t1040 = call core.clamp(%t1031, %t1039, %t1038) :: integer
1020
+ %t1041 = gather %t1028, %t1040 :: integer
1021
+ %t1042 = const 0 :: integer
1022
+ %t1043 = select %t1036, %t1041, %t1042 :: integer
1023
+ %t1044 = load_input "rows" :: array
1024
+ %t1045 = length %t1044 :: integer
1025
+ %t1046 = const 1 :: integer
1026
+ %t1047 = call core.sub(%rows_i_271, %t1046) :: integer
1021
1027
  %t1048 = const 0 :: integer
1022
- %t1049 = select %t1042, %t1047, %t1048 :: integer
1023
- %t1050 = load_input "rows" :: array
1024
- %t1051 = Length %t1050 :: integer
1028
+ %t1049 = call core.gte(%t1047, %t1048) :: boolean
1029
+ %t1050 = call core.lt(%t1047, %t1045) :: boolean
1030
+ %t1051 = call core.and(%t1049, %t1050) :: boolean
1025
1031
  %t1052 = const 1 :: integer
1026
- %t1053 = call core.sub(%rows_i_271, %t1052) :: integer
1032
+ %t1053 = call core.sub(%t1045, %t1052) :: integer
1027
1033
  %t1054 = const 0 :: integer
1028
- %t1055 = call core.gte(%t1053, %t1054) :: boolean
1029
- %t1056 = call core.lt(%t1053, %t1051) :: boolean
1030
- %t1057 = call core.and(%t1055, %t1056) :: boolean
1031
- %t1058 = const 1 :: integer
1032
- %t1059 = call core.sub(%t1051, %t1058) :: integer
1034
+ %t1055 = call core.clamp(%t1047, %t1054, %t1053) :: integer
1035
+ %t1056 = gather %t1044, %t1055 :: any
1036
+ %t1057 = length %t1056 :: integer
1037
+ %t1058 = const -1 :: integer
1038
+ %t1059 = call core.sub(%col_i_273, %t1058) :: integer
1033
1039
  %t1060 = const 0 :: integer
1034
- %t1061 = call core.clamp(%t1053, %t1060, %t1059) :: integer
1035
- %t1062 = Gather %t1050, %t1061 :: any
1036
- %t1063 = Length %t1062 :: integer
1037
- %t1064 = const -1 :: integer
1038
- %t1065 = call core.sub(%col_i_273, %t1064) :: integer
1039
- %t1066 = const 0 :: integer
1040
- %t1067 = call core.gte(%t1065, %t1066) :: boolean
1041
- %t1068 = call core.lt(%t1065, %t1063) :: boolean
1042
- %t1069 = call core.and(%t1067, %t1068) :: boolean
1043
- %t1070 = call core.and(%t1057, %t1069) :: boolean
1044
- %t1071 = const 1 :: integer
1045
- %t1072 = call core.sub(%t1063, %t1071) :: integer
1046
- %t1073 = const 0 :: integer
1047
- %t1074 = call core.clamp(%t1065, %t1073, %t1072) :: integer
1048
- %t1075 = Gather %t1062, %t1074 :: integer
1040
+ %t1061 = call core.gte(%t1059, %t1060) :: boolean
1041
+ %t1062 = call core.lt(%t1059, %t1057) :: boolean
1042
+ %t1063 = call core.and(%t1061, %t1062) :: boolean
1043
+ %t1064 = call core.and(%t1051, %t1063) :: boolean
1044
+ %t1065 = const 1 :: integer
1045
+ %t1066 = call core.sub(%t1057, %t1065) :: integer
1046
+ %t1067 = const 0 :: integer
1047
+ %t1068 = call core.clamp(%t1059, %t1067, %t1066) :: integer
1048
+ %t1069 = gather %t1056, %t1068 :: integer
1049
+ %t1070 = const 0 :: integer
1050
+ %t1071 = select %t1064, %t1069, %t1070 :: integer
1051
+ %t1072 = load_input "rows" :: array
1052
+ %t1073 = length %t1072 :: integer
1053
+ %t1074 = const 1 :: integer
1054
+ %t1075 = call core.sub(%rows_i_271, %t1074) :: integer
1049
1055
  %t1076 = const 0 :: integer
1050
- %t1077 = select %t1070, %t1075, %t1076 :: integer
1051
- %t1078 = load_input "rows" :: array
1052
- %t1079 = Length %t1078 :: integer
1056
+ %t1077 = call core.gte(%t1075, %t1076) :: boolean
1057
+ %t1078 = call core.lt(%t1075, %t1073) :: boolean
1058
+ %t1079 = call core.and(%t1077, %t1078) :: boolean
1053
1059
  %t1080 = const 1 :: integer
1054
- %t1081 = call core.sub(%rows_i_271, %t1080) :: integer
1060
+ %t1081 = call core.sub(%t1073, %t1080) :: integer
1055
1061
  %t1082 = const 0 :: integer
1056
- %t1083 = call core.gte(%t1081, %t1082) :: boolean
1057
- %t1084 = call core.lt(%t1081, %t1079) :: boolean
1058
- %t1085 = call core.and(%t1083, %t1084) :: boolean
1062
+ %t1083 = call core.clamp(%t1075, %t1082, %t1081) :: integer
1063
+ %t1084 = gather %t1072, %t1083 :: any
1064
+ %t1085 = length %t1084 :: integer
1059
1065
  %t1086 = const 1 :: integer
1060
- %t1087 = call core.sub(%t1079, %t1086) :: integer
1066
+ %t1087 = call core.sub(%col_i_273, %t1086) :: integer
1061
1067
  %t1088 = const 0 :: integer
1062
- %t1089 = call core.clamp(%t1081, %t1088, %t1087) :: integer
1063
- %t1090 = Gather %t1078, %t1089 :: any
1064
- %t1091 = Length %t1090 :: integer
1065
- %t1092 = const 1 :: integer
1066
- %t1093 = call core.sub(%col_i_273, %t1092) :: integer
1067
- %t1094 = const 0 :: integer
1068
- %t1095 = call core.gte(%t1093, %t1094) :: boolean
1069
- %t1096 = call core.lt(%t1093, %t1091) :: boolean
1070
- %t1097 = call core.and(%t1095, %t1096) :: boolean
1071
- %t1098 = call core.and(%t1085, %t1097) :: boolean
1072
- %t1099 = const 1 :: integer
1073
- %t1100 = call core.sub(%t1091, %t1099) :: integer
1074
- %t1101 = const 0 :: integer
1075
- %t1102 = call core.clamp(%t1093, %t1101, %t1100) :: integer
1076
- %t1103 = Gather %t1090, %t1102 :: integer
1077
- %t1104 = const 0 :: integer
1078
- %t1105 = select %t1098, %t1103, %t1104 :: integer
1079
- %t1106 = make_tuple(%t933, %t953, %t973, %t993, %t1021, %t1049, %t1077, %t1105) :: tuple<integer>
1080
- %t1107 = Fold %t1106 fn="agg.sum" ::
1081
- %t511 = const 2 :: integer
1082
- %t512 = call core.eq(%t1107, %t511) :: boolean
1083
- %t513 = load_input "rows" :: array
1084
- %t1108 = load_input "rows" :: array
1085
- %t515 = const 0 :: integer
1086
- %t516 = call core.gt(%col_el_272, %t515) :: boolean
1087
- %t276 = call core.and(%t512, %t516) :: boolean
1068
+ %t1089 = call core.gte(%t1087, %t1088) :: boolean
1069
+ %t1090 = call core.lt(%t1087, %t1085) :: boolean
1070
+ %t1091 = call core.and(%t1089, %t1090) :: boolean
1071
+ %t1092 = call core.and(%t1079, %t1091) :: boolean
1072
+ %t1093 = const 1 :: integer
1073
+ %t1094 = call core.sub(%t1085, %t1093) :: integer
1074
+ %t1095 = const 0 :: integer
1075
+ %t1096 = call core.clamp(%t1087, %t1095, %t1094) :: integer
1076
+ %t1097 = gather %t1084, %t1096 :: integer
1077
+ %t1098 = const 0 :: integer
1078
+ %t1099 = select %t1092, %t1097, %t1098 :: integer
1079
+ %t906 = make_tuple(%t927, %t947, %t967, %t987, %t1015, %t1043, %t1071, %t1099) :: tuple<integer>
1080
+ %t907 = fold %t906 fn="agg.sum" ::
1081
+ %t895 = const 2 :: integer
1082
+ %t896 = call core.eq(%t907, %t895) :: boolean
1083
+ %t1100 = load_input "rows" :: array
1084
+ %t1104 = load_input "rows" :: array
1085
+ %t1102 = const 0 :: integer
1086
+ %t1103 = call core.gt(%col_el_272, %t1102) :: boolean
1087
+ %t276 = call core.and(%t896, %t1103) :: boolean
1088
1088
  yield %t276
1089
1089
  end_loop
1090
1090
  end_loop
@@ -1093,276 +1093,291 @@
1093
1093
  %t277 = load_input "rows" :: array
1094
1094
  loop rows id=L29 in %t277 as el=%rows_el_278, idx=%rows_i_279
1095
1095
  loop col id=L30 in %rows_el_278 as el=%col_el_280, idx=%col_i_281
1096
- %t517 = load_input "rows" :: array
1096
+ %t1105 = load_input "rows" :: array
1097
1097
  %t1109 = load_input "rows" :: array
1098
- %t1110 = load_input "rows" :: array
1099
- %t1111 = Length %t1110 :: integer
1100
- %t1112 = const -1 :: integer
1101
- %t1113 = call core.sub(%rows_i_279, %t1112) :: integer
1102
- %t1114 = const 0 :: integer
1103
- %t1115 = call core.gte(%t1113, %t1114) :: boolean
1104
- %t1116 = call core.lt(%t1113, %t1111) :: boolean
1105
- %t1117 = call core.and(%t1115, %t1116) :: boolean
1106
- %t1118 = const 1 :: integer
1107
- %t1119 = call core.sub(%t1111, %t1118) :: integer
1108
- %t1120 = const 0 :: integer
1109
- %t1121 = call core.clamp(%t1113, %t1120, %t1119) :: integer
1110
- %t1122 = Gather %t1110, %t1121 :: any
1111
- %t1123 = Length %t1122 :: integer
1112
- %t1124 = call core.mod(%col_i_281, %t1123) :: integer
1113
- %t1125 = call core.add(%t1124, %t1123) :: integer
1114
- %t1126 = call core.mod(%t1125, %t1123) :: integer
1115
- %t1127 = Gather %t1122, %t1126 :: integer
1116
- %t1128 = const 0 :: integer
1117
- %t1129 = select %t1117, %t1127, %t1128 :: integer
1118
- %t1130 = load_input "rows" :: array
1119
- %t1131 = Length %t1130 :: integer
1120
- %t1132 = const 1 :: integer
1121
- %t1133 = call core.sub(%rows_i_279, %t1132) :: integer
1122
- %t1134 = const 0 :: integer
1123
- %t1135 = call core.gte(%t1133, %t1134) :: boolean
1124
- %t1136 = call core.lt(%t1133, %t1131) :: boolean
1125
- %t1137 = call core.and(%t1135, %t1136) :: boolean
1126
- %t1138 = const 1 :: integer
1127
- %t1139 = call core.sub(%t1131, %t1138) :: integer
1128
- %t1140 = const 0 :: integer
1129
- %t1141 = call core.clamp(%t1133, %t1140, %t1139) :: integer
1130
- %t1142 = Gather %t1130, %t1141 :: any
1131
- %t1143 = Length %t1142 :: integer
1132
- %t1144 = call core.mod(%col_i_281, %t1143) :: integer
1133
- %t1145 = call core.add(%t1144, %t1143) :: integer
1134
- %t1146 = call core.mod(%t1145, %t1143) :: integer
1135
- %t1147 = Gather %t1142, %t1146 :: integer
1136
- %t1148 = const 0 :: integer
1137
- %t1149 = select %t1137, %t1147, %t1148 :: integer
1138
- %t1150 = load_input "rows" :: array
1139
- %t1151 = Length %t1150 :: integer
1140
- %t1152 = call core.mod(%rows_i_279, %t1151) :: integer
1141
- %t1153 = call core.add(%t1152, %t1151) :: integer
1142
- %t1154 = call core.mod(%t1153, %t1151) :: integer
1143
- %t1155 = Gather %t1150, %t1154 :: any
1144
- %t1156 = Length %t1155 :: integer
1145
- %t1157 = const -1 :: integer
1146
- %t1158 = call core.sub(%col_i_281, %t1157) :: integer
1147
- %t1159 = const 0 :: integer
1148
- %t1160 = call core.gte(%t1158, %t1159) :: boolean
1149
- %t1161 = call core.lt(%t1158, %t1156) :: boolean
1150
- %t1162 = call core.and(%t1160, %t1161) :: boolean
1151
- %t1163 = const 1 :: integer
1152
- %t1164 = call core.sub(%t1156, %t1163) :: integer
1153
- %t1165 = const 0 :: integer
1154
- %t1166 = call core.clamp(%t1158, %t1165, %t1164) :: integer
1155
- %t1167 = Gather %t1155, %t1166 :: integer
1156
- %t1168 = const 0 :: integer
1157
- %t1169 = select %t1162, %t1167, %t1168 :: integer
1158
- %t1170 = load_input "rows" :: array
1159
- %t1171 = Length %t1170 :: integer
1160
- %t1172 = call core.mod(%rows_i_279, %t1171) :: integer
1161
- %t1173 = call core.add(%t1172, %t1171) :: integer
1162
- %t1174 = call core.mod(%t1173, %t1171) :: integer
1163
- %t1175 = Gather %t1170, %t1174 :: any
1164
- %t1176 = Length %t1175 :: integer
1165
- %t1177 = const 1 :: integer
1166
- %t1178 = call core.sub(%col_i_281, %t1177) :: integer
1167
- %t1179 = const 0 :: integer
1168
- %t1180 = call core.gte(%t1178, %t1179) :: boolean
1169
- %t1181 = call core.lt(%t1178, %t1176) :: boolean
1170
- %t1182 = call core.and(%t1180, %t1181) :: boolean
1171
- %t1183 = const 1 :: integer
1172
- %t1184 = call core.sub(%t1176, %t1183) :: integer
1173
- %t1185 = const 0 :: integer
1174
- %t1186 = call core.clamp(%t1178, %t1185, %t1184) :: integer
1175
- %t1187 = Gather %t1175, %t1186 :: integer
1176
- %t1188 = const 0 :: integer
1177
- %t1189 = select %t1182, %t1187, %t1188 :: integer
1178
- %t1190 = load_input "rows" :: array
1179
- %t1191 = Length %t1190 :: integer
1180
- %t1192 = const -1 :: integer
1181
- %t1193 = call core.sub(%rows_i_279, %t1192) :: integer
1182
- %t1194 = const 0 :: integer
1183
- %t1195 = call core.gte(%t1193, %t1194) :: boolean
1184
- %t1196 = call core.lt(%t1193, %t1191) :: boolean
1185
- %t1197 = call core.and(%t1195, %t1196) :: boolean
1186
- %t1198 = const 1 :: integer
1187
- %t1199 = call core.sub(%t1191, %t1198) :: integer
1188
- %t1200 = const 0 :: integer
1189
- %t1201 = call core.clamp(%t1193, %t1200, %t1199) :: integer
1190
- %t1202 = Gather %t1190, %t1201 :: any
1191
- %t1203 = Length %t1202 :: integer
1192
- %t1204 = const -1 :: integer
1193
- %t1205 = call core.sub(%col_i_281, %t1204) :: integer
1194
- %t1206 = const 0 :: integer
1195
- %t1207 = call core.gte(%t1205, %t1206) :: boolean
1196
- %t1208 = call core.lt(%t1205, %t1203) :: boolean
1197
- %t1209 = call core.and(%t1207, %t1208) :: boolean
1198
- %t1210 = call core.and(%t1197, %t1209) :: boolean
1199
- %t1211 = const 1 :: integer
1200
- %t1212 = call core.sub(%t1203, %t1211) :: integer
1201
- %t1213 = const 0 :: integer
1202
- %t1214 = call core.clamp(%t1205, %t1213, %t1212) :: integer
1203
- %t1215 = Gather %t1202, %t1214 :: integer
1098
+ %t1120 = load_input "rows" :: array
1099
+ %t1121 = length %t1120 :: integer
1100
+ %t1122 = const -1 :: integer
1101
+ %t1123 = call core.sub(%rows_i_279, %t1122) :: integer
1102
+ %t1124 = const 0 :: integer
1103
+ %t1125 = call core.gte(%t1123, %t1124) :: boolean
1104
+ %t1126 = call core.lt(%t1123, %t1121) :: boolean
1105
+ %t1127 = call core.and(%t1125, %t1126) :: boolean
1106
+ %t1128 = const 1 :: integer
1107
+ %t1129 = call core.sub(%t1121, %t1128) :: integer
1108
+ %t1130 = const 0 :: integer
1109
+ %t1131 = call core.clamp(%t1123, %t1130, %t1129) :: integer
1110
+ %t1132 = gather %t1120, %t1131 :: any
1111
+ %t1133 = length %t1132 :: integer
1112
+ %t1134 = call core.mod(%col_i_281, %t1133) :: integer
1113
+ %t1135 = call core.add(%t1134, %t1133) :: integer
1114
+ %t1136 = call core.mod(%t1135, %t1133) :: integer
1115
+ %t1137 = gather %t1132, %t1136 :: integer
1116
+ %t1138 = const 0 :: integer
1117
+ %t1139 = select %t1127, %t1137, %t1138 :: integer
1118
+ %t1140 = load_input "rows" :: array
1119
+ %t1141 = length %t1140 :: integer
1120
+ %t1142 = const 1 :: integer
1121
+ %t1143 = call core.sub(%rows_i_279, %t1142) :: integer
1122
+ %t1144 = const 0 :: integer
1123
+ %t1145 = call core.gte(%t1143, %t1144) :: boolean
1124
+ %t1146 = call core.lt(%t1143, %t1141) :: boolean
1125
+ %t1147 = call core.and(%t1145, %t1146) :: boolean
1126
+ %t1148 = const 1 :: integer
1127
+ %t1149 = call core.sub(%t1141, %t1148) :: integer
1128
+ %t1150 = const 0 :: integer
1129
+ %t1151 = call core.clamp(%t1143, %t1150, %t1149) :: integer
1130
+ %t1152 = gather %t1140, %t1151 :: any
1131
+ %t1153 = length %t1152 :: integer
1132
+ %t1154 = call core.mod(%col_i_281, %t1153) :: integer
1133
+ %t1155 = call core.add(%t1154, %t1153) :: integer
1134
+ %t1156 = call core.mod(%t1155, %t1153) :: integer
1135
+ %t1157 = gather %t1152, %t1156 :: integer
1136
+ %t1158 = const 0 :: integer
1137
+ %t1159 = select %t1147, %t1157, %t1158 :: integer
1138
+ %t1160 = load_input "rows" :: array
1139
+ %t1161 = length %t1160 :: integer
1140
+ %t1162 = call core.mod(%rows_i_279, %t1161) :: integer
1141
+ %t1163 = call core.add(%t1162, %t1161) :: integer
1142
+ %t1164 = call core.mod(%t1163, %t1161) :: integer
1143
+ %t1165 = gather %t1160, %t1164 :: any
1144
+ %t1166 = length %t1165 :: integer
1145
+ %t1167 = const -1 :: integer
1146
+ %t1168 = call core.sub(%col_i_281, %t1167) :: integer
1147
+ %t1169 = const 0 :: integer
1148
+ %t1170 = call core.gte(%t1168, %t1169) :: boolean
1149
+ %t1171 = call core.lt(%t1168, %t1166) :: boolean
1150
+ %t1172 = call core.and(%t1170, %t1171) :: boolean
1151
+ %t1173 = const 1 :: integer
1152
+ %t1174 = call core.sub(%t1166, %t1173) :: integer
1153
+ %t1175 = const 0 :: integer
1154
+ %t1176 = call core.clamp(%t1168, %t1175, %t1174) :: integer
1155
+ %t1177 = gather %t1165, %t1176 :: integer
1156
+ %t1178 = const 0 :: integer
1157
+ %t1179 = select %t1172, %t1177, %t1178 :: integer
1158
+ %t1180 = load_input "rows" :: array
1159
+ %t1181 = length %t1180 :: integer
1160
+ %t1182 = call core.mod(%rows_i_279, %t1181) :: integer
1161
+ %t1183 = call core.add(%t1182, %t1181) :: integer
1162
+ %t1184 = call core.mod(%t1183, %t1181) :: integer
1163
+ %t1185 = gather %t1180, %t1184 :: any
1164
+ %t1186 = length %t1185 :: integer
1165
+ %t1187 = const 1 :: integer
1166
+ %t1188 = call core.sub(%col_i_281, %t1187) :: integer
1167
+ %t1189 = const 0 :: integer
1168
+ %t1190 = call core.gte(%t1188, %t1189) :: boolean
1169
+ %t1191 = call core.lt(%t1188, %t1186) :: boolean
1170
+ %t1192 = call core.and(%t1190, %t1191) :: boolean
1171
+ %t1193 = const 1 :: integer
1172
+ %t1194 = call core.sub(%t1186, %t1193) :: integer
1173
+ %t1195 = const 0 :: integer
1174
+ %t1196 = call core.clamp(%t1188, %t1195, %t1194) :: integer
1175
+ %t1197 = gather %t1185, %t1196 :: integer
1176
+ %t1198 = const 0 :: integer
1177
+ %t1199 = select %t1192, %t1197, %t1198 :: integer
1178
+ %t1200 = load_input "rows" :: array
1179
+ %t1201 = length %t1200 :: integer
1180
+ %t1202 = const -1 :: integer
1181
+ %t1203 = call core.sub(%rows_i_279, %t1202) :: integer
1182
+ %t1204 = const 0 :: integer
1183
+ %t1205 = call core.gte(%t1203, %t1204) :: boolean
1184
+ %t1206 = call core.lt(%t1203, %t1201) :: boolean
1185
+ %t1207 = call core.and(%t1205, %t1206) :: boolean
1186
+ %t1208 = const 1 :: integer
1187
+ %t1209 = call core.sub(%t1201, %t1208) :: integer
1188
+ %t1210 = const 0 :: integer
1189
+ %t1211 = call core.clamp(%t1203, %t1210, %t1209) :: integer
1190
+ %t1212 = gather %t1200, %t1211 :: any
1191
+ %t1213 = length %t1212 :: integer
1192
+ %t1214 = const -1 :: integer
1193
+ %t1215 = call core.sub(%col_i_281, %t1214) :: integer
1204
1194
  %t1216 = const 0 :: integer
1205
- %t1217 = select %t1210, %t1215, %t1216 :: integer
1206
- %t1218 = load_input "rows" :: array
1207
- %t1219 = Length %t1218 :: integer
1208
- %t1220 = const -1 :: integer
1209
- %t1221 = call core.sub(%rows_i_279, %t1220) :: integer
1210
- %t1222 = const 0 :: integer
1211
- %t1223 = call core.gte(%t1221, %t1222) :: boolean
1212
- %t1224 = call core.lt(%t1221, %t1219) :: boolean
1213
- %t1225 = call core.and(%t1223, %t1224) :: boolean
1214
- %t1226 = const 1 :: integer
1215
- %t1227 = call core.sub(%t1219, %t1226) :: integer
1216
- %t1228 = const 0 :: integer
1217
- %t1229 = call core.clamp(%t1221, %t1228, %t1227) :: integer
1218
- %t1230 = Gather %t1218, %t1229 :: any
1219
- %t1231 = Length %t1230 :: integer
1220
- %t1232 = const 1 :: integer
1221
- %t1233 = call core.sub(%col_i_281, %t1232) :: integer
1222
- %t1234 = const 0 :: integer
1223
- %t1235 = call core.gte(%t1233, %t1234) :: boolean
1224
- %t1236 = call core.lt(%t1233, %t1231) :: boolean
1225
- %t1237 = call core.and(%t1235, %t1236) :: boolean
1226
- %t1238 = call core.and(%t1225, %t1237) :: boolean
1227
- %t1239 = const 1 :: integer
1228
- %t1240 = call core.sub(%t1231, %t1239) :: integer
1229
- %t1241 = const 0 :: integer
1230
- %t1242 = call core.clamp(%t1233, %t1241, %t1240) :: integer
1231
- %t1243 = Gather %t1230, %t1242 :: integer
1195
+ %t1217 = call core.gte(%t1215, %t1216) :: boolean
1196
+ %t1218 = call core.lt(%t1215, %t1213) :: boolean
1197
+ %t1219 = call core.and(%t1217, %t1218) :: boolean
1198
+ %t1220 = call core.and(%t1207, %t1219) :: boolean
1199
+ %t1221 = const 1 :: integer
1200
+ %t1222 = call core.sub(%t1213, %t1221) :: integer
1201
+ %t1223 = const 0 :: integer
1202
+ %t1224 = call core.clamp(%t1215, %t1223, %t1222) :: integer
1203
+ %t1225 = gather %t1212, %t1224 :: integer
1204
+ %t1226 = const 0 :: integer
1205
+ %t1227 = select %t1220, %t1225, %t1226 :: integer
1206
+ %t1228 = load_input "rows" :: array
1207
+ %t1229 = length %t1228 :: integer
1208
+ %t1230 = const -1 :: integer
1209
+ %t1231 = call core.sub(%rows_i_279, %t1230) :: integer
1210
+ %t1232 = const 0 :: integer
1211
+ %t1233 = call core.gte(%t1231, %t1232) :: boolean
1212
+ %t1234 = call core.lt(%t1231, %t1229) :: boolean
1213
+ %t1235 = call core.and(%t1233, %t1234) :: boolean
1214
+ %t1236 = const 1 :: integer
1215
+ %t1237 = call core.sub(%t1229, %t1236) :: integer
1216
+ %t1238 = const 0 :: integer
1217
+ %t1239 = call core.clamp(%t1231, %t1238, %t1237) :: integer
1218
+ %t1240 = gather %t1228, %t1239 :: any
1219
+ %t1241 = length %t1240 :: integer
1220
+ %t1242 = const 1 :: integer
1221
+ %t1243 = call core.sub(%col_i_281, %t1242) :: integer
1232
1222
  %t1244 = const 0 :: integer
1233
- %t1245 = select %t1238, %t1243, %t1244 :: integer
1234
- %t1246 = load_input "rows" :: array
1235
- %t1247 = Length %t1246 :: integer
1236
- %t1248 = const 1 :: integer
1237
- %t1249 = call core.sub(%rows_i_279, %t1248) :: integer
1238
- %t1250 = const 0 :: integer
1239
- %t1251 = call core.gte(%t1249, %t1250) :: boolean
1240
- %t1252 = call core.lt(%t1249, %t1247) :: boolean
1241
- %t1253 = call core.and(%t1251, %t1252) :: boolean
1242
- %t1254 = const 1 :: integer
1243
- %t1255 = call core.sub(%t1247, %t1254) :: integer
1244
- %t1256 = const 0 :: integer
1245
- %t1257 = call core.clamp(%t1249, %t1256, %t1255) :: integer
1246
- %t1258 = Gather %t1246, %t1257 :: any
1247
- %t1259 = Length %t1258 :: integer
1248
- %t1260 = const -1 :: integer
1249
- %t1261 = call core.sub(%col_i_281, %t1260) :: integer
1250
- %t1262 = const 0 :: integer
1251
- %t1263 = call core.gte(%t1261, %t1262) :: boolean
1252
- %t1264 = call core.lt(%t1261, %t1259) :: boolean
1253
- %t1265 = call core.and(%t1263, %t1264) :: boolean
1254
- %t1266 = call core.and(%t1253, %t1265) :: boolean
1255
- %t1267 = const 1 :: integer
1256
- %t1268 = call core.sub(%t1259, %t1267) :: integer
1257
- %t1269 = const 0 :: integer
1258
- %t1270 = call core.clamp(%t1261, %t1269, %t1268) :: integer
1259
- %t1271 = Gather %t1258, %t1270 :: integer
1223
+ %t1245 = call core.gte(%t1243, %t1244) :: boolean
1224
+ %t1246 = call core.lt(%t1243, %t1241) :: boolean
1225
+ %t1247 = call core.and(%t1245, %t1246) :: boolean
1226
+ %t1248 = call core.and(%t1235, %t1247) :: boolean
1227
+ %t1249 = const 1 :: integer
1228
+ %t1250 = call core.sub(%t1241, %t1249) :: integer
1229
+ %t1251 = const 0 :: integer
1230
+ %t1252 = call core.clamp(%t1243, %t1251, %t1250) :: integer
1231
+ %t1253 = gather %t1240, %t1252 :: integer
1232
+ %t1254 = const 0 :: integer
1233
+ %t1255 = select %t1248, %t1253, %t1254 :: integer
1234
+ %t1256 = load_input "rows" :: array
1235
+ %t1257 = length %t1256 :: integer
1236
+ %t1258 = const 1 :: integer
1237
+ %t1259 = call core.sub(%rows_i_279, %t1258) :: integer
1238
+ %t1260 = const 0 :: integer
1239
+ %t1261 = call core.gte(%t1259, %t1260) :: boolean
1240
+ %t1262 = call core.lt(%t1259, %t1257) :: boolean
1241
+ %t1263 = call core.and(%t1261, %t1262) :: boolean
1242
+ %t1264 = const 1 :: integer
1243
+ %t1265 = call core.sub(%t1257, %t1264) :: integer
1244
+ %t1266 = const 0 :: integer
1245
+ %t1267 = call core.clamp(%t1259, %t1266, %t1265) :: integer
1246
+ %t1268 = gather %t1256, %t1267 :: any
1247
+ %t1269 = length %t1268 :: integer
1248
+ %t1270 = const -1 :: integer
1249
+ %t1271 = call core.sub(%col_i_281, %t1270) :: integer
1260
1250
  %t1272 = const 0 :: integer
1261
- %t1273 = select %t1266, %t1271, %t1272 :: integer
1262
- %t1274 = load_input "rows" :: array
1263
- %t1275 = Length %t1274 :: integer
1264
- %t1276 = const 1 :: integer
1265
- %t1277 = call core.sub(%rows_i_279, %t1276) :: integer
1266
- %t1278 = const 0 :: integer
1267
- %t1279 = call core.gte(%t1277, %t1278) :: boolean
1268
- %t1280 = call core.lt(%t1277, %t1275) :: boolean
1269
- %t1281 = call core.and(%t1279, %t1280) :: boolean
1270
- %t1282 = const 1 :: integer
1271
- %t1283 = call core.sub(%t1275, %t1282) :: integer
1272
- %t1284 = const 0 :: integer
1273
- %t1285 = call core.clamp(%t1277, %t1284, %t1283) :: integer
1274
- %t1286 = Gather %t1274, %t1285 :: any
1275
- %t1287 = Length %t1286 :: integer
1276
- %t1288 = const 1 :: integer
1277
- %t1289 = call core.sub(%col_i_281, %t1288) :: integer
1278
- %t1290 = const 0 :: integer
1279
- %t1291 = call core.gte(%t1289, %t1290) :: boolean
1280
- %t1292 = call core.lt(%t1289, %t1287) :: boolean
1281
- %t1293 = call core.and(%t1291, %t1292) :: boolean
1282
- %t1294 = call core.and(%t1281, %t1293) :: boolean
1283
- %t1295 = const 1 :: integer
1284
- %t1296 = call core.sub(%t1287, %t1295) :: integer
1285
- %t1297 = const 0 :: integer
1286
- %t1298 = call core.clamp(%t1289, %t1297, %t1296) :: integer
1287
- %t1299 = Gather %t1286, %t1298 :: integer
1251
+ %t1273 = call core.gte(%t1271, %t1272) :: boolean
1252
+ %t1274 = call core.lt(%t1271, %t1269) :: boolean
1253
+ %t1275 = call core.and(%t1273, %t1274) :: boolean
1254
+ %t1276 = call core.and(%t1263, %t1275) :: boolean
1255
+ %t1277 = const 1 :: integer
1256
+ %t1278 = call core.sub(%t1269, %t1277) :: integer
1257
+ %t1279 = const 0 :: integer
1258
+ %t1280 = call core.clamp(%t1271, %t1279, %t1278) :: integer
1259
+ %t1281 = gather %t1268, %t1280 :: integer
1260
+ %t1282 = const 0 :: integer
1261
+ %t1283 = select %t1276, %t1281, %t1282 :: integer
1262
+ %t1284 = load_input "rows" :: array
1263
+ %t1285 = length %t1284 :: integer
1264
+ %t1286 = const 1 :: integer
1265
+ %t1287 = call core.sub(%rows_i_279, %t1286) :: integer
1266
+ %t1288 = const 0 :: integer
1267
+ %t1289 = call core.gte(%t1287, %t1288) :: boolean
1268
+ %t1290 = call core.lt(%t1287, %t1285) :: boolean
1269
+ %t1291 = call core.and(%t1289, %t1290) :: boolean
1270
+ %t1292 = const 1 :: integer
1271
+ %t1293 = call core.sub(%t1285, %t1292) :: integer
1272
+ %t1294 = const 0 :: integer
1273
+ %t1295 = call core.clamp(%t1287, %t1294, %t1293) :: integer
1274
+ %t1296 = gather %t1284, %t1295 :: any
1275
+ %t1297 = length %t1296 :: integer
1276
+ %t1298 = const 1 :: integer
1277
+ %t1299 = call core.sub(%col_i_281, %t1298) :: integer
1288
1278
  %t1300 = const 0 :: integer
1289
- %t1301 = select %t1294, %t1299, %t1300 :: integer
1290
- %t1302 = make_tuple(%t1129, %t1149, %t1169, %t1189, %t1217, %t1245, %t1273, %t1301) :: tuple<integer>
1291
- %t1303 = Fold %t1302 fn="agg.sum" ::
1292
- %t519 = const 3 :: integer
1293
- %t520 = call core.eq(%t1303, %t519) :: boolean
1294
- %t521 = load_input "rows" :: array
1295
- %t1304 = load_input "rows" :: array
1296
- %t1305 = load_input "rows" :: array
1297
- %t1346 = load_input "rows" :: array
1298
- %t1347 = Length %t1346 :: integer
1299
- %t1348 = const -1 :: integer
1300
- %t1349 = call core.sub(%rows_i_279, %t1348) :: integer
1301
- %t1350 = const 0 :: integer
1302
- %t1351 = call core.gte(%t1349, %t1350) :: boolean
1303
- %t1352 = call core.lt(%t1349, %t1347) :: boolean
1304
- %t1353 = call core.and(%t1351, %t1352) :: boolean
1305
- %t1354 = const 1 :: integer
1306
- %t1355 = call core.sub(%t1347, %t1354) :: integer
1307
- %t1356 = const 0 :: integer
1308
- %t1357 = call core.clamp(%t1349, %t1356, %t1355) :: integer
1309
- %t1358 = Gather %t1346, %t1357 :: any
1310
- %t1359 = Length %t1358 :: integer
1311
- %t1360 = call core.mod(%col_i_281, %t1359) :: integer
1312
- %t1361 = call core.add(%t1360, %t1359) :: integer
1313
- %t1362 = call core.mod(%t1361, %t1359) :: integer
1314
- %t1363 = Gather %t1358, %t1362 :: integer
1315
- %t1364 = const 0 :: integer
1316
- %t1365 = select %t1353, %t1363, %t1364 :: integer
1317
- %t1366 = load_input "rows" :: array
1318
- %t1367 = Length %t1366 :: integer
1319
- %t1368 = const 1 :: integer
1320
- %t1369 = call core.sub(%rows_i_279, %t1368) :: integer
1321
- %t1370 = const 0 :: integer
1322
- %t1371 = call core.gte(%t1369, %t1370) :: boolean
1323
- %t1372 = call core.lt(%t1369, %t1367) :: boolean
1324
- %t1373 = call core.and(%t1371, %t1372) :: boolean
1325
- %t1374 = const 1 :: integer
1326
- %t1375 = call core.sub(%t1367, %t1374) :: integer
1327
- %t1376 = const 0 :: integer
1328
- %t1377 = call core.clamp(%t1369, %t1376, %t1375) :: integer
1329
- %t1378 = Gather %t1366, %t1377 :: any
1330
- %t1379 = Length %t1378 :: integer
1331
- %t1380 = call core.mod(%col_i_281, %t1379) :: integer
1332
- %t1381 = call core.add(%t1380, %t1379) :: integer
1333
- %t1382 = call core.mod(%t1381, %t1379) :: integer
1334
- %t1383 = Gather %t1378, %t1382 :: integer
1335
- %t1384 = const 0 :: integer
1336
- %t1385 = select %t1373, %t1383, %t1384 :: integer
1337
- %t1386 = load_input "rows" :: array
1338
- %t1387 = Length %t1386 :: integer
1339
- %t1388 = call core.mod(%rows_i_279, %t1387) :: integer
1340
- %t1389 = call core.add(%t1388, %t1387) :: integer
1341
- %t1390 = call core.mod(%t1389, %t1387) :: integer
1342
- %t1391 = Gather %t1386, %t1390 :: any
1343
- %t1392 = Length %t1391 :: integer
1344
- %t1393 = const -1 :: integer
1345
- %t1394 = call core.sub(%col_i_281, %t1393) :: integer
1346
- %t1395 = const 0 :: integer
1347
- %t1396 = call core.gte(%t1394, %t1395) :: boolean
1348
- %t1397 = call core.lt(%t1394, %t1392) :: boolean
1349
- %t1398 = call core.and(%t1396, %t1397) :: boolean
1350
- %t1399 = const 1 :: integer
1351
- %t1400 = call core.sub(%t1392, %t1399) :: integer
1352
- %t1401 = const 0 :: integer
1353
- %t1402 = call core.clamp(%t1394, %t1401, %t1400) :: integer
1354
- %t1403 = Gather %t1391, %t1402 :: integer
1355
- %t1404 = const 0 :: integer
1356
- %t1405 = select %t1398, %t1403, %t1404 :: integer
1357
- %t1406 = load_input "rows" :: array
1358
- %t1407 = Length %t1406 :: integer
1359
- %t1408 = call core.mod(%rows_i_279, %t1407) :: integer
1360
- %t1409 = call core.add(%t1408, %t1407) :: integer
1361
- %t1410 = call core.mod(%t1409, %t1407) :: integer
1362
- %t1411 = Gather %t1406, %t1410 :: any
1363
- %t1412 = Length %t1411 :: integer
1364
- %t1413 = const 1 :: integer
1365
- %t1414 = call core.sub(%col_i_281, %t1413) :: integer
1279
+ %t1301 = call core.gte(%t1299, %t1300) :: boolean
1280
+ %t1302 = call core.lt(%t1299, %t1297) :: boolean
1281
+ %t1303 = call core.and(%t1301, %t1302) :: boolean
1282
+ %t1304 = call core.and(%t1291, %t1303) :: boolean
1283
+ %t1305 = const 1 :: integer
1284
+ %t1306 = call core.sub(%t1297, %t1305) :: integer
1285
+ %t1307 = const 0 :: integer
1286
+ %t1308 = call core.clamp(%t1299, %t1307, %t1306) :: integer
1287
+ %t1309 = gather %t1296, %t1308 :: integer
1288
+ %t1310 = const 0 :: integer
1289
+ %t1311 = select %t1304, %t1309, %t1310 :: integer
1290
+ %t1118 = make_tuple(%t1139, %t1159, %t1179, %t1199, %t1227, %t1255, %t1283, %t1311) :: tuple<integer>
1291
+ %t1119 = fold %t1118 fn="agg.sum" ::
1292
+ %t1107 = const 3 :: integer
1293
+ %t1108 = call core.eq(%t1119, %t1107) :: boolean
1294
+ %t1312 = load_input "rows" :: array
1295
+ %t1316 = load_input "rows" :: array
1296
+ %t1320 = load_input "rows" :: array
1297
+ %t1331 = load_input "rows" :: array
1298
+ %t1332 = length %t1331 :: integer
1299
+ %t1333 = const -1 :: integer
1300
+ %t1334 = call core.sub(%rows_i_279, %t1333) :: integer
1301
+ %t1335 = const 0 :: integer
1302
+ %t1336 = call core.gte(%t1334, %t1335) :: boolean
1303
+ %t1337 = call core.lt(%t1334, %t1332) :: boolean
1304
+ %t1338 = call core.and(%t1336, %t1337) :: boolean
1305
+ %t1339 = const 1 :: integer
1306
+ %t1340 = call core.sub(%t1332, %t1339) :: integer
1307
+ %t1341 = const 0 :: integer
1308
+ %t1342 = call core.clamp(%t1334, %t1341, %t1340) :: integer
1309
+ %t1343 = gather %t1331, %t1342 :: any
1310
+ %t1344 = length %t1343 :: integer
1311
+ %t1345 = call core.mod(%col_i_281, %t1344) :: integer
1312
+ %t1346 = call core.add(%t1345, %t1344) :: integer
1313
+ %t1347 = call core.mod(%t1346, %t1344) :: integer
1314
+ %t1348 = gather %t1343, %t1347 :: integer
1315
+ %t1349 = const 0 :: integer
1316
+ %t1350 = select %t1338, %t1348, %t1349 :: integer
1317
+ %t1351 = load_input "rows" :: array
1318
+ %t1352 = length %t1351 :: integer
1319
+ %t1353 = const 1 :: integer
1320
+ %t1354 = call core.sub(%rows_i_279, %t1353) :: integer
1321
+ %t1355 = const 0 :: integer
1322
+ %t1356 = call core.gte(%t1354, %t1355) :: boolean
1323
+ %t1357 = call core.lt(%t1354, %t1352) :: boolean
1324
+ %t1358 = call core.and(%t1356, %t1357) :: boolean
1325
+ %t1359 = const 1 :: integer
1326
+ %t1360 = call core.sub(%t1352, %t1359) :: integer
1327
+ %t1361 = const 0 :: integer
1328
+ %t1362 = call core.clamp(%t1354, %t1361, %t1360) :: integer
1329
+ %t1363 = gather %t1351, %t1362 :: any
1330
+ %t1364 = length %t1363 :: integer
1331
+ %t1365 = call core.mod(%col_i_281, %t1364) :: integer
1332
+ %t1366 = call core.add(%t1365, %t1364) :: integer
1333
+ %t1367 = call core.mod(%t1366, %t1364) :: integer
1334
+ %t1368 = gather %t1363, %t1367 :: integer
1335
+ %t1369 = const 0 :: integer
1336
+ %t1370 = select %t1358, %t1368, %t1369 :: integer
1337
+ %t1371 = load_input "rows" :: array
1338
+ %t1372 = length %t1371 :: integer
1339
+ %t1373 = call core.mod(%rows_i_279, %t1372) :: integer
1340
+ %t1374 = call core.add(%t1373, %t1372) :: integer
1341
+ %t1375 = call core.mod(%t1374, %t1372) :: integer
1342
+ %t1376 = gather %t1371, %t1375 :: any
1343
+ %t1377 = length %t1376 :: integer
1344
+ %t1378 = const -1 :: integer
1345
+ %t1379 = call core.sub(%col_i_281, %t1378) :: integer
1346
+ %t1380 = const 0 :: integer
1347
+ %t1381 = call core.gte(%t1379, %t1380) :: boolean
1348
+ %t1382 = call core.lt(%t1379, %t1377) :: boolean
1349
+ %t1383 = call core.and(%t1381, %t1382) :: boolean
1350
+ %t1384 = const 1 :: integer
1351
+ %t1385 = call core.sub(%t1377, %t1384) :: integer
1352
+ %t1386 = const 0 :: integer
1353
+ %t1387 = call core.clamp(%t1379, %t1386, %t1385) :: integer
1354
+ %t1388 = gather %t1376, %t1387 :: integer
1355
+ %t1389 = const 0 :: integer
1356
+ %t1390 = select %t1383, %t1388, %t1389 :: integer
1357
+ %t1391 = load_input "rows" :: array
1358
+ %t1392 = length %t1391 :: integer
1359
+ %t1393 = call core.mod(%rows_i_279, %t1392) :: integer
1360
+ %t1394 = call core.add(%t1393, %t1392) :: integer
1361
+ %t1395 = call core.mod(%t1394, %t1392) :: integer
1362
+ %t1396 = gather %t1391, %t1395 :: any
1363
+ %t1397 = length %t1396 :: integer
1364
+ %t1398 = const 1 :: integer
1365
+ %t1399 = call core.sub(%col_i_281, %t1398) :: integer
1366
+ %t1400 = const 0 :: integer
1367
+ %t1401 = call core.gte(%t1399, %t1400) :: boolean
1368
+ %t1402 = call core.lt(%t1399, %t1397) :: boolean
1369
+ %t1403 = call core.and(%t1401, %t1402) :: boolean
1370
+ %t1404 = const 1 :: integer
1371
+ %t1405 = call core.sub(%t1397, %t1404) :: integer
1372
+ %t1406 = const 0 :: integer
1373
+ %t1407 = call core.clamp(%t1399, %t1406, %t1405) :: integer
1374
+ %t1408 = gather %t1396, %t1407 :: integer
1375
+ %t1409 = const 0 :: integer
1376
+ %t1410 = select %t1403, %t1408, %t1409 :: integer
1377
+ %t1411 = load_input "rows" :: array
1378
+ %t1412 = length %t1411 :: integer
1379
+ %t1413 = const -1 :: integer
1380
+ %t1414 = call core.sub(%rows_i_279, %t1413) :: integer
1366
1381
  %t1415 = const 0 :: integer
1367
1382
  %t1416 = call core.gte(%t1414, %t1415) :: boolean
1368
1383
  %t1417 = call core.lt(%t1414, %t1412) :: boolean
@@ -1371,131 +1386,116 @@
1371
1386
  %t1420 = call core.sub(%t1412, %t1419) :: integer
1372
1387
  %t1421 = const 0 :: integer
1373
1388
  %t1422 = call core.clamp(%t1414, %t1421, %t1420) :: integer
1374
- %t1423 = Gather %t1411, %t1422 :: integer
1375
- %t1424 = const 0 :: integer
1376
- %t1425 = select %t1418, %t1423, %t1424 :: integer
1377
- %t1426 = load_input "rows" :: array
1378
- %t1427 = Length %t1426 :: integer
1379
- %t1428 = const -1 :: integer
1380
- %t1429 = call core.sub(%rows_i_279, %t1428) :: integer
1381
- %t1430 = const 0 :: integer
1382
- %t1431 = call core.gte(%t1429, %t1430) :: boolean
1383
- %t1432 = call core.lt(%t1429, %t1427) :: boolean
1384
- %t1433 = call core.and(%t1431, %t1432) :: boolean
1385
- %t1434 = const 1 :: integer
1386
- %t1435 = call core.sub(%t1427, %t1434) :: integer
1387
- %t1436 = const 0 :: integer
1388
- %t1437 = call core.clamp(%t1429, %t1436, %t1435) :: integer
1389
- %t1438 = Gather %t1426, %t1437 :: any
1390
- %t1439 = Length %t1438 :: integer
1391
- %t1440 = const -1 :: integer
1392
- %t1441 = call core.sub(%col_i_281, %t1440) :: integer
1393
- %t1442 = const 0 :: integer
1394
- %t1443 = call core.gte(%t1441, %t1442) :: boolean
1395
- %t1444 = call core.lt(%t1441, %t1439) :: boolean
1396
- %t1445 = call core.and(%t1443, %t1444) :: boolean
1397
- %t1446 = call core.and(%t1433, %t1445) :: boolean
1389
+ %t1423 = gather %t1411, %t1422 :: any
1390
+ %t1424 = length %t1423 :: integer
1391
+ %t1425 = const -1 :: integer
1392
+ %t1426 = call core.sub(%col_i_281, %t1425) :: integer
1393
+ %t1427 = const 0 :: integer
1394
+ %t1428 = call core.gte(%t1426, %t1427) :: boolean
1395
+ %t1429 = call core.lt(%t1426, %t1424) :: boolean
1396
+ %t1430 = call core.and(%t1428, %t1429) :: boolean
1397
+ %t1431 = call core.and(%t1418, %t1430) :: boolean
1398
+ %t1432 = const 1 :: integer
1399
+ %t1433 = call core.sub(%t1424, %t1432) :: integer
1400
+ %t1434 = const 0 :: integer
1401
+ %t1435 = call core.clamp(%t1426, %t1434, %t1433) :: integer
1402
+ %t1436 = gather %t1423, %t1435 :: integer
1403
+ %t1437 = const 0 :: integer
1404
+ %t1438 = select %t1431, %t1436, %t1437 :: integer
1405
+ %t1439 = load_input "rows" :: array
1406
+ %t1440 = length %t1439 :: integer
1407
+ %t1441 = const -1 :: integer
1408
+ %t1442 = call core.sub(%rows_i_279, %t1441) :: integer
1409
+ %t1443 = const 0 :: integer
1410
+ %t1444 = call core.gte(%t1442, %t1443) :: boolean
1411
+ %t1445 = call core.lt(%t1442, %t1440) :: boolean
1412
+ %t1446 = call core.and(%t1444, %t1445) :: boolean
1398
1413
  %t1447 = const 1 :: integer
1399
- %t1448 = call core.sub(%t1439, %t1447) :: integer
1414
+ %t1448 = call core.sub(%t1440, %t1447) :: integer
1400
1415
  %t1449 = const 0 :: integer
1401
- %t1450 = call core.clamp(%t1441, %t1449, %t1448) :: integer
1402
- %t1451 = Gather %t1438, %t1450 :: integer
1403
- %t1452 = const 0 :: integer
1404
- %t1453 = select %t1446, %t1451, %t1452 :: integer
1405
- %t1454 = load_input "rows" :: array
1406
- %t1455 = Length %t1454 :: integer
1407
- %t1456 = const -1 :: integer
1408
- %t1457 = call core.sub(%rows_i_279, %t1456) :: integer
1409
- %t1458 = const 0 :: integer
1410
- %t1459 = call core.gte(%t1457, %t1458) :: boolean
1411
- %t1460 = call core.lt(%t1457, %t1455) :: boolean
1412
- %t1461 = call core.and(%t1459, %t1460) :: boolean
1413
- %t1462 = const 1 :: integer
1414
- %t1463 = call core.sub(%t1455, %t1462) :: integer
1415
- %t1464 = const 0 :: integer
1416
- %t1465 = call core.clamp(%t1457, %t1464, %t1463) :: integer
1417
- %t1466 = Gather %t1454, %t1465 :: any
1418
- %t1467 = Length %t1466 :: integer
1419
- %t1468 = const 1 :: integer
1420
- %t1469 = call core.sub(%col_i_281, %t1468) :: integer
1421
- %t1470 = const 0 :: integer
1422
- %t1471 = call core.gte(%t1469, %t1470) :: boolean
1423
- %t1472 = call core.lt(%t1469, %t1467) :: boolean
1424
- %t1473 = call core.and(%t1471, %t1472) :: boolean
1425
- %t1474 = call core.and(%t1461, %t1473) :: boolean
1416
+ %t1450 = call core.clamp(%t1442, %t1449, %t1448) :: integer
1417
+ %t1451 = gather %t1439, %t1450 :: any
1418
+ %t1452 = length %t1451 :: integer
1419
+ %t1453 = const 1 :: integer
1420
+ %t1454 = call core.sub(%col_i_281, %t1453) :: integer
1421
+ %t1455 = const 0 :: integer
1422
+ %t1456 = call core.gte(%t1454, %t1455) :: boolean
1423
+ %t1457 = call core.lt(%t1454, %t1452) :: boolean
1424
+ %t1458 = call core.and(%t1456, %t1457) :: boolean
1425
+ %t1459 = call core.and(%t1446, %t1458) :: boolean
1426
+ %t1460 = const 1 :: integer
1427
+ %t1461 = call core.sub(%t1452, %t1460) :: integer
1428
+ %t1462 = const 0 :: integer
1429
+ %t1463 = call core.clamp(%t1454, %t1462, %t1461) :: integer
1430
+ %t1464 = gather %t1451, %t1463 :: integer
1431
+ %t1465 = const 0 :: integer
1432
+ %t1466 = select %t1459, %t1464, %t1465 :: integer
1433
+ %t1467 = load_input "rows" :: array
1434
+ %t1468 = length %t1467 :: integer
1435
+ %t1469 = const 1 :: integer
1436
+ %t1470 = call core.sub(%rows_i_279, %t1469) :: integer
1437
+ %t1471 = const 0 :: integer
1438
+ %t1472 = call core.gte(%t1470, %t1471) :: boolean
1439
+ %t1473 = call core.lt(%t1470, %t1468) :: boolean
1440
+ %t1474 = call core.and(%t1472, %t1473) :: boolean
1426
1441
  %t1475 = const 1 :: integer
1427
- %t1476 = call core.sub(%t1467, %t1475) :: integer
1442
+ %t1476 = call core.sub(%t1468, %t1475) :: integer
1428
1443
  %t1477 = const 0 :: integer
1429
- %t1478 = call core.clamp(%t1469, %t1477, %t1476) :: integer
1430
- %t1479 = Gather %t1466, %t1478 :: integer
1431
- %t1480 = const 0 :: integer
1432
- %t1481 = select %t1474, %t1479, %t1480 :: integer
1433
- %t1482 = load_input "rows" :: array
1434
- %t1483 = Length %t1482 :: integer
1435
- %t1484 = const 1 :: integer
1436
- %t1485 = call core.sub(%rows_i_279, %t1484) :: integer
1437
- %t1486 = const 0 :: integer
1438
- %t1487 = call core.gte(%t1485, %t1486) :: boolean
1439
- %t1488 = call core.lt(%t1485, %t1483) :: boolean
1440
- %t1489 = call core.and(%t1487, %t1488) :: boolean
1441
- %t1490 = const 1 :: integer
1442
- %t1491 = call core.sub(%t1483, %t1490) :: integer
1443
- %t1492 = const 0 :: integer
1444
- %t1493 = call core.clamp(%t1485, %t1492, %t1491) :: integer
1445
- %t1494 = Gather %t1482, %t1493 :: any
1446
- %t1495 = Length %t1494 :: integer
1447
- %t1496 = const -1 :: integer
1448
- %t1497 = call core.sub(%col_i_281, %t1496) :: integer
1449
- %t1498 = const 0 :: integer
1450
- %t1499 = call core.gte(%t1497, %t1498) :: boolean
1451
- %t1500 = call core.lt(%t1497, %t1495) :: boolean
1452
- %t1501 = call core.and(%t1499, %t1500) :: boolean
1453
- %t1502 = call core.and(%t1489, %t1501) :: boolean
1444
+ %t1478 = call core.clamp(%t1470, %t1477, %t1476) :: integer
1445
+ %t1479 = gather %t1467, %t1478 :: any
1446
+ %t1480 = length %t1479 :: integer
1447
+ %t1481 = const -1 :: integer
1448
+ %t1482 = call core.sub(%col_i_281, %t1481) :: integer
1449
+ %t1483 = const 0 :: integer
1450
+ %t1484 = call core.gte(%t1482, %t1483) :: boolean
1451
+ %t1485 = call core.lt(%t1482, %t1480) :: boolean
1452
+ %t1486 = call core.and(%t1484, %t1485) :: boolean
1453
+ %t1487 = call core.and(%t1474, %t1486) :: boolean
1454
+ %t1488 = const 1 :: integer
1455
+ %t1489 = call core.sub(%t1480, %t1488) :: integer
1456
+ %t1490 = const 0 :: integer
1457
+ %t1491 = call core.clamp(%t1482, %t1490, %t1489) :: integer
1458
+ %t1492 = gather %t1479, %t1491 :: integer
1459
+ %t1493 = const 0 :: integer
1460
+ %t1494 = select %t1487, %t1492, %t1493 :: integer
1461
+ %t1495 = load_input "rows" :: array
1462
+ %t1496 = length %t1495 :: integer
1463
+ %t1497 = const 1 :: integer
1464
+ %t1498 = call core.sub(%rows_i_279, %t1497) :: integer
1465
+ %t1499 = const 0 :: integer
1466
+ %t1500 = call core.gte(%t1498, %t1499) :: boolean
1467
+ %t1501 = call core.lt(%t1498, %t1496) :: boolean
1468
+ %t1502 = call core.and(%t1500, %t1501) :: boolean
1454
1469
  %t1503 = const 1 :: integer
1455
- %t1504 = call core.sub(%t1495, %t1503) :: integer
1470
+ %t1504 = call core.sub(%t1496, %t1503) :: integer
1456
1471
  %t1505 = const 0 :: integer
1457
- %t1506 = call core.clamp(%t1497, %t1505, %t1504) :: integer
1458
- %t1507 = Gather %t1494, %t1506 :: integer
1459
- %t1508 = const 0 :: integer
1460
- %t1509 = select %t1502, %t1507, %t1508 :: integer
1461
- %t1510 = load_input "rows" :: array
1462
- %t1511 = Length %t1510 :: integer
1463
- %t1512 = const 1 :: integer
1464
- %t1513 = call core.sub(%rows_i_279, %t1512) :: integer
1465
- %t1514 = const 0 :: integer
1466
- %t1515 = call core.gte(%t1513, %t1514) :: boolean
1467
- %t1516 = call core.lt(%t1513, %t1511) :: boolean
1468
- %t1517 = call core.and(%t1515, %t1516) :: boolean
1469
- %t1518 = const 1 :: integer
1470
- %t1519 = call core.sub(%t1511, %t1518) :: integer
1471
- %t1520 = const 0 :: integer
1472
- %t1521 = call core.clamp(%t1513, %t1520, %t1519) :: integer
1473
- %t1522 = Gather %t1510, %t1521 :: any
1474
- %t1523 = Length %t1522 :: integer
1475
- %t1524 = const 1 :: integer
1476
- %t1525 = call core.sub(%col_i_281, %t1524) :: integer
1477
- %t1526 = const 0 :: integer
1478
- %t1527 = call core.gte(%t1525, %t1526) :: boolean
1479
- %t1528 = call core.lt(%t1525, %t1523) :: boolean
1480
- %t1529 = call core.and(%t1527, %t1528) :: boolean
1481
- %t1530 = call core.and(%t1517, %t1529) :: boolean
1482
- %t1531 = const 1 :: integer
1483
- %t1532 = call core.sub(%t1523, %t1531) :: integer
1484
- %t1533 = const 0 :: integer
1485
- %t1534 = call core.clamp(%t1525, %t1533, %t1532) :: integer
1486
- %t1535 = Gather %t1522, %t1534 :: integer
1487
- %t1536 = const 0 :: integer
1488
- %t1537 = select %t1530, %t1535, %t1536 :: integer
1489
- %t1314 = make_tuple(%t1365, %t1385, %t1405, %t1425, %t1453, %t1481, %t1509, %t1537) :: tuple<integer>
1490
- %t1315 = Fold %t1314 fn="agg.sum" ::
1491
- %t1316 = const 2 :: integer
1492
- %t1317 = call core.eq(%t1315, %t1316) :: boolean
1493
- %t1318 = load_input "rows" :: array
1494
- %t1319 = load_input "rows" :: array
1495
- %t1320 = const 0 :: integer
1496
- %t1321 = call core.gt(%col_el_280, %t1320) :: boolean
1497
- %t524 = call core.and(%t1317, %t1321) :: boolean
1498
- %t284 = call core.or(%t520, %t524) :: boolean
1472
+ %t1506 = call core.clamp(%t1498, %t1505, %t1504) :: integer
1473
+ %t1507 = gather %t1495, %t1506 :: any
1474
+ %t1508 = length %t1507 :: integer
1475
+ %t1509 = const 1 :: integer
1476
+ %t1510 = call core.sub(%col_i_281, %t1509) :: integer
1477
+ %t1511 = const 0 :: integer
1478
+ %t1512 = call core.gte(%t1510, %t1511) :: boolean
1479
+ %t1513 = call core.lt(%t1510, %t1508) :: boolean
1480
+ %t1514 = call core.and(%t1512, %t1513) :: boolean
1481
+ %t1515 = call core.and(%t1502, %t1514) :: boolean
1482
+ %t1516 = const 1 :: integer
1483
+ %t1517 = call core.sub(%t1508, %t1516) :: integer
1484
+ %t1518 = const 0 :: integer
1485
+ %t1519 = call core.clamp(%t1510, %t1518, %t1517) :: integer
1486
+ %t1520 = gather %t1507, %t1519 :: integer
1487
+ %t1521 = const 0 :: integer
1488
+ %t1522 = select %t1515, %t1520, %t1521 :: integer
1489
+ %t1329 = make_tuple(%t1350, %t1370, %t1390, %t1410, %t1438, %t1466, %t1494, %t1522) :: tuple<integer>
1490
+ %t1330 = fold %t1329 fn="agg.sum" ::
1491
+ %t1318 = const 2 :: integer
1492
+ %t1319 = call core.eq(%t1330, %t1318) :: boolean
1493
+ %t1523 = load_input "rows" :: array
1494
+ %t1527 = load_input "rows" :: array
1495
+ %t1525 = const 0 :: integer
1496
+ %t1526 = call core.gt(%col_el_280, %t1525) :: boolean
1497
+ %t1315 = call core.and(%t1319, %t1526) :: boolean
1498
+ %t284 = call core.or(%t1108, %t1315) :: boolean
1499
1499
  yield %t284
1500
1500
  end_loop
1501
1501
  end_loop
@@ -1504,413 +1504,413 @@
1504
1504
  %t285 = load_input "rows" :: array
1505
1505
  loop rows id=L31 in %t285 as el=%rows_el_286, idx=%rows_i_287
1506
1506
  loop col id=L32 in %rows_el_286 as el=%col_el_288, idx=%col_i_289
1507
- %t525 = load_input "rows" :: array
1508
- %t1322 = load_input "rows" :: array
1509
- %t1323 = load_input "rows" :: array
1510
- %t1538 = load_input "rows" :: array
1511
- %t1539 = Length %t1538 :: integer
1512
- %t1540 = const -1 :: integer
1513
- %t1541 = call core.sub(%rows_i_287, %t1540) :: integer
1514
- %t1542 = const 0 :: integer
1515
- %t1543 = call core.gte(%t1541, %t1542) :: boolean
1516
- %t1544 = call core.lt(%t1541, %t1539) :: boolean
1517
- %t1545 = call core.and(%t1543, %t1544) :: boolean
1518
- %t1546 = const 1 :: integer
1519
- %t1547 = call core.sub(%t1539, %t1546) :: integer
1520
- %t1548 = const 0 :: integer
1521
- %t1549 = call core.clamp(%t1541, %t1548, %t1547) :: integer
1522
- %t1550 = Gather %t1538, %t1549 :: any
1523
- %t1551 = Length %t1550 :: integer
1524
- %t1552 = call core.mod(%col_i_289, %t1551) :: integer
1525
- %t1553 = call core.add(%t1552, %t1551) :: integer
1526
- %t1554 = call core.mod(%t1553, %t1551) :: integer
1527
- %t1555 = Gather %t1550, %t1554 :: integer
1528
- %t1556 = const 0 :: integer
1529
- %t1557 = select %t1545, %t1555, %t1556 :: integer
1530
- %t1558 = load_input "rows" :: array
1531
- %t1559 = Length %t1558 :: integer
1532
- %t1560 = const 1 :: integer
1533
- %t1561 = call core.sub(%rows_i_287, %t1560) :: integer
1534
- %t1562 = const 0 :: integer
1535
- %t1563 = call core.gte(%t1561, %t1562) :: boolean
1536
- %t1564 = call core.lt(%t1561, %t1559) :: boolean
1537
- %t1565 = call core.and(%t1563, %t1564) :: boolean
1538
- %t1566 = const 1 :: integer
1539
- %t1567 = call core.sub(%t1559, %t1566) :: integer
1540
- %t1568 = const 0 :: integer
1541
- %t1569 = call core.clamp(%t1561, %t1568, %t1567) :: integer
1542
- %t1570 = Gather %t1558, %t1569 :: any
1543
- %t1571 = Length %t1570 :: integer
1544
- %t1572 = call core.mod(%col_i_289, %t1571) :: integer
1545
- %t1573 = call core.add(%t1572, %t1571) :: integer
1546
- %t1574 = call core.mod(%t1573, %t1571) :: integer
1547
- %t1575 = Gather %t1570, %t1574 :: integer
1548
- %t1576 = const 0 :: integer
1549
- %t1577 = select %t1565, %t1575, %t1576 :: integer
1550
- %t1578 = load_input "rows" :: array
1551
- %t1579 = Length %t1578 :: integer
1552
- %t1580 = call core.mod(%rows_i_287, %t1579) :: integer
1553
- %t1581 = call core.add(%t1580, %t1579) :: integer
1554
- %t1582 = call core.mod(%t1581, %t1579) :: integer
1555
- %t1583 = Gather %t1578, %t1582 :: any
1556
- %t1584 = Length %t1583 :: integer
1557
- %t1585 = const -1 :: integer
1558
- %t1586 = call core.sub(%col_i_289, %t1585) :: integer
1559
- %t1587 = const 0 :: integer
1560
- %t1588 = call core.gte(%t1586, %t1587) :: boolean
1561
- %t1589 = call core.lt(%t1586, %t1584) :: boolean
1562
- %t1590 = call core.and(%t1588, %t1589) :: boolean
1563
- %t1591 = const 1 :: integer
1564
- %t1592 = call core.sub(%t1584, %t1591) :: integer
1565
- %t1593 = const 0 :: integer
1566
- %t1594 = call core.clamp(%t1586, %t1593, %t1592) :: integer
1567
- %t1595 = Gather %t1583, %t1594 :: integer
1507
+ %t1528 = load_input "rows" :: array
1508
+ %t1532 = load_input "rows" :: array
1509
+ %t1536 = load_input "rows" :: array
1510
+ %t1547 = load_input "rows" :: array
1511
+ %t1548 = length %t1547 :: integer
1512
+ %t1549 = const -1 :: integer
1513
+ %t1550 = call core.sub(%rows_i_287, %t1549) :: integer
1514
+ %t1551 = const 0 :: integer
1515
+ %t1552 = call core.gte(%t1550, %t1551) :: boolean
1516
+ %t1553 = call core.lt(%t1550, %t1548) :: boolean
1517
+ %t1554 = call core.and(%t1552, %t1553) :: boolean
1518
+ %t1555 = const 1 :: integer
1519
+ %t1556 = call core.sub(%t1548, %t1555) :: integer
1520
+ %t1557 = const 0 :: integer
1521
+ %t1558 = call core.clamp(%t1550, %t1557, %t1556) :: integer
1522
+ %t1559 = gather %t1547, %t1558 :: any
1523
+ %t1560 = length %t1559 :: integer
1524
+ %t1561 = call core.mod(%col_i_289, %t1560) :: integer
1525
+ %t1562 = call core.add(%t1561, %t1560) :: integer
1526
+ %t1563 = call core.mod(%t1562, %t1560) :: integer
1527
+ %t1564 = gather %t1559, %t1563 :: integer
1528
+ %t1565 = const 0 :: integer
1529
+ %t1566 = select %t1554, %t1564, %t1565 :: integer
1530
+ %t1567 = load_input "rows" :: array
1531
+ %t1568 = length %t1567 :: integer
1532
+ %t1569 = const 1 :: integer
1533
+ %t1570 = call core.sub(%rows_i_287, %t1569) :: integer
1534
+ %t1571 = const 0 :: integer
1535
+ %t1572 = call core.gte(%t1570, %t1571) :: boolean
1536
+ %t1573 = call core.lt(%t1570, %t1568) :: boolean
1537
+ %t1574 = call core.and(%t1572, %t1573) :: boolean
1538
+ %t1575 = const 1 :: integer
1539
+ %t1576 = call core.sub(%t1568, %t1575) :: integer
1540
+ %t1577 = const 0 :: integer
1541
+ %t1578 = call core.clamp(%t1570, %t1577, %t1576) :: integer
1542
+ %t1579 = gather %t1567, %t1578 :: any
1543
+ %t1580 = length %t1579 :: integer
1544
+ %t1581 = call core.mod(%col_i_289, %t1580) :: integer
1545
+ %t1582 = call core.add(%t1581, %t1580) :: integer
1546
+ %t1583 = call core.mod(%t1582, %t1580) :: integer
1547
+ %t1584 = gather %t1579, %t1583 :: integer
1548
+ %t1585 = const 0 :: integer
1549
+ %t1586 = select %t1574, %t1584, %t1585 :: integer
1550
+ %t1587 = load_input "rows" :: array
1551
+ %t1588 = length %t1587 :: integer
1552
+ %t1589 = call core.mod(%rows_i_287, %t1588) :: integer
1553
+ %t1590 = call core.add(%t1589, %t1588) :: integer
1554
+ %t1591 = call core.mod(%t1590, %t1588) :: integer
1555
+ %t1592 = gather %t1587, %t1591 :: any
1556
+ %t1593 = length %t1592 :: integer
1557
+ %t1594 = const -1 :: integer
1558
+ %t1595 = call core.sub(%col_i_289, %t1594) :: integer
1568
1559
  %t1596 = const 0 :: integer
1569
- %t1597 = select %t1590, %t1595, %t1596 :: integer
1570
- %t1598 = load_input "rows" :: array
1571
- %t1599 = Length %t1598 :: integer
1572
- %t1600 = call core.mod(%rows_i_287, %t1599) :: integer
1573
- %t1601 = call core.add(%t1600, %t1599) :: integer
1574
- %t1602 = call core.mod(%t1601, %t1599) :: integer
1575
- %t1603 = Gather %t1598, %t1602 :: any
1576
- %t1604 = Length %t1603 :: integer
1577
- %t1605 = const 1 :: integer
1578
- %t1606 = call core.sub(%col_i_289, %t1605) :: integer
1579
- %t1607 = const 0 :: integer
1580
- %t1608 = call core.gte(%t1606, %t1607) :: boolean
1581
- %t1609 = call core.lt(%t1606, %t1604) :: boolean
1582
- %t1610 = call core.and(%t1608, %t1609) :: boolean
1583
- %t1611 = const 1 :: integer
1584
- %t1612 = call core.sub(%t1604, %t1611) :: integer
1585
- %t1613 = const 0 :: integer
1586
- %t1614 = call core.clamp(%t1606, %t1613, %t1612) :: integer
1587
- %t1615 = Gather %t1603, %t1614 :: integer
1560
+ %t1597 = call core.gte(%t1595, %t1596) :: boolean
1561
+ %t1598 = call core.lt(%t1595, %t1593) :: boolean
1562
+ %t1599 = call core.and(%t1597, %t1598) :: boolean
1563
+ %t1600 = const 1 :: integer
1564
+ %t1601 = call core.sub(%t1593, %t1600) :: integer
1565
+ %t1602 = const 0 :: integer
1566
+ %t1603 = call core.clamp(%t1595, %t1602, %t1601) :: integer
1567
+ %t1604 = gather %t1592, %t1603 :: integer
1568
+ %t1605 = const 0 :: integer
1569
+ %t1606 = select %t1599, %t1604, %t1605 :: integer
1570
+ %t1607 = load_input "rows" :: array
1571
+ %t1608 = length %t1607 :: integer
1572
+ %t1609 = call core.mod(%rows_i_287, %t1608) :: integer
1573
+ %t1610 = call core.add(%t1609, %t1608) :: integer
1574
+ %t1611 = call core.mod(%t1610, %t1608) :: integer
1575
+ %t1612 = gather %t1607, %t1611 :: any
1576
+ %t1613 = length %t1612 :: integer
1577
+ %t1614 = const 1 :: integer
1578
+ %t1615 = call core.sub(%col_i_289, %t1614) :: integer
1588
1579
  %t1616 = const 0 :: integer
1589
- %t1617 = select %t1610, %t1615, %t1616 :: integer
1590
- %t1618 = load_input "rows" :: array
1591
- %t1619 = Length %t1618 :: integer
1592
- %t1620 = const -1 :: integer
1593
- %t1621 = call core.sub(%rows_i_287, %t1620) :: integer
1580
+ %t1617 = call core.gte(%t1615, %t1616) :: boolean
1581
+ %t1618 = call core.lt(%t1615, %t1613) :: boolean
1582
+ %t1619 = call core.and(%t1617, %t1618) :: boolean
1583
+ %t1620 = const 1 :: integer
1584
+ %t1621 = call core.sub(%t1613, %t1620) :: integer
1594
1585
  %t1622 = const 0 :: integer
1595
- %t1623 = call core.gte(%t1621, %t1622) :: boolean
1596
- %t1624 = call core.lt(%t1621, %t1619) :: boolean
1597
- %t1625 = call core.and(%t1623, %t1624) :: boolean
1598
- %t1626 = const 1 :: integer
1599
- %t1627 = call core.sub(%t1619, %t1626) :: integer
1600
- %t1628 = const 0 :: integer
1601
- %t1629 = call core.clamp(%t1621, %t1628, %t1627) :: integer
1602
- %t1630 = Gather %t1618, %t1629 :: any
1603
- %t1631 = Length %t1630 :: integer
1604
- %t1632 = const -1 :: integer
1605
- %t1633 = call core.sub(%col_i_289, %t1632) :: integer
1606
- %t1634 = const 0 :: integer
1607
- %t1635 = call core.gte(%t1633, %t1634) :: boolean
1608
- %t1636 = call core.lt(%t1633, %t1631) :: boolean
1609
- %t1637 = call core.and(%t1635, %t1636) :: boolean
1610
- %t1638 = call core.and(%t1625, %t1637) :: boolean
1611
- %t1639 = const 1 :: integer
1612
- %t1640 = call core.sub(%t1631, %t1639) :: integer
1613
- %t1641 = const 0 :: integer
1614
- %t1642 = call core.clamp(%t1633, %t1641, %t1640) :: integer
1615
- %t1643 = Gather %t1630, %t1642 :: integer
1616
- %t1644 = const 0 :: integer
1617
- %t1645 = select %t1638, %t1643, %t1644 :: integer
1618
- %t1646 = load_input "rows" :: array
1619
- %t1647 = Length %t1646 :: integer
1620
- %t1648 = const -1 :: integer
1621
- %t1649 = call core.sub(%rows_i_287, %t1648) :: integer
1586
+ %t1623 = call core.clamp(%t1615, %t1622, %t1621) :: integer
1587
+ %t1624 = gather %t1612, %t1623 :: integer
1588
+ %t1625 = const 0 :: integer
1589
+ %t1626 = select %t1619, %t1624, %t1625 :: integer
1590
+ %t1627 = load_input "rows" :: array
1591
+ %t1628 = length %t1627 :: integer
1592
+ %t1629 = const -1 :: integer
1593
+ %t1630 = call core.sub(%rows_i_287, %t1629) :: integer
1594
+ %t1631 = const 0 :: integer
1595
+ %t1632 = call core.gte(%t1630, %t1631) :: boolean
1596
+ %t1633 = call core.lt(%t1630, %t1628) :: boolean
1597
+ %t1634 = call core.and(%t1632, %t1633) :: boolean
1598
+ %t1635 = const 1 :: integer
1599
+ %t1636 = call core.sub(%t1628, %t1635) :: integer
1600
+ %t1637 = const 0 :: integer
1601
+ %t1638 = call core.clamp(%t1630, %t1637, %t1636) :: integer
1602
+ %t1639 = gather %t1627, %t1638 :: any
1603
+ %t1640 = length %t1639 :: integer
1604
+ %t1641 = const -1 :: integer
1605
+ %t1642 = call core.sub(%col_i_289, %t1641) :: integer
1606
+ %t1643 = const 0 :: integer
1607
+ %t1644 = call core.gte(%t1642, %t1643) :: boolean
1608
+ %t1645 = call core.lt(%t1642, %t1640) :: boolean
1609
+ %t1646 = call core.and(%t1644, %t1645) :: boolean
1610
+ %t1647 = call core.and(%t1634, %t1646) :: boolean
1611
+ %t1648 = const 1 :: integer
1612
+ %t1649 = call core.sub(%t1640, %t1648) :: integer
1622
1613
  %t1650 = const 0 :: integer
1623
- %t1651 = call core.gte(%t1649, %t1650) :: boolean
1624
- %t1652 = call core.lt(%t1649, %t1647) :: boolean
1625
- %t1653 = call core.and(%t1651, %t1652) :: boolean
1626
- %t1654 = const 1 :: integer
1627
- %t1655 = call core.sub(%t1647, %t1654) :: integer
1628
- %t1656 = const 0 :: integer
1629
- %t1657 = call core.clamp(%t1649, %t1656, %t1655) :: integer
1630
- %t1658 = Gather %t1646, %t1657 :: any
1631
- %t1659 = Length %t1658 :: integer
1632
- %t1660 = const 1 :: integer
1633
- %t1661 = call core.sub(%col_i_289, %t1660) :: integer
1634
- %t1662 = const 0 :: integer
1635
- %t1663 = call core.gte(%t1661, %t1662) :: boolean
1636
- %t1664 = call core.lt(%t1661, %t1659) :: boolean
1637
- %t1665 = call core.and(%t1663, %t1664) :: boolean
1638
- %t1666 = call core.and(%t1653, %t1665) :: boolean
1639
- %t1667 = const 1 :: integer
1640
- %t1668 = call core.sub(%t1659, %t1667) :: integer
1641
- %t1669 = const 0 :: integer
1642
- %t1670 = call core.clamp(%t1661, %t1669, %t1668) :: integer
1643
- %t1671 = Gather %t1658, %t1670 :: integer
1644
- %t1672 = const 0 :: integer
1645
- %t1673 = select %t1666, %t1671, %t1672 :: integer
1646
- %t1674 = load_input "rows" :: array
1647
- %t1675 = Length %t1674 :: integer
1614
+ %t1651 = call core.clamp(%t1642, %t1650, %t1649) :: integer
1615
+ %t1652 = gather %t1639, %t1651 :: integer
1616
+ %t1653 = const 0 :: integer
1617
+ %t1654 = select %t1647, %t1652, %t1653 :: integer
1618
+ %t1655 = load_input "rows" :: array
1619
+ %t1656 = length %t1655 :: integer
1620
+ %t1657 = const -1 :: integer
1621
+ %t1658 = call core.sub(%rows_i_287, %t1657) :: integer
1622
+ %t1659 = const 0 :: integer
1623
+ %t1660 = call core.gte(%t1658, %t1659) :: boolean
1624
+ %t1661 = call core.lt(%t1658, %t1656) :: boolean
1625
+ %t1662 = call core.and(%t1660, %t1661) :: boolean
1626
+ %t1663 = const 1 :: integer
1627
+ %t1664 = call core.sub(%t1656, %t1663) :: integer
1628
+ %t1665 = const 0 :: integer
1629
+ %t1666 = call core.clamp(%t1658, %t1665, %t1664) :: integer
1630
+ %t1667 = gather %t1655, %t1666 :: any
1631
+ %t1668 = length %t1667 :: integer
1632
+ %t1669 = const 1 :: integer
1633
+ %t1670 = call core.sub(%col_i_289, %t1669) :: integer
1634
+ %t1671 = const 0 :: integer
1635
+ %t1672 = call core.gte(%t1670, %t1671) :: boolean
1636
+ %t1673 = call core.lt(%t1670, %t1668) :: boolean
1637
+ %t1674 = call core.and(%t1672, %t1673) :: boolean
1638
+ %t1675 = call core.and(%t1662, %t1674) :: boolean
1648
1639
  %t1676 = const 1 :: integer
1649
- %t1677 = call core.sub(%rows_i_287, %t1676) :: integer
1640
+ %t1677 = call core.sub(%t1668, %t1676) :: integer
1650
1641
  %t1678 = const 0 :: integer
1651
- %t1679 = call core.gte(%t1677, %t1678) :: boolean
1652
- %t1680 = call core.lt(%t1677, %t1675) :: boolean
1653
- %t1681 = call core.and(%t1679, %t1680) :: boolean
1654
- %t1682 = const 1 :: integer
1655
- %t1683 = call core.sub(%t1675, %t1682) :: integer
1656
- %t1684 = const 0 :: integer
1657
- %t1685 = call core.clamp(%t1677, %t1684, %t1683) :: integer
1658
- %t1686 = Gather %t1674, %t1685 :: any
1659
- %t1687 = Length %t1686 :: integer
1660
- %t1688 = const -1 :: integer
1661
- %t1689 = call core.sub(%col_i_289, %t1688) :: integer
1662
- %t1690 = const 0 :: integer
1663
- %t1691 = call core.gte(%t1689, %t1690) :: boolean
1664
- %t1692 = call core.lt(%t1689, %t1687) :: boolean
1665
- %t1693 = call core.and(%t1691, %t1692) :: boolean
1666
- %t1694 = call core.and(%t1681, %t1693) :: boolean
1667
- %t1695 = const 1 :: integer
1668
- %t1696 = call core.sub(%t1687, %t1695) :: integer
1669
- %t1697 = const 0 :: integer
1670
- %t1698 = call core.clamp(%t1689, %t1697, %t1696) :: integer
1671
- %t1699 = Gather %t1686, %t1698 :: integer
1672
- %t1700 = const 0 :: integer
1673
- %t1701 = select %t1694, %t1699, %t1700 :: integer
1674
- %t1702 = load_input "rows" :: array
1675
- %t1703 = Length %t1702 :: integer
1642
+ %t1679 = call core.clamp(%t1670, %t1678, %t1677) :: integer
1643
+ %t1680 = gather %t1667, %t1679 :: integer
1644
+ %t1681 = const 0 :: integer
1645
+ %t1682 = select %t1675, %t1680, %t1681 :: integer
1646
+ %t1683 = load_input "rows" :: array
1647
+ %t1684 = length %t1683 :: integer
1648
+ %t1685 = const 1 :: integer
1649
+ %t1686 = call core.sub(%rows_i_287, %t1685) :: integer
1650
+ %t1687 = const 0 :: integer
1651
+ %t1688 = call core.gte(%t1686, %t1687) :: boolean
1652
+ %t1689 = call core.lt(%t1686, %t1684) :: boolean
1653
+ %t1690 = call core.and(%t1688, %t1689) :: boolean
1654
+ %t1691 = const 1 :: integer
1655
+ %t1692 = call core.sub(%t1684, %t1691) :: integer
1656
+ %t1693 = const 0 :: integer
1657
+ %t1694 = call core.clamp(%t1686, %t1693, %t1692) :: integer
1658
+ %t1695 = gather %t1683, %t1694 :: any
1659
+ %t1696 = length %t1695 :: integer
1660
+ %t1697 = const -1 :: integer
1661
+ %t1698 = call core.sub(%col_i_289, %t1697) :: integer
1662
+ %t1699 = const 0 :: integer
1663
+ %t1700 = call core.gte(%t1698, %t1699) :: boolean
1664
+ %t1701 = call core.lt(%t1698, %t1696) :: boolean
1665
+ %t1702 = call core.and(%t1700, %t1701) :: boolean
1666
+ %t1703 = call core.and(%t1690, %t1702) :: boolean
1676
1667
  %t1704 = const 1 :: integer
1677
- %t1705 = call core.sub(%rows_i_287, %t1704) :: integer
1668
+ %t1705 = call core.sub(%t1696, %t1704) :: integer
1678
1669
  %t1706 = const 0 :: integer
1679
- %t1707 = call core.gte(%t1705, %t1706) :: boolean
1680
- %t1708 = call core.lt(%t1705, %t1703) :: boolean
1681
- %t1709 = call core.and(%t1707, %t1708) :: boolean
1682
- %t1710 = const 1 :: integer
1683
- %t1711 = call core.sub(%t1703, %t1710) :: integer
1684
- %t1712 = const 0 :: integer
1685
- %t1713 = call core.clamp(%t1705, %t1712, %t1711) :: integer
1686
- %t1714 = Gather %t1702, %t1713 :: any
1687
- %t1715 = Length %t1714 :: integer
1688
- %t1716 = const 1 :: integer
1689
- %t1717 = call core.sub(%col_i_289, %t1716) :: integer
1690
- %t1718 = const 0 :: integer
1691
- %t1719 = call core.gte(%t1717, %t1718) :: boolean
1692
- %t1720 = call core.lt(%t1717, %t1715) :: boolean
1693
- %t1721 = call core.and(%t1719, %t1720) :: boolean
1694
- %t1722 = call core.and(%t1709, %t1721) :: boolean
1695
- %t1723 = const 1 :: integer
1696
- %t1724 = call core.sub(%t1715, %t1723) :: integer
1697
- %t1725 = const 0 :: integer
1698
- %t1726 = call core.clamp(%t1717, %t1725, %t1724) :: integer
1699
- %t1727 = Gather %t1714, %t1726 :: integer
1700
- %t1728 = const 0 :: integer
1701
- %t1729 = select %t1722, %t1727, %t1728 :: integer
1702
- %t1332 = make_tuple(%t1557, %t1577, %t1597, %t1617, %t1645, %t1673, %t1701, %t1729) :: tuple<integer>
1703
- %t1333 = Fold %t1332 fn="agg.sum" ::
1704
- %t1334 = const 3 :: integer
1705
- %t1335 = call core.eq(%t1333, %t1334) :: boolean
1706
- %t1336 = load_input "rows" :: array
1707
- %t1337 = load_input "rows" :: array
1708
- %t1730 = load_input "rows" :: array
1709
- %t1731 = load_input "rows" :: array
1710
- %t1732 = Length %t1731 :: integer
1711
- %t1733 = const -1 :: integer
1712
- %t1734 = call core.sub(%rows_i_287, %t1733) :: integer
1713
- %t1735 = const 0 :: integer
1714
- %t1736 = call core.gte(%t1734, %t1735) :: boolean
1715
- %t1737 = call core.lt(%t1734, %t1732) :: boolean
1716
- %t1738 = call core.and(%t1736, %t1737) :: boolean
1717
- %t1739 = const 1 :: integer
1718
- %t1740 = call core.sub(%t1732, %t1739) :: integer
1719
- %t1741 = const 0 :: integer
1720
- %t1742 = call core.clamp(%t1734, %t1741, %t1740) :: integer
1721
- %t1743 = Gather %t1731, %t1742 :: any
1722
- %t1744 = Length %t1743 :: integer
1723
- %t1745 = call core.mod(%col_i_289, %t1744) :: integer
1724
- %t1746 = call core.add(%t1745, %t1744) :: integer
1725
- %t1747 = call core.mod(%t1746, %t1744) :: integer
1726
- %t1748 = Gather %t1743, %t1747 :: integer
1727
- %t1749 = const 0 :: integer
1728
- %t1750 = select %t1738, %t1748, %t1749 :: integer
1729
- %t1751 = load_input "rows" :: array
1730
- %t1752 = Length %t1751 :: integer
1731
- %t1753 = const 1 :: integer
1732
- %t1754 = call core.sub(%rows_i_287, %t1753) :: integer
1733
- %t1755 = const 0 :: integer
1734
- %t1756 = call core.gte(%t1754, %t1755) :: boolean
1735
- %t1757 = call core.lt(%t1754, %t1752) :: boolean
1736
- %t1758 = call core.and(%t1756, %t1757) :: boolean
1737
- %t1759 = const 1 :: integer
1738
- %t1760 = call core.sub(%t1752, %t1759) :: integer
1739
- %t1761 = const 0 :: integer
1740
- %t1762 = call core.clamp(%t1754, %t1761, %t1760) :: integer
1741
- %t1763 = Gather %t1751, %t1762 :: any
1742
- %t1764 = Length %t1763 :: integer
1743
- %t1765 = call core.mod(%col_i_289, %t1764) :: integer
1744
- %t1766 = call core.add(%t1765, %t1764) :: integer
1745
- %t1767 = call core.mod(%t1766, %t1764) :: integer
1746
- %t1768 = Gather %t1763, %t1767 :: integer
1747
- %t1769 = const 0 :: integer
1748
- %t1770 = select %t1758, %t1768, %t1769 :: integer
1749
- %t1771 = load_input "rows" :: array
1750
- %t1772 = Length %t1771 :: integer
1751
- %t1773 = call core.mod(%rows_i_287, %t1772) :: integer
1752
- %t1774 = call core.add(%t1773, %t1772) :: integer
1753
- %t1775 = call core.mod(%t1774, %t1772) :: integer
1754
- %t1776 = Gather %t1771, %t1775 :: any
1755
- %t1777 = Length %t1776 :: integer
1756
- %t1778 = const -1 :: integer
1757
- %t1779 = call core.sub(%col_i_289, %t1778) :: integer
1758
- %t1780 = const 0 :: integer
1759
- %t1781 = call core.gte(%t1779, %t1780) :: boolean
1760
- %t1782 = call core.lt(%t1779, %t1777) :: boolean
1761
- %t1783 = call core.and(%t1781, %t1782) :: boolean
1762
- %t1784 = const 1 :: integer
1763
- %t1785 = call core.sub(%t1777, %t1784) :: integer
1764
- %t1786 = const 0 :: integer
1765
- %t1787 = call core.clamp(%t1779, %t1786, %t1785) :: integer
1766
- %t1788 = Gather %t1776, %t1787 :: integer
1767
- %t1789 = const 0 :: integer
1768
- %t1790 = select %t1783, %t1788, %t1789 :: integer
1769
- %t1791 = load_input "rows" :: array
1770
- %t1792 = Length %t1791 :: integer
1771
- %t1793 = call core.mod(%rows_i_287, %t1792) :: integer
1772
- %t1794 = call core.add(%t1793, %t1792) :: integer
1773
- %t1795 = call core.mod(%t1794, %t1792) :: integer
1774
- %t1796 = Gather %t1791, %t1795 :: any
1775
- %t1797 = Length %t1796 :: integer
1776
- %t1798 = const 1 :: integer
1777
- %t1799 = call core.sub(%col_i_289, %t1798) :: integer
1778
- %t1800 = const 0 :: integer
1779
- %t1801 = call core.gte(%t1799, %t1800) :: boolean
1780
- %t1802 = call core.lt(%t1799, %t1797) :: boolean
1781
- %t1803 = call core.and(%t1801, %t1802) :: boolean
1782
- %t1804 = const 1 :: integer
1783
- %t1805 = call core.sub(%t1797, %t1804) :: integer
1784
- %t1806 = const 0 :: integer
1785
- %t1807 = call core.clamp(%t1799, %t1806, %t1805) :: integer
1786
- %t1808 = Gather %t1796, %t1807 :: integer
1787
- %t1809 = const 0 :: integer
1788
- %t1810 = select %t1803, %t1808, %t1809 :: integer
1789
- %t1811 = load_input "rows" :: array
1790
- %t1812 = Length %t1811 :: integer
1791
- %t1813 = const -1 :: integer
1792
- %t1814 = call core.sub(%rows_i_287, %t1813) :: integer
1793
- %t1815 = const 0 :: integer
1794
- %t1816 = call core.gte(%t1814, %t1815) :: boolean
1795
- %t1817 = call core.lt(%t1814, %t1812) :: boolean
1796
- %t1818 = call core.and(%t1816, %t1817) :: boolean
1797
- %t1819 = const 1 :: integer
1798
- %t1820 = call core.sub(%t1812, %t1819) :: integer
1799
- %t1821 = const 0 :: integer
1800
- %t1822 = call core.clamp(%t1814, %t1821, %t1820) :: integer
1801
- %t1823 = Gather %t1811, %t1822 :: any
1802
- %t1824 = Length %t1823 :: integer
1803
- %t1825 = const -1 :: integer
1670
+ %t1707 = call core.clamp(%t1698, %t1706, %t1705) :: integer
1671
+ %t1708 = gather %t1695, %t1707 :: integer
1672
+ %t1709 = const 0 :: integer
1673
+ %t1710 = select %t1703, %t1708, %t1709 :: integer
1674
+ %t1711 = load_input "rows" :: array
1675
+ %t1712 = length %t1711 :: integer
1676
+ %t1713 = const 1 :: integer
1677
+ %t1714 = call core.sub(%rows_i_287, %t1713) :: integer
1678
+ %t1715 = const 0 :: integer
1679
+ %t1716 = call core.gte(%t1714, %t1715) :: boolean
1680
+ %t1717 = call core.lt(%t1714, %t1712) :: boolean
1681
+ %t1718 = call core.and(%t1716, %t1717) :: boolean
1682
+ %t1719 = const 1 :: integer
1683
+ %t1720 = call core.sub(%t1712, %t1719) :: integer
1684
+ %t1721 = const 0 :: integer
1685
+ %t1722 = call core.clamp(%t1714, %t1721, %t1720) :: integer
1686
+ %t1723 = gather %t1711, %t1722 :: any
1687
+ %t1724 = length %t1723 :: integer
1688
+ %t1725 = const 1 :: integer
1689
+ %t1726 = call core.sub(%col_i_289, %t1725) :: integer
1690
+ %t1727 = const 0 :: integer
1691
+ %t1728 = call core.gte(%t1726, %t1727) :: boolean
1692
+ %t1729 = call core.lt(%t1726, %t1724) :: boolean
1693
+ %t1730 = call core.and(%t1728, %t1729) :: boolean
1694
+ %t1731 = call core.and(%t1718, %t1730) :: boolean
1695
+ %t1732 = const 1 :: integer
1696
+ %t1733 = call core.sub(%t1724, %t1732) :: integer
1697
+ %t1734 = const 0 :: integer
1698
+ %t1735 = call core.clamp(%t1726, %t1734, %t1733) :: integer
1699
+ %t1736 = gather %t1723, %t1735 :: integer
1700
+ %t1737 = const 0 :: integer
1701
+ %t1738 = select %t1731, %t1736, %t1737 :: integer
1702
+ %t1545 = make_tuple(%t1566, %t1586, %t1606, %t1626, %t1654, %t1682, %t1710, %t1738) :: tuple<integer>
1703
+ %t1546 = fold %t1545 fn="agg.sum" ::
1704
+ %t1534 = const 3 :: integer
1705
+ %t1535 = call core.eq(%t1546, %t1534) :: boolean
1706
+ %t1739 = load_input "rows" :: array
1707
+ %t1743 = load_input "rows" :: array
1708
+ %t1747 = load_input "rows" :: array
1709
+ %t1758 = load_input "rows" :: array
1710
+ %t1759 = length %t1758 :: integer
1711
+ %t1760 = const -1 :: integer
1712
+ %t1761 = call core.sub(%rows_i_287, %t1760) :: integer
1713
+ %t1762 = const 0 :: integer
1714
+ %t1763 = call core.gte(%t1761, %t1762) :: boolean
1715
+ %t1764 = call core.lt(%t1761, %t1759) :: boolean
1716
+ %t1765 = call core.and(%t1763, %t1764) :: boolean
1717
+ %t1766 = const 1 :: integer
1718
+ %t1767 = call core.sub(%t1759, %t1766) :: integer
1719
+ %t1768 = const 0 :: integer
1720
+ %t1769 = call core.clamp(%t1761, %t1768, %t1767) :: integer
1721
+ %t1770 = gather %t1758, %t1769 :: any
1722
+ %t1771 = length %t1770 :: integer
1723
+ %t1772 = call core.mod(%col_i_289, %t1771) :: integer
1724
+ %t1773 = call core.add(%t1772, %t1771) :: integer
1725
+ %t1774 = call core.mod(%t1773, %t1771) :: integer
1726
+ %t1775 = gather %t1770, %t1774 :: integer
1727
+ %t1776 = const 0 :: integer
1728
+ %t1777 = select %t1765, %t1775, %t1776 :: integer
1729
+ %t1778 = load_input "rows" :: array
1730
+ %t1779 = length %t1778 :: integer
1731
+ %t1780 = const 1 :: integer
1732
+ %t1781 = call core.sub(%rows_i_287, %t1780) :: integer
1733
+ %t1782 = const 0 :: integer
1734
+ %t1783 = call core.gte(%t1781, %t1782) :: boolean
1735
+ %t1784 = call core.lt(%t1781, %t1779) :: boolean
1736
+ %t1785 = call core.and(%t1783, %t1784) :: boolean
1737
+ %t1786 = const 1 :: integer
1738
+ %t1787 = call core.sub(%t1779, %t1786) :: integer
1739
+ %t1788 = const 0 :: integer
1740
+ %t1789 = call core.clamp(%t1781, %t1788, %t1787) :: integer
1741
+ %t1790 = gather %t1778, %t1789 :: any
1742
+ %t1791 = length %t1790 :: integer
1743
+ %t1792 = call core.mod(%col_i_289, %t1791) :: integer
1744
+ %t1793 = call core.add(%t1792, %t1791) :: integer
1745
+ %t1794 = call core.mod(%t1793, %t1791) :: integer
1746
+ %t1795 = gather %t1790, %t1794 :: integer
1747
+ %t1796 = const 0 :: integer
1748
+ %t1797 = select %t1785, %t1795, %t1796 :: integer
1749
+ %t1798 = load_input "rows" :: array
1750
+ %t1799 = length %t1798 :: integer
1751
+ %t1800 = call core.mod(%rows_i_287, %t1799) :: integer
1752
+ %t1801 = call core.add(%t1800, %t1799) :: integer
1753
+ %t1802 = call core.mod(%t1801, %t1799) :: integer
1754
+ %t1803 = gather %t1798, %t1802 :: any
1755
+ %t1804 = length %t1803 :: integer
1756
+ %t1805 = const -1 :: integer
1757
+ %t1806 = call core.sub(%col_i_289, %t1805) :: integer
1758
+ %t1807 = const 0 :: integer
1759
+ %t1808 = call core.gte(%t1806, %t1807) :: boolean
1760
+ %t1809 = call core.lt(%t1806, %t1804) :: boolean
1761
+ %t1810 = call core.and(%t1808, %t1809) :: boolean
1762
+ %t1811 = const 1 :: integer
1763
+ %t1812 = call core.sub(%t1804, %t1811) :: integer
1764
+ %t1813 = const 0 :: integer
1765
+ %t1814 = call core.clamp(%t1806, %t1813, %t1812) :: integer
1766
+ %t1815 = gather %t1803, %t1814 :: integer
1767
+ %t1816 = const 0 :: integer
1768
+ %t1817 = select %t1810, %t1815, %t1816 :: integer
1769
+ %t1818 = load_input "rows" :: array
1770
+ %t1819 = length %t1818 :: integer
1771
+ %t1820 = call core.mod(%rows_i_287, %t1819) :: integer
1772
+ %t1821 = call core.add(%t1820, %t1819) :: integer
1773
+ %t1822 = call core.mod(%t1821, %t1819) :: integer
1774
+ %t1823 = gather %t1818, %t1822 :: any
1775
+ %t1824 = length %t1823 :: integer
1776
+ %t1825 = const 1 :: integer
1804
1777
  %t1826 = call core.sub(%col_i_289, %t1825) :: integer
1805
1778
  %t1827 = const 0 :: integer
1806
1779
  %t1828 = call core.gte(%t1826, %t1827) :: boolean
1807
1780
  %t1829 = call core.lt(%t1826, %t1824) :: boolean
1808
1781
  %t1830 = call core.and(%t1828, %t1829) :: boolean
1809
- %t1831 = call core.and(%t1818, %t1830) :: boolean
1810
- %t1832 = const 1 :: integer
1811
- %t1833 = call core.sub(%t1824, %t1832) :: integer
1812
- %t1834 = const 0 :: integer
1813
- %t1835 = call core.clamp(%t1826, %t1834, %t1833) :: integer
1814
- %t1836 = Gather %t1823, %t1835 :: integer
1815
- %t1837 = const 0 :: integer
1816
- %t1838 = select %t1831, %t1836, %t1837 :: integer
1817
- %t1839 = load_input "rows" :: array
1818
- %t1840 = Length %t1839 :: integer
1819
- %t1841 = const -1 :: integer
1820
- %t1842 = call core.sub(%rows_i_287, %t1841) :: integer
1821
- %t1843 = const 0 :: integer
1822
- %t1844 = call core.gte(%t1842, %t1843) :: boolean
1823
- %t1845 = call core.lt(%t1842, %t1840) :: boolean
1824
- %t1846 = call core.and(%t1844, %t1845) :: boolean
1825
- %t1847 = const 1 :: integer
1826
- %t1848 = call core.sub(%t1840, %t1847) :: integer
1827
- %t1849 = const 0 :: integer
1828
- %t1850 = call core.clamp(%t1842, %t1849, %t1848) :: integer
1829
- %t1851 = Gather %t1839, %t1850 :: any
1830
- %t1852 = Length %t1851 :: integer
1831
- %t1853 = const 1 :: integer
1832
- %t1854 = call core.sub(%col_i_289, %t1853) :: integer
1833
- %t1855 = const 0 :: integer
1834
- %t1856 = call core.gte(%t1854, %t1855) :: boolean
1835
- %t1857 = call core.lt(%t1854, %t1852) :: boolean
1836
- %t1858 = call core.and(%t1856, %t1857) :: boolean
1837
- %t1859 = call core.and(%t1846, %t1858) :: boolean
1838
- %t1860 = const 1 :: integer
1839
- %t1861 = call core.sub(%t1852, %t1860) :: integer
1840
- %t1862 = const 0 :: integer
1841
- %t1863 = call core.clamp(%t1854, %t1862, %t1861) :: integer
1842
- %t1864 = Gather %t1851, %t1863 :: integer
1843
- %t1865 = const 0 :: integer
1844
- %t1866 = select %t1859, %t1864, %t1865 :: integer
1845
- %t1867 = load_input "rows" :: array
1846
- %t1868 = Length %t1867 :: integer
1847
- %t1869 = const 1 :: integer
1848
- %t1870 = call core.sub(%rows_i_287, %t1869) :: integer
1849
- %t1871 = const 0 :: integer
1850
- %t1872 = call core.gte(%t1870, %t1871) :: boolean
1851
- %t1873 = call core.lt(%t1870, %t1868) :: boolean
1852
- %t1874 = call core.and(%t1872, %t1873) :: boolean
1853
- %t1875 = const 1 :: integer
1854
- %t1876 = call core.sub(%t1868, %t1875) :: integer
1855
- %t1877 = const 0 :: integer
1856
- %t1878 = call core.clamp(%t1870, %t1877, %t1876) :: integer
1857
- %t1879 = Gather %t1867, %t1878 :: any
1858
- %t1880 = Length %t1879 :: integer
1859
- %t1881 = const -1 :: integer
1860
- %t1882 = call core.sub(%col_i_289, %t1881) :: integer
1861
- %t1883 = const 0 :: integer
1862
- %t1884 = call core.gte(%t1882, %t1883) :: boolean
1863
- %t1885 = call core.lt(%t1882, %t1880) :: boolean
1864
- %t1886 = call core.and(%t1884, %t1885) :: boolean
1865
- %t1887 = call core.and(%t1874, %t1886) :: boolean
1866
- %t1888 = const 1 :: integer
1867
- %t1889 = call core.sub(%t1880, %t1888) :: integer
1868
- %t1890 = const 0 :: integer
1869
- %t1891 = call core.clamp(%t1882, %t1890, %t1889) :: integer
1870
- %t1892 = Gather %t1879, %t1891 :: integer
1871
- %t1893 = const 0 :: integer
1872
- %t1894 = select %t1887, %t1892, %t1893 :: integer
1873
- %t1895 = load_input "rows" :: array
1874
- %t1896 = Length %t1895 :: integer
1875
- %t1897 = const 1 :: integer
1876
- %t1898 = call core.sub(%rows_i_287, %t1897) :: integer
1877
- %t1899 = const 0 :: integer
1878
- %t1900 = call core.gte(%t1898, %t1899) :: boolean
1879
- %t1901 = call core.lt(%t1898, %t1896) :: boolean
1880
- %t1902 = call core.and(%t1900, %t1901) :: boolean
1881
- %t1903 = const 1 :: integer
1882
- %t1904 = call core.sub(%t1896, %t1903) :: integer
1883
- %t1905 = const 0 :: integer
1884
- %t1906 = call core.clamp(%t1898, %t1905, %t1904) :: integer
1885
- %t1907 = Gather %t1895, %t1906 :: any
1886
- %t1908 = Length %t1907 :: integer
1887
- %t1909 = const 1 :: integer
1888
- %t1910 = call core.sub(%col_i_289, %t1909) :: integer
1889
- %t1911 = const 0 :: integer
1890
- %t1912 = call core.gte(%t1910, %t1911) :: boolean
1891
- %t1913 = call core.lt(%t1910, %t1908) :: boolean
1892
- %t1914 = call core.and(%t1912, %t1913) :: boolean
1893
- %t1915 = call core.and(%t1902, %t1914) :: boolean
1894
- %t1916 = const 1 :: integer
1895
- %t1917 = call core.sub(%t1908, %t1916) :: integer
1896
- %t1918 = const 0 :: integer
1897
- %t1919 = call core.clamp(%t1910, %t1918, %t1917) :: integer
1898
- %t1920 = Gather %t1907, %t1919 :: integer
1899
- %t1921 = const 0 :: integer
1900
- %t1922 = select %t1915, %t1920, %t1921 :: integer
1901
- %t1923 = make_tuple(%t1750, %t1770, %t1790, %t1810, %t1838, %t1866, %t1894, %t1922) :: tuple<integer>
1902
- %t1924 = Fold %t1923 fn="agg.sum" ::
1903
- %t1339 = const 2 :: integer
1904
- %t1340 = call core.eq(%t1924, %t1339) :: boolean
1905
- %t1341 = load_input "rows" :: array
1906
- %t1925 = load_input "rows" :: array
1907
- %t1343 = const 0 :: integer
1908
- %t1344 = call core.gt(%col_el_288, %t1343) :: boolean
1909
- %t1345 = call core.and(%t1340, %t1344) :: boolean
1910
- %t528 = call core.or(%t1335, %t1345) :: boolean
1782
+ %t1831 = const 1 :: integer
1783
+ %t1832 = call core.sub(%t1824, %t1831) :: integer
1784
+ %t1833 = const 0 :: integer
1785
+ %t1834 = call core.clamp(%t1826, %t1833, %t1832) :: integer
1786
+ %t1835 = gather %t1823, %t1834 :: integer
1787
+ %t1836 = const 0 :: integer
1788
+ %t1837 = select %t1830, %t1835, %t1836 :: integer
1789
+ %t1838 = load_input "rows" :: array
1790
+ %t1839 = length %t1838 :: integer
1791
+ %t1840 = const -1 :: integer
1792
+ %t1841 = call core.sub(%rows_i_287, %t1840) :: integer
1793
+ %t1842 = const 0 :: integer
1794
+ %t1843 = call core.gte(%t1841, %t1842) :: boolean
1795
+ %t1844 = call core.lt(%t1841, %t1839) :: boolean
1796
+ %t1845 = call core.and(%t1843, %t1844) :: boolean
1797
+ %t1846 = const 1 :: integer
1798
+ %t1847 = call core.sub(%t1839, %t1846) :: integer
1799
+ %t1848 = const 0 :: integer
1800
+ %t1849 = call core.clamp(%t1841, %t1848, %t1847) :: integer
1801
+ %t1850 = gather %t1838, %t1849 :: any
1802
+ %t1851 = length %t1850 :: integer
1803
+ %t1852 = const -1 :: integer
1804
+ %t1853 = call core.sub(%col_i_289, %t1852) :: integer
1805
+ %t1854 = const 0 :: integer
1806
+ %t1855 = call core.gte(%t1853, %t1854) :: boolean
1807
+ %t1856 = call core.lt(%t1853, %t1851) :: boolean
1808
+ %t1857 = call core.and(%t1855, %t1856) :: boolean
1809
+ %t1858 = call core.and(%t1845, %t1857) :: boolean
1810
+ %t1859 = const 1 :: integer
1811
+ %t1860 = call core.sub(%t1851, %t1859) :: integer
1812
+ %t1861 = const 0 :: integer
1813
+ %t1862 = call core.clamp(%t1853, %t1861, %t1860) :: integer
1814
+ %t1863 = gather %t1850, %t1862 :: integer
1815
+ %t1864 = const 0 :: integer
1816
+ %t1865 = select %t1858, %t1863, %t1864 :: integer
1817
+ %t1866 = load_input "rows" :: array
1818
+ %t1867 = length %t1866 :: integer
1819
+ %t1868 = const -1 :: integer
1820
+ %t1869 = call core.sub(%rows_i_287, %t1868) :: integer
1821
+ %t1870 = const 0 :: integer
1822
+ %t1871 = call core.gte(%t1869, %t1870) :: boolean
1823
+ %t1872 = call core.lt(%t1869, %t1867) :: boolean
1824
+ %t1873 = call core.and(%t1871, %t1872) :: boolean
1825
+ %t1874 = const 1 :: integer
1826
+ %t1875 = call core.sub(%t1867, %t1874) :: integer
1827
+ %t1876 = const 0 :: integer
1828
+ %t1877 = call core.clamp(%t1869, %t1876, %t1875) :: integer
1829
+ %t1878 = gather %t1866, %t1877 :: any
1830
+ %t1879 = length %t1878 :: integer
1831
+ %t1880 = const 1 :: integer
1832
+ %t1881 = call core.sub(%col_i_289, %t1880) :: integer
1833
+ %t1882 = const 0 :: integer
1834
+ %t1883 = call core.gte(%t1881, %t1882) :: boolean
1835
+ %t1884 = call core.lt(%t1881, %t1879) :: boolean
1836
+ %t1885 = call core.and(%t1883, %t1884) :: boolean
1837
+ %t1886 = call core.and(%t1873, %t1885) :: boolean
1838
+ %t1887 = const 1 :: integer
1839
+ %t1888 = call core.sub(%t1879, %t1887) :: integer
1840
+ %t1889 = const 0 :: integer
1841
+ %t1890 = call core.clamp(%t1881, %t1889, %t1888) :: integer
1842
+ %t1891 = gather %t1878, %t1890 :: integer
1843
+ %t1892 = const 0 :: integer
1844
+ %t1893 = select %t1886, %t1891, %t1892 :: integer
1845
+ %t1894 = load_input "rows" :: array
1846
+ %t1895 = length %t1894 :: integer
1847
+ %t1896 = const 1 :: integer
1848
+ %t1897 = call core.sub(%rows_i_287, %t1896) :: integer
1849
+ %t1898 = const 0 :: integer
1850
+ %t1899 = call core.gte(%t1897, %t1898) :: boolean
1851
+ %t1900 = call core.lt(%t1897, %t1895) :: boolean
1852
+ %t1901 = call core.and(%t1899, %t1900) :: boolean
1853
+ %t1902 = const 1 :: integer
1854
+ %t1903 = call core.sub(%t1895, %t1902) :: integer
1855
+ %t1904 = const 0 :: integer
1856
+ %t1905 = call core.clamp(%t1897, %t1904, %t1903) :: integer
1857
+ %t1906 = gather %t1894, %t1905 :: any
1858
+ %t1907 = length %t1906 :: integer
1859
+ %t1908 = const -1 :: integer
1860
+ %t1909 = call core.sub(%col_i_289, %t1908) :: integer
1861
+ %t1910 = const 0 :: integer
1862
+ %t1911 = call core.gte(%t1909, %t1910) :: boolean
1863
+ %t1912 = call core.lt(%t1909, %t1907) :: boolean
1864
+ %t1913 = call core.and(%t1911, %t1912) :: boolean
1865
+ %t1914 = call core.and(%t1901, %t1913) :: boolean
1866
+ %t1915 = const 1 :: integer
1867
+ %t1916 = call core.sub(%t1907, %t1915) :: integer
1868
+ %t1917 = const 0 :: integer
1869
+ %t1918 = call core.clamp(%t1909, %t1917, %t1916) :: integer
1870
+ %t1919 = gather %t1906, %t1918 :: integer
1871
+ %t1920 = const 0 :: integer
1872
+ %t1921 = select %t1914, %t1919, %t1920 :: integer
1873
+ %t1922 = load_input "rows" :: array
1874
+ %t1923 = length %t1922 :: integer
1875
+ %t1924 = const 1 :: integer
1876
+ %t1925 = call core.sub(%rows_i_287, %t1924) :: integer
1877
+ %t1926 = const 0 :: integer
1878
+ %t1927 = call core.gte(%t1925, %t1926) :: boolean
1879
+ %t1928 = call core.lt(%t1925, %t1923) :: boolean
1880
+ %t1929 = call core.and(%t1927, %t1928) :: boolean
1881
+ %t1930 = const 1 :: integer
1882
+ %t1931 = call core.sub(%t1923, %t1930) :: integer
1883
+ %t1932 = const 0 :: integer
1884
+ %t1933 = call core.clamp(%t1925, %t1932, %t1931) :: integer
1885
+ %t1934 = gather %t1922, %t1933 :: any
1886
+ %t1935 = length %t1934 :: integer
1887
+ %t1936 = const 1 :: integer
1888
+ %t1937 = call core.sub(%col_i_289, %t1936) :: integer
1889
+ %t1938 = const 0 :: integer
1890
+ %t1939 = call core.gte(%t1937, %t1938) :: boolean
1891
+ %t1940 = call core.lt(%t1937, %t1935) :: boolean
1892
+ %t1941 = call core.and(%t1939, %t1940) :: boolean
1893
+ %t1942 = call core.and(%t1929, %t1941) :: boolean
1894
+ %t1943 = const 1 :: integer
1895
+ %t1944 = call core.sub(%t1935, %t1943) :: integer
1896
+ %t1945 = const 0 :: integer
1897
+ %t1946 = call core.clamp(%t1937, %t1945, %t1944) :: integer
1898
+ %t1947 = gather %t1934, %t1946 :: integer
1899
+ %t1948 = const 0 :: integer
1900
+ %t1949 = select %t1942, %t1947, %t1948 :: integer
1901
+ %t1756 = make_tuple(%t1777, %t1797, %t1817, %t1837, %t1865, %t1893, %t1921, %t1949) :: tuple<integer>
1902
+ %t1757 = fold %t1756 fn="agg.sum" ::
1903
+ %t1745 = const 2 :: integer
1904
+ %t1746 = call core.eq(%t1757, %t1745) :: boolean
1905
+ %t1950 = load_input "rows" :: array
1906
+ %t1954 = load_input "rows" :: array
1907
+ %t1952 = const 0 :: integer
1908
+ %t1953 = call core.gt(%col_el_288, %t1952) :: boolean
1909
+ %t1742 = call core.and(%t1746, %t1953) :: boolean
1910
+ %t1531 = call core.or(%t1535, %t1742) :: boolean
1911
1911
  %t291 = const 1 :: integer
1912
1912
  %t292 = const 0 :: integer
1913
- %t293 = select %t528, %t291, %t292 :: integer
1913
+ %t293 = select %t1531, %t291, %t292 :: integer
1914
1914
  yield %t293
1915
1915
  end_loop
1916
1916
  end_loop