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