kumi 0.0.24 → 0.0.25

data/golden/game_of_life/expected/lir_02_inlined.txt

@@ -473,199 +473,199 @@
     loop rows id=L23 in %t253 as el=%rows_el_254, idx=%rows_i_255
       loop col id=L24 in %rows_el_254 as el=%col_el_256, idx=%col_i_257
         %t487 = load_input "rows" :: array
-        %t529 = load_input "rows" :: array
-        %t530 = length %t529 :: integer
-        %t531 = const -1 :: integer
-        %t532 = call core.sub(%rows_i_255, %t531) :: integer
-        %t533 = const 0 :: integer
-        %t534 = call core.gte(%t532, %t533) :: boolean
-        %t535 = call core.lt(%t532, %t530) :: boolean
-        %t536 = call core.and(%t534, %t535) :: boolean
-        %t537 = const 1 :: integer
-        %t538 = call core.sub(%t530, %t537) :: integer
-        %t539 = const 0 :: integer
-        %t540 = call core.clamp(%t532, %t539, %t538) :: integer
-        %t541 = gather %t529, %t540 :: any
-        %t542 = length %t541 :: integer
-        %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
+        %t498 = load_input "rows" :: array
+        %t499 = length %t498 :: integer
+        %t500 = const -1 :: integer
+        %t501 = call core.sub(%rows_i_255, %t500) :: integer
+        %t502 = const 0 :: integer
+        %t503 = call core.gte(%t501, %t502) :: boolean
+        %t504 = call core.lt(%t501, %t499) :: boolean
+        %t505 = call core.and(%t503, %t504) :: boolean
+        %t506 = const 1 :: integer
+        %t507 = call core.sub(%t499, %t506) :: integer
+        %t508 = const 0 :: integer
+        %t509 = call core.clamp(%t501, %t508, %t507) :: integer
+        %t510 = gather %t498, %t509 :: any
+        %t511 = length %t510 :: integer
+        %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
+        %t516 = const 0 :: integer
+        %t517 = select %t505, %t515, %t516 :: integer
+        %t518 = load_input "rows" :: array
+        %t519 = length %t518 :: integer
+        %t520 = const 1 :: integer
+        %t521 = call core.sub(%rows_i_255, %t520) :: integer
+        %t522 = const 0 :: integer
+        %t523 = call core.gte(%t521, %t522) :: boolean
+        %t524 = call core.lt(%t521, %t519) :: boolean
+        %t525 = call core.and(%t523, %t524) :: boolean
+        %t526 = const 1 :: integer
+        %t527 = call core.sub(%t519, %t526) :: integer
+        %t528 = const 0 :: integer
+        %t529 = call core.clamp(%t521, %t528, %t527) :: integer
+        %t530 = gather %t518, %t529 :: any
+        %t531 = length %t530 :: 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
+        %t536 = const 0 :: integer
+        %t537 = select %t525, %t535, %t536 :: integer
+        %t538 = load_input "rows" :: array
+        %t539 = length %t538 :: integer
+        %t540 = call core.mod(%rows_i_255, %t539) :: integer
+        %t541 = call core.add(%t540, %t539) :: integer
+        %t542 = call core.mod(%t541, %t539) :: integer
+        %t543 = gather %t538, %t542 :: any
+        %t544 = length %t543 :: integer
+        %t545 = const -1 :: integer
+        %t546 = call core.sub(%col_i_257, %t545) :: integer
         %t547 = const 0 :: integer
-        %t548 = select %t536, %t546, %t547 :: integer
-        %t549 = load_input "rows" :: array
-        %t550 = length %t549 :: integer
+        %t548 = call core.gte(%t546, %t547) :: boolean
+        %t549 = call core.lt(%t546, %t544) :: boolean
+        %t550 = call core.and(%t548, %t549) :: boolean
         %t551 = const 1 :: integer
-        %t552 = call core.sub(%rows_i_255, %t551) :: integer
+        %t552 = call core.sub(%t544, %t551) :: integer
         %t553 = const 0 :: integer
-        %t554 = call core.gte(%t552, %t553) :: boolean
-        %t555 = call core.lt(%t552, %t550) :: boolean
-        %t556 = call core.and(%t554, %t555) :: boolean
-        %t557 = const 1 :: integer
-        %t558 = call core.sub(%t550, %t557) :: integer
-        %t559 = const 0 :: integer
-        %t560 = call core.clamp(%t552, %t559, %t558) :: integer
-        %t561 = gather %t549, %t560 :: any
-        %t562 = length %t561 :: 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
+        %t554 = call core.clamp(%t546, %t553, %t552) :: integer
+        %t555 = gather %t543, %t554 :: integer
+        %t556 = const 0 :: integer
+        %t557 = select %t550, %t555, %t556 :: integer
+        %t558 = load_input "rows" :: array
+        %t559 = length %t558 :: integer
+        %t560 = call core.mod(%rows_i_255, %t559) :: integer
+        %t561 = call core.add(%t560, %t559) :: integer
+        %t562 = call core.mod(%t561, %t559) :: integer
+        %t563 = gather %t558, %t562 :: any
+        %t564 = length %t563 :: integer
+        %t565 = const 1 :: integer
+        %t566 = call core.sub(%col_i_257, %t565) :: integer
         %t567 = const 0 :: integer
-        %t568 = select %t556, %t566, %t567 :: integer
-        %t569 = load_input "rows" :: array
-        %t570 = length %t569 :: integer
-        %t571 = call core.mod(%rows_i_255, %t570) :: integer
-        %t572 = call core.add(%t571, %t570) :: integer
-        %t573 = call core.mod(%t572, %t570) :: integer
-        %t574 = gather %t569, %t573 :: any
-        %t575 = length %t574 :: integer
-        %t576 = const -1 :: integer
-        %t577 = call core.sub(%col_i_257, %t576) :: integer
-        %t578 = const 0 :: integer
-        %t579 = call core.gte(%t577, %t578) :: boolean
-        %t580 = call core.lt(%t577, %t575) :: boolean
-        %t581 = call core.and(%t579, %t580) :: boolean
-        %t582 = const 1 :: integer
-        %t583 = call core.sub(%t575, %t582) :: integer
-        %t584 = const 0 :: integer
-        %t585 = call core.clamp(%t577, %t584, %t583) :: integer
-        %t586 = gather %t574, %t585 :: integer
-        %t587 = const 0 :: integer
-        %t588 = select %t581, %t586, %t587 :: integer
-        %t589 = load_input "rows" :: array
-        %t590 = length %t589 :: integer
-        %t591 = call core.mod(%rows_i_255, %t590) :: integer
-        %t592 = call core.add(%t591, %t590) :: integer
-        %t593 = call core.mod(%t592, %t590) :: integer
-        %t594 = gather %t589, %t593 :: any
-        %t595 = length %t594 :: integer
-        %t596 = const 1 :: integer
-        %t597 = call core.sub(%col_i_257, %t596) :: integer
-        %t598 = const 0 :: integer
-        %t599 = call core.gte(%t597, %t598) :: boolean
-        %t600 = call core.lt(%t597, %t595) :: boolean
-        %t601 = call core.and(%t599, %t600) :: boolean
-        %t602 = const 1 :: integer
-        %t603 = call core.sub(%t595, %t602) :: integer
+        %t568 = call core.gte(%t566, %t567) :: boolean
+        %t569 = call core.lt(%t566, %t564) :: boolean
+        %t570 = call core.and(%t568, %t569) :: boolean
+        %t571 = const 1 :: integer
+        %t572 = call core.sub(%t564, %t571) :: integer
+        %t573 = const 0 :: integer
+        %t574 = call core.clamp(%t566, %t573, %t572) :: integer
+        %t575 = gather %t563, %t574 :: integer
+        %t576 = const 0 :: integer
+        %t577 = select %t570, %t575, %t576 :: integer
+        %t578 = load_input "rows" :: array
+        %t579 = length %t578 :: integer
+        %t580 = const -1 :: integer
+        %t581 = call core.sub(%rows_i_255, %t580) :: integer
+        %t582 = const 0 :: integer
+        %t583 = call core.gte(%t581, %t582) :: boolean
+        %t584 = call core.lt(%t581, %t579) :: boolean
+        %t585 = call core.and(%t583, %t584) :: boolean
+        %t586 = const 1 :: integer
+        %t587 = call core.sub(%t579, %t586) :: integer
+        %t588 = const 0 :: integer
+        %t589 = call core.clamp(%t581, %t588, %t587) :: integer
+        %t590 = gather %t578, %t589 :: any
+        %t591 = length %t590 :: integer
+        %t592 = const -1 :: integer
+        %t593 = call core.sub(%col_i_257, %t592) :: integer
+        %t594 = const 0 :: integer
+        %t595 = call core.gte(%t593, %t594) :: boolean
+        %t596 = call core.lt(%t593, %t591) :: boolean
+        %t597 = call core.and(%t595, %t596) :: boolean
+        %t598 = call core.and(%t585, %t597) :: boolean
+        %t599 = const 1 :: integer
+        %t600 = call core.sub(%t591, %t599) :: integer
+        %t601 = const 0 :: integer
+        %t602 = call core.clamp(%t593, %t601, %t600) :: integer
+        %t603 = gather %t590, %t602 :: integer
         %t604 = const 0 :: integer
-        %t605 = call core.clamp(%t597, %t604, %t603) :: integer
-        %t606 = gather %t594, %t605 :: integer
-        %t607 = const 0 :: integer
-        %t608 = select %t601, %t606, %t607 :: integer
-        %t609 = load_input "rows" :: array
-        %t610 = length %t609 :: integer
-        %t611 = const -1 :: integer
-        %t612 = call core.sub(%rows_i_255, %t611) :: integer
-        %t613 = const 0 :: integer
-        %t614 = call core.gte(%t612, %t613) :: boolean
-        %t615 = call core.lt(%t612, %t610) :: boolean
-        %t616 = call core.and(%t614, %t615) :: boolean
-        %t617 = const 1 :: integer
-        %t618 = call core.sub(%t610, %t617) :: integer
-        %t619 = const 0 :: integer
-        %t620 = call core.clamp(%t612, %t619, %t618) :: integer
-        %t621 = gather %t609, %t620 :: any
-        %t622 = length %t621 :: integer
-        %t623 = const -1 :: integer
-        %t624 = call core.sub(%col_i_257, %t623) :: integer
-        %t625 = const 0 :: integer
-        %t626 = call core.gte(%t624, %t625) :: boolean
-        %t627 = call core.lt(%t624, %t622) :: boolean
-        %t628 = call core.and(%t626, %t627) :: boolean
-        %t629 = call core.and(%t616, %t628) :: boolean
-        %t630 = const 1 :: integer
-        %t631 = call core.sub(%t622, %t630) :: integer
+        %t605 = select %t598, %t603, %t604 :: integer
+        %t606 = load_input "rows" :: array
+        %t607 = length %t606 :: integer
+        %t608 = const -1 :: integer
+        %t609 = call core.sub(%rows_i_255, %t608) :: integer
+        %t610 = const 0 :: integer
+        %t611 = call core.gte(%t609, %t610) :: boolean
+        %t612 = call core.lt(%t609, %t607) :: boolean
+        %t613 = call core.and(%t611, %t612) :: boolean
+        %t614 = const 1 :: integer
+        %t615 = call core.sub(%t607, %t614) :: integer
+        %t616 = const 0 :: integer
+        %t617 = call core.clamp(%t609, %t616, %t615) :: integer
+        %t618 = gather %t606, %t617 :: any
+        %t619 = length %t618 :: integer
+        %t620 = const 1 :: integer
+        %t621 = call core.sub(%col_i_257, %t620) :: integer
+        %t622 = const 0 :: integer
+        %t623 = call core.gte(%t621, %t622) :: boolean
+        %t624 = call core.lt(%t621, %t619) :: boolean
+        %t625 = call core.and(%t623, %t624) :: boolean
+        %t626 = call core.and(%t613, %t625) :: boolean
+        %t627 = const 1 :: integer
+        %t628 = call core.sub(%t619, %t627) :: integer
+        %t629 = const 0 :: integer
+        %t630 = call core.clamp(%t621, %t629, %t628) :: integer
+        %t631 = gather %t618, %t630 :: integer
         %t632 = const 0 :: integer
-        %t633 = call core.clamp(%t624, %t632, %t631) :: integer
-        %t634 = gather %t621, %t633 :: integer
-        %t635 = const 0 :: integer
-        %t636 = select %t629, %t634, %t635 :: integer
-        %t637 = load_input "rows" :: array
-        %t638 = length %t637 :: integer
-        %t639 = const -1 :: integer
-        %t640 = call core.sub(%rows_i_255, %t639) :: integer
-        %t641 = const 0 :: integer
-        %t642 = call core.gte(%t640, %t641) :: boolean
-        %t643 = call core.lt(%t640, %t638) :: boolean
-        %t644 = call core.and(%t642, %t643) :: boolean
-        %t645 = const 1 :: integer
-        %t646 = call core.sub(%t638, %t645) :: integer
-        %t647 = const 0 :: integer
-        %t648 = call core.clamp(%t640, %t647, %t646) :: integer
-        %t649 = gather %t637, %t648 :: any
-        %t650 = length %t649 :: integer
-        %t651 = const 1 :: integer
-        %t652 = call core.sub(%col_i_257, %t651) :: integer
-        %t653 = const 0 :: integer
-        %t654 = call core.gte(%t652, %t653) :: boolean
-        %t655 = call core.lt(%t652, %t650) :: boolean
-        %t656 = call core.and(%t654, %t655) :: boolean
-        %t657 = call core.and(%t644, %t656) :: boolean
-        %t658 = const 1 :: integer
-        %t659 = call core.sub(%t650, %t658) :: integer
+        %t633 = select %t626, %t631, %t632 :: integer
+        %t634 = load_input "rows" :: array
+        %t635 = length %t634 :: integer
+        %t636 = const 1 :: integer
+        %t637 = call core.sub(%rows_i_255, %t636) :: integer
+        %t638 = const 0 :: integer
+        %t639 = call core.gte(%t637, %t638) :: boolean
+        %t640 = call core.lt(%t637, %t635) :: boolean
+        %t641 = call core.and(%t639, %t640) :: boolean
+        %t642 = const 1 :: integer
+        %t643 = call core.sub(%t635, %t642) :: integer
+        %t644 = const 0 :: integer
+        %t645 = call core.clamp(%t637, %t644, %t643) :: integer
+        %t646 = gather %t634, %t645 :: any
+        %t647 = length %t646 :: integer
+        %t648 = const -1 :: integer
+        %t649 = call core.sub(%col_i_257, %t648) :: integer
+        %t650 = const 0 :: integer
+        %t651 = call core.gte(%t649, %t650) :: boolean
+        %t652 = call core.lt(%t649, %t647) :: boolean
+        %t653 = call core.and(%t651, %t652) :: boolean
+        %t654 = call core.and(%t641, %t653) :: boolean
+        %t655 = const 1 :: integer
+        %t656 = call core.sub(%t647, %t655) :: integer
+        %t657 = const 0 :: integer
+        %t658 = call core.clamp(%t649, %t657, %t656) :: integer
+        %t659 = gather %t646, %t658 :: integer
         %t660 = const 0 :: integer
-        %t661 = call core.clamp(%t652, %t660, %t659) :: integer
-        %t662 = gather %t649, %t661 :: integer
-        %t663 = const 0 :: integer
-        %t664 = select %t657, %t662, %t663 :: integer
-        %t665 = load_input "rows" :: array
-        %t666 = length %t665 :: integer
-        %t667 = const 1 :: integer
-        %t668 = call core.sub(%rows_i_255, %t667) :: integer
-        %t669 = const 0 :: integer
-        %t670 = call core.gte(%t668, %t669) :: boolean
-        %t671 = call core.lt(%t668, %t666) :: boolean
-        %t672 = call core.and(%t670, %t671) :: boolean
-        %t673 = const 1 :: integer
-        %t674 = call core.sub(%t666, %t673) :: integer
-        %t675 = const 0 :: integer
-        %t676 = call core.clamp(%t668, %t675, %t674) :: integer
-        %t677 = gather %t665, %t676 :: any
-        %t678 = length %t677 :: integer
-        %t679 = const -1 :: integer
-        %t680 = call core.sub(%col_i_257, %t679) :: integer
-        %t681 = const 0 :: integer
-        %t682 = call core.gte(%t680, %t681) :: boolean
-        %t683 = call core.lt(%t680, %t678) :: boolean
-        %t684 = call core.and(%t682, %t683) :: boolean
-        %t685 = call core.and(%t672, %t684) :: boolean
-        %t686 = const 1 :: integer
-        %t687 = call core.sub(%t678, %t686) :: integer
+        %t661 = select %t654, %t659, %t660 :: integer
+        %t662 = load_input "rows" :: array
+        %t663 = length %t662 :: integer
+        %t664 = const 1 :: integer
+        %t665 = call core.sub(%rows_i_255, %t664) :: integer
+        %t666 = const 0 :: integer
+        %t667 = call core.gte(%t665, %t666) :: boolean
+        %t668 = call core.lt(%t665, %t663) :: boolean
+        %t669 = call core.and(%t667, %t668) :: boolean
+        %t670 = const 1 :: integer
+        %t671 = call core.sub(%t663, %t670) :: integer
+        %t672 = const 0 :: integer
+        %t673 = call core.clamp(%t665, %t672, %t671) :: integer
+        %t674 = gather %t662, %t673 :: any
+        %t675 = length %t674 :: integer
+        %t676 = const 1 :: integer
+        %t677 = call core.sub(%col_i_257, %t676) :: integer
+        %t678 = const 0 :: integer
+        %t679 = call core.gte(%t677, %t678) :: boolean
+        %t680 = call core.lt(%t677, %t675) :: boolean
+        %t681 = call core.and(%t679, %t680) :: boolean
+        %t682 = call core.and(%t669, %t681) :: boolean
+        %t683 = const 1 :: integer
+        %t684 = call core.sub(%t675, %t683) :: integer
+        %t685 = const 0 :: integer
+        %t686 = call core.clamp(%t677, %t685, %t684) :: integer
+        %t687 = gather %t674, %t686 :: integer
         %t688 = const 0 :: integer
