Problem 396
Last 9 digits of sum_{n=1..15} G(n) for weak Goodstein sequences.
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n) | O(n) |
|---|
| Space complexity | O(n^2) | O(n) |
|---|
| Approach | Flow solution | Big-integer arithmetic |
|---|
| Verdict | Optimal |
|---|
Flow source
# Project Euler 396
# Last 9 digits of sum_{n=1..15} G(n) for weak Goodstein sequences.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
}
function modpow(base0: i64, exp0: i64, mod: i64) -> i64 {
if mod == 1 { return 0 }
let mut r: i64 = 1
let mut b: i64 = base0 % mod
let mut e: i64 = exp0
while e > 0 {
if (e & 1) == 1 { r = (r * b) % mod }
b = (b * b) % mod
e = e >> 1
}
return r
}
function f2_exact(x: i64) -> i64 {
let e: i64 = x + 1
return (x + 1) * (1 << e) - 1
}
function pow2_chain_level(a2: i64, b5: i64, m2: i64, m5: i64, phi5: i64, inv: i64,
mod: i64, next_res: i64, exact_x: i64, has_exact: i64) -> i64 {
if mod == 1 { return 0 }
let mut r2: i64 = 0
if a2 != 0 {
if has_exact == 1 && (exact_x + 1) < a2 {
r2 = 1 << (exact_x + 1)
} else {
r2 = 0
}
}
let mut r5: i64 = 0
if b5 != 0 {
let exp_mod: i64 = (next_res % phi5 + 1) % phi5
r5 = modpow(2, exp_mod, m5)
}
if a2 == 0 { return r5 }
if b5 == 0 { return r2 }
let mask: i64 = m2 - 1
let t: i64 = ((((r2 - r5) & mask) * inv) & mask)
return (r5 + m5 * t) % mod
}
function f2_iter_mod5(x0: i64, iters: i64,
mods: ptr<i64>, a2s: ptr<i64>, b5s: ptr<i64>,
m2s: ptr<i64>, m5s: ptr<i64>, phi5s: ptr<i64>, invs: ptr<i64>,
residues: ptr<i64>, new_res: ptr<i64>, clen: i64) -> i64 {
let mut i: i64 = 0
while i < clen {
residues[i] = x0 % mods[i]
i = i + 1
}
let mut has_exact: i64 = 0
let mut exact_x: i64 = 0
if x0 <= 20 {
has_exact = 1
exact_x = x0
}
let mut it: i64 = 0
while it < iters {
let mut exact_next: i64 = 0
let mut has_next: i64 = 0
if has_exact == 1 {
let en: i64 = f2_exact(exact_x)
if en <= 20 {
has_next = 1
exact_next = en
}
}
i = 0
while i < clen {
let m: i64 = mods[i]
if m == 1 {
new_res[i] = 0
} else {
let next_res: i64 = residues[i + 1]
let p2: i64 = pow2_chain_level(a2s[i], b5s[i], m2s[i], m5s[i], phi5s[i], invs[i],
m, next_res, exact_x, has_exact)
let mut val: i64 = (((residues[i] + 1) % m) * p2 - 1) % m
if val < 0 { val = val + m }
new_res[i] = val
}
i = i + 1
}
i = 0
while i < clen {
residues[i] = new_res[i]
i = i + 1
}
has_exact = has_next
exact_x = exact_next
it = it + 1
}
return residues[0]
}
function f2_iter_mod2(x0: i64, iters: i64) -> i64 {
let MOD2: i64 = 512
let mask: i64 = MOD2 - 1
let mut x_mod: i64 = x0 & mask
let mut has_exact: i64 = 0
let mut exact_x: i64 = 0
if x0 <= 20 {
has_exact = 1
exact_x = x0
}
let mut it: i64 = 0
while it < iters {
let mut p2: i64 = 0
if has_exact == 1 && (exact_x + 1) < 9 {
p2 = 1 << (exact_x + 1)
let en: i64 = f2_exact(exact_x)
if en <= 20 {
exact_x = en
} else {
has_exact = 0
}
} else {
p2 = 0
has_exact = 0
}
x_mod = (((x_mod + 1) & mask) * p2 - 1) & mask
it = it + 1
}
return x_mod
}
function crt_1e9(r2: i64, r5: i64) -> i64 {
let MOD: i64 = 1000000000
let MOD2: i64 = 512
let MOD5: i64 = 1953125
let INV: i64 = 1537323
let t: i64 = ((r5 - r2) % MOD5 + MOD5) % MOD5
t = (t * INV) % MOD5
return (r2 + MOD2 * t) % MOD
}
function main() -> i32 {
let MOD: i64 = 1000000000
let clen: i64 = 20
let mods: ptr<i64> = calloc(clen, 8)
let a2s: ptr<i64> = calloc(clen, 8)
let b5s: ptr<i64> = calloc(clen, 8)
let m2s: ptr<i64> = calloc(clen, 8)
let m5s: ptr<i64> = calloc(clen, 8)
let phi5s: ptr<i64> = calloc(clen, 8)
let invs: ptr<i64> = calloc(clen, 8)
let residues: ptr<i64> = calloc(clen, 8)
let new_res: ptr<i64> = calloc(clen, 8)
if mods == null || a2s == null || b5s == null || m2s == null || m5s == null { return 1 }
if phi5s == null || invs == null || residues == null || new_res == null { return 1 }
let mods_init: array<i64, 20> = [
1953125, 1562500, 625000, 250000, 100000, 40000, 16000, 6400, 2560, 1024,
512, 256, 128, 64, 32, 16, 8, 4, 2, 1
]
let a2_init: array<i64, 20> = [
0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
]
let b5_init: array<i64, 20> = [
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
let m2_init: array<i64, 20> = [
1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1
]
let m5_init: array<i64, 20> = [
1953125, 390625, 78125, 15625, 3125, 625, 125, 25, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
]
let phi5_init: array<i64, 20> = [
1562500, 312500, 62500, 12500, 2500, 500, 100, 20, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
]
let inv_init: array<i64, 20> = [
0, 1, 5, 9, 29, 17, 85, 41, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
let mut i: i64 = 0
while i < clen {
mods[i] = mods_init[i]
a2s[i] = a2_init[i]
b5s[i] = b5_init[i]
m2s[i] = m2_init[i]
m5s[i] = m5_init[i]
phi5s[i] = phi5_init[i]
invs[i] = inv_init[i]
i = i + 1
}
let a0: array<i64, 8> = [2, 3, 5, 7, 23, 63, 383, 2047]
let mut total: i64 = 0
let mut n: i64 = 1
while n < 16 {
let mut a_mod: i64 = 0
if n < 8 {
a_mod = a0[n]
} else {
let x0: i64 = a0[n - 8]
let iters: i64 = x0 + 1
let r5: i64 = f2_iter_mod5(x0, iters, mods, a2s, b5s, m2s, m5s, phi5s, invs, residues, new_res, clen)
let r2: i64 = f2_iter_mod2(x0, iters)
a_mod = crt_1e9(r2, r5)
}
let mut g: i64 = (a_mod - 2) % MOD
if g < 0 { g = g + MOD }
total = (total + g) % MOD
n = n + 1
}
printf("%lld\n", total)
free(new_res)
free(residues)
free(invs)
free(phi5s)
free(m5s)
free(m2s)
free(b5s)
free(a2s)
free(mods)
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; }
int64_t modpow_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod);
int64_t f2_exact_i64(int64_t x);
int64_t pow2_chain_level_i64_i64_i64_i64_i64_i64_i64_i64_i64_i64(int64_t a2, int64_t b5, int64_t m2, int64_t m5, int64_t phi5, int64_t inv, int64_t mod, int64_t next_res, int64_t exact_x, int64_t has_exact);
int64_t f2_iter_mod5_i64_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_i64(int64_t x0, int64_t iters, int64_t* mods, int64_t* a2s, int64_t* b5s, int64_t* m2s, int64_t* m5s, int64_t* phi5s, int64_t* invs, int64_t* residues, int64_t* new_res, int64_t clen);
int64_t f2_iter_mod2_i64_i64(int64_t x0, int64_t iters);
int64_t crt_1e9_i64_i64(int64_t r2, int64_t r5);
int32_t main(void);
int64_t modpow_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod) {
if (mod == 1) {
return 0;
}
int64_t r = 1;
int64_t b = FLOW_CHECKED_MOD((base0), (mod));
int64_t e = exp0;
while (e > 0) {
if ((e & 1) == 1) {
r = FLOW_CHECKED_MOD(((r * b)), (mod));
}
b = FLOW_CHECKED_MOD(((b * b)), (mod));
e = FLOW_CHECKED_SHR((e), (1));
}
return r;
}
int64_t f2_exact_i64(int64_t x) {
int64_t e = (x + 1);
return (((x + 1) * FLOW_CHECKED_SHL((1), (e))) - 1);
}
int64_t pow2_chain_level_i64_i64_i64_i64_i64_i64_i64_i64_i64_i64(int64_t a2, int64_t b5, int64_t m2, int64_t m5, int64_t phi5, int64_t inv, int64_t mod, int64_t next_res, int64_t exact_x, int64_t has_exact) {
if (mod == 1) {
return 0;
}
int64_t r2 = 0;
if (a2 != 0) {
if ((has_exact == 1 && (exact_x + 1) < a2)) {
r2 = FLOW_CHECKED_SHL((1), ((exact_x + 1)));
} else {
r2 = 0;
}
}
int64_t r5 = 0;
if (b5 != 0) {
int64_t exp_mod = FLOW_CHECKED_MOD(((FLOW_CHECKED_MOD((next_res), (phi5)) + 1)), (phi5));
r5 = modpow_i64_i64_i64(2, exp_mod, m5);
}
if (a2 == 0) {
return r5;
}
if (b5 == 0) {
return r2;
}
int64_t mask = (m2 - 1);
int64_t t = ((((r2 - r5) & mask) * inv) & mask);
return FLOW_CHECKED_MOD(((r5 + (m5 * t))), (mod));
}
int64_t f2_iter_mod5_i64_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_i64(int64_t x0, int64_t iters, int64_t* mods, int64_t* a2s, int64_t* b5s, int64_t* m2s, int64_t* m5s, int64_t* phi5s, int64_t* invs, int64_t* residues, int64_t* new_res, int64_t clen) {
int64_t i = 0;
while (i < clen) {
residues[i] = FLOW_CHECKED_MOD((x0), (mods[i]));
i = (i + 1);
}
int64_t has_exact = 0;
int64_t exact_x = 0;
if (x0 <= 20) {
has_exact = 1;
exact_x = x0;
}
int64_t it = 0;
while (it < iters) {
int64_t exact_next = 0;
int64_t has_next = 0;
if (has_exact == 1) {
int64_t en = f2_exact_i64(exact_x);
if (en <= 20) {
has_next = 1;
exact_next = en;
}
}
i = 0;
while (i < clen) {
int64_t m = mods[i];
if (m == 1) {
new_res[i] = 0;
} else {
int64_t next_res = residues[(i + 1)];
int64_t p2 = pow2_chain_level_i64_i64_i64_i64_i64_i64_i64_i64_i64_i64(a2s[i], b5s[i], m2s[i], m5s[i], phi5s[i], invs[i], m, next_res, exact_x, has_exact);
int64_t val = FLOW_CHECKED_MOD((((FLOW_CHECKED_MOD(((residues[i] + 1)), (m)) * p2) - 1)), (m));
if (val < 0) {
val = (val + m);
}
new_res[i] = val;
}
i = (i + 1);
}
i = 0;
while (i < clen) {
residues[i] = new_res[i];
i = (i + 1);
}
has_exact = has_next;
exact_x = exact_next;
it = (it + 1);
}
return residues[0];
}
int64_t f2_iter_mod2_i64_i64(int64_t x0, int64_t iters) {
int64_t MOD2 = 512;
int64_t mask = (MOD2 - 1);
int64_t x_mod = (x0 & mask);
int64_t has_exact = 0;
int64_t exact_x = 0;
if (x0 <= 20) {
has_exact = 1;
exact_x = x0;
}
int64_t it = 0;
while (it < iters) {
int64_t p2 = 0;
if ((has_exact == 1 && (exact_x + 1) < 9)) {
p2 = FLOW_CHECKED_SHL((1), ((exact_x + 1)));
int64_t en = f2_exact_i64(exact_x);
if (en <= 20) {
exact_x = en;
} else {
has_exact = 0;
}
} else {
p2 = 0;
has_exact = 0;
}
x_mod = (((((x_mod + 1) & mask) * p2) - 1) & mask);
it = (it + 1);
}
return x_mod;
}
int64_t crt_1e9_i64_i64(int64_t r2, int64_t r5) {
int64_t MOD = 1000000000;
int64_t MOD2 = 512;
int64_t MOD5 = 1953125;
int64_t INV = 1537323;
int64_t t = FLOW_CHECKED_MOD(((FLOW_CHECKED_MOD(((r5 - r2)), (MOD5)) + MOD5)), (MOD5));
t = FLOW_CHECKED_MOD(((t * INV)), (MOD5));
return FLOW_CHECKED_MOD(((r2 + (MOD2 * t))), (MOD));
}
int32_t main(void) {
int64_t MOD = 1000000000;
int64_t clen = 20;
int64_t* mods = (int64_t*)(calloc(clen, 8));
int64_t* a2s = (int64_t*)(calloc(clen, 8));
int64_t* b5s = (int64_t*)(calloc(clen, 8));
int64_t* m2s = (int64_t*)(calloc(clen, 8));
int64_t* m5s = (int64_t*)(calloc(clen, 8));
int64_t* phi5s = (int64_t*)(calloc(clen, 8));
int64_t* invs = (int64_t*)(calloc(clen, 8));
int64_t* residues = (int64_t*)(calloc(clen, 8));
int64_t* new_res = (int64_t*)(calloc(clen, 8));
if (((((mods == NULL || a2s == NULL) || b5s == NULL) || m2s == NULL) || m5s == NULL)) {
return 1;
}
if ((((phi5s == NULL || invs == NULL) || residues == NULL) || new_res == NULL)) {
return 1;
}
int64_t mods_init[20] = { 1953125, 1562500, 625000, 250000, 100000, 40000, 16000, 6400, 2560, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1 };
int64_t a2_init[20] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
int64_t b5_init[20] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int64_t m2_init[20] = { 1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1 };
int64_t m5_init[20] = { 1953125, 390625, 78125, 15625, 3125, 625, 125, 25, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
int64_t phi5_init[20] = { 1562500, 312500, 62500, 12500, 2500, 500, 100, 20, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
int64_t inv_init[20] = { 0, 1, 5, 9, 29, 17, 85, 41, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int64_t i = 0;
while (i < clen) {
mods[i] = (((unsigned)(i) < 20) ? mods_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), mods_init[0]));
a2s[i] = (((unsigned)(i) < 20) ? a2_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), a2_init[0]));
b5s[i] = (((unsigned)(i) < 20) ? b5_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), b5_init[0]));
m2s[i] = (((unsigned)(i) < 20) ? m2_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), m2_init[0]));
m5s[i] = (((unsigned)(i) < 20) ? m5_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), m5_init[0]));
phi5s[i] = (((unsigned)(i) < 20) ? phi5_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), phi5_init[0]));
invs[i] = (((unsigned)(i) < 20) ? inv_init[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 20), flow_fault_handler("array index out of bounds"), inv_init[0]));
i = (i + 1);
}
int64_t a0[8] = { 2, 3, 5, 7, 23, 63, 383, 2047 };
int64_t total = 0;
int64_t n = 1;
while (n < 16) {
int64_t a_mod = 0;
if (n < 8) {
a_mod = (((unsigned)(n) < 8) ? a0[n] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(n), 8), flow_fault_handler("array index out of bounds"), a0[0]));
} else {
int64_t x0 = (((unsigned)((n - 8)) < 8) ? a0[(n - 8)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)((n - 8)), 8), flow_fault_handler("array index out of bounds"), a0[0]));
int64_t iters = (x0 + 1);
int64_t r5 = f2_iter_mod5_i64_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_ptr_i64_i64(x0, iters, mods, a2s, b5s, m2s, m5s, phi5s, invs, residues, new_res, clen);
int64_t r2 = f2_iter_mod2_i64_i64(x0, iters);
a_mod = crt_1e9_i64_i64(r2, r5);
}
int64_t g = FLOW_CHECKED_MOD(((a_mod - 2)), (MOD));
if (g < 0) {
g = (g + MOD);
}
total = FLOW_CHECKED_MOD(((total + g)), (MOD));
n = (n + 1);
}
printf("%lld\n", total);
free(new_res);
free(residues);
free(invs);
free(phi5s);
free(m5s);
free(m2s);
free(b5s);
free(a2s);
free(mods);
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 @modpow(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%0 = arith.constant 1 : i32
%2 = arith.extsi %0 : i32 to i64
%1 = arith.cmpi eq, %arg2, %2 : i64
cf.cond_br %1, ^bb0, ^bb1
^bb0:
%3 = arith.constant 0 : i32
%4 = arith.extsi %3 : i32 to i64
func.return %4 : i64
^bb1:
cf.br ^bb2
^bb2:
%5 = arith.constant 1 : i32
%6 = arith.extsi %5 : i32 to i64
%7 = llvm.mlir.constant(1 : i64) : i64
%8 = llvm.alloca %7 x i64 : (i64) -> !llvm.ptr
llvm.store %6, %8 : i64, !llvm.ptr
%9 = arith.remsi %arg0, %arg2 : i64
%10 = llvm.mlir.constant(1 : i64) : i64
%11 = llvm.alloca %10 x i64 : (i64) -> !llvm.ptr
llvm.store %9, %11 : i64, !llvm.ptr
%12 = llvm.mlir.constant(1 : i64) : i64
%13 = llvm.alloca %12 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %13 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%14 = llvm.load %13 : !llvm.ptr -> i64
%15 = arith.constant 0 : i32
%17 = arith.extsi %15 : i32 to i64
%16 = arith.cmpi sgt, %14, %17 : i64
cf.cond_br %16, ^bb4, ^bb5
^bb4:
%18 = llvm.load %13 : !llvm.ptr -> i64
%19 = arith.constant 1 : i32
%21 = arith.extsi %19 : i32 to i64
%20 = arith.andi %18, %21 : i64
%22 = arith.constant 1 : i32
%24 = arith.extsi %22 : i32 to i64
%23 = arith.cmpi eq, %20, %24 : i64
cf.cond_br %23, ^bb6, ^bb7
^bb6:
%25 = llvm.load %8 : !llvm.ptr -> i64
%26 = llvm.load %11 : !llvm.ptr -> i64
%27 = arith.muli %25, %26 : i64
%28 = arith.remsi %27, %arg2 : i64
llvm.store %28, %8 : i64, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%29 = llvm.load %11 : !llvm.ptr -> i64
%30 = llvm.load %11 : !llvm.ptr -> i64
%31 = arith.muli %29, %30 : i64
%32 = arith.remsi %31, %arg2 : i64
llvm.store %32, %11 : i64, !llvm.ptr
%33 = llvm.load %13 : !llvm.ptr -> i64
%34 = arith.constant 1 : i32
%36 = arith.extsi %34 : i32 to i64
%35 = arith.shrsi %33, %36 : i64
llvm.store %35, %13 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
%37 = llvm.load %8 : !llvm.ptr -> i64
func.return %37 : i64
}
func.func @f2_exact(%arg0: i64) -> i64 {
%38 = arith.constant 1 : i32
%40 = arith.extsi %38 : i32 to i64
%39 = arith.addi %arg0, %40 : i64
%41 = arith.constant 1 : i32
%43 = arith.extsi %41 : i32 to i64
%42 = arith.addi %arg0, %43 : i64
%44 = arith.constant 1 : i32
%46 = arith.extsi %44 : i32 to i64
%45 = arith.shli %46, %39 : i64
%47 = arith.muli %42, %45 : i64
%48 = arith.constant 1 : i32
%50 = arith.extsi %48 : i32 to i64
%49 = arith.subi %47, %50 : i64
func.return %49 : i64
}
func.func @pow2_chain_level(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: i64, %arg8: i64, %arg9: i64) -> i64 {
%51 = arith.constant 1 : i32
%53 = arith.extsi %51 : i32 to i64
%52 = arith.cmpi eq, %arg6, %53 : i64
cf.cond_br %52, ^bb9, ^bb10
^bb9:
%54 = arith.constant 0 : i32
%55 = arith.extsi %54 : i32 to i64
func.return %55 : i64
^bb10:
cf.br ^bb11
^bb11:
%56 = arith.constant 0 : i32
%57 = arith.extsi %56 : i32 to i64
%58 = llvm.mlir.constant(1 : i64) : i64
%59 = llvm.alloca %58 x i64 : (i64) -> !llvm.ptr
llvm.store %57, %59 : i64, !llvm.ptr
%60 = arith.constant 0 : i32
%62 = arith.extsi %60 : i32 to i64
%61 = arith.cmpi ne, %arg0, %62 : i64
cf.cond_br %61, ^bb12, ^bb13
^bb12:
%63 = arith.constant 1 : i32
%65 = arith.extsi %63 : i32 to i64
%64 = arith.cmpi eq, %arg9, %65 : i64
%66 = scf.if %64 -> (i1) {
%67 = arith.constant 1 : i32
%69 = arith.extsi %67 : i32 to i64
%68 = arith.addi %arg8, %69 : i64
%70 = arith.cmpi slt, %68, %arg0 : i64
scf.yield %70 : i1
} else {
%71 = arith.constant false
scf.yield %71 : i1
}
cf.cond_br %66, ^bb15, ^bb16
^bb15:
%72 = arith.constant 1 : i32
%73 = arith.constant 1 : i32
%75 = arith.extsi %73 : i32 to i64
%74 = arith.addi %arg8, %75 : i64
%77 = arith.extsi %72 : i32 to i64
%76 = arith.shli %77, %74 : i64
llvm.store %76, %59 : i64, !llvm.ptr
cf.br ^bb17
^bb16:
%78 = arith.constant 0 : i32
%79 = arith.extsi %78 : i32 to i64
llvm.store %79, %59 : i64, !llvm.ptr
cf.br ^bb17
^bb17:
cf.br ^bb14
^bb13:
cf.br ^bb14
^bb14:
%80 = arith.constant 0 : i32
%81 = arith.extsi %80 : i32 to i64
%82 = llvm.mlir.constant(1 : i64) : i64
%83 = llvm.alloca %82 x i64 : (i64) -> !llvm.ptr
llvm.store %81, %83 : i64, !llvm.ptr
%84 = arith.constant 0 : i32
%86 = arith.extsi %84 : i32 to i64
%85 = arith.cmpi ne, %arg1, %86 : i64
cf.cond_br %85, ^bb18, ^bb19
^bb18:
%87 = arith.remsi %arg7, %arg4 : i64
%88 = arith.constant 1 : i32
%90 = arith.extsi %88 : i32 to i64
%89 = arith.addi %87, %90 : i64
%91 = arith.remsi %89, %arg4 : i64
%93 = arith.constant 2 : i32
%94 = arith.extsi %93 : i32 to i64
%92 = func.call @modpow(%94, %91, %arg3) : (i64, i64, i64) -> i64
llvm.store %92, %83 : i64, !llvm.ptr
cf.br ^bb20
^bb19:
cf.br ^bb20
^bb20:
%95 = arith.constant 0 : i32
%97 = arith.extsi %95 : i32 to i64
%96 = arith.cmpi eq, %arg0, %97 : i64
cf.cond_br %96, ^bb21, ^bb22
^bb21:
%98 = llvm.load %83 : !llvm.ptr -> i64
func.return %98 : i64
^bb22:
cf.br ^bb23
^bb23:
%99 = arith.constant 0 : i32
%101 = arith.extsi %99 : i32 to i64
%100 = arith.cmpi eq, %arg1, %101 : i64
cf.cond_br %100, ^bb24, ^bb25
^bb24:
%102 = llvm.load %59 : !llvm.ptr -> i64
func.return %102 : i64
^bb25:
cf.br ^bb26
^bb26:
%103 = arith.constant 1 : i32
%105 = arith.extsi %103 : i32 to i64
%104 = arith.subi %arg2, %105 : i64
%106 = llvm.load %59 : !llvm.ptr -> i64
%107 = llvm.load %83 : !llvm.ptr -> i64
%108 = arith.subi %106, %107 : i64
%109 = arith.andi %108, %104 : i64
%110 = arith.muli %109, %arg5 : i64
%111 = arith.andi %110, %104 : i64
%112 = llvm.load %83 : !llvm.ptr -> i64
%113 = arith.muli %arg3, %111 : i64
%114 = arith.addi %112, %113 : i64
%115 = arith.remsi %114, %arg6 : i64
func.return %115 : i64
}
func.func @f2_iter_mod5(%arg0: i64, %arg1: i64, %arg2: !llvm.ptr, %arg3: !llvm.ptr, %arg4: !llvm.ptr, %arg5: !llvm.ptr, %arg6: !llvm.ptr, %arg7: !llvm.ptr, %arg8: !llvm.ptr, %arg9: !llvm.ptr, %arg10: !llvm.ptr, %arg11: i64) -> i64 {
%116 = arith.constant 0 : 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
cf.br ^bb27
^bb27:
%120 = llvm.load %119 : !llvm.ptr -> i64
%121 = arith.cmpi slt, %120, %arg11 : i64
cf.cond_br %121, ^bb28, ^bb29
^bb28:
%123 = llvm.load %119 : !llvm.ptr -> i64
%124 = llvm.getelementptr %arg2[%123] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%122 = llvm.load %124 : !llvm.ptr -> i64
%125 = arith.remsi %arg0, %122 : i64
%126 = llvm.load %119 : !llvm.ptr -> i64
%127 = llvm.getelementptr %arg9[%126] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %125, %127 : i64, !llvm.ptr
%128 = llvm.load %119 : !llvm.ptr -> i64
%129 = arith.constant 1 : i32
%131 = arith.extsi %129 : i32 to i64
%130 = arith.addi %128, %131 : i64
llvm.store %130, %119 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
%132 = arith.constant 0 : i32
%133 = arith.extsi %132 : i32 to i64
%134 = llvm.mlir.constant(1 : i64) : i64
%135 = llvm.alloca %134 x i64 : (i64) -> !llvm.ptr
llvm.store %133, %135 : i64, !llvm.ptr
%136 = arith.constant 0 : i32
%137 = arith.extsi %136 : i32 to i64
%138 = llvm.mlir.constant(1 : i64) : i64
%139 = llvm.alloca %138 x i64 : (i64) -> !llvm.ptr
llvm.store %137, %139 : i64, !llvm.ptr
%140 = arith.constant 20 : i32
%142 = arith.extsi %140 : i32 to i64
%141 = arith.cmpi sle, %arg0, %142 : i64
cf.cond_br %141, ^bb30, ^bb31
^bb30:
%143 = arith.constant 1 : i32
%144 = arith.extsi %143 : i32 to i64
llvm.store %144, %135 : i64, !llvm.ptr
llvm.store %arg0, %139 : i64, !llvm.ptr
cf.br ^bb32
^bb31:
cf.br ^bb32
^bb32:
%145 = arith.constant 0 : i32
%146 = arith.extsi %145 : i32 to i64
%147 = llvm.mlir.constant(1 : i64) : i64
%148 = llvm.alloca %147 x i64 : (i64) -> !llvm.ptr
llvm.store %146, %148 : i64, !llvm.ptr
cf.br ^bb33
^bb33:
%149 = llvm.load %148 : !llvm.ptr -> i64
%150 = arith.cmpi slt, %149, %arg1 : i64
cf.cond_br %150, ^bb34, ^bb35
^bb34:
%151 = arith.constant 0 : i32
%152 = arith.extsi %151 : i32 to i64
%153 = llvm.mlir.constant(1 : i64) : i64
%154 = llvm.alloca %153 x i64 : (i64) -> !llvm.ptr
llvm.store %152, %154 : i64, !llvm.ptr
%155 = arith.constant 0 : i32
%156 = arith.extsi %155 : i32 to i64
%157 = llvm.mlir.constant(1 : i64) : i64
%158 = llvm.alloca %157 x i64 : (i64) -> !llvm.ptr
llvm.store %156, %158 : i64, !llvm.ptr
%159 = llvm.load %135 : !llvm.ptr -> i64
%160 = arith.constant 1 : i32
%162 = arith.extsi %160 : i32 to i64
%161 = arith.cmpi eq, %159, %162 : i64
cf.cond_br %161, ^bb36, ^bb37
^bb36:
%164 = llvm.load %139 : !llvm.ptr -> i64
%163 = func.call @f2_exact(%164) : (i64) -> i64
%165 = arith.constant 20 : i32
%167 = arith.extsi %165 : i32 to i64
%166 = arith.cmpi sle, %163, %167 : i64
cf.cond_br %166, ^bb39, ^bb40
^bb39:
%168 = arith.constant 1 : i32
%169 = arith.extsi %168 : i32 to i64
llvm.store %169, %158 : i64, !llvm.ptr
llvm.store %163, %154 : i64, !llvm.ptr
cf.br ^bb41
^bb40:
cf.br ^bb41
^bb41:
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
%170 = arith.constant 0 : i32
%171 = arith.extsi %170 : i32 to i64
llvm.store %171, %119 : i64, !llvm.ptr
cf.br ^bb42
^bb42:
%172 = llvm.load %119 : !llvm.ptr -> i64
%173 = arith.cmpi slt, %172, %arg11 : i64
cf.cond_br %173, ^bb43, ^bb44
^bb43:
%175 = llvm.load %119 : !llvm.ptr -> i64
%176 = llvm.getelementptr %arg2[%175] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%174 = llvm.load %176 : !llvm.ptr -> i64
%177 = arith.constant 1 : i32
%179 = arith.extsi %177 : i32 to i64
%178 = arith.cmpi eq, %174, %179 : i64
cf.cond_br %178, ^bb45, ^bb46
^bb45:
%180 = arith.constant 0 : i32
%181 = llvm.load %119 : !llvm.ptr -> i64
%182 = arith.extsi %180 : i32 to i64
%183 = llvm.getelementptr %arg10[%181] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %182, %183 : i64, !llvm.ptr
cf.br ^bb47
^bb46:
%185 = llvm.load %119 : !llvm.ptr -> i64
%186 = arith.constant 1 : i32
%188 = arith.extsi %186 : i32 to i64
%187 = arith.addi %185, %188 : i64
%189 = llvm.getelementptr %arg9[%187] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%184 = llvm.load %189 : !llvm.ptr -> i64
%192 = llvm.load %119 : !llvm.ptr -> i64
%193 = llvm.getelementptr %arg3[%192] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%191 = llvm.load %193 : !llvm.ptr -> i64
%195 = llvm.load %119 : !llvm.ptr -> i64
%196 = llvm.getelementptr %arg4[%195] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%194 = llvm.load %196 : !llvm.ptr -> i64
%198 = llvm.load %119 : !llvm.ptr -> i64
%199 = llvm.getelementptr %arg5[%198] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%197 = llvm.load %199 : !llvm.ptr -> i64
%201 = llvm.load %119 : !llvm.ptr -> i64
%202 = llvm.getelementptr %arg6[%201] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%200 = llvm.load %202 : !llvm.ptr -> i64
%204 = llvm.load %119 : !llvm.ptr -> i64
%205 = llvm.getelementptr %arg7[%204] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%203 = llvm.load %205 : !llvm.ptr -> i64
%207 = llvm.load %119 : !llvm.ptr -> i64
%208 = llvm.getelementptr %arg8[%207] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%206 = llvm.load %208 : !llvm.ptr -> i64
%209 = llvm.load %139 : !llvm.ptr -> i64
%210 = llvm.load %135 : !llvm.ptr -> i64
%190 = func.call @pow2_chain_level(%191, %194, %197, %200, %203, %206, %174, %184, %209, %210) : (i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64
%212 = llvm.load %119 : !llvm.ptr -> i64
%213 = llvm.getelementptr %arg9[%212] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%211 = llvm.load %213 : !llvm.ptr -> i64
%214 = arith.constant 1 : i32
%216 = arith.extsi %214 : i32 to i64
%215 = arith.addi %211, %216 : i64
%217 = arith.remsi %215, %174 : i64
%218 = arith.muli %217, %190 : i64
%219 = arith.constant 1 : i32
%221 = arith.extsi %219 : i32 to i64
%220 = arith.subi %218, %221 : i64
%222 = arith.remsi %220, %174 : i64
%223 = llvm.mlir.constant(1 : i64) : i64
%224 = llvm.alloca %223 x i64 : (i64) -> !llvm.ptr
llvm.store %222, %224 : i64, !llvm.ptr
%225 = llvm.load %224 : !llvm.ptr -> i64
%226 = arith.constant 0 : i32
%228 = arith.extsi %226 : i32 to i64
%227 = arith.cmpi slt, %225, %228 : i64
cf.cond_br %227, ^bb48, ^bb49
^bb48:
%229 = llvm.load %224 : !llvm.ptr -> i64
%230 = arith.addi %229, %174 : i64
llvm.store %230, %224 : i64, !llvm.ptr
cf.br ^bb50
^bb49:
cf.br ^bb50
^bb50:
%231 = llvm.load %224 : !llvm.ptr -> i64
%232 = llvm.load %119 : !llvm.ptr -> i64
%233 = llvm.getelementptr %arg10[%232] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %231, %233 : i64, !llvm.ptr
cf.br ^bb47
^bb47:
%234 = llvm.load %119 : !llvm.ptr -> i64
%235 = arith.constant 1 : i32
%237 = arith.extsi %235 : i32 to i64
%236 = arith.addi %234, %237 : i64
llvm.store %236, %119 : i64, !llvm.ptr
cf.br ^bb42
^bb44:
%238 = arith.constant 0 : i32
%239 = arith.extsi %238 : i32 to i64
llvm.store %239, %119 : i64, !llvm.ptr
cf.br ^bb51
^bb51:
%240 = llvm.load %119 : !llvm.ptr -> i64
%241 = arith.cmpi slt, %240, %arg11 : i64
cf.cond_br %241, ^bb52, ^bb53
^bb52:
%243 = llvm.load %119 : !llvm.ptr -> i64
%244 = llvm.getelementptr %arg10[%243] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%242 = llvm.load %244 : !llvm.ptr -> i64
%245 = llvm.load %119 : !llvm.ptr -> i64
%246 = llvm.getelementptr %arg9[%245] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %242, %246 : i64, !llvm.ptr
%247 = llvm.load %119 : !llvm.ptr -> i64
%248 = arith.constant 1 : i32
%250 = arith.extsi %248 : i32 to i64
%249 = arith.addi %247, %250 : i64
llvm.store %249, %119 : i64, !llvm.ptr
cf.br ^bb51
^bb53:
%251 = llvm.load %158 : !llvm.ptr -> i64
llvm.store %251, %135 : i64, !llvm.ptr
%252 = llvm.load %154 : !llvm.ptr -> i64
llvm.store %252, %139 : i64, !llvm.ptr
%253 = llvm.load %148 : !llvm.ptr -> i64
%254 = arith.constant 1 : i32
%256 = arith.extsi %254 : i32 to i64
%255 = arith.addi %253, %256 : i64
llvm.store %255, %148 : i64, !llvm.ptr
cf.br ^bb33
^bb35:
%258 = arith.constant 0 : i32
%259 = arith.extsi %258 : i32 to i64
%260 = llvm.getelementptr %arg9[%259] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%257 = llvm.load %260 : !llvm.ptr -> i64
func.return %257 : i64
}
func.func @f2_iter_mod2(%arg0: i64, %arg1: i64) -> i64 {
%261 = arith.constant 512 : i32
%262 = arith.extsi %261 : i32 to i64
%263 = arith.constant 1 : i32
%265 = arith.extsi %263 : i32 to i64
%264 = arith.subi %262, %265 : i64
%266 = arith.andi %arg0, %264 : i64
%267 = llvm.mlir.constant(1 : i64) : i64
%268 = llvm.alloca %267 x i64 : (i64) -> !llvm.ptr
llvm.store %266, %268 : i64, !llvm.ptr
%269 = arith.constant 0 : i32
%270 = arith.extsi %269 : i32 to i64
%271 = llvm.mlir.constant(1 : i64) : i64
%272 = llvm.alloca %271 x i64 : (i64) -> !llvm.ptr
llvm.store %270, %272 : i64, !llvm.ptr
%273 = arith.constant 0 : i32
%274 = arith.extsi %273 : i32 to i64
%275 = llvm.mlir.constant(1 : i64) : i64
%276 = llvm.alloca %275 x i64 : (i64) -> !llvm.ptr
llvm.store %274, %276 : i64, !llvm.ptr
%277 = arith.constant 20 : i32
%279 = arith.extsi %277 : i32 to i64
%278 = arith.cmpi sle, %arg0, %279 : i64
cf.cond_br %278, ^bb54, ^bb55
^bb54:
%280 = arith.constant 1 : i32
%281 = arith.extsi %280 : i32 to i64
llvm.store %281, %272 : i64, !llvm.ptr
llvm.store %arg0, %276 : i64, !llvm.ptr
cf.br ^bb56
^bb55:
cf.br ^bb56
^bb56:
%282 = arith.constant 0 : i32
%283 = arith.extsi %282 : i32 to i64
%284 = llvm.mlir.constant(1 : i64) : i64
%285 = llvm.alloca %284 x i64 : (i64) -> !llvm.ptr
llvm.store %283, %285 : i64, !llvm.ptr
cf.br ^bb57
^bb57:
%286 = llvm.load %285 : !llvm.ptr -> i64
%287 = arith.cmpi slt, %286, %arg1 : i64
cf.cond_br %287, ^bb58, ^bb59
^bb58:
%288 = arith.constant 0 : i32
%289 = arith.extsi %288 : i32 to i64
%290 = llvm.mlir.constant(1 : i64) : i64
%291 = llvm.alloca %290 x i64 : (i64) -> !llvm.ptr
llvm.store %289, %291 : i64, !llvm.ptr
%292 = llvm.load %272 : !llvm.ptr -> i64
%293 = arith.constant 1 : i32
%295 = arith.extsi %293 : i32 to i64
%294 = arith.cmpi eq, %292, %295 : i64
%296 = scf.if %294 -> (i1) {
%297 = llvm.load %276 : !llvm.ptr -> i64
%298 = arith.constant 1 : i32
%300 = arith.extsi %298 : i32 to i64
%299 = arith.addi %297, %300 : i64
%301 = arith.constant 9 : i32
%303 = arith.extsi %301 : i32 to i64
%302 = arith.cmpi slt, %299, %303 : i64
scf.yield %302 : i1
} else {
%304 = arith.constant false
scf.yield %304 : i1
}
cf.cond_br %296, ^bb60, ^bb61
^bb60:
%305 = arith.constant 1 : i32
%306 = llvm.load %276 : !llvm.ptr -> i64
%307 = arith.constant 1 : i32
%309 = arith.extsi %307 : i32 to i64
%308 = arith.addi %306, %309 : i64
%311 = arith.extsi %305 : i32 to i64
%310 = arith.shli %311, %308 : i64
llvm.store %310, %291 : i64, !llvm.ptr
%313 = llvm.load %276 : !llvm.ptr -> i64
%312 = func.call @f2_exact(%313) : (i64) -> i64
%314 = arith.constant 20 : i32
%316 = arith.extsi %314 : i32 to i64
%315 = arith.cmpi sle, %312, %316 : i64
cf.cond_br %315, ^bb63, ^bb64
^bb63:
llvm.store %312, %276 : i64, !llvm.ptr
cf.br ^bb65
^bb64:
%317 = arith.constant 0 : i32
%318 = arith.extsi %317 : i32 to i64
llvm.store %318, %272 : i64, !llvm.ptr
cf.br ^bb65
^bb65:
cf.br ^bb62
^bb61:
%319 = arith.constant 0 : i32
%320 = arith.extsi %319 : i32 to i64
llvm.store %320, %291 : i64, !llvm.ptr
%321 = arith.constant 0 : i32
%322 = arith.extsi %321 : i32 to i64
llvm.store %322, %272 : i64, !llvm.ptr
cf.br ^bb62
^bb62:
%323 = llvm.load %268 : !llvm.ptr -> i64
%324 = arith.constant 1 : i32
%326 = arith.extsi %324 : i32 to i64
%325 = arith.addi %323, %326 : i64
%327 = arith.andi %325, %264 : i64
%328 = llvm.load %291 : !llvm.ptr -> i64
%329 = arith.muli %327, %328 : i64
%330 = arith.constant 1 : i32
%332 = arith.extsi %330 : i32 to i64
%331 = arith.subi %329, %332 : i64
%333 = arith.andi %331, %264 : i64
llvm.store %333, %268 : i64, !llvm.ptr
%334 = llvm.load %285 : !llvm.ptr -> i64
%335 = arith.constant 1 : i32
%337 = arith.extsi %335 : i32 to i64
%336 = arith.addi %334, %337 : i64
llvm.store %336, %285 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
%338 = llvm.load %268 : !llvm.ptr -> i64
func.return %338 : i64
}
func.func @crt_1e9(%arg0: i64, %arg1: i64) -> i64 {
%339 = arith.constant 1000000000 : i32
%340 = arith.extsi %339 : i32 to i64
%341 = arith.constant 512 : i32
%342 = arith.extsi %341 : i32 to i64
%343 = arith.constant 1953125 : i32
%344 = arith.extsi %343 : i32 to i64
%345 = arith.constant 1537323 : i32
%346 = arith.extsi %345 : i32 to i64
%347 = arith.subi %arg1, %arg0 : i64
%348 = arith.remsi %347, %344 : i64
%349 = arith.addi %348, %344 : i64
%350 = arith.remsi %349, %344 : i64
%351 = arith.muli %350, %346 : i64
%352 = arith.remsi %351, %344 : i64
%353 = arith.muli %342, %352 : i64
%354 = arith.addi %arg0, %353 : i64
%355 = arith.remsi %354, %340 : i64
func.return %355 : i64
}
func.func @main() -> i32 {
%356 = arith.constant 1000000000 : i32
%357 = arith.extsi %356 : i32 to i64
%358 = arith.constant 20 : i32
%359 = arith.extsi %358 : i32 to i64
%361 = arith.constant 8 : i32
%362 = arith.extsi %361 : i32 to i64
%360 = func.call @calloc(%359, %362) : (i64, i64) -> !llvm.ptr
%364 = arith.constant 8 : i32
%365 = arith.extsi %364 : i32 to i64
%363 = func.call @calloc(%359, %365) : (i64, i64) -> !llvm.ptr
%367 = arith.constant 8 : i32
%368 = arith.extsi %367 : i32 to i64
%366 = func.call @calloc(%359, %368) : (i64, i64) -> !llvm.ptr
%370 = arith.constant 8 : i32
%371 = arith.extsi %370 : i32 to i64
%369 = func.call @calloc(%359, %371) : (i64, i64) -> !llvm.ptr
%373 = arith.constant 8 : i32
%374 = arith.extsi %373 : i32 to i64
%372 = func.call @calloc(%359, %374) : (i64, i64) -> !llvm.ptr
%376 = arith.constant 8 : i32
%377 = arith.extsi %376 : i32 to i64
%375 = func.call @calloc(%359, %377) : (i64, i64) -> !llvm.ptr
%379 = arith.constant 8 : i32
%380 = arith.extsi %379 : i32 to i64
%378 = func.call @calloc(%359, %380) : (i64, i64) -> !llvm.ptr
%382 = arith.constant 8 : i32
%383 = arith.extsi %382 : i32 to i64
%381 = func.call @calloc(%359, %383) : (i64, i64) -> !llvm.ptr
%385 = arith.constant 8 : i32
%386 = arith.extsi %385 : i32 to i64
%384 = func.call @calloc(%359, %386) : (i64, i64) -> !llvm.ptr
%387 = llvm.mlir.zero : !llvm.ptr
%388 = llvm.icmp "eq" %360, %387 : !llvm.ptr
%389 = scf.if %388 -> (i1) {
%390 = arith.constant true
scf.yield %390 : i1
} else {
%391 = llvm.mlir.zero : !llvm.ptr
%392 = llvm.icmp "eq" %363, %391 : !llvm.ptr
scf.yield %392 : i1
}
%393 = scf.if %389 -> (i1) {
%394 = arith.constant true
scf.yield %394 : i1
} else {
%395 = llvm.mlir.zero : !llvm.ptr
%396 = llvm.icmp "eq" %366, %395 : !llvm.ptr
scf.yield %396 : i1
}
%397 = scf.if %393 -> (i1) {
%398 = arith.constant true
scf.yield %398 : i1
} else {
%399 = llvm.mlir.zero : !llvm.ptr
%400 = llvm.icmp "eq" %369, %399 : !llvm.ptr
scf.yield %400 : i1
}
%401 = scf.if %397 -> (i1) {
%402 = arith.constant true
scf.yield %402 : i1
} else {
%403 = llvm.mlir.zero : !llvm.ptr
%404 = llvm.icmp "eq" %372, %403 : !llvm.ptr
scf.yield %404 : i1
}
cf.cond_br %401, ^bb66, ^bb67
^bb66:
%405 = arith.constant 1 : i32
func.return %405 : i32
^bb67:
cf.br ^bb68
^bb68:
%406 = llvm.mlir.zero : !llvm.ptr
%407 = llvm.icmp "eq" %375, %406 : !llvm.ptr
%408 = scf.if %407 -> (i1) {
%409 = arith.constant true
scf.yield %409 : i1
} else {
%410 = llvm.mlir.zero : !llvm.ptr
%411 = llvm.icmp "eq" %378, %410 : !llvm.ptr
scf.yield %411 : i1
}
%412 = scf.if %408 -> (i1) {
%413 = arith.constant true
scf.yield %413 : i1
} else {
%414 = llvm.mlir.zero : !llvm.ptr
%415 = llvm.icmp "eq" %381, %414 : !llvm.ptr
scf.yield %415 : i1
}
%416 = scf.if %412 -> (i1) {
%417 = arith.constant true
scf.yield %417 : i1
} else {
%418 = llvm.mlir.zero : !llvm.ptr
%419 = llvm.icmp "eq" %384, %418 : !llvm.ptr
scf.yield %419 : i1
}
cf.cond_br %416, ^bb69, ^bb70
^bb69:
%420 = arith.constant 1 : i32
func.return %420 : i32
^bb70:
cf.br ^bb71
^bb71:
%422 = arith.constant 1953125 : i32
%423 = arith.constant 1562500 : i32
%424 = arith.constant 625000 : i32
%425 = arith.constant 250000 : i32
%426 = arith.constant 100000 : i32
%427 = arith.constant 40000 : i32
%428 = arith.constant 16000 : i32
%429 = arith.constant 6400 : i32
%430 = arith.constant 2560 : i32
%431 = arith.constant 1024 : i32
%432 = arith.constant 512 : i32
%433 = arith.constant 256 : i32
%434 = arith.constant 128 : i32
%435 = arith.constant 64 : i32
%436 = arith.constant 32 : i32
%437 = arith.constant 16 : i32
%438 = arith.constant 8 : i32
%439 = arith.constant 4 : i32
%440 = arith.constant 2 : i32
%441 = arith.constant 1 : i32
%442 = llvm.mlir.constant(1 : i64) : i64
%443 = llvm.alloca %442 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%444 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %444, %443 : !llvm.array<20 x i64>, !llvm.ptr
%445 = arith.extsi %422 : i32 to i64
%446 = arith.extsi %423 : i32 to i64
%447 = arith.extsi %424 : i32 to i64
%448 = arith.extsi %425 : i32 to i64
%449 = arith.extsi %426 : i32 to i64
%450 = arith.extsi %427 : i32 to i64
%451 = arith.extsi %428 : i32 to i64
%452 = arith.extsi %429 : i32 to i64
%453 = arith.extsi %430 : i32 to i64
%454 = arith.extsi %431 : i32 to i64
%455 = arith.extsi %432 : i32 to i64
%456 = arith.extsi %433 : i32 to i64
%457 = arith.extsi %434 : i32 to i64
%458 = arith.extsi %435 : i32 to i64
%459 = arith.extsi %436 : i32 to i64
%460 = arith.extsi %437 : i32 to i64
%461 = arith.extsi %438 : i32 to i64
%462 = arith.extsi %439 : i32 to i64
%463 = arith.extsi %440 : i32 to i64
%464 = arith.extsi %441 : i32 to i64
%465 = llvm.mlir.constant(0 : i64) : i64
%466 = llvm.getelementptr %443[0, %465] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %445, %466 : i64, !llvm.ptr
%467 = llvm.mlir.constant(1 : i64) : i64
%468 = llvm.getelementptr %443[0, %467] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %446, %468 : i64, !llvm.ptr
%469 = llvm.mlir.constant(2 : i64) : i64
%470 = llvm.getelementptr %443[0, %469] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %447, %470 : i64, !llvm.ptr
%471 = llvm.mlir.constant(3 : i64) : i64
%472 = llvm.getelementptr %443[0, %471] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %448, %472 : i64, !llvm.ptr
%473 = llvm.mlir.constant(4 : i64) : i64
%474 = llvm.getelementptr %443[0, %473] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %449, %474 : i64, !llvm.ptr
%475 = llvm.mlir.constant(5 : i64) : i64
%476 = llvm.getelementptr %443[0, %475] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %450, %476 : i64, !llvm.ptr
%477 = llvm.mlir.constant(6 : i64) : i64
%478 = llvm.getelementptr %443[0, %477] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %451, %478 : i64, !llvm.ptr
%479 = llvm.mlir.constant(7 : i64) : i64
%480 = llvm.getelementptr %443[0, %479] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %452, %480 : i64, !llvm.ptr
%481 = llvm.mlir.constant(8 : i64) : i64
%482 = llvm.getelementptr %443[0, %481] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %453, %482 : i64, !llvm.ptr
%483 = llvm.mlir.constant(9 : i64) : i64
%484 = llvm.getelementptr %443[0, %483] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %454, %484 : i64, !llvm.ptr
%485 = llvm.mlir.constant(10 : i64) : i64
%486 = llvm.getelementptr %443[0, %485] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %455, %486 : i64, !llvm.ptr
%487 = llvm.mlir.constant(11 : i64) : i64
%488 = llvm.getelementptr %443[0, %487] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %456, %488 : i64, !llvm.ptr
%489 = llvm.mlir.constant(12 : i64) : i64
%490 = llvm.getelementptr %443[0, %489] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %457, %490 : i64, !llvm.ptr
%491 = llvm.mlir.constant(13 : i64) : i64
%492 = llvm.getelementptr %443[0, %491] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %458, %492 : i64, !llvm.ptr
%493 = llvm.mlir.constant(14 : i64) : i64
%494 = llvm.getelementptr %443[0, %493] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %459, %494 : i64, !llvm.ptr
%495 = llvm.mlir.constant(15 : i64) : i64
%496 = llvm.getelementptr %443[0, %495] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %460, %496 : i64, !llvm.ptr
%497 = llvm.mlir.constant(16 : i64) : i64
%498 = llvm.getelementptr %443[0, %497] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %461, %498 : i64, !llvm.ptr
%499 = llvm.mlir.constant(17 : i64) : i64
%500 = llvm.getelementptr %443[0, %499] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %462, %500 : i64, !llvm.ptr
%501 = llvm.mlir.constant(18 : i64) : i64
%502 = llvm.getelementptr %443[0, %501] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %463, %502 : i64, !llvm.ptr
%503 = llvm.mlir.constant(19 : i64) : i64
%504 = llvm.getelementptr %443[0, %503] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %464, %504 : i64, !llvm.ptr
%506 = arith.constant 0 : i32
%507 = arith.constant 2 : i32
%508 = arith.constant 3 : i32
%509 = arith.constant 4 : i32
%510 = arith.constant 5 : i32
%511 = arith.constant 6 : i32
%512 = arith.constant 7 : i32
%513 = arith.constant 8 : i32
%514 = arith.constant 9 : i32
%515 = arith.constant 10 : i32
%516 = arith.constant 9 : i32
%517 = arith.constant 8 : i32
%518 = arith.constant 7 : i32
%519 = arith.constant 6 : i32
%520 = arith.constant 5 : i32
%521 = arith.constant 4 : i32
%522 = arith.constant 3 : i32
%523 = arith.constant 2 : i32
%524 = arith.constant 1 : i32
%525 = arith.constant 0 : i32
%526 = llvm.mlir.constant(1 : i64) : i64
%527 = llvm.alloca %526 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%528 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %528, %527 : !llvm.array<20 x i64>, !llvm.ptr
%529 = arith.extsi %506 : i32 to i64
%530 = arith.extsi %507 : i32 to i64
%531 = arith.extsi %508 : i32 to i64
%532 = arith.extsi %509 : i32 to i64
%533 = arith.extsi %510 : i32 to i64
%534 = arith.extsi %511 : i32 to i64
%535 = arith.extsi %512 : i32 to i64
%536 = arith.extsi %513 : i32 to i64
%537 = arith.extsi %514 : i32 to i64
%538 = arith.extsi %515 : i32 to i64
%539 = arith.extsi %516 : i32 to i64
%540 = arith.extsi %517 : i32 to i64
%541 = arith.extsi %518 : i32 to i64
%542 = arith.extsi %519 : i32 to i64
%543 = arith.extsi %520 : i32 to i64
%544 = arith.extsi %521 : i32 to i64
%545 = arith.extsi %522 : i32 to i64
%546 = arith.extsi %523 : i32 to i64
%547 = arith.extsi %524 : i32 to i64
%548 = arith.extsi %525 : i32 to i64
%549 = llvm.mlir.constant(0 : i64) : i64
%550 = llvm.getelementptr %527[0, %549] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %529, %550 : i64, !llvm.ptr
%551 = llvm.mlir.constant(1 : i64) : i64
%552 = llvm.getelementptr %527[0, %551] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %530, %552 : i64, !llvm.ptr
%553 = llvm.mlir.constant(2 : i64) : i64
%554 = llvm.getelementptr %527[0, %553] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %531, %554 : i64, !llvm.ptr
%555 = llvm.mlir.constant(3 : i64) : i64
%556 = llvm.getelementptr %527[0, %555] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %532, %556 : i64, !llvm.ptr
%557 = llvm.mlir.constant(4 : i64) : i64
%558 = llvm.getelementptr %527[0, %557] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %533, %558 : i64, !llvm.ptr
%559 = llvm.mlir.constant(5 : i64) : i64
%560 = llvm.getelementptr %527[0, %559] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %534, %560 : i64, !llvm.ptr
%561 = llvm.mlir.constant(6 : i64) : i64
%562 = llvm.getelementptr %527[0, %561] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %535, %562 : i64, !llvm.ptr
%563 = llvm.mlir.constant(7 : i64) : i64
%564 = llvm.getelementptr %527[0, %563] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %536, %564 : i64, !llvm.ptr
%565 = llvm.mlir.constant(8 : i64) : i64
%566 = llvm.getelementptr %527[0, %565] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %537, %566 : i64, !llvm.ptr
%567 = llvm.mlir.constant(9 : i64) : i64
%568 = llvm.getelementptr %527[0, %567] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %538, %568 : i64, !llvm.ptr
%569 = llvm.mlir.constant(10 : i64) : i64
%570 = llvm.getelementptr %527[0, %569] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %539, %570 : i64, !llvm.ptr
%571 = llvm.mlir.constant(11 : i64) : i64
%572 = llvm.getelementptr %527[0, %571] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %540, %572 : i64, !llvm.ptr
%573 = llvm.mlir.constant(12 : i64) : i64
%574 = llvm.getelementptr %527[0, %573] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %541, %574 : i64, !llvm.ptr
%575 = llvm.mlir.constant(13 : i64) : i64
%576 = llvm.getelementptr %527[0, %575] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %542, %576 : i64, !llvm.ptr
%577 = llvm.mlir.constant(14 : i64) : i64
%578 = llvm.getelementptr %527[0, %577] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %543, %578 : i64, !llvm.ptr
%579 = llvm.mlir.constant(15 : i64) : i64
%580 = llvm.getelementptr %527[0, %579] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %544, %580 : i64, !llvm.ptr
%581 = llvm.mlir.constant(16 : i64) : i64
%582 = llvm.getelementptr %527[0, %581] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %545, %582 : i64, !llvm.ptr
%583 = llvm.mlir.constant(17 : i64) : i64
%584 = llvm.getelementptr %527[0, %583] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %546, %584 : i64, !llvm.ptr
%585 = llvm.mlir.constant(18 : i64) : i64
%586 = llvm.getelementptr %527[0, %585] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %547, %586 : i64, !llvm.ptr
%587 = llvm.mlir.constant(19 : i64) : i64
%588 = llvm.getelementptr %527[0, %587] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %548, %588 : i64, !llvm.ptr
%590 = arith.constant 9 : i32
%591 = arith.constant 8 : i32
%592 = arith.constant 7 : i32
%593 = arith.constant 6 : i32
%594 = arith.constant 5 : i32
%595 = arith.constant 4 : i32
%596 = arith.constant 3 : i32
%597 = arith.constant 2 : i32
%598 = arith.constant 1 : i32
%599 = arith.constant 0 : i32
%600 = arith.constant 0 : i32
%601 = arith.constant 0 : i32
%602 = arith.constant 0 : i32
%603 = arith.constant 0 : i32
%604 = arith.constant 0 : i32
%605 = arith.constant 0 : i32
%606 = arith.constant 0 : i32
%607 = arith.constant 0 : i32
%608 = arith.constant 0 : i32
%609 = arith.constant 0 : i32
%610 = llvm.mlir.constant(1 : i64) : i64
%611 = llvm.alloca %610 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%612 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %612, %611 : !llvm.array<20 x i64>, !llvm.ptr
%613 = arith.extsi %590 : i32 to i64
%614 = arith.extsi %591 : i32 to i64
%615 = arith.extsi %592 : i32 to i64
%616 = arith.extsi %593 : i32 to i64
%617 = arith.extsi %594 : i32 to i64
%618 = arith.extsi %595 : i32 to i64
%619 = arith.extsi %596 : i32 to i64
%620 = arith.extsi %597 : i32 to i64
%621 = arith.extsi %598 : i32 to i64
%622 = arith.extsi %599 : i32 to i64
%623 = arith.extsi %600 : i32 to i64
%624 = arith.extsi %601 : i32 to i64
%625 = arith.extsi %602 : i32 to i64
%626 = arith.extsi %603 : i32 to i64
%627 = arith.extsi %604 : i32 to i64
%628 = arith.extsi %605 : i32 to i64
%629 = arith.extsi %606 : i32 to i64
%630 = arith.extsi %607 : i32 to i64
%631 = arith.extsi %608 : i32 to i64
%632 = arith.extsi %609 : i32 to i64
%633 = llvm.mlir.constant(0 : i64) : i64
%634 = llvm.getelementptr %611[0, %633] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %613, %634 : i64, !llvm.ptr
%635 = llvm.mlir.constant(1 : i64) : i64
%636 = llvm.getelementptr %611[0, %635] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %614, %636 : i64, !llvm.ptr
%637 = llvm.mlir.constant(2 : i64) : i64
%638 = llvm.getelementptr %611[0, %637] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %615, %638 : i64, !llvm.ptr
%639 = llvm.mlir.constant(3 : i64) : i64
%640 = llvm.getelementptr %611[0, %639] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %616, %640 : i64, !llvm.ptr
%641 = llvm.mlir.constant(4 : i64) : i64
%642 = llvm.getelementptr %611[0, %641] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %617, %642 : i64, !llvm.ptr
%643 = llvm.mlir.constant(5 : i64) : i64
%644 = llvm.getelementptr %611[0, %643] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %618, %644 : i64, !llvm.ptr
%645 = llvm.mlir.constant(6 : i64) : i64
%646 = llvm.getelementptr %611[0, %645] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %619, %646 : i64, !llvm.ptr
%647 = llvm.mlir.constant(7 : i64) : i64
%648 = llvm.getelementptr %611[0, %647] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %620, %648 : i64, !llvm.ptr
%649 = llvm.mlir.constant(8 : i64) : i64
%650 = llvm.getelementptr %611[0, %649] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %621, %650 : i64, !llvm.ptr
%651 = llvm.mlir.constant(9 : i64) : i64
%652 = llvm.getelementptr %611[0, %651] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %622, %652 : i64, !llvm.ptr
%653 = llvm.mlir.constant(10 : i64) : i64
%654 = llvm.getelementptr %611[0, %653] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %623, %654 : i64, !llvm.ptr
%655 = llvm.mlir.constant(11 : i64) : i64
%656 = llvm.getelementptr %611[0, %655] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %624, %656 : i64, !llvm.ptr
%657 = llvm.mlir.constant(12 : i64) : i64
%658 = llvm.getelementptr %611[0, %657] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %625, %658 : i64, !llvm.ptr
%659 = llvm.mlir.constant(13 : i64) : i64
%660 = llvm.getelementptr %611[0, %659] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %626, %660 : i64, !llvm.ptr
%661 = llvm.mlir.constant(14 : i64) : i64
%662 = llvm.getelementptr %611[0, %661] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %627, %662 : i64, !llvm.ptr
%663 = llvm.mlir.constant(15 : i64) : i64
%664 = llvm.getelementptr %611[0, %663] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %628, %664 : i64, !llvm.ptr
%665 = llvm.mlir.constant(16 : i64) : i64
%666 = llvm.getelementptr %611[0, %665] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %629, %666 : i64, !llvm.ptr
%667 = llvm.mlir.constant(17 : i64) : i64
%668 = llvm.getelementptr %611[0, %667] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %630, %668 : i64, !llvm.ptr
%669 = llvm.mlir.constant(18 : i64) : i64
%670 = llvm.getelementptr %611[0, %669] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %631, %670 : i64, !llvm.ptr
%671 = llvm.mlir.constant(19 : i64) : i64
%672 = llvm.getelementptr %611[0, %671] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %632, %672 : i64, !llvm.ptr
%674 = arith.constant 1 : i32
%675 = arith.constant 4 : i32
%676 = arith.constant 8 : i32
%677 = arith.constant 16 : i32
%678 = arith.constant 32 : i32
%679 = arith.constant 64 : i32
%680 = arith.constant 128 : i32
%681 = arith.constant 256 : i32
%682 = arith.constant 512 : i32
%683 = arith.constant 1024 : i32
%684 = arith.constant 512 : i32
%685 = arith.constant 256 : i32
%686 = arith.constant 128 : i32
%687 = arith.constant 64 : i32
%688 = arith.constant 32 : i32
%689 = arith.constant 16 : i32
%690 = arith.constant 8 : i32
%691 = arith.constant 4 : i32
%692 = arith.constant 2 : i32
%693 = arith.constant 1 : i32
%694 = llvm.mlir.constant(1 : i64) : i64
%695 = llvm.alloca %694 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%696 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %696, %695 : !llvm.array<20 x i64>, !llvm.ptr
%697 = arith.extsi %674 : i32 to i64
%698 = arith.extsi %675 : i32 to i64
%699 = arith.extsi %676 : i32 to i64
%700 = arith.extsi %677 : i32 to i64
%701 = arith.extsi %678 : i32 to i64
%702 = arith.extsi %679 : i32 to i64
%703 = arith.extsi %680 : i32 to i64
%704 = arith.extsi %681 : i32 to i64
%705 = arith.extsi %682 : i32 to i64
%706 = arith.extsi %683 : i32 to i64
%707 = arith.extsi %684 : i32 to i64
%708 = arith.extsi %685 : i32 to i64
%709 = arith.extsi %686 : i32 to i64
%710 = arith.extsi %687 : i32 to i64
%711 = arith.extsi %688 : i32 to i64
%712 = arith.extsi %689 : i32 to i64
%713 = arith.extsi %690 : i32 to i64
%714 = arith.extsi %691 : i32 to i64
%715 = arith.extsi %692 : i32 to i64
%716 = arith.extsi %693 : i32 to i64
%717 = llvm.mlir.constant(0 : i64) : i64
%718 = llvm.getelementptr %695[0, %717] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %697, %718 : i64, !llvm.ptr
%719 = llvm.mlir.constant(1 : i64) : i64
%720 = llvm.getelementptr %695[0, %719] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %698, %720 : i64, !llvm.ptr
%721 = llvm.mlir.constant(2 : i64) : i64
%722 = llvm.getelementptr %695[0, %721] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %699, %722 : i64, !llvm.ptr
%723 = llvm.mlir.constant(3 : i64) : i64
%724 = llvm.getelementptr %695[0, %723] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %700, %724 : i64, !llvm.ptr
%725 = llvm.mlir.constant(4 : i64) : i64
%726 = llvm.getelementptr %695[0, %725] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %701, %726 : i64, !llvm.ptr
%727 = llvm.mlir.constant(5 : i64) : i64
%728 = llvm.getelementptr %695[0, %727] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %702, %728 : i64, !llvm.ptr
%729 = llvm.mlir.constant(6 : i64) : i64
%730 = llvm.getelementptr %695[0, %729] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %703, %730 : i64, !llvm.ptr
%731 = llvm.mlir.constant(7 : i64) : i64
%732 = llvm.getelementptr %695[0, %731] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %704, %732 : i64, !llvm.ptr
%733 = llvm.mlir.constant(8 : i64) : i64
%734 = llvm.getelementptr %695[0, %733] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %705, %734 : i64, !llvm.ptr
%735 = llvm.mlir.constant(9 : i64) : i64
%736 = llvm.getelementptr %695[0, %735] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %706, %736 : i64, !llvm.ptr
%737 = llvm.mlir.constant(10 : i64) : i64
%738 = llvm.getelementptr %695[0, %737] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %707, %738 : i64, !llvm.ptr
%739 = llvm.mlir.constant(11 : i64) : i64
%740 = llvm.getelementptr %695[0, %739] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %708, %740 : i64, !llvm.ptr
%741 = llvm.mlir.constant(12 : i64) : i64
%742 = llvm.getelementptr %695[0, %741] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %709, %742 : i64, !llvm.ptr
%743 = llvm.mlir.constant(13 : i64) : i64
%744 = llvm.getelementptr %695[0, %743] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %710, %744 : i64, !llvm.ptr
%745 = llvm.mlir.constant(14 : i64) : i64
%746 = llvm.getelementptr %695[0, %745] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %711, %746 : i64, !llvm.ptr
%747 = llvm.mlir.constant(15 : i64) : i64
%748 = llvm.getelementptr %695[0, %747] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %712, %748 : i64, !llvm.ptr
%749 = llvm.mlir.constant(16 : i64) : i64
%750 = llvm.getelementptr %695[0, %749] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %713, %750 : i64, !llvm.ptr
%751 = llvm.mlir.constant(17 : i64) : i64
%752 = llvm.getelementptr %695[0, %751] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %714, %752 : i64, !llvm.ptr
%753 = llvm.mlir.constant(18 : i64) : i64
%754 = llvm.getelementptr %695[0, %753] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %715, %754 : i64, !llvm.ptr
%755 = llvm.mlir.constant(19 : i64) : i64
%756 = llvm.getelementptr %695[0, %755] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %716, %756 : i64, !llvm.ptr
%758 = arith.constant 1953125 : i32
%759 = arith.constant 390625 : i32
%760 = arith.constant 78125 : i32
%761 = arith.constant 15625 : i32
%762 = arith.constant 3125 : i32
%763 = arith.constant 625 : i32
%764 = arith.constant 125 : i32
%765 = arith.constant 25 : i32
%766 = arith.constant 5 : i32
%767 = arith.constant 1 : i32
%768 = arith.constant 1 : i32
%769 = arith.constant 1 : i32
%770 = arith.constant 1 : i32
%771 = arith.constant 1 : i32
%772 = arith.constant 1 : i32
%773 = arith.constant 1 : i32
%774 = arith.constant 1 : i32
%775 = arith.constant 1 : i32
%776 = arith.constant 1 : i32
%777 = arith.constant 1 : i32
%778 = llvm.mlir.constant(1 : i64) : i64
%779 = llvm.alloca %778 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%780 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %780, %779 : !llvm.array<20 x i64>, !llvm.ptr
%781 = arith.extsi %758 : i32 to i64
%782 = arith.extsi %759 : i32 to i64
%783 = arith.extsi %760 : i32 to i64
%784 = arith.extsi %761 : i32 to i64
%785 = arith.extsi %762 : i32 to i64
%786 = arith.extsi %763 : i32 to i64
%787 = arith.extsi %764 : i32 to i64
%788 = arith.extsi %765 : i32 to i64
%789 = arith.extsi %766 : i32 to i64
%790 = arith.extsi %767 : i32 to i64
%791 = arith.extsi %768 : i32 to i64
%792 = arith.extsi %769 : i32 to i64
%793 = arith.extsi %770 : i32 to i64
%794 = arith.extsi %771 : i32 to i64
%795 = arith.extsi %772 : i32 to i64
%796 = arith.extsi %773 : i32 to i64
%797 = arith.extsi %774 : i32 to i64
%798 = arith.extsi %775 : i32 to i64
%799 = arith.extsi %776 : i32 to i64
%800 = arith.extsi %777 : i32 to i64
%801 = llvm.mlir.constant(0 : i64) : i64
%802 = llvm.getelementptr %779[0, %801] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %781, %802 : i64, !llvm.ptr
%803 = llvm.mlir.constant(1 : i64) : i64
%804 = llvm.getelementptr %779[0, %803] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %782, %804 : i64, !llvm.ptr
%805 = llvm.mlir.constant(2 : i64) : i64
%806 = llvm.getelementptr %779[0, %805] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %783, %806 : i64, !llvm.ptr
%807 = llvm.mlir.constant(3 : i64) : i64
%808 = llvm.getelementptr %779[0, %807] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %784, %808 : i64, !llvm.ptr
%809 = llvm.mlir.constant(4 : i64) : i64
%810 = llvm.getelementptr %779[0, %809] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %785, %810 : i64, !llvm.ptr
%811 = llvm.mlir.constant(5 : i64) : i64
%812 = llvm.getelementptr %779[0, %811] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %786, %812 : i64, !llvm.ptr
%813 = llvm.mlir.constant(6 : i64) : i64
%814 = llvm.getelementptr %779[0, %813] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %787, %814 : i64, !llvm.ptr
%815 = llvm.mlir.constant(7 : i64) : i64
%816 = llvm.getelementptr %779[0, %815] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %788, %816 : i64, !llvm.ptr
%817 = llvm.mlir.constant(8 : i64) : i64
%818 = llvm.getelementptr %779[0, %817] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %789, %818 : i64, !llvm.ptr
%819 = llvm.mlir.constant(9 : i64) : i64
%820 = llvm.getelementptr %779[0, %819] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %790, %820 : i64, !llvm.ptr
%821 = llvm.mlir.constant(10 : i64) : i64
%822 = llvm.getelementptr %779[0, %821] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %791, %822 : i64, !llvm.ptr
%823 = llvm.mlir.constant(11 : i64) : i64
%824 = llvm.getelementptr %779[0, %823] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %792, %824 : i64, !llvm.ptr
%825 = llvm.mlir.constant(12 : i64) : i64
%826 = llvm.getelementptr %779[0, %825] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %793, %826 : i64, !llvm.ptr
%827 = llvm.mlir.constant(13 : i64) : i64
%828 = llvm.getelementptr %779[0, %827] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %794, %828 : i64, !llvm.ptr
%829 = llvm.mlir.constant(14 : i64) : i64
%830 = llvm.getelementptr %779[0, %829] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %795, %830 : i64, !llvm.ptr
%831 = llvm.mlir.constant(15 : i64) : i64
%832 = llvm.getelementptr %779[0, %831] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %796, %832 : i64, !llvm.ptr
%833 = llvm.mlir.constant(16 : i64) : i64
%834 = llvm.getelementptr %779[0, %833] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %797, %834 : i64, !llvm.ptr
%835 = llvm.mlir.constant(17 : i64) : i64
%836 = llvm.getelementptr %779[0, %835] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %798, %836 : i64, !llvm.ptr
%837 = llvm.mlir.constant(18 : i64) : i64
%838 = llvm.getelementptr %779[0, %837] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %799, %838 : i64, !llvm.ptr
%839 = llvm.mlir.constant(19 : i64) : i64
%840 = llvm.getelementptr %779[0, %839] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %800, %840 : i64, !llvm.ptr
%842 = arith.constant 1562500 : i32
%843 = arith.constant 312500 : i32
%844 = arith.constant 62500 : i32
%845 = arith.constant 12500 : i32
%846 = arith.constant 2500 : i32
%847 = arith.constant 500 : i32
%848 = arith.constant 100 : i32
%849 = arith.constant 20 : i32
%850 = arith.constant 4 : i32
%851 = arith.constant 1 : i32
%852 = arith.constant 1 : i32
%853 = arith.constant 1 : i32
%854 = arith.constant 1 : i32
%855 = arith.constant 1 : i32
%856 = arith.constant 1 : i32
%857 = arith.constant 1 : i32
%858 = arith.constant 1 : i32
%859 = arith.constant 1 : i32
%860 = arith.constant 1 : i32
%861 = arith.constant 1 : i32
%862 = llvm.mlir.constant(1 : i64) : i64
%863 = llvm.alloca %862 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%864 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %864, %863 : !llvm.array<20 x i64>, !llvm.ptr
%865 = arith.extsi %842 : i32 to i64
%866 = arith.extsi %843 : i32 to i64
%867 = arith.extsi %844 : i32 to i64
%868 = arith.extsi %845 : i32 to i64
%869 = arith.extsi %846 : i32 to i64
%870 = arith.extsi %847 : i32 to i64
%871 = arith.extsi %848 : i32 to i64
%872 = arith.extsi %849 : i32 to i64
%873 = arith.extsi %850 : i32 to i64
%874 = arith.extsi %851 : i32 to i64
%875 = arith.extsi %852 : i32 to i64
%876 = arith.extsi %853 : i32 to i64
%877 = arith.extsi %854 : i32 to i64
%878 = arith.extsi %855 : i32 to i64
%879 = arith.extsi %856 : i32 to i64
%880 = arith.extsi %857 : i32 to i64
%881 = arith.extsi %858 : i32 to i64
%882 = arith.extsi %859 : i32 to i64
%883 = arith.extsi %860 : i32 to i64
%884 = arith.extsi %861 : i32 to i64
%885 = llvm.mlir.constant(0 : i64) : i64
%886 = llvm.getelementptr %863[0, %885] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %865, %886 : i64, !llvm.ptr
%887 = llvm.mlir.constant(1 : i64) : i64
%888 = llvm.getelementptr %863[0, %887] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %866, %888 : i64, !llvm.ptr
%889 = llvm.mlir.constant(2 : i64) : i64
%890 = llvm.getelementptr %863[0, %889] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %867, %890 : i64, !llvm.ptr
%891 = llvm.mlir.constant(3 : i64) : i64
%892 = llvm.getelementptr %863[0, %891] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %868, %892 : i64, !llvm.ptr
%893 = llvm.mlir.constant(4 : i64) : i64
%894 = llvm.getelementptr %863[0, %893] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %869, %894 : i64, !llvm.ptr
%895 = llvm.mlir.constant(5 : i64) : i64
%896 = llvm.getelementptr %863[0, %895] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %870, %896 : i64, !llvm.ptr
%897 = llvm.mlir.constant(6 : i64) : i64
%898 = llvm.getelementptr %863[0, %897] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %871, %898 : i64, !llvm.ptr
%899 = llvm.mlir.constant(7 : i64) : i64
%900 = llvm.getelementptr %863[0, %899] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %872, %900 : i64, !llvm.ptr
%901 = llvm.mlir.constant(8 : i64) : i64
%902 = llvm.getelementptr %863[0, %901] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %873, %902 : i64, !llvm.ptr
%903 = llvm.mlir.constant(9 : i64) : i64
%904 = llvm.getelementptr %863[0, %903] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %874, %904 : i64, !llvm.ptr
%905 = llvm.mlir.constant(10 : i64) : i64
%906 = llvm.getelementptr %863[0, %905] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %875, %906 : i64, !llvm.ptr
%907 = llvm.mlir.constant(11 : i64) : i64
%908 = llvm.getelementptr %863[0, %907] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %876, %908 : i64, !llvm.ptr
%909 = llvm.mlir.constant(12 : i64) : i64
%910 = llvm.getelementptr %863[0, %909] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %877, %910 : i64, !llvm.ptr
%911 = llvm.mlir.constant(13 : i64) : i64
%912 = llvm.getelementptr %863[0, %911] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %878, %912 : i64, !llvm.ptr
%913 = llvm.mlir.constant(14 : i64) : i64
%914 = llvm.getelementptr %863[0, %913] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %879, %914 : i64, !llvm.ptr
%915 = llvm.mlir.constant(15 : i64) : i64
%916 = llvm.getelementptr %863[0, %915] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %880, %916 : i64, !llvm.ptr
%917 = llvm.mlir.constant(16 : i64) : i64
%918 = llvm.getelementptr %863[0, %917] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %881, %918 : i64, !llvm.ptr
%919 = llvm.mlir.constant(17 : i64) : i64
%920 = llvm.getelementptr %863[0, %919] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %882, %920 : i64, !llvm.ptr
%921 = llvm.mlir.constant(18 : i64) : i64
%922 = llvm.getelementptr %863[0, %921] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %883, %922 : i64, !llvm.ptr
%923 = llvm.mlir.constant(19 : i64) : i64
%924 = llvm.getelementptr %863[0, %923] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %884, %924 : i64, !llvm.ptr
%926 = arith.constant 0 : i32
%927 = arith.constant 1 : i32
%928 = arith.constant 5 : i32
%929 = arith.constant 9 : i32
%930 = arith.constant 29 : i32
%931 = arith.constant 17 : i32
%932 = arith.constant 85 : i32
%933 = arith.constant 41 : i32
%934 = arith.constant 205 : i32
%935 = arith.constant 0 : i32
%936 = arith.constant 0 : i32
%937 = arith.constant 0 : i32
%938 = arith.constant 0 : i32
%939 = arith.constant 0 : i32
%940 = arith.constant 0 : i32
%941 = arith.constant 0 : i32
%942 = arith.constant 0 : i32
%943 = arith.constant 0 : i32
%944 = arith.constant 0 : i32
%945 = arith.constant 0 : i32
%946 = llvm.mlir.constant(1 : i64) : i64
%947 = llvm.alloca %946 x !llvm.array<20 x i64> : (i64) -> !llvm.ptr
%948 = llvm.mlir.zero : !llvm.array<20 x i64>
llvm.store %948, %947 : !llvm.array<20 x i64>, !llvm.ptr
%949 = arith.extsi %926 : i32 to i64
%950 = arith.extsi %927 : i32 to i64
%951 = arith.extsi %928 : i32 to i64
%952 = arith.extsi %929 : i32 to i64
%953 = arith.extsi %930 : i32 to i64
%954 = arith.extsi %931 : i32 to i64
%955 = arith.extsi %932 : i32 to i64
%956 = arith.extsi %933 : i32 to i64
%957 = arith.extsi %934 : i32 to i64
%958 = arith.extsi %935 : i32 to i64
%959 = arith.extsi %936 : i32 to i64
%960 = arith.extsi %937 : i32 to i64
%961 = arith.extsi %938 : i32 to i64
%962 = arith.extsi %939 : i32 to i64
%963 = arith.extsi %940 : i32 to i64
%964 = arith.extsi %941 : i32 to i64
%965 = arith.extsi %942 : i32 to i64
%966 = arith.extsi %943 : i32 to i64
%967 = arith.extsi %944 : i32 to i64
%968 = arith.extsi %945 : i32 to i64
%969 = llvm.mlir.constant(0 : i64) : i64
%970 = llvm.getelementptr %947[0, %969] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %949, %970 : i64, !llvm.ptr
%971 = llvm.mlir.constant(1 : i64) : i64
%972 = llvm.getelementptr %947[0, %971] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %950, %972 : i64, !llvm.ptr
%973 = llvm.mlir.constant(2 : i64) : i64
%974 = llvm.getelementptr %947[0, %973] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %951, %974 : i64, !llvm.ptr
%975 = llvm.mlir.constant(3 : i64) : i64
%976 = llvm.getelementptr %947[0, %975] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %952, %976 : i64, !llvm.ptr
%977 = llvm.mlir.constant(4 : i64) : i64
%978 = llvm.getelementptr %947[0, %977] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %953, %978 : i64, !llvm.ptr
%979 = llvm.mlir.constant(5 : i64) : i64
%980 = llvm.getelementptr %947[0, %979] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %954, %980 : i64, !llvm.ptr
%981 = llvm.mlir.constant(6 : i64) : i64
%982 = llvm.getelementptr %947[0, %981] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %955, %982 : i64, !llvm.ptr
%983 = llvm.mlir.constant(7 : i64) : i64
%984 = llvm.getelementptr %947[0, %983] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %956, %984 : i64, !llvm.ptr
%985 = llvm.mlir.constant(8 : i64) : i64
%986 = llvm.getelementptr %947[0, %985] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %957, %986 : i64, !llvm.ptr
%987 = llvm.mlir.constant(9 : i64) : i64
%988 = llvm.getelementptr %947[0, %987] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %958, %988 : i64, !llvm.ptr
%989 = llvm.mlir.constant(10 : i64) : i64
%990 = llvm.getelementptr %947[0, %989] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %959, %990 : i64, !llvm.ptr
%991 = llvm.mlir.constant(11 : i64) : i64
%992 = llvm.getelementptr %947[0, %991] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %960, %992 : i64, !llvm.ptr
%993 = llvm.mlir.constant(12 : i64) : i64
%994 = llvm.getelementptr %947[0, %993] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %961, %994 : i64, !llvm.ptr
%995 = llvm.mlir.constant(13 : i64) : i64
%996 = llvm.getelementptr %947[0, %995] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %962, %996 : i64, !llvm.ptr
%997 = llvm.mlir.constant(14 : i64) : i64
%998 = llvm.getelementptr %947[0, %997] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %963, %998 : i64, !llvm.ptr
%999 = llvm.mlir.constant(15 : i64) : i64
%1000 = llvm.getelementptr %947[0, %999] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %964, %1000 : i64, !llvm.ptr
%1001 = llvm.mlir.constant(16 : i64) : i64
%1002 = llvm.getelementptr %947[0, %1001] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %965, %1002 : i64, !llvm.ptr
%1003 = llvm.mlir.constant(17 : i64) : i64
%1004 = llvm.getelementptr %947[0, %1003] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %966, %1004 : i64, !llvm.ptr
%1005 = llvm.mlir.constant(18 : i64) : i64
%1006 = llvm.getelementptr %947[0, %1005] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %967, %1006 : i64, !llvm.ptr
%1007 = llvm.mlir.constant(19 : i64) : i64
%1008 = llvm.getelementptr %947[0, %1007] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
llvm.store %968, %1008 : i64, !llvm.ptr
%1009 = arith.constant 0 : i32
%1010 = arith.extsi %1009 : i32 to i64
%1011 = llvm.mlir.constant(1 : i64) : i64
%1012 = llvm.alloca %1011 x i64 : (i64) -> !llvm.ptr
llvm.store %1010, %1012 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%1013 = llvm.load %1012 : !llvm.ptr -> i64
%1014 = arith.cmpi slt, %1013, %359 : i64
cf.cond_br %1014, ^bb73, ^bb74
^bb73:
%1016 = llvm.load %1012 : !llvm.ptr -> i64
%1017 = llvm.getelementptr %443[0, %1016] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1015 = llvm.load %1017 : !llvm.ptr -> i64
%1018 = llvm.load %1012 : !llvm.ptr -> i64
%1019 = llvm.getelementptr %360[%1018] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1015, %1019 : i64, !llvm.ptr
%1021 = llvm.load %1012 : !llvm.ptr -> i64
%1022 = llvm.getelementptr %527[0, %1021] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1020 = llvm.load %1022 : !llvm.ptr -> i64
%1023 = llvm.load %1012 : !llvm.ptr -> i64
%1024 = llvm.getelementptr %363[%1023] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1020, %1024 : i64, !llvm.ptr
%1026 = llvm.load %1012 : !llvm.ptr -> i64
%1027 = llvm.getelementptr %611[0, %1026] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1025 = llvm.load %1027 : !llvm.ptr -> i64
%1028 = llvm.load %1012 : !llvm.ptr -> i64
%1029 = llvm.getelementptr %366[%1028] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1025, %1029 : i64, !llvm.ptr
%1031 = llvm.load %1012 : !llvm.ptr -> i64
%1032 = llvm.getelementptr %695[0, %1031] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1030 = llvm.load %1032 : !llvm.ptr -> i64
%1033 = llvm.load %1012 : !llvm.ptr -> i64
%1034 = llvm.getelementptr %369[%1033] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1030, %1034 : i64, !llvm.ptr
%1036 = llvm.load %1012 : !llvm.ptr -> i64
%1037 = llvm.getelementptr %779[0, %1036] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1035 = llvm.load %1037 : !llvm.ptr -> i64
%1038 = llvm.load %1012 : !llvm.ptr -> i64
%1039 = llvm.getelementptr %372[%1038] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1035, %1039 : i64, !llvm.ptr
%1041 = llvm.load %1012 : !llvm.ptr -> i64
%1042 = llvm.getelementptr %863[0, %1041] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1040 = llvm.load %1042 : !llvm.ptr -> i64
%1043 = llvm.load %1012 : !llvm.ptr -> i64
%1044 = llvm.getelementptr %375[%1043] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1040, %1044 : i64, !llvm.ptr
%1046 = llvm.load %1012 : !llvm.ptr -> i64
%1047 = llvm.getelementptr %947[0, %1046] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<20 x i64>
%1045 = llvm.load %1047 : !llvm.ptr -> i64
%1048 = llvm.load %1012 : !llvm.ptr -> i64
%1049 = llvm.getelementptr %378[%1048] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1045, %1049 : i64, !llvm.ptr
%1050 = llvm.load %1012 : !llvm.ptr -> i64
%1051 = arith.constant 1 : i32
%1053 = arith.extsi %1051 : i32 to i64
%1052 = arith.addi %1050, %1053 : i64
llvm.store %1052, %1012 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
%1055 = arith.constant 2 : i32
%1056 = arith.constant 3 : i32
%1057 = arith.constant 5 : i32
%1058 = arith.constant 7 : i32
%1059 = arith.constant 23 : i32
%1060 = arith.constant 63 : i32
%1061 = arith.constant 383 : i32
%1062 = arith.constant 2047 : i32
%1063 = llvm.mlir.constant(1 : i64) : i64
%1064 = llvm.alloca %1063 x !llvm.array<8 x i64> : (i64) -> !llvm.ptr
%1065 = llvm.mlir.zero : !llvm.array<8 x i64>
llvm.store %1065, %1064 : !llvm.array<8 x i64>, !llvm.ptr
%1066 = arith.extsi %1055 : i32 to i64
%1067 = arith.extsi %1056 : i32 to i64
%1068 = arith.extsi %1057 : i32 to i64
%1069 = arith.extsi %1058 : i32 to i64
%1070 = arith.extsi %1059 : i32 to i64
%1071 = arith.extsi %1060 : i32 to i64
%1072 = arith.extsi %1061 : i32 to i64
%1073 = arith.extsi %1062 : i32 to i64
%1074 = llvm.mlir.constant(0 : i64) : i64
%1075 = llvm.getelementptr %1064[0, %1074] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1066, %1075 : i64, !llvm.ptr
%1076 = llvm.mlir.constant(1 : i64) : i64
%1077 = llvm.getelementptr %1064[0, %1076] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1067, %1077 : i64, !llvm.ptr
%1078 = llvm.mlir.constant(2 : i64) : i64
%1079 = llvm.getelementptr %1064[0, %1078] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1068, %1079 : i64, !llvm.ptr
%1080 = llvm.mlir.constant(3 : i64) : i64
%1081 = llvm.getelementptr %1064[0, %1080] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1069, %1081 : i64, !llvm.ptr
%1082 = llvm.mlir.constant(4 : i64) : i64
%1083 = llvm.getelementptr %1064[0, %1082] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1070, %1083 : i64, !llvm.ptr
%1084 = llvm.mlir.constant(5 : i64) : i64
%1085 = llvm.getelementptr %1064[0, %1084] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1071, %1085 : i64, !llvm.ptr
%1086 = llvm.mlir.constant(6 : i64) : i64
%1087 = llvm.getelementptr %1064[0, %1086] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1072, %1087 : i64, !llvm.ptr
%1088 = llvm.mlir.constant(7 : i64) : i64
%1089 = llvm.getelementptr %1064[0, %1088] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
llvm.store %1073, %1089 : i64, !llvm.ptr
%1090 = arith.constant 0 : i32
%1091 = arith.extsi %1090 : i32 to i64
%1092 = llvm.mlir.constant(1 : i64) : i64
%1093 = llvm.alloca %1092 x i64 : (i64) -> !llvm.ptr
llvm.store %1091, %1093 : i64, !llvm.ptr
%1094 = arith.constant 1 : i32
%1095 = arith.extsi %1094 : i32 to i64
%1096 = llvm.mlir.constant(1 : i64) : i64
%1097 = llvm.alloca %1096 x i64 : (i64) -> !llvm.ptr
llvm.store %1095, %1097 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%1098 = llvm.load %1097 : !llvm.ptr -> i64
%1099 = arith.constant 16 : i32
%1101 = arith.extsi %1099 : i32 to i64
%1100 = arith.cmpi slt, %1098, %1101 : i64
cf.cond_br %1100, ^bb76, ^bb77
^bb76:
%1102 = arith.constant 0 : i32
%1103 = arith.extsi %1102 : i32 to i64
%1104 = llvm.mlir.constant(1 : i64) : i64
%1105 = llvm.alloca %1104 x i64 : (i64) -> !llvm.ptr
llvm.store %1103, %1105 : i64, !llvm.ptr
%1106 = llvm.load %1097 : !llvm.ptr -> i64
%1107 = arith.constant 8 : i32
%1109 = arith.extsi %1107 : i32 to i64
%1108 = arith.cmpi slt, %1106, %1109 : i64
cf.cond_br %1108, ^bb78, ^bb79
^bb78:
%1111 = llvm.load %1097 : !llvm.ptr -> i64
%1112 = llvm.getelementptr %1064[0, %1111] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
%1110 = llvm.load %1112 : !llvm.ptr -> i64
llvm.store %1110, %1105 : i64, !llvm.ptr
cf.br ^bb80
^bb79:
%1114 = llvm.load %1097 : !llvm.ptr -> i64
%1115 = arith.constant 8 : i32
%1117 = arith.extsi %1115 : i32 to i64
%1116 = arith.subi %1114, %1117 : i64
%1118 = llvm.getelementptr %1064[0, %1116] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<8 x i64>
%1113 = llvm.load %1118 : !llvm.ptr -> i64
%1119 = arith.constant 1 : i32
%1121 = arith.extsi %1119 : i32 to i64
%1120 = arith.addi %1113, %1121 : i64
%1122 = func.call @f2_iter_mod5(%1113, %1120, %360, %363, %366, %369, %372, %375, %378, %381, %384, %359) : (i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> i64
%1123 = func.call @f2_iter_mod2(%1113, %1120) : (i64, i64) -> i64
%1124 = func.call @crt_1e9(%1123, %1122) : (i64, i64) -> i64
llvm.store %1124, %1105 : i64, !llvm.ptr
cf.br ^bb80
^bb80:
%1125 = llvm.load %1105 : !llvm.ptr -> i64
%1126 = arith.constant 2 : i32
%1128 = arith.extsi %1126 : i32 to i64
%1127 = arith.subi %1125, %1128 : i64
%1129 = arith.remsi %1127, %357 : i64
%1130 = llvm.mlir.constant(1 : i64) : i64
%1131 = llvm.alloca %1130 x i64 : (i64) -> !llvm.ptr
llvm.store %1129, %1131 : i64, !llvm.ptr
%1132 = llvm.load %1131 : !llvm.ptr -> i64
%1133 = arith.constant 0 : i32
%1135 = arith.extsi %1133 : i32 to i64
%1134 = arith.cmpi slt, %1132, %1135 : i64
cf.cond_br %1134, ^bb81, ^bb82
^bb81:
%1136 = llvm.load %1131 : !llvm.ptr -> i64
%1137 = arith.addi %1136, %357 : i64
llvm.store %1137, %1131 : i64, !llvm.ptr
cf.br ^bb83
^bb82:
cf.br ^bb83
^bb83:
%1138 = llvm.load %1093 : !llvm.ptr -> i64
%1139 = llvm.load %1131 : !llvm.ptr -> i64
%1140 = arith.addi %1138, %1139 : i64
%1141 = arith.remsi %1140, %357 : i64
llvm.store %1141, %1093 : i64, !llvm.ptr
%1142 = llvm.load %1097 : !llvm.ptr -> i64
%1143 = arith.constant 1 : i32
%1145 = arith.extsi %1143 : i32 to i64
%1144 = arith.addi %1142, %1145 : i64
llvm.store %1144, %1097 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
%1146 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1147 = llvm.load %1093 : !llvm.ptr -> i64
%1148 = llvm.call @printf(%1146, %1147) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
func.call @free(%384) : (!llvm.ptr) -> ()
func.call @free(%381) : (!llvm.ptr) -> ()
func.call @free(%378) : (!llvm.ptr) -> ()
func.call @free(%375) : (!llvm.ptr) -> ()
func.call @free(%372) : (!llvm.ptr) -> ()
func.call @free(%369) : (!llvm.ptr) -> ()
func.call @free(%366) : (!llvm.ptr) -> ()
func.call @free(%363) : (!llvm.ptr) -> ()
func.call @free(%360) : (!llvm.ptr) -> ()
%1158 = arith.constant 0 : i32
func.return %1158 : i32
}
}