kumi 0.0.18 → 0.0.20

data/golden/roll/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,55 @@
+(LIR
+  (Declaration roll_right
+    %t1 = load_input "cells" :: array
+    loop cells id=L1 in %t1 as el=%cells_el_2, idx=%cells_i_3
+      %t4 = Length %t1 :: integer
+      %t5 = const 1 :: integer
+      %t6 = call core.sub(%cells_i_3, %t5) :: integer
+      %t7 = call core.mod(%t6, %t4) :: integer
+      %t8 = call core.add(%t7, %t4) :: integer
+      %t9 = call core.mod(%t8, %t4) :: integer
+      %t10 = Gather %t1, %t9 :: integer
+      yield %t10
+    end_loop
+  )
+  (Declaration roll_left
+    %t11 = load_input "cells" :: array
+    loop cells id=L2 in %t11 as el=%cells_el_12, idx=%cells_i_13
+      %t14 = Length %t11 :: integer
+      %t15 = const -1 :: integer
+      %t16 = call core.sub(%cells_i_13, %t15) :: integer
+      %t17 = call core.mod(%t16, %t14) :: integer
+      %t18 = call core.add(%t17, %t14) :: integer
+      %t19 = call core.mod(%t18, %t14) :: integer
+      %t20 = Gather %t11, %t19 :: integer
+      yield %t20
+    end_loop
+  )
+  (Declaration roll_right_clamp
+    %t21 = load_input "cells" :: array
+    loop cells id=L3 in %t21 as el=%cells_el_22, idx=%cells_i_23
+      %t24 = Length %t21 :: integer
+      %t25 = const 1 :: integer
+      %t29 = const 0 :: integer
+      %t26 = call core.sub(%cells_i_23, %t25) :: integer
+      %t28 = call core.sub(%t24, %t25) :: integer
+      %t30 = call core.clamp(%t26, %t29, %t28) :: integer
+      %t31 = Gather %t21, %t30 :: integer
+      yield %t31
+    end_loop
+  )
+  (Declaration roll_left_clamp
+    %t32 = load_input "cells" :: array
+    loop cells id=L4 in %t32 as el=%cells_el_33, idx=%cells_i_34
+      %t35 = Length %t32 :: integer
+      %t36 = const -1 :: integer
+      %t38 = const 1 :: integer
+      %t40 = const 0 :: integer
+      %t37 = call core.sub(%cells_i_34, %t36) :: integer
+      %t39 = call core.sub(%t35, %t38) :: integer
+      %t41 = call core.clamp(%t37, %t40, %t39) :: integer
+      %t42 = Gather %t32, %t41 :: integer
+      yield %t42
+    end_loop
+  )
+)

data/golden/roll/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,55 @@
+(LIR
+  (Declaration roll_right
+    %t1 = load_input "cells" :: array
+    %t4 = Length %t1 :: integer
+    %t5 = const 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
+      %t7 = call core.mod(%t6, %t4) :: integer
+      %t8 = call core.add(%t7, %t4) :: integer
+      %t9 = call core.mod(%t8, %t4) :: integer
+      %t10 = Gather %t1, %t9 :: integer
+      yield %t10
+    end_loop
+  )
+  (Declaration roll_left
+    %t11 = load_input "cells" :: array
+    %t14 = Length %t11 :: integer
+    %t15 = const -1 :: integer
+    loop cells id=L2 in %t11 as el=%cells_el_12, idx=%cells_i_13
+      %t16 = call core.sub(%cells_i_13, %t15) :: integer
+      %t17 = call core.mod(%t16, %t14) :: integer
+      %t18 = call core.add(%t17, %t14) :: integer
+      %t19 = call core.mod(%t18, %t14) :: integer
+      %t20 = Gather %t11, %t19 :: integer
+      yield %t20
+    end_loop
+  )
+  (Declaration roll_right_clamp
+    %t21 = load_input "cells" :: array
+    %t24 = Length %t21 :: integer
+    %t25 = const 1 :: integer
+    %t29 = const 0 :: integer
+    %t28 = call core.sub(%t24, %t25) :: integer
+    loop cells id=L3 in %t21 as el=%cells_el_22, idx=%cells_i_23
+      %t26 = call core.sub(%cells_i_23, %t25) :: integer
+      %t30 = call core.clamp(%t26, %t29, %t28) :: integer
+      %t31 = Gather %t21, %t30 :: integer
+      yield %t31
+    end_loop
+  )
+  (Declaration roll_left_clamp
+    %t32 = load_input "cells" :: array
+    %t35 = Length %t32 :: integer
+    %t36 = const -1 :: integer
+    %t38 = const 1 :: integer
+    %t40 = const 0 :: integer
+    %t39 = call core.sub(%t35, %t38) :: integer
+    loop cells id=L4 in %t32 as el=%cells_el_33, idx=%cells_i_34
+      %t37 = call core.sub(%cells_i_34, %t36) :: integer
+      %t41 = call core.clamp(%t37, %t40, %t39) :: integer
+      %t42 = Gather %t32, %t41 :: integer
+      yield %t42
+    end_loop
+  )
+)

