@zkasm/zkevm-rom 0.0.1-security → 6.0.1

package/main/modexp/array_lib/array_add_short.zkasm

@@ -0,0 +1,85 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; array_add_short:
+;;             in:
+;;                  · C ∈ [1, 32], the len of inA
+;;                  · inA ∈ [0, 2²⁵⁶ - 1]^C, the first input array
+;;                  · inB ∈ [0, 2²⁵⁶ - 1],   the second input
+;;
+;;          output:
+;;                  · out = inA + inB, with len(out) <= C + 1
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; function array_add_short(a: bigint[], b: bigint, base: bigint): bigint[] {
+;     const alen = a.length;
+;     let result = new Array<bigint>(alen);
+;     let sum = 0n;
+;     let carry = b;
+;     for (let i = 0; i < alen; i++) {
+;         sum = a[i] + carry;
+;         carry = sum >= base ? 1n : 0n;
+;         out[i] = sum - carry * base;
+;     }
+
+;     if (carry === 1n) {
+;         result.push(carry);
+;     }
+;     return result;
+; }
+
+VAR GLOBAL array_add_short_inA[%ARRAY_MAX_LEN]
+VAR GLOBAL array_add_short_inB
+VAR GLOBAL array_add_short_out[%ARRAY_MAX_LEN_PLUS_ONE]
+VAR GLOBAL array_add_short_len_inA
+VAR GLOBAL array_add_short_len_out
+
+VAR GLOBAL array_add_short_carry
+
+VAR GLOBAL array_add_short_RR
+
+array_add_short:
+        %MAX_CNT_BINARY - CNT_BINARY     -    C           :JMPN(outOfCountersBinary)
+        %MAX_CNT_STEPS - STEP        - 5 - 10*C - 8       :JMPN(outOfCountersStep)
+
+        RR              :MSTORE(array_add_short_RR)
+
+        C               :MSTORE(array_add_short_len_inA)
+
+        0 => E ; index in loops
+        $ => A          :MLOAD(array_add_short_inB)
+        A               :MSTORE(array_add_short_carry)
+
+array_add_short_loopZero2inA:
+        ; The result will be stored as D·base + C
+
+        0 => D  ; reset the carry chunk
+
+        ; a[i] + carry, where a[i] ∈ [0,base-1]:
+        ;       · If i = 0, then carry = inB and then the number cannot be GT base + (base - 2), two chunks
+        ;       · Otherwise, the number cannot be GT base, two chunks
+        $ => A          :MLOAD(array_add_short_inA + E)
+        $ => B          :MLOAD(array_add_short_carry)
+        $ => C          :ADD, JMPNC(__array_add_short_continue_1)
+        1 => D
+                        __array_add_short_continue_1:
+
+        C               :MSTORE(array_add_short_out + E)
+        D               :MSTORE(array_add_short_carry)
+
+        E + 1 => E,A
+        $ => B          :MLOAD(array_add_short_len_inA)
+        B - A           :JMPZ(array_add_short_check_carry, array_add_short_loopZero2inA)
+
+array_add_short_check_carry:
+        D => A
+        A               :JMPZ(__array_add_short_continue_2)
+        ; In this case, the carry = 1 and we should append it to the result
+        1               :MSTORE(array_add_short_out + E)
+        E + 1           :MSTORE(array_add_short_len_out)
+                        :JMP(array_add_short_end)
+                        __array_add_short_continue_2:
+         E              :MSTORE(array_add_short_len_out)
+
+array_add_short_end:
+        $ => RR         :MLOAD(array_add_short_RR)
+                        :RETURN

package/main/modexp/array_lib/array_div.zkasm