-        %t689 = call core.clamp(%t680, %t688, %t687) :: integer
-        %t690 = gather %t677, %t689 :: integer
-        %t691 = const 0 :: integer
-        %t692 = select %t685, %t690, %t691 :: integer
-        %t693 = load_input "rows" :: array
-        %t694 = length %t693 :: integer
-        %t695 = const 1 :: integer
-        %t696 = call core.sub(%rows_i_255, %t695) :: integer
-        %t697 = const 0 :: integer
-        %t698 = call core.gte(%t696, %t697) :: boolean
-        %t699 = call core.lt(%t696, %t694) :: boolean
-        %t700 = call core.and(%t698, %t699) :: boolean
-        %t701 = const 1 :: integer
-        %t702 = call core.sub(%t694, %t701) :: integer
-        %t703 = const 0 :: integer
-        %t704 = call core.clamp(%t696, %t703, %t702) :: integer
-        %t705 = gather %t693, %t704 :: any
-        %t706 = length %t705 :: integer
-        %t707 = const 1 :: integer
-        %t708 = call core.sub(%col_i_257, %t707) :: integer
-        %t709 = const 0 :: integer
-        %t710 = call core.gte(%t708, %t709) :: boolean
-        %t711 = call core.lt(%t708, %t706) :: boolean
-        %t712 = call core.and(%t710, %t711) :: boolean
-        %t713 = call core.and(%t700, %t712) :: boolean
-        %t714 = const 1 :: integer
-        %t715 = call core.sub(%t706, %t714) :: integer
-        %t716 = const 0 :: integer
-        %t717 = call core.clamp(%t708, %t716, %t715) :: integer
-        %t718 = gather %t705, %t717 :: integer
-        %t719 = const 0 :: integer
-        %t720 = select %t713, %t718, %t719 :: integer
-        %t496 = make_tuple(%t548, %t568, %t588, %t608, %t636, %t664, %t692, %t720) :: tuple<integer>
+        %t689 = select %t682, %t687, %t688 :: integer
+        %t496 = make_tuple(%t517, %t537, %t557, %t577, %t605, %t633, %t661, %t689) :: tuple<integer>
         %t497 = fold %t496 fn="agg.sum" :: 
         %t259 = const 3 :: integer
         %t260 = call core.eq(%t497, %t259) :: boolean
@@ -677,10 +677,30 @@
     %t261 = load_input "rows" :: array
     loop rows id=L25 in %t261 as el=%rows_el_262, idx=%rows_i_263
       loop col id=L26 in %rows_el_262 as el=%col_el_264, idx=%col_i_265
-        %t498 = load_input "rows" :: array
+        %t690 = load_input "rows" :: array
+        %t701 = load_input "rows" :: array
+        %t702 = length %t701 :: integer
+        %t703 = const -1 :: integer
+        %t704 = call core.sub(%rows_i_263, %t703) :: integer
+        %t705 = const 0 :: integer
+        %t706 = call core.gte(%t704, %t705) :: boolean
+        %t707 = call core.lt(%t704, %t702) :: boolean
+        %t708 = call core.and(%t706, %t707) :: boolean
+        %t709 = const 1 :: integer
+        %t710 = call core.sub(%t702, %t709) :: integer
+        %t711 = const 0 :: integer
+        %t712 = call core.clamp(%t704, %t711, %t710) :: integer
+        %t713 = gather %t701, %t712 :: any
+        %t714 = length %t713 :: integer
+        %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
+        %t719 = const 0 :: integer
+        %t720 = select %t708, %t718, %t719 :: integer
         %t721 = load_input "rows" :: array
         %t722 = length %t721 :: integer
-        %t723 = const -1 :: integer
+        %t723 = const 1 :: integer
         %t724 = call core.sub(%rows_i_263, %t723) :: integer
         %t725 = const 0 :: integer
         %t726 = call core.gte(%t724, %t725) :: boolean
@@ -700,24 +720,24 @@
         %t740 = select %t728, %t738, %t739 :: integer
         %t741 = load_input "rows" :: array
         %t742 = length %t741 :: integer
-        %t743 = const 1 :: integer
-        %t744 = call core.sub(%rows_i_263, %t743) :: integer
-        %t745 = const 0 :: integer
-        %t746 = call core.gte(%t744, %t745) :: boolean
-        %t747 = call core.lt(%t744, %t742) :: boolean
-        %t748 = call core.and(%t746, %t747) :: boolean
-        %t749 = const 1 :: integer
-        %t750 = call core.sub(%t742, %t749) :: integer
-        %t751 = const 0 :: integer
-        %t752 = call core.clamp(%t744, %t751, %t750) :: integer
-        %t753 = gather %t741, %t752 :: any
-        %t754 = length %t753 :: 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
+        %t743 = call core.mod(%rows_i_263, %t742) :: integer
+        %t744 = call core.add(%t743, %t742) :: integer
+        %t745 = call core.mod(%t744, %t742) :: integer
+        %t746 = gather %t741, %t745 :: any
+        %t747 = length %t746 :: integer
+        %t748 = const -1 :: integer
+        %t749 = call core.sub(%col_i_265, %t748) :: integer
+        %t750 = const 0 :: integer
+        %t751 = call core.gte(%t749, %t750) :: boolean
+        %t752 = call core.lt(%t749, %t747) :: boolean
+        %t753 = call core.and(%t751, %t752) :: boolean
+        %t754 = const 1 :: integer
+        %t755 = call core.sub(%t747, %t754) :: integer
+        %t756 = const 0 :: integer
+        %t757 = call core.clamp(%t749, %t756, %t755) :: integer
+        %t758 = gather %t746, %t757 :: integer
         %t759 = const 0 :: integer
-        %t760 = select %t748, %t758, %t759 :: integer
+        %t760 = select %t753, %t758, %t759 :: integer
         %t761 = load_input "rows" :: array
         %t762 = length %t761 :: integer
         %t763 = call core.mod(%rows_i_263, %t762) :: integer
@@ -725,7 +745,7 @@
         %t765 = call core.mod(%t764, %t762) :: integer
         %t766 = gather %t761, %t765 :: any
         %t767 = length %t766 :: integer
-        %t768 = const -1 :: integer
+        %t768 = const 1 :: integer
         %t769 = call core.sub(%col_i_265, %t768) :: integer
         %t770 = const 0 :: integer
         %t771 = call core.gte(%t769, %t770) :: boolean
@@ -740,140 +760,120 @@
         %t780 = select %t773, %t778, %t779 :: integer
         %t781 = load_input "rows" :: array
         %t782 = length %t781 :: integer
-        %t783 = call core.mod(%rows_i_263, %t782) :: integer
-        %t784 = call core.add(%t783, %t782) :: integer
-        %t785 = call core.mod(%t784, %t782) :: integer
-        %t786 = gather %t781, %t785 :: any
-        %t787 = length %t786 :: integer
-        %t788 = const 1 :: integer
-        %t789 = call core.sub(%col_i_265, %t788) :: integer
-        %t790 = const 0 :: integer
-        %t791 = call core.gte(%t789, %t790) :: boolean
-        %t792 = call core.lt(%t789, %t787) :: boolean
-        %t793 = call core.and(%t791, %t792) :: boolean
-        %t794 = const 1 :: integer
-        %t795 = call core.sub(%t787, %t794) :: integer
-        %t796 = const 0 :: integer
-        %t797 = call core.clamp(%t789, %t796, %t795) :: integer
-        %t798 = gather %t786, %t797 :: integer
-        %t799 = const 0 :: integer
-        %t800 = select %t793, %t798, %t799 :: integer
-        %t801 = load_input "rows" :: array
-        %t802 = length %t801 :: integer
-        %t803 = const -1 :: integer
-        %t804 = call core.sub(%rows_i_263, %t803) :: integer
-        %t805 = const 0 :: integer
-        %t806 = call core.gte(%t804, %t805) :: boolean
-        %t807 = call core.lt(%t804, %t802) :: boolean
-        %t808 = call core.and(%t806, %t807) :: boolean
-        %t809 = const 1 :: integer
-        %t810 = call core.sub(%t802, %t809) :: integer
-        %t811 = const 0 :: integer
-        %t812 = call core.clamp(%t804, %t811, %t810) :: integer
-        %t813 = gather %t801, %t812 :: any
-        %t814 = length %t813 :: integer
-        %t815 = const -1 :: integer
-        %t816 = call core.sub(%col_i_265, %t815) :: integer
-        %t817 = const 0 :: integer
-        %t818 = call core.gte(%t816, %t817) :: boolean
-        %t819 = call core.lt(%t816, %t814) :: boolean
-        %t820 = call core.and(%t818, %t819) :: boolean
-        %t821 = call core.and(%t808, %t820) :: boolean
-        %t822 = const 1 :: integer
-        %t823 = call core.sub(%t814, %t822) :: integer
-        %t824 = const 0 :: integer
-        %t825 = call core.clamp(%t816, %t824, %t823) :: integer
-        %t826 = gather %t813, %t825 :: integer
-        %t827 = const 0 :: integer
-        %t828 = select %t821, %t826, %t827 :: integer
-        %t829 = load_input "rows" :: array
-        %t830 = length %t829 :: integer
-        %t831 = const -1 :: integer
-        %t832 = call core.sub(%rows_i_263, %t831) :: integer
-        %t833 = const 0 :: integer
-        %t834 = call core.gte(%t832, %t833) :: boolean
-        %t835 = call core.lt(%t832, %t830) :: boolean
-        %t836 = call core.and(%t834, %t835) :: boolean
-        %t837 = const 1 :: integer
-        %t838 = call core.sub(%t830, %t837) :: integer
-        %t839 = const 0 :: integer
-        %t840 = call core.clamp(%t832, %t839, %t838) :: integer
-        %t841 = gather %t829, %t840 :: any
-        %t842 = length %t841 :: integer
-        %t843 = const 1 :: integer
-        %t844 = call core.sub(%col_i_265, %t843) :: integer
-        %t845 = const 0 :: integer
-        %t846 = call core.gte(%t844, %t845) :: boolean
-        %t847 = call core.lt(%t844, %t842) :: boolean
-        %t848 = call core.and(%t846, %t847) :: boolean
-        %t849 = call core.and(%t836, %t848) :: boolean
-        %t850 = const 1 :: integer
-        %t851 = call core.sub(%t842, %t850) :: integer
-        %t852 = const 0 :: integer
-        %t853 = call core.clamp(%t844, %t852, %t851) :: integer
-        %t854 = gather %t841, %t853 :: integer
-        %t855 = const 0 :: integer
-        %t856 = select %t849, %t854, %t855 :: integer
-        %t857 = load_input "rows" :: array
-        %t858 = length %t857 :: integer
-        %t859 = const 1 :: integer
-        %t860 = call core.sub(%rows_i_263, %t859) :: integer
-        %t861 = const 0 :: integer
-        %t862 = call core.gte(%t860, %t861) :: boolean
-        %t863 = call core.lt(%t860, %t858) :: boolean
-        %t864 = call core.and(%t862, %t863) :: boolean
-        %t865 = const 1 :: integer
-        %t866 = call core.sub(%t858, %t865) :: integer
-        %t867 = const 0 :: integer
-        %t868 = call core.clamp(%t860, %t867, %t866) :: integer
-        %t869 = gather %t857, %t868 :: any
-        %t870 = length %t869 :: integer
-        %t871 = const -1 :: integer
-        %t872 = call core.sub(%col_i_265, %t871) :: integer
-        %t873 = const 0 :: integer
-        %t874 = call core.gte(%t872, %t873) :: boolean
-        %t875 = call core.lt(%t872, %t870) :: boolean
-        %t876 = call core.and(%t874, %t875) :: boolean
-        %t877 = call core.and(%t864, %t876) :: boolean
-        %t878 = const 1 :: integer
-        %t879 = call core.sub(%t870, %t878) :: integer
-        %t880 = const 0 :: integer
-        %t881 = call core.clamp(%t872, %t880, %t879) :: integer
-        %t882 = gather %t869, %t881 :: integer
-        %t883 = const 0 :: integer
-        %t884 = select %t877, %t882, %t883 :: integer
-        %t885 = load_input "rows" :: array
-        %t886 = length %t885 :: integer
-        %t887 = const 1 :: integer
-        %t888 = call core.sub(%rows_i_263, %t887) :: integer
-        %t889 = const 0 :: integer
-        %t890 = call core.gte(%t888, %t889) :: boolean
-        %t891 = call core.lt(%t888, %t886) :: boolean
-        %t892 = call core.and(%t890, %t891) :: boolean
-        %t893 = const 1 :: integer
-        %t894 = call core.sub(%t886, %t893) :: integer
-        %t895 = const 0 :: integer
-        %t896 = call core.clamp(%t888, %t895, %t894) :: integer
-        %t897 = gather %t885, %t896 :: any
-        %t898 = length %t897 :: integer
-        %t899 = const 1 :: integer
-        %t900 = call core.sub(%col_i_265, %t899) :: integer
-        %t901 = const 0 :: integer
-        %t902 = call core.gte(%t900, %t901) :: boolean
-        %t903 = call core.lt(%t900, %t898) :: boolean
-        %t904 = call core.and(%t902, %t903) :: boolean
-        %t905 = call core.and(%t892, %t904) :: boolean
-        %t906 = const 1 :: integer
-        %t907 = call core.sub(%t898, %t906) :: integer
-        %t908 = const 0 :: integer
-        %t909 = call core.clamp(%t900, %t908, %t907) :: integer
-        %t910 = gather %t897, %t909 :: integer
-        %t911 = const 0 :: integer
-        %t912 = select %t905, %t910, %t911 :: integer
-        %t507 = make_tuple(%t740, %t760, %t780, %t800, %t828, %t856, %t884, %t912) :: tuple<integer>
-        %t508 = fold %t507 fn="agg.sum" :: 
+        %t783 = const -1 :: integer
+        %t784 = call core.sub(%rows_i_263, %t783) :: integer
+        %t785 = const 0 :: integer
+        %t786 = call core.gte(%t784, %t785) :: boolean
+        %t787 = call core.lt(%t784, %t782) :: boolean
+        %t788 = call core.and(%t786, %t787) :: boolean
+        %t789 = const 1 :: integer
+        %t790 = call core.sub(%t782, %t789) :: integer
+        %t791 = const 0 :: integer
+        %t792 = call core.clamp(%t784, %t791, %t790) :: integer
+        %t793 = gather %t781, %t792 :: any
+        %t794 = length %t793 :: integer
+        %t795 = const -1 :: integer
+        %t796 = call core.sub(%col_i_265, %t795) :: integer
+        %t797 = const 0 :: integer
+        %t798 = call core.gte(%t796, %t797) :: boolean
+        %t799 = call core.lt(%t796, %t794) :: boolean
+        %t800 = call core.and(%t798, %t799) :: boolean
+        %t801 = call core.and(%t788, %t800) :: boolean
+        %t802 = const 1 :: integer
+        %t803 = call core.sub(%t794, %t802) :: integer
+        %t804 = const 0 :: integer
+        %t805 = call core.clamp(%t796, %t804, %t803) :: integer
+        %t806 = gather %t793, %t805 :: integer
+        %t807 = const 0 :: integer
+        %t808 = select %t801, %t806, %t807 :: integer
+        %t809 = load_input "rows" :: array
+        %t810 = length %t809 :: integer
+        %t811 = const -1 :: integer
+        %t812 = call core.sub(%rows_i_263, %t811) :: integer
+        %t813 = const 0 :: integer
+        %t814 = call core.gte(%t812, %t813) :: boolean
+        %t815 = call core.lt(%t812, %t810) :: boolean
+        %t816 = call core.and(%t814, %t815) :: boolean
+        %t817 = const 1 :: integer
+        %t818 = call core.sub(%t810, %t817) :: integer
+        %t819 = const 0 :: integer
+        %t820 = call core.clamp(%t812, %t819, %t818) :: integer
+        %t821 = gather %t809, %t820 :: any
+        %t822 = length %t821 :: integer
+        %t823 = const 1 :: integer
+        %t824 = call core.sub(%col_i_265, %t823) :: integer
+        %t825 = const 0 :: integer
+        %t826 = call core.gte(%t824, %t825) :: boolean
+        %t827 = call core.lt(%t824, %t822) :: boolean
+        %t828 = call core.and(%t826, %t827) :: boolean
+        %t829 = call core.and(%t816, %t828) :: boolean
+        %t830 = const 1 :: integer
+        %t831 = call core.sub(%t822, %t830) :: integer
+        %t832 = const 0 :: integer
+        %t833 = call core.clamp(%t824, %t832, %t831) :: integer
+        %t834 = gather %t821, %t833 :: integer
+        %t835 = const 0 :: integer
+        %t836 = select %t829, %t834, %t835 :: integer
+        %t837 = load_input "rows" :: array
+        %t838 = length %t837 :: integer
+        %t839 = const 1 :: integer
+        %t840 = call core.sub(%rows_i_263, %t839) :: integer
+        %t841 = const 0 :: integer
+        %t842 = call core.gte(%t840, %t841) :: boolean
+        %t843 = call core.lt(%t840, %t838) :: boolean
+        %t844 = call core.and(%t842, %t843) :: boolean
+        %t845 = const 1 :: integer
+        %t846 = call core.sub(%t838, %t845) :: integer
+        %t847 = const 0 :: integer
+        %t848 = call core.clamp(%t840, %t847, %t846) :: integer
+        %t849 = gather %t837, %t848 :: any
+        %t850 = length %t849 :: integer
+        %t851 = const -1 :: integer
+        %t852 = call core.sub(%col_i_265, %t851) :: integer
+        %t853 = const 0 :: integer
+        %t854 = call core.gte(%t852, %t853) :: boolean
+        %t855 = call core.lt(%t852, %t850) :: boolean
+        %t856 = call core.and(%t854, %t855) :: boolean
+        %t857 = call core.and(%t844, %t856) :: boolean
+        %t858 = const 1 :: integer
+        %t859 = call core.sub(%t850, %t858) :: integer
+        %t860 = const 0 :: integer
+        %t861 = call core.clamp(%t852, %t860, %t859) :: integer
+        %t862 = gather %t849, %t861 :: integer
+        %t863 = const 0 :: integer
+        %t864 = select %t857, %t862, %t863 :: integer
+        %t865 = load_input "rows" :: array
+        %t866 = length %t865 :: integer
+        %t867 = const 1 :: integer
+        %t868 = call core.sub(%rows_i_263, %t867) :: integer
+        %t869 = const 0 :: integer
+        %t870 = call core.gte(%t868, %t869) :: boolean
+        %t871 = call core.lt(%t868, %t866) :: boolean
+        %t872 = call core.and(%t870, %t871) :: boolean
+        %t873 = const 1 :: integer
+        %t874 = call core.sub(%t866, %t873) :: integer
+        %t875 = const 0 :: integer
+        %t876 = call core.clamp(%t868, %t875, %t874) :: integer
+        %t877 = gather %t865, %t876 :: any
+        %t878 = length %t877 :: integer
+        %t879 = const 1 :: integer
+        %t880 = call core.sub(%col_i_265, %t879) :: integer
+        %t881 = const 0 :: integer
+        %t882 = call core.gte(%t880, %t881) :: boolean
+        %t883 = call core.lt(%t880, %t878) :: boolean
+        %t884 = call core.and(%t882, %t883) :: boolean
+        %t885 = call core.and(%t872, %t884) :: boolean
+        %t886 = const 1 :: integer
+        %t887 = call core.sub(%t878, %t886) :: integer
+        %t888 = const 0 :: integer
+        %t889 = call core.clamp(%t880, %t888, %t887) :: integer
+        %t890 = gather %t877, %t889 :: integer
+        %t891 = const 0 :: integer
+        %t892 = select %t885, %t890, %t891 :: integer
+        %t699 = make_tuple(%t720, %t740, %t760, %t780, %t808, %t836, %t864, %t892) :: tuple<integer>
+        %t700 = fold %t699 fn="agg.sum" :: 
         %t267 = const 2 :: integer
-        %t268 = call core.eq(%t508, %t267) :: boolean
+        %t268 = call core.eq(%t700, %t267) :: boolean
         yield %t268
       end_loop
     end_loop
@@ -882,209 +882,209 @@
     %t269 = load_input "rows" :: array
     loop rows id=L27 in %t269 as el=%rows_el_270, idx=%rows_i_271
       loop col id=L28 in %rows_el_270 as el=%col_el_272, idx=%col_i_273
