kumi 0.0.24 → 0.0.26

data/golden/game_of_life/expected/lir_04_loop_invcm.txt

@@ -299,8 +299,8 @@
         %t482 = call core.clamp(%t362, %t298, %t452) :: integer
         %t483 = gather %t326, %t482 :: integer
         %t485 = select %t478, %t483, %t298 :: integer
-        %t243 = make_tuple(%t313, %t333, %t353, %t373, %t401, %t429, %t457, %t485) :: tuple<integer>
-        %t244 = fold %t243 fn="agg.sum" :: 
+        %t243 = make_tuple(%t313, %t333, %t353, %t373, %t401, %t429, %t457, %t485) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t244 = fold %t243 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
         yield %t244
       end_loop
     end_loop
@@ -317,86 +317,86 @@
   )
   (Declaration n3_alive
     %t253 = load_input "rows" :: array
-    %t530 = length %t253 :: integer
-    %t531 = const -1 :: integer
-    %t533 = const 0 :: integer
-    %t537 = const 1 :: integer
+    %t499 = length %t253 :: integer
+    %t500 = const -1 :: integer
+    %t502 = const 0 :: integer
+    %t506 = const 1 :: integer
     %t259 = const 3 :: integer
-    %t538 = call core.sub(%t530, %t537) :: integer
+    %t507 = call core.sub(%t499, %t506) :: integer
     loop rows id=L23 in %t253 as el=%rows_el_254, idx=%rows_i_255
-      %t532 = call core.sub(%rows_i_255, %t531) :: integer
-      %t552 = call core.sub(%rows_i_255, %t537) :: integer
-      %t571 = call core.mod(%rows_i_255, %t530) :: integer
-      %t534 = call core.gte(%t532, %t533) :: boolean
-      %t535 = call core.lt(%t532, %t530) :: boolean
-      %t540 = call core.clamp(%t532, %t533, %t538) :: integer
-      %t554 = call core.gte(%t552, %t533) :: boolean
-      %t555 = call core.lt(%t552, %t530) :: boolean
-      %t560 = call core.clamp(%t552, %t533, %t538) :: integer
-      %t572 = call core.add(%t571, %t530) :: integer
-      %t536 = call core.and(%t534, %t535) :: boolean
-      %t541 = gather %t253, %t540 :: any
-      %t556 = call core.and(%t554, %t555) :: boolean
-      %t561 = gather %t253, %t560 :: any
-      %t573 = call core.mod(%t572, %t530) :: integer
-      %t542 = length %t541 :: integer
-      %t562 = length %t561 :: integer
-      %t574 = gather %t253, %t573 :: any
-      %t575 = length %t574 :: integer
-      %t631 = call core.sub(%t542, %t537) :: integer
-      %t687 = call core.sub(%t562, %t537) :: integer
-      %t583 = call core.sub(%t575, %t537) :: integer
+      %t501 = call core.sub(%rows_i_255, %t500) :: integer
+      %t521 = call core.sub(%rows_i_255, %t506) :: integer
+      %t540 = call core.mod(%rows_i_255, %t499) :: integer
+      %t503 = call core.gte(%t501, %t502) :: boolean
+      %t504 = call core.lt(%t501, %t499) :: boolean
+      %t509 = call core.clamp(%t501, %t502, %t507) :: integer
+      %t523 = call core.gte(%t521, %t502) :: boolean
+      %t524 = call core.lt(%t521, %t499) :: boolean
+      %t529 = call core.clamp(%t521, %t502, %t507) :: integer
+      %t541 = call core.add(%t540, %t499) :: integer
+      %t505 = call core.and(%t503, %t504) :: boolean
+      %t510 = gather %t253, %t509 :: any
+      %t525 = call core.and(%t523, %t524) :: boolean
+      %t530 = gather %t253, %t529 :: any
+      %t542 = call core.mod(%t541, %t499) :: integer
+      %t511 = length %t510 :: integer
+      %t531 = length %t530 :: integer
+      %t543 = gather %t253, %t542 :: any
+      %t544 = length %t543 :: integer
+      %t600 = call core.sub(%t511, %t506) :: integer
+      %t656 = call core.sub(%t531, %t506) :: integer
+      %t552 = call core.sub(%t544, %t506) :: integer
       loop col id=L24 in %rows_el_254 as el=%col_el_256, idx=%col_i_257
-        %t543 = call core.mod(%col_i_257, %t542) :: integer
-        %t544 = call core.add(%t543, %t542) :: integer
-        %t545 = call core.mod(%t544, %t542) :: integer
-        %t546 = gather %t541, %t545 :: integer
-        %t548 = select %t536, %t546, %t533 :: integer
-        %t563 = call core.mod(%col_i_257, %t562) :: integer
-        %t564 = call core.add(%t563, %t562) :: integer
-        %t565 = call core.mod(%t564, %t562) :: integer
-        %t566 = gather %t561, %t565 :: integer
-        %t568 = select %t556, %t566, %t533 :: integer
-        %t577 = call core.sub(%col_i_257, %t531) :: integer
-        %t579 = call core.gte(%t577, %t533) :: boolean
-        %t580 = call core.lt(%t577, %t575) :: boolean
-        %t581 = call core.and(%t579, %t580) :: boolean
-        %t585 = call core.clamp(%t577, %t533, %t583) :: integer
-        %t586 = gather %t574, %t585 :: integer
-        %t588 = select %t581, %t586, %t533 :: integer
-        %t597 = call core.sub(%col_i_257, %t537) :: integer
-        %t599 = call core.gte(%t597, %t533) :: boolean
-        %t600 = call core.lt(%t597, %t575) :: boolean
-        %t601 = call core.and(%t599, %t600) :: boolean
-        %t605 = call core.clamp(%t597, %t533, %t583) :: integer
-        %t606 = gather %t574, %t605 :: integer
-        %t608 = select %t601, %t606, %t533 :: integer
-        %t627 = call core.lt(%t577, %t542) :: boolean
-        %t628 = call core.and(%t579, %t627) :: boolean
-        %t629 = call core.and(%t536, %t628) :: boolean
-        %t633 = call core.clamp(%t577, %t533, %t631) :: integer
-        %t634 = gather %t541, %t633 :: integer
-        %t636 = select %t629, %t634, %t533 :: integer
-        %t655 = call core.lt(%t597, %t542) :: boolean
-        %t656 = call core.and(%t599, %t655) :: boolean
-        %t657 = call core.and(%t536, %t656) :: boolean
-        %t661 = call core.clamp(%t597, %t533, %t631) :: integer
-        %t662 = gather %t541, %t661 :: integer
-        %t664 = select %t657, %t662, %t533 :: integer
-        %t683 = call core.lt(%t577, %t562) :: boolean
-        %t684 = call core.and(%t579, %t683) :: boolean
-        %t685 = call core.and(%t556, %t684) :: boolean
-        %t689 = call core.clamp(%t577, %t533, %t687) :: integer
-        %t690 = gather %t561, %t689 :: integer
-        %t692 = select %t685, %t690, %t533 :: integer
-        %t711 = call core.lt(%t597, %t562) :: boolean
-        %t712 = call core.and(%t599, %t711) :: boolean
-        %t713 = call core.and(%t556, %t712) :: boolean
-        %t717 = call core.clamp(%t597, %t533, %t687) :: integer
-        %t718 = gather %t561, %t717 :: integer
-        %t720 = select %t713, %t718, %t533 :: integer
-        %t496 = make_tuple(%t548, %t568, %t588, %t608, %t636, %t664, %t692, %t720) :: tuple<integer>
-        %t497 = fold %t496 fn="agg.sum" :: 
+        %t512 = call core.mod(%col_i_257, %t511) :: integer
+        %t513 = call core.add(%t512, %t511) :: integer
+        %t514 = call core.mod(%t513, %t511) :: integer
+        %t515 = gather %t510, %t514 :: integer
+        %t517 = select %t505, %t515, %t502 :: integer
+        %t532 = call core.mod(%col_i_257, %t531) :: integer
+        %t533 = call core.add(%t532, %t531) :: integer
+        %t534 = call core.mod(%t533, %t531) :: integer
+        %t535 = gather %t530, %t534 :: integer
+        %t537 = select %t525, %t535, %t502 :: integer
+        %t546 = call core.sub(%col_i_257, %t500) :: integer
+        %t548 = call core.gte(%t546, %t502) :: boolean
+        %t549 = call core.lt(%t546, %t544) :: boolean
+        %t550 = call core.and(%t548, %t549) :: boolean
+        %t554 = call core.clamp(%t546, %t502, %t552) :: integer
+        %t555 = gather %t543, %t554 :: integer
+        %t557 = select %t550, %t555, %t502 :: integer
+        %t566 = call core.sub(%col_i_257, %t506) :: integer
+        %t568 = call core.gte(%t566, %t502) :: boolean
+        %t569 = call core.lt(%t566, %t544) :: boolean
+        %t570 = call core.and(%t568, %t569) :: boolean
+        %t574 = call core.clamp(%t566, %t502, %t552) :: integer
+        %t575 = gather %t543, %t574 :: integer
+        %t577 = select %t570, %t575, %t502 :: integer
+        %t596 = call core.lt(%t546, %t511) :: boolean
+        %t597 = call core.and(%t548, %t596) :: boolean
+        %t598 = call core.and(%t505, %t597) :: boolean
+        %t602 = call core.clamp(%t546, %t502, %t600) :: integer
+        %t603 = gather %t510, %t602 :: integer
+        %t605 = select %t598, %t603, %t502 :: integer
+        %t624 = call core.lt(%t566, %t511) :: boolean
+        %t625 = call core.and(%t568, %t624) :: boolean
+        %t626 = call core.and(%t505, %t625) :: boolean
+        %t630 = call core.clamp(%t566, %t502, %t600) :: integer
+        %t631 = gather %t510, %t630 :: integer
+        %t633 = select %t626, %t631, %t502 :: integer
+        %t652 = call core.lt(%t546, %t531) :: boolean
+        %t653 = call core.and(%t548, %t652) :: boolean
+        %t654 = call core.and(%t525, %t653) :: boolean
+        %t658 = call core.clamp(%t546, %t502, %t656) :: integer
+        %t659 = gather %t530, %t658 :: integer
+        %t661 = select %t654, %t659, %t502 :: integer
+        %t680 = call core.lt(%t566, %t531) :: boolean
+        %t681 = call core.and(%t568, %t680) :: boolean
+        %t682 = call core.and(%t525, %t681) :: boolean
+        %t686 = call core.clamp(%t566, %t502, %t656) :: integer
+        %t687 = gather %t530, %t686 :: integer
+        %t689 = select %t682, %t687, %t502 :: integer
+        %t496 = make_tuple(%t517, %t537, %t557, %t577, %t605, %t633, %t661, %t689) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t497 = fold %t496 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
         %t260 = call core.eq(%t497, %t259) :: boolean
         yield %t260
       end_loop
@@ -404,361 +404,365 @@
   )
   (Declaration n2_alive
     %t261 = load_input "rows" :: array
-    %t722 = length %t261 :: integer
-    %t723 = const -1 :: integer
-    %t725 = const 0 :: integer
-    %t729 = const 1 :: integer
+    %t702 = length %t261 :: integer
+    %t703 = const -1 :: integer
+    %t705 = const 0 :: integer
+    %t709 = const 1 :: integer
     %t267 = const 2 :: integer
-    %t730 = call core.sub(%t722, %t729) :: integer
+    %t710 = call core.sub(%t702, %t709) :: integer
     loop rows id=L25 in %t261 as el=%rows_el_262, idx=%rows_i_263
-      %t724 = call core.sub(%rows_i_263, %t723) :: integer
-      %t744 = call core.sub(%rows_i_263, %t729) :: integer
-      %t763 = call core.mod(%rows_i_263, %t722) :: integer
-      %t726 = call core.gte(%t724, %t725) :: boolean
-      %t727 = call core.lt(%t724, %t722) :: boolean
-      %t732 = call core.clamp(%t724, %t725, %t730) :: integer
-      %t746 = call core.gte(%t744, %t725) :: boolean
-      %t747 = call core.lt(%t744, %t722) :: boolean
-      %t752 = call core.clamp(%t744, %t725, %t730) :: integer
-      %t764 = call core.add(%t763, %t722) :: integer
+      %t704 = call core.sub(%rows_i_263, %t703) :: integer
+      %t724 = call core.sub(%rows_i_263, %t709) :: integer
+      %t743 = call core.mod(%rows_i_263, %t702) :: integer
+      %t706 = call core.gte(%t704, %t705) :: boolean
+      %t707 = call core.lt(%t704, %t702) :: boolean
+      %t712 = call core.clamp(%t704, %t705, %t710) :: integer
+      %t726 = call core.gte(%t724, %t705) :: boolean
+      %t727 = call core.lt(%t724, %t702) :: boolean
+      %t732 = call core.clamp(%t724, %t705, %t710) :: integer
+      %t744 = call core.add(%t743, %t702) :: integer
+      %t708 = call core.and(%t706, %t707) :: boolean
+      %t713 = gather %t261, %t712 :: any
       %t728 = call core.and(%t726, %t727) :: boolean
       %t733 = gather %t261, %t732 :: any
-      %t748 = call core.and(%t746, %t747) :: boolean
-      %t753 = gather %t261, %t752 :: any
-      %t765 = call core.mod(%t764, %t722) :: integer
+      %t745 = call core.mod(%t744, %t702) :: integer
+      %t714 = length %t713 :: integer
       %t734 = length %t733 :: integer
-      %t754 = length %t753 :: integer
-      %t766 = gather %t261, %t765 :: any
-      %t767 = length %t766 :: integer
-      %t823 = call core.sub(%t734, %t729) :: integer
-      %t879 = call core.sub(%t754, %t729) :: integer
-      %t775 = call core.sub(%t767, %t729) :: integer
+      %t746 = gather %t261, %t745 :: any
+      %t747 = length %t746 :: integer
+      %t803 = call core.sub(%t714, %t709) :: integer
+      %t859 = call core.sub(%t734, %t709) :: integer
+      %t755 = call core.sub(%t747, %t709) :: integer
       loop col id=L26 in %rows_el_262 as el=%col_el_264, idx=%col_i_265
+        %t715 = call core.mod(%col_i_265, %t714) :: integer
+        %t716 = call core.add(%t715, %t714) :: integer
+        %t717 = call core.mod(%t716, %t714) :: integer
+        %t718 = gather %t713, %t717 :: integer
+        %t720 = select %t708, %t718, %t705 :: integer
         %t735 = call core.mod(%col_i_265, %t734) :: integer
         %t736 = call core.add(%t735, %t734) :: integer
         %t737 = call core.mod(%t736, %t734) :: integer
         %t738 = gather %t733, %t737 :: integer
-        %t740 = select %t728, %t738, %t725 :: integer
-        %t755 = call core.mod(%col_i_265, %t754) :: integer
-        %t756 = call core.add(%t755, %t754) :: integer
-        %t757 = call core.mod(%t756, %t754) :: integer
-        %t758 = gather %t753, %t757 :: integer
-        %t760 = select %t748, %t758, %t725 :: integer
-        %t769 = call core.sub(%col_i_265, %t723) :: integer
-        %t771 = call core.gte(%t769, %t725) :: boolean
-        %t772 = call core.lt(%t769, %t767) :: boolean
+        %t740 = select %t728, %t738, %t705 :: integer
+        %t749 = call core.sub(%col_i_265, %t703) :: integer
+        %t751 = call core.gte(%t749, %t705) :: boolean
+        %t752 = call core.lt(%t749, %t747) :: boolean
+        %t753 = call core.and(%t751, %t752) :: boolean
+        %t757 = call core.clamp(%t749, %t705, %t755) :: integer
+        %t758 = gather %t746, %t757 :: integer
+        %t760 = select %t753, %t758, %t705 :: integer
+        %t769 = call core.sub(%col_i_265, %t709) :: integer
+        %t771 = call core.gte(%t769, %t705) :: boolean
+        %t772 = call core.lt(%t769, %t747) :: boolean
         %t773 = call core.and(%t771, %t772) :: boolean
-        %t777 = call core.clamp(%t769, %t725, %t775) :: integer
-        %t778 = gather %t766, %t777 :: integer
-        %t780 = select %t773, %t778, %t725 :: integer
-        %t789 = call core.sub(%col_i_265, %t729) :: integer
-        %t791 = call core.gte(%t789, %t725) :: boolean
-        %t792 = call core.lt(%t789, %t767) :: boolean
-        %t793 = call core.and(%t791, %t792) :: boolean
-        %t797 = call core.clamp(%t789, %t725, %t775) :: integer
-        %t798 = gather %t766, %t797 :: integer
-        %t800 = select %t793, %t798, %t725 :: integer
-        %t819 = call core.lt(%t769, %t734) :: boolean
-        %t820 = call core.and(%t771, %t819) :: boolean
-        %t821 = call core.and(%t728, %t820) :: boolean
-        %t825 = call core.clamp(%t769, %t725, %t823) :: integer
-        %t826 = gather %t733, %t825 :: integer
-        %t828 = select %t821, %t826, %t725 :: integer
-        %t847 = call core.lt(%t789, %t734) :: boolean
-        %t848 = call core.and(%t791, %t847) :: boolean
-        %t849 = call core.and(%t728, %t848) :: boolean
-        %t853 = call core.clamp(%t789, %t725, %t823) :: integer
-        %t854 = gather %t733, %t853 :: integer
-        %t856 = select %t849, %t854, %t725 :: integer
-        %t875 = call core.lt(%t769, %t754) :: boolean
-        %t876 = call core.and(%t771, %t875) :: boolean
-        %t877 = call core.and(%t748, %t876) :: boolean
-        %t881 = call core.clamp(%t769, %t725, %t879) :: integer
-        %t882 = gather %t753, %t881 :: integer
-        %t884 = select %t877, %t882, %t725 :: integer
-        %t903 = call core.lt(%t789, %t754) :: boolean
-        %t904 = call core.and(%t791, %t903) :: boolean
-        %t905 = call core.and(%t748, %t904) :: boolean
-        %t909 = call core.clamp(%t789, %t725, %t879) :: integer
-        %t910 = gather %t753, %t909 :: integer
-        %t912 = select %t905, %t910, %t725 :: integer
-        %t507 = make_tuple(%t740, %t760, %t780, %t800, %t828, %t856, %t884, %t912) :: tuple<integer>
-        %t508 = fold %t507 fn="agg.sum" :: 
-        %t268 = call core.eq(%t508, %t267) :: boolean
+        %t777 = call core.clamp(%t769, %t705, %t755) :: integer
+        %t778 = gather %t746, %t777 :: integer
+        %t780 = select %t773, %t778, %t705 :: integer
+        %t799 = call core.lt(%t749, %t714) :: boolean
+        %t800 = call core.and(%t751, %t799) :: boolean
+        %t801 = call core.and(%t708, %t800) :: boolean
+        %t805 = call core.clamp(%t749, %t705, %t803) :: integer
+        %t806 = gather %t713, %t805 :: integer
+        %t808 = select %t801, %t806, %t705 :: integer
+        %t827 = call core.lt(%t769, %t714) :: boolean
+        %t828 = call core.and(%t771, %t827) :: boolean
+        %t829 = call core.and(%t708, %t828) :: boolean
+        %t833 = call core.clamp(%t769, %t705, %t803) :: integer
+        %t834 = gather %t713, %t833 :: integer
+        %t836 = select %t829, %t834, %t705 :: integer
+        %t855 = call core.lt(%t749, %t734) :: boolean
+        %t856 = call core.and(%t751, %t855) :: boolean
+        %t857 = call core.and(%t728, %t856) :: boolean
+        %t861 = call core.clamp(%t749, %t705, %t859) :: integer
+        %t862 = gather %t733, %t861 :: integer
+        %t864 = select %t857, %t862, %t705 :: integer
+        %t883 = call core.lt(%t769, %t734) :: boolean
+        %t884 = call core.and(%t771, %t883) :: boolean
+        %t885 = call core.and(%t728, %t884) :: boolean
+        %t889 = call core.clamp(%t769, %t705, %t859) :: integer
+        %t890 = gather %t733, %t889 :: integer
+        %t892 = select %t885, %t890, %t705 :: integer
+        %t699 = make_tuple(%t720, %t740, %t760, %t780, %t808, %t836, %t864, %t892) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t700 = fold %t699 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t268 = call core.eq(%t700, %t267) :: boolean
         yield %t268
       end_loop
     end_loop
   )
   (Declaration keep_alive
     %t269 = load_input "rows" :: array
-    %t915 = length %t269 :: integer
-    %t916 = const -1 :: integer
-    %t918 = const 0 :: integer
-    %t922 = const 1 :: integer
-    %t511 = const 2 :: integer
-    %t923 = call core.sub(%t915, %t922) :: integer
+    %t909 = length %t269 :: integer
+    %t910 = const -1 :: integer
+    %t912 = const 0 :: integer
+    %t916 = const 1 :: integer
+    %t895 = const 2 :: integer
+    %t1102 = const 0 :: integer
+    %t917 = call core.sub(%t909, %t916) :: integer
     loop rows id=L27 in %t269 as el=%rows_el_270, idx=%rows_i_271
-      %t917 = call core.sub(%rows_i_271, %t916) :: integer
-      %t937 = call core.sub(%rows_i_271, %t922) :: integer
-      %t956 = call core.mod(%rows_i_271, %t915) :: integer
-      %t919 = call core.gte(%t917, %t918) :: boolean
-      %t920 = call core.lt(%t917, %t915) :: boolean
-      %t925 = call core.clamp(%t917, %t918, %t923) :: integer
-      %t939 = call core.gte(%t937, %t918) :: boolean
-      %t940 = call core.lt(%t937, %t915) :: boolean
-      %t945 = call core.clamp(%t937, %t918, %t923) :: integer
-      %t957 = call core.add(%t956, %t915) :: integer
-      %t921 = call core.and(%t919, %t920) :: boolean
-      %t926 = gather %t269, %t925 :: any
-      %t941 = call core.and(%t939, %t940) :: boolean
-      %t946 = gather %t269, %t945 :: any
-      %t958 = call core.mod(%t957, %t915) :: integer
-      %t927 = length %t926 :: integer
-      %t947 = length %t946 :: integer
-      %t959 = gather %t269, %t958 :: any
-      %t960 = length %t959 :: integer
-      %t1016 = call core.sub(%t927, %t922) :: integer
-      %t1072 = call core.sub(%t947, %t922) :: integer
-      %t968 = call core.sub(%t960, %t922) :: integer
+      %t911 = call core.sub(%rows_i_271, %t910) :: integer
+      %t931 = call core.sub(%rows_i_271, %t916) :: integer
+      %t950 = call core.mod(%rows_i_271, %t909) :: integer
+      %t913 = call core.gte(%t911, %t912) :: boolean
+      %t914 = call core.lt(%t911, %t909) :: boolean
+      %t919 = call core.clamp(%t911, %t912, %t917) :: integer
+      %t933 = call core.gte(%t931, %t912) :: boolean
+      %t934 = call core.lt(%t931, %t909) :: boolean
+      %t939 = call core.clamp(%t931, %t912, %t917) :: integer
+      %t951 = call core.add(%t950, %t909) :: integer
+      %t915 = call core.and(%t913, %t914) :: boolean
+      %t920 = gather %t269, %t919 :: any
+      %t935 = call core.and(%t933, %t934) :: boolean
+      %t940 = gather %t269, %t939 :: any
+      %t952 = call core.mod(%t951, %t909) :: integer
+      %t921 = length %t920 :: integer
+      %t941 = length %t940 :: integer
+      %t953 = gather %t269, %t952 :: any
+      %t954 = length %t953 :: integer
+      %t1010 = call core.sub(%t921, %t916) :: integer
+      %t1066 = call core.sub(%t941, %t916) :: integer
+      %t962 = call core.sub(%t954, %t916) :: integer
       loop col id=L28 in %rows_el_270 as el=%col_el_272, idx=%col_i_273
-        %t928 = call core.mod(%col_i_273, %t927) :: integer
-        %t929 = call core.add(%t928, %t927) :: integer
-        %t930 = call core.mod(%t929, %t927) :: integer
-        %t931 = gather %t926, %t930 :: integer
-        %t933 = select %t921, %t931, %t918 :: integer
-        %t948 = call core.mod(%col_i_273, %t947) :: integer
-        %t949 = call core.add(%t948, %t947) :: integer
-        %t950 = call core.mod(%t949, %t947) :: integer
-        %t951 = gather %t946, %t950 :: integer
-        %t953 = select %t941, %t951, %t918 :: integer
-        %t962 = call core.sub(%col_i_273, %t916) :: integer
-        %t964 = call core.gte(%t962, %t918) :: boolean
-        %t965 = call core.lt(%t962, %t960) :: boolean
-        %t966 = call core.and(%t964, %t965) :: boolean
-        %t970 = call core.clamp(%t962, %t918, %t968) :: integer
-        %t971 = gather %t959, %t970 :: integer
-        %t973 = select %t966, %t971, %t918 :: integer
-        %t982 = call core.sub(%col_i_273, %t922) :: integer
-        %t984 = call core.gte(%t982, %t918) :: boolean
-        %t985 = call core.lt(%t982, %t960) :: boolean
-        %t986 = call core.and(%t984, %t985) :: boolean
-        %t990 = call core.clamp(%t982, %t918, %t968) :: integer
-        %t991 = gather %t959, %t990 :: integer
-        %t993 = select %t986, %t991, %t918 :: integer
-        %t1012 = call core.lt(%t962, %t927) :: boolean
-        %t1013 = call core.and(%t964, %t1012) :: boolean
-        %t1014 = call core.and(%t921, %t1013) :: boolean
-        %t1018 = call core.clamp(%t962, %t918, %t1016) :: integer
-        %t1019 = gather %t926, %t1018 :: integer
-        %t1021 = select %t1014, %t1019, %t918 :: integer
-        %t1040 = call core.lt(%t982, %t927) :: boolean
-        %t1041 = call core.and(%t984, %t1040) :: boolean
-        %t1042 = call core.and(%t921, %t1041) :: boolean
-        %t1046 = call core.clamp(%t982, %t918, %t1016) :: integer
-        %t1047 = gather %t926, %t1046 :: integer
-        %t1049 = select %t1042, %t1047, %t918 :: integer
-        %t1068 = call core.lt(%t962, %t947) :: boolean
-        %t1069 = call core.and(%t964, %t1068) :: boolean
-        %t1070 = call core.and(%t941, %t1069) :: boolean
-        %t1074 = call core.clamp(%t962, %t918, %t1072) :: integer
-        %t1075 = gather %t946, %t1074 :: integer
-        %t1077 = select %t1070, %t1075, %t918 :: integer
-        %t1096 = call core.lt(%t982, %t947) :: boolean
-        %t1097 = call core.and(%t984, %t1096) :: boolean
-        %t1098 = call core.and(%t941, %t1097) :: boolean
-        %t1102 = call core.clamp(%t982, %t918, %t1072) :: integer
-        %t1103 = gather %t946, %t1102 :: integer
-        %t1105 = select %t1098, %t1103, %t918 :: integer
-        %t1106 = make_tuple(%t933, %t953, %t973, %t993, %t1021, %t1049, %t1077, %t1105) :: tuple<integer>
-        %t1107 = fold %t1106 fn="agg.sum" :: 
-        %t512 = call core.eq(%t1107, %t511) :: boolean
-        %t516 = call core.gt(%col_el_272, %t918) :: boolean
-        %t276 = call core.and(%t512, %t516) :: boolean
+        %t922 = call core.mod(%col_i_273, %t921) :: integer
+        %t923 = call core.add(%t922, %t921) :: integer
+        %t924 = call core.mod(%t923, %t921) :: integer
+        %t925 = gather %t920, %t924 :: integer
+        %t927 = select %t915, %t925, %t912 :: integer
+        %t942 = call core.mod(%col_i_273, %t941) :: integer
+        %t943 = call core.add(%t942, %t941) :: integer
+        %t944 = call core.mod(%t943, %t941) :: integer
+        %t945 = gather %t940, %t944 :: integer
+        %t947 = select %t935, %t945, %t912 :: integer
+        %t956 = call core.sub(%col_i_273, %t910) :: integer
+        %t958 = call core.gte(%t956, %t912) :: boolean
+        %t959 = call core.lt(%t956, %t954) :: boolean
+        %t960 = call core.and(%t958, %t959) :: boolean
+        %t964 = call core.clamp(%t956, %t912, %t962) :: integer
+        %t965 = gather %t953, %t964 :: integer
+        %t967 = select %t960, %t965, %t912 :: integer
+        %t976 = call core.sub(%col_i_273, %t916) :: integer
+        %t978 = call core.gte(%t976, %t912) :: boolean
+        %t979 = call core.lt(%t976, %t954) :: boolean
+        %t980 = call core.and(%t978, %t979) :: boolean
+        %t984 = call core.clamp(%t976, %t912, %t962) :: integer
+        %t985 = gather %t953, %t984 :: integer
+        %t987 = select %t980, %t985, %t912 :: integer
+        %t1006 = call core.lt(%t956, %t921) :: boolean
+        %t1007 = call core.and(%t958, %t1006) :: boolean
+        %t1008 = call core.and(%t915, %t1007) :: boolean
+        %t1012 = call core.clamp(%t956, %t912, %t1010) :: integer
+        %t1013 = gather %t920, %t1012 :: integer
+        %t1015 = select %t1008, %t1013, %t912 :: integer
+        %t1034 = call core.lt(%t976, %t921) :: boolean
+        %t1035 = call core.and(%t978, %t1034) :: boolean
+        %t1036 = call core.and(%t915, %t1035) :: boolean
+        %t1040 = call core.clamp(%t976, %t912, %t1010) :: integer
+        %t1041 = gather %t920, %t1040 :: integer
+        %t1043 = select %t1036, %t1041, %t912 :: integer
+        %t1062 = call core.lt(%t956, %t941) :: boolean
+        %t1063 = call core.and(%t958, %t1062) :: boolean
+        %t1064 = call core.and(%t935, %t1063) :: boolean
+        %t1068 = call core.clamp(%t956, %t912, %t1066) :: integer
+        %t1069 = gather %t940, %t1068 :: integer
+        %t1071 = select %t1064, %t1069, %t912 :: integer
+        %t1090 = call core.lt(%t976, %t941) :: boolean
+        %t1091 = call core.and(%t978, %t1090) :: boolean
+        %t1092 = call core.and(%t935, %t1091) :: boolean
+        %t1096 = call core.clamp(%t976, %t912, %t1066) :: integer
+        %t1097 = gather %t940, %t1096 :: integer
+        %t1099 = select %t1092, %t1097, %t912 :: integer
+        %t906 = make_tuple(%t927, %t947, %t967, %t987, %t1015, %t1043, %t1071, %t1099) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t907 = fold %t906 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t896 = call core.eq(%t907, %t895) :: boolean
+        %t1103 = call core.gt(%col_el_272, %t1102) :: boolean
+        %t276 = call core.and(%t896, %t1103) :: boolean
         yield %t276
       end_loop
     end_loop
   )
   (Declaration next_alive
     %t277 = load_input "rows" :: array
-    %t1111 = length %t277 :: integer
-    %t1112 = const -1 :: integer
-    %t1114 = const 0 :: integer
-    %t1118 = const 1 :: integer
-    %t519 = const 3 :: integer
-    %t1316 = const 2 :: integer
-    %t1119 = call core.sub(%t1111, %t1118) :: integer
+    %t1121 = length %t277 :: integer
+    %t1122 = const -1 :: integer
+    %t1124 = const 0 :: integer
+    %t1128 = const 1 :: integer
+    %t1107 = const 3 :: integer
+    %t1318 = const 2 :: integer
+    %t1525 = const 0 :: integer
+    %t1129 = call core.sub(%t1121, %t1128) :: integer
     loop rows id=L29 in %t277 as el=%rows_el_278, idx=%rows_i_279
-      %t1113 = call core.sub(%rows_i_279, %t1112) :: integer
-      %t1133 = call core.sub(%rows_i_279, %t1118) :: integer
-      %t1152 = call core.mod(%rows_i_279, %t1111) :: integer
-      %t1115 = call core.gte(%t1113, %t1114) :: boolean
-      %t1116 = call core.lt(%t1113, %t1111) :: boolean
-      %t1121 = call core.clamp(%t1113, %t1114, %t1119) :: integer
-      %t1135 = call core.gte(%t1133, %t1114) :: boolean
-      %t1136 = call core.lt(%t1133, %t1111) :: boolean
-      %t1141 = call core.clamp(%t1133, %t1114, %t1119) :: integer
-      %t1153 = call core.add(%t1152, %t1111) :: integer
-      %t1117 = call core.and(%t1115, %t1116) :: boolean
-      %t1122 = gather %t277, %t1121 :: any
-      %t1137 = call core.and(%t1135, %t1136) :: boolean
-      %t1142 = gather %t277, %t1141 :: any
-      %t1154 = call core.mod(%t1153, %t1111) :: integer
-      %t1123 = length %t1122 :: integer
-      %t1143 = length %t1142 :: integer
-      %t1155 = gather %t277, %t1154 :: any
-      %t1156 = length %t1155 :: integer
-      %t1212 = call core.sub(%t1123, %t1118) :: integer
-      %t1268 = call core.sub(%t1143, %t1118) :: integer
-      %t1164 = call core.sub(%t1156, %t1118) :: integer
+      %t1123 = call core.sub(%rows_i_279, %t1122) :: integer
+      %t1143 = call core.sub(%rows_i_279, %t1128) :: integer
+      %t1162 = call core.mod(%rows_i_279, %t1121) :: integer
+      %t1125 = call core.gte(%t1123, %t1124) :: boolean
+      %t1126 = call core.lt(%t1123, %t1121) :: boolean
+      %t1131 = call core.clamp(%t1123, %t1124, %t1129) :: integer
+      %t1145 = call core.gte(%t1143, %t1124) :: boolean
+      %t1146 = call core.lt(%t1143, %t1121) :: boolean
+      %t1151 = call core.clamp(%t1143, %t1124, %t1129) :: integer
+      %t1163 = call core.add(%t1162, %t1121) :: integer
+      %t1127 = call core.and(%t1125, %t1126) :: boolean
+      %t1132 = gather %t277, %t1131 :: any
+      %t1147 = call core.and(%t1145, %t1146) :: boolean
+      %t1152 = gather %t277, %t1151 :: any
+      %t1164 = call core.mod(%t1163, %t1121) :: integer
+      %t1133 = length %t1132 :: integer
+      %t1153 = length %t1152 :: integer
+      %t1165 = gather %t277, %t1164 :: any
+      %t1166 = length %t1165 :: integer
+      %t1222 = call core.sub(%t1133, %t1128) :: integer
+      %t1278 = call core.sub(%t1153, %t1128) :: integer
+      %t1174 = call core.sub(%t1166, %t1128) :: integer
       loop col id=L30 in %rows_el_278 as el=%col_el_280, idx=%col_i_281
-        %t1124 = call core.mod(%col_i_281, %t1123) :: integer
-        %t1125 = call core.add(%t1124, %t1123) :: integer
-        %t1126 = call core.mod(%t1125, %t1123) :: integer
-        %t1127 = gather %t1122, %t1126 :: integer
-        %t1129 = select %t1117, %t1127, %t1114 :: integer
-        %t1144 = call core.mod(%col_i_281, %t1143) :: integer
-        %t1145 = call core.add(%t1144, %t1143) :: integer
-        %t1146 = call core.mod(%t1145, %t1143) :: integer
-        %t1147 = gather %t1142, %t1146 :: integer
-        %t1149 = select %t1137, %t1147, %t1114 :: integer
-        %t1158 = call core.sub(%col_i_281, %t1112) :: integer
-        %t1160 = call core.gte(%t1158, %t1114) :: boolean
-        %t1161 = call core.lt(%t1158, %t1156) :: boolean
-        %t1162 = call core.and(%t1160, %t1161) :: boolean
-        %t1166 = call core.clamp(%t1158, %t1114, %t1164) :: integer
-        %t1167 = gather %t1155, %t1166 :: integer
-        %t1169 = select %t1162, %t1167, %t1114 :: integer
-        %t1178 = call core.sub(%col_i_281, %t1118) :: integer
-        %t1180 = call core.gte(%t1178, %t1114) :: boolean
-        %t1181 = call core.lt(%t1178, %t1156) :: boolean
-        %t1182 = call core.and(%t1180, %t1181) :: boolean
-        %t1186 = call core.clamp(%t1178, %t1114, %t1164) :: integer
-        %t1187 = gather %t1155, %t1186 :: integer
-        %t1189 = select %t1182, %t1187, %t1114 :: integer
-        %t1208 = call core.lt(%t1158, %t1123) :: boolean
-        %t1209 = call core.and(%t1160, %t1208) :: boolean
-        %t1210 = call core.and(%t1117, %t1209) :: boolean
-        %t1214 = call core.clamp(%t1158, %t1114, %t1212) :: integer
-        %t1215 = gather %t1122, %t1214 :: integer
-        %t1217 = select %t1210, %t1215, %t1114 :: integer
-        %t1236 = call core.lt(%t1178, %t1123) :: boolean
-        %t1237 = call core.and(%t1180, %t1236) :: boolean
-        %t1238 = call core.and(%t1117, %t1237) :: boolean
-        %t1242 = call core.clamp(%t1178, %t1114, %t1212) :: integer
-        %t1243 = gather %t1122, %t1242 :: integer
-        %t1245 = select %t1238, %t1243, %t1114 :: integer
-        %t1264 = call core.lt(%t1158, %t1143) :: boolean
-        %t1265 = call core.and(%t1160, %t1264) :: boolean
-        %t1266 = call core.and(%t1137, %t1265) :: boolean
-        %t1270 = call core.clamp(%t1158, %t1114, %t1268) :: integer
-        %t1271 = gather %t1142, %t1270 :: integer
-        %t1273 = select %t1266, %t1271, %t1114 :: integer
-        %t1292 = call core.lt(%t1178, %t1143) :: boolean
-        %t1293 = call core.and(%t1180, %t1292) :: boolean
-        %t1294 = call core.and(%t1137, %t1293) :: boolean
-        %t1298 = call core.clamp(%t1178, %t1114, %t1268) :: integer
-        %t1299 = gather %t1142, %t1298 :: integer
-        %t1301 = select %t1294, %t1299, %t1114 :: integer
-        %t1302 = make_tuple(%t1129, %t1149, %t1169, %t1189, %t1217, %t1245, %t1273, %t1301) :: tuple<integer>
-        %t1303 = fold %t1302 fn="agg.sum" :: 
-        %t520 = call core.eq(%t1303, %t519) :: boolean
-        %t1317 = call core.eq(%t1303, %t1316) :: boolean
-        %t1321 = call core.gt(%col_el_280, %t1114) :: boolean
-        %t524 = call core.and(%t1317, %t1321) :: boolean
-        %t284 = call core.or(%t520, %t524) :: boolean
+        %t1134 = call core.mod(%col_i_281, %t1133) :: integer
+        %t1135 = call core.add(%t1134, %t1133) :: integer
+        %t1136 = call core.mod(%t1135, %t1133) :: integer
+        %t1137 = gather %t1132, %t1136 :: integer
+        %t1139 = select %t1127, %t1137, %t1124 :: integer
+        %t1154 = call core.mod(%col_i_281, %t1153) :: integer
+        %t1155 = call core.add(%t1154, %t1153) :: integer
+        %t1156 = call core.mod(%t1155, %t1153) :: integer
+        %t1157 = gather %t1152, %t1156 :: integer
+        %t1159 = select %t1147, %t1157, %t1124 :: integer
+        %t1168 = call core.sub(%col_i_281, %t1122) :: integer
+        %t1170 = call core.gte(%t1168, %t1124) :: boolean
+        %t1171 = call core.lt(%t1168, %t1166) :: boolean
+        %t1172 = call core.and(%t1170, %t1171) :: boolean
+        %t1176 = call core.clamp(%t1168, %t1124, %t1174) :: integer
+        %t1177 = gather %t1165, %t1176 :: integer
+        %t1179 = select %t1172, %t1177, %t1124 :: integer
+        %t1188 = call core.sub(%col_i_281, %t1128) :: integer
+        %t1190 = call core.gte(%t1188, %t1124) :: boolean
+        %t1191 = call core.lt(%t1188, %t1166) :: boolean
+        %t1192 = call core.and(%t1190, %t1191) :: boolean
+        %t1196 = call core.clamp(%t1188, %t1124, %t1174) :: integer
+        %t1197 = gather %t1165, %t1196 :: integer
+        %t1199 = select %t1192, %t1197, %t1124 :: integer
+        %t1218 = call core.lt(%t1168, %t1133) :: boolean
+        %t1219 = call core.and(%t1170, %t1218) :: boolean
+        %t1220 = call core.and(%t1127, %t1219) :: boolean
+        %t1224 = call core.clamp(%t1168, %t1124, %t1222) :: integer
+        %t1225 = gather %t1132, %t1224 :: integer
+        %t1227 = select %t1220, %t1225, %t1124 :: integer
+        %t1246 = call core.lt(%t1188, %t1133) :: boolean
+        %t1247 = call core.and(%t1190, %t1246) :: boolean
+        %t1248 = call core.and(%t1127, %t1247) :: boolean
+        %t1252 = call core.clamp(%t1188, %t1124, %t1222) :: integer
+        %t1253 = gather %t1132, %t1252 :: integer
+        %t1255 = select %t1248, %t1253, %t1124 :: integer
+        %t1274 = call core.lt(%t1168, %t1153) :: boolean
+        %t1275 = call core.and(%t1170, %t1274) :: boolean
+        %t1276 = call core.and(%t1147, %t1275) :: boolean
+        %t1280 = call core.clamp(%t1168, %t1124, %t1278) :: integer
+        %t1281 = gather %t1152, %t1280 :: integer
+        %t1283 = select %t1276, %t1281, %t1124 :: integer
+        %t1302 = call core.lt(%t1188, %t1153) :: boolean
+        %t1303 = call core.and(%t1190, %t1302) :: boolean
+        %t1304 = call core.and(%t1147, %t1303) :: boolean
+        %t1308 = call core.clamp(%t1188, %t1124, %t1278) :: integer
+        %t1309 = gather %t1152, %t1308 :: integer
+        %t1311 = select %t1304, %t1309, %t1124 :: integer
+        %t1118 = make_tuple(%t1139, %t1159, %t1179, %t1199, %t1227, %t1255, %t1283, %t1311) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t1119 = fold %t1118 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t1108 = call core.eq(%t1119, %t1107) :: boolean
+        %t1319 = call core.eq(%t1119, %t1318) :: boolean
+        %t1526 = call core.gt(%col_el_280, %t1525) :: boolean
+        %t1315 = call core.and(%t1319, %t1526) :: boolean
+        %t284 = call core.or(%t1108, %t1315) :: boolean
         yield %t284
       end_loop
     end_loop
   )
   (Declaration next_state
     %t285 = load_input "rows" :: array
-    %t1539 = length %t285 :: integer
-    %t1540 = const -1 :: integer
-    %t1542 = const 0 :: integer
-    %t1546 = const 1 :: integer
-    %t1334 = const 3 :: integer
-    %t1339 = const 2 :: integer
-    %t1547 = call core.sub(%t1539, %t1546) :: integer
+    %t1548 = length %t285 :: integer
+    %t1549 = const -1 :: integer
+    %t1551 = const 0 :: integer
+    %t1555 = const 1 :: integer
+    %t1534 = const 3 :: integer
+    %t1745 = const 2 :: integer
+    %t1952 = const 0 :: integer
+    %t291 = const 1 :: integer
+    %t1556 = call core.sub(%t1548, %t1555) :: integer
     loop rows id=L31 in %t285 as el=%rows_el_286, idx=%rows_i_287
-      %t1541 = call core.sub(%rows_i_287, %t1540) :: integer
-      %t1561 = call core.sub(%rows_i_287, %t1546) :: integer
-      %t1580 = call core.mod(%rows_i_287, %t1539) :: integer
-      %t1543 = call core.gte(%t1541, %t1542) :: boolean
-      %t1544 = call core.lt(%t1541, %t1539) :: boolean
-      %t1549 = call core.clamp(%t1541, %t1542, %t1547) :: integer
-      %t1563 = call core.gte(%t1561, %t1542) :: boolean
-      %t1564 = call core.lt(%t1561, %t1539) :: boolean
-      %t1569 = call core.clamp(%t1561, %t1542, %t1547) :: integer
-      %t1581 = call core.add(%t1580, %t1539) :: integer
-      %t1545 = call core.and(%t1543, %t1544) :: boolean
-      %t1550 = gather %t285, %t1549 :: any
-      %t1565 = call core.and(%t1563, %t1564) :: boolean
-      %t1570 = gather %t285, %t1569 :: any
-      %t1582 = call core.mod(%t1581, %t1539) :: integer
-      %t1551 = length %t1550 :: integer
-      %t1571 = length %t1570 :: integer
-      %t1583 = gather %t285, %t1582 :: any
-      %t1584 = length %t1583 :: integer
-      %t1640 = call core.sub(%t1551, %t1546) :: integer
-      %t1696 = call core.sub(%t1571, %t1546) :: integer
-      %t1592 = call core.sub(%t1584, %t1546) :: integer
+      %t1550 = call core.sub(%rows_i_287, %t1549) :: integer
+      %t1570 = call core.sub(%rows_i_287, %t1555) :: integer
+      %t1589 = call core.mod(%rows_i_287, %t1548) :: integer
+      %t1552 = call core.gte(%t1550, %t1551) :: boolean
+      %t1553 = call core.lt(%t1550, %t1548) :: boolean
+      %t1558 = call core.clamp(%t1550, %t1551, %t1556) :: integer
+      %t1572 = call core.gte(%t1570, %t1551) :: boolean
+      %t1573 = call core.lt(%t1570, %t1548) :: boolean
+      %t1578 = call core.clamp(%t1570, %t1551, %t1556) :: integer
+      %t1590 = call core.add(%t1589, %t1548) :: integer
+      %t1554 = call core.and(%t1552, %t1553) :: boolean
+      %t1559 = gather %t285, %t1558 :: any
+      %t1574 = call core.and(%t1572, %t1573) :: boolean
+      %t1579 = gather %t285, %t1578 :: any
+      %t1591 = call core.mod(%t1590, %t1548) :: integer
+      %t1560 = length %t1559 :: integer
+      %t1580 = length %t1579 :: integer
+      %t1592 = gather %t285, %t1591 :: any
+      %t1593 = length %t1592 :: integer
+      %t1649 = call core.sub(%t1560, %t1555) :: integer
+      %t1705 = call core.sub(%t1580, %t1555) :: integer
+      %t1601 = call core.sub(%t1593, %t1555) :: integer
       loop col id=L32 in %rows_el_286 as el=%col_el_288, idx=%col_i_289
-        %t1552 = call core.mod(%col_i_289, %t1551) :: integer
-        %t1553 = call core.add(%t1552, %t1551) :: integer
-        %t1554 = call core.mod(%t1553, %t1551) :: integer
-        %t1555 = gather %t1550, %t1554 :: integer
-        %t1557 = select %t1545, %t1555, %t1542 :: integer
-        %t1572 = call core.mod(%col_i_289, %t1571) :: integer
-        %t1573 = call core.add(%t1572, %t1571) :: integer
-        %t1574 = call core.mod(%t1573, %t1571) :: integer
-        %t1575 = gather %t1570, %t1574 :: integer
-        %t1577 = select %t1565, %t1575, %t1542 :: integer
-        %t1586 = call core.sub(%col_i_289, %t1540) :: integer
-        %t1588 = call core.gte(%t1586, %t1542) :: boolean
-        %t1589 = call core.lt(%t1586, %t1584) :: boolean
-        %t1590 = call core.and(%t1588, %t1589) :: boolean
-        %t1594 = call core.clamp(%t1586, %t1542, %t1592) :: integer
-        %t1595 = gather %t1583, %t1594 :: integer
-        %t1597 = select %t1590, %t1595, %t1542 :: integer
-        %t1606 = call core.sub(%col_i_289, %t1546) :: integer
-        %t1608 = call core.gte(%t1606, %t1542) :: boolean
-        %t1609 = call core.lt(%t1606, %t1584) :: boolean
-        %t1610 = call core.and(%t1608, %t1609) :: boolean
-        %t1614 = call core.clamp(%t1606, %t1542, %t1592) :: integer
-        %t1615 = gather %t1583, %t1614 :: integer
-        %t1617 = select %t1610, %t1615, %t1542 :: integer
-        %t1636 = call core.lt(%t1586, %t1551) :: boolean
-        %t1637 = call core.and(%t1588, %t1636) :: boolean
-        %t1638 = call core.and(%t1545, %t1637) :: boolean
-        %t1642 = call core.clamp(%t1586, %t1542, %t1640) :: integer
-        %t1643 = gather %t1550, %t1642 :: integer
-        %t1645 = select %t1638, %t1643, %t1542 :: integer
-        %t1664 = call core.lt(%t1606, %t1551) :: boolean
-        %t1665 = call core.and(%t1608, %t1664) :: boolean
-        %t1666 = call core.and(%t1545, %t1665) :: boolean
-        %t1670 = call core.clamp(%t1606, %t1542, %t1640) :: integer
-        %t1671 = gather %t1550, %t1670 :: integer
-        %t1673 = select %t1666, %t1671, %t1542 :: integer
-        %t1692 = call core.lt(%t1586, %t1571) :: boolean
-        %t1693 = call core.and(%t1588, %t1692) :: boolean
-        %t1694 = call core.and(%t1565, %t1693) :: boolean
-        %t1698 = call core.clamp(%t1586, %t1542, %t1696) :: integer
-        %t1699 = gather %t1570, %t1698 :: integer
-        %t1701 = select %t1694, %t1699, %t1542 :: integer
-        %t1720 = call core.lt(%t1606, %t1571) :: boolean
-        %t1721 = call core.and(%t1608, %t1720) :: boolean
-        %t1722 = call core.and(%t1565, %t1721) :: boolean
-        %t1726 = call core.clamp(%t1606, %t1542, %t1696) :: integer
-        %t1727 = gather %t1570, %t1726 :: integer
-        %t1729 = select %t1722, %t1727, %t1542 :: integer
-        %t1332 = make_tuple(%t1557, %t1577, %t1597, %t1617, %t1645, %t1673, %t1701, %t1729) :: tuple<integer>
-        %t1333 = fold %t1332 fn="agg.sum" :: 
-        %t1335 = call core.eq(%t1333, %t1334) :: boolean
-        %t1340 = call core.eq(%t1333, %t1339) :: boolean
-        %t1344 = call core.gt(%col_el_288, %t1542) :: boolean
-        %t1345 = call core.and(%t1340, %t1344) :: boolean
-        %t528 = call core.or(%t1335, %t1345) :: boolean
-        %t293 = select %t528, %t1546, %t1542 :: integer
+        %t1561 = call core.mod(%col_i_289, %t1560) :: integer
+        %t1562 = call core.add(%t1561, %t1560) :: integer
+        %t1563 = call core.mod(%t1562, %t1560) :: integer
+        %t1564 = gather %t1559, %t1563 :: integer
+        %t1566 = select %t1554, %t1564, %t1551 :: integer
+        %t1581 = call core.mod(%col_i_289, %t1580) :: integer
+        %t1582 = call core.add(%t1581, %t1580) :: integer
+        %t1583 = call core.mod(%t1582, %t1580) :: integer
+        %t1584 = gather %t1579, %t1583 :: integer
+        %t1586 = select %t1574, %t1584, %t1551 :: integer
+        %t1595 = call core.sub(%col_i_289, %t1549) :: integer
+        %t1597 = call core.gte(%t1595, %t1551) :: boolean
+        %t1598 = call core.lt(%t1595, %t1593) :: boolean
+        %t1599 = call core.and(%t1597, %t1598) :: boolean
+        %t1603 = call core.clamp(%t1595, %t1551, %t1601) :: integer
+        %t1604 = gather %t1592, %t1603 :: integer
+        %t1606 = select %t1599, %t1604, %t1551 :: integer
+        %t1615 = call core.sub(%col_i_289, %t1555) :: integer
+        %t1617 = call core.gte(%t1615, %t1551) :: boolean
+        %t1618 = call core.lt(%t1615, %t1593) :: boolean
+        %t1619 = call core.and(%t1617, %t1618) :: boolean
+        %t1623 = call core.clamp(%t1615, %t1551, %t1601) :: integer
+        %t1624 = gather %t1592, %t1623 :: integer
+        %t1626 = select %t1619, %t1624, %t1551 :: integer
+        %t1645 = call core.lt(%t1595, %t1560) :: boolean
+        %t1646 = call core.and(%t1597, %t1645) :: boolean
+        %t1647 = call core.and(%t1554, %t1646) :: boolean
+        %t1651 = call core.clamp(%t1595, %t1551, %t1649) :: integer
+        %t1652 = gather %t1559, %t1651 :: integer
+        %t1654 = select %t1647, %t1652, %t1551 :: integer
+        %t1673 = call core.lt(%t1615, %t1560) :: boolean
+        %t1674 = call core.and(%t1617, %t1673) :: boolean
+        %t1675 = call core.and(%t1554, %t1674) :: boolean
+        %t1679 = call core.clamp(%t1615, %t1551, %t1649) :: integer
+        %t1680 = gather %t1559, %t1679 :: integer
+        %t1682 = select %t1675, %t1680, %t1551 :: integer
+        %t1701 = call core.lt(%t1595, %t1580) :: boolean
+        %t1702 = call core.and(%t1597, %t1701) :: boolean
+        %t1703 = call core.and(%t1574, %t1702) :: boolean
+        %t1707 = call core.clamp(%t1595, %t1551, %t1705) :: integer
+        %t1708 = gather %t1579, %t1707 :: integer
+        %t1710 = select %t1703, %t1708, %t1551 :: integer
+        %t1729 = call core.lt(%t1615, %t1580) :: boolean
+        %t1730 = call core.and(%t1617, %t1729) :: boolean
+        %t1731 = call core.and(%t1574, %t1730) :: boolean
+        %t1735 = call core.clamp(%t1615, %t1551, %t1705) :: integer
+        %t1736 = gather %t1579, %t1735 :: integer
+        %t1738 = select %t1731, %t1736, %t1551 :: integer
+        %t1545 = make_tuple(%t1566, %t1586, %t1606, %t1626, %t1654, %t1682, %t1710, %t1738) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t1546 = fold %t1545 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t1535 = call core.eq(%t1546, %t1534) :: boolean
+        %t1746 = call core.eq(%t1546, %t1745) :: boolean
+        %t1953 = call core.gt(%col_el_288, %t1952) :: boolean
+        %t1742 = call core.and(%t1746, %t1953) :: boolean
+        %t1531 = call core.or(%t1535, %t1742) :: boolean
+        %t293 = select %t1531, %t291, %t1952 :: integer
         yield %t293
       end_loop
     end_loop