kumi 0.0.24 → 0.0.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (108) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +5 -0
  3. data/golden/array_element/expected/schema_ruby.rb +1 -1
  4. data/golden/array_index/expected/schema_ruby.rb +1 -1
  5. data/golden/array_operations/expected/schema_ruby.rb +1 -1
  6. data/golden/cascade_logic/expected/lir_02_inlined.txt +8 -8
  7. data/golden/cascade_logic/expected/schema_ruby.rb +1 -1
  8. data/golden/chained_fusion/expected/lir_02_inlined.txt +36 -36
  9. data/golden/chained_fusion/expected/lir_03_cse.txt +23 -23
  10. data/golden/chained_fusion/expected/lir_04_1_loop_fusion.txt +25 -25
  11. data/golden/chained_fusion/expected/lir_04_loop_invcm.txt +23 -23
  12. data/golden/chained_fusion/expected/lir_06_const_prop.txt +23 -23
  13. data/golden/chained_fusion/expected/schema_javascript.mjs +23 -23
  14. data/golden/chained_fusion/expected/schema_ruby.rb +28 -28
  15. data/golden/element_arrays/expected/schema_ruby.rb +1 -1
  16. data/golden/empty_and_null_inputs/expected/lir_02_inlined.txt +18 -18
  17. data/golden/empty_and_null_inputs/expected/lir_03_cse.txt +17 -17
  18. data/golden/empty_and_null_inputs/expected/lir_04_1_loop_fusion.txt +17 -17
  19. data/golden/empty_and_null_inputs/expected/lir_04_loop_invcm.txt +17 -17
  20. data/golden/empty_and_null_inputs/expected/lir_06_const_prop.txt +17 -17
  21. data/golden/empty_and_null_inputs/expected/schema_javascript.mjs +13 -13
  22. data/golden/empty_and_null_inputs/expected/schema_ruby.rb +18 -18
  23. data/golden/game_of_life/expected/lir_02_inlined.txt +1291 -1291
  24. data/golden/game_of_life/expected/lir_03_cse.txt +396 -396
  25. data/golden/game_of_life/expected/lir_04_1_loop_fusion.txt +396 -396
  26. data/golden/game_of_life/expected/lir_04_loop_invcm.txt +396 -396
  27. data/golden/game_of_life/expected/lir_06_const_prop.txt +396 -396
  28. data/golden/game_of_life/expected/schema_javascript.mjs +85 -85
  29. data/golden/game_of_life/expected/schema_ruby.rb +86 -86
  30. data/golden/hash_keys/expected/schema_ruby.rb +1 -1
  31. data/golden/hash_value/expected/schema_ruby.rb +1 -1
  32. data/golden/hierarchical_complex/expected/lir_02_inlined.txt +15 -15
  33. data/golden/hierarchical_complex/expected/lir_03_cse.txt +1 -1
  34. data/golden/hierarchical_complex/expected/lir_04_1_loop_fusion.txt +1 -1
  35. data/golden/hierarchical_complex/expected/lir_04_loop_invcm.txt +1 -1
  36. data/golden/hierarchical_complex/expected/lir_06_const_prop.txt +1 -1
  37. data/golden/hierarchical_complex/expected/schema_javascript.mjs +1 -1
  38. data/golden/hierarchical_complex/expected/schema_ruby.rb +2 -2
  39. data/golden/inline_rename_scope_leak/expected/schema_ruby.rb +1 -1
  40. data/golden/input_reference/expected/schema_ruby.rb +1 -1
  41. data/golden/interleaved_fusion/expected/lir_02_inlined.txt +35 -35
  42. data/golden/interleaved_fusion/expected/lir_03_cse.txt +26 -26
  43. data/golden/interleaved_fusion/expected/lir_04_1_loop_fusion.txt +27 -26
  44. data/golden/interleaved_fusion/expected/lir_04_loop_invcm.txt +26 -26
  45. data/golden/interleaved_fusion/expected/lir_06_const_prop.txt +26 -26
  46. data/golden/interleaved_fusion/expected/schema_javascript.mjs +23 -23
  47. data/golden/interleaved_fusion/expected/schema_ruby.rb +29 -29
  48. data/golden/let_inline/expected/schema_ruby.rb +1 -1
  49. data/golden/loop_fusion/expected/lir_02_inlined.txt +17 -17
  50. data/golden/loop_fusion/expected/lir_03_cse.txt +14 -14
  51. data/golden/loop_fusion/expected/lir_04_1_loop_fusion.txt +14 -14
  52. data/golden/loop_fusion/expected/lir_04_loop_invcm.txt +14 -14
  53. data/golden/loop_fusion/expected/lir_06_const_prop.txt +14 -14
  54. data/golden/loop_fusion/expected/schema_javascript.mjs +12 -12
  55. data/golden/loop_fusion/expected/schema_ruby.rb +16 -16
  56. data/golden/min_reduce_scope/expected/schema_ruby.rb +1 -1
  57. data/golden/mixed_dimensions/expected/lir_02_inlined.txt +5 -5
  58. data/golden/mixed_dimensions/expected/lir_03_cse.txt +5 -5
  59. data/golden/mixed_dimensions/expected/lir_04_1_loop_fusion.txt +5 -5
  60. data/golden/mixed_dimensions/expected/lir_04_loop_invcm.txt +5 -5
  61. data/golden/mixed_dimensions/expected/lir_06_const_prop.txt +5 -5
  62. data/golden/mixed_dimensions/expected/schema_javascript.mjs +3 -3
  63. data/golden/mixed_dimensions/expected/schema_ruby.rb +6 -6
  64. data/golden/multirank_hoisting/expected/lir_02_inlined.txt +48 -48
  65. data/golden/multirank_hoisting/expected/lir_03_cse.txt +35 -35
  66. data/golden/multirank_hoisting/expected/lir_04_1_loop_fusion.txt +35 -35
  67. data/golden/multirank_hoisting/expected/lir_04_loop_invcm.txt +35 -35
  68. data/golden/multirank_hoisting/expected/lir_06_const_prop.txt +35 -35
  69. data/golden/multirank_hoisting/expected/schema_javascript.mjs +34 -34
  70. data/golden/multirank_hoisting/expected/schema_ruby.rb +36 -36
  71. data/golden/nested_hash/expected/schema_ruby.rb +1 -1
  72. data/golden/reduction_broadcast/expected/lir_02_inlined.txt +30 -30
  73. data/golden/reduction_broadcast/expected/lir_03_cse.txt +22 -22
  74. data/golden/reduction_broadcast/expected/lir_04_1_loop_fusion.txt +22 -22
  75. data/golden/reduction_broadcast/expected/lir_04_loop_invcm.txt +22 -22
  76. data/golden/reduction_broadcast/expected/lir_06_const_prop.txt +22 -22
  77. data/golden/reduction_broadcast/expected/schema_javascript.mjs +18 -18
  78. data/golden/reduction_broadcast/expected/schema_ruby.rb +23 -23
  79. data/golden/roll/expected/schema_ruby.rb +1 -1
  80. data/golden/shift/expected/schema_ruby.rb +1 -1
  81. data/golden/shift_2d/expected/schema_ruby.rb +1 -1
  82. data/golden/simple_math/expected/schema_ruby.rb +1 -1
  83. data/golden/streaming_basics/expected/lir_02_inlined.txt +25 -25
  84. data/golden/streaming_basics/expected/lir_03_cse.txt +13 -13
  85. data/golden/streaming_basics/expected/lir_04_1_loop_fusion.txt +13 -13
  86. data/golden/streaming_basics/expected/lir_04_loop_invcm.txt +13 -13
  87. data/golden/streaming_basics/expected/lir_06_const_prop.txt +13 -13
  88. data/golden/streaming_basics/expected/schema_javascript.mjs +13 -13
  89. data/golden/streaming_basics/expected/schema_ruby.rb +14 -14
  90. data/golden/tuples/expected/schema_ruby.rb +1 -1
  91. data/golden/tuples_and_arrays/expected/lir_02_inlined.txt +16 -16
  92. data/golden/tuples_and_arrays/expected/lir_03_cse.txt +13 -13
  93. data/golden/tuples_and_arrays/expected/lir_04_1_loop_fusion.txt +13 -13
  94. data/golden/tuples_and_arrays/expected/lir_04_loop_invcm.txt +13 -13
  95. data/golden/tuples_and_arrays/expected/lir_06_const_prop.txt +13 -13
  96. data/golden/tuples_and_arrays/expected/schema_javascript.mjs +13 -13
  97. data/golden/tuples_and_arrays/expected/schema_ruby.rb +14 -14
  98. data/golden/us_tax_2024/expected/lir_02_inlined.txt +524 -524
  99. data/golden/us_tax_2024/expected/lir_03_cse.txt +283 -283
  100. data/golden/us_tax_2024/expected/lir_04_1_loop_fusion.txt +283 -283
  101. data/golden/us_tax_2024/expected/lir_04_loop_invcm.txt +320 -260
  102. data/golden/us_tax_2024/expected/lir_06_const_prop.txt +320 -260
  103. data/golden/us_tax_2024/expected/schema_javascript.mjs +24 -24
  104. data/golden/us_tax_2024/expected/schema_ruby.rb +25 -25
  105. data/golden/with_constants/expected/schema_ruby.rb +1 -1
  106. data/lib/kumi/core/analyzer/passes/lir/inline_declarations_pass.rb +118 -74
  107. data/lib/kumi/version.rb +1 -1
  108. metadata +1 -1