-        %t509 = load_input "rows" :: array
-        %t913 = load_input "rows" :: array
-        %t914 = load_input "rows" :: array
-        %t915 = length %t914 :: integer
-        %t916 = const -1 :: integer
-        %t917 = call core.sub(%rows_i_271, %t916) :: integer
+        %t893 = load_input "rows" :: array
+        %t897 = load_input "rows" :: array
+        %t908 = load_input "rows" :: array
+        %t909 = length %t908 :: integer
+        %t910 = const -1 :: integer
+        %t911 = call core.sub(%rows_i_271, %t910) :: integer
+        %t912 = const 0 :: integer
+        %t913 = call core.gte(%t911, %t912) :: boolean
+        %t914 = call core.lt(%t911, %t909) :: boolean
+        %t915 = call core.and(%t913, %t914) :: boolean
+        %t916 = const 1 :: integer
+        %t917 = call core.sub(%t909, %t916) :: integer
         %t918 = const 0 :: integer
-        %t919 = call core.gte(%t917, %t918) :: boolean
-        %t920 = call core.lt(%t917, %t915) :: boolean
-        %t921 = call core.and(%t919, %t920) :: boolean
-        %t922 = const 1 :: integer
-        %t923 = call core.sub(%t915, %t922) :: integer
-        %t924 = const 0 :: integer
-        %t925 = call core.clamp(%t917, %t924, %t923) :: integer
-        %t926 = gather %t914, %t925 :: any
-        %t927 = length %t926 :: integer
-        %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
+        %t919 = call core.clamp(%t911, %t918, %t917) :: integer
+        %t920 = gather %t908, %t919 :: any
+        %t921 = length %t920 :: integer
+        %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
+        %t926 = const 0 :: integer
+        %t927 = select %t915, %t925, %t926 :: integer
+        %t928 = load_input "rows" :: array
+        %t929 = length %t928 :: integer
+        %t930 = const 1 :: integer
+        %t931 = call core.sub(%rows_i_271, %t930) :: integer
         %t932 = const 0 :: integer
-        %t933 = select %t921, %t931, %t932 :: integer
-        %t934 = load_input "rows" :: array
-        %t935 = length %t934 :: integer
+        %t933 = call core.gte(%t931, %t932) :: boolean
+        %t934 = call core.lt(%t931, %t929) :: boolean
+        %t935 = call core.and(%t933, %t934) :: boolean
         %t936 = const 1 :: integer
-        %t937 = call core.sub(%rows_i_271, %t936) :: integer
+        %t937 = call core.sub(%t929, %t936) :: integer
         %t938 = const 0 :: integer
-        %t939 = call core.gte(%t937, %t938) :: boolean
-        %t940 = call core.lt(%t937, %t935) :: boolean
-        %t941 = call core.and(%t939, %t940) :: boolean
-        %t942 = const 1 :: integer
-        %t943 = call core.sub(%t935, %t942) :: integer
-        %t944 = const 0 :: integer
-        %t945 = call core.clamp(%t937, %t944, %t943) :: integer
-        %t946 = gather %t934, %t945 :: any
-        %t947 = length %t946 :: 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
-        %t952 = const 0 :: integer
-        %t953 = select %t941, %t951, %t952 :: integer
-        %t954 = load_input "rows" :: array
-        %t955 = length %t954 :: integer
-        %t956 = call core.mod(%rows_i_271, %t955) :: integer
-        %t957 = call core.add(%t956, %t955) :: integer
-        %t958 = call core.mod(%t957, %t955) :: integer
-        %t959 = gather %t954, %t958 :: any
-        %t960 = length %t959 :: integer
-        %t961 = const -1 :: integer
-        %t962 = call core.sub(%col_i_273, %t961) :: integer
+        %t939 = call core.clamp(%t931, %t938, %t937) :: integer
+        %t940 = gather %t928, %t939 :: any
+        %t941 = length %t940 :: 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
+        %t946 = const 0 :: integer
+        %t947 = select %t935, %t945, %t946 :: integer
+        %t948 = load_input "rows" :: array
+        %t949 = length %t948 :: integer
+        %t950 = call core.mod(%rows_i_271, %t949) :: integer
+        %t951 = call core.add(%t950, %t949) :: integer
+        %t952 = call core.mod(%t951, %t949) :: integer
+        %t953 = gather %t948, %t952 :: any
+        %t954 = length %t953 :: integer
+        %t955 = const -1 :: integer
+        %t956 = call core.sub(%col_i_273, %t955) :: integer
+        %t957 = const 0 :: integer
+        %t958 = call core.gte(%t956, %t957) :: boolean
+        %t959 = call core.lt(%t956, %t954) :: boolean
+        %t960 = call core.and(%t958, %t959) :: boolean
+        %t961 = const 1 :: integer
+        %t962 = call core.sub(%t954, %t961) :: integer
         %t963 = const 0 :: integer
-        %t964 = call core.gte(%t962, %t963) :: boolean
-        %t965 = call core.lt(%t962, %t960) :: boolean
-        %t966 = call core.and(%t964, %t965) :: boolean
-        %t967 = const 1 :: integer
-        %t968 = call core.sub(%t960, %t967) :: integer
-        %t969 = const 0 :: integer
-        %t970 = call core.clamp(%t962, %t969, %t968) :: integer
-        %t971 = gather %t959, %t970 :: integer
-        %t972 = const 0 :: integer
-        %t973 = select %t966, %t971, %t972 :: integer
-        %t974 = load_input "rows" :: array
-        %t975 = length %t974 :: integer
-        %t976 = call core.mod(%rows_i_271, %t975) :: integer
-        %t977 = call core.add(%t976, %t975) :: integer
-        %t978 = call core.mod(%t977, %t975) :: integer
-        %t979 = gather %t974, %t978 :: any
-        %t980 = length %t979 :: integer
+        %t964 = call core.clamp(%t956, %t963, %t962) :: integer
+        %t965 = gather %t953, %t964 :: integer
+        %t966 = const 0 :: integer
+        %t967 = select %t960, %t965, %t966 :: integer
+        %t968 = load_input "rows" :: array
+        %t969 = length %t968 :: integer
+        %t970 = call core.mod(%rows_i_271, %t969) :: integer
+        %t971 = call core.add(%t970, %t969) :: integer
+        %t972 = call core.mod(%t971, %t969) :: integer
+        %t973 = gather %t968, %t972 :: any
+        %t974 = length %t973 :: integer
+        %t975 = const 1 :: integer
+        %t976 = call core.sub(%col_i_273, %t975) :: integer
+        %t977 = const 0 :: integer
+        %t978 = call core.gte(%t976, %t977) :: boolean
+        %t979 = call core.lt(%t976, %t974) :: boolean
+        %t980 = call core.and(%t978, %t979) :: boolean
         %t981 = const 1 :: integer
-        %t982 = call core.sub(%col_i_273, %t981) :: integer
+        %t982 = call core.sub(%t974, %t981) :: integer
         %t983 = const 0 :: integer
-        %t984 = call core.gte(%t982, %t983) :: boolean
-        %t985 = call core.lt(%t982, %t980) :: boolean
-        %t986 = call core.and(%t984, %t985) :: boolean
-        %t987 = const 1 :: integer
-        %t988 = call core.sub(%t980, %t987) :: integer
-        %t989 = const 0 :: integer
-        %t990 = call core.clamp(%t982, %t989, %t988) :: integer
-        %t991 = gather %t979, %t990 :: integer
+        %t984 = call core.clamp(%t976, %t983, %t982) :: integer
+        %t985 = gather %t973, %t984 :: integer
+        %t986 = const 0 :: integer
+        %t987 = select %t980, %t985, %t986 :: integer
+        %t988 = load_input "rows" :: array
+        %t989 = length %t988 :: integer
+        %t990 = const -1 :: integer
+        %t991 = call core.sub(%rows_i_271, %t990) :: integer
         %t992 = const 0 :: integer
-        %t993 = select %t986, %t991, %t992 :: integer
-        %t994 = load_input "rows" :: array
-        %t995 = length %t994 :: integer
-        %t996 = const -1 :: integer
-        %t997 = call core.sub(%rows_i_271, %t996) :: integer
+        %t993 = call core.gte(%t991, %t992) :: boolean
+        %t994 = call core.lt(%t991, %t989) :: boolean
+        %t995 = call core.and(%t993, %t994) :: boolean
+        %t996 = const 1 :: integer
+        %t997 = call core.sub(%t989, %t996) :: integer
         %t998 = const 0 :: integer
-        %t999 = call core.gte(%t997, %t998) :: boolean
-        %t1000 = call core.lt(%t997, %t995) :: boolean
-        %t1001 = call core.and(%t999, %t1000) :: boolean
-        %t1002 = const 1 :: integer
-        %t1003 = call core.sub(%t995, %t1002) :: integer
+        %t999 = call core.clamp(%t991, %t998, %t997) :: integer
+        %t1000 = gather %t988, %t999 :: any
+        %t1001 = length %t1000 :: integer
+        %t1002 = const -1 :: integer
+        %t1003 = call core.sub(%col_i_273, %t1002) :: integer
         %t1004 = const 0 :: integer
-        %t1005 = call core.clamp(%t997, %t1004, %t1003) :: integer
-        %t1006 = gather %t994, %t1005 :: any
-        %t1007 = length %t1006 :: integer
-        %t1008 = const -1 :: integer
-        %t1009 = call core.sub(%col_i_273, %t1008) :: integer
-        %t1010 = const 0 :: integer
-        %t1011 = call core.gte(%t1009, %t1010) :: boolean
-        %t1012 = call core.lt(%t1009, %t1007) :: boolean
-        %t1013 = call core.and(%t1011, %t1012) :: boolean
-        %t1014 = call core.and(%t1001, %t1013) :: boolean
-        %t1015 = const 1 :: integer
-        %t1016 = call core.sub(%t1007, %t1015) :: integer
-        %t1017 = const 0 :: integer
-        %t1018 = call core.clamp(%t1009, %t1017, %t1016) :: integer
-        %t1019 = gather %t1006, %t1018 :: integer
+        %t1005 = call core.gte(%t1003, %t1004) :: boolean
+        %t1006 = call core.lt(%t1003, %t1001) :: boolean
+        %t1007 = call core.and(%t1005, %t1006) :: boolean
+        %t1008 = call core.and(%t995, %t1007) :: boolean
+        %t1009 = const 1 :: integer
+        %t1010 = call core.sub(%t1001, %t1009) :: integer
+        %t1011 = const 0 :: integer
+        %t1012 = call core.clamp(%t1003, %t1011, %t1010) :: integer
+        %t1013 = gather %t1000, %t1012 :: integer
+        %t1014 = const 0 :: integer
+        %t1015 = select %t1008, %t1013, %t1014 :: integer
+        %t1016 = load_input "rows" :: array
+        %t1017 = length %t1016 :: integer
+        %t1018 = const -1 :: integer
+        %t1019 = call core.sub(%rows_i_271, %t1018) :: integer
         %t1020 = const 0 :: integer
-        %t1021 = select %t1014, %t1019, %t1020 :: integer
-        %t1022 = load_input "rows" :: array
-        %t1023 = length %t1022 :: integer
-        %t1024 = const -1 :: integer
-        %t1025 = call core.sub(%rows_i_271, %t1024) :: integer
+        %t1021 = call core.gte(%t1019, %t1020) :: boolean
+        %t1022 = call core.lt(%t1019, %t1017) :: boolean
+        %t1023 = call core.and(%t1021, %t1022) :: boolean
+        %t1024 = const 1 :: integer
+        %t1025 = call core.sub(%t1017, %t1024) :: integer
         %t1026 = const 0 :: integer
-        %t1027 = call core.gte(%t1025, %t1026) :: boolean
-        %t1028 = call core.lt(%t1025, %t1023) :: boolean
-        %t1029 = call core.and(%t1027, %t1028) :: boolean
+        %t1027 = call core.clamp(%t1019, %t1026, %t1025) :: integer
+        %t1028 = gather %t1016, %t1027 :: any
+        %t1029 = length %t1028 :: integer
         %t1030 = const 1 :: integer
-        %t1031 = call core.sub(%t1023, %t1030) :: integer
+        %t1031 = call core.sub(%col_i_273, %t1030) :: integer
         %t1032 = const 0 :: integer
-        %t1033 = call core.clamp(%t1025, %t1032, %t1031) :: integer
-        %t1034 = gather %t1022, %t1033 :: any
-        %t1035 = length %t1034 :: integer
-        %t1036 = const 1 :: integer
-        %t1037 = call core.sub(%col_i_273, %t1036) :: integer
-        %t1038 = const 0 :: integer
-        %t1039 = call core.gte(%t1037, %t1038) :: boolean
-        %t1040 = call core.lt(%t1037, %t1035) :: boolean
-        %t1041 = call core.and(%t1039, %t1040) :: boolean
-        %t1042 = call core.and(%t1029, %t1041) :: boolean
-        %t1043 = const 1 :: integer
-        %t1044 = call core.sub(%t1035, %t1043) :: integer
-        %t1045 = const 0 :: integer
-        %t1046 = call core.clamp(%t1037, %t1045, %t1044) :: integer
-        %t1047 = gather %t1034, %t1046 :: integer
+        %t1033 = call core.gte(%t1031, %t1032) :: boolean
+        %t1034 = call core.lt(%t1031, %t1029) :: boolean
+        %t1035 = call core.and(%t1033, %t1034) :: boolean
+        %t1036 = call core.and(%t1023, %t1035) :: boolean
+        %t1037 = const 1 :: integer
+        %t1038 = call core.sub(%t1029, %t1037) :: integer
+        %t1039 = const 0 :: integer
+        %t1040 = call core.clamp(%t1031, %t1039, %t1038) :: integer
+        %t1041 = gather %t1028, %t1040 :: integer
+        %t1042 = const 0 :: integer
+        %t1043 = select %t1036, %t1041, %t1042 :: integer
+        %t1044 = load_input "rows" :: array
+        %t1045 = length %t1044 :: integer
+        %t1046 = const 1 :: integer
+        %t1047 = call core.sub(%rows_i_271, %t1046) :: integer
         %t1048 = const 0 :: integer
-        %t1049 = select %t1042, %t1047, %t1048 :: integer
-        %t1050 = load_input "rows" :: array
-        %t1051 = length %t1050 :: integer
+        %t1049 = call core.gte(%t1047, %t1048) :: boolean
+        %t1050 = call core.lt(%t1047, %t1045) :: boolean
+        %t1051 = call core.and(%t1049, %t1050) :: boolean
         %t1052 = const 1 :: integer
-        %t1053 = call core.sub(%rows_i_271, %t1052) :: integer
+        %t1053 = call core.sub(%t1045, %t1052) :: integer
         %t1054 = const 0 :: integer
-        %t1055 = call core.gte(%t1053, %t1054) :: boolean
-        %t1056 = call core.lt(%t1053, %t1051) :: boolean
-        %t1057 = call core.and(%t1055, %t1056) :: boolean
-        %t1058 = const 1 :: integer
-        %t1059 = call core.sub(%t1051, %t1058) :: integer
+        %t1055 = call core.clamp(%t1047, %t1054, %t1053) :: integer
+        %t1056 = gather %t1044, %t1055 :: any
+        %t1057 = length %t1056 :: integer
+        %t1058 = const -1 :: integer
+        %t1059 = call core.sub(%col_i_273, %t1058) :: integer
         %t1060 = const 0 :: integer
-        %t1061 = call core.clamp(%t1053, %t1060, %t1059) :: integer
-        %t1062 = gather %t1050, %t1061 :: any
-        %t1063 = length %t1062 :: integer
-        %t1064 = const -1 :: integer
-        %t1065 = call core.sub(%col_i_273, %t1064) :: integer
-        %t1066 = const 0 :: integer
-        %t1067 = call core.gte(%t1065, %t1066) :: boolean
-        %t1068 = call core.lt(%t1065, %t1063) :: boolean
-        %t1069 = call core.and(%t1067, %t1068) :: boolean
-        %t1070 = call core.and(%t1057, %t1069) :: boolean
-        %t1071 = const 1 :: integer
-        %t1072 = call core.sub(%t1063, %t1071) :: integer
-        %t1073 = const 0 :: integer
-        %t1074 = call core.clamp(%t1065, %t1073, %t1072) :: integer
-        %t1075 = gather %t1062, %t1074 :: integer
+        %t1061 = call core.gte(%t1059, %t1060) :: boolean
+        %t1062 = call core.lt(%t1059, %t1057) :: boolean
+        %t1063 = call core.and(%t1061, %t1062) :: boolean
+        %t1064 = call core.and(%t1051, %t1063) :: boolean
+        %t1065 = const 1 :: integer
+        %t1066 = call core.sub(%t1057, %t1065) :: integer
+        %t1067 = const 0 :: integer
+        %t1068 = call core.clamp(%t1059, %t1067, %t1066) :: integer
+        %t1069 = gather %t1056, %t1068 :: integer
+        %t1070 = const 0 :: integer
+        %t1071 = select %t1064, %t1069, %t1070 :: integer
+        %t1072 = load_input "rows" :: array
+        %t1073 = length %t1072 :: integer
+        %t1074 = const 1 :: integer
+        %t1075 = call core.sub(%rows_i_271, %t1074) :: integer
         %t1076 = const 0 :: integer
-        %t1077 = select %t1070, %t1075, %t1076 :: integer
-        %t1078 = load_input "rows" :: array
-        %t1079 = length %t1078 :: integer
+        %t1077 = call core.gte(%t1075, %t1076) :: boolean
+        %t1078 = call core.lt(%t1075, %t1073) :: boolean
+        %t1079 = call core.and(%t1077, %t1078) :: boolean
         %t1080 = const 1 :: integer
-        %t1081 = call core.sub(%rows_i_271, %t1080) :: integer
+        %t1081 = call core.sub(%t1073, %t1080) :: integer
         %t1082 = const 0 :: integer
-        %t1083 = call core.gte(%t1081, %t1082) :: boolean
-        %t1084 = call core.lt(%t1081, %t1079) :: boolean
-        %t1085 = call core.and(%t1083, %t1084) :: boolean
+        %t1083 = call core.clamp(%t1075, %t1082, %t1081) :: integer
+        %t1084 = gather %t1072, %t1083 :: any
+        %t1085 = length %t1084 :: integer
         %t1086 = const 1 :: integer
-        %t1087 = call core.sub(%t1079, %t1086) :: integer
+        %t1087 = call core.sub(%col_i_273, %t1086) :: integer
         %t1088 = const 0 :: integer
