kumi 0.0.31 → 0.0.33

data/golden/schema_imports_with_imports/schema.kumi

@@ -0,0 +1,10 @@
+schema do
+  import :tax, from: Kumi::TestSharedSchemas::Tax
+
+  input do
+    decimal :amount
+  end
+
+  value :tax_result, tax(amount: input.amount)
+  value :total, input.amount + tax_result
+end

data/golden/shift/expected/lir_06_const_prop.txt

@@ -2,47 +2,40 @@
   (Declaration shift_right_zero
     %t1 = load_input "cells" :: array
     %t4 = length %t1 :: integer
-    %t5 = const 1 :: integer
-    %t7 = const 0 :: integer
-    %t12 = call core.sub(%t4, %t5) :: integer
+    %t12 = call core.sub(%t4, 1) :: integer
     loop cells id=L1 in %t1 as el=%cells_el_2, idx=%cells_i_3
-      %t6 = call core.sub(%cells_i_3, %t5) :: integer
-      %t8 = call core.gte(%t6, %t7) :: boolean
+      %t6 = call core.sub(%cells_i_3, 1) :: integer
+      %t8 = call core.gte(%t6, 0) :: boolean
       %t9 = call core.lt(%t6, %t4) :: boolean
-      %t14 = call core.clamp(%t6, %t7, %t12) :: integer
+      %t14 = call core.clamp(%t6, 0, %t12) :: integer
       %t10 = call core.and(%t8, %t9) :: boolean
       %t15 = gather %t1, %t14 :: integer
-      %t17 = select %t10, %t15, %t7 :: integer
+      %t17 = select %t10, %t15, 0 :: integer
       yield %t17
     end_loop
   )
   (Declaration shift_left_zero
     %t18 = load_input "cells" :: array
     %t21 = length %t18 :: integer
-    %t22 = const -1 :: integer
-    %t24 = const 0 :: integer
-    %t28 = const 1 :: integer
-    %t29 = call core.sub(%t21, %t28) :: integer
+    %t29 = call core.sub(%t21, 1) :: integer
     loop cells id=L2 in %t18 as el=%cells_el_19, idx=%cells_i_20
-      %t23 = call core.sub(%cells_i_20, %t22) :: integer
-      %t25 = call core.gte(%t23, %t24) :: boolean
+      %t23 = call core.sub(%cells_i_20, -1) :: integer
+      %t25 = call core.gte(%t23, 0) :: boolean
       %t26 = call core.lt(%t23, %t21) :: boolean
-      %t31 = call core.clamp(%t23, %t24, %t29) :: integer
+      %t31 = call core.clamp(%t23, 0, %t29) :: integer
       %t27 = call core.and(%t25, %t26) :: boolean
       %t32 = gather %t18, %t31 :: integer
-      %t34 = select %t27, %t32, %t24 :: integer
+      %t34 = select %t27, %t32, 0 :: integer
       yield %t34
     end_loop
   )
   (Declaration shift_right_clamp
     %t35 = load_input "cells" :: array
     %t38 = length %t35 :: integer
-    %t39 = const 1 :: integer
-    %t43 = const 0 :: integer
-    %t42 = call core.sub(%t38, %t39) :: integer
+    %t42 = call core.sub(%t38, 1) :: integer
     loop cells id=L3 in %t35 as el=%cells_el_36, idx=%cells_i_37
-      %t40 = call core.sub(%cells_i_37, %t39) :: integer
-      %t44 = call core.clamp(%t40, %t43, %t42) :: integer
+      %t40 = call core.sub(%cells_i_37, 1) :: integer
+      %t44 = call core.clamp(%t40, 0, %t42) :: integer
       %t45 = gather %t35, %t44 :: integer
       yield %t45
     end_loop
@@ -50,13 +43,10 @@
   (Declaration shift_left_clamp
     %t46 = load_input "cells" :: array
     %t49 = length %t46 :: integer
-    %t50 = const -1 :: integer
-    %t52 = const 1 :: integer
-    %t54 = const 0 :: integer
-    %t53 = call core.sub(%t49, %t52) :: integer
+    %t53 = call core.sub(%t49, 1) :: integer
     loop cells id=L4 in %t46 as el=%cells_el_47, idx=%cells_i_48
-      %t51 = call core.sub(%cells_i_48, %t50) :: integer
-      %t55 = call core.clamp(%t51, %t54, %t53) :: integer
+      %t51 = call core.sub(%cells_i_48, -1) :: integer
+      %t55 = call core.clamp(%t51, 0, %t53) :: integer
       %t56 = gather %t46, %t55 :: integer
       yield %t56
     end_loop
@@ -64,9 +54,8 @@
   (Declaration shift_right_wrap
     %t57 = load_input "cells" :: array
     %t60 = length %t57 :: integer
-    %t61 = const 1 :: integer
     loop cells id=L5 in %t57 as el=%cells_el_58, idx=%cells_i_59
-      %t62 = call core.sub(%cells_i_59, %t61) :: integer
+      %t62 = call core.sub(%cells_i_59, 1) :: integer
       %t63 = call core.mod(%t62, %t60) :: integer
       %t64 = call core.add(%t63, %t60) :: integer
       %t65 = call core.mod(%t64, %t60) :: integer
@@ -77,9 +66,8 @@
   (Declaration shift_left_wrap
     %t67 = load_input "cells" :: array
     %t70 = length %t67 :: integer
-    %t71 = const -1 :: integer
     loop cells id=L6 in %t67 as el=%cells_el_68, idx=%cells_i_69
-      %t72 = call core.sub(%cells_i_69, %t71) :: integer
+      %t72 = call core.sub(%cells_i_69, -1) :: integer
       %t73 = call core.mod(%t72, %t70) :: integer
       %t74 = call core.add(%t73, %t70) :: integer
       %t75 = call core.mod(%t74, %t70) :: integer

data/golden/shift/expected/schema_javascript.mjs

@@ -2,17 +2,15 @@ export function _shift_right_zero(input) {
   let out = [];
   let t1 = input["cells"];
   let t4 = t1.length;
-  const t5 = 1;
-  const t7 = 0;
-  let t12 = t4 - t5;
+  let t12 = t4 - 1;
   t1.forEach((cells_el_2, cells_i_3) => {
-    let t6 = cells_i_3 - t5;
-    let t8 = t6 >= t7;
+    let t6 = cells_i_3 - 1;
+    let t8 = t6 >= 0;
     let t9 = t6 < t4;
-    let t14 = Math.min(Math.max(t6, t7), t12);
+    let t14 = Math.min(Math.max(t6, 0), t12);
     let t10 = t8 && t9;
     let t15 = t1[t14];
-    let t17 = t10 ? t15 : t7;
+    let t17 = t10 ? t15 : 0;
     out.push(t17);
   });
   return out;
@@ -22,18 +20,15 @@ export function _shift_left_zero(input) {
   let out = [];
   let t18 = input["cells"];
   let t21 = t18.length;
-  const t22 = -1;
-  const t24 = 0;
-  const t28 = 1;
-  let t29 = t21 - t28;
+  let t29 = t21 - 1;
   t18.forEach((cells_el_19, cells_i_20) => {
-    let t23 = cells_i_20 - t22;
-    let t25 = t23 >= t24;
+    let t23 = cells_i_20 - -1;
+    let t25 = t23 >= 0;
     let t26 = t23 < t21;
-    let t31 = Math.min(Math.max(t23, t24), t29);
+    let t31 = Math.min(Math.max(t23, 0), t29);
     let t27 = t25 && t26;
     let t32 = t18[t31];
-    let t34 = t27 ? t32 : t24;
+    let t34 = t27 ? t32 : 0;
     out.push(t34);
   });
   return out;
@@ -43,12 +38,10 @@ export function _shift_right_clamp(input) {
   let out = [];
   let t35 = input["cells"];
   let t38 = t35.length;
-  const t39 = 1;
-  const t43 = 0;
-  let t42 = t38 - t39;
+  let t42 = t38 - 1;
   t35.forEach((cells_el_36, cells_i_37) => {
-    let t40 = cells_i_37 - t39;
-    let t44 = Math.min(Math.max(t40, t43), t42);
+    let t40 = cells_i_37 - 1;
+    let t44 = Math.min(Math.max(t40, 0), t42);
     let t45 = t35[t44];
     out.push(t45);
   });
@@ -59,13 +52,10 @@ export function _shift_left_clamp(input) {
   let out = [];
   let t46 = input["cells"];
   let t49 = t46.length;
-  const t50 = -1;
-  const t52 = 1;
-  const t54 = 0;
-  let t53 = t49 - t52;
+  let t53 = t49 - 1;
   t46.forEach((cells_el_47, cells_i_48) => {
-    let t51 = cells_i_48 - t50;
-    let t55 = Math.min(Math.max(t51, t54), t53);
+    let t51 = cells_i_48 - -1;
+    let t55 = Math.min(Math.max(t51, 0), t53);
     let t56 = t46[t55];
     out.push(t56);
   });
@@ -76,9 +66,8 @@ export function _shift_right_wrap(input) {
   let out = [];
   let t57 = input["cells"];
   let t60 = t57.length;
-  const t61 = 1;
   t57.forEach((cells_el_58, cells_i_59) => {
-    let t62 = cells_i_59 - t61;
+    let t62 = cells_i_59 - 1;
     let t63 = ((t62 % t60) + t60) % t60;
     let t64 = t63 + t60;
     let t65 = ((t64 % t60) + t60) % t60;
@@ -92,9 +81,8 @@ export function _shift_left_wrap(input) {
   let out = [];
   let t67 = input["cells"];
   let t70 = t67.length;
-  const t71 = -1;
   t67.forEach((cells_el_68, cells_i_69) => {
-    let t72 = cells_i_69 - t71;
+    let t72 = cells_i_69 - -1;
     let t73 = ((t72 % t70) + t70) % t70;
     let t74 = t73 + t70;
     let t75 = ((t74 % t70) + t70) % t70;

data/golden/shift/expected/schema_ruby.rb

@@ -1,116 +1,75 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_d17fb0388f7014e59c7e9a892d540e54a949f21eb86a9e8e8a396bc3488d6f35
-  def self.from(input_data = nil)
-    instance = Object.new
-    instance.extend(self)
-    instance.instance_variable_set(:@input, input_data)
-    instance
-  end
-
-  def self.__kumi_executable__
-    instance = Object.new
-    instance.extend(self)
-    instance
-  end
-
-  def update(input_data)
-    @input = @input.merge(input_data)
-    self
-  end
-
-  def [](name)
-    case name
-    when :shift_right_zero then _shift_right_zero
-    when :shift_left_zero then _shift_left_zero
-    when :shift_right_clamp then _shift_right_clamp
-    when :shift_left_clamp then _shift_left_clamp
-    when :shift_right_wrap then _shift_right_wrap
-    when :shift_left_wrap then _shift_left_wrap
-    else raise KeyError, "Unknown declaration"
-    end
-  end
-
-  def _shift_right_zero(input = @input)
+module Kumi::Compiled::KUMI_2b7190617d4ca7038571fc2106e31ea3ee978a4e39607c21cf922cf718c95e73
+  def self._shift_right_zero(input)
     out = []
     t1 = input["cells"] || input[:cells]
     t4 = t1.length
-    t5 = 1
-    t7 = 0
-    t12 = t4 - t5
+    t12 = t4 - 1
     t1.each_with_index do |cells_el_2, cells_i_3|
-      t6 = cells_i_3 - t5
-      t8 = t6 >= t7
+      t6 = cells_i_3 - 1
+      t8 = t6 >= 0
       t9 = t6 < t4
-      t14 = [[ t6, t7 ].max, t12 ].min
+      t14 = t6.clamp(0, t12)
       t10 = t8 && t9
       t15 = t1[t14]
-      t17 = t10 ? t15 : t7
+      t17 = t10 ? t15 : 0
       out << t17
     end
     out
   end
 
-  def _shift_left_zero(input = @input)
+  def self._shift_left_zero(input)
     out = []
     t18 = input["cells"] || input[:cells]
     t21 = t18.length
-    t22 = -1
-    t24 = 0
-    t28 = 1
-    t29 = t21 - t28
+    t29 = t21 - 1
     t18.each_with_index do |cells_el_19, cells_i_20|
-      t23 = cells_i_20 - t22
-      t25 = t23 >= t24
+      t23 = cells_i_20 - -1
+      t25 = t23 >= 0
       t26 = t23 < t21
-      t31 = [[ t23, t24 ].max, t29 ].min
+      t31 = t23.clamp(0, t29)
       t27 = t25 && t26
       t32 = t18[t31]
-      t34 = t27 ? t32 : t24
+      t34 = t27 ? t32 : 0
       out << t34
     end
     out
   end
 
-  def _shift_right_clamp(input = @input)
+  def self._shift_right_clamp(input)
     out = []
     t35 = input["cells"] || input[:cells]
     t38 = t35.length
-    t39 = 1
-    t43 = 0
-    t42 = t38 - t39
+    t42 = t38 - 1
     t35.each_with_index do |cells_el_36, cells_i_37|
-      t40 = cells_i_37 - t39
-      t44 = [[ t40, t43 ].max, t42 ].min
+      t40 = cells_i_37 - 1
+      t44 = t40.clamp(0, t42)
       t45 = t35[t44]
       out << t45
     end
     out
   end
 
-  def _shift_left_clamp(input = @input)
+  def self._shift_left_clamp(input)
     out = []
     t46 = input["cells"] || input[:cells]
     t49 = t46.length
-    t50 = -1
-    t52 = 1
-    t54 = 0
-    t53 = t49 - t52
+    t53 = t49 - 1
     t46.each_with_index do |cells_el_47, cells_i_48|
-      t51 = cells_i_48 - t50
-      t55 = [[ t51, t54 ].max, t53 ].min
+      t51 = cells_i_48 - -1
+      t55 = t51.clamp(0, t53)
       t56 = t46[t55]
       out << t56
     end
     out
   end
 
-  def _shift_right_wrap(input = @input)
+  def self._shift_right_wrap(input)
     out = []
     t57 = input["cells"] || input[:cells]
     t60 = t57.length
-    t61 = 1
     t57.each_with_index do |cells_el_58, cells_i_59|
-      t62 = cells_i_59 - t61
+      t62 = cells_i_59 - 1
       t63 = t62 % t60
       t64 = t63 + t60
       t65 = t64 % t60
@@ -120,13 +79,12 @@ module Kumi::Compiled::KUMI_d17fb0388f7014e59c7e9a892d540e54a949f21eb86a9e8e8a39
     out
   end
 
-  def _shift_left_wrap(input = @input)
+  def self._shift_left_wrap(input)
     out = []
     t67 = input["cells"] || input[:cells]
     t70 = t67.length
-    t71 = -1
     t67.each_with_index do |cells_el_68, cells_i_69|
-      t72 = cells_i_69 - t71
+      t72 = cells_i_69 - -1
       t73 = t72 % t70
       t74 = t73 + t70
       t75 = t74 % t70

data/golden/shift_2d/expected/lir_06_const_prop.txt

@@ -2,23 +2,21 @@
   (Declaration shift_cols_right_zero
     %t1 = load_input "rows" :: array
     %t6 = length %t1 :: integer
-    %t12 = const 1 :: integer
-    %t14 = const 0 :: integer
     loop rows id=L1 in %t1 as el=%rows_el_2, idx=%rows_i_3
       %t7 = call core.mod(%rows_i_3, %t6) :: integer
       %t8 = call core.add(%t7, %t6) :: integer
       %t9 = call core.mod(%t8, %t6) :: integer
       %t10 = gather %t1, %t9 :: any
       %t11 = length %t10 :: integer
-      %t19 = call core.sub(%t11, %t12) :: integer
+      %t19 = call core.sub(%t11, 1) :: integer
       loop col id=L2 in %rows_el_2 as el=%col_el_4, idx=%col_i_5
-        %t13 = call core.sub(%col_i_5, %t12) :: integer
-        %t15 = call core.gte(%t13, %t14) :: boolean
+        %t13 = call core.sub(%col_i_5, 1) :: integer
+        %t15 = call core.gte(%t13, 0) :: boolean
         %t16 = call core.lt(%t13, %t11) :: boolean
         %t17 = call core.and(%t15, %t16) :: boolean
-        %t21 = call core.clamp(%t13, %t14, %t19) :: integer
+        %t21 = call core.clamp(%t13, 0, %t19) :: integer
         %t22 = gather %t10, %t21 :: integer
-        %t24 = select %t17, %t22, %t14 :: integer
+        %t24 = select %t17, %t22, 0 :: integer
         yield %t24
       end_loop
     end_loop
@@ -26,18 +24,16 @@
   (Declaration shift_cols_right_clamp
     %t25 = load_input "rows" :: array
     %t30 = length %t25 :: integer
-    %t36 = const 1 :: integer
-    %t40 = const 0 :: integer
     loop rows id=L3 in %t25 as el=%rows_el_26, idx=%rows_i_27
       %t31 = call core.mod(%rows_i_27, %t30) :: integer
       %t32 = call core.add(%t31, %t30) :: integer
       %t33 = call core.mod(%t32, %t30) :: integer
       %t34 = gather %t25, %t33 :: any
       %t35 = length %t34 :: integer
-      %t39 = call core.sub(%t35, %t36) :: integer
+      %t39 = call core.sub(%t35, 1) :: integer
       loop col id=L4 in %rows_el_26 as el=%col_el_28, idx=%col_i_29
-        %t37 = call core.sub(%col_i_29, %t36) :: integer
-        %t41 = call core.clamp(%t37, %t40, %t39) :: integer
+        %t37 = call core.sub(%col_i_29, 1) :: integer
+        %t41 = call core.clamp(%t37, 0, %t39) :: integer
         %t42 = gather %t34, %t41 :: integer
         yield %t42
       end_loop
@@ -46,7 +42,6 @@
   (Declaration shift_cols_right_wrap
     %t43 = load_input "rows" :: array
     %t48 = length %t43 :: integer
-    %t54 = const 1 :: integer
     loop rows id=L5 in %t43 as el=%rows_el_44, idx=%rows_i_45
       %t49 = call core.mod(%rows_i_45, %t48) :: integer
       %t50 = call core.add(%t49, %t48) :: integer
@@ -54,7 +49,7 @@
       %t52 = gather %t43, %t51 :: any
       %t53 = length %t52 :: integer
       loop col id=L6 in %rows_el_44 as el=%col_el_46, idx=%col_i_47
-        %t55 = call core.sub(%col_i_47, %t54) :: integer
+        %t55 = call core.sub(%col_i_47, 1) :: integer
         %t56 = call core.mod(%t55, %t53) :: integer
         %t57 = call core.add(%t56, %t53) :: integer
         %t58 = call core.mod(%t57, %t53) :: integer
@@ -66,24 +61,21 @@
   (Declaration shift_cols_left_zero
     %t60 = load_input "rows" :: array
     %t65 = length %t60 :: integer
-    %t71 = const -1 :: integer
-    %t73 = const 0 :: integer
-    %t77 = const 1 :: integer
     loop rows id=L7 in %t60 as el=%rows_el_61, idx=%rows_i_62
       %t66 = call core.mod(%rows_i_62, %t65) :: integer
       %t67 = call core.add(%t66, %t65) :: integer
       %t68 = call core.mod(%t67, %t65) :: integer
       %t69 = gather %t60, %t68 :: any
       %t70 = length %t69 :: integer
-      %t78 = call core.sub(%t70, %t77) :: integer
+      %t78 = call core.sub(%t70, 1) :: integer
       loop col id=L8 in %rows_el_61 as el=%col_el_63, idx=%col_i_64
-        %t72 = call core.sub(%col_i_64, %t71) :: integer
-        %t74 = call core.gte(%t72, %t73) :: boolean
+        %t72 = call core.sub(%col_i_64, -1) :: integer
+        %t74 = call core.gte(%t72, 0) :: boolean
         %t75 = call core.lt(%t72, %t70) :: boolean
         %t76 = call core.and(%t74, %t75) :: boolean
-        %t80 = call core.clamp(%t72, %t73, %t78) :: integer
+        %t80 = call core.clamp(%t72, 0, %t78) :: integer
         %t81 = gather %t69, %t80 :: integer
-        %t83 = select %t76, %t81, %t73 :: integer
+        %t83 = select %t76, %t81, 0 :: integer
         yield %t83
       end_loop
     end_loop
@@ -91,19 +83,16 @@
   (Declaration shift_cols_left_clamp
     %t84 = load_input "rows" :: array
     %t89 = length %t84 :: integer
-    %t95 = const -1 :: integer
-    %t97 = const 1 :: integer
-    %t99 = const 0 :: integer
     loop rows id=L9 in %t84 as el=%rows_el_85, idx=%rows_i_86
       %t90 = call core.mod(%rows_i_86, %t89) :: integer
       %t91 = call core.add(%t90, %t89) :: integer
       %t92 = call core.mod(%t91, %t89) :: integer
       %t93 = gather %t84, %t92 :: any
       %t94 = length %t93 :: integer
-      %t98 = call core.sub(%t94, %t97) :: integer
+      %t98 = call core.sub(%t94, 1) :: integer
       loop col id=L10 in %rows_el_85 as el=%col_el_87, idx=%col_i_88
-        %t96 = call core.sub(%col_i_88, %t95) :: integer
-        %t100 = call core.clamp(%t96, %t99, %t98) :: integer
+        %t96 = call core.sub(%col_i_88, -1) :: integer
+        %t100 = call core.clamp(%t96, 0, %t98) :: integer
         %t101 = gather %t93, %t100 :: integer
         yield %t101
       end_loop
@@ -112,7 +101,6 @@
   (Declaration shift_cols_left_wrap
     %t102 = load_input "rows" :: array
     %t107 = length %t102 :: integer
-    %t113 = const -1 :: integer
     loop rows id=L11 in %t102 as el=%rows_el_103, idx=%rows_i_104
       %t108 = call core.mod(%rows_i_104, %t107) :: integer
       %t109 = call core.add(%t108, %t107) :: integer
@@ -120,7 +108,7 @@
       %t111 = gather %t102, %t110 :: any
       %t112 = length %t111 :: integer
       loop col id=L12 in %rows_el_103 as el=%col_el_105, idx=%col_i_106
-        %t114 = call core.sub(%col_i_106, %t113) :: integer
+        %t114 = call core.sub(%col_i_106, -1) :: integer
         %t115 = call core.mod(%t114, %t112) :: integer
         %t116 = call core.add(%t115, %t112) :: integer
         %t117 = call core.mod(%t116, %t112) :: integer
@@ -132,14 +120,12 @@
   (Declaration shift_rows_down_zero
     %t119 = load_input "rows" :: array
     %t124 = length %t119 :: integer
-    %t125 = const 1 :: integer
-    %t127 = const 0 :: integer
-    %t132 = call core.sub(%t124, %t125) :: integer
+    %t132 = call core.sub(%t124, 1) :: integer
     loop rows id=L13 in %t119 as el=%rows_el_120, idx=%rows_i_121
-      %t126 = call core.sub(%rows_i_121, %t125) :: integer
-      %t128 = call core.gte(%t126, %t127) :: boolean
+      %t126 = call core.sub(%rows_i_121, 1) :: integer
+      %t128 = call core.gte(%t126, 0) :: boolean
       %t129 = call core.lt(%t126, %t124) :: boolean
-      %t134 = call core.clamp(%t126, %t127, %t132) :: integer
+      %t134 = call core.clamp(%t126, 0, %t132) :: integer
       %t130 = call core.and(%t128, %t129) :: boolean
       %t135 = gather %t119, %t134 :: any
       %t136 = length %t135 :: integer
@@ -148,7 +134,7 @@
         %t138 = call core.add(%t137, %t136) :: integer
         %t139 = call core.mod(%t138, %t136) :: integer
         %t140 = gather %t135, %t139 :: integer
-        %t142 = select %t130, %t140, %t127 :: integer
+        %t142 = select %t130, %t140, 0 :: integer
         yield %t142
       end_loop
     end_loop
@@ -156,12 +142,10 @@
   (Declaration shift_rows_down_clamp
     %t143 = load_input "rows" :: array
     %t148 = length %t143 :: integer
-    %t149 = const 1 :: integer
-    %t153 = const 0 :: integer
-    %t152 = call core.sub(%t148, %t149) :: integer
+    %t152 = call core.sub(%t148, 1) :: integer
     loop rows id=L15 in %t143 as el=%rows_el_144, idx=%rows_i_145
-      %t150 = call core.sub(%rows_i_145, %t149) :: integer
-      %t154 = call core.clamp(%t150, %t153, %t152) :: integer
+      %t150 = call core.sub(%rows_i_145, 1) :: integer
+      %t154 = call core.clamp(%t150, 0, %t152) :: integer
       %t155 = gather %t143, %t154 :: any
       %t156 = length %t155 :: integer
       loop col id=L16 in %rows_el_144 as el=%col_el_146, idx=%col_i_147
@@ -176,9 +160,8 @@
   (Declaration shift_rows_down_wrap
     %t161 = load_input "rows" :: array
     %t166 = length %t161 :: integer
-    %t167 = const 1 :: integer
     loop rows id=L17 in %t161 as el=%rows_el_162, idx=%rows_i_163
-      %t168 = call core.sub(%rows_i_163, %t167) :: integer
+      %t168 = call core.sub(%rows_i_163, 1) :: integer
       %t169 = call core.mod(%t168, %t166) :: integer
       %t170 = call core.add(%t169, %t166) :: integer
       %t171 = call core.mod(%t170, %t166) :: integer
@@ -196,15 +179,12 @@
   (Declaration shift_rows_up_zero
     %t178 = load_input "rows" :: array
     %t183 = length %t178 :: integer
-    %t184 = const -1 :: integer
-    %t186 = const 0 :: integer
-    %t190 = const 1 :: integer
-    %t191 = call core.sub(%t183, %t190) :: integer
+    %t191 = call core.sub(%t183, 1) :: integer
     loop rows id=L19 in %t178 as el=%rows_el_179, idx=%rows_i_180
-      %t185 = call core.sub(%rows_i_180, %t184) :: integer
-      %t187 = call core.gte(%t185, %t186) :: boolean
+      %t185 = call core.sub(%rows_i_180, -1) :: integer
+      %t187 = call core.gte(%t185, 0) :: boolean
       %t188 = call core.lt(%t185, %t183) :: boolean
-      %t193 = call core.clamp(%t185, %t186, %t191) :: integer
+      %t193 = call core.clamp(%t185, 0, %t191) :: integer
       %t189 = call core.and(%t187, %t188) :: boolean
       %t194 = gather %t178, %t193 :: any
       %t195 = length %t194 :: integer
@@ -213,7 +193,7 @@
         %t197 = call core.add(%t196, %t195) :: integer
         %t198 = call core.mod(%t197, %t195) :: integer
         %t199 = gather %t194, %t198 :: integer
-        %t201 = select %t189, %t199, %t186 :: integer
+        %t201 = select %t189, %t199, 0 :: integer
         yield %t201
       end_loop
     end_loop
@@ -221,13 +201,10 @@
   (Declaration shift_rows_up_clamp
     %t202 = load_input "rows" :: array
     %t207 = length %t202 :: integer
-    %t208 = const -1 :: integer
-    %t210 = const 1 :: integer
-    %t212 = const 0 :: integer
-    %t211 = call core.sub(%t207, %t210) :: integer
+    %t211 = call core.sub(%t207, 1) :: integer
     loop rows id=L21 in %t202 as el=%rows_el_203, idx=%rows_i_204
-      %t209 = call core.sub(%rows_i_204, %t208) :: integer
-      %t213 = call core.clamp(%t209, %t212, %t211) :: integer
+      %t209 = call core.sub(%rows_i_204, -1) :: integer
+      %t213 = call core.clamp(%t209, 0, %t211) :: integer
       %t214 = gather %t202, %t213 :: any
       %t215 = length %t214 :: integer
       loop col id=L22 in %rows_el_203 as el=%col_el_205, idx=%col_i_206
@@ -242,9 +219,8 @@
   (Declaration shift_rows_up_wrap
     %t220 = load_input "rows" :: array
     %t225 = length %t220 :: integer
-    %t226 = const -1 :: integer
     loop rows id=L23 in %t220 as el=%rows_el_221, idx=%rows_i_222
-      %t227 = call core.sub(%rows_i_222, %t226) :: integer
+      %t227 = call core.sub(%rows_i_222, -1) :: integer
       %t228 = call core.mod(%t227, %t225) :: integer
       %t229 = call core.add(%t228, %t225) :: integer
       %t230 = call core.mod(%t229, %t225) :: integer