data/golden/game_of_life/expected/lir_04_1_loop_fusion.txt CHANGED
@@ -319,82 +319,82 @@
319
319
  %t253 = load_input "rows" :: array
320
320
  loop rows id=L23 in %t253 as el=%rows_el_254, idx=%rows_i_255
321
321
  loop col id=L24 in %rows_el_254 as el=%col_el_256, idx=%col_i_257
322
- %t530 = length %t253 :: integer
323
- %t531 = const -1 :: integer
324
- %t532 = call core.sub(%rows_i_255, %t531) :: integer
325
- %t533 = const 0 :: integer
326
- %t534 = call core.gte(%t532, %t533) :: boolean
327
- %t535 = call core.lt(%t532, %t530) :: boolean
328
- %t536 = call core.and(%t534, %t535) :: boolean
329
- %t537 = const 1 :: integer
330
- %t538 = call core.sub(%t530, %t537) :: integer
331
- %t540 = call core.clamp(%t532, %t533, %t538) :: integer
332
- %t541 = gather %t253, %t540 :: any
333
- %t542 = length %t541 :: integer
334
- %t543 = call core.mod(%col_i_257, %t542) :: integer
335
- %t544 = call core.add(%t543, %t542) :: integer
336
- %t545 = call core.mod(%t544, %t542) :: integer
337
- %t546 = gather %t541, %t545 :: integer
338
- %t548 = select %t536, %t546, %t533 :: integer
339
- %t552 = call core.sub(%rows_i_255, %t537) :: integer
340
- %t554 = call core.gte(%t552, %t533) :: boolean
341
- %t555 = call core.lt(%t552, %t530) :: boolean
342
- %t556 = call core.and(%t554, %t555) :: boolean
343
- %t560 = call core.clamp(%t552, %t533, %t538) :: integer
344
- %t561 = gather %t253, %t560 :: any
345
- %t562 = length %t561 :: integer
346
- %t563 = call core.mod(%col_i_257, %t562) :: integer
347
- %t564 = call core.add(%t563, %t562) :: integer
348
- %t565 = call core.mod(%t564, %t562) :: integer
349
- %t566 = gather %t561, %t565 :: integer
350
- %t568 = select %t556, %t566, %t533 :: integer
351
- %t571 = call core.mod(%rows_i_255, %t530) :: integer
352
- %t572 = call core.add(%t571, %t530) :: integer
353
- %t573 = call core.mod(%t572, %t530) :: integer
354
- %t574 = gather %t253, %t573 :: any
355
- %t575 = length %t574 :: integer
356
- %t577 = call core.sub(%col_i_257, %t531) :: integer
357
- %t579 = call core.gte(%t577, %t533) :: boolean
358
- %t580 = call core.lt(%t577, %t575) :: boolean
359
- %t581 = call core.and(%t579, %t580) :: boolean
360
- %t583 = call core.sub(%t575, %t537) :: integer
361
- %t585 = call core.clamp(%t577, %t533, %t583) :: integer
362
- %t586 = gather %t574, %t585 :: integer
363
- %t588 = select %t581, %t586, %t533 :: integer
364
- %t597 = call core.sub(%col_i_257, %t537) :: integer
365
- %t599 = call core.gte(%t597, %t533) :: boolean
366
- %t600 = call core.lt(%t597, %t575) :: boolean
367
- %t601 = call core.and(%t599, %t600) :: boolean
368
- %t605 = call core.clamp(%t597, %t533, %t583) :: integer
369
- %t606 = gather %t574, %t605 :: integer
370
- %t608 = select %t601, %t606, %t533 :: integer
371
- %t627 = call core.lt(%t577, %t542) :: boolean
372
- %t628 = call core.and(%t579, %t627) :: boolean
373
- %t629 = call core.and(%t536, %t628) :: boolean
374
- %t631 = call core.sub(%t542, %t537) :: integer
375
- %t633 = call core.clamp(%t577, %t533, %t631) :: integer
376
- %t634 = gather %t541, %t633 :: integer
377
- %t636 = select %t629, %t634, %t533 :: integer
378
- %t655 = call core.lt(%t597, %t542) :: boolean
379
- %t656 = call core.and(%t599, %t655) :: boolean
380
- %t657 = call core.and(%t536, %t656) :: boolean
381
- %t661 = call core.clamp(%t597, %t533, %t631) :: integer
382
- %t662 = gather %t541, %t661 :: integer
383
- %t664 = select %t657, %t662, %t533 :: integer
384
- %t683 = call core.lt(%t577, %t562) :: boolean
385
- %t684 = call core.and(%t579, %t683) :: boolean
386
- %t685 = call core.and(%t556, %t684) :: boolean
387
- %t687 = call core.sub(%t562, %t537) :: integer
388
- %t689 = call core.clamp(%t577, %t533, %t687) :: integer
389
- %t690 = gather %t561, %t689 :: integer
390
- %t692 = select %t685, %t690, %t533 :: integer
391
- %t711 = call core.lt(%t597, %t562) :: boolean
392
- %t712 = call core.and(%t599, %t711) :: boolean
393
- %t713 = call core.and(%t556, %t712) :: boolean
394
- %t717 = call core.clamp(%t597, %t533, %t687) :: integer
395
- %t718 = gather %t561, %t717 :: integer
396
- %t720 = select %t713, %t718, %t533 :: integer
397
- %t496 = make_tuple(%t548, %t568, %t588, %t608, %t636, %t664, %t692, %t720) :: tuple<integer>
322
+ %t499 = length %t253 :: integer
323
+ %t500 = const -1 :: integer
324
+ %t501 = call core.sub(%rows_i_255, %t500) :: integer
325
+ %t502 = const 0 :: integer
326
+ %t503 = call core.gte(%t501, %t502) :: boolean
327
+ %t504 = call core.lt(%t501, %t499) :: boolean
328
+ %t505 = call core.and(%t503, %t504) :: boolean
329
+ %t506 = const 1 :: integer
330
+ %t507 = call core.sub(%t499, %t506) :: integer
331
+ %t509 = call core.clamp(%t501, %t502, %t507) :: integer
332
+ %t510 = gather %t253, %t509 :: any
333
+ %t511 = length %t510 :: integer
334
+ %t512 = call core.mod(%col_i_257, %t511) :: integer
335
+ %t513 = call core.add(%t512, %t511) :: integer
336
+ %t514 = call core.mod(%t513, %t511) :: integer
337
+ %t515 = gather %t510, %t514 :: integer
338
+ %t517 = select %t505, %t515, %t502 :: integer
339
+ %t521 = call core.sub(%rows_i_255, %t506) :: integer
340
+ %t523 = call core.gte(%t521, %t502) :: boolean
341
+ %t524 = call core.lt(%t521, %t499) :: boolean
342
+ %t525 = call core.and(%t523, %t524) :: boolean
343
+ %t529 = call core.clamp(%t521, %t502, %t507) :: integer
344
+ %t530 = gather %t253, %t529 :: any
345
+ %t531 = length %t530 :: integer
346
+ %t532 = call core.mod(%col_i_257, %t531) :: integer
347
+ %t533 = call core.add(%t532, %t531) :: integer
348
+ %t534 = call core.mod(%t533, %t531) :: integer
349
+ %t535 = gather %t530, %t534 :: integer
350
+ %t537 = select %t525, %t535, %t502 :: integer
351
+ %t540 = call core.mod(%rows_i_255, %t499) :: integer
352
+ %t541 = call core.add(%t540, %t499) :: integer
353
+ %t542 = call core.mod(%t541, %t499) :: integer
354
+ %t543 = gather %t253, %t542 :: any
355
+ %t544 = length %t543 :: integer
356
+ %t546 = call core.sub(%col_i_257, %t500) :: integer
357
+ %t548 = call core.gte(%t546, %t502) :: boolean
358
+ %t549 = call core.lt(%t546, %t544) :: boolean
359
+ %t550 = call core.and(%t548, %t549) :: boolean
360
+ %t552 = call core.sub(%t544, %t506) :: integer
361
+ %t554 = call core.clamp(%t546, %t502, %t552) :: integer
362
+ %t555 = gather %t543, %t554 :: integer
363
+ %t557 = select %t550, %t555, %t502 :: integer
364
+ %t566 = call core.sub(%col_i_257, %t506) :: integer
365
+ %t568 = call core.gte(%t566, %t502) :: boolean
366
+ %t569 = call core.lt(%t566, %t544) :: boolean
367
+ %t570 = call core.and(%t568, %t569) :: boolean
368
+ %t574 = call core.clamp(%t566, %t502, %t552) :: integer
369
+ %t575 = gather %t543, %t574 :: integer
370
+ %t577 = select %t570, %t575, %t502 :: integer
371
+ %t596 = call core.lt(%t546, %t511) :: boolean
372
+ %t597 = call core.and(%t548, %t596) :: boolean
373
+ %t598 = call core.and(%t505, %t597) :: boolean
374
+ %t600 = call core.sub(%t511, %t506) :: integer
375
+ %t602 = call core.clamp(%t546, %t502, %t600) :: integer
376
+ %t603 = gather %t510, %t602 :: integer
377
+ %t605 = select %t598, %t603, %t502 :: integer
378
+ %t624 = call core.lt(%t566, %t511) :: boolean
379
+ %t625 = call core.and(%t568, %t624) :: boolean
380
+ %t626 = call core.and(%t505, %t625) :: boolean
381
+ %t630 = call core.clamp(%t566, %t502, %t600) :: integer
382
+ %t631 = gather %t510, %t630 :: integer
383
+ %t633 = select %t626, %t631, %t502 :: integer
384
+ %t652 = call core.lt(%t546, %t531) :: boolean
385
+ %t653 = call core.and(%t548, %t652) :: boolean
386
+ %t654 = call core.and(%t525, %t653) :: boolean
387
+ %t656 = call core.sub(%t531, %t506) :: integer
388
+ %t658 = call core.clamp(%t546, %t502, %t656) :: integer
389
+ %t659 = gather %t530, %t658 :: integer
390
+ %t661 = select %t654, %t659, %t502 :: integer
391
+ %t680 = call core.lt(%t566, %t531) :: boolean
392
+ %t681 = call core.and(%t568, %t680) :: boolean
393
+ %t682 = call core.and(%t525, %t681) :: boolean
394
+ %t686 = call core.clamp(%t566, %t502, %t656) :: integer
395
+ %t687 = gather %t530, %t686 :: integer
396
+ %t689 = select %t682, %t687, %t502 :: integer
397
+ %t496 = make_tuple(%t517, %t537, %t557, %t577, %t605, %t633, %t661, %t689) :: tuple<integer>
398
398
  %t497 = fold %t496 fn="agg.sum" ::