-        %t1089 = call core.clamp(%t1081, %t1088, %t1087) :: integer
-        %t1090 = gather %t1078, %t1089 :: any
-        %t1091 = length %t1090 :: integer
-        %t1092 = const 1 :: integer
-        %t1093 = call core.sub(%col_i_273, %t1092) :: integer
-        %t1094 = const 0 :: integer
-        %t1095 = call core.gte(%t1093, %t1094) :: boolean
-        %t1096 = call core.lt(%t1093, %t1091) :: boolean
-        %t1097 = call core.and(%t1095, %t1096) :: boolean
-        %t1098 = call core.and(%t1085, %t1097) :: boolean
-        %t1099 = const 1 :: integer
-        %t1100 = call core.sub(%t1091, %t1099) :: integer
-        %t1101 = const 0 :: integer
-        %t1102 = call core.clamp(%t1093, %t1101, %t1100) :: integer
-        %t1103 = gather %t1090, %t1102 :: integer
-        %t1104 = const 0 :: integer
-        %t1105 = select %t1098, %t1103, %t1104 :: integer
-        %t1106 = make_tuple(%t933, %t953, %t973, %t993, %t1021, %t1049, %t1077, %t1105) :: tuple<integer>
-        %t1107 = fold %t1106 fn="agg.sum" :: 
-        %t511 = const 2 :: integer
-        %t512 = call core.eq(%t1107, %t511) :: boolean
-        %t513 = load_input "rows" :: array
-        %t1108 = load_input "rows" :: array
-        %t515 = const 0 :: integer
-        %t516 = call core.gt(%col_el_272, %t515) :: boolean
-        %t276 = call core.and(%t512, %t516) :: boolean
+        %t1089 = call core.gte(%t1087, %t1088) :: boolean
+        %t1090 = call core.lt(%t1087, %t1085) :: boolean
+        %t1091 = call core.and(%t1089, %t1090) :: boolean
+        %t1092 = call core.and(%t1079, %t1091) :: boolean
+        %t1093 = const 1 :: integer
+        %t1094 = call core.sub(%t1085, %t1093) :: integer
+        %t1095 = const 0 :: integer
+        %t1096 = call core.clamp(%t1087, %t1095, %t1094) :: integer
+        %t1097 = gather %t1084, %t1096 :: integer
+        %t1098 = const 0 :: integer
+        %t1099 = select %t1092, %t1097, %t1098 :: integer
+        %t906 = make_tuple(%t927, %t947, %t967, %t987, %t1015, %t1043, %t1071, %t1099) :: tuple<integer>
+        %t907 = fold %t906 fn="agg.sum" :: 
+        %t895 = const 2 :: integer
+        %t896 = call core.eq(%t907, %t895) :: boolean
+        %t1100 = load_input "rows" :: array
+        %t1104 = load_input "rows" :: array
+        %t1102 = const 0 :: integer
+        %t1103 = call core.gt(%col_el_272, %t1102) :: boolean
+        %t276 = call core.and(%t896, %t1103) :: boolean
         yield %t276
       end_loop
     end_loop
@@ -1093,276 +1093,291 @@
     %t277 = load_input "rows" :: array
     loop rows id=L29 in %t277 as el=%rows_el_278, idx=%rows_i_279
       loop col id=L30 in %rows_el_278 as el=%col_el_280, idx=%col_i_281
-        %t517 = load_input "rows" :: array
+        %t1105 = load_input "rows" :: array
         %t1109 = load_input "rows" :: array
-        %t1110 = load_input "rows" :: array
-        %t1111 = length %t1110 :: integer
-        %t1112 = const -1 :: integer
-        %t1113 = call core.sub(%rows_i_279, %t1112) :: integer
-        %t1114 = const 0 :: integer
-        %t1115 = call core.gte(%t1113, %t1114) :: boolean
-        %t1116 = call core.lt(%t1113, %t1111) :: boolean
-        %t1117 = call core.and(%t1115, %t1116) :: boolean
-        %t1118 = const 1 :: integer
-        %t1119 = call core.sub(%t1111, %t1118) :: integer
-        %t1120 = const 0 :: integer
-        %t1121 = call core.clamp(%t1113, %t1120, %t1119) :: integer
-        %t1122 = gather %t1110, %t1121 :: any
-        %t1123 = length %t1122 :: integer
-        %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
-        %t1128 = const 0 :: integer
-        %t1129 = select %t1117, %t1127, %t1128 :: integer
-        %t1130 = load_input "rows" :: array
-        %t1131 = length %t1130 :: integer
-        %t1132 = const 1 :: integer
-        %t1133 = call core.sub(%rows_i_279, %t1132) :: integer
-        %t1134 = const 0 :: integer
-        %t1135 = call core.gte(%t1133, %t1134) :: boolean
-        %t1136 = call core.lt(%t1133, %t1131) :: boolean
-        %t1137 = call core.and(%t1135, %t1136) :: boolean
-        %t1138 = const 1 :: integer
-        %t1139 = call core.sub(%t1131, %t1138) :: integer
-        %t1140 = const 0 :: integer
-        %t1141 = call core.clamp(%t1133, %t1140, %t1139) :: integer
-        %t1142 = gather %t1130, %t1141 :: any
-        %t1143 = length %t1142 :: 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
-        %t1148 = const 0 :: integer
-        %t1149 = select %t1137, %t1147, %t1148 :: integer
-        %t1150 = load_input "rows" :: array
-        %t1151 = length %t1150 :: integer
-        %t1152 = call core.mod(%rows_i_279, %t1151) :: integer
-        %t1153 = call core.add(%t1152, %t1151) :: integer
-        %t1154 = call core.mod(%t1153, %t1151) :: integer
-        %t1155 = gather %t1150, %t1154 :: any
-        %t1156 = length %t1155 :: integer
-        %t1157 = const -1 :: integer
-        %t1158 = call core.sub(%col_i_281, %t1157) :: integer
-        %t1159 = const 0 :: integer
-        %t1160 = call core.gte(%t1158, %t1159) :: boolean
-        %t1161 = call core.lt(%t1158, %t1156) :: boolean
-        %t1162 = call core.and(%t1160, %t1161) :: boolean
-        %t1163 = const 1 :: integer
-        %t1164 = call core.sub(%t1156, %t1163) :: integer
-        %t1165 = const 0 :: integer
-        %t1166 = call core.clamp(%t1158, %t1165, %t1164) :: integer
-        %t1167 = gather %t1155, %t1166 :: integer
-        %t1168 = const 0 :: integer
-        %t1169 = select %t1162, %t1167, %t1168 :: integer
-        %t1170 = load_input "rows" :: array
-        %t1171 = length %t1170 :: integer
-        %t1172 = call core.mod(%rows_i_279, %t1171) :: integer
-        %t1173 = call core.add(%t1172, %t1171) :: integer
-        %t1174 = call core.mod(%t1173, %t1171) :: integer
-        %t1175 = gather %t1170, %t1174 :: any
-        %t1176 = length %t1175 :: integer
-        %t1177 = const 1 :: integer
-        %t1178 = call core.sub(%col_i_281, %t1177) :: integer
-        %t1179 = const 0 :: integer
-        %t1180 = call core.gte(%t1178, %t1179) :: boolean
-        %t1181 = call core.lt(%t1178, %t1176) :: boolean
-        %t1182 = call core.and(%t1180, %t1181) :: boolean
-        %t1183 = const 1 :: integer
-        %t1184 = call core.sub(%t1176, %t1183) :: integer
-        %t1185 = const 0 :: integer
-        %t1186 = call core.clamp(%t1178, %t1185, %t1184) :: integer
-        %t1187 = gather %t1175, %t1186 :: integer
-        %t1188 = const 0 :: integer
-        %t1189 = select %t1182, %t1187, %t1188 :: integer
-        %t1190 = load_input "rows" :: array
-        %t1191 = length %t1190 :: integer
-        %t1192 = const -1 :: integer
-        %t1193 = call core.sub(%rows_i_279, %t1192) :: integer
-        %t1194 = const 0 :: integer
-        %t1195 = call core.gte(%t1193, %t1194) :: boolean
-        %t1196 = call core.lt(%t1193, %t1191) :: boolean
-        %t1197 = call core.and(%t1195, %t1196) :: boolean
-        %t1198 = const 1 :: integer
-        %t1199 = call core.sub(%t1191, %t1198) :: integer
-        %t1200 = const 0 :: integer
-        %t1201 = call core.clamp(%t1193, %t1200, %t1199) :: integer
-        %t1202 = gather %t1190, %t1201 :: any
-        %t1203 = length %t1202 :: integer
-        %t1204 = const -1 :: integer
-        %t1205 = call core.sub(%col_i_281, %t1204) :: integer
-        %t1206 = const 0 :: integer
-        %t1207 = call core.gte(%t1205, %t1206) :: boolean
-        %t1208 = call core.lt(%t1205, %t1203) :: boolean
-        %t1209 = call core.and(%t1207, %t1208) :: boolean
-        %t1210 = call core.and(%t1197, %t1209) :: boolean
-        %t1211 = const 1 :: integer
-        %t1212 = call core.sub(%t1203, %t1211) :: integer
-        %t1213 = const 0 :: integer
-        %t1214 = call core.clamp(%t1205, %t1213, %t1212) :: integer
-        %t1215 = gather %t1202, %t1214 :: integer
+        %t1120 = load_input "rows" :: array
+        %t1121 = length %t1120 :: integer
+        %t1122 = const -1 :: integer
+        %t1123 = call core.sub(%rows_i_279, %t1122) :: integer
+        %t1124 = const 0 :: integer
+        %t1125 = call core.gte(%t1123, %t1124) :: boolean
+        %t1126 = call core.lt(%t1123, %t1121) :: boolean
+        %t1127 = call core.and(%t1125, %t1126) :: boolean
+        %t1128 = const 1 :: integer
+        %t1129 = call core.sub(%t1121, %t1128) :: integer
+        %t1130 = const 0 :: integer
+        %t1131 = call core.clamp(%t1123, %t1130, %t1129) :: integer
+        %t1132 = gather %t1120, %t1131 :: any
+        %t1133 = length %t1132 :: integer
+        %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
+        %t1138 = const 0 :: integer
+        %t1139 = select %t1127, %t1137, %t1138 :: integer
+        %t1140 = load_input "rows" :: array
+        %t1141 = length %t1140 :: integer
+        %t1142 = const 1 :: integer
+        %t1143 = call core.sub(%rows_i_279, %t1142) :: integer
+        %t1144 = const 0 :: integer
+        %t1145 = call core.gte(%t1143, %t1144) :: boolean
+        %t1146 = call core.lt(%t1143, %t1141) :: boolean
+        %t1147 = call core.and(%t1145, %t1146) :: boolean
+        %t1148 = const 1 :: integer
+        %t1149 = call core.sub(%t1141, %t1148) :: integer
+        %t1150 = const 0 :: integer
+        %t1151 = call core.clamp(%t1143, %t1150, %t1149) :: integer
+        %t1152 = gather %t1140, %t1151 :: any
+        %t1153 = length %t1152 :: 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
+        %t1158 = const 0 :: integer
+        %t1159 = select %t1147, %t1157, %t1158 :: integer
+        %t1160 = load_input "rows" :: array
+        %t1161 = length %t1160 :: integer
+        %t1162 = call core.mod(%rows_i_279, %t1161) :: integer
+        %t1163 = call core.add(%t1162, %t1161) :: integer
+        %t1164 = call core.mod(%t1163, %t1161) :: integer
+        %t1165 = gather %t1160, %t1164 :: any
+        %t1166 = length %t1165 :: integer
+        %t1167 = const -1 :: integer
+        %t1168 = call core.sub(%col_i_281, %t1167) :: integer
+        %t1169 = const 0 :: integer
+        %t1170 = call core.gte(%t1168, %t1169) :: boolean
+        %t1171 = call core.lt(%t1168, %t1166) :: boolean
+        %t1172 = call core.and(%t1170, %t1171) :: boolean
+        %t1173 = const 1 :: integer
+        %t1174 = call core.sub(%t1166, %t1173) :: integer
+        %t1175 = const 0 :: integer
+        %t1176 = call core.clamp(%t1168, %t1175, %t1174) :: integer
+        %t1177 = gather %t1165, %t1176 :: integer
+        %t1178 = const 0 :: integer
+        %t1179 = select %t1172, %t1177, %t1178 :: integer
+        %t1180 = load_input "rows" :: array
+        %t1181 = length %t1180 :: integer
+        %t1182 = call core.mod(%rows_i_279, %t1181) :: integer
+        %t1183 = call core.add(%t1182, %t1181) :: integer
+        %t1184 = call core.mod(%t1183, %t1181) :: integer
+        %t1185 = gather %t1180, %t1184 :: any
+        %t1186 = length %t1185 :: integer
+        %t1187 = const 1 :: integer
+        %t1188 = call core.sub(%col_i_281, %t1187) :: integer
+        %t1189 = const 0 :: integer
+        %t1190 = call core.gte(%t1188, %t1189) :: boolean
+        %t1191 = call core.lt(%t1188, %t1186) :: boolean
+        %t1192 = call core.and(%t1190, %t1191) :: boolean
+        %t1193 = const 1 :: integer
+        %t1194 = call core.sub(%t1186, %t1193) :: integer
+        %t1195 = const 0 :: integer
+        %t1196 = call core.clamp(%t1188, %t1195, %t1194) :: integer
+        %t1197 = gather %t1185, %t1196 :: integer
+        %t1198 = const 0 :: integer
+        %t1199 = select %t1192, %t1197, %t1198 :: integer
+        %t1200 = load_input "rows" :: array
+        %t1201 = length %t1200 :: integer
+        %t1202 = const -1 :: integer
+        %t1203 = call core.sub(%rows_i_279, %t1202) :: integer
+        %t1204 = const 0 :: integer
+        %t1205 = call core.gte(%t1203, %t1204) :: boolean
+        %t1206 = call core.lt(%t1203, %t1201) :: boolean
+        %t1207 = call core.and(%t1205, %t1206) :: boolean
+        %t1208 = const 1 :: integer
+        %t1209 = call core.sub(%t1201, %t1208) :: integer
+        %t1210 = const 0 :: integer
+        %t1211 = call core.clamp(%t1203, %t1210, %t1209) :: integer
+        %t1212 = gather %t1200, %t1211 :: any
+        %t1213 = length %t1212 :: integer
+        %t1214 = const -1 :: integer
+        %t1215 = call core.sub(%col_i_281, %t1214) :: integer
         %t1216 = const 0 :: integer
-        %t1217 = select %t1210, %t1215, %t1216 :: integer
-        %t1218 = load_input "rows" :: array
-        %t1219 = length %t1218 :: integer
-        %t1220 = const -1 :: integer
-        %t1221 = call core.sub(%rows_i_279, %t1220) :: integer
-        %t1222 = const 0 :: integer
-        %t1223 = call core.gte(%t1221, %t1222) :: boolean
-        %t1224 = call core.lt(%t1221, %t1219) :: boolean
-        %t1225 = call core.and(%t1223, %t1224) :: boolean
-        %t1226 = const 1 :: integer
-        %t1227 = call core.sub(%t1219, %t1226) :: integer
-        %t1228 = const 0 :: integer
-        %t1229 = call core.clamp(%t1221, %t1228, %t1227) :: integer
-        %t1230 = gather %t1218, %t1229 :: any
-        %t1231 = length %t1230 :: integer
-        %t1232 = const 1 :: integer
-        %t1233 = call core.sub(%col_i_281, %t1232) :: integer
-        %t1234 = const 0 :: integer
-        %t1235 = call core.gte(%t1233, %t1234) :: boolean
-        %t1236 = call core.lt(%t1233, %t1231) :: boolean
-        %t1237 = call core.and(%t1235, %t1236) :: boolean
-        %t1238 = call core.and(%t1225, %t1237) :: boolean
-        %t1239 = const 1 :: integer
-        %t1240 = call core.sub(%t1231, %t1239) :: integer
-        %t1241 = const 0 :: integer
-        %t1242 = call core.clamp(%t1233, %t1241, %t1240) :: integer
-        %t1243 = gather %t1230, %t1242 :: integer
+        %t1217 = call core.gte(%t1215, %t1216) :: boolean
+        %t1218 = call core.lt(%t1215, %t1213) :: boolean
+        %t1219 = call core.and(%t1217, %t1218) :: boolean
+        %t1220 = call core.and(%t1207, %t1219) :: boolean
+        %t1221 = const 1 :: integer
+        %t1222 = call core.sub(%t1213, %t1221) :: integer
+        %t1223 = const 0 :: integer
+        %t1224 = call core.clamp(%t1215, %t1223, %t1222) :: integer
+        %t1225 = gather %t1212, %t1224 :: integer
+        %t1226 = const 0 :: integer
+        %t1227 = select %t1220, %t1225, %t1226 :: integer
+        %t1228 = load_input "rows" :: array
+        %t1229 = length %t1228 :: integer
+        %t1230 = const -1 :: integer
+        %t1231 = call core.sub(%rows_i_279, %t1230) :: integer
+        %t1232 = const 0 :: integer
+        %t1233 = call core.gte(%t1231, %t1232) :: boolean
+        %t1234 = call core.lt(%t1231, %t1229) :: boolean
+        %t1235 = call core.and(%t1233, %t1234) :: boolean
+        %t1236 = const 1 :: integer
+        %t1237 = call core.sub(%t1229, %t1236) :: integer
+        %t1238 = const 0 :: integer
+        %t1239 = call core.clamp(%t1231, %t1238, %t1237) :: integer
+        %t1240 = gather %t1228, %t1239 :: any
+        %t1241 = length %t1240 :: integer
+        %t1242 = const 1 :: integer
+        %t1243 = call core.sub(%col_i_281, %t1242) :: integer
         %t1244 = const 0 :: integer
-        %t1245 = select %t1238, %t1243, %t1244 :: integer
-        %t1246 = load_input "rows" :: array
-        %t1247 = length %t1246 :: integer
-        %t1248 = const 1 :: integer
-        %t1249 = call core.sub(%rows_i_279, %t1248) :: integer
-        %t1250 = const 0 :: integer
-        %t1251 = call core.gte(%t1249, %t1250) :: boolean
-        %t1252 = call core.lt(%t1249, %t1247) :: boolean
-        %t1253 = call core.and(%t1251, %t1252) :: boolean
-        %t1254 = const 1 :: integer
-        %t1255 = call core.sub(%t1247, %t1254) :: integer
-        %t1256 = const 0 :: integer
-        %t1257 = call core.clamp(%t1249, %t1256, %t1255) :: integer
-        %t1258 = gather %t1246, %t1257 :: any
-        %t1259 = length %t1258 :: integer
-        %t1260 = const -1 :: integer
-        %t1261 = call core.sub(%col_i_281, %t1260) :: integer
-        %t1262 = const 0 :: integer
-        %t1263 = call core.gte(%t1261, %t1262) :: boolean
-        %t1264 = call core.lt(%t1261, %t1259) :: boolean
-        %t1265 = call core.and(%t1263, %t1264) :: boolean
-        %t1266 = call core.and(%t1253, %t1265) :: boolean
-        %t1267 = const 1 :: integer
-        %t1268 = call core.sub(%t1259, %t1267) :: integer
-        %t1269 = const 0 :: integer
-        %t1270 = call core.clamp(%t1261, %t1269, %t1268) :: integer
-        %t1271 = gather %t1258, %t1270 :: integer
+        %t1245 = call core.gte(%t1243, %t1244) :: boolean
+        %t1246 = call core.lt(%t1243, %t1241) :: boolean
+        %t1247 = call core.and(%t1245, %t1246) :: boolean
+        %t1248 = call core.and(%t1235, %t1247) :: boolean
+        %t1249 = const 1 :: integer
+        %t1250 = call core.sub(%t1241, %t1249) :: integer
+        %t1251 = const 0 :: integer
+        %t1252 = call core.clamp(%t1243, %t1251, %t1250) :: integer
+        %t1253 = gather %t1240, %t1252 :: integer
+        %t1254 = const 0 :: integer
+        %t1255 = select %t1248, %t1253, %t1254 :: integer
+        %t1256 = load_input "rows" :: array
+        %t1257 = length %t1256 :: integer
+        %t1258 = const 1 :: integer
+        %t1259 = call core.sub(%rows_i_279, %t1258) :: integer
+        %t1260 = const 0 :: integer
+        %t1261 = call core.gte(%t1259, %t1260) :: boolean
+        %t1262 = call core.lt(%t1259, %t1257) :: boolean
+        %t1263 = call core.and(%t1261, %t1262) :: boolean
+        %t1264 = const 1 :: integer
+        %t1265 = call core.sub(%t1257, %t1264) :: integer
+        %t1266 = const 0 :: integer
+        %t1267 = call core.clamp(%t1259, %t1266, %t1265) :: integer
+        %t1268 = gather %t1256, %t1267 :: any
+        %t1269 = length %t1268 :: integer
+        %t1270 = const -1 :: integer
+        %t1271 = call core.sub(%col_i_281, %t1270) :: integer
         %t1272 = const 0 :: integer