data/golden/roll/expected/lir_06_const_prop.txt

@@ -0,0 +1,55 @@
+(LIR
+  (Declaration roll_right
+    %t1 = load_input "cells" :: array
+    %t4 = Length %t1 :: integer
+    %t5 = const 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
+      %t7 = call core.mod(%t6, %t4) :: integer
+      %t8 = call core.add(%t7, %t4) :: integer
+      %t9 = call core.mod(%t8, %t4) :: integer
+      %t10 = Gather %t1, %t9 :: integer
+      yield %t10
+    end_loop
+  )
+  (Declaration roll_left
+    %t11 = load_input "cells" :: array
+    %t14 = Length %t11 :: integer
+    %t15 = const -1 :: integer
+    loop cells id=L2 in %t11 as el=%cells_el_12, idx=%cells_i_13
+      %t16 = call core.sub(%cells_i_13, %t15) :: integer
+      %t17 = call core.mod(%t16, %t14) :: integer
+      %t18 = call core.add(%t17, %t14) :: integer
+      %t19 = call core.mod(%t18, %t14) :: integer
+      %t20 = Gather %t11, %t19 :: integer
+      yield %t20
+    end_loop
+  )
+  (Declaration roll_right_clamp
+    %t21 = load_input "cells" :: array
+    %t24 = Length %t21 :: integer
+    %t25 = const 1 :: integer
+    %t29 = const 0 :: integer
+    %t28 = call core.sub(%t24, %t25) :: integer
+    loop cells id=L3 in %t21 as el=%cells_el_22, idx=%cells_i_23
+      %t26 = call core.sub(%cells_i_23, %t25) :: integer
+      %t30 = call core.clamp(%t26, %t29, %t28) :: integer
+      %t31 = Gather %t21, %t30 :: integer
+      yield %t31
+    end_loop
+  )
+  (Declaration roll_left_clamp
+    %t32 = load_input "cells" :: array
+    %t35 = Length %t32 :: integer
+    %t36 = const -1 :: integer
+    %t38 = const 1 :: integer
+    %t40 = const 0 :: integer
+    %t39 = call core.sub(%t35, %t38) :: integer
+    loop cells id=L4 in %t32 as el=%cells_el_33, idx=%cells_i_34
+      %t37 = call core.sub(%cells_i_34, %t36) :: integer
+      %t41 = call core.clamp(%t37, %t40, %t39) :: integer
+      %t42 = Gather %t32, %t41 :: integer
+      yield %t42
+    end_loop
+  )
+)

data/golden/roll/expected/nast.txt