399
399
  %t259 = const 3 :: integer
400
400
  %t260 = call core.eq(%t497, %t259) :: boolean
@@ -406,85 +406,85 @@
406
406
  %t261 = load_input "rows" :: array
407
407
  loop rows id=L25 in %t261 as el=%rows_el_262, idx=%rows_i_263
408
408
  loop col id=L26 in %rows_el_262 as el=%col_el_264, idx=%col_i_265
409
- %t722 = length %t261 :: integer
410
- %t723 = const -1 :: integer
411
- %t724 = call core.sub(%rows_i_263, %t723) :: integer
412
- %t725 = const 0 :: integer
413
- %t726 = call core.gte(%t724, %t725) :: boolean
414
- %t727 = call core.lt(%t724, %t722) :: boolean
409
+ %t702 = length %t261 :: integer
410
+ %t703 = const -1 :: integer
411
+ %t704 = call core.sub(%rows_i_263, %t703) :: integer
412
+ %t705 = const 0 :: integer
413
+ %t706 = call core.gte(%t704, %t705) :: boolean
414
+ %t707 = call core.lt(%t704, %t702) :: boolean
415
+ %t708 = call core.and(%t706, %t707) :: boolean
416
+ %t709 = const 1 :: integer
417
+ %t710 = call core.sub(%t702, %t709) :: integer
418
+ %t712 = call core.clamp(%t704, %t705, %t710) :: integer
419
+ %t713 = gather %t261, %t712 :: any
420
+ %t714 = length %t713 :: integer
421
+ %t715 = call core.mod(%col_i_265, %t714) :: integer
422
+ %t716 = call core.add(%t715, %t714) :: integer
423
+ %t717 = call core.mod(%t716, %t714) :: integer
424
+ %t718 = gather %t713, %t717 :: integer
425
+ %t720 = select %t708, %t718, %t705 :: integer
426
+ %t724 = call core.sub(%rows_i_263, %t709) :: integer
427
+ %t726 = call core.gte(%t724, %t705) :: boolean
428
+ %t727 = call core.lt(%t724, %t702) :: boolean
415
429
  %t728 = call core.and(%t726, %t727) :: boolean
416
- %t729 = const 1 :: integer
417
- %t730 = call core.sub(%t722, %t729) :: integer
418
- %t732 = call core.clamp(%t724, %t725, %t730) :: integer
430
+ %t732 = call core.clamp(%t724, %t705, %t710) :: integer
419
431
  %t733 = gather %t261, %t732 :: any
420
432
  %t734 = length %t733 :: integer
421
433
  %t735 = call core.mod(%col_i_265, %t734) :: integer
422
434
  %t736 = call core.add(%t735, %t734) :: integer
423
435
  %t737 = call core.mod(%t736, %t734) :: integer
424
436
  %t738 = gather %t733, %t737 :: integer
425
- %t740 = select %t728, %t738, %t725 :: integer
426
- %t744 = call core.sub(%rows_i_263, %t729) :: integer
427
- %t746 = call core.gte(%t744, %t725) :: boolean
428
- %t747 = call core.lt(%t744, %t722) :: boolean
429
- %t748 = call core.and(%t746, %t747) :: boolean
430
- %t752 = call core.clamp(%t744, %t725, %t730) :: integer
431
- %t753 = gather %t261, %t752 :: any
432
- %t754 = length %t753 :: integer
433
- %t755 = call core.mod(%col_i_265, %t754) :: integer
434
- %t756 = call core.add(%t755, %t754) :: integer
435
- %t757 = call core.mod(%t756, %t754) :: integer
436
- %t758 = gather %t753, %t757 :: integer
437
- %t760 = select %t748, %t758, %t725 :: integer
438
- %t763 = call core.mod(%rows_i_263, %t722) :: integer
439
- %t764 = call core.add(%t763, %t722) :: integer
440
- %t765 = call core.mod(%t764, %t722) :: integer
441
- %t766 = gather %t261, %t765 :: any
442
- %t767 = length %t766 :: integer
443
- %t769 = call core.sub(%col_i_265, %t723) :: integer
444
- %t771 = call core.gte(%t769, %t725) :: boolean
445
- %t772 = call core.lt(%t769, %t767) :: boolean
437
+ %t740 = select %t728, %t738, %t705 :: integer
438
+ %t743 = call core.mod(%rows_i_263, %t702) :: integer
439
+ %t744 = call core.add(%t743, %t702) :: integer
440
+ %t745 = call core.mod(%t744, %t702) :: integer
441
+ %t746 = gather %t261, %t745 :: any
442
+ %t747 = length %t746 :: integer
443
+ %t749 = call core.sub(%col_i_265, %t703) :: integer
444
+ %t751 = call core.gte(%t749, %t705) :: boolean
445
+ %t752 = call core.lt(%t749, %t747) :: boolean
446
+ %t753 = call core.and(%t751, %t752) :: boolean
447
+ %t755 = call core.sub(%t747, %t709) :: integer
448
+ %t757 = call core.clamp(%t749, %t705, %t755) :: integer
449
+ %t758 = gather %t746, %t757 :: integer
450
+ %t760 = select %t753, %t758, %t705 :: integer
451
+ %t769 = call core.sub(%col_i_265, %t709) :: integer
452
+ %t771 = call core.gte(%t769, %t705) :: boolean
453
+ %t772 = call core.lt(%t769, %t747) :: boolean
446
454
  %t773 = call core.and(%t771, %t772) :: boolean