-        %t1273 = select %t1266, %t1271, %t1272 :: integer
-        %t1274 = load_input "rows" :: array
-        %t1275 = length %t1274 :: integer
-        %t1276 = const 1 :: integer
-        %t1277 = call core.sub(%rows_i_279, %t1276) :: integer
-        %t1278 = const 0 :: integer
-        %t1279 = call core.gte(%t1277, %t1278) :: boolean
-        %t1280 = call core.lt(%t1277, %t1275) :: boolean
-        %t1281 = call core.and(%t1279, %t1280) :: boolean
-        %t1282 = const 1 :: integer
-        %t1283 = call core.sub(%t1275, %t1282) :: integer
-        %t1284 = const 0 :: integer
-        %t1285 = call core.clamp(%t1277, %t1284, %t1283) :: integer
-        %t1286 = gather %t1274, %t1285 :: any
-        %t1287 = length %t1286 :: integer
-        %t1288 = const 1 :: integer
-        %t1289 = call core.sub(%col_i_281, %t1288) :: integer
-        %t1290 = const 0 :: integer
-        %t1291 = call core.gte(%t1289, %t1290) :: boolean
-        %t1292 = call core.lt(%t1289, %t1287) :: boolean
-        %t1293 = call core.and(%t1291, %t1292) :: boolean
-        %t1294 = call core.and(%t1281, %t1293) :: boolean
-        %t1295 = const 1 :: integer
-        %t1296 = call core.sub(%t1287, %t1295) :: integer
-        %t1297 = const 0 :: integer
-        %t1298 = call core.clamp(%t1289, %t1297, %t1296) :: integer
-        %t1299 = gather %t1286, %t1298 :: integer
+        %t1273 = call core.gte(%t1271, %t1272) :: boolean
+        %t1274 = call core.lt(%t1271, %t1269) :: boolean
+        %t1275 = call core.and(%t1273, %t1274) :: boolean
+        %t1276 = call core.and(%t1263, %t1275) :: boolean
+        %t1277 = const 1 :: integer
+        %t1278 = call core.sub(%t1269, %t1277) :: integer
+        %t1279 = const 0 :: integer
+        %t1280 = call core.clamp(%t1271, %t1279, %t1278) :: integer
+        %t1281 = gather %t1268, %t1280 :: integer
+        %t1282 = const 0 :: integer
+        %t1283 = select %t1276, %t1281, %t1282 :: integer
+        %t1284 = load_input "rows" :: array
+        %t1285 = length %t1284 :: integer
+        %t1286 = const 1 :: integer
+        %t1287 = call core.sub(%rows_i_279, %t1286) :: integer
+        %t1288 = const 0 :: integer
+        %t1289 = call core.gte(%t1287, %t1288) :: boolean
+        %t1290 = call core.lt(%t1287, %t1285) :: boolean
+        %t1291 = call core.and(%t1289, %t1290) :: boolean
+        %t1292 = const 1 :: integer
+        %t1293 = call core.sub(%t1285, %t1292) :: integer
+        %t1294 = const 0 :: integer
+        %t1295 = call core.clamp(%t1287, %t1294, %t1293) :: integer
+        %t1296 = gather %t1284, %t1295 :: any
+        %t1297 = length %t1296 :: integer
+        %t1298 = const 1 :: integer
+        %t1299 = call core.sub(%col_i_281, %t1298) :: integer
         %t1300 = const 0 :: integer
-        %t1301 = select %t1294, %t1299, %t1300 :: integer
-        %t1302 = make_tuple(%t1129, %t1149, %t1169, %t1189, %t1217, %t1245, %t1273, %t1301) :: tuple<integer>
-        %t1303 = fold %t1302 fn="agg.sum" :: 
-        %t519 = const 3 :: integer
-        %t520 = call core.eq(%t1303, %t519) :: boolean
-        %t521 = load_input "rows" :: array
-        %t1304 = load_input "rows" :: array
-        %t1305 = load_input "rows" :: array
-        %t1346 = load_input "rows" :: array
-        %t1347 = length %t1346 :: integer
-        %t1348 = const -1 :: integer
-        %t1349 = call core.sub(%rows_i_279, %t1348) :: integer
-        %t1350 = const 0 :: integer
-        %t1351 = call core.gte(%t1349, %t1350) :: boolean
-        %t1352 = call core.lt(%t1349, %t1347) :: boolean
-        %t1353 = call core.and(%t1351, %t1352) :: boolean
-        %t1354 = const 1 :: integer
-        %t1355 = call core.sub(%t1347, %t1354) :: integer
-        %t1356 = const 0 :: integer
-        %t1357 = call core.clamp(%t1349, %t1356, %t1355) :: integer
-        %t1358 = gather %t1346, %t1357 :: any
-        %t1359 = length %t1358 :: integer
-        %t1360 = call core.mod(%col_i_281, %t1359) :: integer
-        %t1361 = call core.add(%t1360, %t1359) :: integer
-        %t1362 = call core.mod(%t1361, %t1359) :: integer
-        %t1363 = gather %t1358, %t1362 :: integer
-        %t1364 = const 0 :: integer
-        %t1365 = select %t1353, %t1363, %t1364 :: integer
-        %t1366 = load_input "rows" :: array
-        %t1367 = length %t1366 :: integer
-        %t1368 = const 1 :: integer
-        %t1369 = call core.sub(%rows_i_279, %t1368) :: integer
-        %t1370 = const 0 :: integer
-        %t1371 = call core.gte(%t1369, %t1370) :: boolean
-        %t1372 = call core.lt(%t1369, %t1367) :: boolean
-        %t1373 = call core.and(%t1371, %t1372) :: boolean
-        %t1374 = const 1 :: integer
-        %t1375 = call core.sub(%t1367, %t1374) :: integer
-        %t1376 = const 0 :: integer
-        %t1377 = call core.clamp(%t1369, %t1376, %t1375) :: integer
-        %t1378 = gather %t1366, %t1377 :: any
-        %t1379 = length %t1378 :: integer
-        %t1380 = call core.mod(%col_i_281, %t1379) :: integer
-        %t1381 = call core.add(%t1380, %t1379) :: integer
-        %t1382 = call core.mod(%t1381, %t1379) :: integer
-        %t1383 = gather %t1378, %t1382 :: integer
-        %t1384 = const 0 :: integer
-        %t1385 = select %t1373, %t1383, %t1384 :: integer
-        %t1386 = load_input "rows" :: array
-        %t1387 = length %t1386 :: integer
-        %t1388 = call core.mod(%rows_i_279, %t1387) :: integer
-        %t1389 = call core.add(%t1388, %t1387) :: integer
-        %t1390 = call core.mod(%t1389, %t1387) :: integer
-        %t1391 = gather %t1386, %t1390 :: any
+        %t1301 = call core.gte(%t1299, %t1300) :: boolean
+        %t1302 = call core.lt(%t1299, %t1297) :: boolean
+        %t1303 = call core.and(%t1301, %t1302) :: boolean
+        %t1304 = call core.and(%t1291, %t1303) :: boolean
+        %t1305 = const 1 :: integer
+        %t1306 = call core.sub(%t1297, %t1305) :: integer
+        %t1307 = const 0 :: integer
+        %t1308 = call core.clamp(%t1299, %t1307, %t1306) :: integer
+        %t1309 = gather %t1296, %t1308 :: integer
+        %t1310 = const 0 :: integer
+        %t1311 = select %t1304, %t1309, %t1310 :: integer
+        %t1118 = make_tuple(%t1139, %t1159, %t1179, %t1199, %t1227, %t1255, %t1283, %t1311) :: tuple<integer>
+        %t1119 = fold %t1118 fn="agg.sum" :: 
+        %t1107 = const 3 :: integer
+        %t1108 = call core.eq(%t1119, %t1107) :: boolean
+        %t1312 = load_input "rows" :: array
+        %t1316 = load_input "rows" :: array
+        %t1320 = load_input "rows" :: array
+        %t1331 = load_input "rows" :: array
+        %t1332 = length %t1331 :: integer
+        %t1333 = const -1 :: integer
+        %t1334 = call core.sub(%rows_i_279, %t1333) :: integer
+        %t1335 = const 0 :: integer
+        %t1336 = call core.gte(%t1334, %t1335) :: boolean
+        %t1337 = call core.lt(%t1334, %t1332) :: boolean
+        %t1338 = call core.and(%t1336, %t1337) :: boolean
+        %t1339 = const 1 :: integer
+        %t1340 = call core.sub(%t1332, %t1339) :: integer
+        %t1341 = const 0 :: integer
+        %t1342 = call core.clamp(%t1334, %t1341, %t1340) :: integer
+        %t1343 = gather %t1331, %t1342 :: any
+        %t1344 = length %t1343 :: integer
+        %t1345 = call core.mod(%col_i_281, %t1344) :: integer
+        %t1346 = call core.add(%t1345, %t1344) :: integer
+        %t1347 = call core.mod(%t1346, %t1344) :: integer
+        %t1348 = gather %t1343, %t1347 :: integer
+        %t1349 = const 0 :: integer
+        %t1350 = select %t1338, %t1348, %t1349 :: integer
+        %t1351 = load_input "rows" :: array
+        %t1352 = length %t1351 :: integer
+        %t1353 = const 1 :: integer
+        %t1354 = call core.sub(%rows_i_279, %t1353) :: integer
+        %t1355 = const 0 :: integer
+        %t1356 = call core.gte(%t1354, %t1355) :: boolean
+        %t1357 = call core.lt(%t1354, %t1352) :: boolean
+        %t1358 = call core.and(%t1356, %t1357) :: boolean
+        %t1359 = const 1 :: integer
+        %t1360 = call core.sub(%t1352, %t1359) :: integer
+        %t1361 = const 0 :: integer
+        %t1362 = call core.clamp(%t1354, %t1361, %t1360) :: integer
+        %t1363 = gather %t1351, %t1362 :: any
+        %t1364 = length %t1363 :: integer
+        %t1365 = call core.mod(%col_i_281, %t1364) :: integer
+        %t1366 = call core.add(%t1365, %t1364) :: integer
+        %t1367 = call core.mod(%t1366, %t1364) :: integer
+        %t1368 = gather %t1363, %t1367 :: integer
+        %t1369 = const 0 :: integer
+        %t1370 = select %t1358, %t1368, %t1369 :: integer
+        %t1371 = load_input "rows" :: array
+        %t1372 = length %t1371 :: integer
+        %t1373 = call core.mod(%rows_i_279, %t1372) :: integer
+        %t1374 = call core.add(%t1373, %t1372) :: integer
+        %t1375 = call core.mod(%t1374, %t1372) :: integer
+        %t1376 = gather %t1371, %t1375 :: any
+        %t1377 = length %t1376 :: integer
+        %t1378 = const -1 :: integer
+        %t1379 = call core.sub(%col_i_281, %t1378) :: integer
+        %t1380 = const 0 :: integer
+        %t1381 = call core.gte(%t1379, %t1380) :: boolean
+        %t1382 = call core.lt(%t1379, %t1377) :: boolean
+        %t1383 = call core.and(%t1381, %t1382) :: boolean
+        %t1384 = const 1 :: integer
+        %t1385 = call core.sub(%t1377, %t1384) :: integer
+        %t1386 = const 0 :: integer
+        %t1387 = call core.clamp(%t1379, %t1386, %t1385) :: integer
+        %t1388 = gather %t1376, %t1387 :: integer
+        %t1389 = const 0 :: integer
+        %t1390 = select %t1383, %t1388, %t1389 :: integer
+        %t1391 = load_input "rows" :: array
         %t1392 = length %t1391 :: integer
-        %t1393 = const -1 :: integer
-        %t1394 = call core.sub(%col_i_281, %t1393) :: integer
-        %t1395 = const 0 :: integer
-        %t1396 = call core.gte(%t1394, %t1395) :: boolean
-        %t1397 = call core.lt(%t1394, %t1392) :: boolean
-        %t1398 = call core.and(%t1396, %t1397) :: boolean
-        %t1399 = const 1 :: integer
-        %t1400 = call core.sub(%t1392, %t1399) :: integer
-        %t1401 = const 0 :: integer
-        %t1402 = call core.clamp(%t1394, %t1401, %t1400) :: integer
-        %t1403 = gather %t1391, %t1402 :: integer
-        %t1404 = const 0 :: integer
-        %t1405 = select %t1398, %t1403, %t1404 :: integer
-        %t1406 = load_input "rows" :: array
-        %t1407 = length %t1406 :: integer
-        %t1408 = call core.mod(%rows_i_279, %t1407) :: integer
-        %t1409 = call core.add(%t1408, %t1407) :: integer
-        %t1410 = call core.mod(%t1409, %t1407) :: integer
-        %t1411 = gather %t1406, %t1410 :: any
+        %t1393 = call core.mod(%rows_i_279, %t1392) :: integer
+        %t1394 = call core.add(%t1393, %t1392) :: integer
+        %t1395 = call core.mod(%t1394, %t1392) :: integer
+        %t1396 = gather %t1391, %t1395 :: any
+        %t1397 = length %t1396 :: integer
+        %t1398 = const 1 :: integer
+        %t1399 = call core.sub(%col_i_281, %t1398) :: integer
+        %t1400 = const 0 :: integer
+        %t1401 = call core.gte(%t1399, %t1400) :: boolean
+        %t1402 = call core.lt(%t1399, %t1397) :: boolean
+        %t1403 = call core.and(%t1401, %t1402) :: boolean
+        %t1404 = const 1 :: integer
+        %t1405 = call core.sub(%t1397, %t1404) :: integer
+        %t1406 = const 0 :: integer
+        %t1407 = call core.clamp(%t1399, %t1406, %t1405) :: integer
+        %t1408 = gather %t1396, %t1407 :: integer
+        %t1409 = const 0 :: integer
+        %t1410 = select %t1403, %t1408, %t1409 :: integer
+        %t1411 = load_input "rows" :: array
         %t1412 = length %t1411 :: integer
-        %t1413 = const 1 :: integer
-        %t1414 = call core.sub(%col_i_281, %t1413) :: integer
+        %t1413 = const -1 :: integer
+        %t1414 = call core.sub(%rows_i_279, %t1413) :: integer
         %t1415 = const 0 :: integer
         %t1416 = call core.gte(%t1414, %t1415) :: boolean
         %t1417 = call core.lt(%t1414, %t1412) :: boolean
@@ -1371,131 +1386,116 @@
         %t1420 = call core.sub(%t1412, %t1419) :: integer
         %t1421 = const 0 :: integer
         %t1422 = call core.clamp(%t1414, %t1421, %t1420) :: integer
-        %t1423 = gather %t1411, %t1422 :: integer
-        %t1424 = const 0 :: integer
-        %t1425 = select %t1418, %t1423, %t1424 :: integer
-        %t1426 = load_input "rows" :: array
-        %t1427 = length %t1426 :: integer
-        %t1428 = const -1 :: integer
-        %t1429 = call core.sub(%rows_i_279, %t1428) :: integer
-        %t1430 = const 0 :: integer
-        %t1431 = call core.gte(%t1429, %t1430) :: boolean
-        %t1432 = call core.lt(%t1429, %t1427) :: boolean
-        %t1433 = call core.and(%t1431, %t1432) :: boolean
-        %t1434 = const 1 :: integer
-        %t1435 = call core.sub(%t1427, %t1434) :: integer
-        %t1436 = const 0 :: integer
-        %t1437 = call core.clamp(%t1429, %t1436, %t1435) :: integer
-        %t1438 = gather %t1426, %t1437 :: any
-        %t1439 = length %t1438 :: integer
-        %t1440 = const -1 :: integer
-        %t1441 = call core.sub(%col_i_281, %t1440) :: integer
-        %t1442 = const 0 :: integer
-        %t1443 = call core.gte(%t1441, %t1442) :: boolean
-        %t1444 = call core.lt(%t1441, %t1439) :: boolean
-        %t1445 = call core.and(%t1443, %t1444) :: boolean
-        %t1446 = call core.and(%t1433, %t1445) :: boolean
+        %t1423 = gather %t1411, %t1422 :: any
+        %t1424 = length %t1423 :: integer
+        %t1425 = const -1 :: integer
+        %t1426 = call core.sub(%col_i_281, %t1425) :: integer
+        %t1427 = const 0 :: integer
+        %t1428 = call core.gte(%t1426, %t1427) :: boolean
+        %t1429 = call core.lt(%t1426, %t1424) :: boolean
+        %t1430 = call core.and(%t1428, %t1429) :: boolean
+        %t1431 = call core.and(%t1418, %t1430) :: boolean
+        %t1432 = const 1 :: integer
+        %t1433 = call core.sub(%t1424, %t1432) :: integer
+        %t1434 = const 0 :: integer
+        %t1435 = call core.clamp(%t1426, %t1434, %t1433) :: integer
+        %t1436 = gather %t1423, %t1435 :: integer
+        %t1437 = const 0 :: integer
+        %t1438 = select %t1431, %t1436, %t1437 :: integer
+        %t1439 = load_input "rows" :: array
+        %t1440 = length %t1439 :: integer
+        %t1441 = const -1 :: integer
+        %t1442 = call core.sub(%rows_i_279, %t1441) :: integer
+        %t1443 = const 0 :: integer
+        %t1444 = call core.gte(%t1442, %t1443) :: boolean
+        %t1445 = call core.lt(%t1442, %t1440) :: boolean
+        %t1446 = call core.and(%t1444, %t1445) :: boolean
         %t1447 = const 1 :: integer
-        %t1448 = call core.sub(%t1439, %t1447) :: integer
+        %t1448 = call core.sub(%t1440, %t1447) :: integer
         %t1449 = const 0 :: integer
