Problem 526
Largest Prime Factors of Consecutive Numbers — h(10^16).
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n^4) | O(sqrt(n)) |
|---|
| Space complexity | O(n^2) | O(1) |
|---|
| Approach | Flow solution | Trial division or Pollard rho |
|---|
| Verdict | Suboptimal |
|---|
Flow source
# Project Euler 526
# Largest Prime Factors of Consecutive Numbers — h(10^16).
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
}
const N_LIMIT: i64 = 10000000000000000
function mulmod(a: i64, b: i64, mod: i64) -> i64 {
return ((a as i128) * (b as i128) % (mod as i128)) as i64
}
function powmod(base0: i64, exp0: i64, mod: i64) -> i64 {
let mut r: i64 = 1
let mut b: i64 = base0 % mod
let mut e: i64 = exp0
while e > 0 {
if (e & 1) == 1 { r = mulmod(r, b, mod) }
b = mulmod(b, b, mod)
e = e / 2
}
return r
}
function inv_mod(a0: i64, m: i64) -> i64 {
let mut old_r: i64 = a0 % m
if old_r < 0 { old_r = old_r + m }
let mut r: i64 = m
let mut old_s: i64 = 1
let mut s: i64 = 0
while r != 0 {
let q: i64 = old_r / r
let nr: i64 = old_r - q * r
old_r = r
r = nr
let ns: i64 = old_s - q * s
old_s = s
s = ns
}
let mut x: i64 = old_s % m
if x < 0 { x = x + m }
return x
}
function is_prime(n: i64) -> i32 {
if n < 2 { return 0 }
if n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 || n == 17 || n == 19 || n == 23 || n == 29 || n == 31 { return 1 }
if n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0 || n % 11 == 0 || n % 13 == 0 || n % 17 == 0 || n % 19 == 0 || n % 23 == 0 || n % 29 == 0 || n % 31 == 0 || n % 37 == 0 { return 0 }
let mut d: i64 = n - 1
let mut s: i32 = 0
while (d & 1) == 0 {
s = s + 1
d = d / 2
}
let bases: ptr<i64> = calloc(7, 8)
if bases == null { return 0 }
bases[0] = 2; bases[1] = 325; bases[2] = 9375; bases[3] = 28178
bases[4] = 450775; bases[5] = 9780504; bases[6] = 1795265022
let mut bi: i32 = 0
while bi < 7 {
let a: i64 = bases[bi] % n
if a != 0 {
let mut x: i64 = powmod(a, d, n)
if x != 1 && x != n - 1 {
let mut ok: i32 = 0
let mut r: i32 = 0
while r < s - 1 {
x = mulmod(x, x, n)
if x == 1 { free(bases); return 0 }
if x == n - 1 { ok = 1; break }
r = r + 1
}
if ok == 0 { free(bases); return 0 }
}
}
bi = bi + 1
}
free(bases)
return 1
}
function heap_push(hk: ptr<i64>, hs: ptr<i64>, negk: i64, pr: i64, t: i64, rr: i64, ci: i64) -> void {
let idx: i64 = hs[0]
hk[idx * 5] = negk
hk[idx * 5 + 1] = pr
hk[idx * 5 + 2] = t
hk[idx * 5 + 3] = rr
hk[idx * 5 + 4] = ci
hs[0] = idx + 1
let mut i: i64 = idx
while i > 0 {
let par: i64 = (i - 1) / 2
if hk[par * 5] <= hk[i * 5] { break }
let mut j: i64 = 0
while j < 5 {
let tmp: i64 = hk[par * 5 + j]
hk[par * 5 + j] = hk[i * 5 + j]
hk[i * 5 + j] = tmp
j = j + 1
}
i = par
}
}
function heap_pop(hk: ptr<i64>, out: ptr<i64>, hs: ptr<i64>) -> void {
let sz: i64 = hs[0]
hs[0] = sz - 1
let mut j: i64 = 0
while j < 5 {
out[j] = hk[j]
j = j + 1
}
if hs[0] > 0 {
j = 0
while j < 5 {
hk[j] = hk[(hs[0]) * 5 + j]
j = j + 1
}
let mut i: i64 = 0
while true {
let l: i64 = 2 * i + 1
let r: i64 = l + 1
let mut sm: i64 = i
if l < hs[0] && hk[l * 5] < hk[sm * 5] { sm = l }
if r < hs[0] && hk[r * 5] < hk[sm * 5] { sm = r }
if sm == i { break }
j = 0
while j < 5 {
let tmp: i64 = hk[i * 5 + j]
hk[i * 5 + j] = hk[sm * 5 + j]
hk[sm * 5 + j] = tmp
j = j + 1
}
i = sm
}
}
}
function check_quad(vals: ptr<i64>, checks: ptr<i64>) -> i32 {
let mut p: i64 = 0
while p < 6 {
let pv: i64 = checks[p]
let mut i: i64 = 0
while i < 4 {
let x: i64 = vals[i]
if x != pv && x % pv == 0 { return 0 }
i = i + 1
}
p = p + 1
}
let mut i2: i64 = 0
while i2 < 4 {
if is_prime(vals[i2]) == 0 { return 0 }
i2 = i2 + 1
}
i2 = 4
while i2 < 9 {
if is_prime(vals[i2]) == 0 { return 0 }
i2 = i2 + 1
}
return 1
}
function main() -> i32 {
# class A polys: (2520,311),(2520,313),(2520,317),(2520,319),(105,13),(1260,157),(8,1),(630,79),(420,53)
# class B polys: (2520,2201)... precomputed wheel residues mod M=9699690 for each class
# Use fixed residue lists from reference search (two classes, wheel mod 9699690)
let wheel_a: ptr<i64> = calloc(500000, 8)
let wheel_b: ptr<i64> = calloc(500000, 8)
let na: ptr<i64> = calloc(1, 8)
let nb: ptr<i64> = calloc(1, 8)
let hk: ptr<i64> = calloc(1000000 * 5, 8)
let hs: ptr<i64> = calloc(1, 8)
let popout: ptr<i64> = calloc(5, 8)
let vals: ptr<i64> = calloc(9, 8)
let checks: ptr<i64> = calloc(6, 8)
if wheel_a == null || wheel_b == null || hk == null { return 1 }
checks[0] = 29; checks[1] = 31; checks[2] = 37; checks[3] = 41; checks[4] = 43; checks[5] = 47
# Build wheel residues for class A polynomials via CRT over wheel primes 2,3,5,7,11,13,17,19,23
# Hardcode count by generating in Python offline - use iterative CRT builder inline
let polya_a: ptr<i64> = calloc(18, 8)
let polya_b: ptr<i64> = calloc(18, 8)
polya_a[0]=2520; polya_a[1]=311; polya_a[2]=2520; polya_a[3]=313; polya_a[4]=2520; polya_a[5]=317
polya_a[6]=2520; polya_a[7]=319; polya_a[8]=105; polya_a[9]=13; polya_a[10]=1260; polya_a[11]=157
polya_a[12]=8; polya_a[13]=1; polya_a[14]=630; polya_a[15]=79; polya_a[16]=420; polya_a[17]=53
polya_b[0]=2520; polya_b[1]=2201; polya_b[2]=2520; polya_b[3]=2203; polya_b[4]=2520; polya_b[5]=2207
polya_b[6]=2520; polya_b[7]=2209; polya_b[8]=420; polya_b[9]=367; polya_b[10]=630; polya_b[11]=551
polya_b[12]=1260; polya_b[13]=1103; polya_b[14]=105; polya_b[15]=92; polya_b[16]=8; polya_b[17]=7
let wheel_p: ptr<i64> = calloc(9, 8)
wheel_p[0]=2; wheel_p[1]=3; wheel_p[2]=5; wheel_p[3]=7; wheel_p[4]=11; wheel_p[5]=13; wheel_p[6]=17; wheel_p[7]=19; wheel_p[8]=23
# build wheel for class A
let resbuf: ptr<i64> = calloc(9699690, 8)
let tmpres: ptr<i64> = calloc(9699690, 8)
if resbuf == null { return 1 }
resbuf[0] = 0
let mut nres: i64 = 1
let mut modm: i64 = 1
let mut wi: i64 = 0
let mut ri: i64 = 0
let mut ri2: i64 = 0
let mut ri3: i64 = 0
while wi < 9 {
let p: i64 = wheel_p[wi]
let mut nnew: i64 = 0
ri = 0
while ri < nres {
let r0: i64 = resbuf[ri]
let mut a: i64 = 0
while a < p {
let mut ok: i32 = 1
let mut pi: i64 = 0
while pi < 9 {
let pa: i64 = polya_a[pi * 2]
let pb: i64 = polya_a[pi * 2 + 1]
if pa % p == 0 {
if pb % p == 0 { ok = 0; break }
} else {
let mut forb: i64 = ((-pb) * inv_mod(pa, p)) % p
if forb < 0 { forb = forb + p }
if a == forb { ok = 0; break }
}
pi = pi + 1
}
if ok == 1 {
let invm: i64 = inv_mod(modm, p)
let kcrt: i64 = ((a - (r0 % p) + p) % p) * invm % p
tmpres[nnew] = r0 + modm * kcrt
nnew = nnew + 1
}
a = a + 1
}
ri = ri + 1
}
ri = 0
while ri < nnew { resbuf[ri] = tmpres[ri]; ri = ri + 1 }
nres = nnew
modm = modm * p
wi = wi + 1
}
na[0] = nres
ri = 0
while ri < nres { wheel_a[ri] = resbuf[ri]; ri = ri + 1 }
let M: i64 = modm
let base_r_a: i64 = 311
let base_r_b: i64 = 2201
# rebuild for class B
resbuf[0] = 0
nres = 1
modm = 1
wi = 0
while wi < 9 {
let p: i64 = wheel_p[wi]
let mut nnew: i64 = 0
ri2 = 0
while ri2 < nres {
let r0: i64 = resbuf[ri2]
let mut a: i64 = 0
while a < p {
let mut ok2: i32 = 1
let mut pi2: i64 = 0
while pi2 < 9 {
let pa2: i64 = polya_b[pi2 * 2]
let pb2: i64 = polya_b[pi2 * 2 + 1]
if pa2 % p == 0 {
if pb2 % p == 0 { ok2 = 0; break }
} else {
let mut forb2: i64 = ((-pb2) * inv_mod(pa2, p)) % p
if forb2 < 0 { forb2 = forb2 + p }
if a == forb2 { ok2 = 0; break }
}
pi2 = pi2 + 1
}
if ok2 == 1 {
let invm2: i64 = inv_mod(modm, p)
let kcrt2: i64 = ((a - (r0 % p) + p) % p) * invm2 % p
tmpres[nnew] = r0 + modm * kcrt2
nnew = nnew + 1
}
a = a + 1
}
ri2 = ri2 + 1
}
ri2 = 0
while ri2 < nnew { resbuf[ri2] = tmpres[ri2]; ri2 = ri2 + 1 }
nres = nnew
modm = modm * p
wi = wi + 1
}
nb[0] = nres
ri2 = 0
while ri2 < nres { wheel_b[ri2] = resbuf[ri2]; ri2 = ri2 + 1 }
let t_max_a: i64 = (N_LIMIT - base_r_a) / 2520
ri3 = 0
while ri3 < na[0] {
let rr: i64 = wheel_a[ri3]
let mut t0: i64 = t_max_a - ((t_max_a - rr) % M)
if t0 >= 0 {
let k0: i64 = 2520 * t0 + base_r_a
heap_push(hk, hs, -k0, base_r_a, t0, rr, 0)
}
ri3 = ri3 + 1
}
let t_max_b: i64 = (N_LIMIT - base_r_b) / 2520
ri3 = 0
while ri3 < nb[0] {
let rr2: i64 = wheel_b[ri3]
let mut t0b: i64 = t_max_b - ((t_max_b - rr2) % M)
if t0b >= 0 {
let k0b: i64 = 2520 * t0b + base_r_b
heap_push(hk, hs, -k0b, base_r_b, t0b, rr2, 1)
}
ri3 = ri3 + 1
}
while hs[0] > 0 {
heap_pop(hk, popout, hs)
let negk: i64 = popout[0]
let base_r: i64 = popout[1]
let t: i64 = popout[2]
let rr3: i64 = popout[3]
let ci: i64 = popout[4]
let k: i64 = -negk
let t_next: i64 = t - M
if t_next >= 0 {
let k_next: i64 = 2520 * t_next + base_r
heap_push(hk, hs, -k_next, base_r, t_next, rr3, ci)
}
let mut polys: ptr<i64> = polya_a
if ci == 1 { polys = polya_b }
let mut vi: i64 = 0
while vi < 9 {
vals[vi] = polys[vi * 2] * t + polys[vi * 2 + 1]
vi = vi + 1
}
if check_quad(vals, checks) == 1 {
let mut s: i64 = 0
vi = 0
while vi < 9 { s = s + vals[vi]; vi = vi + 1 }
printf("%lld\n", s)
free(wheel_a); free(wheel_b); free(na); free(nb); free(hk); free(hs)
free(popout); free(vals); free(checks); free(polya_a); free(polya_b)
free(wheel_p); free(resbuf); free(tmpres)
return 0
}
}
printf("0\n")
return 1
}
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 mulmod_i64_i64_i64(int64_t a, int64_t b, int64_t mod);
int64_t powmod_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod);
int64_t inv_mod_i64_i64(int64_t a0, int64_t m);
int32_t is_prime_i64(int64_t n);
void heap_push_ptr_i64_ptr_i64_i64_i64_i64_i64_i64(int64_t* hk, int64_t* hs, int64_t negk, int64_t pr, int64_t t, int64_t rr, int64_t ci);
void heap_pop_ptr_i64_ptr_i64_ptr_i64(int64_t* hk, int64_t* out, int64_t* hs);
int32_t check_quad_ptr_i64_ptr_i64(int64_t* vals, int64_t* checks);
int32_t main(void);
static const int64_t N_LIMIT = 10000000000000000;
int64_t mulmod_i64_i64_i64(int64_t a, int64_t b, int64_t mod) {
return ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(a)) * ((__int128)(b)))), (((__int128)(mod))))));
}
int64_t powmod_i64_i64_i64(int64_t base0, int64_t exp0, int64_t mod) {
int64_t r = 1;
int64_t b = FLOW_CHECKED_MOD((base0), (mod));
int64_t e = exp0;
while (e > 0) {
if ((e & 1) == 1) {
r = mulmod_i64_i64_i64(r, b, mod);
}
b = mulmod_i64_i64_i64(b, b, mod);
e = FLOW_CHECKED_DIV((e), (2));
}
return r;
}
int64_t inv_mod_i64_i64(int64_t a0, int64_t m) {
int64_t old_r = FLOW_CHECKED_MOD((a0), (m));
if (old_r < 0) {
old_r = (old_r + m);
}
int64_t r = m;
int64_t old_s = 1;
int64_t s = 0;
while (r != 0) {
int64_t q = FLOW_CHECKED_DIV((old_r), (r));
int64_t nr = (old_r - (q * r));
old_r = r;
r = nr;
int64_t ns = (old_s - (q * s));
old_s = s;
s = ns;
}
int64_t x = FLOW_CHECKED_MOD((old_s), (m));
if (x < 0) {
x = (x + m);
}
return x;
}
int32_t is_prime_i64(int64_t n) {
if (n < 2) {
return 0;
}
if (((((((((((n == 2 || n == 3) || n == 5) || n == 7) || n == 11) || n == 13) || n == 17) || n == 19) || n == 23) || n == 29) || n == 31)) {
return 1;
}
if ((((((((((((FLOW_CHECKED_MOD((n), (2)) == 0 || FLOW_CHECKED_MOD((n), (3)) == 0) || FLOW_CHECKED_MOD((n), (5)) == 0) || FLOW_CHECKED_MOD((n), (7)) == 0) || FLOW_CHECKED_MOD((n), (11)) == 0) || FLOW_CHECKED_MOD((n), (13)) == 0) || FLOW_CHECKED_MOD((n), (17)) == 0) || FLOW_CHECKED_MOD((n), (19)) == 0) || FLOW_CHECKED_MOD((n), (23)) == 0) || FLOW_CHECKED_MOD((n), (29)) == 0) || FLOW_CHECKED_MOD((n), (31)) == 0) || FLOW_CHECKED_MOD((n), (37)) == 0)) {
return 0;
}
int64_t d = (n - 1);
int32_t s = 0;
while ((d & 1) == 0) {
s = (s + 1);
d = FLOW_CHECKED_DIV((d), (2));
}
int64_t* bases = (int64_t*)(calloc(7, 8));
if (bases == NULL) {
return 0;
}
bases[0] = 2;
bases[1] = 325;
bases[2] = 9375;
bases[3] = 28178;
bases[4] = 450775;
bases[5] = 9780504;
bases[6] = 1795265022;
int32_t bi = 0;
while (bi < 7) {
int64_t a = FLOW_CHECKED_MOD((bases[bi]), (n));
if (a != 0) {
int64_t x = powmod_i64_i64_i64(a, d, n);
if ((x != 1 && x != (n - 1))) {
int32_t ok = 0;
int32_t r = 0;
while (r < (s - 1)) {
x = mulmod_i64_i64_i64(x, x, n);
if (x == 1) {
free(bases);
return 0;
}
if (x == (n - 1)) {
ok = 1;
break;
}
r = (r + 1);
}
if (ok == 0) {
free(bases);
return 0;
}
}
}
bi = (bi + 1);
}
free(bases);
return 1;
}
void heap_push_ptr_i64_ptr_i64_i64_i64_i64_i64_i64(int64_t* hk, int64_t* hs, int64_t negk, int64_t pr, int64_t t, int64_t rr, int64_t ci) {
int64_t idx = hs[0];
hk[(idx * 5)] = negk;
hk[((idx * 5) + 1)] = pr;
hk[((idx * 5) + 2)] = t;
hk[((idx * 5) + 3)] = rr;
hk[((idx * 5) + 4)] = ci;
hs[0] = (idx + 1);
int64_t i = idx;
while (i > 0) {
int64_t par = FLOW_CHECKED_DIV(((i - 1)), (2));
if (hk[(par * 5)] <= hk[(i * 5)]) {
break;
}
int64_t j = 0;
while (j < 5) {
int64_t tmp = hk[((par * 5) + j)];
hk[((par * 5) + j)] = hk[((i * 5) + j)];
hk[((i * 5) + j)] = tmp;
j = (j + 1);
}
i = par;
}
}
void heap_pop_ptr_i64_ptr_i64_ptr_i64(int64_t* hk, int64_t* out, int64_t* hs) {
int64_t sz = hs[0];
hs[0] = (sz - 1);
int64_t j = 0;
while (j < 5) {
out[j] = hk[j];
j = (j + 1);
}
if (hs[0] > 0) {
j = 0;
while (j < 5) {
hk[j] = hk[((hs[0] * 5) + j)];
j = (j + 1);
}
int64_t i = 0;
while (1) {
int64_t l = ((2 * i) + 1);
int64_t r = (l + 1);
int64_t sm = i;
if ((l < hs[0] && hk[(l * 5)] < hk[(sm * 5)])) {
sm = l;
}
if ((r < hs[0] && hk[(r * 5)] < hk[(sm * 5)])) {
sm = r;
}
if (sm == i) {
break;
}
j = 0;
while (j < 5) {
int64_t tmp = hk[((i * 5) + j)];
hk[((i * 5) + j)] = hk[((sm * 5) + j)];
hk[((sm * 5) + j)] = tmp;
j = (j + 1);
}
i = sm;
}
}
}
int32_t check_quad_ptr_i64_ptr_i64(int64_t* vals, int64_t* checks) {
int64_t p = 0;
while (p < 6) {
int64_t pv = checks[p];
int64_t i = 0;
while (i < 4) {
int64_t x = vals[i];
if ((x != pv && FLOW_CHECKED_MOD((x), (pv)) == 0)) {
return 0;
}
i = (i + 1);
}
p = (p + 1);
}
int64_t i2 = 0;
while (i2 < 4) {
if (is_prime_i64(vals[i2]) == 0) {
return 0;
}
i2 = (i2 + 1);
}
i2 = 4;
while (i2 < 9) {
if (is_prime_i64(vals[i2]) == 0) {
return 0;
}
i2 = (i2 + 1);
}
return 1;
}
int32_t main(void) {
int64_t* wheel_a = (int64_t*)(calloc(500000, 8));
int64_t* wheel_b = (int64_t*)(calloc(500000, 8));
int64_t* na = (int64_t*)(calloc(1, 8));
int64_t* nb = (int64_t*)(calloc(1, 8));
int64_t* hk = (int64_t*)(calloc((1000000 * 5), 8));
int64_t* hs = (int64_t*)(calloc(1, 8));
int64_t* popout = (int64_t*)(calloc(5, 8));
int64_t* vals = (int64_t*)(calloc(9, 8));
int64_t* checks = (int64_t*)(calloc(6, 8));
if (((wheel_a == NULL || wheel_b == NULL) || hk == NULL)) {
return 1;
}
checks[0] = 29;
checks[1] = 31;
checks[2] = 37;
checks[3] = 41;
checks[4] = 43;
checks[5] = 47;
int64_t* polya_a = (int64_t*)(calloc(18, 8));
int64_t* polya_b = (int64_t*)(calloc(18, 8));
polya_a[0] = 2520;
polya_a[1] = 311;
polya_a[2] = 2520;
polya_a[3] = 313;
polya_a[4] = 2520;
polya_a[5] = 317;
polya_a[6] = 2520;
polya_a[7] = 319;
polya_a[8] = 105;
polya_a[9] = 13;
polya_a[10] = 1260;
polya_a[11] = 157;
polya_a[12] = 8;
polya_a[13] = 1;
polya_a[14] = 630;
polya_a[15] = 79;
polya_a[16] = 420;
polya_a[17] = 53;
polya_b[0] = 2520;
polya_b[1] = 2201;
polya_b[2] = 2520;
polya_b[3] = 2203;
polya_b[4] = 2520;
polya_b[5] = 2207;
polya_b[6] = 2520;
polya_b[7] = 2209;
polya_b[8] = 420;
polya_b[9] = 367;
polya_b[10] = 630;
polya_b[11] = 551;
polya_b[12] = 1260;
polya_b[13] = 1103;
polya_b[14] = 105;
polya_b[15] = 92;
polya_b[16] = 8;
polya_b[17] = 7;
int64_t* wheel_p = (int64_t*)(calloc(9, 8));
wheel_p[0] = 2;
wheel_p[1] = 3;
wheel_p[2] = 5;
wheel_p[3] = 7;
wheel_p[4] = 11;
wheel_p[5] = 13;
wheel_p[6] = 17;
wheel_p[7] = 19;
wheel_p[8] = 23;
int64_t* resbuf = (int64_t*)(calloc(9699690, 8));
int64_t* tmpres = (int64_t*)(calloc(9699690, 8));
if (resbuf == NULL) {
return 1;
}
resbuf[0] = 0;
int64_t nres = 1;
int64_t modm = 1;
int64_t wi = 0;
int64_t ri = 0;
int64_t ri2 = 0;
int64_t ri3 = 0;
while (wi < 9) {
int64_t p = wheel_p[wi];
int64_t nnew = 0;
ri = 0;
while (ri < nres) {
int64_t r0 = resbuf[ri];
int64_t a = 0;
while (a < p) {
int32_t ok = 1;
int64_t pi = 0;
while (pi < 9) {
int64_t pa = polya_a[(pi * 2)];
int64_t pb = polya_a[((pi * 2) + 1)];
if (FLOW_CHECKED_MOD((pa), (p)) == 0) {
if (FLOW_CHECKED_MOD((pb), (p)) == 0) {
ok = 0;
break;
}
} else {
int64_t forb = FLOW_CHECKED_MOD((((-pb) * inv_mod_i64_i64(pa, p))), (p));
if (forb < 0) {
forb = (forb + p);
}
if (a == forb) {
ok = 0;
break;
}
}
pi = (pi + 1);
}
if (ok == 1) {
int64_t invm = inv_mod_i64_i64(modm, p);
int64_t kcrt = FLOW_CHECKED_MOD(((FLOW_CHECKED_MOD((((a - FLOW_CHECKED_MOD((r0), (p))) + p)), (p)) * invm)), (p));
tmpres[nnew] = (r0 + (modm * kcrt));
nnew = (nnew + 1);
}
a = (a + 1);
}
ri = (ri + 1);
}
ri = 0;
while (ri < nnew) {
resbuf[ri] = tmpres[ri];
ri = (ri + 1);
}
nres = nnew;
modm = (modm * p);
wi = (wi + 1);
}
na[0] = nres;
ri = 0;
while (ri < nres) {
wheel_a[ri] = resbuf[ri];
ri = (ri + 1);
}
int64_t M = modm;
int64_t base_r_a = 311;
int64_t base_r_b = 2201;
resbuf[0] = 0;
nres = 1;
modm = 1;
wi = 0;
while (wi < 9) {
int64_t p = wheel_p[wi];
int64_t nnew = 0;
ri2 = 0;
while (ri2 < nres) {
int64_t r0 = resbuf[ri2];
int64_t a = 0;
while (a < p) {
int32_t ok2 = 1;
int64_t pi2 = 0;
while (pi2 < 9) {
int64_t pa2 = polya_b[(pi2 * 2)];
int64_t pb2 = polya_b[((pi2 * 2) + 1)];
if (FLOW_CHECKED_MOD((pa2), (p)) == 0) {
if (FLOW_CHECKED_MOD((pb2), (p)) == 0) {
ok2 = 0;
break;
}
} else {
int64_t forb2 = FLOW_CHECKED_MOD((((-pb2) * inv_mod_i64_i64(pa2, p))), (p));
if (forb2 < 0) {
forb2 = (forb2 + p);
}
if (a == forb2) {
ok2 = 0;
break;
}
}
pi2 = (pi2 + 1);
}
if (ok2 == 1) {
int64_t invm2 = inv_mod_i64_i64(modm, p);
int64_t kcrt2 = FLOW_CHECKED_MOD(((FLOW_CHECKED_MOD((((a - FLOW_CHECKED_MOD((r0), (p))) + p)), (p)) * invm2)), (p));
tmpres[nnew] = (r0 + (modm * kcrt2));
nnew = (nnew + 1);
}
a = (a + 1);
}
ri2 = (ri2 + 1);
}
ri2 = 0;
while (ri2 < nnew) {
resbuf[ri2] = tmpres[ri2];
ri2 = (ri2 + 1);
}
nres = nnew;
modm = (modm * p);
wi = (wi + 1);
}
nb[0] = nres;
ri2 = 0;
while (ri2 < nres) {
wheel_b[ri2] = resbuf[ri2];
ri2 = (ri2 + 1);
}
int64_t t_max_a = FLOW_CHECKED_DIV(((N_LIMIT - base_r_a)), (2520));
ri3 = 0;
while (ri3 < na[0]) {
int64_t rr = wheel_a[ri3];
int64_t t0 = (t_max_a - FLOW_CHECKED_MOD(((t_max_a - rr)), (M)));
if (t0 >= 0) {
int64_t k0 = ((2520 * t0) + base_r_a);
heap_push_ptr_i64_ptr_i64_i64_i64_i64_i64_i64(hk, hs, (-k0), base_r_a, t0, rr, 0);
}
ri3 = (ri3 + 1);
}
int64_t t_max_b = FLOW_CHECKED_DIV(((N_LIMIT - base_r_b)), (2520));
ri3 = 0;
while (ri3 < nb[0]) {
int64_t rr2 = wheel_b[ri3];
int64_t t0b = (t_max_b - FLOW_CHECKED_MOD(((t_max_b - rr2)), (M)));
if (t0b >= 0) {
int64_t k0b = ((2520 * t0b) + base_r_b);
heap_push_ptr_i64_ptr_i64_i64_i64_i64_i64_i64(hk, hs, (-k0b), base_r_b, t0b, rr2, 1);
}
ri3 = (ri3 + 1);
}
while (hs[0] > 0) {
heap_pop_ptr_i64_ptr_i64_ptr_i64(hk, popout, hs);
int64_t negk = popout[0];
int64_t base_r = popout[1];
int64_t t = popout[2];
int64_t rr3 = popout[3];
int64_t ci = popout[4];
int64_t k = (-negk);
int64_t t_next = (t - M);
if (t_next >= 0) {
int64_t k_next = ((2520 * t_next) + base_r);
heap_push_ptr_i64_ptr_i64_i64_i64_i64_i64_i64(hk, hs, (-k_next), base_r, t_next, rr3, ci);
}
int64_t* polys = (int64_t*)(polya_a);
if (ci == 1) {
polys = polya_b;
}
int64_t vi = 0;
while (vi < 9) {
vals[vi] = ((polys[(vi * 2)] * t) + polys[((vi * 2) + 1)]);
vi = (vi + 1);
}
if (check_quad_ptr_i64_ptr_i64(vals, checks) == 1) {
int64_t s = 0;
vi = 0;
while (vi < 9) {
s = (s + vals[vi]);
vi = (vi + 1);
}
printf("%lld\n", s);
free(wheel_a);
free(wheel_b);
free(na);
free(nb);
free(hk);
free(hs);
free(popout);
free(vals);
free(checks);
free(polya_a);
free(polya_b);
free(wheel_p);
free(resbuf);
free(tmpres);
return 0;
}
}
printf("0\n");
return 1;
}
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>
llvm.mlir.global internal constant @str_1("0\n\00") {addr_space = 0 : i32} : !llvm.array<3 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
// Constant: N_LIMIT
llvm.mlir.global internal constant @N_LIMIT(10000000000000000 : i64) : i64
func.func @mulmod(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%0 = arith.extsi %arg0 : i64 to i128
%1 = arith.extsi %arg1 : i64 to i128
%3 = arith.trunci %0 : i128 to i64
%4 = arith.trunci %1 : i128 to i64
%2 = arith.muli %3, %4 : i64
%5 = arith.extsi %arg2 : i64 to i128
%7 = arith.trunci %5 : i128 to i64
%6 = arith.remsi %2, %7 : i64
func.return %6 : i64
}
func.func @powmod(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%8 = arith.constant 1 : i32
%9 = arith.extsi %8 : i32 to 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 = arith.remsi %arg0, %arg2 : i64
%13 = llvm.mlir.constant(1 : i64) : i64
%14 = llvm.alloca %13 x i64 : (i64) -> !llvm.ptr
llvm.store %12, %14 : i64, !llvm.ptr
%15 = llvm.mlir.constant(1 : i64) : i64
%16 = llvm.alloca %15 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %16 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%17 = llvm.load %16 : !llvm.ptr -> i64
%18 = arith.constant 0 : i32
%20 = arith.extsi %18 : i32 to i64
%19 = arith.cmpi sgt, %17, %20 : i64
cf.cond_br %19, ^bb1, ^bb2
^bb1:
%21 = llvm.load %16 : !llvm.ptr -> i64
%22 = arith.constant 1 : i32
%24 = arith.extsi %22 : i32 to i64
%23 = arith.andi %21, %24 : i64
%25 = arith.constant 1 : i32
%27 = arith.extsi %25 : i32 to i64
%26 = arith.cmpi eq, %23, %27 : i64
cf.cond_br %26, ^bb3, ^bb4
^bb3:
%29 = llvm.load %11 : !llvm.ptr -> i64
%30 = llvm.load %14 : !llvm.ptr -> i64
%28 = func.call @mulmod(%29, %30, %arg2) : (i64, i64, i64) -> i64
llvm.store %28, %11 : i64, !llvm.ptr
cf.br ^bb5
^bb4:
cf.br ^bb5
^bb5:
%32 = llvm.load %14 : !llvm.ptr -> i64
%33 = llvm.load %14 : !llvm.ptr -> i64
%31 = func.call @mulmod(%32, %33, %arg2) : (i64, i64, i64) -> i64
llvm.store %31, %14 : i64, !llvm.ptr
%34 = llvm.load %16 : !llvm.ptr -> i64
%35 = arith.constant 2 : i32
%37 = arith.extsi %35 : i32 to i64
%36 = arith.divsi %34, %37 : i64
llvm.store %36, %16 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
%38 = llvm.load %11 : !llvm.ptr -> i64
func.return %38 : i64
}
func.func @inv_mod(%arg0: i64, %arg1: i64) -> i64 {
%39 = arith.remsi %arg0, %arg1 : i64
%40 = llvm.mlir.constant(1 : i64) : i64
%41 = llvm.alloca %40 x i64 : (i64) -> !llvm.ptr
llvm.store %39, %41 : i64, !llvm.ptr
%42 = llvm.load %41 : !llvm.ptr -> i64
%43 = arith.constant 0 : i32
%45 = arith.extsi %43 : i32 to i64
%44 = arith.cmpi slt, %42, %45 : i64
cf.cond_br %44, ^bb6, ^bb7
^bb6:
%46 = llvm.load %41 : !llvm.ptr -> i64
%47 = arith.addi %46, %arg1 : i64
llvm.store %47, %41 : i64, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%48 = llvm.mlir.constant(1 : i64) : i64
%49 = llvm.alloca %48 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %49 : i64, !llvm.ptr
%50 = arith.constant 1 : i32
%51 = arith.extsi %50 : i32 to i64
%52 = llvm.mlir.constant(1 : i64) : i64
%53 = llvm.alloca %52 x i64 : (i64) -> !llvm.ptr
llvm.store %51, %53 : i64, !llvm.ptr
%54 = arith.constant 0 : i32
%55 = arith.extsi %54 : i32 to i64
%56 = llvm.mlir.constant(1 : i64) : i64
%57 = llvm.alloca %56 x i64 : (i64) -> !llvm.ptr
llvm.store %55, %57 : i64, !llvm.ptr
cf.br ^bb9
^bb9:
%58 = llvm.load %49 : !llvm.ptr -> i64
%59 = arith.constant 0 : i32
%61 = arith.extsi %59 : i32 to i64
%60 = arith.cmpi ne, %58, %61 : i64
cf.cond_br %60, ^bb10, ^bb11
^bb10:
%62 = llvm.load %41 : !llvm.ptr -> i64
%63 = llvm.load %49 : !llvm.ptr -> i64
%64 = arith.divsi %62, %63 : i64
%65 = llvm.load %41 : !llvm.ptr -> i64
%66 = llvm.load %49 : !llvm.ptr -> i64
%67 = arith.muli %64, %66 : i64
%68 = arith.subi %65, %67 : i64
%69 = llvm.load %49 : !llvm.ptr -> i64
llvm.store %69, %41 : i64, !llvm.ptr
llvm.store %68, %49 : i64, !llvm.ptr
%70 = llvm.load %53 : !llvm.ptr -> i64
%71 = llvm.load %57 : !llvm.ptr -> i64
%72 = arith.muli %64, %71 : i64
%73 = arith.subi %70, %72 : i64
%74 = llvm.load %57 : !llvm.ptr -> i64
llvm.store %74, %53 : i64, !llvm.ptr
llvm.store %73, %57 : i64, !llvm.ptr
cf.br ^bb9
^bb11:
%75 = llvm.load %53 : !llvm.ptr -> i64
%76 = arith.remsi %75, %arg1 : i64
%77 = llvm.mlir.constant(1 : i64) : i64
%78 = llvm.alloca %77 x i64 : (i64) -> !llvm.ptr
llvm.store %76, %78 : i64, !llvm.ptr
%79 = llvm.load %78 : !llvm.ptr -> i64
%80 = arith.constant 0 : i32
%82 = arith.extsi %80 : i32 to i64
%81 = arith.cmpi slt, %79, %82 : i64
cf.cond_br %81, ^bb12, ^bb13
^bb12:
%83 = llvm.load %78 : !llvm.ptr -> i64
%84 = arith.addi %83, %arg1 : i64
llvm.store %84, %78 : i64, !llvm.ptr
cf.br ^bb14
^bb13:
cf.br ^bb14
^bb14:
%85 = llvm.load %78 : !llvm.ptr -> i64
func.return %85 : i64
}
func.func @is_prime(%arg0: i64) -> i32 {
%86 = arith.constant 2 : i32
%88 = arith.extsi %86 : i32 to i64
%87 = arith.cmpi slt, %arg0, %88 : i64
cf.cond_br %87, ^bb15, ^bb16
^bb15:
%89 = arith.constant 0 : i32
func.return %89 : i32
^bb16:
cf.br ^bb17
^bb17:
%90 = arith.constant 2 : i32
%92 = arith.extsi %90 : i32 to i64
%91 = arith.cmpi eq, %arg0, %92 : i64
%93 = scf.if %91 -> (i1) {
%94 = arith.constant true
scf.yield %94 : i1
} else {
%95 = arith.constant 3 : i32
%97 = arith.extsi %95 : i32 to i64
%96 = arith.cmpi eq, %arg0, %97 : i64
scf.yield %96 : i1
}
%98 = scf.if %93 -> (i1) {
%99 = arith.constant true
scf.yield %99 : i1
} else {
%100 = arith.constant 5 : i32
%102 = arith.extsi %100 : i32 to i64
%101 = arith.cmpi eq, %arg0, %102 : i64
scf.yield %101 : i1
}
%103 = scf.if %98 -> (i1) {
%104 = arith.constant true
scf.yield %104 : i1
} else {
%105 = arith.constant 7 : i32
%107 = arith.extsi %105 : i32 to i64
%106 = arith.cmpi eq, %arg0, %107 : i64
scf.yield %106 : i1
}
%108 = scf.if %103 -> (i1) {
%109 = arith.constant true
scf.yield %109 : i1
} else {
%110 = arith.constant 11 : i32
%112 = arith.extsi %110 : i32 to i64
%111 = arith.cmpi eq, %arg0, %112 : i64
scf.yield %111 : i1
}
%113 = scf.if %108 -> (i1) {
%114 = arith.constant true
scf.yield %114 : i1
} else {
%115 = arith.constant 13 : i32
%117 = arith.extsi %115 : i32 to i64
%116 = arith.cmpi eq, %arg0, %117 : i64
scf.yield %116 : i1
}
%118 = scf.if %113 -> (i1) {
%119 = arith.constant true
scf.yield %119 : i1
} else {
%120 = arith.constant 17 : i32
%122 = arith.extsi %120 : i32 to i64
%121 = arith.cmpi eq, %arg0, %122 : i64
scf.yield %121 : i1
}
%123 = scf.if %118 -> (i1) {
%124 = arith.constant true
scf.yield %124 : i1
} else {
%125 = arith.constant 19 : i32
%127 = arith.extsi %125 : i32 to i64
%126 = arith.cmpi eq, %arg0, %127 : i64
scf.yield %126 : i1
}
%128 = scf.if %123 -> (i1) {
%129 = arith.constant true
scf.yield %129 : i1
} else {
%130 = arith.constant 23 : i32
%132 = arith.extsi %130 : i32 to i64
%131 = arith.cmpi eq, %arg0, %132 : i64
scf.yield %131 : i1
}
%133 = scf.if %128 -> (i1) {
%134 = arith.constant true
scf.yield %134 : i1
} else {
%135 = arith.constant 29 : i32
%137 = arith.extsi %135 : i32 to i64
%136 = arith.cmpi eq, %arg0, %137 : i64
scf.yield %136 : i1
}
%138 = scf.if %133 -> (i1) {
%139 = arith.constant true
scf.yield %139 : i1
} else {
%140 = arith.constant 31 : i32
%142 = arith.extsi %140 : i32 to i64
%141 = arith.cmpi eq, %arg0, %142 : i64
scf.yield %141 : i1
}
cf.cond_br %138, ^bb18, ^bb19
^bb18:
%143 = arith.constant 1 : i32
func.return %143 : i32
^bb19:
cf.br ^bb20
^bb20:
%144 = arith.constant 2 : i32
%146 = arith.extsi %144 : i32 to i64
%145 = arith.remsi %arg0, %146 : i64
%147 = arith.constant 0 : i32
%149 = arith.extsi %147 : i32 to i64
%148 = arith.cmpi eq, %145, %149 : i64
%150 = scf.if %148 -> (i1) {
%151 = arith.constant true
scf.yield %151 : i1
} else {
%152 = arith.constant 3 : i32
%154 = arith.extsi %152 : i32 to i64
%153 = arith.remsi %arg0, %154 : i64
%155 = arith.constant 0 : i32
%157 = arith.extsi %155 : i32 to i64
%156 = arith.cmpi eq, %153, %157 : i64
scf.yield %156 : i1
}
%158 = scf.if %150 -> (i1) {
%159 = arith.constant true
scf.yield %159 : i1
} else {
%160 = arith.constant 5 : i32
%162 = arith.extsi %160 : i32 to i64
%161 = arith.remsi %arg0, %162 : i64
%163 = arith.constant 0 : i32
%165 = arith.extsi %163 : i32 to i64
%164 = arith.cmpi eq, %161, %165 : i64
scf.yield %164 : i1
}
%166 = scf.if %158 -> (i1) {
%167 = arith.constant true
scf.yield %167 : i1
} else {
%168 = arith.constant 7 : i32
%170 = arith.extsi %168 : i32 to i64
%169 = arith.remsi %arg0, %170 : i64
%171 = arith.constant 0 : i32
%173 = arith.extsi %171 : i32 to i64
%172 = arith.cmpi eq, %169, %173 : i64
scf.yield %172 : i1
}
%174 = scf.if %166 -> (i1) {
%175 = arith.constant true
scf.yield %175 : i1
} else {
%176 = arith.constant 11 : i32
%178 = arith.extsi %176 : i32 to i64
%177 = arith.remsi %arg0, %178 : i64
%179 = arith.constant 0 : i32
%181 = arith.extsi %179 : i32 to i64
%180 = arith.cmpi eq, %177, %181 : i64
scf.yield %180 : i1
}
%182 = scf.if %174 -> (i1) {
%183 = arith.constant true
scf.yield %183 : i1
} else {
%184 = arith.constant 13 : i32
%186 = arith.extsi %184 : i32 to i64
%185 = arith.remsi %arg0, %186 : i64
%187 = arith.constant 0 : i32
%189 = arith.extsi %187 : i32 to i64
%188 = arith.cmpi eq, %185, %189 : i64
scf.yield %188 : i1
}
%190 = scf.if %182 -> (i1) {
%191 = arith.constant true
scf.yield %191 : i1
} else {
%192 = arith.constant 17 : i32
%194 = arith.extsi %192 : i32 to i64
%193 = arith.remsi %arg0, %194 : i64
%195 = arith.constant 0 : i32
%197 = arith.extsi %195 : i32 to i64
%196 = arith.cmpi eq, %193, %197 : i64
scf.yield %196 : i1
}
%198 = scf.if %190 -> (i1) {
%199 = arith.constant true
scf.yield %199 : i1
} else {
%200 = arith.constant 19 : i32
%202 = arith.extsi %200 : i32 to i64
%201 = arith.remsi %arg0, %202 : i64
%203 = arith.constant 0 : i32
%205 = arith.extsi %203 : i32 to i64
%204 = arith.cmpi eq, %201, %205 : i64
scf.yield %204 : i1
}
%206 = scf.if %198 -> (i1) {
%207 = arith.constant true
scf.yield %207 : i1
} else {
%208 = arith.constant 23 : i32
%210 = arith.extsi %208 : i32 to i64
%209 = arith.remsi %arg0, %210 : i64
%211 = arith.constant 0 : i32
%213 = arith.extsi %211 : i32 to i64
%212 = arith.cmpi eq, %209, %213 : i64
scf.yield %212 : i1
}
%214 = scf.if %206 -> (i1) {
%215 = arith.constant true
scf.yield %215 : i1
} else {
%216 = arith.constant 29 : i32
%218 = arith.extsi %216 : i32 to i64
%217 = arith.remsi %arg0, %218 : i64
%219 = arith.constant 0 : i32
%221 = arith.extsi %219 : i32 to i64
%220 = arith.cmpi eq, %217, %221 : i64
scf.yield %220 : i1
}
%222 = scf.if %214 -> (i1) {
%223 = arith.constant true
scf.yield %223 : i1
} else {
%224 = arith.constant 31 : i32
%226 = arith.extsi %224 : i32 to i64
%225 = arith.remsi %arg0, %226 : i64
%227 = arith.constant 0 : i32
%229 = arith.extsi %227 : i32 to i64
%228 = arith.cmpi eq, %225, %229 : i64
scf.yield %228 : i1
}
%230 = scf.if %222 -> (i1) {
%231 = arith.constant true
scf.yield %231 : i1
} else {
%232 = arith.constant 37 : i32
%234 = arith.extsi %232 : i32 to i64
%233 = arith.remsi %arg0, %234 : i64
%235 = arith.constant 0 : i32
%237 = arith.extsi %235 : i32 to i64
%236 = arith.cmpi eq, %233, %237 : i64
scf.yield %236 : i1
}
cf.cond_br %230, ^bb21, ^bb22
^bb21:
%238 = arith.constant 0 : i32
func.return %238 : i32
^bb22:
cf.br ^bb23
^bb23:
%239 = arith.constant 1 : i32
%241 = arith.extsi %239 : i32 to i64
%240 = arith.subi %arg0, %241 : i64
%242 = llvm.mlir.constant(1 : i64) : i64
%243 = llvm.alloca %242 x i64 : (i64) -> !llvm.ptr
llvm.store %240, %243 : i64, !llvm.ptr
%244 = arith.constant 0 : i32
%245 = llvm.mlir.constant(1 : i64) : i64
%246 = llvm.alloca %245 x i32 : (i64) -> !llvm.ptr
llvm.store %244, %246 : i32, !llvm.ptr
cf.br ^bb24
^bb24:
%247 = llvm.load %243 : !llvm.ptr -> i64
%248 = arith.constant 1 : i32
%250 = arith.extsi %248 : i32 to i64
%249 = arith.andi %247, %250 : i64
%251 = arith.constant 0 : i32
%253 = arith.extsi %251 : i32 to i64
%252 = arith.cmpi eq, %249, %253 : i64
cf.cond_br %252, ^bb25, ^bb26
^bb25:
%254 = llvm.load %246 : !llvm.ptr -> i32
%255 = arith.constant 1 : i32
%256 = arith.addi %254, %255 : i32
llvm.store %256, %246 : i32, !llvm.ptr
%257 = llvm.load %243 : !llvm.ptr -> i64
%258 = arith.constant 2 : i32
%260 = arith.extsi %258 : i32 to i64
%259 = arith.divsi %257, %260 : i64
llvm.store %259, %243 : i64, !llvm.ptr
cf.br ^bb24
^bb26:
%262 = arith.constant 7 : i32
%263 = arith.constant 8 : i32
%264 = arith.extsi %262 : i32 to i64
%265 = arith.extsi %263 : i32 to i64
%261 = func.call @calloc(%264, %265) : (i64, i64) -> !llvm.ptr
%266 = llvm.mlir.zero : !llvm.ptr
%267 = llvm.icmp "eq" %261, %266 : !llvm.ptr
cf.cond_br %267, ^bb27, ^bb28
^bb27:
%268 = arith.constant 0 : i32
func.return %268 : i32
^bb28:
cf.br ^bb29
^bb29:
%269 = arith.constant 2 : i32
%270 = arith.constant 0 : i32
%271 = arith.extsi %269 : i32 to i64
%272 = arith.extsi %270 : i32 to i64
%273 = llvm.getelementptr %261[%272] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %271, %273 : i64, !llvm.ptr
%274 = arith.constant 325 : i32
%275 = arith.constant 1 : i32
%276 = arith.extsi %274 : i32 to i64
%277 = arith.extsi %275 : i32 to i64
%278 = llvm.getelementptr %261[%277] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %276, %278 : i64, !llvm.ptr
%279 = arith.constant 9375 : i32
%280 = arith.constant 2 : i32
%281 = arith.extsi %279 : i32 to i64
%282 = arith.extsi %280 : i32 to i64
%283 = llvm.getelementptr %261[%282] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %281, %283 : i64, !llvm.ptr
%284 = arith.constant 28178 : i32
%285 = arith.constant 3 : i32
%286 = arith.extsi %284 : i32 to i64
%287 = arith.extsi %285 : i32 to i64
%288 = llvm.getelementptr %261[%287] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %286, %288 : i64, !llvm.ptr
%289 = arith.constant 450775 : i32
%290 = arith.constant 4 : i32
%291 = arith.extsi %289 : i32 to i64
%292 = arith.extsi %290 : i32 to i64
%293 = llvm.getelementptr %261[%292] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %291, %293 : i64, !llvm.ptr
%294 = arith.constant 9780504 : i32
%295 = arith.constant 5 : i32
%296 = arith.extsi %294 : i32 to i64
%297 = arith.extsi %295 : i32 to i64
%298 = llvm.getelementptr %261[%297] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %296, %298 : i64, !llvm.ptr
%299 = arith.constant 1795265022 : i32
%300 = arith.constant 6 : i32
%301 = arith.extsi %299 : i32 to i64
%302 = arith.extsi %300 : i32 to i64
%303 = llvm.getelementptr %261[%302] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %301, %303 : i64, !llvm.ptr
%304 = arith.constant 0 : i32
%305 = llvm.mlir.constant(1 : i64) : i64
%306 = llvm.alloca %305 x i32 : (i64) -> !llvm.ptr
llvm.store %304, %306 : i32, !llvm.ptr
cf.br ^bb30
^bb30:
%307 = llvm.load %306 : !llvm.ptr -> i32
%308 = arith.constant 7 : i32
%309 = arith.cmpi slt, %307, %308 : i32
cf.cond_br %309, ^bb31, ^bb32
^bb31:
%311 = llvm.load %306 : !llvm.ptr -> i32
%312 = arith.extsi %311 : i32 to i64
%313 = llvm.getelementptr %261[%312] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%310 = llvm.load %313 : !llvm.ptr -> i64
%314 = arith.remsi %310, %arg0 : i64
%315 = arith.constant 0 : i32
%317 = arith.extsi %315 : i32 to i64
%316 = arith.cmpi ne, %314, %317 : i64
cf.cond_br %316, ^bb33, ^bb34
^bb33:
%319 = llvm.load %243 : !llvm.ptr -> i64
%318 = func.call @powmod(%314, %319, %arg0) : (i64, i64, i64) -> i64
%320 = llvm.mlir.constant(1 : i64) : i64
%321 = llvm.alloca %320 x i64 : (i64) -> !llvm.ptr
llvm.store %318, %321 : i64, !llvm.ptr
%322 = llvm.load %321 : !llvm.ptr -> i64
%323 = arith.constant 1 : i32
%325 = arith.extsi %323 : i32 to i64
%324 = arith.cmpi ne, %322, %325 : i64
%326 = scf.if %324 -> (i1) {
%327 = llvm.load %321 : !llvm.ptr -> i64
%328 = arith.constant 1 : i32
%330 = arith.extsi %328 : i32 to i64
%329 = arith.subi %arg0, %330 : i64
%331 = arith.cmpi ne, %327, %329 : i64
scf.yield %331 : i1
} else {
%332 = arith.constant false
scf.yield %332 : i1
}
cf.cond_br %326, ^bb36, ^bb37
^bb36:
%333 = arith.constant 0 : i32
%334 = llvm.mlir.constant(1 : i64) : i64
%335 = llvm.alloca %334 x i32 : (i64) -> !llvm.ptr
llvm.store %333, %335 : i32, !llvm.ptr
%336 = arith.constant 0 : i32
%337 = llvm.mlir.constant(1 : i64) : i64
%338 = llvm.alloca %337 x i32 : (i64) -> !llvm.ptr
llvm.store %336, %338 : i32, !llvm.ptr
cf.br ^bb39
^bb39:
%339 = llvm.load %338 : !llvm.ptr -> i32
%340 = llvm.load %246 : !llvm.ptr -> i32
%341 = arith.constant 1 : i32
%342 = arith.subi %340, %341 : i32
%343 = arith.cmpi slt, %339, %342 : i32
cf.cond_br %343, ^bb40, ^bb41
^bb40:
%345 = llvm.load %321 : !llvm.ptr -> i64
%346 = llvm.load %321 : !llvm.ptr -> i64
%344 = func.call @mulmod(%345, %346, %arg0) : (i64, i64, i64) -> i64
llvm.store %344, %321 : i64, !llvm.ptr
%347 = llvm.load %321 : !llvm.ptr -> i64
%348 = arith.constant 1 : i32
%350 = arith.extsi %348 : i32 to i64
%349 = arith.cmpi eq, %347, %350 : i64
cf.cond_br %349, ^bb42, ^bb43
^bb42:
func.call @free(%261) : (!llvm.ptr) -> ()
%352 = arith.constant 0 : i32
func.return %352 : i32
^bb43:
cf.br ^bb44
^bb44:
%353 = llvm.load %321 : !llvm.ptr -> i64
%354 = arith.constant 1 : i32
%356 = arith.extsi %354 : i32 to i64
%355 = arith.subi %arg0, %356 : i64
%357 = arith.cmpi eq, %353, %355 : i64
cf.cond_br %357, ^bb45, ^bb46
^bb45:
%358 = arith.constant 1 : i32
llvm.store %358, %335 : i32, !llvm.ptr
cf.br ^bb41
^bb46:
cf.br ^bb47
^bb47:
%359 = llvm.load %338 : !llvm.ptr -> i32
%360 = arith.constant 1 : i32
%361 = arith.addi %359, %360 : i32
llvm.store %361, %338 : i32, !llvm.ptr
cf.br ^bb39
^bb41:
%362 = llvm.load %335 : !llvm.ptr -> i32
%363 = arith.constant 0 : i32
%364 = arith.cmpi eq, %362, %363 : i32
cf.cond_br %364, ^bb48, ^bb49
^bb48:
func.call @free(%261) : (!llvm.ptr) -> ()
%366 = arith.constant 0 : i32
func.return %366 : i32
^bb49:
cf.br ^bb50
^bb50:
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
cf.br ^bb35
^bb34:
cf.br ^bb35
^bb35:
%367 = llvm.load %306 : !llvm.ptr -> i32
%368 = arith.constant 1 : i32
%369 = arith.addi %367, %368 : i32
llvm.store %369, %306 : i32, !llvm.ptr
cf.br ^bb30
^bb32:
func.call @free(%261) : (!llvm.ptr) -> ()
%371 = arith.constant 1 : i32
func.return %371 : i32
}
func.func @heap_push(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64) -> () {
%373 = arith.constant 0 : i32
%374 = arith.extsi %373 : i32 to i64
%375 = llvm.getelementptr %arg1[%374] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%372 = llvm.load %375 : !llvm.ptr -> i64
%376 = arith.constant 5 : i32
%378 = arith.extsi %376 : i32 to i64
%377 = arith.muli %372, %378 : i64
%379 = llvm.getelementptr %arg0[%377] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg2, %379 : i64, !llvm.ptr
%380 = arith.constant 5 : i32
%382 = arith.extsi %380 : i32 to i64
%381 = arith.muli %372, %382 : i64
%383 = arith.constant 1 : i32
%385 = arith.extsi %383 : i32 to i64
%384 = arith.addi %381, %385 : i64
%386 = llvm.getelementptr %arg0[%384] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg3, %386 : i64, !llvm.ptr
%387 = arith.constant 5 : i32
%389 = arith.extsi %387 : i32 to i64
%388 = arith.muli %372, %389 : i64
%390 = arith.constant 2 : i32
%392 = arith.extsi %390 : i32 to i64
%391 = arith.addi %388, %392 : i64
%393 = llvm.getelementptr %arg0[%391] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg4, %393 : i64, !llvm.ptr
%394 = arith.constant 5 : i32
%396 = arith.extsi %394 : i32 to i64
%395 = arith.muli %372, %396 : i64
%397 = arith.constant 3 : i32
%399 = arith.extsi %397 : i32 to i64
%398 = arith.addi %395, %399 : i64
%400 = llvm.getelementptr %arg0[%398] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg5, %400 : i64, !llvm.ptr
%401 = arith.constant 5 : i32
%403 = arith.extsi %401 : i32 to i64
%402 = arith.muli %372, %403 : i64
%404 = arith.constant 4 : i32
%406 = arith.extsi %404 : i32 to i64
%405 = arith.addi %402, %406 : i64
%407 = llvm.getelementptr %arg0[%405] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg6, %407 : i64, !llvm.ptr
%408 = arith.constant 1 : i32
%410 = arith.extsi %408 : i32 to i64
%409 = arith.addi %372, %410 : i64
%411 = arith.constant 0 : i32
%412 = arith.extsi %411 : i32 to i64
%413 = llvm.getelementptr %arg1[%412] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %409, %413 : i64, !llvm.ptr
%414 = llvm.mlir.constant(1 : i64) : i64
%415 = llvm.alloca %414 x i64 : (i64) -> !llvm.ptr
llvm.store %372, %415 : i64, !llvm.ptr
cf.br ^bb51
^bb51:
%416 = llvm.load %415 : !llvm.ptr -> i64
%417 = arith.constant 0 : i32
%419 = arith.extsi %417 : i32 to i64
%418 = arith.cmpi sgt, %416, %419 : i64
cf.cond_br %418, ^bb52, ^bb53
^bb52:
%420 = llvm.load %415 : !llvm.ptr -> i64
%421 = arith.constant 1 : i32
%423 = arith.extsi %421 : i32 to i64
%422 = arith.subi %420, %423 : i64
%424 = arith.constant 2 : i32
%426 = arith.extsi %424 : i32 to i64
%425 = arith.divsi %422, %426 : i64
%428 = arith.constant 5 : i32
%430 = arith.extsi %428 : i32 to i64
%429 = arith.muli %425, %430 : i64
%431 = llvm.getelementptr %arg0[%429] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%427 = llvm.load %431 : !llvm.ptr -> i64
%433 = llvm.load %415 : !llvm.ptr -> i64
%434 = arith.constant 5 : i32
%436 = arith.extsi %434 : i32 to i64
%435 = arith.muli %433, %436 : i64
%437 = llvm.getelementptr %arg0[%435] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%432 = llvm.load %437 : !llvm.ptr -> i64
%438 = arith.cmpi sle, %427, %432 : i64
cf.cond_br %438, ^bb54, ^bb55
^bb54:
cf.br ^bb53
^bb55:
cf.br ^bb56
^bb56:
%439 = arith.constant 0 : i32
%440 = arith.extsi %439 : i32 to i64
%441 = llvm.mlir.constant(1 : i64) : i64
%442 = llvm.alloca %441 x i64 : (i64) -> !llvm.ptr
llvm.store %440, %442 : i64, !llvm.ptr
cf.br ^bb57
^bb57:
%443 = llvm.load %442 : !llvm.ptr -> i64
%444 = arith.constant 5 : i32
%446 = arith.extsi %444 : i32 to i64
%445 = arith.cmpi slt, %443, %446 : i64
cf.cond_br %445, ^bb58, ^bb59
^bb58:
%448 = arith.constant 5 : i32
%450 = arith.extsi %448 : i32 to i64
%449 = arith.muli %425, %450 : i64
%451 = llvm.load %442 : !llvm.ptr -> i64
%452 = arith.addi %449, %451 : i64
%453 = llvm.getelementptr %arg0[%452] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%447 = llvm.load %453 : !llvm.ptr -> i64
%455 = llvm.load %415 : !llvm.ptr -> i64
%456 = arith.constant 5 : i32
%458 = arith.extsi %456 : i32 to i64
%457 = arith.muli %455, %458 : i64
%459 = llvm.load %442 : !llvm.ptr -> i64
%460 = arith.addi %457, %459 : i64
%461 = llvm.getelementptr %arg0[%460] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%454 = llvm.load %461 : !llvm.ptr -> i64
%462 = arith.constant 5 : i32
%464 = arith.extsi %462 : i32 to i64
%463 = arith.muli %425, %464 : i64
%465 = llvm.load %442 : !llvm.ptr -> i64
%466 = arith.addi %463, %465 : i64
%467 = llvm.getelementptr %arg0[%466] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %454, %467 : i64, !llvm.ptr
%468 = llvm.load %415 : !llvm.ptr -> i64
%469 = arith.constant 5 : i32
%471 = arith.extsi %469 : i32 to i64
%470 = arith.muli %468, %471 : i64
%472 = llvm.load %442 : !llvm.ptr -> i64
%473 = arith.addi %470, %472 : i64
%474 = llvm.getelementptr %arg0[%473] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %447, %474 : i64, !llvm.ptr
%475 = llvm.load %442 : !llvm.ptr -> i64
%476 = arith.constant 1 : i32
%478 = arith.extsi %476 : i32 to i64
%477 = arith.addi %475, %478 : i64
llvm.store %477, %442 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
llvm.store %425, %415 : i64, !llvm.ptr
cf.br ^bb51
^bb53:
func.return
}
func.func @heap_pop(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) -> () {
%480 = arith.constant 0 : i32
%481 = arith.extsi %480 : i32 to i64
%482 = llvm.getelementptr %arg2[%481] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%479 = llvm.load %482 : !llvm.ptr -> i64
%483 = arith.constant 1 : i32
%485 = arith.extsi %483 : i32 to i64
%484 = arith.subi %479, %485 : i64
%486 = arith.constant 0 : i32
%487 = arith.extsi %486 : i32 to i64
%488 = llvm.getelementptr %arg2[%487] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %484, %488 : i64, !llvm.ptr
%489 = arith.constant 0 : i32
%490 = arith.extsi %489 : i32 to i64
%491 = llvm.mlir.constant(1 : i64) : i64
%492 = llvm.alloca %491 x i64 : (i64) -> !llvm.ptr
llvm.store %490, %492 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%493 = llvm.load %492 : !llvm.ptr -> i64
%494 = arith.constant 5 : i32
%496 = arith.extsi %494 : i32 to i64
%495 = arith.cmpi slt, %493, %496 : i64
cf.cond_br %495, ^bb61, ^bb62
^bb61:
%498 = llvm.load %492 : !llvm.ptr -> i64
%499 = llvm.getelementptr %arg0[%498] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%497 = llvm.load %499 : !llvm.ptr -> i64
%500 = llvm.load %492 : !llvm.ptr -> i64
%501 = llvm.getelementptr %arg1[%500] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %497, %501 : i64, !llvm.ptr
%502 = llvm.load %492 : !llvm.ptr -> i64
%503 = arith.constant 1 : i32
%505 = arith.extsi %503 : i32 to i64
%504 = arith.addi %502, %505 : i64
llvm.store %504, %492 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%507 = arith.constant 0 : i32
%508 = arith.extsi %507 : i32 to i64
%509 = llvm.getelementptr %arg2[%508] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%506 = llvm.load %509 : !llvm.ptr -> i64
%510 = arith.constant 0 : i32
%512 = arith.extsi %510 : i32 to i64
%511 = arith.cmpi sgt, %506, %512 : i64
cf.cond_br %511, ^bb63, ^bb64
^bb63:
%513 = arith.constant 0 : i32
%514 = arith.extsi %513 : i32 to i64
llvm.store %514, %492 : i64, !llvm.ptr
cf.br ^bb66
^bb66:
%515 = llvm.load %492 : !llvm.ptr -> i64
%516 = arith.constant 5 : i32
%518 = arith.extsi %516 : i32 to i64
%517 = arith.cmpi slt, %515, %518 : i64
cf.cond_br %517, ^bb67, ^bb68
^bb67:
%521 = arith.constant 0 : i32
%522 = arith.extsi %521 : i32 to i64
%523 = llvm.getelementptr %arg2[%522] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%520 = llvm.load %523 : !llvm.ptr -> i64
%524 = arith.constant 5 : i32
%526 = arith.extsi %524 : i32 to i64
%525 = arith.muli %520, %526 : i64
%527 = llvm.load %492 : !llvm.ptr -> i64
%528 = arith.addi %525, %527 : i64
%529 = llvm.getelementptr %arg0[%528] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%519 = llvm.load %529 : !llvm.ptr -> i64
%530 = llvm.load %492 : !llvm.ptr -> i64
%531 = llvm.getelementptr %arg0[%530] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %519, %531 : i64, !llvm.ptr
%532 = llvm.load %492 : !llvm.ptr -> i64
%533 = arith.constant 1 : i32
%535 = arith.extsi %533 : i32 to i64
%534 = arith.addi %532, %535 : i64
llvm.store %534, %492 : i64, !llvm.ptr
cf.br ^bb66
^bb68:
%536 = arith.constant 0 : i32
%537 = arith.extsi %536 : i32 to i64
%538 = llvm.mlir.constant(1 : i64) : i64
%539 = llvm.alloca %538 x i64 : (i64) -> !llvm.ptr
llvm.store %537, %539 : i64, !llvm.ptr
cf.br ^bb69
^bb69:
%540 = arith.constant 1 : i1
cf.cond_br %540, ^bb70, ^bb71
^bb70:
%541 = arith.constant 2 : i32
%542 = llvm.load %539 : !llvm.ptr -> i64
%544 = arith.extsi %541 : i32 to i64
%543 = arith.muli %544, %542 : i64
%545 = arith.constant 1 : i32
%547 = arith.extsi %545 : i32 to i64
%546 = arith.addi %543, %547 : i64
%548 = arith.constant 1 : i32
%550 = arith.extsi %548 : i32 to i64
%549 = arith.addi %546, %550 : i64
%551 = llvm.load %539 : !llvm.ptr -> i64
%552 = llvm.mlir.constant(1 : i64) : i64
%553 = llvm.alloca %552 x i64 : (i64) -> !llvm.ptr
llvm.store %551, %553 : i64, !llvm.ptr
%555 = arith.constant 0 : i32
%556 = arith.extsi %555 : i32 to i64
%557 = llvm.getelementptr %arg2[%556] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%554 = llvm.load %557 : !llvm.ptr -> i64
%558 = arith.cmpi slt, %546, %554 : i64
%559 = scf.if %558 -> (i1) {
%561 = arith.constant 5 : i32
%563 = arith.extsi %561 : i32 to i64
%562 = arith.muli %546, %563 : i64
%564 = llvm.getelementptr %arg0[%562] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%560 = llvm.load %564 : !llvm.ptr -> i64
%566 = llvm.load %553 : !llvm.ptr -> i64
%567 = arith.constant 5 : i32
%569 = arith.extsi %567 : i32 to i64
%568 = arith.muli %566, %569 : i64
%570 = llvm.getelementptr %arg0[%568] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%565 = llvm.load %570 : !llvm.ptr -> i64
%571 = arith.cmpi slt, %560, %565 : i64
scf.yield %571 : i1
} else {
%572 = arith.constant false
scf.yield %572 : i1
}
cf.cond_br %559, ^bb72, ^bb73
^bb72:
llvm.store %546, %553 : i64, !llvm.ptr
cf.br ^bb74
^bb73:
cf.br ^bb74
^bb74:
%574 = arith.constant 0 : i32
%575 = arith.extsi %574 : i32 to i64
%576 = llvm.getelementptr %arg2[%575] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%573 = llvm.load %576 : !llvm.ptr -> i64
%577 = arith.cmpi slt, %549, %573 : i64
%578 = scf.if %577 -> (i1) {
%580 = arith.constant 5 : i32
%582 = arith.extsi %580 : i32 to i64
%581 = arith.muli %549, %582 : i64
%583 = llvm.getelementptr %arg0[%581] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%579 = llvm.load %583 : !llvm.ptr -> i64
%585 = llvm.load %553 : !llvm.ptr -> i64
%586 = arith.constant 5 : i32
%588 = arith.extsi %586 : i32 to i64
%587 = arith.muli %585, %588 : i64
%589 = llvm.getelementptr %arg0[%587] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%584 = llvm.load %589 : !llvm.ptr -> i64
%590 = arith.cmpi slt, %579, %584 : i64
scf.yield %590 : i1
} else {
%591 = arith.constant false
scf.yield %591 : i1
}
cf.cond_br %578, ^bb75, ^bb76
^bb75:
llvm.store %549, %553 : i64, !llvm.ptr
cf.br ^bb77
^bb76:
cf.br ^bb77
^bb77:
%592 = llvm.load %553 : !llvm.ptr -> i64
%593 = llvm.load %539 : !llvm.ptr -> i64
%594 = arith.cmpi eq, %592, %593 : i64
cf.cond_br %594, ^bb78, ^bb79
^bb78:
cf.br ^bb71
^bb79:
cf.br ^bb80
^bb80:
%595 = arith.constant 0 : i32
%596 = arith.extsi %595 : i32 to i64
llvm.store %596, %492 : i64, !llvm.ptr
cf.br ^bb81
^bb81:
%597 = llvm.load %492 : !llvm.ptr -> i64
%598 = arith.constant 5 : i32
%600 = arith.extsi %598 : i32 to i64
%599 = arith.cmpi slt, %597, %600 : i64
cf.cond_br %599, ^bb82, ^bb83
^bb82:
%602 = llvm.load %539 : !llvm.ptr -> i64
%603 = arith.constant 5 : i32
%605 = arith.extsi %603 : i32 to i64
%604 = arith.muli %602, %605 : i64
%606 = llvm.load %492 : !llvm.ptr -> i64
%607 = arith.addi %604, %606 : i64
%608 = llvm.getelementptr %arg0[%607] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%601 = llvm.load %608 : !llvm.ptr -> i64
%610 = llvm.load %553 : !llvm.ptr -> i64
%611 = arith.constant 5 : i32
%613 = arith.extsi %611 : i32 to i64
%612 = arith.muli %610, %613 : i64
%614 = llvm.load %492 : !llvm.ptr -> i64
%615 = arith.addi %612, %614 : i64
%616 = llvm.getelementptr %arg0[%615] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%609 = llvm.load %616 : !llvm.ptr -> i64
%617 = llvm.load %539 : !llvm.ptr -> i64
%618 = arith.constant 5 : i32
%620 = arith.extsi %618 : i32 to i64
%619 = arith.muli %617, %620 : i64
%621 = llvm.load %492 : !llvm.ptr -> i64
%622 = arith.addi %619, %621 : i64
%623 = llvm.getelementptr %arg0[%622] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %609, %623 : i64, !llvm.ptr
%624 = llvm.load %553 : !llvm.ptr -> i64
%625 = arith.constant 5 : i32
%627 = arith.extsi %625 : i32 to i64
%626 = arith.muli %624, %627 : i64
%628 = llvm.load %492 : !llvm.ptr -> i64
%629 = arith.addi %626, %628 : i64
%630 = llvm.getelementptr %arg0[%629] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %601, %630 : i64, !llvm.ptr
%631 = llvm.load %492 : !llvm.ptr -> i64
%632 = arith.constant 1 : i32
%634 = arith.extsi %632 : i32 to i64
%633 = arith.addi %631, %634 : i64
llvm.store %633, %492 : i64, !llvm.ptr
cf.br ^bb81
^bb83:
%635 = llvm.load %553 : !llvm.ptr -> i64
llvm.store %635, %539 : i64, !llvm.ptr
cf.br ^bb69
^bb71:
cf.br ^bb65
^bb64:
cf.br ^bb65
^bb65:
func.return
}
func.func @check_quad(%arg0: !llvm.ptr, %arg1: !llvm.ptr) -> i32 {
%636 = arith.constant 0 : i32
%637 = arith.extsi %636 : i32 to i64
%638 = llvm.mlir.constant(1 : i64) : i64
%639 = llvm.alloca %638 x i64 : (i64) -> !llvm.ptr
llvm.store %637, %639 : i64, !llvm.ptr
cf.br ^bb84
^bb84:
%640 = llvm.load %639 : !llvm.ptr -> i64
%641 = arith.constant 6 : i32
%643 = arith.extsi %641 : i32 to i64
%642 = arith.cmpi slt, %640, %643 : i64
cf.cond_br %642, ^bb85, ^bb86
^bb85:
%645 = llvm.load %639 : !llvm.ptr -> i64
%646 = llvm.getelementptr %arg1[%645] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%644 = llvm.load %646 : !llvm.ptr -> i64
%647 = arith.constant 0 : i32
%648 = arith.extsi %647 : i32 to i64
%649 = llvm.mlir.constant(1 : i64) : i64
%650 = llvm.alloca %649 x i64 : (i64) -> !llvm.ptr
llvm.store %648, %650 : i64, !llvm.ptr
cf.br ^bb87
^bb87:
%651 = llvm.load %650 : !llvm.ptr -> i64
%652 = arith.constant 4 : i32
%654 = arith.extsi %652 : i32 to i64
%653 = arith.cmpi slt, %651, %654 : i64
cf.cond_br %653, ^bb88, ^bb89
^bb88:
%656 = llvm.load %650 : !llvm.ptr -> i64
%657 = llvm.getelementptr %arg0[%656] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%655 = llvm.load %657 : !llvm.ptr -> i64
%658 = arith.cmpi ne, %655, %644 : i64
%659 = scf.if %658 -> (i1) {
%660 = arith.remsi %655, %644 : i64
%661 = arith.constant 0 : i32
%663 = arith.extsi %661 : i32 to i64
%662 = arith.cmpi eq, %660, %663 : i64
scf.yield %662 : i1
} else {
%664 = arith.constant false
scf.yield %664 : i1
}
cf.cond_br %659, ^bb90, ^bb91
^bb90:
%665 = arith.constant 0 : i32
func.return %665 : i32
^bb91:
cf.br ^bb92
^bb92:
%666 = llvm.load %650 : !llvm.ptr -> i64
%667 = arith.constant 1 : i32
%669 = arith.extsi %667 : i32 to i64
%668 = arith.addi %666, %669 : i64
llvm.store %668, %650 : i64, !llvm.ptr
cf.br ^bb87
^bb89:
%670 = llvm.load %639 : !llvm.ptr -> i64
%671 = arith.constant 1 : i32
%673 = arith.extsi %671 : i32 to i64
%672 = arith.addi %670, %673 : i64
llvm.store %672, %639 : i64, !llvm.ptr
cf.br ^bb84
^bb86:
%674 = arith.constant 0 : i32
%675 = arith.extsi %674 : i32 to i64
%676 = llvm.mlir.constant(1 : i64) : i64
%677 = llvm.alloca %676 x i64 : (i64) -> !llvm.ptr
llvm.store %675, %677 : i64, !llvm.ptr
cf.br ^bb93
^bb93:
%678 = llvm.load %677 : !llvm.ptr -> i64
%679 = arith.constant 4 : i32
%681 = arith.extsi %679 : i32 to i64
%680 = arith.cmpi slt, %678, %681 : i64
cf.cond_br %680, ^bb94, ^bb95
^bb94:
%684 = llvm.load %677 : !llvm.ptr -> i64
%685 = llvm.getelementptr %arg0[%684] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%683 = llvm.load %685 : !llvm.ptr -> i64
%682 = func.call @is_prime(%683) : (i64) -> i32
%686 = arith.constant 0 : i32
%687 = arith.cmpi eq, %682, %686 : i32
cf.cond_br %687, ^bb96, ^bb97
^bb96:
%688 = arith.constant 0 : i32
func.return %688 : i32
^bb97:
cf.br ^bb98
^bb98:
%689 = llvm.load %677 : !llvm.ptr -> i64
%690 = arith.constant 1 : i32
%692 = arith.extsi %690 : i32 to i64
%691 = arith.addi %689, %692 : i64
llvm.store %691, %677 : i64, !llvm.ptr
cf.br ^bb93
^bb95:
%693 = arith.constant 4 : i32
%694 = arith.extsi %693 : i32 to i64
llvm.store %694, %677 : i64, !llvm.ptr
cf.br ^bb99
^bb99:
%695 = llvm.load %677 : !llvm.ptr -> i64
%696 = arith.constant 9 : i32
%698 = arith.extsi %696 : i32 to i64
%697 = arith.cmpi slt, %695, %698 : i64
cf.cond_br %697, ^bb100, ^bb101
^bb100:
%701 = llvm.load %677 : !llvm.ptr -> i64
%702 = llvm.getelementptr %arg0[%701] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%700 = llvm.load %702 : !llvm.ptr -> i64
%699 = func.call @is_prime(%700) : (i64) -> i32
%703 = arith.constant 0 : i32
%704 = arith.cmpi eq, %699, %703 : i32
cf.cond_br %704, ^bb102, ^bb103
^bb102:
%705 = arith.constant 0 : i32
func.return %705 : i32
^bb103:
cf.br ^bb104
^bb104:
%706 = llvm.load %677 : !llvm.ptr -> i64
%707 = arith.constant 1 : i32
%709 = arith.extsi %707 : i32 to i64
%708 = arith.addi %706, %709 : i64
llvm.store %708, %677 : i64, !llvm.ptr
cf.br ^bb99
^bb101:
%710 = arith.constant 1 : i32
func.return %710 : i32
}
func.func @main() -> i32 {
%712 = arith.constant 500000 : i32
%713 = arith.constant 8 : i32
%714 = arith.extsi %712 : i32 to i64
%715 = arith.extsi %713 : i32 to i64
%711 = func.call @calloc(%714, %715) : (i64, i64) -> !llvm.ptr
%717 = arith.constant 500000 : i32
%718 = arith.constant 8 : i32
%719 = arith.extsi %717 : i32 to i64
%720 = arith.extsi %718 : i32 to i64
%716 = func.call @calloc(%719, %720) : (i64, i64) -> !llvm.ptr
%722 = arith.constant 1 : i32
%723 = arith.constant 8 : i32
%724 = arith.extsi %722 : i32 to i64
%725 = arith.extsi %723 : i32 to i64
%721 = func.call @calloc(%724, %725) : (i64, i64) -> !llvm.ptr
%727 = arith.constant 1 : i32
%728 = arith.constant 8 : i32
%729 = arith.extsi %727 : i32 to i64
%730 = arith.extsi %728 : i32 to i64
%726 = func.call @calloc(%729, %730) : (i64, i64) -> !llvm.ptr
%732 = arith.constant 1000000 : i32
%733 = arith.constant 5 : i32
%734 = arith.muli %732, %733 : i32
%735 = arith.constant 8 : i32
%736 = arith.extsi %734 : i32 to i64
%737 = arith.extsi %735 : i32 to i64
%731 = func.call @calloc(%736, %737) : (i64, i64) -> !llvm.ptr
%739 = arith.constant 1 : i32
%740 = arith.constant 8 : i32
%741 = arith.extsi %739 : i32 to i64
%742 = arith.extsi %740 : i32 to i64
%738 = func.call @calloc(%741, %742) : (i64, i64) -> !llvm.ptr
%744 = arith.constant 5 : i32
%745 = arith.constant 8 : i32
%746 = arith.extsi %744 : i32 to i64
%747 = arith.extsi %745 : i32 to i64
%743 = func.call @calloc(%746, %747) : (i64, i64) -> !llvm.ptr
%749 = arith.constant 9 : i32
%750 = arith.constant 8 : i32
%751 = arith.extsi %749 : i32 to i64
%752 = arith.extsi %750 : i32 to i64
%748 = func.call @calloc(%751, %752) : (i64, i64) -> !llvm.ptr
%754 = arith.constant 6 : i32
%755 = arith.constant 8 : i32
%756 = arith.extsi %754 : i32 to i64
%757 = arith.extsi %755 : i32 to i64
%753 = func.call @calloc(%756, %757) : (i64, i64) -> !llvm.ptr
%758 = llvm.mlir.zero : !llvm.ptr
%759 = llvm.icmp "eq" %711, %758 : !llvm.ptr
%760 = scf.if %759 -> (i1) {
%761 = arith.constant true
scf.yield %761 : i1
} else {
%762 = llvm.mlir.zero : !llvm.ptr
%763 = llvm.icmp "eq" %716, %762 : !llvm.ptr
scf.yield %763 : i1
}
%764 = scf.if %760 -> (i1) {
%765 = arith.constant true
scf.yield %765 : i1
} else {
%766 = llvm.mlir.zero : !llvm.ptr
%767 = llvm.icmp "eq" %731, %766 : !llvm.ptr
scf.yield %767 : i1
}
cf.cond_br %764, ^bb105, ^bb106
^bb105:
%768 = arith.constant 1 : i32
func.return %768 : i32
^bb106:
cf.br ^bb107
^bb107:
%769 = arith.constant 29 : i32
%770 = arith.constant 0 : i32
%771 = arith.extsi %769 : i32 to i64
%772 = arith.extsi %770 : i32 to i64
%773 = llvm.getelementptr %753[%772] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %771, %773 : i64, !llvm.ptr
%774 = arith.constant 31 : i32
%775 = arith.constant 1 : i32
%776 = arith.extsi %774 : i32 to i64
%777 = arith.extsi %775 : i32 to i64
%778 = llvm.getelementptr %753[%777] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %776, %778 : i64, !llvm.ptr
%779 = arith.constant 37 : i32
%780 = arith.constant 2 : i32
%781 = arith.extsi %779 : i32 to i64
%782 = arith.extsi %780 : i32 to i64
%783 = llvm.getelementptr %753[%782] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %781, %783 : i64, !llvm.ptr
%784 = arith.constant 41 : i32
%785 = arith.constant 3 : i32
%786 = arith.extsi %784 : i32 to i64
%787 = arith.extsi %785 : i32 to i64
%788 = llvm.getelementptr %753[%787] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %786, %788 : i64, !llvm.ptr
%789 = arith.constant 43 : i32
%790 = arith.constant 4 : i32
%791 = arith.extsi %789 : i32 to i64
%792 = arith.extsi %790 : i32 to i64
%793 = llvm.getelementptr %753[%792] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %791, %793 : i64, !llvm.ptr
%794 = arith.constant 47 : i32
%795 = arith.constant 5 : i32
%796 = arith.extsi %794 : i32 to i64
%797 = arith.extsi %795 : i32 to i64
%798 = llvm.getelementptr %753[%797] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %796, %798 : i64, !llvm.ptr
%800 = arith.constant 18 : i32
%801 = arith.constant 8 : i32
%802 = arith.extsi %800 : i32 to i64
%803 = arith.extsi %801 : i32 to i64
%799 = func.call @calloc(%802, %803) : (i64, i64) -> !llvm.ptr
%805 = arith.constant 18 : i32
%806 = arith.constant 8 : i32
%807 = arith.extsi %805 : i32 to i64
%808 = arith.extsi %806 : i32 to i64
%804 = func.call @calloc(%807, %808) : (i64, i64) -> !llvm.ptr
%809 = arith.constant 2520 : i32
%810 = arith.constant 0 : i32
%811 = arith.extsi %809 : i32 to i64
%812 = arith.extsi %810 : i32 to i64
%813 = llvm.getelementptr %799[%812] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %811, %813 : i64, !llvm.ptr
%814 = arith.constant 311 : i32
%815 = arith.constant 1 : i32
%816 = arith.extsi %814 : i32 to i64
%817 = arith.extsi %815 : i32 to i64
%818 = llvm.getelementptr %799[%817] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %816, %818 : i64, !llvm.ptr
%819 = arith.constant 2520 : i32
%820 = arith.constant 2 : i32
%821 = arith.extsi %819 : i32 to i64
%822 = arith.extsi %820 : i32 to i64
%823 = llvm.getelementptr %799[%822] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %821, %823 : i64, !llvm.ptr
%824 = arith.constant 313 : i32
%825 = arith.constant 3 : i32
%826 = arith.extsi %824 : i32 to i64
%827 = arith.extsi %825 : i32 to i64
%828 = llvm.getelementptr %799[%827] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %826, %828 : i64, !llvm.ptr
%829 = arith.constant 2520 : i32
%830 = arith.constant 4 : i32
%831 = arith.extsi %829 : i32 to i64
%832 = arith.extsi %830 : i32 to i64
%833 = llvm.getelementptr %799[%832] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %831, %833 : i64, !llvm.ptr
%834 = arith.constant 317 : i32
%835 = arith.constant 5 : i32
%836 = arith.extsi %834 : i32 to i64
%837 = arith.extsi %835 : i32 to i64
%838 = llvm.getelementptr %799[%837] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %836, %838 : i64, !llvm.ptr
%839 = arith.constant 2520 : i32
%840 = arith.constant 6 : i32
%841 = arith.extsi %839 : i32 to i64
%842 = arith.extsi %840 : i32 to i64
%843 = llvm.getelementptr %799[%842] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %841, %843 : i64, !llvm.ptr
%844 = arith.constant 319 : i32
%845 = arith.constant 7 : i32
%846 = arith.extsi %844 : i32 to i64
%847 = arith.extsi %845 : i32 to i64
%848 = llvm.getelementptr %799[%847] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %846, %848 : i64, !llvm.ptr
%849 = arith.constant 105 : i32
%850 = arith.constant 8 : i32
%851 = arith.extsi %849 : i32 to i64
%852 = arith.extsi %850 : i32 to i64
%853 = llvm.getelementptr %799[%852] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %851, %853 : i64, !llvm.ptr
%854 = arith.constant 13 : i32
%855 = arith.constant 9 : i32
%856 = arith.extsi %854 : i32 to i64
%857 = arith.extsi %855 : i32 to i64
%858 = llvm.getelementptr %799[%857] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %856, %858 : i64, !llvm.ptr
%859 = arith.constant 1260 : i32
%860 = arith.constant 10 : i32
%861 = arith.extsi %859 : i32 to i64
%862 = arith.extsi %860 : i32 to i64
%863 = llvm.getelementptr %799[%862] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %861, %863 : i64, !llvm.ptr
%864 = arith.constant 157 : i32
%865 = arith.constant 11 : i32
%866 = arith.extsi %864 : i32 to i64
%867 = arith.extsi %865 : i32 to i64
%868 = llvm.getelementptr %799[%867] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %866, %868 : i64, !llvm.ptr
%869 = arith.constant 8 : i32
%870 = arith.constant 12 : i32
%871 = arith.extsi %869 : i32 to i64
%872 = arith.extsi %870 : i32 to i64
%873 = llvm.getelementptr %799[%872] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %871, %873 : i64, !llvm.ptr
%874 = arith.constant 1 : i32
%875 = arith.constant 13 : i32
%876 = arith.extsi %874 : i32 to i64
%877 = arith.extsi %875 : i32 to i64
%878 = llvm.getelementptr %799[%877] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %876, %878 : i64, !llvm.ptr
%879 = arith.constant 630 : i32
%880 = arith.constant 14 : i32
%881 = arith.extsi %879 : i32 to i64
%882 = arith.extsi %880 : i32 to i64
%883 = llvm.getelementptr %799[%882] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %881, %883 : i64, !llvm.ptr
%884 = arith.constant 79 : i32
%885 = arith.constant 15 : i32
%886 = arith.extsi %884 : i32 to i64
%887 = arith.extsi %885 : i32 to i64
%888 = llvm.getelementptr %799[%887] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %886, %888 : i64, !llvm.ptr
%889 = arith.constant 420 : i32
%890 = arith.constant 16 : i32
%891 = arith.extsi %889 : i32 to i64
%892 = arith.extsi %890 : i32 to i64
%893 = llvm.getelementptr %799[%892] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %891, %893 : i64, !llvm.ptr
%894 = arith.constant 53 : i32
%895 = arith.constant 17 : i32
%896 = arith.extsi %894 : i32 to i64
%897 = arith.extsi %895 : i32 to i64
%898 = llvm.getelementptr %799[%897] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %896, %898 : i64, !llvm.ptr
%899 = arith.constant 2520 : i32
%900 = arith.constant 0 : i32
%901 = arith.extsi %899 : i32 to i64
%902 = arith.extsi %900 : i32 to i64
%903 = llvm.getelementptr %804[%902] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %901, %903 : i64, !llvm.ptr
%904 = arith.constant 2201 : i32
%905 = arith.constant 1 : i32
%906 = arith.extsi %904 : i32 to i64
%907 = arith.extsi %905 : i32 to i64
%908 = llvm.getelementptr %804[%907] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %906, %908 : i64, !llvm.ptr
%909 = arith.constant 2520 : i32
%910 = arith.constant 2 : i32
%911 = arith.extsi %909 : i32 to i64
%912 = arith.extsi %910 : i32 to i64
%913 = llvm.getelementptr %804[%912] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %911, %913 : i64, !llvm.ptr
%914 = arith.constant 2203 : i32
%915 = arith.constant 3 : i32
%916 = arith.extsi %914 : i32 to i64
%917 = arith.extsi %915 : i32 to i64
%918 = llvm.getelementptr %804[%917] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %916, %918 : i64, !llvm.ptr
%919 = arith.constant 2520 : i32
%920 = arith.constant 4 : i32
%921 = arith.extsi %919 : i32 to i64
%922 = arith.extsi %920 : i32 to i64
%923 = llvm.getelementptr %804[%922] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %921, %923 : i64, !llvm.ptr
%924 = arith.constant 2207 : i32
%925 = arith.constant 5 : i32
%926 = arith.extsi %924 : i32 to i64
%927 = arith.extsi %925 : i32 to i64
%928 = llvm.getelementptr %804[%927] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %926, %928 : i64, !llvm.ptr
%929 = arith.constant 2520 : i32
%930 = arith.constant 6 : i32
%931 = arith.extsi %929 : i32 to i64
%932 = arith.extsi %930 : i32 to i64
%933 = llvm.getelementptr %804[%932] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %931, %933 : i64, !llvm.ptr
%934 = arith.constant 2209 : i32
%935 = arith.constant 7 : i32
%936 = arith.extsi %934 : i32 to i64
%937 = arith.extsi %935 : i32 to i64
%938 = llvm.getelementptr %804[%937] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %936, %938 : i64, !llvm.ptr
%939 = arith.constant 420 : i32
%940 = arith.constant 8 : i32
%941 = arith.extsi %939 : i32 to i64
%942 = arith.extsi %940 : i32 to i64
%943 = llvm.getelementptr %804[%942] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %941, %943 : i64, !llvm.ptr
%944 = arith.constant 367 : i32
%945 = arith.constant 9 : i32
%946 = arith.extsi %944 : i32 to i64
%947 = arith.extsi %945 : i32 to i64
%948 = llvm.getelementptr %804[%947] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %946, %948 : i64, !llvm.ptr
%949 = arith.constant 630 : i32
%950 = arith.constant 10 : i32
%951 = arith.extsi %949 : i32 to i64
%952 = arith.extsi %950 : i32 to i64
%953 = llvm.getelementptr %804[%952] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %951, %953 : i64, !llvm.ptr
%954 = arith.constant 551 : i32
%955 = arith.constant 11 : i32
%956 = arith.extsi %954 : i32 to i64
%957 = arith.extsi %955 : i32 to i64
%958 = llvm.getelementptr %804[%957] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %956, %958 : i64, !llvm.ptr
%959 = arith.constant 1260 : i32
%960 = arith.constant 12 : i32
%961 = arith.extsi %959 : i32 to i64
%962 = arith.extsi %960 : i32 to i64
%963 = llvm.getelementptr %804[%962] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %961, %963 : i64, !llvm.ptr
%964 = arith.constant 1103 : i32
%965 = arith.constant 13 : i32
%966 = arith.extsi %964 : i32 to i64
%967 = arith.extsi %965 : i32 to i64
%968 = llvm.getelementptr %804[%967] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %966, %968 : i64, !llvm.ptr
%969 = arith.constant 105 : i32
%970 = arith.constant 14 : i32
%971 = arith.extsi %969 : i32 to i64
%972 = arith.extsi %970 : i32 to i64
%973 = llvm.getelementptr %804[%972] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %971, %973 : i64, !llvm.ptr
%974 = arith.constant 92 : i32
%975 = arith.constant 15 : i32
%976 = arith.extsi %974 : i32 to i64
%977 = arith.extsi %975 : i32 to i64
%978 = llvm.getelementptr %804[%977] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %976, %978 : i64, !llvm.ptr
%979 = arith.constant 8 : i32
%980 = arith.constant 16 : i32
%981 = arith.extsi %979 : i32 to i64
%982 = arith.extsi %980 : i32 to i64
%983 = llvm.getelementptr %804[%982] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %981, %983 : i64, !llvm.ptr
%984 = arith.constant 7 : i32
%985 = arith.constant 17 : i32
%986 = arith.extsi %984 : i32 to i64
%987 = arith.extsi %985 : i32 to i64
%988 = llvm.getelementptr %804[%987] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %986, %988 : i64, !llvm.ptr
%990 = arith.constant 9 : i32
%991 = arith.constant 8 : i32
%992 = arith.extsi %990 : i32 to i64
%993 = arith.extsi %991 : i32 to i64
%989 = func.call @calloc(%992, %993) : (i64, i64) -> !llvm.ptr
%994 = arith.constant 2 : i32
%995 = arith.constant 0 : i32
%996 = arith.extsi %994 : i32 to i64
%997 = arith.extsi %995 : i32 to i64
%998 = llvm.getelementptr %989[%997] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %996, %998 : i64, !llvm.ptr
%999 = arith.constant 3 : i32
%1000 = arith.constant 1 : i32
%1001 = arith.extsi %999 : i32 to i64
%1002 = arith.extsi %1000 : i32 to i64
%1003 = llvm.getelementptr %989[%1002] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1001, %1003 : i64, !llvm.ptr
%1004 = arith.constant 5 : i32
%1005 = arith.constant 2 : i32
%1006 = arith.extsi %1004 : i32 to i64
%1007 = arith.extsi %1005 : i32 to i64
%1008 = llvm.getelementptr %989[%1007] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1006, %1008 : i64, !llvm.ptr
%1009 = arith.constant 7 : i32
%1010 = arith.constant 3 : i32
%1011 = arith.extsi %1009 : i32 to i64
%1012 = arith.extsi %1010 : i32 to i64
%1013 = llvm.getelementptr %989[%1012] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1011, %1013 : i64, !llvm.ptr
%1014 = arith.constant 11 : i32
%1015 = arith.constant 4 : i32
%1016 = arith.extsi %1014 : i32 to i64
%1017 = arith.extsi %1015 : i32 to i64
%1018 = llvm.getelementptr %989[%1017] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1016, %1018 : i64, !llvm.ptr
%1019 = arith.constant 13 : i32
%1020 = arith.constant 5 : i32
%1021 = arith.extsi %1019 : i32 to i64
%1022 = arith.extsi %1020 : i32 to i64
%1023 = llvm.getelementptr %989[%1022] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1021, %1023 : i64, !llvm.ptr
%1024 = arith.constant 17 : i32
%1025 = arith.constant 6 : i32
%1026 = arith.extsi %1024 : i32 to i64
%1027 = arith.extsi %1025 : i32 to i64
%1028 = llvm.getelementptr %989[%1027] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1026, %1028 : i64, !llvm.ptr
%1029 = arith.constant 19 : i32
%1030 = arith.constant 7 : i32
%1031 = arith.extsi %1029 : i32 to i64
%1032 = arith.extsi %1030 : i32 to i64
%1033 = llvm.getelementptr %989[%1032] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1031, %1033 : i64, !llvm.ptr
%1034 = arith.constant 23 : i32
%1035 = arith.constant 8 : i32
%1036 = arith.extsi %1034 : i32 to i64
%1037 = arith.extsi %1035 : i32 to i64
%1038 = llvm.getelementptr %989[%1037] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1036, %1038 : i64, !llvm.ptr
%1040 = arith.constant 9699690 : i32
%1041 = arith.constant 8 : i32
%1042 = arith.extsi %1040 : i32 to i64
%1043 = arith.extsi %1041 : i32 to i64
%1039 = func.call @calloc(%1042, %1043) : (i64, i64) -> !llvm.ptr
%1045 = arith.constant 9699690 : i32
%1046 = arith.constant 8 : i32
%1047 = arith.extsi %1045 : i32 to i64
%1048 = arith.extsi %1046 : i32 to i64
%1044 = func.call @calloc(%1047, %1048) : (i64, i64) -> !llvm.ptr
%1049 = llvm.mlir.zero : !llvm.ptr
%1050 = llvm.icmp "eq" %1039, %1049 : !llvm.ptr
cf.cond_br %1050, ^bb108, ^bb109
^bb108:
%1051 = arith.constant 1 : i32
func.return %1051 : i32
^bb109:
cf.br ^bb110
^bb110:
%1052 = arith.constant 0 : i32
%1053 = arith.constant 0 : i32
%1054 = arith.extsi %1052 : i32 to i64
%1055 = arith.extsi %1053 : i32 to i64
%1056 = llvm.getelementptr %1039[%1055] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1054, %1056 : i64, !llvm.ptr
%1057 = arith.constant 1 : i32
%1058 = arith.extsi %1057 : i32 to i64
%1059 = llvm.mlir.constant(1 : i64) : i64
%1060 = llvm.alloca %1059 x i64 : (i64) -> !llvm.ptr
llvm.store %1058, %1060 : i64, !llvm.ptr
%1061 = arith.constant 1 : i32
%1062 = arith.extsi %1061 : i32 to i64
%1063 = llvm.mlir.constant(1 : i64) : i64
%1064 = llvm.alloca %1063 x i64 : (i64) -> !llvm.ptr
llvm.store %1062, %1064 : i64, !llvm.ptr
%1065 = arith.constant 0 : i32
%1066 = arith.extsi %1065 : i32 to i64
%1067 = llvm.mlir.constant(1 : i64) : i64
%1068 = llvm.alloca %1067 x i64 : (i64) -> !llvm.ptr
llvm.store %1066, %1068 : i64, !llvm.ptr
%1069 = arith.constant 0 : i32
%1070 = arith.extsi %1069 : i32 to i64
%1071 = llvm.mlir.constant(1 : i64) : i64
%1072 = llvm.alloca %1071 x i64 : (i64) -> !llvm.ptr
llvm.store %1070, %1072 : i64, !llvm.ptr
%1073 = arith.constant 0 : i32
%1074 = arith.extsi %1073 : i32 to i64
%1075 = llvm.mlir.constant(1 : i64) : i64
%1076 = llvm.alloca %1075 x i64 : (i64) -> !llvm.ptr
llvm.store %1074, %1076 : i64, !llvm.ptr
%1077 = arith.constant 0 : i32
%1078 = arith.extsi %1077 : i32 to i64
%1079 = llvm.mlir.constant(1 : i64) : i64
%1080 = llvm.alloca %1079 x i64 : (i64) -> !llvm.ptr
llvm.store %1078, %1080 : i64, !llvm.ptr
cf.br ^bb111
^bb111:
%1081 = llvm.load %1068 : !llvm.ptr -> i64
%1082 = arith.constant 9 : i32
%1084 = arith.extsi %1082 : i32 to i64
%1083 = arith.cmpi slt, %1081, %1084 : i64
cf.cond_br %1083, ^bb112, ^bb113
^bb112:
%1086 = llvm.load %1068 : !llvm.ptr -> i64
%1087 = llvm.getelementptr %989[%1086] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1085 = llvm.load %1087 : !llvm.ptr -> i64
%1088 = arith.constant 0 : i32
%1089 = arith.extsi %1088 : i32 to i64
%1090 = llvm.mlir.constant(1 : i64) : i64
%1091 = llvm.alloca %1090 x i64 : (i64) -> !llvm.ptr
llvm.store %1089, %1091 : i64, !llvm.ptr
%1092 = arith.constant 0 : i32
%1093 = arith.extsi %1092 : i32 to i64
llvm.store %1093, %1072 : i64, !llvm.ptr
cf.br ^bb114
^bb114:
%1094 = llvm.load %1072 : !llvm.ptr -> i64
%1095 = llvm.load %1060 : !llvm.ptr -> i64
%1096 = arith.cmpi slt, %1094, %1095 : i64
cf.cond_br %1096, ^bb115, ^bb116
^bb115:
%1098 = llvm.load %1072 : !llvm.ptr -> i64
%1099 = llvm.getelementptr %1039[%1098] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1097 = llvm.load %1099 : !llvm.ptr -> i64
%1100 = arith.constant 0 : i32
%1101 = arith.extsi %1100 : i32 to i64
%1102 = llvm.mlir.constant(1 : i64) : i64
%1103 = llvm.alloca %1102 x i64 : (i64) -> !llvm.ptr
llvm.store %1101, %1103 : i64, !llvm.ptr
cf.br ^bb117
^bb117:
%1104 = llvm.load %1103 : !llvm.ptr -> i64
%1105 = arith.cmpi slt, %1104, %1085 : i64
cf.cond_br %1105, ^bb118, ^bb119
^bb118:
%1106 = arith.constant 1 : i32
%1107 = llvm.mlir.constant(1 : i64) : i64
%1108 = llvm.alloca %1107 x i32 : (i64) -> !llvm.ptr
llvm.store %1106, %1108 : i32, !llvm.ptr
%1109 = arith.constant 0 : i32
%1110 = arith.extsi %1109 : i32 to i64
%1111 = llvm.mlir.constant(1 : i64) : i64
%1112 = llvm.alloca %1111 x i64 : (i64) -> !llvm.ptr
llvm.store %1110, %1112 : i64, !llvm.ptr
cf.br ^bb120
^bb120:
%1113 = llvm.load %1112 : !llvm.ptr -> i64
%1114 = arith.constant 9 : i32
%1116 = arith.extsi %1114 : i32 to i64
%1115 = arith.cmpi slt, %1113, %1116 : i64
cf.cond_br %1115, ^bb121, ^bb122
^bb121:
%1118 = llvm.load %1112 : !llvm.ptr -> i64
%1119 = arith.constant 2 : i32
%1121 = arith.extsi %1119 : i32 to i64
%1120 = arith.muli %1118, %1121 : i64
%1122 = llvm.getelementptr %799[%1120] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1117 = llvm.load %1122 : !llvm.ptr -> i64
%1124 = llvm.load %1112 : !llvm.ptr -> i64
%1125 = arith.constant 2 : i32
%1127 = arith.extsi %1125 : i32 to i64
%1126 = arith.muli %1124, %1127 : i64
%1128 = arith.constant 1 : i32
%1130 = arith.extsi %1128 : i32 to i64
%1129 = arith.addi %1126, %1130 : i64
%1131 = llvm.getelementptr %799[%1129] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1123 = llvm.load %1131 : !llvm.ptr -> i64
%1132 = arith.remsi %1117, %1085 : i64
%1133 = arith.constant 0 : i32
%1135 = arith.extsi %1133 : i32 to i64
%1134 = arith.cmpi eq, %1132, %1135 : i64
cf.cond_br %1134, ^bb123, ^bb124
^bb123:
%1136 = arith.remsi %1123, %1085 : i64
%1137 = arith.constant 0 : i32
%1139 = arith.extsi %1137 : i32 to i64
%1138 = arith.cmpi eq, %1136, %1139 : i64
cf.cond_br %1138, ^bb126, ^bb127
^bb126:
%1140 = arith.constant 0 : i32
llvm.store %1140, %1108 : i32, !llvm.ptr
cf.br ^bb122
^bb127:
cf.br ^bb128
^bb128:
cf.br ^bb125
^bb124:
%1142 = arith.constant 0 : i64
%1141 = arith.subi %1142, %1123 : i64
%1143 = func.call @inv_mod(%1117, %1085) : (i64, i64) -> i64
%1144 = arith.muli %1141, %1143 : i64
%1145 = arith.remsi %1144, %1085 : i64
%1146 = llvm.mlir.constant(1 : i64) : i64
%1147 = llvm.alloca %1146 x i64 : (i64) -> !llvm.ptr
llvm.store %1145, %1147 : i64, !llvm.ptr
%1148 = llvm.load %1147 : !llvm.ptr -> i64
%1149 = arith.constant 0 : i32
%1151 = arith.extsi %1149 : i32 to i64
%1150 = arith.cmpi slt, %1148, %1151 : i64
cf.cond_br %1150, ^bb129, ^bb130
^bb129:
%1152 = llvm.load %1147 : !llvm.ptr -> i64
%1153 = arith.addi %1152, %1085 : i64
llvm.store %1153, %1147 : i64, !llvm.ptr
cf.br ^bb131
^bb130:
cf.br ^bb131
^bb131:
%1154 = llvm.load %1103 : !llvm.ptr -> i64
%1155 = llvm.load %1147 : !llvm.ptr -> i64
%1156 = arith.cmpi eq, %1154, %1155 : i64
cf.cond_br %1156, ^bb132, ^bb133
^bb132:
%1157 = arith.constant 0 : i32
llvm.store %1157, %1108 : i32, !llvm.ptr
cf.br ^bb122
^bb133:
cf.br ^bb134
^bb134:
cf.br ^bb125
^bb125:
%1158 = llvm.load %1112 : !llvm.ptr -> i64
%1159 = arith.constant 1 : i32
%1161 = arith.extsi %1159 : i32 to i64
%1160 = arith.addi %1158, %1161 : i64
llvm.store %1160, %1112 : i64, !llvm.ptr
cf.br ^bb120
^bb122:
%1162 = llvm.load %1108 : !llvm.ptr -> i32
%1163 = arith.constant 1 : i32
%1164 = arith.cmpi eq, %1162, %1163 : i32
cf.cond_br %1164, ^bb135, ^bb136
^bb135:
%1166 = llvm.load %1064 : !llvm.ptr -> i64
%1165 = func.call @inv_mod(%1166, %1085) : (i64, i64) -> i64
%1167 = llvm.load %1103 : !llvm.ptr -> i64
%1168 = arith.remsi %1097, %1085 : i64
%1169 = arith.subi %1167, %1168 : i64
%1170 = arith.addi %1169, %1085 : i64
%1171 = arith.remsi %1170, %1085 : i64
%1172 = arith.muli %1171, %1165 : i64
%1173 = arith.remsi %1172, %1085 : i64
%1174 = llvm.load %1064 : !llvm.ptr -> i64
%1175 = arith.muli %1174, %1173 : i64
%1176 = arith.addi %1097, %1175 : i64
%1177 = llvm.load %1091 : !llvm.ptr -> i64
%1178 = llvm.getelementptr %1044[%1177] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1176, %1178 : i64, !llvm.ptr
%1179 = llvm.load %1091 : !llvm.ptr -> i64
%1180 = arith.constant 1 : i32
%1182 = arith.extsi %1180 : i32 to i64
%1181 = arith.addi %1179, %1182 : i64
llvm.store %1181, %1091 : i64, !llvm.ptr
cf.br ^bb137
^bb136:
cf.br ^bb137
^bb137:
%1183 = llvm.load %1103 : !llvm.ptr -> i64
%1184 = arith.constant 1 : i32
%1186 = arith.extsi %1184 : i32 to i64
%1185 = arith.addi %1183, %1186 : i64
llvm.store %1185, %1103 : i64, !llvm.ptr
cf.br ^bb117
^bb119:
%1187 = llvm.load %1072 : !llvm.ptr -> i64
%1188 = arith.constant 1 : i32
%1190 = arith.extsi %1188 : i32 to i64
%1189 = arith.addi %1187, %1190 : i64
llvm.store %1189, %1072 : i64, !llvm.ptr
cf.br ^bb114
^bb116:
%1191 = arith.constant 0 : i32
%1192 = arith.extsi %1191 : i32 to i64
llvm.store %1192, %1072 : i64, !llvm.ptr
cf.br ^bb138
^bb138:
%1193 = llvm.load %1072 : !llvm.ptr -> i64
%1194 = llvm.load %1091 : !llvm.ptr -> i64
%1195 = arith.cmpi slt, %1193, %1194 : i64
cf.cond_br %1195, ^bb139, ^bb140
^bb139:
%1197 = llvm.load %1072 : !llvm.ptr -> i64
%1198 = llvm.getelementptr %1044[%1197] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1196 = llvm.load %1198 : !llvm.ptr -> i64
%1199 = llvm.load %1072 : !llvm.ptr -> i64
%1200 = llvm.getelementptr %1039[%1199] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1196, %1200 : i64, !llvm.ptr
%1201 = llvm.load %1072 : !llvm.ptr -> i64
%1202 = arith.constant 1 : i32
%1204 = arith.extsi %1202 : i32 to i64
%1203 = arith.addi %1201, %1204 : i64
llvm.store %1203, %1072 : i64, !llvm.ptr
cf.br ^bb138
^bb140:
%1205 = llvm.load %1091 : !llvm.ptr -> i64
llvm.store %1205, %1060 : i64, !llvm.ptr
%1206 = llvm.load %1064 : !llvm.ptr -> i64
%1207 = arith.muli %1206, %1085 : i64
llvm.store %1207, %1064 : i64, !llvm.ptr
%1208 = llvm.load %1068 : !llvm.ptr -> i64
%1209 = arith.constant 1 : i32
%1211 = arith.extsi %1209 : i32 to i64
%1210 = arith.addi %1208, %1211 : i64
llvm.store %1210, %1068 : i64, !llvm.ptr
cf.br ^bb111
^bb113:
%1212 = llvm.load %1060 : !llvm.ptr -> i64
%1213 = arith.constant 0 : i32
%1214 = arith.extsi %1213 : i32 to i64
%1215 = llvm.getelementptr %721[%1214] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1212, %1215 : i64, !llvm.ptr
%1216 = arith.constant 0 : i32
%1217 = arith.extsi %1216 : i32 to i64
llvm.store %1217, %1072 : i64, !llvm.ptr
cf.br ^bb141
^bb141:
%1218 = llvm.load %1072 : !llvm.ptr -> i64
%1219 = llvm.load %1060 : !llvm.ptr -> i64
%1220 = arith.cmpi slt, %1218, %1219 : i64
cf.cond_br %1220, ^bb142, ^bb143
^bb142:
%1222 = llvm.load %1072 : !llvm.ptr -> i64
%1223 = llvm.getelementptr %1039[%1222] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1221 = llvm.load %1223 : !llvm.ptr -> i64
%1224 = llvm.load %1072 : !llvm.ptr -> i64
%1225 = llvm.getelementptr %711[%1224] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1221, %1225 : i64, !llvm.ptr
%1226 = llvm.load %1072 : !llvm.ptr -> i64
%1227 = arith.constant 1 : i32
%1229 = arith.extsi %1227 : i32 to i64
%1228 = arith.addi %1226, %1229 : i64
llvm.store %1228, %1072 : i64, !llvm.ptr
cf.br ^bb141
^bb143:
%1230 = llvm.load %1064 : !llvm.ptr -> i64
%1231 = arith.constant 311 : i32
%1232 = arith.extsi %1231 : i32 to i64
%1233 = arith.constant 2201 : i32
%1234 = arith.extsi %1233 : i32 to i64
%1235 = arith.constant 0 : i32
%1236 = arith.constant 0 : i32
%1237 = arith.extsi %1235 : i32 to i64
%1238 = arith.extsi %1236 : i32 to i64
%1239 = llvm.getelementptr %1039[%1238] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1237, %1239 : i64, !llvm.ptr
%1240 = arith.constant 1 : i32
%1241 = arith.extsi %1240 : i32 to i64
llvm.store %1241, %1060 : i64, !llvm.ptr
%1242 = arith.constant 1 : i32
%1243 = arith.extsi %1242 : i32 to i64
llvm.store %1243, %1064 : i64, !llvm.ptr
%1244 = arith.constant 0 : i32
%1245 = arith.extsi %1244 : i32 to i64
llvm.store %1245, %1068 : i64, !llvm.ptr
cf.br ^bb144
^bb144:
%1246 = llvm.load %1068 : !llvm.ptr -> i64
%1247 = arith.constant 9 : i32
%1249 = arith.extsi %1247 : i32 to i64
%1248 = arith.cmpi slt, %1246, %1249 : i64
cf.cond_br %1248, ^bb145, ^bb146
^bb145:
%1251 = llvm.load %1068 : !llvm.ptr -> i64
%1252 = llvm.getelementptr %989[%1251] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1250 = llvm.load %1252 : !llvm.ptr -> i64
%1253 = arith.constant 0 : i32
%1254 = arith.extsi %1253 : i32 to i64
%1255 = llvm.mlir.constant(1 : i64) : i64
%1256 = llvm.alloca %1255 x i64 : (i64) -> !llvm.ptr
llvm.store %1254, %1256 : i64, !llvm.ptr
%1257 = arith.constant 0 : i32
%1258 = arith.extsi %1257 : i32 to i64
llvm.store %1258, %1076 : i64, !llvm.ptr
cf.br ^bb147
^bb147:
%1259 = llvm.load %1076 : !llvm.ptr -> i64
%1260 = llvm.load %1060 : !llvm.ptr -> i64
%1261 = arith.cmpi slt, %1259, %1260 : i64
cf.cond_br %1261, ^bb148, ^bb149
^bb148:
%1263 = llvm.load %1076 : !llvm.ptr -> i64
%1264 = llvm.getelementptr %1039[%1263] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1262 = llvm.load %1264 : !llvm.ptr -> i64
%1265 = arith.constant 0 : i32
%1266 = arith.extsi %1265 : i32 to i64
%1267 = llvm.mlir.constant(1 : i64) : i64
%1268 = llvm.alloca %1267 x i64 : (i64) -> !llvm.ptr
llvm.store %1266, %1268 : i64, !llvm.ptr
cf.br ^bb150
^bb150:
%1269 = llvm.load %1268 : !llvm.ptr -> i64
%1270 = arith.cmpi slt, %1269, %1250 : i64
cf.cond_br %1270, ^bb151, ^bb152
^bb151:
%1271 = arith.constant 1 : i32
%1272 = llvm.mlir.constant(1 : i64) : i64
%1273 = llvm.alloca %1272 x i32 : (i64) -> !llvm.ptr
llvm.store %1271, %1273 : i32, !llvm.ptr
%1274 = arith.constant 0 : i32
%1275 = arith.extsi %1274 : i32 to i64
%1276 = llvm.mlir.constant(1 : i64) : i64
%1277 = llvm.alloca %1276 x i64 : (i64) -> !llvm.ptr
llvm.store %1275, %1277 : i64, !llvm.ptr
cf.br ^bb153
^bb153:
%1278 = llvm.load %1277 : !llvm.ptr -> i64
%1279 = arith.constant 9 : i32
%1281 = arith.extsi %1279 : i32 to i64
%1280 = arith.cmpi slt, %1278, %1281 : i64
cf.cond_br %1280, ^bb154, ^bb155
^bb154:
%1283 = llvm.load %1277 : !llvm.ptr -> i64
%1284 = arith.constant 2 : i32
%1286 = arith.extsi %1284 : i32 to i64
%1285 = arith.muli %1283, %1286 : i64
%1287 = llvm.getelementptr %804[%1285] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1282 = llvm.load %1287 : !llvm.ptr -> i64
%1289 = llvm.load %1277 : !llvm.ptr -> i64
%1290 = arith.constant 2 : i32
%1292 = arith.extsi %1290 : i32 to i64
%1291 = arith.muli %1289, %1292 : i64
%1293 = arith.constant 1 : i32
%1295 = arith.extsi %1293 : i32 to i64
%1294 = arith.addi %1291, %1295 : i64
%1296 = llvm.getelementptr %804[%1294] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1288 = llvm.load %1296 : !llvm.ptr -> i64
%1297 = arith.remsi %1282, %1250 : i64
%1298 = arith.constant 0 : i32
%1300 = arith.extsi %1298 : i32 to i64
%1299 = arith.cmpi eq, %1297, %1300 : i64
cf.cond_br %1299, ^bb156, ^bb157
^bb156:
%1301 = arith.remsi %1288, %1250 : i64
%1302 = arith.constant 0 : i32
%1304 = arith.extsi %1302 : i32 to i64
%1303 = arith.cmpi eq, %1301, %1304 : i64
cf.cond_br %1303, ^bb159, ^bb160
^bb159:
%1305 = arith.constant 0 : i32
llvm.store %1305, %1273 : i32, !llvm.ptr
cf.br ^bb155
^bb160:
cf.br ^bb161
^bb161:
cf.br ^bb158
^bb157:
%1307 = arith.constant 0 : i64
%1306 = arith.subi %1307, %1288 : i64
%1308 = func.call @inv_mod(%1282, %1250) : (i64, i64) -> i64
%1309 = arith.muli %1306, %1308 : i64
%1310 = arith.remsi %1309, %1250 : i64
%1311 = llvm.mlir.constant(1 : i64) : i64
%1312 = llvm.alloca %1311 x i64 : (i64) -> !llvm.ptr
llvm.store %1310, %1312 : i64, !llvm.ptr
%1313 = llvm.load %1312 : !llvm.ptr -> i64
%1314 = arith.constant 0 : i32
%1316 = arith.extsi %1314 : i32 to i64
%1315 = arith.cmpi slt, %1313, %1316 : i64
cf.cond_br %1315, ^bb162, ^bb163
^bb162:
%1317 = llvm.load %1312 : !llvm.ptr -> i64
%1318 = arith.addi %1317, %1250 : i64
llvm.store %1318, %1312 : i64, !llvm.ptr
cf.br ^bb164
^bb163:
cf.br ^bb164
^bb164:
%1319 = llvm.load %1268 : !llvm.ptr -> i64
%1320 = llvm.load %1312 : !llvm.ptr -> i64
%1321 = arith.cmpi eq, %1319, %1320 : i64
cf.cond_br %1321, ^bb165, ^bb166
^bb165:
%1322 = arith.constant 0 : i32
llvm.store %1322, %1273 : i32, !llvm.ptr
cf.br ^bb155
^bb166:
cf.br ^bb167
^bb167:
cf.br ^bb158
^bb158:
%1323 = llvm.load %1277 : !llvm.ptr -> i64
%1324 = arith.constant 1 : i32
%1326 = arith.extsi %1324 : i32 to i64
%1325 = arith.addi %1323, %1326 : i64
llvm.store %1325, %1277 : i64, !llvm.ptr
cf.br ^bb153
^bb155:
%1327 = llvm.load %1273 : !llvm.ptr -> i32
%1328 = arith.constant 1 : i32
%1329 = arith.cmpi eq, %1327, %1328 : i32
cf.cond_br %1329, ^bb168, ^bb169
^bb168:
%1331 = llvm.load %1064 : !llvm.ptr -> i64
%1330 = func.call @inv_mod(%1331, %1250) : (i64, i64) -> i64
%1332 = llvm.load %1268 : !llvm.ptr -> i64
%1333 = arith.remsi %1262, %1250 : i64
%1334 = arith.subi %1332, %1333 : i64
%1335 = arith.addi %1334, %1250 : i64
%1336 = arith.remsi %1335, %1250 : i64
%1337 = arith.muli %1336, %1330 : i64
%1338 = arith.remsi %1337, %1250 : i64
%1339 = llvm.load %1064 : !llvm.ptr -> i64
%1340 = arith.muli %1339, %1338 : i64
%1341 = arith.addi %1262, %1340 : i64
%1342 = llvm.load %1256 : !llvm.ptr -> i64
%1343 = llvm.getelementptr %1044[%1342] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1341, %1343 : i64, !llvm.ptr
%1344 = llvm.load %1256 : !llvm.ptr -> i64
%1345 = arith.constant 1 : i32
%1347 = arith.extsi %1345 : i32 to i64
%1346 = arith.addi %1344, %1347 : i64
llvm.store %1346, %1256 : i64, !llvm.ptr
cf.br ^bb170
^bb169:
cf.br ^bb170
^bb170:
%1348 = llvm.load %1268 : !llvm.ptr -> i64
%1349 = arith.constant 1 : i32
%1351 = arith.extsi %1349 : i32 to i64
%1350 = arith.addi %1348, %1351 : i64
llvm.store %1350, %1268 : i64, !llvm.ptr
cf.br ^bb150
^bb152:
%1352 = llvm.load %1076 : !llvm.ptr -> i64
%1353 = arith.constant 1 : i32
%1355 = arith.extsi %1353 : i32 to i64
%1354 = arith.addi %1352, %1355 : i64
llvm.store %1354, %1076 : i64, !llvm.ptr
cf.br ^bb147
^bb149:
%1356 = arith.constant 0 : i32
%1357 = arith.extsi %1356 : i32 to i64
llvm.store %1357, %1076 : i64, !llvm.ptr
cf.br ^bb171
^bb171:
%1358 = llvm.load %1076 : !llvm.ptr -> i64
%1359 = llvm.load %1256 : !llvm.ptr -> i64
%1360 = arith.cmpi slt, %1358, %1359 : i64
cf.cond_br %1360, ^bb172, ^bb173
^bb172:
%1362 = llvm.load %1076 : !llvm.ptr -> i64
%1363 = llvm.getelementptr %1044[%1362] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1361 = llvm.load %1363 : !llvm.ptr -> i64
%1364 = llvm.load %1076 : !llvm.ptr -> i64
%1365 = llvm.getelementptr %1039[%1364] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1361, %1365 : i64, !llvm.ptr
%1366 = llvm.load %1076 : !llvm.ptr -> i64
%1367 = arith.constant 1 : i32
%1369 = arith.extsi %1367 : i32 to i64
%1368 = arith.addi %1366, %1369 : i64
llvm.store %1368, %1076 : i64, !llvm.ptr
cf.br ^bb171
^bb173:
%1370 = llvm.load %1256 : !llvm.ptr -> i64
llvm.store %1370, %1060 : i64, !llvm.ptr
%1371 = llvm.load %1064 : !llvm.ptr -> i64
%1372 = arith.muli %1371, %1250 : i64
llvm.store %1372, %1064 : i64, !llvm.ptr
%1373 = llvm.load %1068 : !llvm.ptr -> i64
%1374 = arith.constant 1 : i32
%1376 = arith.extsi %1374 : i32 to i64
%1375 = arith.addi %1373, %1376 : i64
llvm.store %1375, %1068 : i64, !llvm.ptr
cf.br ^bb144
^bb146:
%1377 = llvm.load %1060 : !llvm.ptr -> i64
%1378 = arith.constant 0 : i32
%1379 = arith.extsi %1378 : i32 to i64
%1380 = llvm.getelementptr %726[%1379] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1377, %1380 : i64, !llvm.ptr
%1381 = arith.constant 0 : i32
%1382 = arith.extsi %1381 : i32 to i64
llvm.store %1382, %1076 : i64, !llvm.ptr
cf.br ^bb174
^bb174:
%1383 = llvm.load %1076 : !llvm.ptr -> i64
%1384 = llvm.load %1060 : !llvm.ptr -> i64
%1385 = arith.cmpi slt, %1383, %1384 : i64
cf.cond_br %1385, ^bb175, ^bb176
^bb175:
%1387 = llvm.load %1076 : !llvm.ptr -> i64
%1388 = llvm.getelementptr %1039[%1387] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1386 = llvm.load %1388 : !llvm.ptr -> i64
%1389 = llvm.load %1076 : !llvm.ptr -> i64
%1390 = llvm.getelementptr %716[%1389] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1386, %1390 : i64, !llvm.ptr
%1391 = llvm.load %1076 : !llvm.ptr -> i64
%1392 = arith.constant 1 : i32
%1394 = arith.extsi %1392 : i32 to i64
%1393 = arith.addi %1391, %1394 : i64
llvm.store %1393, %1076 : i64, !llvm.ptr
cf.br ^bb174
^bb176:
%1395 = llvm.mlir.addressof @N_LIMIT : !llvm.ptr
%1396 = llvm.load %1395 : !llvm.ptr -> i64
%1397 = arith.subi %1396, %1232 : i64
%1398 = arith.constant 2520 : i32
%1400 = arith.extsi %1398 : i32 to i64
%1399 = arith.divsi %1397, %1400 : i64
%1401 = arith.constant 0 : i32
%1402 = arith.extsi %1401 : i32 to i64
llvm.store %1402, %1080 : i64, !llvm.ptr
cf.br ^bb177
^bb177:
%1403 = llvm.load %1080 : !llvm.ptr -> i64
%1405 = arith.constant 0 : i32
%1406 = arith.extsi %1405 : i32 to i64
%1407 = llvm.getelementptr %721[%1406] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1404 = llvm.load %1407 : !llvm.ptr -> i64
%1408 = arith.cmpi slt, %1403, %1404 : i64
cf.cond_br %1408, ^bb178, ^bb179
^bb178:
%1410 = llvm.load %1080 : !llvm.ptr -> i64
%1411 = llvm.getelementptr %711[%1410] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1409 = llvm.load %1411 : !llvm.ptr -> i64
%1412 = arith.subi %1399, %1409 : i64
%1413 = arith.remsi %1412, %1230 : i64
%1414 = arith.subi %1399, %1413 : i64
%1415 = llvm.mlir.constant(1 : i64) : i64
%1416 = llvm.alloca %1415 x i64 : (i64) -> !llvm.ptr
llvm.store %1414, %1416 : i64, !llvm.ptr
%1417 = llvm.load %1416 : !llvm.ptr -> i64
%1418 = arith.constant 0 : i32
%1420 = arith.extsi %1418 : i32 to i64
%1419 = arith.cmpi sge, %1417, %1420 : i64
cf.cond_br %1419, ^bb180, ^bb181
^bb180:
%1421 = arith.constant 2520 : i32
%1422 = llvm.load %1416 : !llvm.ptr -> i64
%1424 = arith.extsi %1421 : i32 to i64
%1423 = arith.muli %1424, %1422 : i64
%1425 = arith.addi %1423, %1232 : i64
%1428 = arith.constant 0 : i64
%1427 = arith.subi %1428, %1425 : i64
%1429 = llvm.load %1416 : !llvm.ptr -> i64
%1430 = arith.constant 0 : i32
%1431 = arith.extsi %1430 : i32 to i64
func.call @heap_push(%731, %738, %1427, %1232, %1429, %1409, %1431) : (!llvm.ptr, !llvm.ptr, i64, i64, i64, i64, i64) -> ()
cf.br ^bb182
^bb181:
cf.br ^bb182
^bb182:
%1432 = llvm.load %1080 : !llvm.ptr -> i64
%1433 = arith.constant 1 : i32
%1435 = arith.extsi %1433 : i32 to i64
%1434 = arith.addi %1432, %1435 : i64
llvm.store %1434, %1080 : i64, !llvm.ptr
cf.br ^bb177
^bb179:
%1436 = llvm.mlir.addressof @N_LIMIT : !llvm.ptr
%1437 = llvm.load %1436 : !llvm.ptr -> i64
%1438 = arith.subi %1437, %1234 : i64
%1439 = arith.constant 2520 : i32
%1441 = arith.extsi %1439 : i32 to i64
%1440 = arith.divsi %1438, %1441 : i64
%1442 = arith.constant 0 : i32
%1443 = arith.extsi %1442 : i32 to i64
llvm.store %1443, %1080 : i64, !llvm.ptr
cf.br ^bb183
^bb183:
%1444 = llvm.load %1080 : !llvm.ptr -> i64
%1446 = arith.constant 0 : i32
%1447 = arith.extsi %1446 : i32 to i64
%1448 = llvm.getelementptr %726[%1447] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1445 = llvm.load %1448 : !llvm.ptr -> i64
%1449 = arith.cmpi slt, %1444, %1445 : i64
cf.cond_br %1449, ^bb184, ^bb185
^bb184:
%1451 = llvm.load %1080 : !llvm.ptr -> i64
%1452 = llvm.getelementptr %716[%1451] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1450 = llvm.load %1452 : !llvm.ptr -> i64
%1453 = arith.subi %1440, %1450 : i64
%1454 = arith.remsi %1453, %1230 : i64
%1455 = arith.subi %1440, %1454 : i64
%1456 = llvm.mlir.constant(1 : i64) : i64
%1457 = llvm.alloca %1456 x i64 : (i64) -> !llvm.ptr
llvm.store %1455, %1457 : i64, !llvm.ptr
%1458 = llvm.load %1457 : !llvm.ptr -> i64
%1459 = arith.constant 0 : i32
%1461 = arith.extsi %1459 : i32 to i64
%1460 = arith.cmpi sge, %1458, %1461 : i64
cf.cond_br %1460, ^bb186, ^bb187
^bb186:
%1462 = arith.constant 2520 : i32
%1463 = llvm.load %1457 : !llvm.ptr -> i64
%1465 = arith.extsi %1462 : i32 to i64
%1464 = arith.muli %1465, %1463 : i64
%1466 = arith.addi %1464, %1234 : i64
%1469 = arith.constant 0 : i64
%1468 = arith.subi %1469, %1466 : i64
%1470 = llvm.load %1457 : !llvm.ptr -> i64
%1471 = arith.constant 1 : i32
%1472 = arith.extsi %1471 : i32 to i64
func.call @heap_push(%731, %738, %1468, %1234, %1470, %1450, %1472) : (!llvm.ptr, !llvm.ptr, i64, i64, i64, i64, i64) -> ()
cf.br ^bb188
^bb187:
cf.br ^bb188
^bb188:
%1473 = llvm.load %1080 : !llvm.ptr -> i64
%1474 = arith.constant 1 : i32
%1476 = arith.extsi %1474 : i32 to i64
%1475 = arith.addi %1473, %1476 : i64
llvm.store %1475, %1080 : i64, !llvm.ptr
cf.br ^bb183
^bb185:
cf.br ^bb189
^bb189:
%1478 = arith.constant 0 : i32
%1479 = arith.extsi %1478 : i32 to i64
%1480 = llvm.getelementptr %738[%1479] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1477 = llvm.load %1480 : !llvm.ptr -> i64
%1481 = arith.constant 0 : i32
%1483 = arith.extsi %1481 : i32 to i64
%1482 = arith.cmpi sgt, %1477, %1483 : i64
cf.cond_br %1482, ^bb190, ^bb191
^bb190:
func.call @heap_pop(%731, %743, %738) : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
%1486 = arith.constant 0 : i32
%1487 = arith.extsi %1486 : i32 to i64
%1488 = llvm.getelementptr %743[%1487] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1485 = llvm.load %1488 : !llvm.ptr -> i64
%1490 = arith.constant 1 : i32
%1491 = arith.extsi %1490 : i32 to i64
%1492 = llvm.getelementptr %743[%1491] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1489 = llvm.load %1492 : !llvm.ptr -> i64
%1494 = arith.constant 2 : i32
%1495 = arith.extsi %1494 : i32 to i64
%1496 = llvm.getelementptr %743[%1495] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1493 = llvm.load %1496 : !llvm.ptr -> i64
%1498 = arith.constant 3 : i32
%1499 = arith.extsi %1498 : i32 to i64
%1500 = llvm.getelementptr %743[%1499] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1497 = llvm.load %1500 : !llvm.ptr -> i64
%1502 = arith.constant 4 : i32
%1503 = arith.extsi %1502 : i32 to i64
%1504 = llvm.getelementptr %743[%1503] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1501 = llvm.load %1504 : !llvm.ptr -> i64
%1506 = arith.constant 0 : i64
%1505 = arith.subi %1506, %1485 : i64
%1507 = arith.subi %1493, %1230 : i64
%1508 = arith.constant 0 : i32
%1510 = arith.extsi %1508 : i32 to i64
%1509 = arith.cmpi sge, %1507, %1510 : i64
cf.cond_br %1509, ^bb192, ^bb193
^bb192:
%1511 = arith.constant 2520 : i32
%1513 = arith.extsi %1511 : i32 to i64
%1512 = arith.muli %1513, %1507 : i64
%1514 = arith.addi %1512, %1489 : i64
%1517 = arith.constant 0 : i64
%1516 = arith.subi %1517, %1514 : i64
func.call @heap_push(%731, %738, %1516, %1489, %1507, %1497, %1501) : (!llvm.ptr, !llvm.ptr, i64, i64, i64, i64, i64) -> ()
cf.br ^bb194
^bb193:
cf.br ^bb194
^bb194:
%1518 = llvm.mlir.constant(1 : i64) : i64
%1519 = llvm.alloca %1518 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %799, %1519 : !llvm.ptr, !llvm.ptr
%1520 = arith.constant 1 : i32
%1522 = arith.extsi %1520 : i32 to i64
%1521 = arith.cmpi eq, %1501, %1522 : i64
cf.cond_br %1521, ^bb195, ^bb196
^bb195:
llvm.store %804, %1519 : !llvm.ptr, !llvm.ptr
cf.br ^bb197
^bb196:
cf.br ^bb197
^bb197:
%1523 = arith.constant 0 : i32
%1524 = arith.extsi %1523 : i32 to i64
%1525 = llvm.mlir.constant(1 : i64) : i64
%1526 = llvm.alloca %1525 x i64 : (i64) -> !llvm.ptr
llvm.store %1524, %1526 : i64, !llvm.ptr
cf.br ^bb198
^bb198:
%1527 = llvm.load %1526 : !llvm.ptr -> i64
%1528 = arith.constant 9 : i32
%1530 = arith.extsi %1528 : i32 to i64
%1529 = arith.cmpi slt, %1527, %1530 : i64
cf.cond_br %1529, ^bb199, ^bb200
^bb199:
%1532 = llvm.load %1519 : !llvm.ptr -> !llvm.ptr
%1533 = llvm.load %1526 : !llvm.ptr -> i64
%1534 = arith.constant 2 : i32
%1536 = arith.extsi %1534 : i32 to i64
%1535 = arith.muli %1533, %1536 : i64
%1537 = llvm.getelementptr %1532[%1535] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1531 = llvm.load %1537 : !llvm.ptr -> i64
%1538 = arith.muli %1531, %1493 : i64
%1540 = llvm.load %1519 : !llvm.ptr -> !llvm.ptr
%1541 = llvm.load %1526 : !llvm.ptr -> i64
%1542 = arith.constant 2 : i32
%1544 = arith.extsi %1542 : i32 to i64
%1543 = arith.muli %1541, %1544 : i64
%1545 = arith.constant 1 : i32
%1547 = arith.extsi %1545 : i32 to i64
%1546 = arith.addi %1543, %1547 : i64
%1548 = llvm.getelementptr %1540[%1546] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1539 = llvm.load %1548 : !llvm.ptr -> i64
%1549 = arith.addi %1538, %1539 : i64
%1550 = llvm.load %1526 : !llvm.ptr -> i64
%1551 = llvm.getelementptr %748[%1550] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1549, %1551 : i64, !llvm.ptr
%1552 = llvm.load %1526 : !llvm.ptr -> i64
%1553 = arith.constant 1 : i32
%1555 = arith.extsi %1553 : i32 to i64
%1554 = arith.addi %1552, %1555 : i64
llvm.store %1554, %1526 : i64, !llvm.ptr
cf.br ^bb198
^bb200:
%1556 = func.call @check_quad(%748, %753) : (!llvm.ptr, !llvm.ptr) -> i32
%1557 = arith.constant 1 : i32
%1558 = arith.cmpi eq, %1556, %1557 : i32
cf.cond_br %1558, ^bb201, ^bb202
^bb201:
%1559 = arith.constant 0 : i32
%1560 = arith.extsi %1559 : i32 to i64
%1561 = llvm.mlir.constant(1 : i64) : i64
%1562 = llvm.alloca %1561 x i64 : (i64) -> !llvm.ptr
llvm.store %1560, %1562 : i64, !llvm.ptr
%1563 = arith.constant 0 : i32
%1564 = arith.extsi %1563 : i32 to i64
llvm.store %1564, %1526 : i64, !llvm.ptr
cf.br ^bb204
^bb204:
%1565 = llvm.load %1526 : !llvm.ptr -> i64
%1566 = arith.constant 9 : i32
%1568 = arith.extsi %1566 : i32 to i64
%1567 = arith.cmpi slt, %1565, %1568 : i64
cf.cond_br %1567, ^bb205, ^bb206
^bb205:
%1569 = llvm.load %1562 : !llvm.ptr -> i64
%1571 = llvm.load %1526 : !llvm.ptr -> i64
%1572 = llvm.getelementptr %748[%1571] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1570 = llvm.load %1572 : !llvm.ptr -> i64
%1573 = arith.addi %1569, %1570 : i64
llvm.store %1573, %1562 : i64, !llvm.ptr
%1574 = llvm.load %1526 : !llvm.ptr -> i64
%1575 = arith.constant 1 : i32
%1577 = arith.extsi %1575 : i32 to i64
%1576 = arith.addi %1574, %1577 : i64
llvm.store %1576, %1526 : i64, !llvm.ptr
cf.br ^bb204
^bb206:
%1578 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1579 = llvm.load %1562 : !llvm.ptr -> i64
%1580 = llvm.call @printf(%1578, %1579) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
func.call @free(%711) : (!llvm.ptr) -> ()
func.call @free(%716) : (!llvm.ptr) -> ()
func.call @free(%721) : (!llvm.ptr) -> ()
func.call @free(%726) : (!llvm.ptr) -> ()
func.call @free(%731) : (!llvm.ptr) -> ()
func.call @free(%738) : (!llvm.ptr) -> ()
func.call @free(%743) : (!llvm.ptr) -> ()
func.call @free(%748) : (!llvm.ptr) -> ()
func.call @free(%753) : (!llvm.ptr) -> ()
func.call @free(%799) : (!llvm.ptr) -> ()
func.call @free(%804) : (!llvm.ptr) -> ()
func.call @free(%989) : (!llvm.ptr) -> ()
func.call @free(%1039) : (!llvm.ptr) -> ()
func.call @free(%1044) : (!llvm.ptr) -> ()
%1595 = arith.constant 0 : i32
func.return %1595 : i32
^bb202:
cf.br ^bb203
^bb203:
cf.br ^bb189
^bb191:
%1596 = llvm.mlir.addressof @str_1 : !llvm.ptr
%1597 = llvm.call @printf(%1596) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr) -> i32
%1598 = arith.constant 1 : i32
func.return %1598 : i32
}
}