447
- %t775 = call core.sub(%t767, %t729) :: integer
448
- %t777 = call core.clamp(%t769, %t725, %t775) :: integer
449
- %t778 = gather %t766, %t777 :: integer
450
- %t780 = select %t773, %t778, %t725 :: integer
451
- %t789 = call core.sub(%col_i_265, %t729) :: integer
452
- %t791 = call core.gte(%t789, %t725) :: boolean
453
- %t792 = call core.lt(%t789, %t767) :: boolean
454
- %t793 = call core.and(%t791, %t792) :: boolean
455
- %t797 = call core.clamp(%t789, %t725, %t775) :: integer
456
- %t798 = gather %t766, %t797 :: integer
457
- %t800 = select %t793, %t798, %t725 :: integer
458
- %t819 = call core.lt(%t769, %t734) :: boolean
459
- %t820 = call core.and(%t771, %t819) :: boolean
460
- %t821 = call core.and(%t728, %t820) :: boolean
461
- %t823 = call core.sub(%t734, %t729) :: integer
462
- %t825 = call core.clamp(%t769, %t725, %t823) :: integer
463
- %t826 = gather %t733, %t825 :: integer
464
- %t828 = select %t821, %t826, %t725 :: integer
465
- %t847 = call core.lt(%t789, %t734) :: boolean
466
- %t848 = call core.and(%t791, %t847) :: boolean
467
- %t849 = call core.and(%t728, %t848) :: boolean
468
- %t853 = call core.clamp(%t789, %t725, %t823) :: integer
469
- %t854 = gather %t733, %t853 :: integer
470
- %t856 = select %t849, %t854, %t725 :: integer
471
- %t875 = call core.lt(%t769, %t754) :: boolean
472
- %t876 = call core.and(%t771, %t875) :: boolean
473
- %t877 = call core.and(%t748, %t876) :: boolean
474
- %t879 = call core.sub(%t754, %t729) :: integer
475
- %t881 = call core.clamp(%t769, %t725, %t879) :: integer
476
- %t882 = gather %t753, %t881 :: integer
477
- %t884 = select %t877, %t882, %t725 :: integer
478
- %t903 = call core.lt(%t789, %t754) :: boolean
479
- %t904 = call core.and(%t791, %t903) :: boolean
480
- %t905 = call core.and(%t748, %t904) :: boolean
481
- %t909 = call core.clamp(%t789, %t725, %t879) :: integer
482
- %t910 = gather %t753, %t909 :: integer
483
- %t912 = select %t905, %t910, %t725 :: integer
484
- %t507 = make_tuple(%t740, %t760, %t780, %t800, %t828, %t856, %t884, %t912) :: tuple<integer>
485
- %t508 = fold %t507 fn="agg.sum" ::
455
+ %t777 = call core.clamp(%t769, %t705, %t755) :: integer
456
+ %t778 = gather %t746, %t777 :: integer
457
+ %t780 = select %t773, %t778, %t705 :: integer
458
+ %t799 = call core.lt(%t749, %t714) :: boolean
459
+ %t800 = call core.and(%t751, %t799) :: boolean
460
+ %t801 = call core.and(%t708, %t800) :: boolean
461
+ %t803 = call core.sub(%t714, %t709) :: integer
462
+ %t805 = call core.clamp(%t749, %t705, %t803) :: integer
463
+ %t806 = gather %t713, %t805 :: integer
464
+ %t808 = select %t801, %t806, %t705 :: integer
465
+ %t827 = call core.lt(%t769, %t714) :: boolean
466
+ %t828 = call core.and(%t771, %t827) :: boolean
467
+ %t829 = call core.and(%t708, %t828) :: boolean
468
+ %t833 = call core.clamp(%t769, %t705, %t803) :: integer
469
+ %t834 = gather %t713, %t833 :: integer
470
+ %t836 = select %t829, %t834, %t705 :: integer
471
+ %t855 = call core.lt(%t749, %t734) :: boolean
472
+ %t856 = call core.and(%t751, %t855) :: boolean
473
+ %t857 = call core.and(%t728, %t856) :: boolean
474
+ %t859 = call core.sub(%t734, %t709) :: integer
475
+ %t861 = call core.clamp(%t749, %t705, %t859) :: integer
476
+ %t862 = gather %t733, %t861 :: integer
477
+ %t864 = select %t857, %t862, %t705 :: integer
478
+ %t883 = call core.lt(%t769, %t734) :: boolean
479
+ %t884 = call core.and(%t771, %t883) :: boolean
480
+ %t885 = call core.and(%t728, %t884) :: boolean
481
+ %t889 = call core.clamp(%t769, %t705, %t859) :: integer
482
+ %t890 = gather %t733, %t889 :: integer
483
+ %t892 = select %t885, %t890, %t705 :: integer
484
+ %t699 = make_tuple(%t720, %t740, %t760, %t780, %t808, %t836, %t864, %t892) :: tuple<integer>
485
+ %t700 = fold %t699 fn="agg.sum" ::
486
486
  %t267 = const 2 :: integer
487
- %t268 = call core.eq(%t508, %t267) :: boolean
487
+ %t268 = call core.eq(%t700, %t267) :: boolean
488
488
  yield %t268
489
489
  end_loop
490
490
  end_loop
@@ -493,87 +493,87 @@
493
493
  %t269 = load_input "rows" :: array
494
494
  loop rows id=L27 in %t269 as el=%rows_el_270, idx=%rows_i_271
495
495
  loop col id=L28 in %rows_el_270 as el=%col_el_272, idx=%col_i_273