-        %t1450 = call core.clamp(%t1441, %t1449, %t1448) :: integer
-        %t1451 = gather %t1438, %t1450 :: integer
-        %t1452 = const 0 :: integer
-        %t1453 = select %t1446, %t1451, %t1452 :: integer
-        %t1454 = load_input "rows" :: array
-        %t1455 = length %t1454 :: integer
-        %t1456 = const -1 :: integer
-        %t1457 = call core.sub(%rows_i_279, %t1456) :: integer
-        %t1458 = const 0 :: integer
-        %t1459 = call core.gte(%t1457, %t1458) :: boolean
-        %t1460 = call core.lt(%t1457, %t1455) :: boolean
-        %t1461 = call core.and(%t1459, %t1460) :: boolean
-        %t1462 = const 1 :: integer
-        %t1463 = call core.sub(%t1455, %t1462) :: integer
-        %t1464 = const 0 :: integer
-        %t1465 = call core.clamp(%t1457, %t1464, %t1463) :: integer
-        %t1466 = gather %t1454, %t1465 :: any
-        %t1467 = length %t1466 :: integer
-        %t1468 = const 1 :: integer
-        %t1469 = call core.sub(%col_i_281, %t1468) :: integer
-        %t1470 = const 0 :: integer
-        %t1471 = call core.gte(%t1469, %t1470) :: boolean
-        %t1472 = call core.lt(%t1469, %t1467) :: boolean
-        %t1473 = call core.and(%t1471, %t1472) :: boolean
-        %t1474 = call core.and(%t1461, %t1473) :: boolean
+        %t1450 = call core.clamp(%t1442, %t1449, %t1448) :: integer
+        %t1451 = gather %t1439, %t1450 :: any
+        %t1452 = length %t1451 :: integer
+        %t1453 = const 1 :: integer
+        %t1454 = call core.sub(%col_i_281, %t1453) :: integer
+        %t1455 = const 0 :: integer
+        %t1456 = call core.gte(%t1454, %t1455) :: boolean
+        %t1457 = call core.lt(%t1454, %t1452) :: boolean
+        %t1458 = call core.and(%t1456, %t1457) :: boolean
+        %t1459 = call core.and(%t1446, %t1458) :: boolean
+        %t1460 = const 1 :: integer
+        %t1461 = call core.sub(%t1452, %t1460) :: integer
+        %t1462 = const 0 :: integer
+        %t1463 = call core.clamp(%t1454, %t1462, %t1461) :: integer
+        %t1464 = gather %t1451, %t1463 :: integer
+        %t1465 = const 0 :: integer
+        %t1466 = select %t1459, %t1464, %t1465 :: integer
+        %t1467 = load_input "rows" :: array
+        %t1468 = length %t1467 :: integer
+        %t1469 = const 1 :: integer
+        %t1470 = call core.sub(%rows_i_279, %t1469) :: integer
+        %t1471 = const 0 :: integer
+        %t1472 = call core.gte(%t1470, %t1471) :: boolean
+        %t1473 = call core.lt(%t1470, %t1468) :: boolean
+        %t1474 = call core.and(%t1472, %t1473) :: boolean
         %t1475 = const 1 :: integer
-        %t1476 = call core.sub(%t1467, %t1475) :: integer
+        %t1476 = call core.sub(%t1468, %t1475) :: integer
         %t1477 = const 0 :: integer
-        %t1478 = call core.clamp(%t1469, %t1477, %t1476) :: integer
-        %t1479 = gather %t1466, %t1478 :: integer
-        %t1480 = const 0 :: integer
-        %t1481 = select %t1474, %t1479, %t1480 :: integer
-        %t1482 = load_input "rows" :: array
-        %t1483 = length %t1482 :: integer
-        %t1484 = const 1 :: integer
-        %t1485 = call core.sub(%rows_i_279, %t1484) :: integer
-        %t1486 = const 0 :: integer
-        %t1487 = call core.gte(%t1485, %t1486) :: boolean
-        %t1488 = call core.lt(%t1485, %t1483) :: boolean
-        %t1489 = call core.and(%t1487, %t1488) :: boolean
-        %t1490 = const 1 :: integer
-        %t1491 = call core.sub(%t1483, %t1490) :: integer
-        %t1492 = const 0 :: integer
-        %t1493 = call core.clamp(%t1485, %t1492, %t1491) :: integer
-        %t1494 = gather %t1482, %t1493 :: any
-        %t1495 = length %t1494 :: integer
-        %t1496 = const -1 :: integer
-        %t1497 = call core.sub(%col_i_281, %t1496) :: integer
-        %t1498 = const 0 :: integer
-        %t1499 = call core.gte(%t1497, %t1498) :: boolean
-        %t1500 = call core.lt(%t1497, %t1495) :: boolean
-        %t1501 = call core.and(%t1499, %t1500) :: boolean
-        %t1502 = call core.and(%t1489, %t1501) :: boolean
+        %t1478 = call core.clamp(%t1470, %t1477, %t1476) :: integer
+        %t1479 = gather %t1467, %t1478 :: any
+        %t1480 = length %t1479 :: integer
+        %t1481 = const -1 :: integer
+        %t1482 = call core.sub(%col_i_281, %t1481) :: integer
+        %t1483 = const 0 :: integer
+        %t1484 = call core.gte(%t1482, %t1483) :: boolean
+        %t1485 = call core.lt(%t1482, %t1480) :: boolean
+        %t1486 = call core.and(%t1484, %t1485) :: boolean
+        %t1487 = call core.and(%t1474, %t1486) :: boolean
+        %t1488 = const 1 :: integer
+        %t1489 = call core.sub(%t1480, %t1488) :: integer
+        %t1490 = const 0 :: integer
+        %t1491 = call core.clamp(%t1482, %t1490, %t1489) :: integer
+        %t1492 = gather %t1479, %t1491 :: integer
+        %t1493 = const 0 :: integer
+        %t1494 = select %t1487, %t1492, %t1493 :: integer
+        %t1495 = load_input "rows" :: array
+        %t1496 = length %t1495 :: integer
+        %t1497 = const 1 :: integer
+        %t1498 = call core.sub(%rows_i_279, %t1497) :: integer
+        %t1499 = const 0 :: integer
+        %t1500 = call core.gte(%t1498, %t1499) :: boolean
+        %t1501 = call core.lt(%t1498, %t1496) :: boolean
+        %t1502 = call core.and(%t1500, %t1501) :: boolean
         %t1503 = const 1 :: integer
-        %t1504 = call core.sub(%t1495, %t1503) :: integer
+        %t1504 = call core.sub(%t1496, %t1503) :: integer
         %t1505 = const 0 :: integer
-        %t1506 = call core.clamp(%t1497, %t1505, %t1504) :: integer
-        %t1507 = gather %t1494, %t1506 :: integer
-        %t1508 = const 0 :: integer
-        %t1509 = select %t1502, %t1507, %t1508 :: integer
-        %t1510 = load_input "rows" :: array
-        %t1511 = length %t1510 :: integer
-        %t1512 = const 1 :: integer
-        %t1513 = call core.sub(%rows_i_279, %t1512) :: integer
-        %t1514 = const 0 :: integer
-        %t1515 = call core.gte(%t1513, %t1514) :: boolean
-        %t1516 = call core.lt(%t1513, %t1511) :: boolean
-        %t1517 = call core.and(%t1515, %t1516) :: boolean
-        %t1518 = const 1 :: integer
-        %t1519 = call core.sub(%t1511, %t1518) :: integer
-        %t1520 = const 0 :: integer
-        %t1521 = call core.clamp(%t1513, %t1520, %t1519) :: integer
-        %t1522 = gather %t1510, %t1521 :: any
-        %t1523 = length %t1522 :: integer
-        %t1524 = const 1 :: integer
-        %t1525 = call core.sub(%col_i_281, %t1524) :: integer
-        %t1526 = const 0 :: integer
-        %t1527 = call core.gte(%t1525, %t1526) :: boolean
-        %t1528 = call core.lt(%t1525, %t1523) :: boolean
-        %t1529 = call core.and(%t1527, %t1528) :: boolean
-        %t1530 = call core.and(%t1517, %t1529) :: boolean
-        %t1531 = const 1 :: integer
-        %t1532 = call core.sub(%t1523, %t1531) :: integer
-        %t1533 = const 0 :: integer
-        %t1534 = call core.clamp(%t1525, %t1533, %t1532) :: integer
-        %t1535 = gather %t1522, %t1534 :: integer
-        %t1536 = const 0 :: integer
-        %t1537 = select %t1530, %t1535, %t1536 :: integer
-        %t1314 = make_tuple(%t1365, %t1385, %t1405, %t1425, %t1453, %t1481, %t1509, %t1537) :: tuple<integer>
-        %t1315 = fold %t1314 fn="agg.sum" :: 
-        %t1316 = const 2 :: integer
-        %t1317 = call core.eq(%t1315, %t1316) :: boolean
-        %t1318 = load_input "rows" :: array
-        %t1319 = load_input "rows" :: array
-        %t1320 = const 0 :: integer
-        %t1321 = call core.gt(%col_el_280, %t1320) :: boolean
-        %t524 = call core.and(%t1317, %t1321) :: boolean
-        %t284 = call core.or(%t520, %t524) :: boolean
+        %t1506 = call core.clamp(%t1498, %t1505, %t1504) :: integer
+        %t1507 = gather %t1495, %t1506 :: any
+        %t1508 = length %t1507 :: integer
+        %t1509 = const 1 :: integer
+        %t1510 = call core.sub(%col_i_281, %t1509) :: integer
+        %t1511 = const 0 :: integer
+        %t1512 = call core.gte(%t1510, %t1511) :: boolean
+        %t1513 = call core.lt(%t1510, %t1508) :: boolean
+        %t1514 = call core.and(%t1512, %t1513) :: boolean
+        %t1515 = call core.and(%t1502, %t1514) :: boolean
+        %t1516 = const 1 :: integer
+        %t1517 = call core.sub(%t1508, %t1516) :: integer
+        %t1518 = const 0 :: integer
+        %t1519 = call core.clamp(%t1510, %t1518, %t1517) :: integer
+        %t1520 = gather %t1507, %t1519 :: integer
+        %t1521 = const 0 :: integer
+        %t1522 = select %t1515, %t1520, %t1521 :: integer
+        %t1329 = make_tuple(%t1350, %t1370, %t1390, %t1410, %t1438, %t1466, %t1494, %t1522) :: tuple<integer>
+        %t1330 = fold %t1329 fn="agg.sum" :: 
+        %t1318 = const 2 :: integer
+        %t1319 = call core.eq(%t1330, %t1318) :: boolean
+        %t1523 = load_input "rows" :: array
+        %t1527 = load_input "rows" :: array
+        %t1525 = const 0 :: integer
+        %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
@@ -1504,413 +1504,413 @@
     %t285 = load_input "rows" :: array
     loop rows id=L31 in %t285 as el=%rows_el_286, idx=%rows_i_287
       loop col id=L32 in %rows_el_286 as el=%col_el_288, idx=%col_i_289
-        %t525 = load_input "rows" :: array
-        %t1322 = load_input "rows" :: array
-        %t1323 = load_input "rows" :: array
-        %t1538 = load_input "rows" :: array
-        %t1539 = length %t1538 :: integer
-        %t1540 = const -1 :: integer
-        %t1541 = call core.sub(%rows_i_287, %t1540) :: integer
-        %t1542 = const 0 :: integer
-        %t1543 = call core.gte(%t1541, %t1542) :: boolean
-        %t1544 = call core.lt(%t1541, %t1539) :: boolean
-        %t1545 = call core.and(%t1543, %t1544) :: boolean
-        %t1546 = const 1 :: integer
-        %t1547 = call core.sub(%t1539, %t1546) :: integer
-        %t1548 = const 0 :: integer
-        %t1549 = call core.clamp(%t1541, %t1548, %t1547) :: integer
-        %t1550 = gather %t1538, %t1549 :: any
-        %t1551 = length %t1550 :: integer
-        %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
-        %t1556 = const 0 :: integer
-        %t1557 = select %t1545, %t1555, %t1556 :: integer
-        %t1558 = load_input "rows" :: array
-        %t1559 = length %t1558 :: integer
-        %t1560 = const 1 :: integer
-        %t1561 = call core.sub(%rows_i_287, %t1560) :: integer
-        %t1562 = const 0 :: integer
-        %t1563 = call core.gte(%t1561, %t1562) :: boolean
-        %t1564 = call core.lt(%t1561, %t1559) :: boolean
-        %t1565 = call core.and(%t1563, %t1564) :: boolean
-        %t1566 = const 1 :: integer
-        %t1567 = call core.sub(%t1559, %t1566) :: integer
-        %t1568 = const 0 :: integer
-        %t1569 = call core.clamp(%t1561, %t1568, %t1567) :: integer
-        %t1570 = gather %t1558, %t1569 :: any
-        %t1571 = length %t1570 :: 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
-        %t1576 = const 0 :: integer
-        %t1577 = select %t1565, %t1575, %t1576 :: integer
-        %t1578 = load_input "rows" :: array
-        %t1579 = length %t1578 :: integer
-        %t1580 = call core.mod(%rows_i_287, %t1579) :: integer
-        %t1581 = call core.add(%t1580, %t1579) :: integer
-        %t1582 = call core.mod(%t1581, %t1579) :: integer
-        %t1583 = gather %t1578, %t1582 :: any
-        %t1584 = length %t1583 :: integer
-        %t1585 = const -1 :: integer
-        %t1586 = call core.sub(%col_i_289, %t1585) :: integer
-        %t1587 = const 0 :: integer
-        %t1588 = call core.gte(%t1586, %t1587) :: boolean
-        %t1589 = call core.lt(%t1586, %t1584) :: boolean
-        %t1590 = call core.and(%t1588, %t1589) :: boolean
-        %t1591 = const 1 :: integer
-        %t1592 = call core.sub(%t1584, %t1591) :: integer
-        %t1593 = const 0 :: integer
-        %t1594 = call core.clamp(%t1586, %t1593, %t1592) :: integer
-        %t1595 = gather %t1583, %t1594 :: integer
+        %t1528 = load_input "rows" :: array
+        %t1532 = load_input "rows" :: array
+        %t1536 = load_input "rows" :: array
+        %t1547 = load_input "rows" :: array
+        %t1548 = length %t1547 :: integer
+        %t1549 = const -1 :: integer
+        %t1550 = call core.sub(%rows_i_287, %t1549) :: integer
+        %t1551 = const 0 :: integer
+        %t1552 = call core.gte(%t1550, %t1551) :: boolean
+        %t1553 = call core.lt(%t1550, %t1548) :: boolean
+        %t1554 = call core.and(%t1552, %t1553) :: boolean
+        %t1555 = const 1 :: integer
+        %t1556 = call core.sub(%t1548, %t1555) :: integer
+        %t1557 = const 0 :: integer
+        %t1558 = call core.clamp(%t1550, %t1557, %t1556) :: integer
+        %t1559 = gather %t1547, %t1558 :: any
+        %t1560 = length %t1559 :: 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
+        %t1565 = const 0 :: integer
+        %t1566 = select %t1554, %t1564, %t1565 :: integer
+        %t1567 = load_input "rows" :: array
+        %t1568 = length %t1567 :: integer
+        %t1569 = const 1 :: integer
+        %t1570 = call core.sub(%rows_i_287, %t1569) :: integer
+        %t1571 = const 0 :: integer
+        %t1572 = call core.gte(%t1570, %t1571) :: boolean
+        %t1573 = call core.lt(%t1570, %t1568) :: boolean
+        %t1574 = call core.and(%t1572, %t1573) :: boolean
+        %t1575 = const 1 :: integer
+        %t1576 = call core.sub(%t1568, %t1575) :: integer
+        %t1577 = const 0 :: integer
+        %t1578 = call core.clamp(%t1570, %t1577, %t1576) :: integer
+        %t1579 = gather %t1567, %t1578 :: any
+        %t1580 = length %t1579 :: 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
+        %t1585 = const 0 :: integer
+        %t1586 = select %t1574, %t1584, %t1585 :: integer
+        %t1587 = load_input "rows" :: array
+        %t1588 = length %t1587 :: integer
+        %t1589 = call core.mod(%rows_i_287, %t1588) :: integer
+        %t1590 = call core.add(%t1589, %t1588) :: integer
+        %t1591 = call core.mod(%t1590, %t1588) :: integer
+        %t1592 = gather %t1587, %t1591 :: any
+        %t1593 = length %t1592 :: integer
+        %t1594 = const -1 :: integer
+        %t1595 = call core.sub(%col_i_289, %t1594) :: integer
         %t1596 = const 0 :: integer
-        %t1597 = select %t1590, %t1595, %t1596 :: integer
-        %t1598 = load_input "rows" :: array
-        %t1599 = length %t1598 :: integer
-        %t1600 = call core.mod(%rows_i_287, %t1599) :: integer
-        %t1601 = call core.add(%t1600, %t1599) :: integer
-        %t1602 = call core.mod(%t1601, %t1599) :: integer
-        %t1603 = gather %t1598, %t1602 :: any
-        %t1604 = length %t1603 :: integer
-        %t1605 = const 1 :: integer
-        %t1606 = call core.sub(%col_i_289, %t1605) :: integer
-        %t1607 = const 0 :: integer
-        %t1608 = call core.gte(%t1606, %t1607) :: boolean
-        %t1609 = call core.lt(%t1606, %t1604) :: boolean
-        %t1610 = call core.and(%t1608, %t1609) :: boolean
-        %t1611 = const 1 :: integer
-        %t1612 = call core.sub(%t1604, %t1611) :: integer
-        %t1613 = const 0 :: integer
-        %t1614 = call core.clamp(%t1606, %t1613, %t1612) :: integer
-        %t1615 = gather %t1603, %t1614 :: integer
+        %t1597 = call core.gte(%t1595, %t1596) :: boolean
+        %t1598 = call core.lt(%t1595, %t1593) :: boolean
+        %t1599 = call core.and(%t1597, %t1598) :: boolean
+        %t1600 = const 1 :: integer
+        %t1601 = call core.sub(%t1593, %t1600) :: integer
+        %t1602 = const 0 :: integer
+        %t1603 = call core.clamp(%t1595, %t1602, %t1601) :: integer
+        %t1604 = gather %t1592, %t1603 :: integer
+        %t1605 = const 0 :: integer
+        %t1606 = select %t1599, %t1604, %t1605 :: integer
+        %t1607 = load_input "rows" :: array
+        %t1608 = length %t1607 :: integer
+        %t1609 = call core.mod(%rows_i_287, %t1608) :: integer
+        %t1610 = call core.add(%t1609, %t1608) :: integer
+        %t1611 = call core.mod(%t1610, %t1608) :: integer
+        %t1612 = gather %t1607, %t1611 :: any
+        %t1613 = length %t1612 :: integer
+        %t1614 = const 1 :: integer
+        %t1615 = call core.sub(%col_i_289, %t1614) :: integer
         %t1616 = const 0 :: integer
-        %t1617 = select %t1610, %t1615, %t1616 :: integer
-        %t1618 = load_input "rows" :: array
-        %t1619 = length %t1618 :: integer
-        %t1620 = const -1 :: integer
-        %t1621 = call core.sub(%rows_i_287, %t1620) :: integer
+        %t1617 = call core.gte(%t1615, %t1616) :: boolean
+        %t1618 = call core.lt(%t1615, %t1613) :: boolean
+        %t1619 = call core.and(%t1617, %t1618) :: boolean
+        %t1620 = const 1 :: integer
+        %t1621 = call core.sub(%t1613, %t1620) :: integer
         %t1622 = const 0 :: integer