@@ -0,0 +1,215 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;  PRE: The input arrays have been trimmed;
+;; POST: The quotient and remainder are trimmed.
+;;
+;; array_div:
+;;             in:
+;;                  · C ∈ [1, 32], the len of inA
+;;                  · D ∈ [1, 32], the len of inB
+;;                  · inA ∈ [0, 2²⁵⁶ - 1]^C, the first input array
+;;                  · inB ∈ [0, 2²⁵⁶ - 1]^D, the second input array
+;;
+;;          output:
+;;                  · [quo,rem] = [inA / inB, inA % inB], with len(quo) <= C - D + 1, len(rem) <= D
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; function array_div(a: bigint[], b: bigint[], base: bigint): bigint[] {
+;     if (a === [0n]) {
+;         if (b === [0n]) {
+;             throw new Error("Division by zero");
+;         }
+;         return [0n, 0n];
+;     } else if (b === [0n]) {
+;         throw new Error("Division by zero");
+;     }
+;
+;     if (a === b) {
+;         return [1n, 0n];
+;     } else if (a < b) {
+;         return [0n, a];
+;     }
+;
+;     if (b.length === 1) {
+;         return array_div_short(a, b, base);
+;     }
+;     return array_div_long(a, b, base);
+; }
+
+VAR GLOBAL array_div_inA[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_inB[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_quo[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_rem[%ARRAY_MAX_LEN]
+
+VAR GLOBAL array_div_len_inA
+VAR GLOBAL array_div_len_inB
+VAR GLOBAL array_div_len_quo
+VAR GLOBAL array_div_len_rem
+
+VAR GLOBAL array_div_RR
+
+; ERROR CODES (B)
+; 0 - no error
+; 1 - inB is zero
+
+array_div:
+        %MAX_CNT_BINARY - CNT_BINARY - 2                    :JMPN(outOfCountersBinary)
+        %MAX_CNT_STEPS - STEP        - 12 - 3*C - 3*D - 1   :JMPN(outOfCountersStep)
+
+        RR              :MSTORE(array_div_RR)
+
+        C               :MSTORE(array_div_len_inA)
+        D               :MSTORE(array_div_len_inB)
+
+        ; Let's cover the edge cases
+        1 => B
+        ; 1] Is C == 1 and inA == 0?
+        C - B           :JMPNZ(__array_div_inA_continue)
+        $ => A          :MLOAD(array_div_inA)
+        $               :LT, JMPC(array_div_inA_is_zero)
+                        __array_div_inA_continue:
+
+        ; 2] Is D == 1 and inB == 0?
+        D - B           :JMPNZ(__array_div_inB_continue_1)
+        $ => A          :MLOAD(array_div_inB)
+        $               :LT, JMPC(array_div_inB_is_zero)
+                        __array_div_inB_continue_1:
+
+        ; 3] Check if inA = inB or inA < inB
+        C - 1 => RR
+        D - 1 => E
+array_div_compare_inA:
+        $ => A          :MLOAD(array_div_inA + RR)
+        A               :MSTORE(array_compare_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_compare_inB, array_div_compare_inA)
+
+array_div_compare_inB:
+        $ => A          :MLOAD(array_div_inB + E)
+        A               :MSTORE(array_compare_inB + E)
+        E - 1 => E      :JMPN(array_div_compare, array_div_compare_inB)
+
+array_div_compare:
+                        :CALL(array_compare)
+
+        %MAX_CNT_STEPS - STEP        - 5 - 3*C - 3*D - 1  :JMPN(outOfCountersStep)
+
+        $ => A          :MLOAD(array_compare_result), JMPZ(array_div_prep_inALTinB)
+        A - 1           :JMPZ(array_div_same_input)
+        ; From here, inA > inB
+
+        C - 1 => RR
+        D - 1 => E
+        D - 1           :JMPZ(array_div_inA_to_div_short, array_div_inA_to_div_long); worst case is div long
+
+; Begin of edge cases
+array_div_inA_is_zero:
+        ;Is D == 1 and inB == 0? 0/0 is undefined
+        D - B           :JMPNZ(__array_div_inB_continue_2)
+        $ => A          :MLOAD(array_div_inB)
+        $               :LT, JMPC(array_div_inB_is_zero)
+                        __array_div_inB_continue_2:
+        ; From here, inB != 0
+
+        ; Return [q,r] = [0,0] and len(q) = 1, len(r) = 1
+        0               :MSTORE(array_div_quo)
+        0               :MSTORE(array_div_rem)
+        1               :MSTORE(array_div_len_quo)
+        1               :MSTORE(array_div_len_rem)
+        0 => B          :JMP(array_div_end)
+
+array_div_inB_is_zero:
+        ; Error, you cannot divide by 0
+        1 => B          :JMP(array_div_end)
+
+array_div_same_input:
+        1               :MSTORE(array_div_quo)
+        0               :MSTORE(array_div_rem)
+        1               :MSTORE(array_div_len_quo)
+        1               :MSTORE(array_div_len_rem)
+        0 => B          :JMP(array_div_end)
+
+array_div_prep_inALTinB:
+        C               :MSTORE(array_div_len_rem)
+        1               :MSTORE(array_div_len_quo)
+
+        %MAX_CNT_STEPS - STEP  - 1 - 4*C - 2        :JMPN(outOfCountersStep)
+
+        C - 1 => RR
+array_div_inALTinB:
+        $ => A          :MLOAD(array_div_inA + RR)
+        A               :MSTORE(array_div_rem + RR)
+        RR - 1 => RR    :JMPN(array_div_inALTinB_before_end, array_div_inALTinB)
+
+array_div_inALTinB_before_end:
+        0               :MSTORE(array_div_quo)
+        0 => B          :JMP(array_div_end)
+; End of edge cases
+
+; Long
+array_div_inA_to_div_long:
+        $ => A          :MLOAD(array_div_inA + RR)
+        A               :MSTORE(array_div_long_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_inB_to_div_long, array_div_inA_to_div_long)
+
+array_div_inB_to_div_long:
+        $ => A          :MLOAD(array_div_inB + E)
+        A               :MSTORE(array_div_long_inB + E)
+        E - 1 => E      :JMPN(array_div_compute_long, array_div_inB_to_div_long)
+
+array_div_compute_long:
+                        :CALL(array_div_long)
+
+        %MAX_CNT_STEPS - STEP - 7      :JMPN(outOfCountersStep)
+
+        $ => C          :MLOAD(array_div_long_len_quo)
+        $ => D          :MLOAD(array_div_long_len_rem)
+        C               :MSTORE(array_div_len_quo)
+        D               :MSTORE(array_div_len_rem)
+        C - 1 => RR
+        D - 1 => E
+
+        %MAX_CNT_STEPS - STEP - 3*C - 3*D - 2  :JMPN(outOfCountersStep)
+
+array_div_assign_long_quo:
+        $ => A          :MLOAD(array_div_long_quo + RR)
+        A               :MSTORE(array_div_quo + RR)
+        RR - 1 => RR    :JMPN(array_div_assign_long_rem, array_div_assign_long_quo)
+
+array_div_assign_long_rem:
+        $ => A          :MLOAD(array_div_long_rem + E)
+        A               :MSTORE(array_div_rem + E)
+        E - 1 => E      :JMPN(array_div_end, array_div_assign_long_rem)
+
+; Short
+array_div_inA_to_div_short:
+        $ => A          :MLOAD(array_div_inA + RR)
+        A               :MSTORE(array_div_short_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_inB_to_div_short, array_div_inA_to_div_short)
+
+array_div_inB_to_div_short:
+        $ => A          :MLOAD(array_div_inB)
+        A               :MSTORE(array_div_short_inB)
+
+array_div_compute_short:
+                        :CALL(array_div_short)
+
+        %MAX_CNT_STEPS - STEP - 5      :JMPN(outOfCountersStep)
+
+        $ => C          :MLOAD(array_div_short_len_quo)
+        C               :MSTORE(array_div_len_quo)
+        1               :MSTORE(array_div_len_rem)
+        C - 1 => RR
+
+        %MAX_CNT_STEPS - STEP - 3*C - 4  :JMPN(outOfCountersStep)
+
+array_div_assign_short_quo:
+        $ => A          :MLOAD(array_div_short_quo + RR)
+        A               :MSTORE(array_div_quo + RR)
+        RR - 1 => RR    :JMPN(array_div_assign_short_rem, array_div_assign_short_quo)
+
+array_div_assign_short_rem:
+        $ => A          :MLOAD(array_div_short_rem)
+        A               :MSTORE(array_div_rem)
+
+array_div_end:
+        $ => RR         :MLOAD(array_div_RR)
+                        :RETURN