496
- %t915 = length %t269 :: integer
497
- %t916 = const -1 :: integer
498
- %t917 = call core.sub(%rows_i_271, %t916) :: integer
499
- %t918 = const 0 :: integer
500
- %t919 = call core.gte(%t917, %t918) :: boolean
501
- %t920 = call core.lt(%t917, %t915) :: boolean
502
- %t921 = call core.and(%t919, %t920) :: boolean
503
- %t922 = const 1 :: integer
504
- %t923 = call core.sub(%t915, %t922) :: integer
505
- %t925 = call core.clamp(%t917, %t918, %t923) :: integer
506
- %t926 = gather %t269, %t925 :: any
507
- %t927 = length %t926 :: integer
508
- %t928 = call core.mod(%col_i_273, %t927) :: integer
509
- %t929 = call core.add(%t928, %t927) :: integer
510
- %t930 = call core.mod(%t929, %t927) :: integer
511
- %t931 = gather %t926, %t930 :: integer
512
- %t933 = select %t921, %t931, %t918 :: integer
513
- %t937 = call core.sub(%rows_i_271, %t922) :: integer
514
- %t939 = call core.gte(%t937, %t918) :: boolean
515
- %t940 = call core.lt(%t937, %t915) :: boolean
516
- %t941 = call core.and(%t939, %t940) :: boolean
517
- %t945 = call core.clamp(%t937, %t918, %t923) :: integer
518
- %t946 = gather %t269, %t945 :: any
519
- %t947 = length %t946 :: integer
520
- %t948 = call core.mod(%col_i_273, %t947) :: integer
521
- %t949 = call core.add(%t948, %t947) :: integer
522
- %t950 = call core.mod(%t949, %t947) :: integer
523
- %t951 = gather %t946, %t950 :: integer
524
- %t953 = select %t941, %t951, %t918 :: integer
525
- %t956 = call core.mod(%rows_i_271, %t915) :: integer
526
- %t957 = call core.add(%t956, %t915) :: integer
527
- %t958 = call core.mod(%t957, %t915) :: integer
528
- %t959 = gather %t269, %t958 :: any
529
- %t960 = length %t959 :: integer
530
- %t962 = call core.sub(%col_i_273, %t916) :: integer
531
- %t964 = call core.gte(%t962, %t918) :: boolean
532
- %t965 = call core.lt(%t962, %t960) :: boolean
533
- %t966 = call core.and(%t964, %t965) :: boolean
534
- %t968 = call core.sub(%t960, %t922) :: integer
535
- %t970 = call core.clamp(%t962, %t918, %t968) :: integer
536
- %t971 = gather %t959, %t970 :: integer
537
- %t973 = select %t966, %t971, %t918 :: integer
538
- %t982 = call core.sub(%col_i_273, %t922) :: integer
539
- %t984 = call core.gte(%t982, %t918) :: boolean
540
- %t985 = call core.lt(%t982, %t960) :: boolean
541
- %t986 = call core.and(%t984, %t985) :: boolean
542
- %t990 = call core.clamp(%t982, %t918, %t968) :: integer
543
- %t991 = gather %t959, %t990 :: integer
544
- %t993 = select %t986, %t991, %t918 :: integer
545
- %t1012 = call core.lt(%t962, %t927) :: boolean
546
- %t1013 = call core.and(%t964, %t1012) :: boolean
547
- %t1014 = call core.and(%t921, %t1013) :: boolean
548
- %t1016 = call core.sub(%t927, %t922) :: integer
549
- %t1018 = call core.clamp(%t962, %t918, %t1016) :: integer
550
- %t1019 = gather %t926, %t1018 :: integer
551
- %t1021 = select %t1014, %t1019, %t918 :: integer
552
- %t1040 = call core.lt(%t982, %t927) :: boolean
553
- %t1041 = call core.and(%t984, %t1040) :: boolean
554
- %t1042 = call core.and(%t921, %t1041) :: boolean
555
- %t1046 = call core.clamp(%t982, %t918, %t1016) :: integer
556
- %t1047 = gather %t926, %t1046 :: integer
557
- %t1049 = select %t1042, %t1047, %t918 :: integer
558
- %t1068 = call core.lt(%t962, %t947) :: boolean
559
- %t1069 = call core.and(%t964, %t1068) :: boolean
560
- %t1070 = call core.and(%t941, %t1069) :: boolean
561
- %t1072 = call core.sub(%t947, %t922) :: integer
562
- %t1074 = call core.clamp(%t962, %t918, %t1072) :: integer
563
- %t1075 = gather %t946, %t1074 :: integer
564
- %t1077 = select %t1070, %t1075, %t918 :: integer
565
- %t1096 = call core.lt(%t982, %t947) :: boolean
566
- %t1097 = call core.and(%t984, %t1096) :: boolean
567
- %t1098 = call core.and(%t941, %t1097) :: boolean
568
- %t1102 = call core.clamp(%t982, %t918, %t1072) :: integer
569
- %t1103 = gather %t946, %t1102 :: integer
570
- %t1105 = select %t1098, %t1103, %t918 :: integer
571
- %t1106 = make_tuple(%t933, %t953, %t973, %t993, %t1021, %t1049, %t1077, %t1105) :: tuple<integer>
572
- %t1107 = fold %t1106 fn="agg.sum" ::
573
- %t511 = const 2 :: integer
574
- %t512 = call core.eq(%t1107, %t511) :: boolean
575
- %t516 = call core.gt(%col_el_272, %t918) :: boolean
576
- %t276 = call core.and(%t512, %t516) :: boolean
496
+ %t909 = length %t269 :: integer
497
+ %t910 = const -1 :: integer
498
+ %t911 = call core.sub(%rows_i_271, %t910) :: integer
499
+ %t912 = const 0 :: integer
500
+ %t913 = call core.gte(%t911, %t912) :: boolean
501
+ %t914 = call core.lt(%t911, %t909) :: boolean
502
+ %t915 = call core.and(%t913, %t914) :: boolean
503
+ %t916 = const 1 :: integer
504
+ %t917 = call core.sub(%t909, %t916) :: integer
505
+ %t919 = call core.clamp(%t911, %t912, %t917) :: integer
506
+ %t920 = gather %t269, %t919 :: any
507
+ %t921 = length %t920 :: integer
508
+ %t922 = call core.mod(%col_i_273, %t921) :: integer
509
+ %t923 = call core.add(%t922, %t921) :: integer
510
+ %t924 = call core.mod(%t923, %t921) :: integer
511
+ %t925 = gather %t920, %t924 :: integer
512
+ %t927 = select %t915, %t925, %t912 :: integer
513
+ %t931 = call core.sub(%rows_i_271, %t916) :: integer
514
+ %t933 = call core.gte(%t931, %t912) :: boolean
515
+ %t934 = call core.lt(%t931, %t909) :: boolean
516
+ %t935 = call core.and(%t933, %t934) :: boolean
517
+ %t939 = call core.clamp(%t931, %t912, %t917) :: integer
518
+ %t940 = gather %t269, %t939 :: any
519
+ %t941 = length %t940 :: integer
520
+ %t942 = call core.mod(%col_i_273, %t941) :: integer
521
+ %t943 = call core.add(%t942, %t941) :: integer
522
+ %t944 = call core.mod(%t943, %t941) :: integer
523
+ %t945 = gather %t940, %t944 :: integer
524
+ %t947 = select %t935, %t945, %t912 :: integer
525
+ %t950 = call core.mod(%rows_i_271, %t909) :: integer
526
+ %t951 = call core.add(%t950, %t909) :: integer
527
+ %t952 = call core.mod(%t951, %t909) :: integer
528
+ %t953 = gather %t269, %t952 :: any
529
+ %t954 = length %t953 :: integer
530
+ %t956 = call core.sub(%col_i_273, %t910) :: integer
531
+ %t958 = call core.gte(%t956, %t912) :: boolean
532
+ %t959 = call core.lt(%t956, %t954) :: boolean
533
+ %t960 = call core.and(%t958, %t959) :: boolean
534
+ %t962 = call core.sub(%t954, %t916) :: integer
535
+ %t964 = call core.clamp(%t956, %t912, %t962) :: integer
536
+ %t965 = gather %t953, %t964 :: integer
537
+ %t967 = select %t960, %t965, %t912 :: integer
538
+ %t976 = call core.sub(%col_i_273, %t916) :: integer
539
+ %t978 = call core.gte(%t976, %t912) :: boolean
540
+ %t979 = call core.lt(%t976, %t954) :: boolean
541
+ %t980 = call core.and(%t978, %t979) :: boolean
542
+ %t984 = call core.clamp(%t976, %t912, %t962) :: integer
543
+ %t985 = gather %t953, %t984 :: integer
544
+ %t987 = select %t980, %t985, %t912 :: integer
545
+ %t1006 = call core.lt(%t956, %t921) :: boolean
546
+ %t1007 = call core.and(%t958, %t1006) :: boolean
547
+ %t1008 = call core.and(%t915, %t1007) :: boolean
548
+ %t1010 = call core.sub(%t921, %t916) :: integer
549
+ %t1012 = call core.clamp(%t956, %t912, %t1010) :: integer
550
+ %t1013 = gather %t920, %t1012 :: integer
551
+ %t1015 = select %t1008, %t1013, %t912 :: integer
552
+ %t1034 = call core.lt(%t976, %t921) :: boolean
553
+ %t1035 = call core.and(%t978, %t1034) :: boolean
554
+ %t1036 = call core.and(%t915, %t1035) :: boolean
555
+ %t1040 = call core.clamp(%t976, %t912, %t1010) :: integer
556
+ %t1041 = gather %t920, %t1040 :: integer
557
+ %t1043 = select %t1036, %t1041, %t912 :: integer
558
+ %t1062 = call core.lt(%t956, %t941) :: boolean
559
+ %t1063 = call core.and(%t958, %t1062) :: boolean
560
+ %t1064 = call core.and(%t935, %t1063) :: boolean
561
+ %t1066 = call core.sub(%t941, %t916) :: integer
562
+ %t1068 = call core.clamp(%t956, %t912, %t1066) :: integer
563
+ %t1069 = gather %t940, %t1068 :: integer
564
+ %t1071 = select %t1064, %t1069, %t912 :: integer
565
+ %t1090 = call core.lt(%t976, %t941) :: boolean
566
+ %t1091 = call core.and(%t978, %t1090) :: boolean
567
+ %t1092 = call core.and(%t935, %t1091) :: boolean
568
+ %t1096 = call core.clamp(%t976, %t912, %t1066) :: integer
569
+ %t1097 = gather %t940, %t1096 :: integer
570
+ %t1099 = select %t1092, %t1097, %t912 :: integer
571
+ %t906 = make_tuple(%t927, %t947, %t967, %t987, %t1015, %t1043, %t1071, %t1099) :: tuple<integer>
572
+ %t907 = fold %t906 fn="agg.sum" ::
573
+ %t895 = const 2 :: integer
574
+ %t896 = call core.eq(%t907, %t895) :: boolean
575
+ %t1103 = call core.gt(%col_el_272, %t912) :: boolean
576
+ %t276 = call core.and(%t896, %t1103) :: boolean
577
577
  yield %t276
578
578
  end_loop
579
579
  end_loop
@@ -582,90 +582,90 @@
582
582
  %t277 = load_input "rows" :: array
583
583
  loop rows id=L29 in %t277 as el=%rows_el_278, idx=%rows_i_279
584
584
  loop col id=L30 in %rows_el_278 as el=%col_el_280, idx=%col_i_281