-        %t1623 = call core.gte(%t1621, %t1622) :: boolean
-        %t1624 = call core.lt(%t1621, %t1619) :: boolean
-        %t1625 = call core.and(%t1623, %t1624) :: boolean
-        %t1626 = const 1 :: integer
-        %t1627 = call core.sub(%t1619, %t1626) :: integer
-        %t1628 = const 0 :: integer
-        %t1629 = call core.clamp(%t1621, %t1628, %t1627) :: integer
-        %t1630 = gather %t1618, %t1629 :: any
-        %t1631 = length %t1630 :: integer
-        %t1632 = const -1 :: integer
-        %t1633 = call core.sub(%col_i_289, %t1632) :: integer
-        %t1634 = const 0 :: integer
-        %t1635 = call core.gte(%t1633, %t1634) :: boolean
-        %t1636 = call core.lt(%t1633, %t1631) :: boolean
-        %t1637 = call core.and(%t1635, %t1636) :: boolean
-        %t1638 = call core.and(%t1625, %t1637) :: boolean
-        %t1639 = const 1 :: integer
-        %t1640 = call core.sub(%t1631, %t1639) :: integer
-        %t1641 = const 0 :: integer
-        %t1642 = call core.clamp(%t1633, %t1641, %t1640) :: integer
-        %t1643 = gather %t1630, %t1642 :: integer
-        %t1644 = const 0 :: integer
-        %t1645 = select %t1638, %t1643, %t1644 :: integer
-        %t1646 = load_input "rows" :: array
-        %t1647 = length %t1646 :: integer
-        %t1648 = const -1 :: integer
-        %t1649 = call core.sub(%rows_i_287, %t1648) :: integer
+        %t1623 = call core.clamp(%t1615, %t1622, %t1621) :: integer
+        %t1624 = gather %t1612, %t1623 :: integer
+        %t1625 = const 0 :: integer
+        %t1626 = select %t1619, %t1624, %t1625 :: integer
+        %t1627 = load_input "rows" :: array
+        %t1628 = length %t1627 :: integer
+        %t1629 = const -1 :: integer
+        %t1630 = call core.sub(%rows_i_287, %t1629) :: integer
+        %t1631 = const 0 :: integer
+        %t1632 = call core.gte(%t1630, %t1631) :: boolean
+        %t1633 = call core.lt(%t1630, %t1628) :: boolean
+        %t1634 = call core.and(%t1632, %t1633) :: boolean
+        %t1635 = const 1 :: integer
+        %t1636 = call core.sub(%t1628, %t1635) :: integer
+        %t1637 = const 0 :: integer
+        %t1638 = call core.clamp(%t1630, %t1637, %t1636) :: integer
+        %t1639 = gather %t1627, %t1638 :: any
+        %t1640 = length %t1639 :: integer
+        %t1641 = const -1 :: integer
+        %t1642 = call core.sub(%col_i_289, %t1641) :: integer
+        %t1643 = const 0 :: integer
+        %t1644 = call core.gte(%t1642, %t1643) :: boolean
+        %t1645 = call core.lt(%t1642, %t1640) :: boolean
+        %t1646 = call core.and(%t1644, %t1645) :: boolean
+        %t1647 = call core.and(%t1634, %t1646) :: boolean
+        %t1648 = const 1 :: integer
+        %t1649 = call core.sub(%t1640, %t1648) :: integer
         %t1650 = const 0 :: integer
-        %t1651 = call core.gte(%t1649, %t1650) :: boolean
-        %t1652 = call core.lt(%t1649, %t1647) :: boolean
-        %t1653 = call core.and(%t1651, %t1652) :: boolean
-        %t1654 = const 1 :: integer
-        %t1655 = call core.sub(%t1647, %t1654) :: integer
-        %t1656 = const 0 :: integer
-        %t1657 = call core.clamp(%t1649, %t1656, %t1655) :: integer
-        %t1658 = gather %t1646, %t1657 :: any
-        %t1659 = length %t1658 :: integer
-        %t1660 = const 1 :: integer
-        %t1661 = call core.sub(%col_i_289, %t1660) :: integer
-        %t1662 = const 0 :: integer
-        %t1663 = call core.gte(%t1661, %t1662) :: boolean
-        %t1664 = call core.lt(%t1661, %t1659) :: boolean
-        %t1665 = call core.and(%t1663, %t1664) :: boolean
-        %t1666 = call core.and(%t1653, %t1665) :: boolean
-        %t1667 = const 1 :: integer
-        %t1668 = call core.sub(%t1659, %t1667) :: integer
-        %t1669 = const 0 :: integer
-        %t1670 = call core.clamp(%t1661, %t1669, %t1668) :: integer
-        %t1671 = gather %t1658, %t1670 :: integer
-        %t1672 = const 0 :: integer
-        %t1673 = select %t1666, %t1671, %t1672 :: integer
-        %t1674 = load_input "rows" :: array
-        %t1675 = length %t1674 :: integer
+        %t1651 = call core.clamp(%t1642, %t1650, %t1649) :: integer
+        %t1652 = gather %t1639, %t1651 :: integer
+        %t1653 = const 0 :: integer
+        %t1654 = select %t1647, %t1652, %t1653 :: integer
+        %t1655 = load_input "rows" :: array
+        %t1656 = length %t1655 :: integer
+        %t1657 = const -1 :: integer
+        %t1658 = call core.sub(%rows_i_287, %t1657) :: integer
+        %t1659 = const 0 :: integer
+        %t1660 = call core.gte(%t1658, %t1659) :: boolean
+        %t1661 = call core.lt(%t1658, %t1656) :: boolean
+        %t1662 = call core.and(%t1660, %t1661) :: boolean
+        %t1663 = const 1 :: integer
+        %t1664 = call core.sub(%t1656, %t1663) :: integer
+        %t1665 = const 0 :: integer
+        %t1666 = call core.clamp(%t1658, %t1665, %t1664) :: integer
+        %t1667 = gather %t1655, %t1666 :: any
+        %t1668 = length %t1667 :: integer
+        %t1669 = const 1 :: integer
+        %t1670 = call core.sub(%col_i_289, %t1669) :: integer
+        %t1671 = const 0 :: integer
+        %t1672 = call core.gte(%t1670, %t1671) :: boolean
+        %t1673 = call core.lt(%t1670, %t1668) :: boolean
+        %t1674 = call core.and(%t1672, %t1673) :: boolean
+        %t1675 = call core.and(%t1662, %t1674) :: boolean
         %t1676 = const 1 :: integer
-        %t1677 = call core.sub(%rows_i_287, %t1676) :: integer
+        %t1677 = call core.sub(%t1668, %t1676) :: integer
         %t1678 = const 0 :: integer
-        %t1679 = call core.gte(%t1677, %t1678) :: boolean
-        %t1680 = call core.lt(%t1677, %t1675) :: boolean
-        %t1681 = call core.and(%t1679, %t1680) :: boolean
-        %t1682 = const 1 :: integer
-        %t1683 = call core.sub(%t1675, %t1682) :: integer
-        %t1684 = const 0 :: integer
-        %t1685 = call core.clamp(%t1677, %t1684, %t1683) :: integer
-        %t1686 = gather %t1674, %t1685 :: any
-        %t1687 = length %t1686 :: integer
-        %t1688 = const -1 :: integer
-        %t1689 = call core.sub(%col_i_289, %t1688) :: integer
-        %t1690 = const 0 :: integer
-        %t1691 = call core.gte(%t1689, %t1690) :: boolean
-        %t1692 = call core.lt(%t1689, %t1687) :: boolean
-        %t1693 = call core.and(%t1691, %t1692) :: boolean
-        %t1694 = call core.and(%t1681, %t1693) :: boolean
-        %t1695 = const 1 :: integer
-        %t1696 = call core.sub(%t1687, %t1695) :: integer
-        %t1697 = const 0 :: integer
-        %t1698 = call core.clamp(%t1689, %t1697, %t1696) :: integer
-        %t1699 = gather %t1686, %t1698 :: integer
-        %t1700 = const 0 :: integer
-        %t1701 = select %t1694, %t1699, %t1700 :: integer
-        %t1702 = load_input "rows" :: array
-        %t1703 = length %t1702 :: integer
+        %t1679 = call core.clamp(%t1670, %t1678, %t1677) :: integer
+        %t1680 = gather %t1667, %t1679 :: integer
+        %t1681 = const 0 :: integer
+        %t1682 = select %t1675, %t1680, %t1681 :: integer
+        %t1683 = load_input "rows" :: array
+        %t1684 = length %t1683 :: integer
+        %t1685 = const 1 :: integer
+        %t1686 = call core.sub(%rows_i_287, %t1685) :: integer
+        %t1687 = const 0 :: integer
+        %t1688 = call core.gte(%t1686, %t1687) :: boolean
+        %t1689 = call core.lt(%t1686, %t1684) :: boolean
+        %t1690 = call core.and(%t1688, %t1689) :: boolean
+        %t1691 = const 1 :: integer
+        %t1692 = call core.sub(%t1684, %t1691) :: integer
+        %t1693 = const 0 :: integer
+        %t1694 = call core.clamp(%t1686, %t1693, %t1692) :: integer
+        %t1695 = gather %t1683, %t1694 :: any
+        %t1696 = length %t1695 :: integer
+        %t1697 = const -1 :: integer
+        %t1698 = call core.sub(%col_i_289, %t1697) :: integer
+        %t1699 = const 0 :: integer
+        %t1700 = call core.gte(%t1698, %t1699) :: boolean
+        %t1701 = call core.lt(%t1698, %t1696) :: boolean
+        %t1702 = call core.and(%t1700, %t1701) :: boolean
+        %t1703 = call core.and(%t1690, %t1702) :: boolean
         %t1704 = const 1 :: integer
-        %t1705 = call core.sub(%rows_i_287, %t1704) :: integer
+        %t1705 = call core.sub(%t1696, %t1704) :: integer
         %t1706 = const 0 :: integer
-        %t1707 = call core.gte(%t1705, %t1706) :: boolean
-        %t1708 = call core.lt(%t1705, %t1703) :: boolean
-        %t1709 = call core.and(%t1707, %t1708) :: boolean
-        %t1710 = const 1 :: integer
-        %t1711 = call core.sub(%t1703, %t1710) :: integer
-        %t1712 = const 0 :: integer
-        %t1713 = call core.clamp(%t1705, %t1712, %t1711) :: integer
-        %t1714 = gather %t1702, %t1713 :: any
-        %t1715 = length %t1714 :: integer
-        %t1716 = const 1 :: integer
-        %t1717 = call core.sub(%col_i_289, %t1716) :: integer
-        %t1718 = const 0 :: integer
-        %t1719 = call core.gte(%t1717, %t1718) :: boolean
-        %t1720 = call core.lt(%t1717, %t1715) :: boolean
-        %t1721 = call core.and(%t1719, %t1720) :: boolean
-        %t1722 = call core.and(%t1709, %t1721) :: boolean
-        %t1723 = const 1 :: integer
-        %t1724 = call core.sub(%t1715, %t1723) :: integer
-        %t1725 = const 0 :: integer
-        %t1726 = call core.clamp(%t1717, %t1725, %t1724) :: integer
-        %t1727 = gather %t1714, %t1726 :: integer
-        %t1728 = const 0 :: integer
-        %t1729 = select %t1722, %t1727, %t1728 :: integer
-        %t1332 = make_tuple(%t1557, %t1577, %t1597, %t1617, %t1645, %t1673, %t1701, %t1729) :: tuple<integer>
-        %t1333 = fold %t1332 fn="agg.sum" :: 
-        %t1334 = const 3 :: integer
-        %t1335 = call core.eq(%t1333, %t1334) :: boolean
-        %t1336 = load_input "rows" :: array
-        %t1337 = load_input "rows" :: array
-        %t1730 = load_input "rows" :: array
-        %t1731 = load_input "rows" :: array
-        %t1732 = length %t1731 :: integer
-        %t1733 = const -1 :: integer
-        %t1734 = call core.sub(%rows_i_287, %t1733) :: integer
-        %t1735 = const 0 :: integer
-        %t1736 = call core.gte(%t1734, %t1735) :: boolean
-        %t1737 = call core.lt(%t1734, %t1732) :: boolean
-        %t1738 = call core.and(%t1736, %t1737) :: boolean
-        %t1739 = const 1 :: integer
-        %t1740 = call core.sub(%t1732, %t1739) :: integer
-        %t1741 = const 0 :: integer
-        %t1742 = call core.clamp(%t1734, %t1741, %t1740) :: integer
-        %t1743 = gather %t1731, %t1742 :: any
-        %t1744 = length %t1743 :: integer
-        %t1745 = call core.mod(%col_i_289, %t1744) :: integer
-        %t1746 = call core.add(%t1745, %t1744) :: integer
-        %t1747 = call core.mod(%t1746, %t1744) :: integer
-        %t1748 = gather %t1743, %t1747 :: integer
-        %t1749 = const 0 :: integer
-        %t1750 = select %t1738, %t1748, %t1749 :: integer
-        %t1751 = load_input "rows" :: array
-        %t1752 = length %t1751 :: integer
-        %t1753 = const 1 :: integer
-        %t1754 = call core.sub(%rows_i_287, %t1753) :: integer
-        %t1755 = const 0 :: integer
-        %t1756 = call core.gte(%t1754, %t1755) :: boolean
-        %t1757 = call core.lt(%t1754, %t1752) :: boolean
-        %t1758 = call core.and(%t1756, %t1757) :: boolean
-        %t1759 = const 1 :: integer
-        %t1760 = call core.sub(%t1752, %t1759) :: integer
-        %t1761 = const 0 :: integer
-        %t1762 = call core.clamp(%t1754, %t1761, %t1760) :: integer
-        %t1763 = gather %t1751, %t1762 :: any
-        %t1764 = length %t1763 :: integer
-        %t1765 = call core.mod(%col_i_289, %t1764) :: integer
-        %t1766 = call core.add(%t1765, %t1764) :: integer
-        %t1767 = call core.mod(%t1766, %t1764) :: integer
-        %t1768 = gather %t1763, %t1767 :: integer
-        %t1769 = const 0 :: integer
-        %t1770 = select %t1758, %t1768, %t1769 :: integer
-        %t1771 = load_input "rows" :: array
-        %t1772 = length %t1771 :: integer
-        %t1773 = call core.mod(%rows_i_287, %t1772) :: integer
-        %t1774 = call core.add(%t1773, %t1772) :: integer
-        %t1775 = call core.mod(%t1774, %t1772) :: integer
-        %t1776 = gather %t1771, %t1775 :: any
-        %t1777 = length %t1776 :: integer
-        %t1778 = const -1 :: integer
-        %t1779 = call core.sub(%col_i_289, %t1778) :: integer
-        %t1780 = const 0 :: integer
-        %t1781 = call core.gte(%t1779, %t1780) :: boolean
-        %t1782 = call core.lt(%t1779, %t1777) :: boolean
-        %t1783 = call core.and(%t1781, %t1782) :: boolean
-        %t1784 = const 1 :: integer
-        %t1785 = call core.sub(%t1777, %t1784) :: integer
-        %t1786 = const 0 :: integer
-        %t1787 = call core.clamp(%t1779, %t1786, %t1785) :: integer
-        %t1788 = gather %t1776, %t1787 :: integer
-        %t1789 = const 0 :: integer
-        %t1790 = select %t1783, %t1788, %t1789 :: integer
-        %t1791 = load_input "rows" :: array
-        %t1792 = length %t1791 :: integer
-        %t1793 = call core.mod(%rows_i_287, %t1792) :: integer
-        %t1794 = call core.add(%t1793, %t1792) :: integer
-        %t1795 = call core.mod(%t1794, %t1792) :: integer
-        %t1796 = gather %t1791, %t1795 :: any
-        %t1797 = length %t1796 :: integer
-        %t1798 = const 1 :: integer
-        %t1799 = call core.sub(%col_i_289, %t1798) :: integer
-        %t1800 = const 0 :: integer
-        %t1801 = call core.gte(%t1799, %t1800) :: boolean
-        %t1802 = call core.lt(%t1799, %t1797) :: boolean
-        %t1803 = call core.and(%t1801, %t1802) :: boolean
-        %t1804 = const 1 :: integer
-        %t1805 = call core.sub(%t1797, %t1804) :: integer
-        %t1806 = const 0 :: integer
-        %t1807 = call core.clamp(%t1799, %t1806, %t1805) :: integer
-        %t1808 = gather %t1796, %t1807 :: integer
-        %t1809 = const 0 :: integer
-        %t1810 = select %t1803, %t1808, %t1809 :: integer
-        %t1811 = load_input "rows" :: array
-        %t1812 = length %t1811 :: integer
-        %t1813 = const -1 :: integer
-        %t1814 = call core.sub(%rows_i_287, %t1813) :: integer
-        %t1815 = const 0 :: integer
-        %t1816 = call core.gte(%t1814, %t1815) :: boolean
-        %t1817 = call core.lt(%t1814, %t1812) :: boolean
-        %t1818 = call core.and(%t1816, %t1817) :: boolean
-        %t1819 = const 1 :: integer
-        %t1820 = call core.sub(%t1812, %t1819) :: integer
-        %t1821 = const 0 :: integer
-        %t1822 = call core.clamp(%t1814, %t1821, %t1820) :: integer
-        %t1823 = gather %t1811, %t1822 :: any
+        %t1707 = call core.clamp(%t1698, %t1706, %t1705) :: integer
+        %t1708 = gather %t1695, %t1707 :: integer
+        %t1709 = const 0 :: integer
+        %t1710 = select %t1703, %t1708, %t1709 :: integer
+        %t1711 = load_input "rows" :: array
+        %t1712 = length %t1711 :: integer
+        %t1713 = const 1 :: integer
+        %t1714 = call core.sub(%rows_i_287, %t1713) :: integer
+        %t1715 = const 0 :: integer
+        %t1716 = call core.gte(%t1714, %t1715) :: boolean
+        %t1717 = call core.lt(%t1714, %t1712) :: boolean
+        %t1718 = call core.and(%t1716, %t1717) :: boolean
+        %t1719 = const 1 :: integer
+        %t1720 = call core.sub(%t1712, %t1719) :: integer
+        %t1721 = const 0 :: integer
+        %t1722 = call core.clamp(%t1714, %t1721, %t1720) :: integer
+        %t1723 = gather %t1711, %t1722 :: any
+        %t1724 = length %t1723 :: integer
+        %t1725 = const 1 :: integer
+        %t1726 = call core.sub(%col_i_289, %t1725) :: integer
+        %t1727 = const 0 :: integer
+        %t1728 = call core.gte(%t1726, %t1727) :: boolean
+        %t1729 = call core.lt(%t1726, %t1724) :: boolean
+        %t1730 = call core.and(%t1728, %t1729) :: boolean
+        %t1731 = call core.and(%t1718, %t1730) :: boolean
+        %t1732 = const 1 :: integer
+        %t1733 = call core.sub(%t1724, %t1732) :: integer
+        %t1734 = const 0 :: integer
+        %t1735 = call core.clamp(%t1726, %t1734, %t1733) :: integer
+        %t1736 = gather %t1723, %t1735 :: integer
+        %t1737 = const 0 :: integer
+        %t1738 = select %t1731, %t1736, %t1737 :: integer
+        %t1545 = make_tuple(%t1566, %t1586, %t1606, %t1626, %t1654, %t1682, %t1710, %t1738) :: tuple<integer>
+        %t1546 = fold %t1545 fn="agg.sum" :: 
+        %t1534 = const 3 :: integer
+        %t1535 = call core.eq(%t1546, %t1534) :: boolean
+        %t1739 = load_input "rows" :: array
+        %t1743 = load_input "rows" :: array
+        %t1747 = load_input "rows" :: array
+        %t1758 = load_input "rows" :: array
+        %t1759 = length %t1758 :: integer
+        %t1760 = const -1 :: integer
+        %t1761 = call core.sub(%rows_i_287, %t1760) :: integer
+        %t1762 = const 0 :: integer
+        %t1763 = call core.gte(%t1761, %t1762) :: boolean
+        %t1764 = call core.lt(%t1761, %t1759) :: boolean
+        %t1765 = call core.and(%t1763, %t1764) :: boolean
+        %t1766 = const 1 :: integer
+        %t1767 = call core.sub(%t1759, %t1766) :: integer
+        %t1768 = const 0 :: integer
+        %t1769 = call core.clamp(%t1761, %t1768, %t1767) :: integer
+        %t1770 = gather %t1758, %t1769 :: any
+        %t1771 = length %t1770 :: integer
+        %t1772 = call core.mod(%col_i_289, %t1771) :: integer
+        %t1773 = call core.add(%t1772, %t1771) :: integer
+        %t1774 = call core.mod(%t1773, %t1771) :: integer
+        %t1775 = gather %t1770, %t1774 :: integer
+        %t1776 = const 0 :: integer
+        %t1777 = select %t1765, %t1775, %t1776 :: integer
+        %t1778 = load_input "rows" :: array
+        %t1779 = length %t1778 :: integer
+        %t1780 = const 1 :: integer
+        %t1781 = call core.sub(%rows_i_287, %t1780) :: integer
+        %t1782 = const 0 :: integer
+        %t1783 = call core.gte(%t1781, %t1782) :: boolean
+        %t1784 = call core.lt(%t1781, %t1779) :: boolean
+        %t1785 = call core.and(%t1783, %t1784) :: boolean
+        %t1786 = const 1 :: integer
+        %t1787 = call core.sub(%t1779, %t1786) :: integer
+        %t1788 = const 0 :: integer
+        %t1789 = call core.clamp(%t1781, %t1788, %t1787) :: integer
+        %t1790 = gather %t1778, %t1789 :: any
+        %t1791 = length %t1790 :: integer
+        %t1792 = call core.mod(%col_i_289, %t1791) :: integer
+        %t1793 = call core.add(%t1792, %t1791) :: integer
+        %t1794 = call core.mod(%t1793, %t1791) :: integer
+        %t1795 = gather %t1790, %t1794 :: integer
+        %t1796 = const 0 :: integer
+        %t1797 = select %t1785, %t1795, %t1796 :: integer
+        %t1798 = load_input "rows" :: array
+        %t1799 = length %t1798 :: integer
+        %t1800 = call core.mod(%rows_i_287, %t1799) :: integer
+        %t1801 = call core.add(%t1800, %t1799) :: integer
+        %t1802 = call core.mod(%t1801, %t1799) :: integer
+        %t1803 = gather %t1798, %t1802 :: any
+        %t1804 = length %t1803 :: integer
+        %t1805 = const -1 :: integer
+        %t1806 = call core.sub(%col_i_289, %t1805) :: integer
+        %t1807 = const 0 :: integer
+        %t1808 = call core.gte(%t1806, %t1807) :: boolean
+        %t1809 = call core.lt(%t1806, %t1804) :: boolean
+        %t1810 = call core.and(%t1808, %t1809) :: boolean
+        %t1811 = const 1 :: integer
+        %t1812 = call core.sub(%t1804, %t1811) :: integer
+        %t1813 = const 0 :: integer
+        %t1814 = call core.clamp(%t1806, %t1813, %t1812) :: integer
+        %t1815 = gather %t1803, %t1814 :: integer
+        %t1816 = const 0 :: integer
+        %t1817 = select %t1810, %t1815, %t1816 :: integer
+        %t1818 = load_input "rows" :: array
+        %t1819 = length %t1818 :: integer
+        %t1820 = call core.mod(%rows_i_287, %t1819) :: integer
+        %t1821 = call core.add(%t1820, %t1819) :: integer
+        %t1822 = call core.mod(%t1821, %t1819) :: integer
+        %t1823 = gather %t1818, %t1822 :: any
         %t1824 = length %t1823 :: integer