@@ -0,0 +1,26 @@
+(NAST
+  (VALUE roll_right
+    (Call :roll
+    (InputRef [:cells, :value])
+    (Const 1)
+  )
+  )
+  (VALUE roll_left
+    (Call :roll
+    (InputRef [:cells, :value])
+    (Const -1)
+  )
+  )
+  (VALUE roll_right_clamp
+    (Call :roll
+    (InputRef [:cells, :value])
+    (Const 1)
+  )
+  )
+  (VALUE roll_left_clamp
+    (Call :roll
+    (InputRef [:cells, :value])
+    (Const -1)
+  )
+  )
+)

data/golden/roll/expected/schema_javascript.mjs

@@ -0,0 +1,65 @@
+export function _roll_right(input) {
+  let out = [];
+  let t1 = input["cells"];
+  let t4 = t1.length;
+  const t5 = 1;
+  t1.forEach((cells_el_2, cells_i_3) => {
+    let t6 = cells_i_3 - t5;
+    let t7 = ((t6 % t4) + t4) % t4;
+    let t8 = t7 + t4;
+    let t9 = ((t8 % t4) + t4) % t4;
+    let t10 = t1[t9];
+    out.push(t10);
+  });
+  return out;
+}
+
+export function _roll_left(input) {
+  let out = [];
+  let t11 = input["cells"];
+  let t14 = t11.length;
+  const t15 = -1;
+  t11.forEach((cells_el_12, cells_i_13) => {
+    let t16 = cells_i_13 - t15;
+    let t17 = ((t16 % t14) + t14) % t14;
+    let t18 = t17 + t14;
+    let t19 = ((t18 % t14) + t14) % t14;
+    let t20 = t11[t19];
+    out.push(t20);
+  });
+  return out;
+}
+
+export function _roll_right_clamp(input) {
+  let out = [];
+  let t21 = input["cells"];
+  let t24 = t21.length;
+  const t25 = 1;
+  const t29 = 0;
+  let t28 = t24 - t25;
+  t21.forEach((cells_el_22, cells_i_23) => {
+    let t26 = cells_i_23 - t25;
+    let t30 = Math.min(Math.max(t26, t29), t28);
+    let t31 = t21[t30];
+    out.push(t31);
+  });
+  return out;
+}
+
+export function _roll_left_clamp(input) {
+  let out = [];
+  let t32 = input["cells"];
+  let t35 = t32.length;
+  const t36 = -1;
+  const t38 = 1;
+  const t40 = 0;
+  let t39 = t35 - t38;
+  t32.forEach((cells_el_33, cells_i_34) => {
+    let t37 = cells_i_34 - t36;
+    let t41 = Math.min(Math.max(t37, t40), t39);
+    let t42 = t32[t41];
+    out.push(t42);
+  });
+  return out;
+}
+

data/golden/roll/expected/schema_ruby.rb

@@ -0,0 +1,95 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_5886cf1ff229fe88f8837131fddfca7b705ef9e6f4195008b6854677f947ef6b
+  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 :roll_right then _roll_right
+    when :roll_left then _roll_left
+    when :roll_right_clamp then _roll_right_clamp
+    when :roll_left_clamp then _roll_left_clamp
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _roll_right(input = @input)
+    out = []
+    t1 = input["cells"] || input[:cells]
+    t4 = t1.length
+    t5 = 1
+    t1.each_with_index do |cells_el_2, cells_i_3|
+      t6 = cells_i_3 - t5
+      t7 = t6 % t4
+      t8 = t7 + t4
+      t9 = t8 % t4
+      t10 = t1[t9]
+      out << t10
+    end
+    out
+  end
+
+  def _roll_left(input = @input)
+    out = []
+    t11 = input["cells"] || input[:cells]
+    t14 = t11.length
+    t15 = -1
+    t11.each_with_index do |cells_el_12, cells_i_13|
+      t16 = cells_i_13 - t15
+      t17 = t16 % t14
+      t18 = t17 + t14
+      t19 = t18 % t14
+      t20 = t11[t19]
+      out << t20
+    end
+    out
+  end
+
+  def _roll_right_clamp(input = @input)
+    out = []
+    t21 = input["cells"] || input[:cells]
+    t24 = t21.length
+    t25 = 1
+    t29 = 0
+    t28 = t24 - t25
+    t21.each_with_index do |cells_el_22, cells_i_23|
+      t26 = cells_i_23 - t25
+      t30 = [[ t26, t29 ].max, t28 ].min
+      t31 = t21[t30]
+      out << t31
+    end
+    out
+  end
+
+  def _roll_left_clamp(input = @input)
+    out = []
+    t32 = input["cells"] || input[:cells]
+    t35 = t32.length
+    t36 = -1
+    t38 = 1
+    t40 = 0
+    t39 = t35 - t38
+    t32.each_with_index do |cells_el_33, cells_i_34|
+      t37 = cells_i_34 - t36
+      t41 = [[ t37, t40 ].max, t39 ].min
+      t42 = t32[t41]
+      out << t42
+    end
+    out
+  end
+end

