Problem 752

Powers of 1 + sqrt(7). Pure Flow port of the native C solver.

Answer	`5610899769745488`
Output	`5610899769745488`
Status	PASS
Native helper	no
Runtime	130 ms
Peak memory	22720 KB
Time complexity	`O(n^2)` (estimated)
Space complexity	`O(n^2)` (estimated)

Performance comparison

Metric	Our solution	Best known
Time complexity	`O(n^2)`	`?`
Space complexity	`O(n^2)`	`?`
Approach	Flow solution	Not curated
Verdict	Unknown

Flow source

# Project Euler 752
# Powers of 1 + sqrt(7).
# Pure Flow port of the native C solver.

extern {
    function calloc(n: i64, size: i64) -> ptr<void>
    function free(p: ptr<void>) -> void
    function memset(s: ptr<void>, c: i64, n: i64) -> ptr<void>
}

let mut spf: ptr<i32> = null
let mut primes: ptr<i32> = null
let mut nprimes: i32 = 0
let mut orders: ptr<i64> = null

function smallest_prime_factors(limit: i32) -> void {
    spf = calloc((limit + 1) as i64, 4) as ptr<i32>
    primes = calloc((limit / 2 + 100) as i64, 4) as ptr<i32>
    nprimes = 0

    let mut i: i32 = 2
    while i <= limit {
        if spf[i] == 0 {
            spf[i] = i
            primes[nprimes] = i
            nprimes = nprimes + 1
        }
        let mut j: i32 = 0
        while j < nprimes {
            let p: i32 = primes[j]
            let val: i64 = (i as i64) * (p as i64)
            if val > (limit as i64) { break }
            if p > spf[i] { break }
            spf[val as i32] = p
            j = j + 1
        }
        i = i + 1
    }
}

function unique_prime_factors(n0: i32, out: ptr<i32>) -> i32 {
    let mut n: i32 = n0
    let mut cnt: i32 = 0
    while n > 1 {
        let p: i32 = spf[n]
        out[cnt] = p
        cnt = cnt + 1
        while n % p == 0 {
            n = n / p
        }
    }
    return cnt
}

# (1 + sqrt(7))^exponent mod modulus, returns (a, b) via out-params.
function quadratic_power(exponent0: i64, modulus: i64, ra: ptr<i64>, rb: ptr<i64>) -> void {
    let mut res_a: i64 = 1
    let mut res_b: i64 = 0
    let mut base_a: i64 = 1
    let mut base_b: i64 = 1
    let mut exponent: i64 = exponent0

    while exponent != 0 {
        if exponent % 2 == 1 {
            let na: i64 = (base_a * res_a + 7 * base_b * res_b) % modulus
            let nb: i64 = (base_a * res_b + base_b * res_a) % modulus
            res_a = na
            res_b = nb
        }
        let na2: i64 = (base_a * base_a + 7 * base_b * base_b) % modulus
        let nb2: i64 = (2 * base_a * base_b) % modulus
        base_a = na2
        base_b = nb2
        exponent = exponent / 2
    }
    ra[0] = res_a
    rb[0] = res_b
}

function llgcd(a0: i64, b0: i64) -> i64 {
    let mut a: i64 = a0
    let mut b: i64 = b0
    while b != 0 {
        let t: i64 = a % b
        a = b
        b = t
    }
    return a
}

function powmod(base0: i64, exp0: i64, mod: i64) -> i64 {
    let mut r: i64 = 1 % mod
    let mut base: i64 = base0 % mod
    let mut exp: i64 = exp0
    while exp != 0 {
        if exp % 2 == 1 {
            r = r * base % mod
        }
        base = base * base % mod
        exp = exp / 2
    }
    return r
}

function prime_order(p: i32) -> i64 {
    if p == 7 { return 7 }

    let factors: array<i32, 128> = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    let extra: array<i32, 128> = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    let mut nf: i32 = 0
    let mut order: i64 = 0

    if powmod(7, ((p - 1) / 2) as i64, p as i64) == 1 {
        order = (p - 1) as i64
        nf = unique_prime_factors(p - 1, &factors[0])
    } else {
        order = (p - 1) as i64 * (p + 1) as i64
        nf = unique_prime_factors(p - 1, &factors[0])
        let ne: i32 = unique_prime_factors(p + 1, &extra[0])
        let mut i: i32 = 0
        while i < ne {
            factors[nf] = extra[i]
            nf = nf + 1
            i = i + 1
        }
    }

    # deduplicate factors
    let mut i: i32 = 0
    while i < nf {
        let mut j: i32 = i + 1
        while j < nf {
            if factors[i] == factors[j] {
                factors[j] = factors[nf - 1]
                nf = nf - 1
                j = j - 1
            }
            j = j + 1
        }
        i = i + 1
    }

    let ra_buf: array<i64, 1> = [0]
    let rb_buf: array<i64, 1> = [0]

    let mut i2: i32 = 0
    while i2 < nf {
        let q: i64 = factors[i2] as i64
        while order % q == 0 {
            quadratic_power(order / q, p as i64, &ra_buf[0], &rb_buf[0])
            if ra_buf[0] == 1 && rb_buf[0] == 0 {
                order = order / q
            } else {
                break
            }
        }
        i2 = i2 + 1
    }
    return order
}

function build_prime_power_orders(limit: i32) -> void {
    orders = calloc((limit + 1) as i64, 8) as ptr<i64>

    let ra_buf: array<i64, 1> = [0]
    let rb_buf: array<i64, 1> = [0]

    let mut pi: i32 = 0
    while pi < nprimes {
        let p: i32 = primes[pi]
        if p > limit { break }
        if p < 5 {
            pi = pi + 1
            continue
        }

        let order: i64 = prime_order(p)
        let mut pp: i64 = p as i64
        let mut lifted: i64 = order
        orders[pp as i32] = lifted

        while pp * (p as i64) <= (limit as i64) {
            pp = pp * (p as i64)
            quadratic_power(lifted, pp, &ra_buf[0], &rb_buf[0])
            if !(ra_buf[0] == 1 && rb_buf[0] == 0) {
                lifted = lifted * (p as i64)
            }
            orders[pp as i32] = lifted
        }
        pi = pi + 1
    }
}

function G(limit: i32) -> i64 {
    smallest_prime_factors(limit + 1)
    build_prime_power_orders(limit)

    let values: ptr<i64> = calloc((limit + 1) as i64, 8) as ptr<i64>
    let mut total: i64 = 0

    let mut n: i32 = 2
    while n <= limit {
        if n % 2 == 0 || n % 3 == 0 {
            n = n + 1
            continue
        }

        let p: i32 = spf[n]
        let mut remaining: i32 = n
        let mut pp: i64 = 1
        while remaining % p == 0 {
            remaining = remaining / p
            pp = pp * (p as i64)
        }

        let prev: i64 = 0
        if remaining > 1 {
            prev = values[remaining]
        } else {
            prev = 1
        }
        let comp: i64 = orders[pp as i32]
        let g: i64 = llgcd(prev, comp)
        let val: i64 = prev / g * comp
        values[n] = val
        total = total + val
        n = n + 1
    }

    free(values as ptr<void>)
    return total
}

function main() -> i32 {
    printf("%lld\n", G(1000000))
    return 0
}

Generated C

#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Flow runtime helpers */
typedef struct flow_temp_node { struct flow_temp_node* next; } flow_temp_node;
static flow_temp_node* flow_temp_head = NULL;
static int flow_temp_atexit_set = 0;
__attribute__((unused)) static void flow_temp_free_all(void) {
    while (flow_temp_head) {
        flow_temp_node* n = flow_temp_head;
        flow_temp_head = n->next;
        free(n);
    }
}
__attribute__((unused)) static void* flow_temp_alloc(size_t nbytes) {
    flow_temp_node* node = (flow_temp_node*)malloc(sizeof(flow_temp_node) + nbytes);
    if (!node) return NULL;
    node->next = flow_temp_head;
    flow_temp_head = node;
    if (!flow_temp_atexit_set) {
        flow_temp_atexit_set = 1;
        atexit(flow_temp_free_all);
    }
    return (void*)(node + 1);
}
#ifndef FLOW_DIAG
#define FLOW_DIAG(msg) fprintf(stderr, "%s", (msg))
#endif
#ifndef FLOW_LOG
#define FLOW_LOG(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
#ifndef FLOW_LOG_EMPTY
#define FLOW_LOG_EMPTY(fmt) printf(fmt)
#endif
static char* flow_strcat(const char* a, const char* b) {
    size_t la = strlen(a ? a : ""), lb = strlen(b ? b : "");
    char* r = (char*)flow_temp_alloc(la + lb + 1);
    if (!r) return NULL;
    if (la) memcpy(r, a, la);
    if (lb) memcpy(r + la, b, lb);
    r[la + lb] = '\0';
    return r;
}

#define __flow_in_arr(arr, val) __extension__ ({ \
    int _found = 0; \
    size_t _n = sizeof(arr)/sizeof((arr)[0]); \
    for (size_t _i = 0; _i < _n; _i++) { \
        if ((arr)[_i] == (val)) { _found = 1; break; } \
    } _found; })

/* Unified fault handler (MISRA #279) — override with -DFLOW_FAULT_HANDLER=fn */
#ifndef FLOW_FAULT_HANDLER
__attribute__((unused)) static inline void flow_fault_handler(const char* msg) {
    fprintf(stderr, "flow: %s\n", msg ? msg : "fault");
    abort();
#if defined(__GNUC__) || defined(__clang__)
    __builtin_unreachable();
#endif
}
#else
#define flow_fault_handler FLOW_FAULT_HANDLER
#endif
#define flow_div_by_zero_handler() flow_fault_handler("division by zero")
#define flow_shift_ub_handler() flow_fault_handler("invalid shift (amount out of range or left-shift of negative)")

#ifndef FLOW_CHECKED_DIV
#define FLOW_CHECKED_DIV(L, R) (((R) != 0) ? ((L) / (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_MOD
#define FLOW_CHECKED_MOD(L, R) (((R) != 0) ? ((L) % (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHL
#define FLOW_CHECKED_SHL(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull)) && ((L) >= 0)) ? ((L) << (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHR
#define FLOW_CHECKED_SHR(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull))) ? ((L) >> (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif

#include <math.h>

void* _ui_state = NULL;

static inline float i32_to_f32(int32_t v) { return (float)v; }

/* Host stub for @gpu kernels (device codegen replaces this). */
static inline int32_t gpu_thread_id(void) { return 0; }

void smallest_prime_factors_i32(int32_t limit);
int32_t unique_prime_factors_i32_ptr_i32(int32_t n0, int32_t* out);
void quadratic_power_i64_i64_ptr_i64_ptr_i64(int64_t exponent0, int64_t modulus, int64_t* ra, int64_t* rb);
int64_t llgcd_i64_i64(int64_t a0, int64_t b0);
int64_t powmod_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod);
int64_t prime_order_i32(int32_t p);
void build_prime_power_orders_i32(int32_t limit);
int64_t G_i32(int32_t limit);
int32_t main(void);

/* Module statics */
static int32_t* spf = NULL;
static int32_t* primes = NULL;
static int32_t nprimes = 0;
static int64_t* orders = NULL;




void smallest_prime_factors_i32(int32_t limit) {
    spf = ((int32_t*)(calloc(((int64_t)((limit + 1))), 4)));
    primes = ((int32_t*)(calloc(((int64_t)((FLOW_CHECKED_DIV((limit), (2)) + 100))), 4)));
    nprimes = 0;
    int32_t i = 2;
    while (i <= limit) {
        if (spf[i] == 0) {
            spf[i] = i;
            primes[nprimes] = i;
            nprimes = (nprimes + 1);
        }
        int32_t j = 0;
        while (j < nprimes) {
            int32_t p = primes[j];
            int64_t val = (((int64_t)(i)) * ((int64_t)(p)));
            if (val > ((int64_t)(limit))) {
                break;
            }
            if (p > spf[i]) {
                break;
            }
            spf[((int32_t)(val))] = p;
            j = (j + 1);
        }
        i = (i + 1);
    }
}

int32_t unique_prime_factors_i32_ptr_i32(int32_t n0, int32_t* out) {
    int32_t n = n0;
    int32_t cnt = 0;
    while (n > 1) {
        int32_t p = spf[n];
        out[cnt] = p;
        cnt = (cnt + 1);
        while (FLOW_CHECKED_MOD((n), (p)) == 0) {
            n = FLOW_CHECKED_DIV((n), (p));
        }
    }
    return cnt;
}

void quadratic_power_i64_i64_ptr_i64_ptr_i64(int64_t exponent0, int64_t modulus, int64_t* ra, int64_t* rb) {
    int64_t res_a = 1;
    int64_t res_b = 0;
    int64_t base_a = 1;
    int64_t base_b = 1;
    int64_t exponent = exponent0;
    while (exponent != 0) {
        if (FLOW_CHECKED_MOD((exponent), (2)) == 1) {
            int64_t na = FLOW_CHECKED_MOD((((base_a * res_a) + ((7 * base_b) * res_b))), (modulus));
            int64_t nb = FLOW_CHECKED_MOD((((base_a * res_b) + (base_b * res_a))), (modulus));
            res_a = na;
            res_b = nb;
        }
        int64_t na2 = FLOW_CHECKED_MOD((((base_a * base_a) + ((7 * base_b) * base_b))), (modulus));
        int64_t nb2 = FLOW_CHECKED_MOD((((2 * base_a) * base_b)), (modulus));
        base_a = na2;
        base_b = nb2;
        exponent = FLOW_CHECKED_DIV((exponent), (2));
    }
    ra[0] = res_a;
    rb[0] = res_b;
}

int64_t llgcd_i64_i64(int64_t a0, int64_t b0) {
    int64_t a = a0;
    int64_t b = b0;
    while (b != 0) {
        int64_t t = FLOW_CHECKED_MOD((a), (b));
        a = b;
        b = t;
    }
    return a;
}

int64_t powmod_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod) {
    int64_t r = FLOW_CHECKED_MOD((1), (mod));
    int64_t base = FLOW_CHECKED_MOD((base0), (mod));
    int64_t exp = exp0;
    while (exp != 0) {
        if (FLOW_CHECKED_MOD((exp), (2)) == 1) {
            r = FLOW_CHECKED_MOD(((r * base)), (mod));
        }
        base = FLOW_CHECKED_MOD(((base * base)), (mod));
        exp = FLOW_CHECKED_DIV((exp), (2));
    }
    return r;
}

int64_t prime_order_i32(int32_t p) {
    if (p == 7) {
        return 7;
    }
    int32_t factors[128] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    int32_t extra[128] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
    int32_t nf = 0;
    int64_t order = 0;
    if (powmod_i64_i64_i64(7, ((int64_t)(FLOW_CHECKED_DIV(((p - 1)), (2)))), ((int64_t)(p))) == 1) {
        order = ((int64_t)((p - 1)));
        nf = unique_prime_factors_i32_ptr_i32((p - 1), (&(factors[0])));
    } else {
        order = (((int64_t)((p - 1))) * ((int64_t)((p + 1))));
        nf = unique_prime_factors_i32_ptr_i32((p - 1), (&(factors[0])));
        int32_t ne = unique_prime_factors_i32_ptr_i32((p + 1), (&(extra[0])));
        int32_t i = 0;
        while (i < ne) {
            factors[nf] = (((unsigned)(i) < 128) ? extra[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 128), flow_fault_handler("array index out of bounds"), extra[0]));
            nf = (nf + 1);
            i = (i + 1);
        }
    }
    int32_t i = 0;
    while (i < nf) {
        int32_t j = (i + 1);
        while (j < nf) {
            if ((((unsigned)(i) < 128) ? factors[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 128), flow_fault_handler("array index out of bounds"), factors[0])) == (((unsigned)(j) < 128) ? factors[j] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(j), 128), flow_fault_handler("array index out of bounds"), factors[0]))) {
                factors[j] = (((unsigned)((nf - 1)) < 128) ? factors[(nf - 1)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)((nf - 1)), 128), flow_fault_handler("array index out of bounds"), factors[0]));
                nf = (nf - 1);
                j = (j - 1);
            }
            j = (j + 1);
        }
        i = (i + 1);
    }
    int64_t ra_buf[1] = { 0 };
    int64_t rb_buf[1] = { 0 };
    int32_t i2 = 0;
    while (i2 < nf) {
        int64_t q = ((int64_t)((((unsigned)(i2) < 128) ? factors[i2] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i2), 128), flow_fault_handler("array index out of bounds"), factors[0]))));
        while (FLOW_CHECKED_MOD((order), (q)) == 0) {
            quadratic_power_i64_i64_ptr_i64_ptr_i64(FLOW_CHECKED_DIV((order), (q)), ((int64_t)(p)), (&(ra_buf[0])), (&(rb_buf[0])));
            if (((((unsigned)(0) < 1) ? ra_buf[0] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(0), 1), flow_fault_handler("array index out of bounds"), ra_buf[0])) == 1 && (((unsigned)(0) < 1) ? rb_buf[0] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(0), 1), flow_fault_handler("array index out of bounds"), rb_buf[0])) == 0)) {
                order = FLOW_CHECKED_DIV((order), (q));
            } else {
                break;
            }
        }
        i2 = (i2 + 1);
    }
    return order;
}