-        %t1825 = const -1 :: integer
+        %t1825 = const 1 :: integer
         %t1826 = call core.sub(%col_i_289, %t1825) :: integer
         %t1827 = const 0 :: integer
         %t1828 = call core.gte(%t1826, %t1827) :: boolean
         %t1829 = call core.lt(%t1826, %t1824) :: boolean
         %t1830 = call core.and(%t1828, %t1829) :: boolean
-        %t1831 = call core.and(%t1818, %t1830) :: boolean
-        %t1832 = const 1 :: integer
-        %t1833 = call core.sub(%t1824, %t1832) :: integer
-        %t1834 = const 0 :: integer
-        %t1835 = call core.clamp(%t1826, %t1834, %t1833) :: integer
-        %t1836 = gather %t1823, %t1835 :: integer
-        %t1837 = const 0 :: integer
-        %t1838 = select %t1831, %t1836, %t1837 :: integer
-        %t1839 = load_input "rows" :: array
-        %t1840 = length %t1839 :: integer
-        %t1841 = const -1 :: integer
-        %t1842 = call core.sub(%rows_i_287, %t1841) :: integer
-        %t1843 = const 0 :: integer
-        %t1844 = call core.gte(%t1842, %t1843) :: boolean
-        %t1845 = call core.lt(%t1842, %t1840) :: boolean
-        %t1846 = call core.and(%t1844, %t1845) :: boolean
-        %t1847 = const 1 :: integer
-        %t1848 = call core.sub(%t1840, %t1847) :: integer
-        %t1849 = const 0 :: integer
-        %t1850 = call core.clamp(%t1842, %t1849, %t1848) :: integer
-        %t1851 = gather %t1839, %t1850 :: any
-        %t1852 = length %t1851 :: integer
-        %t1853 = const 1 :: integer
-        %t1854 = call core.sub(%col_i_289, %t1853) :: integer
-        %t1855 = const 0 :: integer
-        %t1856 = call core.gte(%t1854, %t1855) :: boolean
-        %t1857 = call core.lt(%t1854, %t1852) :: boolean
-        %t1858 = call core.and(%t1856, %t1857) :: boolean
-        %t1859 = call core.and(%t1846, %t1858) :: boolean
-        %t1860 = const 1 :: integer
-        %t1861 = call core.sub(%t1852, %t1860) :: integer
-        %t1862 = const 0 :: integer
-        %t1863 = call core.clamp(%t1854, %t1862, %t1861) :: integer
-        %t1864 = gather %t1851, %t1863 :: integer
-        %t1865 = const 0 :: integer
-        %t1866 = select %t1859, %t1864, %t1865 :: integer
-        %t1867 = load_input "rows" :: array
-        %t1868 = length %t1867 :: integer
-        %t1869 = const 1 :: integer
-        %t1870 = call core.sub(%rows_i_287, %t1869) :: integer
-        %t1871 = const 0 :: integer
-        %t1872 = call core.gte(%t1870, %t1871) :: boolean
-        %t1873 = call core.lt(%t1870, %t1868) :: boolean
-        %t1874 = call core.and(%t1872, %t1873) :: boolean
-        %t1875 = const 1 :: integer
-        %t1876 = call core.sub(%t1868, %t1875) :: integer
-        %t1877 = const 0 :: integer
-        %t1878 = call core.clamp(%t1870, %t1877, %t1876) :: integer
-        %t1879 = gather %t1867, %t1878 :: any
-        %t1880 = length %t1879 :: integer
-        %t1881 = const -1 :: integer
-        %t1882 = call core.sub(%col_i_289, %t1881) :: integer
-        %t1883 = const 0 :: integer
-        %t1884 = call core.gte(%t1882, %t1883) :: boolean
-        %t1885 = call core.lt(%t1882, %t1880) :: boolean
-        %t1886 = call core.and(%t1884, %t1885) :: boolean
-        %t1887 = call core.and(%t1874, %t1886) :: boolean
-        %t1888 = const 1 :: integer
-        %t1889 = call core.sub(%t1880, %t1888) :: integer
-        %t1890 = const 0 :: integer
-        %t1891 = call core.clamp(%t1882, %t1890, %t1889) :: integer
-        %t1892 = gather %t1879, %t1891 :: integer
-        %t1893 = const 0 :: integer
-        %t1894 = select %t1887, %t1892, %t1893 :: integer
-        %t1895 = load_input "rows" :: array
-        %t1896 = length %t1895 :: integer
-        %t1897 = const 1 :: integer
-        %t1898 = call core.sub(%rows_i_287, %t1897) :: integer
-        %t1899 = const 0 :: integer
-        %t1900 = call core.gte(%t1898, %t1899) :: boolean
-        %t1901 = call core.lt(%t1898, %t1896) :: boolean
-        %t1902 = call core.and(%t1900, %t1901) :: boolean
-        %t1903 = const 1 :: integer
-        %t1904 = call core.sub(%t1896, %t1903) :: integer
-        %t1905 = const 0 :: integer
-        %t1906 = call core.clamp(%t1898, %t1905, %t1904) :: integer
-        %t1907 = gather %t1895, %t1906 :: any
-        %t1908 = length %t1907 :: integer
-        %t1909 = const 1 :: integer
-        %t1910 = call core.sub(%col_i_289, %t1909) :: integer
-        %t1911 = const 0 :: integer
-        %t1912 = call core.gte(%t1910, %t1911) :: boolean
-        %t1913 = call core.lt(%t1910, %t1908) :: boolean
-        %t1914 = call core.and(%t1912, %t1913) :: boolean
-        %t1915 = call core.and(%t1902, %t1914) :: boolean
-        %t1916 = const 1 :: integer
-        %t1917 = call core.sub(%t1908, %t1916) :: integer
-        %t1918 = const 0 :: integer
-        %t1919 = call core.clamp(%t1910, %t1918, %t1917) :: integer
-        %t1920 = gather %t1907, %t1919 :: integer
-        %t1921 = const 0 :: integer
-        %t1922 = select %t1915, %t1920, %t1921 :: integer
-        %t1923 = make_tuple(%t1750, %t1770, %t1790, %t1810, %t1838, %t1866, %t1894, %t1922) :: tuple<integer>
-        %t1924 = fold %t1923 fn="agg.sum" :: 
-        %t1339 = const 2 :: integer
-        %t1340 = call core.eq(%t1924, %t1339) :: boolean
-        %t1341 = load_input "rows" :: array
-        %t1925 = load_input "rows" :: array
-        %t1343 = const 0 :: integer
-        %t1344 = call core.gt(%col_el_288, %t1343) :: boolean
-        %t1345 = call core.and(%t1340, %t1344) :: boolean
-        %t528 = call core.or(%t1335, %t1345) :: boolean
+        %t1831 = const 1 :: integer
+        %t1832 = call core.sub(%t1824, %t1831) :: integer
+        %t1833 = const 0 :: integer
+        %t1834 = call core.clamp(%t1826, %t1833, %t1832) :: integer
+        %t1835 = gather %t1823, %t1834 :: integer
+        %t1836 = const 0 :: integer
+        %t1837 = select %t1830, %t1835, %t1836 :: integer
+        %t1838 = load_input "rows" :: array
+        %t1839 = length %t1838 :: integer
+        %t1840 = const -1 :: integer
+        %t1841 = call core.sub(%rows_i_287, %t1840) :: integer
+        %t1842 = const 0 :: integer
+        %t1843 = call core.gte(%t1841, %t1842) :: boolean
+        %t1844 = call core.lt(%t1841, %t1839) :: boolean
+        %t1845 = call core.and(%t1843, %t1844) :: boolean
+        %t1846 = const 1 :: integer
+        %t1847 = call core.sub(%t1839, %t1846) :: integer
+        %t1848 = const 0 :: integer
+        %t1849 = call core.clamp(%t1841, %t1848, %t1847) :: integer
+        %t1850 = gather %t1838, %t1849 :: any
+        %t1851 = length %t1850 :: integer
+        %t1852 = const -1 :: integer
+        %t1853 = call core.sub(%col_i_289, %t1852) :: integer
+        %t1854 = const 0 :: integer
+        %t1855 = call core.gte(%t1853, %t1854) :: boolean
+        %t1856 = call core.lt(%t1853, %t1851) :: boolean
+        %t1857 = call core.and(%t1855, %t1856) :: boolean
+        %t1858 = call core.and(%t1845, %t1857) :: boolean
+        %t1859 = const 1 :: integer
+        %t1860 = call core.sub(%t1851, %t1859) :: integer
+        %t1861 = const 0 :: integer
+        %t1862 = call core.clamp(%t1853, %t1861, %t1860) :: integer
+        %t1863 = gather %t1850, %t1862 :: integer
+        %t1864 = const 0 :: integer
+        %t1865 = select %t1858, %t1863, %t1864 :: integer
+        %t1866 = load_input "rows" :: array
+        %t1867 = length %t1866 :: integer
+        %t1868 = const -1 :: integer
+        %t1869 = call core.sub(%rows_i_287, %t1868) :: integer
+        %t1870 = const 0 :: integer
+        %t1871 = call core.gte(%t1869, %t1870) :: boolean
+        %t1872 = call core.lt(%t1869, %t1867) :: boolean
+        %t1873 = call core.and(%t1871, %t1872) :: boolean
+        %t1874 = const 1 :: integer
+        %t1875 = call core.sub(%t1867, %t1874) :: integer
+        %t1876 = const 0 :: integer
+        %t1877 = call core.clamp(%t1869, %t1876, %t1875) :: integer
+        %t1878 = gather %t1866, %t1877 :: any
+        %t1879 = length %t1878 :: integer
+        %t1880 = const 1 :: integer
+        %t1881 = call core.sub(%col_i_289, %t1880) :: integer
+        %t1882 = const 0 :: integer
+        %t1883 = call core.gte(%t1881, %t1882) :: boolean
+        %t1884 = call core.lt(%t1881, %t1879) :: boolean
+        %t1885 = call core.and(%t1883, %t1884) :: boolean
+        %t1886 = call core.and(%t1873, %t1885) :: boolean
+        %t1887 = const 1 :: integer
+        %t1888 = call core.sub(%t1879, %t1887) :: integer
+        %t1889 = const 0 :: integer
+        %t1890 = call core.clamp(%t1881, %t1889, %t1888) :: integer
+        %t1891 = gather %t1878, %t1890 :: integer
+        %t1892 = const 0 :: integer
+        %t1893 = select %t1886, %t1891, %t1892 :: integer
+        %t1894 = load_input "rows" :: array
+        %t1895 = length %t1894 :: integer
+        %t1896 = const 1 :: integer
+        %t1897 = call core.sub(%rows_i_287, %t1896) :: integer
+        %t1898 = const 0 :: integer
+        %t1899 = call core.gte(%t1897, %t1898) :: boolean
+        %t1900 = call core.lt(%t1897, %t1895) :: boolean
+        %t1901 = call core.and(%t1899, %t1900) :: boolean
+        %t1902 = const 1 :: integer
+        %t1903 = call core.sub(%t1895, %t1902) :: integer
+        %t1904 = const 0 :: integer
+        %t1905 = call core.clamp(%t1897, %t1904, %t1903) :: integer
+        %t1906 = gather %t1894, %t1905 :: any
+        %t1907 = length %t1906 :: integer
+        %t1908 = const -1 :: integer
+        %t1909 = call core.sub(%col_i_289, %t1908) :: integer
+        %t1910 = const 0 :: integer
+        %t1911 = call core.gte(%t1909, %t1910) :: boolean
+        %t1912 = call core.lt(%t1909, %t1907) :: boolean
+        %t1913 = call core.and(%t1911, %t1912) :: boolean
+        %t1914 = call core.and(%t1901, %t1913) :: boolean
+        %t1915 = const 1 :: integer
+        %t1916 = call core.sub(%t1907, %t1915) :: integer
+        %t1917 = const 0 :: integer
+        %t1918 = call core.clamp(%t1909, %t1917, %t1916) :: integer
+        %t1919 = gather %t1906, %t1918 :: integer
+        %t1920 = const 0 :: integer
+        %t1921 = select %t1914, %t1919, %t1920 :: integer
+        %t1922 = load_input "rows" :: array
+        %t1923 = length %t1922 :: integer
+        %t1924 = const 1 :: integer
+        %t1925 = call core.sub(%rows_i_287, %t1924) :: integer
+        %t1926 = const 0 :: integer
+        %t1927 = call core.gte(%t1925, %t1926) :: boolean
+        %t1928 = call core.lt(%t1925, %t1923) :: boolean
+        %t1929 = call core.and(%t1927, %t1928) :: boolean
+        %t1930 = const 1 :: integer
+        %t1931 = call core.sub(%t1923, %t1930) :: integer
+        %t1932 = const 0 :: integer
+        %t1933 = call core.clamp(%t1925, %t1932, %t1931) :: integer
+        %t1934 = gather %t1922, %t1933 :: any
+        %t1935 = length %t1934 :: integer
+        %t1936 = const 1 :: integer
+        %t1937 = call core.sub(%col_i_289, %t1936) :: integer
+        %t1938 = const 0 :: integer
+        %t1939 = call core.gte(%t1937, %t1938) :: boolean
+        %t1940 = call core.lt(%t1937, %t1935) :: boolean
+        %t1941 = call core.and(%t1939, %t1940) :: boolean
+        %t1942 = call core.and(%t1929, %t1941) :: boolean
+        %t1943 = const 1 :: integer
+        %t1944 = call core.sub(%t1935, %t1943) :: integer
+        %t1945 = const 0 :: integer
+        %t1946 = call core.clamp(%t1937, %t1945, %t1944) :: integer
+        %t1947 = gather %t1934, %t1946 :: integer
+        %t1948 = const 0 :: integer
+        %t1949 = select %t1942, %t1947, %t1948 :: integer
+        %t1756 = make_tuple(%t1777, %t1797, %t1817, %t1837, %t1865, %t1893, %t1921, %t1949) :: tuple<integer>
+        %t1757 = fold %t1756 fn="agg.sum" :: 
+        %t1745 = const 2 :: integer
+        %t1746 = call core.eq(%t1757, %t1745) :: boolean
+        %t1950 = load_input "rows" :: array
+        %t1954 = load_input "rows" :: array
+        %t1952 = const 0 :: integer
+        %t1953 = call core.gt(%col_el_288, %t1952) :: boolean
+        %t1742 = call core.and(%t1746, %t1953) :: boolean
+        %t1531 = call core.or(%t1535, %t1742) :: boolean
         %t291 = const 1 :: integer
         %t292 = const 0 :: integer
-        %t293 = select %t528, %t291, %t292 :: integer
+        %t293 = select %t1531, %t291, %t292 :: integer
         yield %t293
       end_loop
     end_loop