data/golden/roll/expected/snast.txt

@@ -0,0 +1,26 @@
+(SNAST
+  (VALUE roll_right
+    (Call :roll
+      (InputRef cells.value key_chain=[]) :: [cells] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [cells] -> integer
+  ) :: [cells] -> integer
+  (VALUE roll_left
+    (Call :roll
+      (InputRef cells.value key_chain=[]) :: [cells] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [cells] -> integer
+  ) :: [cells] -> integer
+  (VALUE roll_right_clamp
+    (Call :roll
+      (InputRef cells.value key_chain=[]) :: [cells] -> integer
+      (Const 1) :: [] -> integer
+    ) :: [cells] -> integer
+  ) :: [cells] -> integer
+  (VALUE roll_left_clamp
+    (Call :roll
+      (InputRef cells.value key_chain=[]) :: [cells] -> integer
+      (Const -1) :: [] -> integer
+    ) :: [cells] -> integer
+  ) :: [cells] -> integer
+)

data/golden/roll/expected.json

@@ -0,0 +1,6 @@
+{
+  "roll_right":       [4, 1, 2, 3],
+  "roll_left":        [2, 3, 4, 1],
+  "roll_right_clamp": [1, 1, 2, 3],
+  "roll_left_clamp":  [2, 3, 4, 4]
+}

data/golden/roll/input.json

@@ -0,0 +1 @@
+{ "cells": [1, 2, 3, 4] }

data/golden/roll/schema.kumi

@@ -0,0 +1,13 @@
+schema do
+  input do
+    array :cells do
+      integer :value
+    end
+  end
+
+  # ROLL — wrap by default; include clamp variants
+  value :roll_right,         roll(input.cells.value,  1)                       # :wrap
+  value :roll_left,          roll(input.cells.value, -1)                       # :wrap
+  value :roll_right_clamp,   roll(input.cells.value,  1, policy: :clamp)
+  value :roll_left_clamp,    roll(input.cells.value, -1, policy: :clamp)
+end

data/golden/shift/expected/ast.txt

@@ -0,0 +1,48 @@
+(Root
+  inputs: [
+    (InputDeclaration :cells :array
+      [
+        (InputDeclaration :value :integer)
+      ]
+    )
+  ]
+  values: [
+    (ValueDeclaration :shift_right_zero
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal 1)
+      )
+    )
+    (ValueDeclaration :shift_left_zero
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal -1)
+      )
+    )
+    (ValueDeclaration :shift_right_clamp
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal 1)
+      )
+    )
+    (ValueDeclaration :shift_left_clamp
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal -1)
+      )
+    )
+    (ValueDeclaration :shift_right_wrap
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal 1)
+      )
+    )
+    (ValueDeclaration :shift_left_wrap
+      (CallExpression :shift
+        (InputElementReference cells.value)
+        (Literal -1)
+      )
+    )
+  ]
+  traits: []
+)

data/golden/shift/expected/input_plan.txt

@@ -0,0 +1,3 @@
+cells: array (array) access_mode=element
+  └─> value: element_access
+  value: integer

data/golden/shift/expected/lir_00_unoptimized.txt

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

data/golden/shift/expected/lir_01_hoist_scalar_references.txt

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