void build_prime_power_orders_i32(int32_t limit) {
    orders = ((int64_t*)(calloc(((int64_t)((limit + 1))), 8)));
    int64_t ra_buf[1] = { 0 };
    int64_t rb_buf[1] = { 0 };
    int32_t pi = 0;
    while (pi < nprimes) {
        int32_t p = primes[pi];
        if (p > limit) {
            break;
        }
        if (p < 5) {
            pi = (pi + 1);
            continue;
        }
        int64_t order = prime_order_i32(p);
        int64_t pp = ((int64_t)(p));
        int64_t lifted = order;
        orders[((int32_t)(pp))] = lifted;
        while ((pp * ((int64_t)(p))) <= ((int64_t)(limit))) {
            pp = (pp * ((int64_t)(p)));
            quadratic_power_i64_i64_ptr_i64_ptr_i64(lifted, pp, (&(ra_buf[0])), (&(rb_buf[0])));
            if ((!(((((unsigned)(0) < 1) ? ra_buf[0] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(0), 1), flow_fault_handler("array index out of bounds"), ra_buf[0])) == 1 && (((unsigned)(0) < 1) ? rb_buf[0] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(0), 1), flow_fault_handler("array index out of bounds"), rb_buf[0])) == 0)))) {
                lifted = (lifted * ((int64_t)(p)));
            }
            orders[((int32_t)(pp))] = lifted;
        }
        pi = (pi + 1);
    }
}

int64_t G_i32(int32_t limit) {
    smallest_prime_factors_i32((limit + 1));
    build_prime_power_orders_i32(limit);
    int64_t* values = (int64_t*)(((int64_t*)(calloc(((int64_t)((limit + 1))), 8))));
    int64_t total = 0;
    int32_t n = 2;
    while (n <= limit) {
        if ((FLOW_CHECKED_MOD((n), (2)) == 0 || FLOW_CHECKED_MOD((n), (3)) == 0)) {
            n = (n + 1);
            continue;
        }
        int32_t p = spf[n];
        int32_t remaining = n;
        int64_t pp = 1;
        while (FLOW_CHECKED_MOD((remaining), (p)) == 0) {
            remaining = FLOW_CHECKED_DIV((remaining), (p));
            pp = (pp * ((int64_t)(p)));
        }
        int64_t prev = 0;
        if (remaining > 1) {
            prev = values[remaining];
        } else {
            prev = 1;
        }
        int64_t comp = orders[((int32_t)(pp))];
        int64_t g = llgcd_i64_i64(prev, comp);
        int64_t val = (FLOW_CHECKED_DIV((prev), (g)) * comp);
        values[n] = val;
        total = (total + val);
        n = (n + 1);
    }
    free(((void*)(values)));
    return total;
}

int32_t main(void) {
    printf("%lld\n", G_i32(1000000));
    return 0;
}

Generated MLIR