585
- %t1111 = length %t277 :: integer
586
- %t1112 = const -1 :: integer
587
- %t1113 = call core.sub(%rows_i_279, %t1112) :: integer
588
- %t1114 = const 0 :: integer
589
- %t1115 = call core.gte(%t1113, %t1114) :: boolean
590
- %t1116 = call core.lt(%t1113, %t1111) :: boolean
591
- %t1117 = call core.and(%t1115, %t1116) :: boolean
592
- %t1118 = const 1 :: integer
593
- %t1119 = call core.sub(%t1111, %t1118) :: integer
594
- %t1121 = call core.clamp(%t1113, %t1114, %t1119) :: integer
595
- %t1122 = gather %t277, %t1121 :: any
596
- %t1123 = length %t1122 :: integer
597
- %t1124 = call core.mod(%col_i_281, %t1123) :: integer
598
- %t1125 = call core.add(%t1124, %t1123) :: integer
599
- %t1126 = call core.mod(%t1125, %t1123) :: integer
600
- %t1127 = gather %t1122, %t1126 :: integer
601
- %t1129 = select %t1117, %t1127, %t1114 :: integer
602
- %t1133 = call core.sub(%rows_i_279, %t1118) :: integer
603
- %t1135 = call core.gte(%t1133, %t1114) :: boolean
604
- %t1136 = call core.lt(%t1133, %t1111) :: boolean
605
- %t1137 = call core.and(%t1135, %t1136) :: boolean
606
- %t1141 = call core.clamp(%t1133, %t1114, %t1119) :: integer
607
- %t1142 = gather %t277, %t1141 :: any
608
- %t1143 = length %t1142 :: integer
609
- %t1144 = call core.mod(%col_i_281, %t1143) :: integer
610
- %t1145 = call core.add(%t1144, %t1143) :: integer
611
- %t1146 = call core.mod(%t1145, %t1143) :: integer
612
- %t1147 = gather %t1142, %t1146 :: integer
613
- %t1149 = select %t1137, %t1147, %t1114 :: integer
614
- %t1152 = call core.mod(%rows_i_279, %t1111) :: integer
615
- %t1153 = call core.add(%t1152, %t1111) :: integer
616
- %t1154 = call core.mod(%t1153, %t1111) :: integer
617
- %t1155 = gather %t277, %t1154 :: any
618
- %t1156 = length %t1155 :: integer
619
- %t1158 = call core.sub(%col_i_281, %t1112) :: integer
620
- %t1160 = call core.gte(%t1158, %t1114) :: boolean
621
- %t1161 = call core.lt(%t1158, %t1156) :: boolean
622
- %t1162 = call core.and(%t1160, %t1161) :: boolean
623
- %t1164 = call core.sub(%t1156, %t1118) :: integer
624
- %t1166 = call core.clamp(%t1158, %t1114, %t1164) :: integer
625
- %t1167 = gather %t1155, %t1166 :: integer
626
- %t1169 = select %t1162, %t1167, %t1114 :: integer
627
- %t1178 = call core.sub(%col_i_281, %t1118) :: integer
628
- %t1180 = call core.gte(%t1178, %t1114) :: boolean
629
- %t1181 = call core.lt(%t1178, %t1156) :: boolean
630
- %t1182 = call core.and(%t1180, %t1181) :: boolean
631
- %t1186 = call core.clamp(%t1178, %t1114, %t1164) :: integer
632
- %t1187 = gather %t1155, %t1186 :: integer
633
- %t1189 = select %t1182, %t1187, %t1114 :: integer
634
- %t1208 = call core.lt(%t1158, %t1123) :: boolean
635
- %t1209 = call core.and(%t1160, %t1208) :: boolean
636
- %t1210 = call core.and(%t1117, %t1209) :: boolean
637
- %t1212 = call core.sub(%t1123, %t1118) :: integer
638
- %t1214 = call core.clamp(%t1158, %t1114, %t1212) :: integer
639
- %t1215 = gather %t1122, %t1214 :: integer
640
- %t1217 = select %t1210, %t1215, %t1114 :: integer
641
- %t1236 = call core.lt(%t1178, %t1123) :: boolean
642
- %t1237 = call core.and(%t1180, %t1236) :: boolean
643
- %t1238 = call core.and(%t1117, %t1237) :: boolean
644
- %t1242 = call core.clamp(%t1178, %t1114, %t1212) :: integer
645
- %t1243 = gather %t1122, %t1242 :: integer
646
- %t1245 = select %t1238, %t1243, %t1114 :: integer
647
- %t1264 = call core.lt(%t1158, %t1143) :: boolean
648
- %t1265 = call core.and(%t1160, %t1264) :: boolean
649
- %t1266 = call core.and(%t1137, %t1265) :: boolean
650
- %t1268 = call core.sub(%t1143, %t1118) :: integer
651
- %t1270 = call core.clamp(%t1158, %t1114, %t1268) :: integer
652
- %t1271 = gather %t1142, %t1270 :: integer
653
- %t1273 = select %t1266, %t1271, %t1114 :: integer
654
- %t1292 = call core.lt(%t1178, %t1143) :: boolean
655
- %t1293 = call core.and(%t1180, %t1292) :: boolean
656
- %t1294 = call core.and(%t1137, %t1293) :: boolean
657
- %t1298 = call core.clamp(%t1178, %t1114, %t1268) :: integer
658
- %t1299 = gather %t1142, %t1298 :: integer
659
- %t1301 = select %t1294, %t1299, %t1114 :: integer
660
- %t1302 = make_tuple(%t1129, %t1149, %t1169, %t1189, %t1217, %t1245, %t1273, %t1301) :: tuple<integer>
661
- %t1303 = fold %t1302 fn="agg.sum" ::
662
- %t519 = const 3 :: integer
663
- %t520 = call core.eq(%t1303, %t519) :: boolean
664
- %t1316 = const 2 :: integer
665
- %t1317 = call core.eq(%t1303, %t1316) :: boolean
666
- %t1321 = call core.gt(%col_el_280, %t1114) :: boolean
667
- %t524 = call core.and(%t1317, %t1321) :: boolean
668
- %t284 = call core.or(%t520, %t524) :: boolean
585
+ %t1121 = length %t277 :: integer
586
+ %t1122 = const -1 :: integer
587
+ %t1123 = call core.sub(%rows_i_279, %t1122) :: integer
588
+ %t1124 = const 0 :: integer
589
+ %t1125 = call core.gte(%t1123, %t1124) :: boolean
590
+ %t1126 = call core.lt(%t1123, %t1121) :: boolean
591
+ %t1127 = call core.and(%t1125, %t1126) :: boolean
592
+ %t1128 = const 1 :: integer
593
+ %t1129 = call core.sub(%t1121, %t1128) :: integer
594
+ %t1131 = call core.clamp(%t1123, %t1124, %t1129) :: integer
595
+ %t1132 = gather %t277, %t1131 :: any
596
+ %t1133 = length %t1132 :: integer
597
+ %t1134 = call core.mod(%col_i_281, %t1133) :: integer
598
+ %t1135 = call core.add(%t1134, %t1133) :: integer
599
+ %t1136 = call core.mod(%t1135, %t1133) :: integer
600
+ %t1137 = gather %t1132, %t1136 :: integer
601
+ %t1139 = select %t1127, %t1137, %t1124 :: integer
602
+ %t1143 = call core.sub(%rows_i_279, %t1128) :: integer
603
+ %t1145 = call core.gte(%t1143, %t1124) :: boolean
604
+ %t1146 = call core.lt(%t1143, %t1121) :: boolean
605
+ %t1147 = call core.and(%t1145, %t1146) :: boolean
606
+ %t1151 = call core.clamp(%t1143, %t1124, %t1129) :: integer
607
+ %t1152 = gather %t277, %t1151 :: any
608
+ %t1153 = length %t1152 :: integer
609
+ %t1154 = call core.mod(%col_i_281, %t1153) :: integer
610
+ %t1155 = call core.add(%t1154, %t1153) :: integer
611
+ %t1156 = call core.mod(%t1155, %t1153) :: integer
612
+ %t1157 = gather %t1152, %t1156 :: integer
613
+ %t1159 = select %t1147, %t1157, %t1124 :: integer
614
+ %t1162 = call core.mod(%rows_i_279, %t1121) :: integer
615
+ %t1163 = call core.add(%t1162, %t1121) :: integer
616
+ %t1164 = call core.mod(%t1163, %t1121) :: integer
617
+ %t1165 = gather %t277, %t1164 :: any
618
+ %t1166 = length %t1165 :: integer
619
+ %t1168 = call core.sub(%col_i_281, %t1122) :: integer
620
+ %t1170 = call core.gte(%t1168, %t1124) :: boolean
621
+ %t1171 = call core.lt(%t1168, %t1166) :: boolean
622
+ %t1172 = call core.and(%t1170, %t1171) :: boolean
623
+ %t1174 = call core.sub(%t1166, %t1128) :: integer
624
+ %t1176 = call core.clamp(%t1168, %t1124, %t1174) :: integer
625
+ %t1177 = gather %t1165, %t1176 :: integer
626
+ %t1179 = select %t1172, %t1177, %t1124 :: integer
627
+ %t1188 = call core.sub(%col_i_281, %t1128) :: integer
628
+ %t1190 = call core.gte(%t1188, %t1124) :: boolean
629
+ %t1191 = call core.lt(%t1188, %t1166) :: boolean
630
+ %t1192 = call core.and(%t1190, %t1191) :: boolean
631
+ %t1196 = call core.clamp(%t1188, %t1124, %t1174) :: integer
632
+ %t1197 = gather %t1165, %t1196 :: integer
633
+ %t1199 = select %t1192, %t1197, %t1124 :: integer
634
+ %t1218 = call core.lt(%t1168, %t1133) :: boolean
635
+ %t1219 = call core.and(%t1170, %t1218) :: boolean
636
+ %t1220 = call core.and(%t1127, %t1219) :: boolean
637
+ %t1222 = call core.sub(%t1133, %t1128) :: integer
638
+ %t1224 = call core.clamp(%t1168, %t1124, %t1222) :: integer
639
+ %t1225 = gather %t1132, %t1224 :: integer
640
+ %t1227 = select %t1220, %t1225, %t1124 :: integer
641
+ %t1246 = call core.lt(%t1188, %t1133) :: boolean
642
+ %t1247 = call core.and(%t1190, %t1246) :: boolean
643
+ %t1248 = call core.and(%t1127, %t1247) :: boolean
644
+ %t1252 = call core.clamp(%t1188, %t1124, %t1222) :: integer
645
+ %t1253 = gather %t1132, %t1252 :: integer
646
+ %t1255 = select %t1248, %t1253, %t1124 :: integer
647
+ %t1274 = call core.lt(%t1168, %t1153) :: boolean
648
+ %t1275 = call core.and(%t1170, %t1274) :: boolean
649
+ %t1276 = call core.and(%t1147, %t1275) :: boolean
650
+ %t1278 = call core.sub(%t1153, %t1128) :: integer
651
+ %t1280 = call core.clamp(%t1168, %t1124, %t1278) :: integer
652
+ %t1281 = gather %t1152, %t1280 :: integer
653
+ %t1283 = select %t1276, %t1281, %t1124 :: integer
654
+ %t1302 = call core.lt(%t1188, %t1153) :: boolean
655
+ %t1303 = call core.and(%t1190, %t1302) :: boolean
656
+ %t1304 = call core.and(%t1147, %t1303) :: boolean
657
+ %t1308 = call core.clamp(%t1188, %t1124, %t1278) :: integer
658
+ %t1309 = gather %t1152, %t1308 :: integer
659
+ %t1311 = select %t1304, %t1309, %t1124 :: integer
660
+ %t1118 = make_tuple(%t1139, %t1159, %t1179, %t1199, %t1227, %t1255, %t1283, %t1311) :: tuple<integer>
661
+ %t1119 = fold %t1118 fn="agg.sum" ::
662
+ %t1107 = const 3 :: integer
663
+ %t1108 = call core.eq(%t1119, %t1107) :: boolean
664
+ %t1318 = const 2 :: integer
665
+ %t1319 = call core.eq(%t1119, %t1318) :: boolean
666
+ %t1526 = call core.gt(%col_el_280, %t1124) :: boolean
667
+ %t1315 = call core.and(%t1319, %t1526) :: boolean
668
+ %t284 = call core.or(%t1108, %t1315) :: boolean
669
669
  yield %t284