package/main/modexp/array_lib/array_div_long.zkasm

@@ -0,0 +1,284 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;  PRE: The input arrays have been trimmed.
+;; POST: The quotient and remainder are trimmed.
+;;
+;; array_div_long:
+;;             in:
+;;                  · C ∈ [1, 32], the len of inA
+;;                  · D ∈ [1, 32], the len of inB
+;;                  · inA ∈ [0, 2²⁵⁶ - 1]^C, the first input array
+;;                  · inB ∈ [0, 2²⁵⁶ - 1]^D, the second input array
+;;
+;;          output:
+;;                  · [quo,rem] = [inA / inB, inA % inB], with len(quo) <= C - D + 1, len(rem) <= D
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; function array_div_long(a: bigint[], b: bigint[], base: bigint): bigint[] {
+;     if (a === [0n]) {
+;         if (b === [0n]) {
+;             throw new Error("Division by zero");
+;         }
+;         return [0n, 0n];
+;     } else if (b === [0n]) {
+;         throw new Error("Division by zero");
+;     }
+;
+;     if (a === b) {
+;         return [1n, 0n];
+;     } else if (a < b) {
+;         return [0n, a];
+;     }
+; }
+
+; NOTE: This function receives the actual result from the helper (avoiding the need of computing divisions);
+;       checks the correctness of the result and returns the result to the caller
+
+VAR GLOBAL array_div_long_inA[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_long_inB[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_long_quo[%ARRAY_MAX_LEN]
+VAR GLOBAL array_div_long_rem[%ARRAY_MAX_LEN]
+
+VAR GLOBAL array_div_long_len_inA
+VAR GLOBAL array_div_long_len_inB
+VAR GLOBAL array_div_long_len_quo
+VAR GLOBAL array_div_long_len_rem
+
+VAR GLOBAL array_div_long_RR
+
+; ERROR CODES (B)
+; 0 - no error
+; 1 - inB is zero
+
+array_div_long:
+        %MAX_CNT_BINARY - CNT_BINARY - 2                  :JMPN(outOfCountersBinary)
+        %MAX_CNT_STEPS - STEP        - 12 - 3*C - 3*D - 1 :JMPN(outOfCountersStep)
+
+        RR              :MSTORE(array_div_long_RR)
+
+        C               :MSTORE(array_div_long_len_inA)
+        D               :MSTORE(array_div_long_len_inB)
+
+        ; Let's cover the edge cases
+        1 => B
+        ; 1] Is C == 1 and inA == 0?
+        C - B           :JMPNZ(__array_div_long_inA_continue)
+        $ => A          :MLOAD(array_div_long_inA)
+        $               :LT, JMPC(array_div_long_inA_is_zero)
+                        __array_div_long_inA_continue:
+
+        ; 2] Is D == 1 and inB == 0?
+        D - B           :JMPNZ(__array_div_long_inB_continue_1)
+        $ => A          :MLOAD(array_div_long_inB)
+        $               :LT, JMPC(array_div_long_inB_is_zero)
+                        __array_div_long_inB_continue_1:
+
+        ; 3] Check if inA = inB or inA < inB
+        C - 1 => RR
+        D - 1 => E
+array_div_long_compare_inA1:
+        $ => A          :MLOAD(array_div_long_inA + RR)
+        A               :MSTORE(array_compare_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_compare_inB1, array_div_long_compare_inA1)
+
+array_div_long_compare_inB1:
+        $ => A          :MLOAD(array_div_long_inB + E)
+        A               :MSTORE(array_compare_inB + E)
+        E - 1 => E      :JMPN(array_div_long_compare1, array_div_long_compare_inB1)
+
+array_div_long_compare1:
+                        :CALL(array_compare)
+
+        %MAX_CNT_BINARY - CNT_BINARY - 1                                        :JMPN(outOfCountersBinary)
+        %MAX_CNT_STEPS - STEP        - 12 - 4*%ARRAY_MAX_LEN - 3*D - 1    :JMPN(outOfCountersStep)
+
+        $ => A          :MLOAD(array_compare_result), JMPZ(array_div_long_prep_inALTinB)
+        A - 1           :JMPZ(array_div_long_same_input)
+        ; From here, inA > inB
+
+        ; Strategy: Divide outside and check the result inside
+        $${MPdiv(addr.array_div_long_inA,mem.array_div_long_len_inA,addr.array_div_long_inB,mem.array_div_long_len_inB)}
+
+                        :JMP(array_div_long_prepare_mul_quo_inB)
+
+; Begin of edge cases
+array_div_long_inA_is_zero:
+        ; Is D == 1 and inB == 0? 0/0 is undefined
+        D - B           :JMPNZ(__array_div_long_inB_continue_2)
+        $ => A          :MLOAD(array_div_long_inB)
+        $               :LT, JMPC(array_div_long_inB_is_zero)
+                        __array_div_long_inB_continue_2:
+        ; From here, inA == 0 and inB != 0
+
+        ; Return [q,r] = [0,0] and len(q) = 1, len(r) = 1
+        0               :MSTORE(array_div_long_quo)
+        0               :MSTORE(array_div_long_rem)
+        1               :MSTORE(array_div_long_len_quo)
+        1               :MSTORE(array_div_long_len_rem)
+        0 => B          :JMP(array_div_long_end)
+
+array_div_long_inB_is_zero:
+        ; Error, you cannot divide by 0
+        1 => B          :JMP(array_div_long_end)
+
+array_div_long_same_input:
+        ; if inA = inB, then return [1, 0] and len(q) = 1, len(r) = 1
+        1               :MSTORE(array_div_long_quo)
+        0               :MSTORE(array_div_long_rem)
+        1               :MSTORE(array_div_long_len_quo)
+        1               :MSTORE(array_div_long_len_rem)
+        0 => B          :JMP(array_div_long_end)
+
+array_div_long_prep_inALTinB:
+        ; if inA < inB, then return [0, inA] and len(q) = 1, len(r) = C
+        1               :MSTORE(array_div_long_len_quo)
+        C               :MSTORE(array_div_long_len_rem)
+
+        %MAX_CNT_STEPS - STEP  - 1 - 3*C - 2        :JMPN(outOfCountersStep)
+
+        C - 1 => RR
+array_div_long_inALTinB:
+        $ => A          :MLOAD(array_div_long_inA + RR)
+        A               :MSTORE(array_div_long_rem + RR)
+        RR - 1 => RR    :JMPN(array_div_long_inALTinB_before_end, array_div_long_inALTinB)
+
+array_div_long_inALTinB_before_end:
+        0               :MSTORE(array_div_long_quo)
+        0 => B          :JMP(array_div_long_end)
+; End of edge cases
+
+array_div_long_prepare_mul_quo_inB:
+        $0{receiveLenQuotient()} => C
+
+        ; The received length must be between 1 and %ARRAY_MAX_LEN
+        C - 1 => RR             :JMPN(failAssert) ; If C = 0, then fail
+        %ARRAY_MAX_LEN - C      :JMPN(failAssert) ; If C > %ARRAY_MAX_LEN, then fail
+        ; From here, 1 <= C <= %ARRAY_MAX_LEN
+
+        ; To avoid non-determinism, we must ensure that the quotient is trimmed
+        ; i.e., that its last chunk is not 0
+        ${receiveQuotientChunk(RR)} => A
+        0 => B
+        0               :EQ
+        ; From here, the quotient is trimmed
+
+        C               :MSTORE(array_div_long_len_quo)
+        $ => D          :MLOAD(array_div_long_len_inB)
+        C - 1 => RR
+        D - 1 => E
+
+        ; save the first non-zero chunk of quo
+        A               :MSTORE(array_div_long_quo + RR)
+        A               :MSTORE(array_mul_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_inB_to_mul)
+
+array_div_long_quo_to_mul:
+        ${receiveQuotientChunk(RR)} => A
+        A               :MSTORE(array_div_long_quo + RR)
+        A               :MSTORE(array_mul_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_inB_to_mul, array_div_long_quo_to_mul)
+
+array_div_long_inB_to_mul:
+        $ => A          :MLOAD(array_div_long_inB + E)
+        A               :MSTORE(array_mul_inB + E)
+        E - 1 => E      :JMPN(array_div_long_mul_quo_inB, array_div_long_inB_to_mul)
+
+array_div_long_mul_quo_inB:
+                        :CALL(array_mul)
+
+        $ => D          :MLOAD(array_div_long_len_inB)
+        %MAX_CNT_BINARY - CNT_BINARY - 1                                        :JMPN(outOfCountersBinary)
+        %MAX_CNT_STEPS - STEP        - 8 - 3*%ARRAY_MAX_LEN - 3*D - 1           :JMPN(outOfCountersStep)
+
+        ; Check the remainder
+        $0{receiveLenRemainder()} => D
+
+        ; 1] The received length must be between 1 and %ARRAY_MAX_LEN
+        D - 1 => E              :JMPN(failAssert) ; If D = 0, then fail
+        %ARRAY_MAX_LEN - D      :JMPN(failAssert) ; If D > %ARRAY_MAX_LEN, then fail
+        ; From here, 1 <= D <= %ARRAY_MAX_LEN
+
+        ; 2] To avoid non-determinism, we must ensure that the remainder is trimmed
+        ; i.e., that its last chunk is not 0
+        ${receiveRemainderChunk(E)} => A
+        0 => B
+        0               :EQ
+        ; From here, the remainder is trimmed
+
+        ; 3] Finally, we must ensure that the remainder is lower than inB
+        $ => C           :MLOAD(array_div_long_len_inB)
+        C - 1 => RR
+        D - 1 => E
+
+        ; save the first non-zero chunk of rem
+        A               :MSTORE(array_compare_inB + E)
+        E - 1 => E      :JMPN(array_div_long_compare_inB2)
+
+array_div_long_compare_rem:
+        ${receiveRemainderChunk(E)} => A
+        A               :MSTORE(array_compare_inB + E)
+        E - 1 => E      :JMPN(array_div_long_compare_inB2, array_div_long_compare_rem)
+
+array_div_long_compare_inB2:
+        $ => A          :MLOAD(array_div_long_inB + RR)
+        A               :MSTORE(array_compare_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_compare2, array_div_long_compare_inB2)
+
+array_div_long_compare2:
+                        :CALL(array_compare)
+
+        %MAX_CNT_STEPS - STEP - 5 - 3*%ARRAY_MAX_LEN - 4*%ARRAY_MAX_LEN - 1        :JMPN(outOfCountersStep)
+
+        2               :MLOAD(array_compare_result)
+
+        D               :MSTORE(array_div_long_len_rem)
+
+        ; prepare output and remainder to be added
+        $ => C          :MLOAD(array_mul_len_out)
+        C - 1 => RR
+        D - 1 => E
+
+array_div_long_res_to_add:
+        $ => A          :MLOAD(array_mul_out + RR)
+        A               :MSTORE(array_add_AGTB_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_rem_to_add, array_div_long_res_to_add)
+
+array_div_long_rem_to_add:
+        $ => A          :MLOAD(array_compare_inB + E) ; Load the remainder used in the comparison
+        A               :MSTORE(array_div_long_rem + E)
+        A               :MSTORE(array_add_AGTB_inB + E)
+        E - 1 => E      :JMPN(array_div_long_add_res_rem, array_div_long_rem_to_add)
+
+array_div_long_add_res_rem:
+                        :CALL(array_add_AGTB)
+
+        %MAX_CNT_STEPS - STEP - 5      :JMPN(outOfCountersStep)
+
+        ; prepare next
+        $ => C           :MLOAD(array_add_AGTB_len_out)
+        $ => D           :MLOAD(array_div_long_len_inA)
+        C - 1 => RR
+        D - 1 => E
+
+        %MAX_CNT_STEPS - STEP - 3*%ARRAY_MAX_LEN - 3*D - 1    :JMPN(outOfCountersStep)
+
+array_div_long_compare_inA2:
+        $ => A          :MLOAD(array_add_AGTB_out + RR)
+        A               :MSTORE(array_compare_inA + RR)
+        RR - 1 => RR    :JMPN(array_div_long_compare_inB3, array_div_long_compare_inA2)
+
+array_div_long_compare_inB3:
+        $ => A          :MLOAD(array_div_long_inA + E)
+        A               :MSTORE(array_compare_inB + E)
+        E - 1 => E      :JMPN(array_div_long_compare3, array_div_long_compare_inB3)
+
+array_div_long_compare3:
+                        :CALL(array_compare)
+
+        %MAX_CNT_STEPS - STEP - 4      :JMPN(outOfCountersStep)
+
+        1               :MLOAD(array_compare_result)
+        0 => B
+
+array_div_long_end:
+        $ => RR         :MLOAD(array_div_long_RR)
+                        :RETURN