module {
  llvm.func @printf(!llvm.ptr, ...) -> i32
  llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
  func.func private @calloc(i64, i64) -> !llvm.ptr
  func.func private @free(!llvm.ptr) -> ()
  func.func private @memset(!llvm.ptr, i64, i64) -> !llvm.ptr
  // Module static: spf
  llvm.mlir.global internal @spf() {addr_space = 0 : i32} : !llvm.ptr {
    %0 = llvm.mlir.zero : !llvm.ptr
    llvm.return %0 : !llvm.ptr
  }
  // Module static: primes
  llvm.mlir.global internal @primes() {addr_space = 0 : i32} : !llvm.ptr {
    %1 = llvm.mlir.zero : !llvm.ptr
    llvm.return %1 : !llvm.ptr
  }
  // Module static: nprimes
  llvm.mlir.global internal @nprimes(0 : i32) : i32
  // Module static: orders
  llvm.mlir.global internal @orders() {addr_space = 0 : i32} : !llvm.ptr {
    %2 = llvm.mlir.zero : !llvm.ptr
    llvm.return %2 : !llvm.ptr
  }
  func.func @smallest_prime_factors(%arg0: i32) -> () {
    %4 = arith.constant 1 : i32
    %5 = arith.addi %arg0, %4 : i32
    %6 = arith.extsi %5 : i32 to i64
    %7 = arith.constant 4 : i32
    %8 = arith.extsi %7 : i32 to i64
    %3 = func.call @calloc(%6, %8) : (i64, i64) -> !llvm.ptr
    %9 = llvm.mlir.addressof @spf : !llvm.ptr
    llvm.store %3, %9 : !llvm.ptr, !llvm.ptr
    %11 = arith.constant 2 : i32
    %12 = arith.divsi %arg0, %11 : i32
    %13 = arith.constant 100 : i32
    %14 = arith.addi %12, %13 : i32
    %15 = arith.extsi %14 : i32 to i64
    %16 = arith.constant 4 : i32
    %17 = arith.extsi %16 : i32 to i64
    %10 = func.call @calloc(%15, %17) : (i64, i64) -> !llvm.ptr
    %18 = llvm.mlir.addressof @primes : !llvm.ptr
    llvm.store %10, %18 : !llvm.ptr, !llvm.ptr
    %19 = arith.constant 0 : i32
    %20 = llvm.mlir.addressof @nprimes : !llvm.ptr
    llvm.store %19, %20 : i32, !llvm.ptr
    %21 = arith.constant 2 : i32
    %22 = llvm.mlir.constant(1 : i64) : i64
    %23 = llvm.alloca %22 x i32 : (i64) -> !llvm.ptr
    llvm.store %21, %23 : i32, !llvm.ptr
    cf.br ^bb0
    ^bb0:
    %24 = llvm.load %23 : !llvm.ptr -> i32
    %25 = arith.cmpi sle, %24, %arg0 : i32
    cf.cond_br %25, ^bb1, ^bb2
    ^bb1:
      %27 = llvm.mlir.addressof @spf : !llvm.ptr
      %28 = llvm.load %27 : !llvm.ptr -> !llvm.ptr
      %29 = llvm.load %23 : !llvm.ptr -> i32
      %30 = arith.extsi %29 : i32 to i64
      %31 = llvm.getelementptr %28[%30] : (!llvm.ptr, i64) -> !llvm.ptr, i32
      %26 = llvm.load %31 : !llvm.ptr -> i32
      %32 = arith.constant 0 : i32
      %33 = arith.cmpi eq, %26, %32 : i32
      cf.cond_br %33, ^bb3, ^bb4
      ^bb3:
        %34 = llvm.load %23 : !llvm.ptr -> i32
        %35 = llvm.mlir.addressof @spf : !llvm.ptr
        %36 = llvm.load %35 : !llvm.ptr -> !llvm.ptr
        %37 = llvm.load %23 : !llvm.ptr -> i32
        %38 = arith.extsi %37 : i32 to i64
        %39 = llvm.getelementptr %36[%38] : (!llvm.ptr, i64) -> !llvm.ptr, i32
        llvm.store %34, %39 : i32, !llvm.ptr
        %40 = llvm.load %23 : !llvm.ptr -> i32
        %41 = llvm.mlir.addressof @primes : !llvm.ptr
        %42 = llvm.load %41 : !llvm.ptr -> !llvm.ptr
        %43 = llvm.mlir.addressof @nprimes : !llvm.ptr
        %44 = llvm.load %43 : !llvm.ptr -> i32
        %45 = arith.extsi %44 : i32 to i64
        %46 = llvm.getelementptr %42[%45] : (!llvm.ptr, i64) -> !llvm.ptr, i32
        llvm.store %40, %46 : i32, !llvm.ptr
        %47 = llvm.mlir.addressof @nprimes : !llvm.ptr
        %48 = llvm.load %47 : !llvm.ptr -> i32
        %49 = arith.constant 1 : i32
        %50 = arith.addi %48, %49 : i32
        %51 = llvm.mlir.addressof @nprimes : !llvm.ptr
        llvm.store %50, %51 : i32, !llvm.ptr
        cf.br ^bb5
      ^bb4:
        cf.br ^bb5
      ^bb5:
      %52 = arith.constant 0 : i32
      %53 = llvm.mlir.constant(1 : i64) : i64
      %54 = llvm.alloca %53 x i32 : (i64) -> !llvm.ptr
      llvm.store %52, %54 : i32, !llvm.ptr
      cf.br ^bb6
      ^bb6:
      %55 = llvm.load %54 : !llvm.ptr -> i32
      %56 = llvm.mlir.addressof @nprimes : !llvm.ptr
      %57 = llvm.load %56 : !llvm.ptr -> i32
      %58 = arith.cmpi slt, %55, %57 : i32
      cf.cond_br %58, ^bb7, ^bb8
      ^bb7:
        %60 = llvm.mlir.addressof @primes : !llvm.ptr
        %61 = llvm.load %60 : !llvm.ptr -> !llvm.ptr
        %62 = llvm.load %54 : !llvm.ptr -> i32
        %63 = arith.extsi %62 : i32 to i64
        %64 = llvm.getelementptr %61[%63] : (!llvm.ptr, i64) -> !llvm.ptr, i32
        %59 = llvm.load %64 : !llvm.ptr -> i32
        %65 = llvm.load %23 : !llvm.ptr -> i32
        %66 = arith.extsi %65 : i32 to i64
        %67 = arith.extsi %59 : i32 to i64
        %68 = arith.muli %66, %67 : i64
        %69 = arith.extsi %arg0 : i32 to i64
        %70 = arith.cmpi sgt, %68, %69 : i64
        cf.cond_br %70, ^bb9, ^bb10
        ^bb9:
          cf.br ^bb8
        ^bb10:
          cf.br ^bb11
        ^bb11:
        %72 = llvm.mlir.addressof @spf : !llvm.ptr
        %73 = llvm.load %72 : !llvm.ptr -> !llvm.ptr
        %74 = llvm.load %23 : !llvm.ptr -> i32
        %75 = arith.extsi %74 : i32 to i64
        %76 = llvm.getelementptr %73[%75] : (!llvm.ptr, i64) -> !llvm.ptr, i32
        %71 = llvm.load %76 : !llvm.ptr -> i32
        %77 = arith.cmpi sgt, %59, %71 : i32
        cf.cond_br %77, ^bb12, ^bb13
        ^bb12:
          cf.br ^bb8
        ^bb13:
          cf.br ^bb14
        ^bb14:
        %78 = llvm.mlir.addressof @spf : !llvm.ptr
        %79 = llvm.load %78 : !llvm.ptr -> !llvm.ptr
        %80 = arith.trunci %68 : i64 to i32
        %81 = arith.extsi %80 : i32 to i64
        %82 = llvm.getelementptr %79[%81] : (!llvm.ptr, i64) -> !llvm.ptr, i32
        llvm.store %59, %82 : i32, !llvm.ptr
        %83 = llvm.load %54 : !llvm.ptr -> i32
        %84 = arith.constant 1 : i32
        %85 = arith.addi %83, %84 : i32
        llvm.store %85, %54 : i32, !llvm.ptr
        cf.br ^bb6
      ^bb8:
      %86 = llvm.load %23 : !llvm.ptr -> i32
      %87 = arith.constant 1 : i32
      %88 = arith.addi %86, %87 : i32
      llvm.store %88, %23 : i32, !llvm.ptr
      cf.br ^bb0
    ^bb2:
    func.return
  }
  func.func @unique_prime_factors(%arg0: i32, %arg1: !llvm.ptr) -> i32 {
    %89 = llvm.mlir.constant(1 : i64) : i64
    %90 = llvm.alloca %89 x i32 : (i64) -> !llvm.ptr
    llvm.store %arg0, %90 : i32, !llvm.ptr
    %91 = arith.constant 0 : i32
    %92 = llvm.mlir.constant(1 : i64) : i64
    %93 = llvm.alloca %92 x i32 : (i64) -> !llvm.ptr
    llvm.store %91, %93 : i32, !llvm.ptr
    cf.br ^bb15
    ^bb15:
    %94 = llvm.load %90 : !llvm.ptr -> i32
    %95 = arith.constant 1 : i32
    %96 = arith.cmpi sgt, %94, %95 : i32
    cf.cond_br %96, ^bb16, ^bb17
    ^bb16:
      %98 = llvm.mlir.addressof @spf : !llvm.ptr
      %99 = llvm.load %98 : !llvm.ptr -> !llvm.ptr
      %100 = llvm.load %90 : !llvm.ptr -> i32
      %101 = arith.extsi %100 : i32 to i64
      %102 = llvm.getelementptr %99[%101] : (!llvm.ptr, i64) -> !llvm.ptr, i32
      %97 = llvm.load %102 : !llvm.ptr -> i32
      %103 = llvm.load %93 : !llvm.ptr -> i32
      %104 = arith.extsi %103 : i32 to i64
      %105 = llvm.getelementptr %arg1[%104] : (!llvm.ptr, i64) -> !llvm.ptr, i32
      llvm.store %97, %105 : i32, !llvm.ptr
      %106 = llvm.load %93 : !llvm.ptr -> i32
      %107 = arith.constant 1 : i32
      %108 = arith.addi %106, %107 : i32
      llvm.store %108, %93 : i32, !llvm.ptr
      cf.br ^bb18
      ^bb18:
      %109 = llvm.load %90 : !llvm.ptr -> i32
      %110 = arith.remsi %109, %97 : i32
      %111 = arith.constant 0 : i32
      %112 = arith.cmpi eq, %110, %111 : i32
      cf.cond_br %112, ^bb19, ^bb20
      ^bb19:
        %113 = llvm.load %90 : !llvm.ptr -> i32
        %114 = arith.divsi %113, %97 : i32
        llvm.store %114, %90 : i32, !llvm.ptr
        cf.br ^bb18
      ^bb20:
      cf.br ^bb15
    ^bb17:
    %115 = llvm.load %93 : !llvm.ptr -> i32
    func.return %115 : i32
  }
  func.func @quadratic_power(%arg0: i64, %arg1: i64, %arg2: !llvm.ptr, %arg3: !llvm.ptr) -> () {
    %116 = arith.constant 1 : i32
    %117 = arith.extsi %116 : i32 to i64
    %118 = llvm.mlir.constant(1 : i64) : i64
    %119 = llvm.alloca %118 x i64 : (i64) -> !llvm.ptr
    llvm.store %117, %119 : i64, !llvm.ptr
    %120 = arith.constant 0 : i32
    %121 = arith.extsi %120 : i32 to i64
    %122 = llvm.mlir.constant(1 : i64) : i64
    %123 = llvm.alloca %122 x i64 : (i64) -> !llvm.ptr
    llvm.store %121, %123 : i64, !llvm.ptr
    %124 = arith.constant 1 : i32
    %125 = arith.extsi %124 : i32 to i64
    %126 = llvm.mlir.constant(1 : i64) : i64
    %127 = llvm.alloca %126 x i64 : (i64) -> !llvm.ptr
    llvm.store %125, %127 : i64, !llvm.ptr
    %128 = arith.constant 1 : i32
    %129 = arith.extsi %128 : i32 to i64
    %130 = llvm.mlir.constant(1 : i64) : i64
    %131 = llvm.alloca %130 x i64 : (i64) -> !llvm.ptr
    llvm.store %129, %131 : i64, !llvm.ptr
    %132 = llvm.mlir.constant(1 : i64) : i64
    %133 = llvm.alloca %132 x i64 : (i64) -> !llvm.ptr
    llvm.store %arg0, %133 : i64, !llvm.ptr
    cf.br ^bb21
    ^bb21:
    %134 = llvm.load %133 : !llvm.ptr -> i64
    %135 = arith.constant 0 : i32
    %137 = arith.extsi %135 : i32 to i64
    %136 = arith.cmpi ne, %134, %137 : i64
    cf.cond_br %136, ^bb22, ^bb23
    ^bb22:
      %138 = llvm.load %133 : !llvm.ptr -> i64
      %139 = arith.constant 2 : i32
      %141 = arith.extsi %139 : i32 to i64
      %140 = arith.remsi %138, %141 : i64
      %142 = arith.constant 1 : i32
      %144 = arith.extsi %142 : i32 to i64
      %143 = arith.cmpi eq, %140, %144 : i64
      cf.cond_br %143, ^bb24, ^bb25
      ^bb24:
        %145 = llvm.load %127 : !llvm.ptr -> i64
        %146 = llvm.load %119 : !llvm.ptr -> i64
        %147 = arith.muli %145, %146 : i64
        %148 = arith.constant 7 : i32
        %149 = llvm.load %131 : !llvm.ptr -> i64
        %151 = arith.extsi %148 : i32 to i64
        %150 = arith.muli %151, %149 : i64
        %152 = llvm.load %123 : !llvm.ptr -> i64
        %153 = arith.muli %150, %152 : i64
        %154 = arith.addi %147, %153 : i64
        %155 = arith.remsi %154, %arg1 : i64
        %156 = llvm.load %127 : !llvm.ptr -> i64
        %157 = llvm.load %123 : !llvm.ptr -> i64
        %158 = arith.muli %156, %157 : i64
        %159 = llvm.load %131 : !llvm.ptr -> i64
        %160 = llvm.load %119 : !llvm.ptr -> i64
        %161 = arith.muli %159, %160 : i64
        %162 = arith.addi %158, %161 : i64
        %163 = arith.remsi %162, %arg1 : i64
        llvm.store %155, %119 : i64, !llvm.ptr
        llvm.store %163, %123 : i64, !llvm.ptr
        cf.br ^bb26
      ^bb25:
        cf.br ^bb26
      ^bb26:
      %164 = llvm.load %127 : !llvm.ptr -> i64
      %165 = llvm.load %127 : !llvm.ptr -> i64
      %166 = arith.muli %164, %165 : i64
      %167 = arith.constant 7 : i32
      %168 = llvm.load %131 : !llvm.ptr -> i64
      %170 = arith.extsi %167 : i32 to i64
      %169 = arith.muli %170, %168 : i64
      %171 = llvm.load %131 : !llvm.ptr -> i64
      %172 = arith.muli %169, %171 : i64
      %173 = arith.addi %166, %172 : i64
      %174 = arith.remsi %173, %arg1 : i64
      %175 = arith.constant 2 : i32
      %176 = llvm.load %127 : !llvm.ptr -> i64
      %178 = arith.extsi %175 : i32 to i64
      %177 = arith.muli %178, %176 : i64
      %179 = llvm.load %131 : !llvm.ptr -> i64
      %180 = arith.muli %177, %179 : i64
      %181 = arith.remsi %180, %arg1 : i64
      llvm.store %174, %127 : i64, !llvm.ptr
      llvm.store %181, %131 : i64, !llvm.ptr
      %182 = llvm.load %133 : !llvm.ptr -> i64
      %183 = arith.constant 2 : i32
      %185 = arith.extsi %183 : i32 to i64
      %184 = arith.divsi %182, %185 : i64
      llvm.store %184, %133 : i64, !llvm.ptr
      cf.br ^bb21
    ^bb23:
    %186 = llvm.load %119 : !llvm.ptr -> i64
    %187 = arith.constant 0 : i32
    %188 = arith.extsi %187 : i32 to i64
    %189 = llvm.getelementptr %arg2[%188] : (!llvm.ptr, i64) -> !llvm.ptr, i64
    llvm.store %186, %189 : i64, !llvm.ptr
    %190 = llvm.load %123 : !llvm.ptr -> i64
    %191 = arith.constant 0 : i32
    %192 = arith.extsi %191 : i32 to i64
    %193 = llvm.getelementptr %arg3[%192] : (!llvm.ptr, i64) -> !llvm.ptr, i64
    llvm.store %190, %193 : i64, !llvm.ptr
    func.return
  }
  func.func @llgcd(%arg0: i64, %arg1: i64) -> i64 {
    %194 = llvm.mlir.constant(1 : i64) : i64
    %195 = llvm.alloca %194 x i64 : (i64) -> !llvm.ptr
    llvm.store %arg0, %195 : i64, !llvm.ptr
    %196 = llvm.mlir.constant(1 : i64) : i64
    %197 = llvm.alloca %196 x i64 : (i64) -> !llvm.ptr
    llvm.store %arg1, %197 : i64, !llvm.ptr
    cf.br ^bb27
    ^bb27:
    %198 = llvm.load %197 : !llvm.ptr -> i64
    %199 = arith.constant 0 : i32
    %201 = arith.extsi %199 : i32 to i64
    %200 = arith.cmpi ne, %198, %201 : i64
    cf.cond_br %200, ^bb28, ^bb29
    ^bb28:
      %202 = llvm.load %195 : !llvm.ptr -> i64
      %203 = llvm.load %197 : !llvm.ptr -> i64
      %204 = arith.remsi %202, %203 : i64
      %205 = llvm.load %197 : !llvm.ptr -> i64
      llvm.store %205, %195 : i64, !llvm.ptr
      llvm.store %204, %197 : i64, !llvm.ptr
      cf.br ^bb27
    ^bb29:
    %206 = llvm.load %195 : !llvm.ptr -> i64
    func.return %206 : i64
  }
  func.func @powmod(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
    %207 = arith.constant 1 : i32
    %209 = arith.extsi %207 : i32 to i64
    %208 = arith.remsi %209, %arg2 : i64
    %210 = llvm.mlir.constant(1 : i64) : i64
    %211 = llvm.alloca %210 x i64 : (i64) -> !llvm.ptr
    llvm.store %208, %211 : i64, !llvm.ptr
    %212 = arith.remsi %arg0, %arg2 : i64
    %213 = llvm.mlir.constant(1 : i64) : i64
    %214 = llvm.alloca %213 x i64 : (i64) -> !llvm.ptr
    llvm.store %212, %214 : i64, !llvm.ptr
    %215 = llvm.mlir.constant(1 : i64) : i64
    %216 = llvm.alloca %215 x i64 : (i64) -> !llvm.ptr
    llvm.store %arg1, %216 : i64, !llvm.ptr
    cf.br ^bb30
    ^bb30:
    %217 = llvm.load %216 : !llvm.ptr -> i64
    %218 = arith.constant 0 : i32
    %220 = arith.extsi %218 : i32 to i64
    %219 = arith.cmpi ne, %217, %220 : i64
    cf.cond_br %219, ^bb31, ^bb32
    ^bb31:
      %221 = llvm.load %216 : !llvm.ptr -> i64
      %222 = arith.constant 2 : i32
      %224 = arith.extsi %222 : i32 to i64
      %223 = arith.remsi %221, %224 : i64
      %225 = arith.constant 1 : i32
      %227 = arith.extsi %225 : i32 to i64
      %226 = arith.cmpi eq, %223, %227 : i64
      cf.cond_br %226, ^bb33, ^bb34
      ^bb33:
        %228 = llvm.load %211 : !llvm.ptr -> i64
        %229 = llvm.load %214 : !llvm.ptr -> i64
        %230 = arith.muli %228, %229 : i64
        %231 = arith.remsi %230, %arg2 : i64
        llvm.store %231, %211 : i64, !llvm.ptr
        cf.br ^bb35
      ^bb34:
        cf.br ^bb35
      ^bb35:
      %232 = llvm.load %214 : !llvm.ptr -> i64
      %233 = llvm.load %214 : !llvm.ptr -> i64
      %234 = arith.muli %232, %233 : i64
      %235 = arith.remsi %234, %arg2 : i64
      llvm.store %235, %214 : i64, !llvm.ptr
      %236 = llvm.load %216 : !llvm.ptr -> i64
      %237 = arith.constant 2 : i32
      %239 = arith.extsi %237 : i32 to i64
      %238 = arith.divsi %236, %239 : i64
      llvm.store %238, %216 : i64, !llvm.ptr
      cf.br ^bb30
    ^bb32:
    %240 = llvm.load %211 : !llvm.ptr -> i64
    func.return %240 : i64
  }
  func.func @prime_order(%arg0: i32) -> i64 {
    %241 = arith.constant 7 : i32
    %242 = arith.cmpi eq, %arg0, %241 : i32
    cf.cond_br %242, ^bb36, ^bb37
    ^bb36:
      %243 = arith.constant 7 : i32
      %244 = arith.extsi %243 : i32 to i64
      func.return %244 : i64
    ^bb37:
      cf.br ^bb38
    ^bb38:
    %246 = arith.constant 0 : i32
    %247 = arith.constant 0 : i32
    %248 = arith.constant 0 : i32
    %249 = arith.constant 0 : i32
    %250 = arith.constant 0 : i32
    %251 = arith.constant 0 : i32
    %252 = arith.constant 0 : i32
    %253 = arith.constant 0 : i32
    %254 = arith.constant 0 : i32
    %255 = arith.constant 0 : i32
    %256 = arith.constant 0 : i32
    %257 = arith.constant 0 : i32
    %258 = arith.constant 0 : i32
    %259 = arith.constant 0 : i32
    %260 = arith.constant 0 : i32
    %261 = arith.constant 0 : i32
    %262 = arith.constant 0 : i32
    %263 = arith.constant 0 : i32
    %264 = arith.constant 0 : i32
    %265 = arith.constant 0 : i32
    %266 = arith.constant 0 : i32
    %267 = arith.constant 0 : i32
    %268 = arith.constant 0 : i32
    %269 = arith.constant 0 : i32
    %270 = arith.constant 0 : i32
    %271 = arith.constant 0 : i32
    %272 = arith.constant 0 : i32
    %273 = arith.constant 0 : i32
    %274 = arith.constant 0 : i32
    %275 = arith.constant 0 : i32
    %276 = arith.constant 0 : i32
    %277 = arith.constant 0 : i32
    %278 = arith.constant 0 : i32
    %279 = arith.constant 0 : i32
    %280 = arith.constant 0 : i32
    %281 = arith.constant 0 : i32
    %282 = arith.constant 0 : i32
    %283 = arith.constant 0 : i32
    %284 = arith.constant 0 : i32
    %285 = arith.constant 0 : i32
    %286 = arith.constant 0 : i32
    %287 = arith.constant 0 : i32
    %288 = arith.constant 0 : i32
    %289 = arith.constant 0 : i32
    %290 = arith.constant 0 : i32
    %291 = arith.constant 0 : i32
    %292 = arith.constant 0 : i32
    %293 = arith.constant 0 : i32
    %294 = arith.constant 0 : i32
    %295 = arith.constant 0 : i32
    %296 = arith.constant 0 : i32
    %297 = arith.constant 0 : i32
    %298 = arith.constant 0 : i32
    %299 = arith.constant 0 : i32
    %300 = arith.constant 0 : i32
    %301 = arith.constant 0 : i32
    %302 = arith.constant 0 : i32
    %303 = arith.constant 0 : i32
    %304 = arith.constant 0 : i32
    %305 = arith.constant 0 : i32
    %306 = arith.constant 0 : i32
    %307 = arith.constant 0 : i32
    %308 = arith.constant 0 : i32
    %309 = arith.constant 0 : i32
    %310 = arith.constant 0 : i32
    %311 = arith.constant 0 : i32
    %312 = arith.constant 0 : i32
    %313 = arith.constant 0 : i32
    %314 = arith.constant 0 : i32
    %315 = arith.constant 0 : i32
    %316 = arith.constant 0 : i32
    %317 = arith.constant 0 : i32
    %318 = arith.constant 0 : i32
    %319 = arith.constant 0 : i32
    %320 = arith.constant 0 : i32
    %321 = arith.constant 0 : i32
    %322 = arith.constant 0 : i32
    %323 = arith.constant 0 : i32
    %324 = arith.constant 0 : i32
    %325 = arith.constant 0 : i32
    %326 = arith.constant 0 : i32
    %327 = arith.constant 0 : i32
    %328 = arith.constant 0 : i32
    %329 = arith.constant 0 : i32
    %330 = arith.constant 0 : i32
    %331 = arith.constant 0 : i32
    %332 = arith.constant 0 : i32
    %333 = arith.constant 0 : i32
    %334 = arith.constant 0 : i32
    %335 = arith.constant 0 : i32
    %336 = arith.constant 0 : i32
    %337 = arith.constant 0 : i32
    %338 = arith.constant 0 : i32
    %339 = arith.constant 0 : i32
    %340 = arith.constant 0 : i32
    %341 = arith.constant 0 : i32
    %342 = arith.constant 0 : i32
    %343 = arith.constant 0 : i32
    %344 = arith.constant 0 : i32
    %345 = arith.constant 0 : i32
    %346 = arith.constant 0 : i32
    %347 = arith.constant 0 : i32
    %348 = arith.constant 0 : i32
    %349 = arith.constant 0 : i32
    %350 = arith.constant 0 : i32
    %351 = arith.constant 0 : i32
    %352 = arith.constant 0 : i32
    %353 = arith.constant 0 : i32
    %354 = arith.constant 0 : i32
    %355 = arith.constant 0 : i32
    %356 = arith.constant 0 : i32
    %357 = arith.constant 0 : i32
    %358 = arith.constant 0 : i32
    %359 = arith.constant 0 : i32
    %360 = arith.constant 0 : i32
    %361 = arith.constant 0 : i32
    %362 = arith.constant 0 : i32
    %363 = arith.constant 0 : i32
    %364 = arith.constant 0 : i32
    %365 = arith.constant 0 : i32
    %366 = arith.constant 0 : i32
    %367 = arith.constant 0 : i32
    %368 = arith.constant 0 : i32
    %369 = arith.constant 0 : i32
    %370 = arith.constant 0 : i32
    %371 = arith.constant 0 : i32
    %372 = arith.constant 0 : i32
    %373 = arith.constant 0 : i32
    %374 = arith.constant 0 : i32
    %375 = arith.constant 0 : i32
    %376 = arith.constant 0 : i32
    %377 = arith.constant 0 : i32
    %378 = arith.constant 0 : i32
    %379 = arith.constant 0 : i32
    %380 = llvm.mlir.constant(1 : i64) : i64
    %381 = llvm.alloca %380 x !llvm.array<128 x i32> : (i64) -> !llvm.ptr
    %382 = llvm.mlir.zero : !llvm.array<128 x i32>
    llvm.store %382, %381 : !llvm.array<128 x i32>, !llvm.ptr
    %383 = llvm.mlir.constant(0 : i64) : i64
    %384 = llvm.getelementptr %381[0, %383] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %246, %384 : i32, !llvm.ptr
    %385 = llvm.mlir.constant(1 : i64) : i64
    %386 = llvm.getelementptr %381[0, %385] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %247, %386 : i32, !llvm.ptr
    %387 = llvm.mlir.constant(2 : i64) : i64
    %388 = llvm.getelementptr %381[0, %387] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %248, %388 : i32, !llvm.ptr
    %389 = llvm.mlir.constant(3 : i64) : i64
    %390 = llvm.getelementptr %381[0, %389] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %249, %390 : i32, !llvm.ptr
    %391 = llvm.mlir.constant(4 : i64) : i64
    %392 = llvm.getelementptr %381[0, %391] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %250, %392 : i32, !llvm.ptr
    %393 = llvm.mlir.constant(5 : i64) : i64
    %394 = llvm.getelementptr %381[0, %393] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %251, %394 : i32, !llvm.ptr
    %395 = llvm.mlir.constant(6 : i64) : i64
    %396 = llvm.getelementptr %381[0, %395] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %252, %396 : i32, !llvm.ptr
    %397 = llvm.mlir.constant(7 : i64) : i64
    %398 = llvm.getelementptr %381[0, %397] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %253, %398 : i32, !llvm.ptr
    %399 = llvm.mlir.constant(8 : i64) : i64
    %400 = llvm.getelementptr %381[0, %399] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %254, %400 : i32, !llvm.ptr
    %401 = llvm.mlir.constant(9 : i64) : i64
    %402 = llvm.getelementptr %381[0, %401] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %255, %402 : i32, !llvm.ptr
    %403 = llvm.mlir.constant(10 : i64) : i64
    %404 = llvm.getelementptr %381[0, %403] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %256, %404 : i32, !llvm.ptr
    %405 = llvm.mlir.constant(11 : i64) : i64
    %406 = llvm.getelementptr %381[0, %405] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %257, %406 : i32, !llvm.ptr
    %407 = llvm.mlir.constant(12 : i64) : i64
    %408 = llvm.getelementptr %381[0, %407] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %258, %408 : i32, !llvm.ptr
    %409 = llvm.mlir.constant(13 : i64) : i64
    %410 = llvm.getelementptr %381[0, %409] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %259, %410 : i32, !llvm.ptr
    %411 = llvm.mlir.constant(14 : i64) : i64
    %412 = llvm.getelementptr %381[0, %411] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %260, %412 : i32, !llvm.ptr
    %413 = llvm.mlir.constant(15 : i64) : i64
    %414 = llvm.getelementptr %381[0, %413] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %261, %414 : i32, !llvm.ptr
    %415 = llvm.mlir.constant(16 : i64) : i64
    %416 = llvm.getelementptr %381[0, %415] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %262, %416 : i32, !llvm.ptr
    %417 = llvm.mlir.constant(17 : i64) : i64
    %418 = llvm.getelementptr %381[0, %417] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %263, %418 : i32, !llvm.ptr
    %419 = llvm.mlir.constant(18 : i64) : i64
    %420 = llvm.getelementptr %381[0, %419] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %264, %420 : i32, !llvm.ptr
    %421 = llvm.mlir.constant(19 : i64) : i64
    %422 = llvm.getelementptr %381[0, %421] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %265, %422 : i32, !llvm.ptr
    %423 = llvm.mlir.constant(20 : i64) : i64
    %424 = llvm.getelementptr %381[0, %423] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %266, %424 : i32, !llvm.ptr
    %425 = llvm.mlir.constant(21 : i64) : i64
    %426 = llvm.getelementptr %381[0, %425] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %267, %426 : i32, !llvm.ptr
    %427 = llvm.mlir.constant(22 : i64) : i64
    %428 = llvm.getelementptr %381[0, %427] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %268, %428 : i32, !llvm.ptr
    %429 = llvm.mlir.constant(23 : i64) : i64
    %430 = llvm.getelementptr %381[0, %429] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %269, %430 : i32, !llvm.ptr
    %431 = llvm.mlir.constant(24 : i64) : i64
    %432 = llvm.getelementptr %381[0, %431] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %270, %432 : i32, !llvm.ptr
    %433 = llvm.mlir.constant(25 : i64) : i64
    %434 = llvm.getelementptr %381[0, %433] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %271, %434 : i32, !llvm.ptr
    %435 = llvm.mlir.constant(26 : i64) : i64
    %436 = llvm.getelementptr %381[0, %435] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %272, %436 : i32, !llvm.ptr
    %437 = llvm.mlir.constant(27 : i64) : i64
    %438 = llvm.getelementptr %381[0, %437] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %273, %438 : i32, !llvm.ptr
    %439 = llvm.mlir.constant(28 : i64) : i64
    %440 = llvm.getelementptr %381[0, %439] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %274, %440 : i32, !llvm.ptr
    %441 = llvm.mlir.constant(29 : i64) : i64
    %442 = llvm.getelementptr %381[0, %441] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %275, %442 : i32, !llvm.ptr
    %443 = llvm.mlir.constant(30 : i64) : i64
    %444 = llvm.getelementptr %381[0, %443] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %276, %444 : i32, !llvm.ptr
    %445 = llvm.mlir.constant(31 : i64) : i64
    %446 = llvm.getelementptr %381[0, %445] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %277, %446 : i32, !llvm.ptr
    %447 = llvm.mlir.constant(32 : i64) : i64
    %448 = llvm.getelementptr %381[0, %447] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %278, %448 : i32, !llvm.ptr
    %449 = llvm.mlir.constant(33 : i64) : i64
    %450 = llvm.getelementptr %381[0, %449] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %279, %450 : i32, !llvm.ptr
    %451 = llvm.mlir.constant(34 : i64) : i64
    %452 = llvm.getelementptr %381[0, %451] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %280, %452 : i32, !llvm.ptr
    %453 = llvm.mlir.constant(35 : i64) : i64
    %454 = llvm.getelementptr %381[0, %453] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %281, %454 : i32, !llvm.ptr
    %455 = llvm.mlir.constant(36 : i64) : i64
    %456 = llvm.getelementptr %381[0, %455] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %282, %456 : i32, !llvm.ptr
    %457 = llvm.mlir.constant(37 : i64) : i64
    %458 = llvm.getelementptr %381[0, %457] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %283, %458 : i32, !llvm.ptr
    %459 = llvm.mlir.constant(38 : i64) : i64
    %460 = llvm.getelementptr %381[0, %459] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %284, %460 : i32, !llvm.ptr
    %461 = llvm.mlir.constant(39 : i64) : i64
    %462 = llvm.getelementptr %381[0, %461] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %285, %462 : i32, !llvm.ptr
    %463 = llvm.mlir.constant(40 : i64) : i64
    %464 = llvm.getelementptr %381[0, %463] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %286, %464 : i32, !llvm.ptr
    %465 = llvm.mlir.constant(41 : i64) : i64
    %466 = llvm.getelementptr %381[0, %465] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %287, %466 : i32, !llvm.ptr
    %467 = llvm.mlir.constant(42 : i64) : i64
    %468 = llvm.getelementptr %381[0, %467] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %288, %468 : i32, !llvm.ptr
    %469 = llvm.mlir.constant(43 : i64) : i64
    %470 = llvm.getelementptr %381[0, %469] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %289, %470 : i32, !llvm.ptr
    %471 = llvm.mlir.constant(44 : i64) : i64
    %472 = llvm.getelementptr %381[0, %471] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %290, %472 : i32, !llvm.ptr
    %473 = llvm.mlir.constant(45 : i64) : i64
    %474 = llvm.getelementptr %381[0, %473] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %291, %474 : i32, !llvm.ptr
    %475 = llvm.mlir.constant(46 : i64) : i64
    %476 = llvm.getelementptr %381[0, %475] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %292, %476 : i32, !llvm.ptr
    %477 = llvm.mlir.constant(47 : i64) : i64
    %478 = llvm.getelementptr %381[0, %477] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %293, %478 : i32, !llvm.ptr
    %479 = llvm.mlir.constant(48 : i64) : i64
    %480 = llvm.getelementptr %381[0, %479] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %294, %480 : i32, !llvm.ptr
    %481 = llvm.mlir.constant(49 : i64) : i64
    %482 = llvm.getelementptr %381[0, %481] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %295, %482 : i32, !llvm.ptr
    %483 = llvm.mlir.constant(50 : i64) : i64
    %484 = llvm.getelementptr %381[0, %483] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %296, %484 : i32, !llvm.ptr
    %485 = llvm.mlir.constant(51 : i64) : i64
    %486 = llvm.getelementptr %381[0, %485] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %297, %486 : i32, !llvm.ptr
    %487 = llvm.mlir.constant(52 : i64) : i64
    %488 = llvm.getelementptr %381[0, %487] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %298, %488 : i32, !llvm.ptr
    %489 = llvm.mlir.constant(53 : i64) : i64
    %490 = llvm.getelementptr %381[0, %489] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %299, %490 : i32, !llvm.ptr
    %491 = llvm.mlir.constant(54 : i64) : i64
    %492 = llvm.getelementptr %381[0, %491] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %300, %492 : i32, !llvm.ptr
    %493 = llvm.mlir.constant(55 : i64) : i64
    %494 = llvm.getelementptr %381[0, %493] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %301, %494 : i32, !llvm.ptr
    %495 = llvm.mlir.constant(56 : i64) : i64
    %496 = llvm.getelementptr %381[0, %495] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %302, %496 : i32, !llvm.ptr
    %497 = llvm.mlir.constant(57 : i64) : i64
    %498 = llvm.getelementptr %381[0, %497] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %303, %498 : i32, !llvm.ptr
    %499 = llvm.mlir.constant(58 : i64) : i64
    %500 = llvm.getelementptr %381[0, %499] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %304, %500 : i32, !llvm.ptr
    %501 = llvm.mlir.constant(59 : i64) : i64
    %502 = llvm.getelementptr %381[0, %501] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %305, %502 : i32, !llvm.ptr
    %503 = llvm.mlir.constant(60 : i64) : i64
    %504 = llvm.getelementptr %381[0, %503] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %306, %504 : i32, !llvm.ptr
    %505 = llvm.mlir.constant(61 : i64) : i64
    %506 = llvm.getelementptr %381[0, %505] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %307, %506 : i32, !llvm.ptr
    %507 = llvm.mlir.constant(62 : i64) : i64
    %508 = llvm.getelementptr %381[0, %507] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %308, %508 : i32, !llvm.ptr
    %509 = llvm.mlir.constant(63 : i64) : i64
    %510 = llvm.getelementptr %381[0, %509] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %309, %510 : i32, !llvm.ptr
    %511 = llvm.mlir.constant(64 : i64) : i64
    %512 = llvm.getelementptr %381[0, %511] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %310, %512 : i32, !llvm.ptr
    %513 = llvm.mlir.constant(65 : i64) : i64
    %514 = llvm.getelementptr %381[0, %513] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %311, %514 : i32, !llvm.ptr
    %515 = llvm.mlir.constant(66 : i64) : i64
    %516 = llvm.getelementptr %381[0, %515] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %312, %516 : i32, !llvm.ptr
    %517 = llvm.mlir.constant(67 : i64) : i64
    %518 = llvm.getelementptr %381[0, %517] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %313, %518 : i32, !llvm.ptr
    %519 = llvm.mlir.constant(68 : i64) : i64
    %520 = llvm.getelementptr %381[0, %519] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %314, %520 : i32, !llvm.ptr
    %521 = llvm.mlir.constant(69 : i64) : i64
    %522 = llvm.getelementptr %381[0, %521] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %315, %522 : i32, !llvm.ptr
    %523 = llvm.mlir.constant(70 : i64) : i64
    %524 = llvm.getelementptr %381[0, %523] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %316, %524 : i32, !llvm.ptr
    %525 = llvm.mlir.constant(71 : i64) : i64
    %526 = llvm.getelementptr %381[0, %525] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %317, %526 : i32, !llvm.ptr
    %527 = llvm.mlir.constant(72 : i64) : i64
    %528 = llvm.getelementptr %381[0, %527] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %318, %528 : i32, !llvm.ptr
    %529 = llvm.mlir.constant(73 : i64) : i64
    %530 = llvm.getelementptr %381[0, %529] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %319, %530 : i32, !llvm.ptr
    %531 = llvm.mlir.constant(74 : i64) : i64
    %532 = llvm.getelementptr %381[0, %531] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %320, %532 : i32, !llvm.ptr
    %533 = llvm.mlir.constant(75 : i64) : i64
    %534 = llvm.getelementptr %381[0, %533] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %321, %534 : i32, !llvm.ptr
    %535 = llvm.mlir.constant(76 : i64) : i64
    %536 = llvm.getelementptr %381[0, %535] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %322, %536 : i32, !llvm.ptr
    %537 = llvm.mlir.constant(77 : i64) : i64
    %538 = llvm.getelementptr %381[0, %537] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %323, %538 : i32, !llvm.ptr
    %539 = llvm.mlir.constant(78 : i64) : i64
    %540 = llvm.getelementptr %381[0, %539] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %324, %540 : i32, !llvm.ptr
    %541 = llvm.mlir.constant(79 : i64) : i64
    %542 = llvm.getelementptr %381[0, %541] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %325, %542 : i32, !llvm.ptr
    %543 = llvm.mlir.constant(80 : i64) : i64
    %544 = llvm.getelementptr %381[0, %543] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %326, %544 : i32, !llvm.ptr
    %545 = llvm.mlir.constant(81 : i64) : i64
    %546 = llvm.getelementptr %381[0, %545] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %327, %546 : i32, !llvm.ptr
    %547 = llvm.mlir.constant(82 : i64) : i64
    %548 = llvm.getelementptr %381[0, %547] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %328, %548 : i32, !llvm.ptr
    %549 = llvm.mlir.constant(83 : i64) : i64
    %550 = llvm.getelementptr %381[0, %549] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %329, %550 : i32, !llvm.ptr
    %551 = llvm.mlir.constant(84 : i64) : i64
    %552 = llvm.getelementptr %381[0, %551] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %330, %552 : i32, !llvm.ptr
    %553 = llvm.mlir.constant(85 : i64) : i64
    %554 = llvm.getelementptr %381[0, %553] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %331, %554 : i32, !llvm.ptr
    %555 = llvm.mlir.constant(86 : i64) : i64
    %556 = llvm.getelementptr %381[0, %555] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %332, %556 : i32, !llvm.ptr
    %557 = llvm.mlir.constant(87 : i64) : i64
    %558 = llvm.getelementptr %381[0, %557] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %333, %558 : i32, !llvm.ptr
    %559 = llvm.mlir.constant(88 : i64) : i64
    %560 = llvm.getelementptr %381[0, %559] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %334, %560 : i32, !llvm.ptr
    %561 = llvm.mlir.constant(89 : i64) : i64
    %562 = llvm.getelementptr %381[0, %561] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %335, %562 : i32, !llvm.ptr
    %563 = llvm.mlir.constant(90 : i64) : i64
    %564 = llvm.getelementptr %381[0, %563] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %336, %564 : i32, !llvm.ptr
    %565 = llvm.mlir.constant(91 : i64) : i64
    %566 = llvm.getelementptr %381[0, %565] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %337, %566 : i32, !llvm.ptr
    %567 = llvm.mlir.constant(92 : i64) : i64
    %568 = llvm.getelementptr %381[0, %567] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %338, %568 : i32, !llvm.ptr
    %569 = llvm.mlir.constant(93 : i64) : i64
    %570 = llvm.getelementptr %381[0, %569] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %339, %570 : i32, !llvm.ptr
    %571 = llvm.mlir.constant(94 : i64) : i64
    %572 = llvm.getelementptr %381[0, %571] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %340, %572 : i32, !llvm.ptr
    %573 = llvm.mlir.constant(95 : i64) : i64
    %574 = llvm.getelementptr %381[0, %573] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %341, %574 : i32, !llvm.ptr
    %575 = llvm.mlir.constant(96 : i64) : i64
    %576 = llvm.getelementptr %381[0, %575] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %342, %576 : i32, !llvm.ptr
    %577 = llvm.mlir.constant(97 : i64) : i64
    %578 = llvm.getelementptr %381[0, %577] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %343, %578 : i32, !llvm.ptr
    %579 = llvm.mlir.constant(98 : i64) : i64
    %580 = llvm.getelementptr %381[0, %579] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %344, %580 : i32, !llvm.ptr
    %581 = llvm.mlir.constant(99 : i64) : i64
    %582 = llvm.getelementptr %381[0, %581] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %345, %582 : i32, !llvm.ptr
    %583 = llvm.mlir.constant(100 : i64) : i64
    %584 = llvm.getelementptr %381[0, %583] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %346, %584 : i32, !llvm.ptr
    %585 = llvm.mlir.constant(101 : i64) : i64
    %586 = llvm.getelementptr %381[0, %585] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %347, %586 : i32, !llvm.ptr
    %587 = llvm.mlir.constant(102 : i64) : i64
    %588 = llvm.getelementptr %381[0, %587] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %348, %588 : i32, !llvm.ptr
    %589 = llvm.mlir.constant(103 : i64) : i64
    %590 = llvm.getelementptr %381[0, %589] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %349, %590 : i32, !llvm.ptr
    %591 = llvm.mlir.constant(104 : i64) : i64
    %592 = llvm.getelementptr %381[0, %591] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %350, %592 : i32, !llvm.ptr
    %593 = llvm.mlir.constant(105 : i64) : i64
    %594 = llvm.getelementptr %381[0, %593] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %351, %594 : i32, !llvm.ptr
    %595 = llvm.mlir.constant(106 : i64) : i64
    %596 = llvm.getelementptr %381[0, %595] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %352, %596 : i32, !llvm.ptr
    %597 = llvm.mlir.constant(107 : i64) : i64
    %598 = llvm.getelementptr %381[0, %597] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %353, %598 : i32, !llvm.ptr
    %599 = llvm.mlir.constant(108 : i64) : i64
    %600 = llvm.getelementptr %381[0, %599] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %354, %600 : i32, !llvm.ptr
    %601 = llvm.mlir.constant(109 : i64) : i64
    %602 = llvm.getelementptr %381[0, %601] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %355, %602 : i32, !llvm.ptr
    %603 = llvm.mlir.constant(110 : i64) : i64
    %604 = llvm.getelementptr %381[0, %603] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %356, %604 : i32, !llvm.ptr
    %605 = llvm.mlir.constant(111 : i64) : i64
    %606 = llvm.getelementptr %381[0, %605] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %357, %606 : i32, !llvm.ptr
    %607 = llvm.mlir.constant(112 : i64) : i64
    %608 = llvm.getelementptr %381[0, %607] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %358, %608 : i32, !llvm.ptr
    %609 = llvm.mlir.constant(113 : i64) : i64
    %610 = llvm.getelementptr %381[0, %609] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %359, %610 : i32, !llvm.ptr
    %611 = llvm.mlir.constant(114 : i64) : i64
    %612 = llvm.getelementptr %381[0, %611] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %360, %612 : i32, !llvm.ptr
    %613 = llvm.mlir.constant(115 : i64) : i64
    %614 = llvm.getelementptr %381[0, %613] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %361, %614 : i32, !llvm.ptr
    %615 = llvm.mlir.constant(116 : i64) : i64
    %616 = llvm.getelementptr %381[0, %615] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %362, %616 : i32, !llvm.ptr
    %617 = llvm.mlir.constant(117 : i64) : i64
    %618 = llvm.getelementptr %381[0, %617] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %363, %618 : i32, !llvm.ptr
    %619 = llvm.mlir.constant(118 : i64) : i64
    %620 = llvm.getelementptr %381[0, %619] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %364, %620 : i32, !llvm.ptr
    %621 = llvm.mlir.constant(119 : i64) : i64
    %622 = llvm.getelementptr %381[0, %621] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %365, %622 : i32, !llvm.ptr
    %623 = llvm.mlir.constant(120 : i64) : i64
    %624 = llvm.getelementptr %381[0, %623] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %366, %624 : i32, !llvm.ptr
    %625 = llvm.mlir.constant(121 : i64) : i64
    %626 = llvm.getelementptr %381[0, %625] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %367, %626 : i32, !llvm.ptr
    %627 = llvm.mlir.constant(122 : i64) : i64
    %628 = llvm.getelementptr %381[0, %627] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %368, %628 : i32, !llvm.ptr
    %629 = llvm.mlir.constant(123 : i64) : i64
    %630 = llvm.getelementptr %381[0, %629] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %369, %630 : i32, !llvm.ptr
    %631 = llvm.mlir.constant(124 : i64) : i64
    %632 = llvm.getelementptr %381[0, %631] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %370, %632 : i32, !llvm.ptr
    %633 = llvm.mlir.constant(125 : i64) : i64
    %634 = llvm.getelementptr %381[0, %633] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %371, %634 : i32, !llvm.ptr
    %635 = llvm.mlir.constant(126 : i64) : i64
    %636 = llvm.getelementptr %381[0, %635] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %372, %636 : i32, !llvm.ptr
    %637 = llvm.mlir.constant(127 : i64) : i64
    %638 = llvm.getelementptr %381[0, %637] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %373, %638 : i32, !llvm.ptr
    %639 = llvm.mlir.constant(128 : i64) : i64
    %640 = llvm.getelementptr %381[0, %639] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %374, %640 : i32, !llvm.ptr
    %641 = llvm.mlir.constant(129 : i64) : i64
    %642 = llvm.getelementptr %381[0, %641] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %375, %642 : i32, !llvm.ptr
    %643 = llvm.mlir.constant(130 : i64) : i64
    %644 = llvm.getelementptr %381[0, %643] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %376, %644 : i32, !llvm.ptr
    %645 = llvm.mlir.constant(131 : i64) : i64
    %646 = llvm.getelementptr %381[0, %645] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %377, %646 : i32, !llvm.ptr
    %647 = llvm.mlir.constant(132 : i64) : i64
    %648 = llvm.getelementptr %381[0, %647] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %378, %648 : i32, !llvm.ptr
    %649 = llvm.mlir.constant(133 : i64) : i64
    %650 = llvm.getelementptr %381[0, %649] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %379, %650 : i32, !llvm.ptr
    %652 = arith.constant 0 : i32
    %653 = arith.constant 0 : i32
    %654 = arith.constant 0 : i32
    %655 = arith.constant 0 : i32
    %656 = arith.constant 0 : i32
    %657 = arith.constant 0 : i32
    %658 = arith.constant 0 : i32
    %659 = arith.constant 0 : i32
    %660 = arith.constant 0 : i32
    %661 = arith.constant 0 : i32
    %662 = arith.constant 0 : i32
    %663 = arith.constant 0 : i32
    %664 = arith.constant 0 : i32
    %665 = arith.constant 0 : i32
    %666 = arith.constant 0 : i32
    %667 = arith.constant 0 : i32
    %668 = arith.constant 0 : i32
    %669 = arith.constant 0 : i32
    %670 = arith.constant 0 : i32
    %671 = arith.constant 0 : i32
    %672 = arith.constant 0 : i32
    %673 = arith.constant 0 : i32
    %674 = arith.constant 0 : i32
    %675 = arith.constant 0 : i32
    %676 = arith.constant 0 : i32
    %677 = arith.constant 0 : i32
    %678 = arith.constant 0 : i32
    %679 = arith.constant 0 : i32
    %680 = arith.constant 0 : i32
    %681 = arith.constant 0 : i32
    %682 = arith.constant 0 : i32
    %683 = arith.constant 0 : i32
    %684 = arith.constant 0 : i32
    %685 = arith.constant 0 : i32
    %686 = arith.constant 0 : i32
    %687 = arith.constant 0 : i32
    %688 = arith.constant 0 : i32
    %689 = arith.constant 0 : i32
    %690 = arith.constant 0 : i32
    %691 = arith.constant 0 : i32
    %692 = arith.constant 0 : i32
    %693 = arith.constant 0 : i32
    %694 = arith.constant 0 : i32
    %695 = arith.constant 0 : i32
    %696 = arith.constant 0 : i32
    %697 = arith.constant 0 : i32
    %698 = arith.constant 0 : i32
    %699 = arith.constant 0 : i32
    %700 = arith.constant 0 : i32
    %701 = arith.constant 0 : i32
    %702 = arith.constant 0 : i32
    %703 = arith.constant 0 : i32
    %704 = arith.constant 0 : i32
    %705 = arith.constant 0 : i32
    %706 = arith.constant 0 : i32
    %707 = arith.constant 0 : i32
    %708 = arith.constant 0 : i32
    %709 = arith.constant 0 : i32
    %710 = arith.constant 0 : i32
    %711 = arith.constant 0 : i32
    %712 = arith.constant 0 : i32
    %713 = arith.constant 0 : i32
    %714 = arith.constant 0 : i32
    %715 = arith.constant 0 : i32
    %716 = arith.constant 0 : i32
    %717 = arith.constant 0 : i32
    %718 = arith.constant 0 : i32
    %719 = arith.constant 0 : i32
    %720 = arith.constant 0 : i32
    %721 = arith.constant 0 : i32
    %722 = arith.constant 0 : i32
    %723 = arith.constant 0 : i32
    %724 = arith.constant 0 : i32
    %725 = arith.constant 0 : i32
    %726 = arith.constant 0 : i32
    %727 = arith.constant 0 : i32
    %728 = arith.constant 0 : i32
    %729 = arith.constant 0 : i32
    %730 = arith.constant 0 : i32
    %731 = arith.constant 0 : i32
    %732 = arith.constant 0 : i32
    %733 = arith.constant 0 : i32
    %734 = arith.constant 0 : i32
    %735 = arith.constant 0 : i32
    %736 = arith.constant 0 : i32
    %737 = arith.constant 0 : i32
    %738 = arith.constant 0 : i32
    %739 = arith.constant 0 : i32
    %740 = arith.constant 0 : i32
    %741 = arith.constant 0 : i32
    %742 = arith.constant 0 : i32
    %743 = arith.constant 0 : i32
    %744 = arith.constant 0 : i32
    %745 = arith.constant 0 : i32
    %746 = arith.constant 0 : i32
    %747 = arith.constant 0 : i32
    %748 = arith.constant 0 : i32
    %749 = arith.constant 0 : i32
    %750 = arith.constant 0 : i32
    %751 = arith.constant 0 : i32
    %752 = arith.constant 0 : i32
    %753 = arith.constant 0 : i32
    %754 = arith.constant 0 : i32
    %755 = arith.constant 0 : i32
    %756 = arith.constant 0 : i32
    %757 = arith.constant 0 : i32
    %758 = arith.constant 0 : i32
    %759 = arith.constant 0 : i32
    %760 = arith.constant 0 : i32
    %761 = arith.constant 0 : i32
    %762 = arith.constant 0 : i32
    %763 = arith.constant 0 : i32
    %764 = arith.constant 0 : i32
    %765 = arith.constant 0 : i32
    %766 = arith.constant 0 : i32
    %767 = arith.constant 0 : i32
    %768 = arith.constant 0 : i32
    %769 = arith.constant 0 : i32
    %770 = arith.constant 0 : i32
    %771 = arith.constant 0 : i32
    %772 = arith.constant 0 : i32
    %773 = arith.constant 0 : i32
    %774 = arith.constant 0 : i32
    %775 = arith.constant 0 : i32
    %776 = arith.constant 0 : i32
    %777 = arith.constant 0 : i32
    %778 = arith.constant 0 : i32
    %779 = arith.constant 0 : i32
    %780 = arith.constant 0 : i32
    %781 = arith.constant 0 : i32
    %782 = arith.constant 0 : i32
    %783 = arith.constant 0 : i32
    %784 = arith.constant 0 : i32
    %785 = arith.constant 0 : i32
    %786 = arith.constant 0 : i32
    %787 = llvm.mlir.constant(1 : i64) : i64
    %788 = llvm.alloca %787 x !llvm.array<128 x i32> : (i64) -> !llvm.ptr
    %789 = llvm.mlir.zero : !llvm.array<128 x i32>
    llvm.store %789, %788 : !llvm.array<128 x i32>, !llvm.ptr
    %790 = llvm.mlir.constant(0 : i64) : i64
    %791 = llvm.getelementptr %788[0, %790] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %652, %791 : i32, !llvm.ptr
    %792 = llvm.mlir.constant(1 : i64) : i64
    %793 = llvm.getelementptr %788[0, %792] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %653, %793 : i32, !llvm.ptr
    %794 = llvm.mlir.constant(2 : i64) : i64
    %795 = llvm.getelementptr %788[0, %794] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %654, %795 : i32, !llvm.ptr
    %796 = llvm.mlir.constant(3 : i64) : i64
    %797 = llvm.getelementptr %788[0, %796] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %655, %797 : i32, !llvm.ptr
    %798 = llvm.mlir.constant(4 : i64) : i64
    %799 = llvm.getelementptr %788[0, %798] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %656, %799 : i32, !llvm.ptr
    %800 = llvm.mlir.constant(5 : i64) : i64
    %801 = llvm.getelementptr %788[0, %800] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %657, %801 : i32, !llvm.ptr
    %802 = llvm.mlir.constant(6 : i64) : i64
    %803 = llvm.getelementptr %788[0, %802] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %658, %803 : i32, !llvm.ptr
    %804 = llvm.mlir.constant(7 : i64) : i64
    %805 = llvm.getelementptr %788[0, %804] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %659, %805 : i32, !llvm.ptr
    %806 = llvm.mlir.constant(8 : i64) : i64
    %807 = llvm.getelementptr %788[0, %806] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %660, %807 : i32, !llvm.ptr
    %808 = llvm.mlir.constant(9 : i64) : i64
    %809 = llvm.getelementptr %788[0, %808] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %661, %809 : i32, !llvm.ptr
    %810 = llvm.mlir.constant(10 : i64) : i64
    %811 = llvm.getelementptr %788[0, %810] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %662, %811 : i32, !llvm.ptr
    %812 = llvm.mlir.constant(11 : i64) : i64
    %813 = llvm.getelementptr %788[0, %812] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %663, %813 : i32, !llvm.ptr
    %814 = llvm.mlir.constant(12 : i64) : i64
    %815 = llvm.getelementptr %788[0, %814] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %664, %815 : i32, !llvm.ptr
    %816 = llvm.mlir.constant(13 : i64) : i64
    %817 = llvm.getelementptr %788[0, %816] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %665, %817 : i32, !llvm.ptr
    %818 = llvm.mlir.constant(14 : i64) : i64
    %819 = llvm.getelementptr %788[0, %818] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %666, %819 : i32, !llvm.ptr
    %820 = llvm.mlir.constant(15 : i64) : i64
    %821 = llvm.getelementptr %788[0, %820] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %667, %821 : i32, !llvm.ptr
    %822 = llvm.mlir.constant(16 : i64) : i64
    %823 = llvm.getelementptr %788[0, %822] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %668, %823 : i32, !llvm.ptr
    %824 = llvm.mlir.constant(17 : i64) : i64
    %825 = llvm.getelementptr %788[0, %824] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %669, %825 : i32, !llvm.ptr
    %826 = llvm.mlir.constant(18 : i64) : i64
    %827 = llvm.getelementptr %788[0, %826] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %670, %827 : i32, !llvm.ptr
    %828 = llvm.mlir.constant(19 : i64) : i64
    %829 = llvm.getelementptr %788[0, %828] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %671, %829 : i32, !llvm.ptr
    %830 = llvm.mlir.constant(20 : i64) : i64
    %831 = llvm.getelementptr %788[0, %830] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %672, %831 : i32, !llvm.ptr
    %832 = llvm.mlir.constant(21 : i64) : i64
    %833 = llvm.getelementptr %788[0, %832] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %673, %833 : i32, !llvm.ptr
    %834 = llvm.mlir.constant(22 : i64) : i64
    %835 = llvm.getelementptr %788[0, %834] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %674, %835 : i32, !llvm.ptr
    %836 = llvm.mlir.constant(23 : i64) : i64
    %837 = llvm.getelementptr %788[0, %836] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %675, %837 : i32, !llvm.ptr
    %838 = llvm.mlir.constant(24 : i64) : i64
    %839 = llvm.getelementptr %788[0, %838] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %676, %839 : i32, !llvm.ptr
    %840 = llvm.mlir.constant(25 : i64) : i64
    %841 = llvm.getelementptr %788[0, %840] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %677, %841 : i32, !llvm.ptr
    %842 = llvm.mlir.constant(26 : i64) : i64
    %843 = llvm.getelementptr %788[0, %842] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %678, %843 : i32, !llvm.ptr
    %844 = llvm.mlir.constant(27 : i64) : i64
    %845 = llvm.getelementptr %788[0, %844] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %679, %845 : i32, !llvm.ptr
    %846 = llvm.mlir.constant(28 : i64) : i64
    %847 = llvm.getelementptr %788[0, %846] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %680, %847 : i32, !llvm.ptr
    %848 = llvm.mlir.constant(29 : i64) : i64
    %849 = llvm.getelementptr %788[0, %848] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %681, %849 : i32, !llvm.ptr
    %850 = llvm.mlir.constant(30 : i64) : i64
    %851 = llvm.getelementptr %788[0, %850] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %682, %851 : i32, !llvm.ptr
    %852 = llvm.mlir.constant(31 : i64) : i64
    %853 = llvm.getelementptr %788[0, %852] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %683, %853 : i32, !llvm.ptr
    %854 = llvm.mlir.constant(32 : i64) : i64
    %855 = llvm.getelementptr %788[0, %854] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %684, %855 : i32, !llvm.ptr
    %856 = llvm.mlir.constant(33 : i64) : i64
    %857 = llvm.getelementptr %788[0, %856] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %685, %857 : i32, !llvm.ptr
    %858 = llvm.mlir.constant(34 : i64) : i64
    %859 = llvm.getelementptr %788[0, %858] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %686, %859 : i32, !llvm.ptr
    %860 = llvm.mlir.constant(35 : i64) : i64
    %861 = llvm.getelementptr %788[0, %860] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %687, %861 : i32, !llvm.ptr
    %862 = llvm.mlir.constant(36 : i64) : i64
    %863 = llvm.getelementptr %788[0, %862] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %688, %863 : i32, !llvm.ptr
    %864 = llvm.mlir.constant(37 : i64) : i64
    %865 = llvm.getelementptr %788[0, %864] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %689, %865 : i32, !llvm.ptr
    %866 = llvm.mlir.constant(38 : i64) : i64
    %867 = llvm.getelementptr %788[0, %866] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %690, %867 : i32, !llvm.ptr
    %868 = llvm.mlir.constant(39 : i64) : i64
    %869 = llvm.getelementptr %788[0, %868] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %691, %869 : i32, !llvm.ptr
    %870 = llvm.mlir.constant(40 : i64) : i64
    %871 = llvm.getelementptr %788[0, %870] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %692, %871 : i32, !llvm.ptr
    %872 = llvm.mlir.constant(41 : i64) : i64
    %873 = llvm.getelementptr %788[0, %872] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %693, %873 : i32, !llvm.ptr
    %874 = llvm.mlir.constant(42 : i64) : i64
    %875 = llvm.getelementptr %788[0, %874] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %694, %875 : i32, !llvm.ptr
    %876 = llvm.mlir.constant(43 : i64) : i64
    %877 = llvm.getelementptr %788[0, %876] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %695, %877 : i32, !llvm.ptr
    %878 = llvm.mlir.constant(44 : i64) : i64
    %879 = llvm.getelementptr %788[0, %878] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %696, %879 : i32, !llvm.ptr
    %880 = llvm.mlir.constant(45 : i64) : i64
    %881 = llvm.getelementptr %788[0, %880] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %697, %881 : i32, !llvm.ptr
    %882 = llvm.mlir.constant(46 : i64) : i64
    %883 = llvm.getelementptr %788[0, %882] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %698, %883 : i32, !llvm.ptr
    %884 = llvm.mlir.constant(47 : i64) : i64
    %885 = llvm.getelementptr %788[0, %884] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %699, %885 : i32, !llvm.ptr
    %886 = llvm.mlir.constant(48 : i64) : i64
    %887 = llvm.getelementptr %788[0, %886] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %700, %887 : i32, !llvm.ptr
    %888 = llvm.mlir.constant(49 : i64) : i64
    %889 = llvm.getelementptr %788[0, %888] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %701, %889 : i32, !llvm.ptr
    %890 = llvm.mlir.constant(50 : i64) : i64
    %891 = llvm.getelementptr %788[0, %890] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %702, %891 : i32, !llvm.ptr
    %892 = llvm.mlir.constant(51 : i64) : i64
    %893 = llvm.getelementptr %788[0, %892] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %703, %893 : i32, !llvm.ptr
    %894 = llvm.mlir.constant(52 : i64) : i64
    %895 = llvm.getelementptr %788[0, %894] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %704, %895 : i32, !llvm.ptr
    %896 = llvm.mlir.constant(53 : i64) : i64
    %897 = llvm.getelementptr %788[0, %896] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %705, %897 : i32, !llvm.ptr
    %898 = llvm.mlir.constant(54 : i64) : i64
    %899 = llvm.getelementptr %788[0, %898] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %706, %899 : i32, !llvm.ptr
    %900 = llvm.mlir.constant(55 : i64) : i64
    %901 = llvm.getelementptr %788[0, %900] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %707, %901 : i32, !llvm.ptr
    %902 = llvm.mlir.constant(56 : i64) : i64
    %903 = llvm.getelementptr %788[0, %902] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %708, %903 : i32, !llvm.ptr
    %904 = llvm.mlir.constant(57 : i64) : i64
    %905 = llvm.getelementptr %788[0, %904] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %709, %905 : i32, !llvm.ptr
    %906 = llvm.mlir.constant(58 : i64) : i64
    %907 = llvm.getelementptr %788[0, %906] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %710, %907 : i32, !llvm.ptr
    %908 = llvm.mlir.constant(59 : i64) : i64
    %909 = llvm.getelementptr %788[0, %908] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %711, %909 : i32, !llvm.ptr
    %910 = llvm.mlir.constant(60 : i64) : i64
    %911 = llvm.getelementptr %788[0, %910] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %712, %911 : i32, !llvm.ptr
    %912 = llvm.mlir.constant(61 : i64) : i64
    %913 = llvm.getelementptr %788[0, %912] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %713, %913 : i32, !llvm.ptr
    %914 = llvm.mlir.constant(62 : i64) : i64
    %915 = llvm.getelementptr %788[0, %914] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %714, %915 : i32, !llvm.ptr
    %916 = llvm.mlir.constant(63 : i64) : i64
    %917 = llvm.getelementptr %788[0, %916] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %715, %917 : i32, !llvm.ptr
    %918 = llvm.mlir.constant(64 : i64) : i64
    %919 = llvm.getelementptr %788[0, %918] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %716, %919 : i32, !llvm.ptr
    %920 = llvm.mlir.constant(65 : i64) : i64
    %921 = llvm.getelementptr %788[0, %920] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %717, %921 : i32, !llvm.ptr
    %922 = llvm.mlir.constant(66 : i64) : i64
    %923 = llvm.getelementptr %788[0, %922] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %718, %923 : i32, !llvm.ptr
    %924 = llvm.mlir.constant(67 : i64) : i64
    %925 = llvm.getelementptr %788[0, %924] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %719, %925 : i32, !llvm.ptr
    %926 = llvm.mlir.constant(68 : i64) : i64
    %927 = llvm.getelementptr %788[0, %926] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %720, %927 : i32, !llvm.ptr
    %928 = llvm.mlir.constant(69 : i64) : i64
    %929 = llvm.getelementptr %788[0, %928] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %721, %929 : i32, !llvm.ptr
    %930 = llvm.mlir.constant(70 : i64) : i64
    %931 = llvm.getelementptr %788[0, %930] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %722, %931 : i32, !llvm.ptr
    %932 = llvm.mlir.constant(71 : i64) : i64
    %933 = llvm.getelementptr %788[0, %932] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %723, %933 : i32, !llvm.ptr
    %934 = llvm.mlir.constant(72 : i64) : i64
    %935 = llvm.getelementptr %788[0, %934] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %724, %935 : i32, !llvm.ptr
    %936 = llvm.mlir.constant(73 : i64) : i64
    %937 = llvm.getelementptr %788[0, %936] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %725, %937 : i32, !llvm.ptr
    %938 = llvm.mlir.constant(74 : i64) : i64
    %939 = llvm.getelementptr %788[0, %938] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %726, %939 : i32, !llvm.ptr
    %940 = llvm.mlir.constant(75 : i64) : i64
    %941 = llvm.getelementptr %788[0, %940] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %727, %941 : i32, !llvm.ptr
    %942 = llvm.mlir.constant(76 : i64) : i64
    %943 = llvm.getelementptr %788[0, %942] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %728, %943 : i32, !llvm.ptr
    %944 = llvm.mlir.constant(77 : i64) : i64
    %945 = llvm.getelementptr %788[0, %944] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %729, %945 : i32, !llvm.ptr
    %946 = llvm.mlir.constant(78 : i64) : i64
    %947 = llvm.getelementptr %788[0, %946] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %730, %947 : i32, !llvm.ptr
    %948 = llvm.mlir.constant(79 : i64) : i64
    %949 = llvm.getelementptr %788[0, %948] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %731, %949 : i32, !llvm.ptr
    %950 = llvm.mlir.constant(80 : i64) : i64
    %951 = llvm.getelementptr %788[0, %950] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %732, %951 : i32, !llvm.ptr
    %952 = llvm.mlir.constant(81 : i64) : i64
    %953 = llvm.getelementptr %788[0, %952] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %733, %953 : i32, !llvm.ptr
    %954 = llvm.mlir.constant(82 : i64) : i64
    %955 = llvm.getelementptr %788[0, %954] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %734, %955 : i32, !llvm.ptr
    %956 = llvm.mlir.constant(83 : i64) : i64
    %957 = llvm.getelementptr %788[0, %956] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %735, %957 : i32, !llvm.ptr
    %958 = llvm.mlir.constant(84 : i64) : i64
    %959 = llvm.getelementptr %788[0, %958] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %736, %959 : i32, !llvm.ptr
    %960 = llvm.mlir.constant(85 : i64) : i64
    %961 = llvm.getelementptr %788[0, %960] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %737, %961 : i32, !llvm.ptr
    %962 = llvm.mlir.constant(86 : i64) : i64
    %963 = llvm.getelementptr %788[0, %962] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %738, %963 : i32, !llvm.ptr
    %964 = llvm.mlir.constant(87 : i64) : i64
    %965 = llvm.getelementptr %788[0, %964] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %739, %965 : i32, !llvm.ptr
    %966 = llvm.mlir.constant(88 : i64) : i64
    %967 = llvm.getelementptr %788[0, %966] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %740, %967 : i32, !llvm.ptr
    %968 = llvm.mlir.constant(89 : i64) : i64
    %969 = llvm.getelementptr %788[0, %968] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %741, %969 : i32, !llvm.ptr
    %970 = llvm.mlir.constant(90 : i64) : i64
    %971 = llvm.getelementptr %788[0, %970] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %742, %971 : i32, !llvm.ptr
    %972 = llvm.mlir.constant(91 : i64) : i64
    %973 = llvm.getelementptr %788[0, %972] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %743, %973 : i32, !llvm.ptr
    %974 = llvm.mlir.constant(92 : i64) : i64
    %975 = llvm.getelementptr %788[0, %974] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %744, %975 : i32, !llvm.ptr
    %976 = llvm.mlir.constant(93 : i64) : i64
    %977 = llvm.getelementptr %788[0, %976] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %745, %977 : i32, !llvm.ptr
    %978 = llvm.mlir.constant(94 : i64) : i64
    %979 = llvm.getelementptr %788[0, %978] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %746, %979 : i32, !llvm.ptr
    %980 = llvm.mlir.constant(95 : i64) : i64
    %981 = llvm.getelementptr %788[0, %980] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %747, %981 : i32, !llvm.ptr
    %982 = llvm.mlir.constant(96 : i64) : i64
    %983 = llvm.getelementptr %788[0, %982] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %748, %983 : i32, !llvm.ptr
    %984 = llvm.mlir.constant(97 : i64) : i64
    %985 = llvm.getelementptr %788[0, %984] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %749, %985 : i32, !llvm.ptr
    %986 = llvm.mlir.constant(98 : i64) : i64
    %987 = llvm.getelementptr %788[0, %986] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %750, %987 : i32, !llvm.ptr
    %988 = llvm.mlir.constant(99 : i64) : i64
    %989 = llvm.getelementptr %788[0, %988] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %751, %989 : i32, !llvm.ptr
    %990 = llvm.mlir.constant(100 : i64) : i64
    %991 = llvm.getelementptr %788[0, %990] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %752, %991 : i32, !llvm.ptr
    %992 = llvm.mlir.constant(101 : i64) : i64
    %993 = llvm.getelementptr %788[0, %992] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %753, %993 : i32, !llvm.ptr
    %994 = llvm.mlir.constant(102 : i64) : i64
    %995 = llvm.getelementptr %788[0, %994] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %754, %995 : i32, !llvm.ptr
    %996 = llvm.mlir.constant(103 : i64) : i64
    %997 = llvm.getelementptr %788[0, %996] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %755, %997 : i32, !llvm.ptr
    %998 = llvm.mlir.constant(104 : i64) : i64
    %999 = llvm.getelementptr %788[0, %998] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %756, %999 : i32, !llvm.ptr
    %1000 = llvm.mlir.constant(105 : i64) : i64
    %1001 = llvm.getelementptr %788[0, %1000] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %757, %1001 : i32, !llvm.ptr
    %1002 = llvm.mlir.constant(106 : i64) : i64
    %1003 = llvm.getelementptr %788[0, %1002] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %758, %1003 : i32, !llvm.ptr
    %1004 = llvm.mlir.constant(107 : i64) : i64
    %1005 = llvm.getelementptr %788[0, %1004] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %759, %1005 : i32, !llvm.ptr
    %1006 = llvm.mlir.constant(108 : i64) : i64
    %1007 = llvm.getelementptr %788[0, %1006] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %760, %1007 : i32, !llvm.ptr
    %1008 = llvm.mlir.constant(109 : i64) : i64
    %1009 = llvm.getelementptr %788[0, %1008] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %761, %1009 : i32, !llvm.ptr
    %1010 = llvm.mlir.constant(110 : i64) : i64
    %1011 = llvm.getelementptr %788[0, %1010] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %762, %1011 : i32, !llvm.ptr
    %1012 = llvm.mlir.constant(111 : i64) : i64
    %1013 = llvm.getelementptr %788[0, %1012] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %763, %1013 : i32, !llvm.ptr
    %1014 = llvm.mlir.constant(112 : i64) : i64
    %1015 = llvm.getelementptr %788[0, %1014] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %764, %1015 : i32, !llvm.ptr
    %1016 = llvm.mlir.constant(113 : i64) : i64
    %1017 = llvm.getelementptr %788[0, %1016] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %765, %1017 : i32, !llvm.ptr
    %1018 = llvm.mlir.constant(114 : i64) : i64
    %1019 = llvm.getelementptr %788[0, %1018] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %766, %1019 : i32, !llvm.ptr
    %1020 = llvm.mlir.constant(115 : i64) : i64
    %1021 = llvm.getelementptr %788[0, %1020] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %767, %1021 : i32, !llvm.ptr
    %1022 = llvm.mlir.constant(116 : i64) : i64
    %1023 = llvm.getelementptr %788[0, %1022] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %768, %1023 : i32, !llvm.ptr
    %1024 = llvm.mlir.constant(117 : i64) : i64
    %1025 = llvm.getelementptr %788[0, %1024] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %769, %1025 : i32, !llvm.ptr
    %1026 = llvm.mlir.constant(118 : i64) : i64
    %1027 = llvm.getelementptr %788[0, %1026] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %770, %1027 : i32, !llvm.ptr
    %1028 = llvm.mlir.constant(119 : i64) : i64
    %1029 = llvm.getelementptr %788[0, %1028] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %771, %1029 : i32, !llvm.ptr
    %1030 = llvm.mlir.constant(120 : i64) : i64
    %1031 = llvm.getelementptr %788[0, %1030] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %772, %1031 : i32, !llvm.ptr
    %1032 = llvm.mlir.constant(121 : i64) : i64
    %1033 = llvm.getelementptr %788[0, %1032] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %773, %1033 : i32, !llvm.ptr
    %1034 = llvm.mlir.constant(122 : i64) : i64
    %1035 = llvm.getelementptr %788[0, %1034] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %774, %1035 : i32, !llvm.ptr
    %1036 = llvm.mlir.constant(123 : i64) : i64
    %1037 = llvm.getelementptr %788[0, %1036] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %775, %1037 : i32, !llvm.ptr
    %1038 = llvm.mlir.constant(124 : i64) : i64
    %1039 = llvm.getelementptr %788[0, %1038] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %776, %1039 : i32, !llvm.ptr
    %1040 = llvm.mlir.constant(125 : i64) : i64
    %1041 = llvm.getelementptr %788[0, %1040] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %777, %1041 : i32, !llvm.ptr
    %1042 = llvm.mlir.constant(126 : i64) : i64
    %1043 = llvm.getelementptr %788[0, %1042] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %778, %1043 : i32, !llvm.ptr
    %1044 = llvm.mlir.constant(127 : i64) : i64
    %1045 = llvm.getelementptr %788[0, %1044] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %779, %1045 : i32, !llvm.ptr
    %1046 = llvm.mlir.constant(128 : i64) : i64
    %1047 = llvm.getelementptr %788[0, %1046] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %780, %1047 : i32, !llvm.ptr
    %1048 = llvm.mlir.constant(129 : i64) : i64
    %1049 = llvm.getelementptr %788[0, %1048] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %781, %1049 : i32, !llvm.ptr
    %1050 = llvm.mlir.constant(130 : i64) : i64
    %1051 = llvm.getelementptr %788[0, %1050] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %782, %1051 : i32, !llvm.ptr
    %1052 = llvm.mlir.constant(131 : i64) : i64
    %1053 = llvm.getelementptr %788[0, %1052] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %783, %1053 : i32, !llvm.ptr
    %1054 = llvm.mlir.constant(132 : i64) : i64
    %1055 = llvm.getelementptr %788[0, %1054] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %784, %1055 : i32, !llvm.ptr
    %1056 = llvm.mlir.constant(133 : i64) : i64
    %1057 = llvm.getelementptr %788[0, %1056] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %785, %1057 : i32, !llvm.ptr
    %1058 = llvm.mlir.constant(134 : i64) : i64
    %1059 = llvm.getelementptr %788[0, %1058] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
    llvm.store %786, %1059 : i32, !llvm.ptr
    %1060 = arith.constant 0 : i32
    %1061 = llvm.mlir.constant(1 : i64) : i64
    %1062 = llvm.alloca %1061 x i32 : (i64) -> !llvm.ptr
    llvm.store %1060, %1062 : i32, !llvm.ptr
    %1063 = arith.constant 0 : i32
    %1064 = arith.extsi %1063 : i32 to i64
    %1065 = llvm.mlir.constant(1 : i64) : i64
    %1066 = llvm.alloca %1065 x i64 : (i64) -> !llvm.ptr
    llvm.store %1064, %1066 : i64, !llvm.ptr
    %1068 = arith.constant 7 : i32
    %1069 = arith.constant 1 : i32
    %1070 = arith.subi %arg0, %1069 : i32
    %1071 = arith.constant 2 : i32
    %1072 = arith.divsi %1070, %1071 : i32
    %1073 = arith.extsi %1072 : i32 to i64
    %1074 = arith.extsi %arg0 : i32 to i64
    %1075 = arith.extsi %1068 : i32 to i64
    %1067 = func.call @powmod(%1075, %1073, %1074) : (i64, i64, i64) -> i64
    %1076 = arith.constant 1 : i32
    %1078 = arith.extsi %1076 : i32 to i64
    %1077 = arith.cmpi eq, %1067, %1078 : i64
    cf.cond_br %1077, ^bb39, ^bb40
    ^bb39:
      %1079 = arith.constant 1 : i32
      %1080 = arith.subi %arg0, %1079 : i32
      %1081 = arith.extsi %1080 : i32 to i64
      llvm.store %1081, %1066 : i64, !llvm.ptr
      %1083 = arith.constant 1 : i32
      %1084 = arith.subi %arg0, %1083 : i32
      %1085 = arith.constant 0 : i32
      %1086 = arith.extsi %1085 : i32 to i64
      %1087 = llvm.getelementptr %381[0, %1086] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
      %1082 = func.call @unique_prime_factors(%1084, %1087) : (i32, !llvm.ptr) -> i32
      llvm.store %1082, %1062 : i32, !llvm.ptr
      cf.br ^bb41
    ^bb40:
      %1088 = arith.constant 1 : i32
      %1089 = arith.subi %arg0, %1088 : i32
      %1090 = arith.extsi %1089 : i32 to i64
      %1091 = arith.constant 1 : i32
      %1092 = arith.addi %arg0, %1091 : i32
      %1093 = arith.extsi %1092 : i32 to i64
      %1094 = arith.muli %1090, %1093 : i64
      llvm.store %1094, %1066 : i64, !llvm.ptr
      %1096 = arith.constant 1 : i32
      %1097 = arith.subi %arg0, %1096 : i32
      %1098 = arith.constant 0 : i32
      %1099 = arith.extsi %1098 : i32 to i64
      %1100 = llvm.getelementptr %381[0, %1099] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
      %1095 = func.call @unique_prime_factors(%1097, %1100) : (i32, !llvm.ptr) -> i32
      llvm.store %1095, %1062 : i32, !llvm.ptr
      %1102 = arith.constant 1 : i32
      %1103 = arith.addi %arg0, %1102 : i32
      %1104 = arith.constant 0 : i32
      %1105 = arith.extsi %1104 : i32 to i64
      %1106 = llvm.getelementptr %788[0, %1105] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
      %1101 = func.call @unique_prime_factors(%1103, %1106) : (i32, !llvm.ptr) -> i32
      %1107 = arith.constant 0 : i32
      %1108 = llvm.mlir.constant(1 : i64) : i64
      %1109 = llvm.alloca %1108 x i32 : (i64) -> !llvm.ptr
      llvm.store %1107, %1109 : i32, !llvm.ptr
      cf.br ^bb42
      ^bb42:
      %1110 = llvm.load %1109 : !llvm.ptr -> i32
      %1111 = arith.cmpi slt, %1110, %1101 : i32
      cf.cond_br %1111, ^bb43, ^bb44
      ^bb43:
        %1113 = llvm.load %1109 : !llvm.ptr -> i32
        %1114 = arith.extsi %1113 : i32 to i64
        %1115 = llvm.getelementptr %788[0, %1114] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
        %1112 = llvm.load %1115 : !llvm.ptr -> i32
        %1116 = llvm.load %1062 : !llvm.ptr -> i32
        %1117 = arith.extsi %1116 : i32 to i64
        %1118 = llvm.getelementptr %381[0, %1117] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
        llvm.store %1112, %1118 : i32, !llvm.ptr
        %1119 = llvm.load %1062 : !llvm.ptr -> i32
        %1120 = arith.constant 1 : i32
        %1121 = arith.addi %1119, %1120 : i32
        llvm.store %1121, %1062 : i32, !llvm.ptr
        %1122 = llvm.load %1109 : !llvm.ptr -> i32
        %1123 = arith.constant 1 : i32
        %1124 = arith.addi %1122, %1123 : i32
        llvm.store %1124, %1109 : i32, !llvm.ptr
        cf.br ^bb42
      ^bb44:
      cf.br ^bb41
    ^bb41:
    %1125 = arith.constant 0 : i32
    %1126 = llvm.mlir.constant(1 : i64) : i64
    %1127 = llvm.alloca %1126 x i32 : (i64) -> !llvm.ptr
    llvm.store %1125, %1127 : i32, !llvm.ptr
    cf.br ^bb45
    ^bb45:
    %1128 = llvm.load %1127 : !llvm.ptr -> i32
    %1129 = llvm.load %1062 : !llvm.ptr -> i32
    %1130 = arith.cmpi slt, %1128, %1129 : i32
    cf.cond_br %1130, ^bb46, ^bb47
    ^bb46:
      %1131 = llvm.load %1127 : !llvm.ptr -> i32
      %1132 = arith.constant 1 : i32
      %1133 = arith.addi %1131, %1132 : i32
      %1134 = llvm.mlir.constant(1 : i64) : i64
      %1135 = llvm.alloca %1134 x i32 : (i64) -> !llvm.ptr
      llvm.store %1133, %1135 : i32, !llvm.ptr
      cf.br ^bb48
      ^bb48:
      %1136 = llvm.load %1135 : !llvm.ptr -> i32
      %1137 = llvm.load %1062 : !llvm.ptr -> i32
      %1138 = arith.cmpi slt, %1136, %1137 : i32
      cf.cond_br %1138, ^bb49, ^bb50
      ^bb49:
        %1140 = llvm.load %1127 : !llvm.ptr -> i32
        %1141 = arith.extsi %1140 : i32 to i64
        %1142 = llvm.getelementptr %381[0, %1141] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
        %1139 = llvm.load %1142 : !llvm.ptr -> i32
        %1144 = llvm.load %1135 : !llvm.ptr -> i32
        %1145 = arith.extsi %1144 : i32 to i64
        %1146 = llvm.getelementptr %381[0, %1145] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
        %1143 = llvm.load %1146 : !llvm.ptr -> i32
        %1147 = arith.cmpi eq, %1139, %1143 : i32
        cf.cond_br %1147, ^bb51, ^bb52
        ^bb51:
          %1149 = llvm.load %1062 : !llvm.ptr -> i32
          %1150 = arith.constant 1 : i32
          %1151 = arith.subi %1149, %1150 : i32
          %1152 = arith.extsi %1151 : i32 to i64
          %1153 = llvm.getelementptr %381[0, %1152] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
          %1148 = llvm.load %1153 : !llvm.ptr -> i32
          %1154 = llvm.load %1135 : !llvm.ptr -> i32
          %1155 = arith.extsi %1154 : i32 to i64
          %1156 = llvm.getelementptr %381[0, %1155] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
          llvm.store %1148, %1156 : i32, !llvm.ptr
          %1157 = llvm.load %1062 : !llvm.ptr -> i32
          %1158 = arith.constant 1 : i32
          %1159 = arith.subi %1157, %1158 : i32
          llvm.store %1159, %1062 : i32, !llvm.ptr
          %1160 = llvm.load %1135 : !llvm.ptr -> i32
          %1161 = arith.constant 1 : i32
          %1162 = arith.subi %1160, %1161 : i32
          llvm.store %1162, %1135 : i32, !llvm.ptr
          cf.br ^bb53
        ^bb52:
          cf.br ^bb53
        ^bb53:
        %1163 = llvm.load %1135 : !llvm.ptr -> i32
        %1164 = arith.constant 1 : i32
        %1165 = arith.addi %1163, %1164 : i32
        llvm.store %1165, %1135 : i32, !llvm.ptr
        cf.br ^bb48
      ^bb50:
      %1166 = llvm.load %1127 : !llvm.ptr -> i32
      %1167 = arith.constant 1 : i32
      %1168 = arith.addi %1166, %1167 : i32
      llvm.store %1168, %1127 : i32, !llvm.ptr
      cf.br ^bb45
    ^bb47:
    %1170 = arith.constant 0 : i32
    %1171 = llvm.mlir.constant(1 : i64) : i64
    %1172 = llvm.alloca %1171 x !llvm.array<1 x i64> : (i64) -> !llvm.ptr
    %1173 = llvm.mlir.zero : !llvm.array<1 x i64>
    llvm.store %1173, %1172 : !llvm.array<1 x i64>, !llvm.ptr
    %1174 = arith.extsi %1170 : i32 to i64
    %1175 = llvm.mlir.constant(0 : i64) : i64
    %1176 = llvm.getelementptr %1172[0, %1175] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
    llvm.store %1174, %1176 : i64, !llvm.ptr
    %1178 = arith.constant 0 : i32
    %1179 = llvm.mlir.constant(1 : i64) : i64
    %1180 = llvm.alloca %1179 x !llvm.array<1 x i64> : (i64) -> !llvm.ptr
    %1181 = llvm.mlir.zero : !llvm.array<1 x i64>
    llvm.store %1181, %1180 : !llvm.array<1 x i64>, !llvm.ptr
    %1182 = arith.extsi %1178 : i32 to i64
    %1183 = llvm.mlir.constant(0 : i64) : i64
    %1184 = llvm.getelementptr %1180[0, %1183] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
    llvm.store %1182, %1184 : i64, !llvm.ptr
    %1185 = arith.constant 0 : i32
    %1186 = llvm.mlir.constant(1 : i64) : i64
    %1187 = llvm.alloca %1186 x i32 : (i64) -> !llvm.ptr
    llvm.store %1185, %1187 : i32, !llvm.ptr
    cf.br ^bb54
    ^bb54:
    %1188 = llvm.load %1187 : !llvm.ptr -> i32
    %1189 = llvm.load %1062 : !llvm.ptr -> i32
    %1190 = arith.cmpi slt, %1188, %1189 : i32
    cf.cond_br %1190, ^bb55, ^bb56
    ^bb55:
      %1192 = llvm.load %1187 : !llvm.ptr -> i32
      %1193 = arith.extsi %1192 : i32 to i64
      %1194 = llvm.getelementptr %381[0, %1193] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<128 x i32>
      %1191 = llvm.load %1194 : !llvm.ptr -> i32
      %1195 = arith.extsi %1191 : i32 to i64
      cf.br ^bb57
      ^bb57:
      %1196 = llvm.load %1066 : !llvm.ptr -> i64
      %1197 = arith.remsi %1196, %1195 : i64
      %1198 = arith.constant 0 : i32
      %1200 = arith.extsi %1198 : i32 to i64
      %1199 = arith.cmpi eq, %1197, %1200 : i64
      cf.cond_br %1199, ^bb58, ^bb59
      ^bb58:
        %1202 = llvm.load %1066 : !llvm.ptr -> i64
        %1203 = arith.divsi %1202, %1195 : i64
        %1204 = arith.extsi %arg0 : i32 to i64
        %1205 = arith.constant 0 : i32
        %1206 = arith.extsi %1205 : i32 to i64
        %1207 = llvm.getelementptr %1172[0, %1206] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        %1208 = arith.constant 0 : i32
        %1209 = arith.extsi %1208 : i32 to i64
        %1210 = llvm.getelementptr %1180[0, %1209] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        func.call @quadratic_power(%1203, %1204, %1207, %1210) : (i64, i64, !llvm.ptr, !llvm.ptr) -> ()
        %1212 = arith.constant 0 : i32
        %1213 = arith.extsi %1212 : i32 to i64
        %1214 = llvm.getelementptr %1172[0, %1213] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        %1211 = llvm.load %1214 : !llvm.ptr -> i64
        %1215 = arith.constant 1 : i32
        %1217 = arith.extsi %1215 : i32 to i64
        %1216 = arith.cmpi eq, %1211, %1217 : i64
        %1218 = scf.if %1216 -> (i1) {
          %1220 = arith.constant 0 : i32
          %1221 = arith.extsi %1220 : i32 to i64
          %1222 = llvm.getelementptr %1180[0, %1221] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
          %1219 = llvm.load %1222 : !llvm.ptr -> i64
          %1223 = arith.constant 0 : i32
          %1225 = arith.extsi %1223 : i32 to i64
          %1224 = arith.cmpi eq, %1219, %1225 : i64
          scf.yield %1224 : i1
        } else {
          %1226 = arith.constant false
          scf.yield %1226 : i1
        }
        cf.cond_br %1218, ^bb60, ^bb61
        ^bb60:
          %1227 = llvm.load %1066 : !llvm.ptr -> i64
          %1228 = arith.divsi %1227, %1195 : i64
          llvm.store %1228, %1066 : i64, !llvm.ptr
          cf.br ^bb62
        ^bb61:
          cf.br ^bb59
        ^bb62:
        cf.br ^bb57
      ^bb59:
      %1229 = llvm.load %1187 : !llvm.ptr -> i32
      %1230 = arith.constant 1 : i32
      %1231 = arith.addi %1229, %1230 : i32
      llvm.store %1231, %1187 : i32, !llvm.ptr
      cf.br ^bb54
    ^bb56:
    %1232 = llvm.load %1066 : !llvm.ptr -> i64
    func.return %1232 : i64
  }
  func.func @build_prime_power_orders(%arg0: i32) -> () {
    %1234 = arith.constant 1 : i32
    %1235 = arith.addi %arg0, %1234 : i32
    %1236 = arith.extsi %1235 : i32 to i64
    %1237 = arith.constant 8 : i32
    %1238 = arith.extsi %1237 : i32 to i64
    %1233 = func.call @calloc(%1236, %1238) : (i64, i64) -> !llvm.ptr
    %1239 = llvm.mlir.addressof @orders : !llvm.ptr
    llvm.store %1233, %1239 : !llvm.ptr, !llvm.ptr
    %1241 = arith.constant 0 : i32
    %1242 = llvm.mlir.constant(1 : i64) : i64
    %1243 = llvm.alloca %1242 x !llvm.array<1 x i64> : (i64) -> !llvm.ptr
    %1244 = llvm.mlir.zero : !llvm.array<1 x i64>
    llvm.store %1244, %1243 : !llvm.array<1 x i64>, !llvm.ptr
    %1245 = arith.extsi %1241 : i32 to i64
    %1246 = llvm.mlir.constant(0 : i64) : i64
    %1247 = llvm.getelementptr %1243[0, %1246] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
    llvm.store %1245, %1247 : i64, !llvm.ptr
    %1249 = arith.constant 0 : i32
    %1250 = llvm.mlir.constant(1 : i64) : i64
    %1251 = llvm.alloca %1250 x !llvm.array<1 x i64> : (i64) -> !llvm.ptr
    %1252 = llvm.mlir.zero : !llvm.array<1 x i64>
    llvm.store %1252, %1251 : !llvm.array<1 x i64>, !llvm.ptr
    %1253 = arith.extsi %1249 : i32 to i64
    %1254 = llvm.mlir.constant(0 : i64) : i64
    %1255 = llvm.getelementptr %1251[0, %1254] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
    llvm.store %1253, %1255 : i64, !llvm.ptr
    %1256 = arith.constant 0 : i32
    %1257 = llvm.mlir.constant(1 : i64) : i64
    %1258 = llvm.alloca %1257 x i32 : (i64) -> !llvm.ptr
    llvm.store %1256, %1258 : i32, !llvm.ptr
    cf.br ^bb63
    ^bb63:
    %1259 = llvm.load %1258 : !llvm.ptr -> i32
    %1260 = llvm.mlir.addressof @nprimes : !llvm.ptr
    %1261 = llvm.load %1260 : !llvm.ptr -> i32
    %1262 = arith.cmpi slt, %1259, %1261 : i32
    cf.cond_br %1262, ^bb64, ^bb65
    ^bb64:
      %1264 = llvm.mlir.addressof @primes : !llvm.ptr
      %1265 = llvm.load %1264 : !llvm.ptr -> !llvm.ptr
      %1266 = llvm.load %1258 : !llvm.ptr -> i32
      %1267 = arith.extsi %1266 : i32 to i64
      %1268 = llvm.getelementptr %1265[%1267] : (!llvm.ptr, i64) -> !llvm.ptr, i32
      %1263 = llvm.load %1268 : !llvm.ptr -> i32
      %1269 = arith.cmpi sgt, %1263, %arg0 : i32
      cf.cond_br %1269, ^bb66, ^bb67
      ^bb66:
        cf.br ^bb65
      ^bb67:
        cf.br ^bb68
      ^bb68:
      %1270 = arith.constant 5 : i32
      %1271 = arith.cmpi slt, %1263, %1270 : i32
      cf.cond_br %1271, ^bb69, ^bb70
      ^bb69:
        %1272 = llvm.load %1258 : !llvm.ptr -> i32
        %1273 = arith.constant 1 : i32
        %1274 = arith.addi %1272, %1273 : i32
        llvm.store %1274, %1258 : i32, !llvm.ptr
        cf.br ^bb63
      ^bb70:
        cf.br ^bb71
      ^bb71:
      %1275 = func.call @prime_order(%1263) : (i32) -> i64
      %1276 = arith.extsi %1263 : i32 to i64
      %1277 = llvm.mlir.constant(1 : i64) : i64
      %1278 = llvm.alloca %1277 x i64 : (i64) -> !llvm.ptr
      llvm.store %1276, %1278 : i64, !llvm.ptr
      %1279 = llvm.mlir.constant(1 : i64) : i64
      %1280 = llvm.alloca %1279 x i64 : (i64) -> !llvm.ptr
      llvm.store %1275, %1280 : i64, !llvm.ptr
      %1281 = llvm.load %1280 : !llvm.ptr -> i64
      %1282 = llvm.mlir.addressof @orders : !llvm.ptr
      %1283 = llvm.load %1282 : !llvm.ptr -> !llvm.ptr
      %1284 = llvm.load %1278 : !llvm.ptr -> i64
      %1285 = arith.trunci %1284 : i64 to i32
      %1286 = arith.extsi %1285 : i32 to i64
      %1287 = llvm.getelementptr %1283[%1286] : (!llvm.ptr, i64) -> !llvm.ptr, i64
      llvm.store %1281, %1287 : i64, !llvm.ptr
      cf.br ^bb72
      ^bb72:
      %1288 = llvm.load %1278 : !llvm.ptr -> i64
      %1289 = arith.extsi %1263 : i32 to i64
      %1290 = arith.muli %1288, %1289 : i64
      %1291 = arith.extsi %arg0 : i32 to i64
      %1292 = arith.cmpi sle, %1290, %1291 : i64
      cf.cond_br %1292, ^bb73, ^bb74
      ^bb73:
        %1293 = llvm.load %1278 : !llvm.ptr -> i64
        %1294 = arith.extsi %1263 : i32 to i64
        %1295 = arith.muli %1293, %1294 : i64
        llvm.store %1295, %1278 : i64, !llvm.ptr
        %1297 = llvm.load %1280 : !llvm.ptr -> i64
        %1298 = llvm.load %1278 : !llvm.ptr -> i64
        %1299 = arith.constant 0 : i32
        %1300 = arith.extsi %1299 : i32 to i64
        %1301 = llvm.getelementptr %1243[0, %1300] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        %1302 = arith.constant 0 : i32
        %1303 = arith.extsi %1302 : i32 to i64
        %1304 = llvm.getelementptr %1251[0, %1303] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        func.call @quadratic_power(%1297, %1298, %1301, %1304) : (i64, i64, !llvm.ptr, !llvm.ptr) -> ()
        %1306 = arith.constant 0 : i32
        %1307 = arith.extsi %1306 : i32 to i64
        %1308 = llvm.getelementptr %1243[0, %1307] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
        %1305 = llvm.load %1308 : !llvm.ptr -> i64
        %1309 = arith.constant 1 : i32
        %1311 = arith.extsi %1309 : i32 to i64
        %1310 = arith.cmpi eq, %1305, %1311 : i64
        %1312 = scf.if %1310 -> (i1) {
          %1314 = arith.constant 0 : i32
          %1315 = arith.extsi %1314 : i32 to i64
          %1316 = llvm.getelementptr %1251[0, %1315] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<1 x i64>
          %1313 = llvm.load %1316 : !llvm.ptr -> i64
          %1317 = arith.constant 0 : i32
          %1319 = arith.extsi %1317 : i32 to i64
          %1318 = arith.cmpi eq, %1313, %1319 : i64
          scf.yield %1318 : i1
        } else {
          %1320 = arith.constant false
          scf.yield %1320 : i1
        }
        %1322 = arith.constant 1 : i1
        %1321 = arith.xori %1312, %1322 : i1
        cf.cond_br %1321, ^bb75, ^bb76
        ^bb75:
          %1324 = llvm.load %1280 : !llvm.ptr -> i64
          %1325 = arith.extsi %1263 : i32 to i64
          %1326 = arith.muli %1324, %1325 : i64
          llvm.store %1326, %1280 : i64, !llvm.ptr
          cf.br ^bb77
        ^bb76:
          cf.br ^bb77
        ^bb77:
        %1327 = llvm.load %1280 : !llvm.ptr -> i64
        %1328 = llvm.mlir.addressof @orders : !llvm.ptr
        %1329 = llvm.load %1328 : !llvm.ptr -> !llvm.ptr
        %1330 = llvm.load %1278 : !llvm.ptr -> i64
        %1331 = arith.trunci %1330 : i64 to i32
        %1332 = arith.extsi %1331 : i32 to i64
        %1333 = llvm.getelementptr %1329[%1332] : (!llvm.ptr, i64) -> !llvm.ptr, i64
        llvm.store %1327, %1333 : i64, !llvm.ptr
        cf.br ^bb72
      ^bb74:
      %1334 = llvm.load %1258 : !llvm.ptr -> i32
      %1335 = arith.constant 1 : i32
      %1336 = arith.addi %1334, %1335 : i32
      llvm.store %1336, %1258 : i32, !llvm.ptr
      cf.br ^bb63
    ^bb65:
    func.return
  }
  func.func @G(%arg0: i32) -> i64 {
    %1338 = arith.constant 1 : i32
    %1339 = arith.addi %arg0, %1338 : i32
    func.call @smallest_prime_factors(%1339) : (i32) -> ()
    func.call @build_prime_power_orders(%arg0) : (i32) -> ()
    %1342 = arith.constant 1 : i32
    %1343 = arith.addi %arg0, %1342 : i32
    %1344 = arith.extsi %1343 : i32 to i64
    %1345 = arith.constant 8 : i32
    %1346 = arith.extsi %1345 : i32 to i64
    %1341 = func.call @calloc(%1344, %1346) : (i64, i64) -> !llvm.ptr
    %1347 = arith.constant 0 : i32
    %1348 = arith.extsi %1347 : i32 to i64
    %1349 = llvm.mlir.constant(1 : i64) : i64
    %1350 = llvm.alloca %1349 x i64 : (i64) -> !llvm.ptr
    llvm.store %1348, %1350 : i64, !llvm.ptr
    %1351 = arith.constant 2 : i32
    %1352 = llvm.mlir.constant(1 : i64) : i64
    %1353 = llvm.alloca %1352 x i32 : (i64) -> !llvm.ptr
    llvm.store %1351, %1353 : i32, !llvm.ptr
    cf.br ^bb78
    ^bb78:
    %1354 = llvm.load %1353 : !llvm.ptr -> i32
    %1355 = arith.cmpi sle, %1354, %arg0 : i32
    cf.cond_br %1355, ^bb79, ^bb80
    ^bb79:
      %1356 = llvm.load %1353 : !llvm.ptr -> i32
      %1357 = arith.constant 2 : i32
      %1358 = arith.remsi %1356, %1357 : i32
      %1359 = arith.constant 0 : i32
      %1360 = arith.cmpi eq, %1358, %1359 : i32
      %1361 = scf.if %1360 -> (i1) {
        %1362 = arith.constant true
        scf.yield %1362 : i1
      } else {
        %1363 = llvm.load %1353 : !llvm.ptr -> i32
        %1364 = arith.constant 3 : i32
        %1365 = arith.remsi %1363, %1364 : i32
        %1366 = arith.constant 0 : i32
        %1367 = arith.cmpi eq, %1365, %1366 : i32
        scf.yield %1367 : i1
      }
      cf.cond_br %1361, ^bb81, ^bb82
      ^bb81:
        %1368 = llvm.load %1353 : !llvm.ptr -> i32
        %1369 = arith.constant 1 : i32
        %1370 = arith.addi %1368, %1369 : i32
        llvm.store %1370, %1353 : i32, !llvm.ptr
        cf.br ^bb78
      ^bb82:
        cf.br ^bb83
      ^bb83:
      %1372 = llvm.mlir.addressof @spf : !llvm.ptr
      %1373 = llvm.load %1372 : !llvm.ptr -> !llvm.ptr
      %1374 = llvm.load %1353 : !llvm.ptr -> i32
      %1375 = arith.extsi %1374 : i32 to i64
      %1376 = llvm.getelementptr %1373[%1375] : (!llvm.ptr, i64) -> !llvm.ptr, i32
      %1371 = llvm.load %1376 : !llvm.ptr -> i32
      %1377 = llvm.load %1353 : !llvm.ptr -> i32
      %1378 = llvm.mlir.constant(1 : i64) : i64
      %1379 = llvm.alloca %1378 x i32 : (i64) -> !llvm.ptr
      llvm.store %1377, %1379 : i32, !llvm.ptr
      %1380 = arith.constant 1 : i32
      %1381 = arith.extsi %1380 : i32 to i64
      %1382 = llvm.mlir.constant(1 : i64) : i64
      %1383 = llvm.alloca %1382 x i64 : (i64) -> !llvm.ptr
      llvm.store %1381, %1383 : i64, !llvm.ptr
      cf.br ^bb84
      ^bb84:
      %1384 = llvm.load %1379 : !llvm.ptr -> i32
      %1385 = arith.remsi %1384, %1371 : i32
      %1386 = arith.constant 0 : i32
      %1387 = arith.cmpi eq, %1385, %1386 : i32
      cf.cond_br %1387, ^bb85, ^bb86
      ^bb85:
        %1388 = llvm.load %1379 : !llvm.ptr -> i32
        %1389 = arith.divsi %1388, %1371 : i32
        llvm.store %1389, %1379 : i32, !llvm.ptr
        %1390 = llvm.load %1383 : !llvm.ptr -> i64
        %1391 = arith.extsi %1371 : i32 to i64
        %1392 = arith.muli %1390, %1391 : i64
        llvm.store %1392, %1383 : i64, !llvm.ptr
        cf.br ^bb84
      ^bb86:
      %1393 = arith.constant 0 : i32
      %1394 = arith.extsi %1393 : i32 to i64
      %1395 = llvm.load %1379 : !llvm.ptr -> i32
      %1396 = arith.constant 1 : i32
      %1397 = arith.cmpi sgt, %1395, %1396 : i32
      %1398 = scf.if %1397 -> (i64) {
        %1400 = llvm.load %1379 : !llvm.ptr -> i32
        %1401 = arith.extsi %1400 : i32 to i64
        %1402 = llvm.getelementptr %1341[%1401] : (!llvm.ptr, i64) -> !llvm.ptr, i64
        %1399 = llvm.load %1402 : !llvm.ptr -> i64
        scf.yield %1399 : i64
      } else {
        %1403 = arith.constant 1 : i32
        %1404 = arith.extsi %1403 : i32 to i64
        scf.yield %1404 : i64
      }
      %1406 = llvm.mlir.addressof @orders : !llvm.ptr
      %1407 = llvm.load %1406 : !llvm.ptr -> !llvm.ptr
      %1408 = llvm.load %1383 : !llvm.ptr -> i64
      %1409 = arith.trunci %1408 : i64 to i32
      %1410 = arith.extsi %1409 : i32 to i64
      %1411 = llvm.getelementptr %1407[%1410] : (!llvm.ptr, i64) -> !llvm.ptr, i64
      %1405 = llvm.load %1411 : !llvm.ptr -> i64
      %1412 = func.call @llgcd(%1398, %1405) : (i64, i64) -> i64
      %1413 = arith.divsi %1398, %1412 : i64
      %1414 = arith.muli %1413, %1405 : i64
      %1415 = llvm.load %1353 : !llvm.ptr -> i32
      %1416 = arith.extsi %1415 : i32 to i64
      %1417 = llvm.getelementptr %1341[%1416] : (!llvm.ptr, i64) -> !llvm.ptr, i64
      llvm.store %1414, %1417 : i64, !llvm.ptr
      %1418 = llvm.load %1350 : !llvm.ptr -> i64
      %1419 = arith.addi %1418, %1414 : i64
      llvm.store %1419, %1350 : i64, !llvm.ptr
      %1420 = llvm.load %1353 : !llvm.ptr -> i32
      %1421 = arith.constant 1 : i32
      %1422 = arith.addi %1420, %1421 : i32
      llvm.store %1422, %1353 : i32, !llvm.ptr
      cf.br ^bb78
    ^bb80:
    func.call @free(%1341) : (!llvm.ptr) -> ()
    %1424 = llvm.load %1350 : !llvm.ptr -> i64
    func.return %1424 : i64
  }
  func.func @main() -> i32 {
    %1425 = llvm.mlir.addressof @str_0 : !llvm.ptr
    %1427 = arith.constant 1000000 : i32
    %1426 = func.call @G(%1427) : (i32) -> i64
    %1428 = llvm.call @printf(%1425, %1426) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
    %1429 = arith.constant 0 : i32
    func.return %1429 : i32
  }
}