670
670
  end_loop
671
671
  end_loop
@@ -674,91 +674,91 @@
674
674
  %t285 = load_input "rows" :: array
675
675
  loop rows id=L31 in %t285 as el=%rows_el_286, idx=%rows_i_287
676
676
  loop col id=L32 in %rows_el_286 as el=%col_el_288, idx=%col_i_289
677
- %t1539 = length %t285 :: integer
678
- %t1540 = const -1 :: integer
679
- %t1541 = call core.sub(%rows_i_287, %t1540) :: integer
680
- %t1542 = const 0 :: integer
681
- %t1543 = call core.gte(%t1541, %t1542) :: boolean
682
- %t1544 = call core.lt(%t1541, %t1539) :: boolean
683
- %t1545 = call core.and(%t1543, %t1544) :: boolean
684
- %t1546 = const 1 :: integer
685
- %t1547 = call core.sub(%t1539, %t1546) :: integer
686
- %t1549 = call core.clamp(%t1541, %t1542, %t1547) :: integer
687
- %t1550 = gather %t285, %t1549 :: any
688
- %t1551 = length %t1550 :: integer
689
- %t1552 = call core.mod(%col_i_289, %t1551) :: integer
690
- %t1553 = call core.add(%t1552, %t1551) :: integer
691
- %t1554 = call core.mod(%t1553, %t1551) :: integer
692
- %t1555 = gather %t1550, %t1554 :: integer
693
- %t1557 = select %t1545, %t1555, %t1542 :: integer
694
- %t1561 = call core.sub(%rows_i_287, %t1546) :: integer
695
- %t1563 = call core.gte(%t1561, %t1542) :: boolean
696
- %t1564 = call core.lt(%t1561, %t1539) :: boolean
697
- %t1565 = call core.and(%t1563, %t1564) :: boolean
698
- %t1569 = call core.clamp(%t1561, %t1542, %t1547) :: integer
699
- %t1570 = gather %t285, %t1569 :: any
700
- %t1571 = length %t1570 :: integer
701
- %t1572 = call core.mod(%col_i_289, %t1571) :: integer
702
- %t1573 = call core.add(%t1572, %t1571) :: integer
703
- %t1574 = call core.mod(%t1573, %t1571) :: integer
704
- %t1575 = gather %t1570, %t1574 :: integer
705
- %t1577 = select %t1565, %t1575, %t1542 :: integer
706
- %t1580 = call core.mod(%rows_i_287, %t1539) :: integer
707
- %t1581 = call core.add(%t1580, %t1539) :: integer
708
- %t1582 = call core.mod(%t1581, %t1539) :: integer
709
- %t1583 = gather %t285, %t1582 :: any
710
- %t1584 = length %t1583 :: integer
711
- %t1586 = call core.sub(%col_i_289, %t1540) :: integer
712
- %t1588 = call core.gte(%t1586, %t1542) :: boolean
713
- %t1589 = call core.lt(%t1586, %t1584) :: boolean
714
- %t1590 = call core.and(%t1588, %t1589) :: boolean
715
- %t1592 = call core.sub(%t1584, %t1546) :: integer
716
- %t1594 = call core.clamp(%t1586, %t1542, %t1592) :: integer
717
- %t1595 = gather %t1583, %t1594 :: integer
718
- %t1597 = select %t1590, %t1595, %t1542 :: integer
719
- %t1606 = call core.sub(%col_i_289, %t1546) :: integer
720
- %t1608 = call core.gte(%t1606, %t1542) :: boolean
721
- %t1609 = call core.lt(%t1606, %t1584) :: boolean
722
- %t1610 = call core.and(%t1608, %t1609) :: boolean
723
- %t1614 = call core.clamp(%t1606, %t1542, %t1592) :: integer
724
- %t1615 = gather %t1583, %t1614 :: integer
725
- %t1617 = select %t1610, %t1615, %t1542 :: integer
726
- %t1636 = call core.lt(%t1586, %t1551) :: boolean
727
- %t1637 = call core.and(%t1588, %t1636) :: boolean
728
- %t1638 = call core.and(%t1545, %t1637) :: boolean
729
- %t1640 = call core.sub(%t1551, %t1546) :: integer
730
- %t1642 = call core.clamp(%t1586, %t1542, %t1640) :: integer
731
- %t1643 = gather %t1550, %t1642 :: integer
732
- %t1645 = select %t1638, %t1643, %t1542 :: integer
733
- %t1664 = call core.lt(%t1606, %t1551) :: boolean
734
- %t1665 = call core.and(%t1608, %t1664) :: boolean
735
- %t1666 = call core.and(%t1545, %t1665) :: boolean
736
- %t1670 = call core.clamp(%t1606, %t1542, %t1640) :: integer
737
- %t1671 = gather %t1550, %t1670 :: integer
738
- %t1673 = select %t1666, %t1671, %t1542 :: integer
739
- %t1692 = call core.lt(%t1586, %t1571) :: boolean
740
- %t1693 = call core.and(%t1588, %t1692) :: boolean
741
- %t1694 = call core.and(%t1565, %t1693) :: boolean
742
- %t1696 = call core.sub(%t1571, %t1546) :: integer
743
- %t1698 = call core.clamp(%t1586, %t1542, %t1696) :: integer
744
- %t1699 = gather %t1570, %t1698 :: integer
745
- %t1701 = select %t1694, %t1699, %t1542 :: integer
746
- %t1720 = call core.lt(%t1606, %t1571) :: boolean
747
- %t1721 = call core.and(%t1608, %t1720) :: boolean
748
- %t1722 = call core.and(%t1565, %t1721) :: boolean
749
- %t1726 = call core.clamp(%t1606, %t1542, %t1696) :: integer
750
- %t1727 = gather %t1570, %t1726 :: integer
751
- %t1729 = select %t1722, %t1727, %t1542 :: integer
752
- %t1332 = make_tuple(%t1557, %t1577, %t1597, %t1617, %t1645, %t1673, %t1701, %t1729) :: tuple<integer>
753
- %t1333 = fold %t1332 fn="agg.sum" ::
754
- %t1334 = const 3 :: integer
755
- %t1335 = call core.eq(%t1333, %t1334) :: boolean
756
- %t1339 = const 2 :: integer
757
- %t1340 = call core.eq(%t1333, %t1339) :: boolean
758
- %t1344 = call core.gt(%col_el_288, %t1542) :: boolean
759
- %t1345 = call core.and(%t1340, %t1344) :: boolean
760
- %t528 = call core.or(%t1335, %t1345) :: boolean
761
- %t293 = select %t528, %t1546, %t1542 :: integer
677
+ %t1548 = length %t285 :: integer
678
+ %t1549 = const -1 :: integer
679
+ %t1550 = call core.sub(%rows_i_287, %t1549) :: integer
680
+ %t1551 = const 0 :: integer
681
+ %t1552 = call core.gte(%t1550, %t1551) :: boolean
682
+ %t1553 = call core.lt(%t1550, %t1548) :: boolean
683
+ %t1554 = call core.and(%t1552, %t1553) :: boolean
684
+ %t1555 = const 1 :: integer
685
+ %t1556 = call core.sub(%t1548, %t1555) :: integer
686
+ %t1558 = call core.clamp(%t1550, %t1551, %t1556) :: integer
687
+ %t1559 = gather %t285, %t1558 :: any
688
+ %t1560 = length %t1559 :: integer
689
+ %t1561 = call core.mod(%col_i_289, %t1560) :: integer
690
+ %t1562 = call core.add(%t1561, %t1560) :: integer
691
+ %t1563 = call core.mod(%t1562, %t1560) :: integer
692
+ %t1564 = gather %t1559, %t1563 :: integer
693
+ %t1566 = select %t1554, %t1564, %t1551 :: integer
694
+ %t1570 = call core.sub(%rows_i_287, %t1555) :: integer
695
+ %t1572 = call core.gte(%t1570, %t1551) :: boolean
696
+ %t1573 = call core.lt(%t1570, %t1548) :: boolean
697
+ %t1574 = call core.and(%t1572, %t1573) :: boolean
698
+ %t1578 = call core.clamp(%t1570, %t1551, %t1556) :: integer
699
+ %t1579 = gather %t285, %t1578 :: any
700
+ %t1580 = length %t1579 :: integer
701
+ %t1581 = call core.mod(%col_i_289, %t1580) :: integer
702
+ %t1582 = call core.add(%t1581, %t1580) :: integer
703
+ %t1583 = call core.mod(%t1582, %t1580) :: integer
704
+ %t1584 = gather %t1579, %t1583 :: integer
705
+ %t1586 = select %t1574, %t1584, %t1551 :: integer
706
+ %t1589 = call core.mod(%rows_i_287, %t1548) :: integer
707
+ %t1590 = call core.add(%t1589, %t1548) :: integer
708
+ %t1591 = call core.mod(%t1590, %t1548) :: integer
709
+ %t1592 = gather %t285, %t1591 :: any
710
+ %t1593 = length %t1592 :: integer
711
+ %t1595 = call core.sub(%col_i_289, %t1549) :: integer
712
+ %t1597 = call core.gte(%t1595, %t1551) :: boolean
713
+ %t1598 = call core.lt(%t1595, %t1593) :: boolean
714
+ %t1599 = call core.and(%t1597, %t1598) :: boolean
715
+ %t1601 = call core.sub(%t1593, %t1555) :: integer
716
+ %t1603 = call core.clamp(%t1595, %t1551, %t1601) :: integer
717
+ %t1604 = gather %t1592, %t1603 :: integer
718
+ %t1606 = select %t1599, %t1604, %t1551 :: integer
719
+ %t1615 = call core.sub(%col_i_289, %t1555) :: integer
720
+ %t1617 = call core.gte(%t1615, %t1551) :: boolean
721
+ %t1618 = call core.lt(%t1615, %t1593) :: boolean
722
+ %t1619 = call core.and(%t1617, %t1618) :: boolean
723
+ %t1623 = call core.clamp(%t1615, %t1551, %t1601) :: integer
724
+ %t1624 = gather %t1592, %t1623 :: integer
725
+ %t1626 = select %t1619, %t1624, %t1551 :: integer
726
+ %t1645 = call core.lt(%t1595, %t1560) :: boolean
727
+ %t1646 = call core.and(%t1597, %t1645) :: boolean
728
+ %t1647 = call core.and(%t1554, %t1646) :: boolean
729
+ %t1649 = call core.sub(%t1560, %t1555) :: integer
730
+ %t1651 = call core.clamp(%t1595, %t1551, %t1649) :: integer
731
+ %t1652 = gather %t1559, %t1651 :: integer
732
+ %t1654 = select %t1647, %t1652, %t1551 :: integer
733
+ %t1673 = call core.lt(%t1615, %t1560) :: boolean
734
+ %t1674 = call core.and(%t1617, %t1673) :: boolean
735
+ %t1675 = call core.and(%t1554, %t1674) :: boolean
736
+ %t1679 = call core.clamp(%t1615, %t1551, %t1649) :: integer
737
+ %t1680 = gather %t1559, %t1679 :: integer
738
+ %t1682 = select %t1675, %t1680, %t1551 :: integer
739
+ %t1701 = call core.lt(%t1595, %t1580) :: boolean
740
+ %t1702 = call core.and(%t1597, %t1701) :: boolean
741
+ %t1703 = call core.and(%t1574, %t1702) :: boolean
742
+ %t1705 = call core.sub(%t1580, %t1555) :: integer
743
+ %t1707 = call core.clamp(%t1595, %t1551, %t1705) :: integer
744
+ %t1708 = gather %t1579, %t1707 :: integer
745
+ %t1710 = select %t1703, %t1708, %t1551 :: integer
746
+ %t1729 = call core.lt(%t1615, %t1580) :: boolean
747
+ %t1730 = call core.and(%t1617, %t1729) :: boolean
748
+ %t1731 = call core.and(%t1574, %t1730) :: boolean
749
+ %t1735 = call core.clamp(%t1615, %t1551, %t1705) :: integer
750
+ %t1736 = gather %t1579, %t1735 :: integer
751
+ %t1738 = select %t1731, %t1736, %t1551 :: integer
752
+ %t1545 = make_tuple(%t1566, %t1586, %t1606, %t1626, %t1654, %t1682, %t1710, %t1738) :: tuple<integer>
753
+ %t1546 = fold %t1545 fn="agg.sum" ::
754
+ %t1534 = const 3 :: integer
755
+ %t1535 = call core.eq(%t1546, %t1534) :: boolean
756
+ %t1745 = const 2 :: integer
757
+ %t1746 = call core.eq(%t1546, %t1745) :: boolean
758
+ %t1953 = call core.gt(%col_el_288, %t1551) :: boolean
759
+ %t1742 = call core.and(%t1746, %t1953) :: boolean
760
+ %t1531 = call core.or(%t1535, %t1742) :: boolean
761
+ %t293 = select %t1531, %t1555, %t1551 :: integer
762
762
  yield %t293
763
763
  end_loop
764
764
  end_loop