Problem 598
Split Divisibilities — ratio DP for C(100!).
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n^4) | ? |
|---|
| Space complexity | O(n^2) | ? |
|---|
| Approach | Flow solution | Not curated |
|---|
| Verdict | Unknown |
|---|
Flow source
# Project Euler 598
# Split Divisibilities — ratio DP for C(100!).
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
}
function build_spf(limit: i64, spf: ptr<i32>) -> void {
let mut i: i64 = 0
while i <= limit {
spf[i] = i as i32
i = i + 1
}
spf[0] = 0
if limit >= 1 { spf[1] = 1 }
i = 2
while i * i <= limit {
if (spf[i] as i64) == i {
let mut j: i64 = i * i
while j <= limit {
if (spf[j] as i64) == j { spf[j] = i as i32 }
j = j + i
}
}
i = i + 1
}
}
function packR(v: ptr<i64>) -> i64 {
let mut k: i64 = 0
let mut i: i64 = 0
while i < 7 {
k = (k << 8) + (v[i] + 128)
i = i + 1
}
return k
}
function main() -> i32 {
let spf: ptr<i32> = calloc(100, 4)
build_spf(99, spf)
let pl: ptr<i64> = calloc(9, 8)
pl[0]=2
pl[1]=3
pl[2]=5
pl[3]=7
pl[4]=11
pl[5]=13
pl[6]=17
pl[7]=19
pl[8]=23
let ph: ptr<i64> = calloc(6, 8)
ph[0]=29
ph[1]=31
ph[2]=37
ph[3]=41
ph[4]=43
ph[5]=47
let vlow: ptr<i64> = calloc(100 * 9, 8)
let vhigh: ptr<i64> = calloc(100 * 6, 8)
let has_big: ptr<i8> = calloc(100, 1)
let mut n: i64 = 2
while n <= 99 {
let mut x: i64 = n
while x > 1 {
let p: i64 = spf[x] as i64
let mut c: i64 = 0
while x % p == 0 {
x = x / p
c = c + 1
}
if p > 47 { has_big[n] = 1 }
let mut i: i64 = 0
while i < 9 {
if pl[i] == p { vlow[n * 9 + i] = c }
i = i + 1
}
i = 0
while i < 6 {
if ph[i] == p { vhigh[n * 6 + i] = c }
i = i + 1
}
}
n = n + 1
}
let big_es: ptr<i64> = calloc(7, 8)
let bps: ptr<i64> = calloc(7, 8)
bps[0]=5
bps[1]=7
bps[2]=11
bps[3]=13
bps[4]=17
bps[5]=19
bps[6]=23
let mut bi: i64 = 0
while bi < 7 {
let p: i64 = bps[bi]
let mut e: i64 = 0
let mut v: i64 = 100
while v > 0 {
v = v / p
e = e + v
}
big_es[bi] = e
bi = bi + 1
}
# Entry lists: Rpack, d2, d3, cnt
let CAP: i64 = 3000000
let mut R0: ptr<i64> = calloc(CAP, 8)
let mut A0: ptr<i64> = calloc(CAP, 8)
let mut B0: ptr<i64> = calloc(CAP, 8)
let mut C0: ptr<i64> = calloc(CAP, 8)
let mut n0: i64 = 1
let zR: ptr<i64> = calloc(7, 8)
R0[0] = packR(zR)
free(zR)
A0[0] = 0
B0[0] = 0
C0[0] = 1
# Hash for combining duplicates each layer
let HCAP: i64 = 400003
let mut hi: i64 = 0
let hkey: ptr<i64> = calloc(HCAP, 8)
let hval: ptr<i64> = calloc(HCAP, 8)
let hused: ptr<i8> = calloc(HCAP, 1)
let hidx: ptr<i64> = calloc(HCAP, 8)
bi = 0
while bi < 7 {
let e: i64 = big_es[bi]
# clear hash
hi = 0
while hi < HCAP {
hused[hi] = 0
hi = hi + 1
}
let R1: ptr<i64> = calloc(CAP, 8)
let A1: ptr<i64> = calloc(CAP, 8)
let B1: ptr<i64> = calloc(CAP, 8)
let C1: ptr<i64> = calloc(CAP, 8)
let mut n1: i64 = 0
let mut oi: i64 = 0
while oi < n0 {
let mut x: i64 = 0
while x <= e {
let u: i64 = x + 1
let v: i64 = e - x + 1
let Rd: ptr<i64> = calloc(7, 8)
let mut k: i64 = 0
while k < 7 {
Rd[k] = vlow[u * 9 + (k + 2)] - vlow[v * 9 + (k + 2)]
k = k + 1
}
let d2d: i64 = vlow[u * 9 + 0] - vlow[v * 9 + 0]
let d3d: i64 = vlow[u * 9 + 1] - vlow[v * 9 + 1]
# decode old R
let mut oldR: ptr<i64> = calloc(7, 8)
let mut rp: i64 = R0[oi]
k = 6
while k >= 0 {
oldR[k] = (rp & 255) - 128
rp = rp >> 8
k = k - 1
}
let newR: ptr<i64> = calloc(7, 8)
k = 0
while k < 7 {
newR[k] = oldR[k] + Rd[k]
k = k + 1
}
let Rpack: i64 = packR(newR)
let nd2: i64 = A0[oi] + d2d
let nd3: i64 = B0[oi] + d3d
let mut combo: i64 = Rpack ^ ((nd2 + 5000) * 1000003) ^ ((nd3 + 5000) * 9176)
if combo < 0 { combo = -combo }
let mut h: i64 = combo % HCAP
let mut found: i32 = 0
let mut probes: i64 = 0
while probes < 20000 {
if hused[h] == 0 {
hused[h] = 1
hkey[h] = combo
hidx[h] = n1
R1[n1] = Rpack
A1[n1] = nd2
B1[n1] = nd3
C1[n1] = C0[oi]
n1 = n1 + 1
found = 1
break
}
if hkey[h] == combo && R1[hidx[h]] == Rpack && A1[hidx[h]] == nd2 && B1[hidx[h]] == nd3 {
C1[hidx[h]] = C1[hidx[h]] + C0[oi]
found = 1
break
}
h = h + 1
if h >= HCAP { h = 0 }
probes = probes + 1
}
free(Rd)
free(oldR)
free(newR)
x = x + 1
}
oi = oi + 1
}
free(R0)
free(A0)
free(B0)
free(C0)
R0 = R1
A0 = A1
B0 = B1
C0 = C1
n0 = n1
bi = bi + 1
}
# Small-groups distribution S on (d2,d3)
let SCAP: i64 = 200000
let mut S2: ptr<i64> = calloc(SCAP, 8)
let mut S3: ptr<i64> = calloc(SCAP, 8)
let mut SC: ptr<i64> = calloc(SCAP, 8)
let mut ns: i64 = 1
S2[0]=0
S3[0]=0
SC[0]=1
# 10 times (+-1,0)
let mut rep: i64 = 0
while rep < 10 {
let mut T2: ptr<i64> = calloc(SCAP, 8)
let mut T3: ptr<i64> = calloc(SCAP, 8)
let mut TC: ptr<i64> = calloc(SCAP, 8)
let mut nt: i64 = 0
hi = 0
while hi < HCAP {
hused[hi] = 0
hi = hi + 1
}
let mut si: i64 = 0
while si < ns {
let mut sign: i64 = -1
while sign <= 1 {
if sign != 0 {
let nd2: i64 = S2[si] + sign
let nd3: i64 = S3[si]
let mut combo: i64 = (nd2 + 5000) * 10007 + (nd3 + 5000)
if combo < 0 { combo = -combo }
let mut h: i64 = combo % HCAP
let mut probes: i64 = 0
while probes < 20000 {
if hused[h] == 0 {
hused[h]=1
hkey[h]=combo
hidx[h]=nt
T2[nt]=nd2
T3[nt]=nd3
TC[nt]=SC[si]
nt=nt+1
break
}
if hkey[h]==combo && T2[hidx[h]]==nd2 && T3[hidx[h]]==nd3 {
TC[hidx[h]] = TC[hidx[h]] + SC[si]
break
}
h=h+1
if h>=HCAP { h=0 }
probes=probes+1
}
}
sign = sign + 2
}
si = si + 1
}
free(S2)
free(S3)
free(SC)
S2=T2
S3=T3
SC=TC
ns=nt
rep = rep + 1
}
# 4 times (0, +-1) and (0,0)
rep = 0
while rep < 4 {
let mut T2: ptr<i64> = calloc(SCAP, 8)
let mut T3: ptr<i64> = calloc(SCAP, 8)
let mut TC: ptr<i64> = calloc(SCAP, 8)
let mut nt: i64 = 0
hi = 0
while hi < HCAP {
hused[hi] = 0
hi = hi + 1
}
let mut si: i64 = 0
while si < ns {
let mut db: i64 = -1
while db <= 1 {
let nd2: i64 = S2[si]
let nd3: i64 = S3[si] + db
let mut combo: i64 = (nd2 + 5000) * 10007 + (nd3 + 5000)
if combo < 0 { combo = -combo }
let mut h: i64 = combo % HCAP
let mut probes: i64 = 0
while probes < 20000 {
if hused[h] == 0 {
hused[h]=1
hkey[h]=combo
hidx[h]=nt
T2[nt]=nd2
T3[nt]=nd3
TC[nt]=SC[si]
nt=nt+1
break
}
if hkey[h]==combo && T2[hidx[h]]==nd2 && T3[hidx[h]]==nd3 {
TC[hidx[h]] = TC[hidx[h]] + SC[si]
break
}
h=h+1
if h>=HCAP { h=0 }
probes=probes+1
}
db = db + 1
}
si = si + 1
}
free(S2)
free(S3)
free(SC)
S2=T2
S3=T3
SC=TC
ns=nt
rep = rep + 1
}
# 2 times special deltas for e=3
rep = 0
while rep < 2 {
let deltas: ptr<i64> = calloc(8, 8)
deltas[0]=-2
deltas[1]=0
deltas[2]=1
deltas[3]=-1
deltas[4]=-1
deltas[5]=1
deltas[6]=2
deltas[7]=0
let mut T2: ptr<i64> = calloc(SCAP, 8)
let mut T3: ptr<i64> = calloc(SCAP, 8)
let mut TC: ptr<i64> = calloc(SCAP, 8)
let mut nt: i64 = 0
hi = 0
while hi < HCAP {
hused[hi] = 0
hi = hi + 1
}
let mut si: i64 = 0
while si < ns {
let mut di: i64 = 0
while di < 4 {
let nd2: i64 = S2[si] + deltas[2*di]
let nd3: i64 = S3[si] + deltas[2*di+1]
let mut combo: i64 = (nd2 + 5000) * 10007 + (nd3 + 5000)
if combo < 0 { combo = -combo }
let mut h: i64 = combo % HCAP
let mut probes: i64 = 0
while probes < 20000 {
if hused[h] == 0 {
hused[h]=1
hkey[h]=combo
hidx[h]=nt
T2[nt]=nd2
T3[nt]=nd3
TC[nt]=SC[si]
nt=nt+1
break
}
if hkey[h]==combo && T2[hidx[h]]==nd2 && T3[hidx[h]]==nd3 {
TC[hidx[h]] = TC[hidx[h]] + SC[si]
break
}
h=h+1
if h>=HCAP { h=0 }
probes=probes+1
}
di = di + 1
}
si = si + 1
}
free(deltas)
free(S2)
free(S3)
free(SC)
S2=T2
S3=T3
SC=TC
ns=nt
rep = rep + 1
}
# Index M by Rpack for lookup: build hash Rpack -> list of (d2,d3,cnt)
# For simplicity linear scan over n0 entries per query is OK if we first bucket by Rpack
let mut N_all: i64 = 0
let mut u2: i64 = 1
while u2 <= 98 {
let v2: i64 = 99 - u2
if has_big[u2] == 0 && has_big[v2] == 0 {
let mut u3: i64 = 1
while u3 <= 49 {
let v3: i64 = 50 - u3
let mut okh: i32 = 1
let mut k: i64 = 0
while k < 6 {
if vhigh[u2*6+k] - vhigh[v2*6+k] + vhigh[u3*6+k] - vhigh[v3*6+k] != 0 { okh = 0 }
k = k + 1
}
if okh != 0 {
let targetR: ptr<i64> = calloc(7, 8)
k = 0
while k < 7 {
let d: i64 = (vlow[u2*9+(k+2)] - vlow[v2*9+(k+2)]) + (vlow[u3*9+(k+2)] - vlow[v3*9+(k+2)])
targetR[k] = 0 - d
k = k + 1
}
let tpack: i64 = packR(targetR)
let t2: i64 = 0 - ((vlow[u2*9+0]-vlow[v2*9+0]) + (vlow[u3*9+0]-vlow[v3*9+0]))
let t3: i64 = 0 - ((vlow[u2*9+1]-vlow[v2*9+1]) + (vlow[u3*9+1]-vlow[v3*9+1]))
let mut sub: i64 = 0
let mut mi: i64 = 0
while mi < n0 {
if R0[mi] == tpack {
let mut si: i64 = 0
while si < ns {
if A0[mi] == t2 - S2[si] && B0[mi] == t3 - S3[si] {
sub = sub + C0[mi] * SC[si]
}
si = si + 1
}
}
mi = mi + 1
}
N_all = N_all + sub
free(targetR)
}
u3 = u3 + 1
}
}
u2 = u2 + 1
}
printf("%lld\n", N_all / 2)
return 0
}
Generated C
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Flow runtime helpers */
typedef struct flow_temp_node { struct flow_temp_node* next; } flow_temp_node;
static flow_temp_node* flow_temp_head = NULL;
static int flow_temp_atexit_set = 0;
__attribute__((unused)) static void flow_temp_free_all(void) {
while (flow_temp_head) {
flow_temp_node* n = flow_temp_head;
flow_temp_head = n->next;
free(n);
}
}
__attribute__((unused)) static void* flow_temp_alloc(size_t nbytes) {
flow_temp_node* node = (flow_temp_node*)malloc(sizeof(flow_temp_node) + nbytes);
if (!node) return NULL;
node->next = flow_temp_head;
flow_temp_head = node;
if (!flow_temp_atexit_set) {
flow_temp_atexit_set = 1;
atexit(flow_temp_free_all);
}
return (void*)(node + 1);
}
#ifndef FLOW_DIAG
#define FLOW_DIAG(msg) fprintf(stderr, "%s", (msg))
#endif
#ifndef FLOW_LOG
#define FLOW_LOG(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
#ifndef FLOW_LOG_EMPTY
#define FLOW_LOG_EMPTY(fmt) printf(fmt)
#endif
static char* flow_strcat(const char* a, const char* b) {
size_t la = strlen(a ? a : ""), lb = strlen(b ? b : "");
char* r = (char*)flow_temp_alloc(la + lb + 1);
if (!r) return NULL;
if (la) memcpy(r, a, la);
if (lb) memcpy(r + la, b, lb);
r[la + lb] = '\0';
return r;
}
#define __flow_in_arr(arr, val) __extension__ ({ \
int _found = 0; \
size_t _n = sizeof(arr)/sizeof((arr)[0]); \
for (size_t _i = 0; _i < _n; _i++) { \
if ((arr)[_i] == (val)) { _found = 1; break; } \
} _found; })
/* Unified fault handler (MISRA #279) — override with -DFLOW_FAULT_HANDLER=fn */
#ifndef FLOW_FAULT_HANDLER
__attribute__((unused)) static inline void flow_fault_handler(const char* msg) {
fprintf(stderr, "flow: %s\n", msg ? msg : "fault");
abort();
#if defined(__GNUC__) || defined(__clang__)
__builtin_unreachable();
#endif
}
#else
#define flow_fault_handler FLOW_FAULT_HANDLER
#endif
#define flow_div_by_zero_handler() flow_fault_handler("division by zero")
#define flow_shift_ub_handler() flow_fault_handler("invalid shift (amount out of range or left-shift of negative)")
#ifndef FLOW_CHECKED_DIV
#define FLOW_CHECKED_DIV(L, R) (((R) != 0) ? ((L) / (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_MOD
#define FLOW_CHECKED_MOD(L, R) (((R) != 0) ? ((L) % (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHL
#define FLOW_CHECKED_SHL(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull)) && ((L) >= 0)) ? ((L) << (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHR
#define FLOW_CHECKED_SHR(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull))) ? ((L) >> (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#include <math.h>
void* _ui_state = NULL;
static inline float i32_to_f32(int32_t v) { return (float)v; }
/* Host stub for @gpu kernels (device codegen replaces this). */
static inline int32_t gpu_thread_id(void) { return 0; }
void build_spf_i64_ptr_i32(int64_t limit, int32_t* spf);
int64_t packR_ptr_i64(int64_t* v);
int32_t main(void);
void build_spf_i64_ptr_i32(int64_t limit, int32_t* spf) {
int64_t i = 0;
while (i <= limit) {
spf[i] = ((int32_t)(i));
i = (i + 1);
}
spf[0] = 0;
if (limit >= 1) {
spf[1] = 1;
}
i = 2;
while ((i * i) <= limit) {
if (((int64_t)(spf[i])) == i) {
int64_t j = (i * i);
while (j <= limit) {
if (((int64_t)(spf[j])) == j) {
spf[j] = ((int32_t)(i));
}
j = (j + i);
}
}
i = (i + 1);
}
}
int64_t packR_ptr_i64(int64_t* v) {
int64_t k = 0;
int64_t i = 0;
while (i < 7) {
k = (FLOW_CHECKED_SHL((k), (8)) + (v[i] + 128));
i = (i + 1);
}
return k;
}
int32_t main(void) {
int32_t* spf = (int32_t*)(calloc(100, 4));
build_spf_i64_ptr_i32(99, spf);
int64_t* pl = (int64_t*)(calloc(9, 8));
pl[0] = 2;
pl[1] = 3;
pl[2] = 5;
pl[3] = 7;
pl[4] = 11;
pl[5] = 13;
pl[6] = 17;
pl[7] = 19;
pl[8] = 23;
int64_t* ph = (int64_t*)(calloc(6, 8));
ph[0] = 29;
ph[1] = 31;
ph[2] = 37;
ph[3] = 41;
ph[4] = 43;
ph[5] = 47;
int64_t* vlow = (int64_t*)(calloc((100 * 9), 8));
int64_t* vhigh = (int64_t*)(calloc((100 * 6), 8));
int8_t* has_big = (int8_t*)(calloc(100, 1));
int64_t n = 2;
while (n <= 99) {
int64_t x = n;
while (x > 1) {
int64_t p = ((int64_t)(spf[x]));
int64_t c = 0;
while (FLOW_CHECKED_MOD((x), (p)) == 0) {
x = FLOW_CHECKED_DIV((x), (p));
c = (c + 1);
}
if (p > 47) {
has_big[n] = 1;
}
int64_t i = 0;
while (i < 9) {
if (pl[i] == p) {
vlow[((n * 9) + i)] = c;
}
i = (i + 1);
}
i = 0;
while (i < 6) {
if (ph[i] == p) {
vhigh[((n * 6) + i)] = c;
}
i = (i + 1);
}
}
n = (n + 1);
}
int64_t* big_es = (int64_t*)(calloc(7, 8));
int64_t* bps = (int64_t*)(calloc(7, 8));
bps[0] = 5;
bps[1] = 7;
bps[2] = 11;
bps[3] = 13;
bps[4] = 17;
bps[5] = 19;
bps[6] = 23;
int64_t bi = 0;
while (bi < 7) {
int64_t p = bps[bi];
int64_t e = 0;
int64_t v = 100;
while (v > 0) {
v = FLOW_CHECKED_DIV((v), (p));
e = (e + v);
}
big_es[bi] = e;
bi = (bi + 1);
}
int64_t CAP = 3000000;
int64_t* R0 = (int64_t*)(calloc(CAP, 8));
int64_t* A0 = (int64_t*)(calloc(CAP, 8));
int64_t* B0 = (int64_t*)(calloc(CAP, 8));
int64_t* C0 = (int64_t*)(calloc(CAP, 8));
int64_t n0 = 1;
int64_t* zR = (int64_t*)(calloc(7, 8));
R0[0] = packR_ptr_i64(zR);
free(zR);
A0[0] = 0;
B0[0] = 0;
C0[0] = 1;
int64_t HCAP = 400003;
int64_t hi = 0;
int64_t* hkey = (int64_t*)(calloc(HCAP, 8));
int64_t* hval = (int64_t*)(calloc(HCAP, 8));
int8_t* hused = (int8_t*)(calloc(HCAP, 1));
int64_t* hidx = (int64_t*)(calloc(HCAP, 8));
bi = 0;
while (bi < 7) {
int64_t e = big_es[bi];
hi = 0;
while (hi < HCAP) {
hused[hi] = 0;
hi = (hi + 1);
}
int64_t* R1 = (int64_t*)(calloc(CAP, 8));
int64_t* A1 = (int64_t*)(calloc(CAP, 8));
int64_t* B1 = (int64_t*)(calloc(CAP, 8));
int64_t* C1 = (int64_t*)(calloc(CAP, 8));
int64_t n1 = 0;
int64_t oi = 0;
while (oi < n0) {
int64_t x = 0;
while (x <= e) {
int64_t u = (x + 1);
int64_t v = ((e - x) + 1);
int64_t* Rd = (int64_t*)(calloc(7, 8));
int64_t k = 0;
while (k < 7) {
Rd[k] = (vlow[((u * 9) + (k + 2))] - vlow[((v * 9) + (k + 2))]);
k = (k + 1);
}
int64_t d2d = (vlow[((u * 9) + 0)] - vlow[((v * 9) + 0)]);
int64_t d3d = (vlow[((u * 9) + 1)] - vlow[((v * 9) + 1)]);
int64_t* oldR = (int64_t*)(calloc(7, 8));
int64_t rp = R0[oi];
k = 6;
while (k >= 0) {
oldR[k] = ((rp & 255) - 128);
rp = FLOW_CHECKED_SHR((rp), (8));
k = (k - 1);
}
int64_t* newR = (int64_t*)(calloc(7, 8));
k = 0;
while (k < 7) {
newR[k] = (oldR[k] + Rd[k]);
k = (k + 1);
}
int64_t Rpack = packR_ptr_i64(newR);
int64_t nd2 = (A0[oi] + d2d);
int64_t nd3 = (B0[oi] + d3d);
int64_t combo = ((Rpack ^ ((nd2 + 5000) * 1000003)) ^ ((nd3 + 5000) * 9176));
if (combo < 0) {
combo = (-combo);
}
int64_t h = FLOW_CHECKED_MOD((combo), (HCAP));
int32_t found = 0;
int64_t probes = 0;
while (probes < 20000) {
if (hused[h] == 0) {
hused[h] = 1;
hkey[h] = combo;
hidx[h] = n1;
R1[n1] = Rpack;
A1[n1] = nd2;
B1[n1] = nd3;
C1[n1] = C0[oi];
n1 = (n1 + 1);
found = 1;
break;
}
if ((((hkey[h] == combo && R1[hidx[h]] == Rpack) && A1[hidx[h]] == nd2) && B1[hidx[h]] == nd3)) {
C1[hidx[h]] = (C1[hidx[h]] + C0[oi]);
found = 1;
break;
}
h = (h + 1);
if (h >= HCAP) {
h = 0;
}
probes = (probes + 1);
}
free(Rd);
free(oldR);
free(newR);
x = (x + 1);
}
oi = (oi + 1);
}
free(R0);
free(A0);
free(B0);
free(C0);
R0 = R1;
A0 = A1;
B0 = B1;
C0 = C1;
n0 = n1;
bi = (bi + 1);
}
int64_t SCAP = 200000;
int64_t* S2 = (int64_t*)(calloc(SCAP, 8));
int64_t* S3 = (int64_t*)(calloc(SCAP, 8));
int64_t* SC = (int64_t*)(calloc(SCAP, 8));
int64_t ns = 1;
S2[0] = 0;
S3[0] = 0;
SC[0] = 1;
int64_t rep = 0;
while (rep < 10) {
int64_t* T2 = (int64_t*)(calloc(SCAP, 8));
int64_t* T3 = (int64_t*)(calloc(SCAP, 8));
int64_t* TC = (int64_t*)(calloc(SCAP, 8));
int64_t nt = 0;
hi = 0;
while (hi < HCAP) {
hused[hi] = 0;
hi = (hi + 1);
}
int64_t si = 0;
while (si < ns) {
int64_t sign = (-1);
while (sign <= 1) {
if (sign != 0) {
int64_t nd2 = (S2[si] + sign);
int64_t nd3 = S3[si];
int64_t combo = (((nd2 + 5000) * 10007) + (nd3 + 5000));
if (combo < 0) {
combo = (-combo);
}
int64_t h = FLOW_CHECKED_MOD((combo), (HCAP));
int64_t probes = 0;
while (probes < 20000) {
if (hused[h] == 0) {
hused[h] = 1;
hkey[h] = combo;
hidx[h] = nt;
T2[nt] = nd2;
T3[nt] = nd3;
TC[nt] = SC[si];
nt = (nt + 1);
break;
}
if (((hkey[h] == combo && T2[hidx[h]] == nd2) && T3[hidx[h]] == nd3)) {
TC[hidx[h]] = (TC[hidx[h]] + SC[si]);
break;
}
h = (h + 1);
if (h >= HCAP) {
h = 0;
}
probes = (probes + 1);
}
}
sign = (sign + 2);
}
si = (si + 1);
}
free(S2);
free(S3);
free(SC);
S2 = T2;
S3 = T3;
SC = TC;
ns = nt;
rep = (rep + 1);
}
rep = 0;
while (rep < 4) {
int64_t* T2 = (int64_t*)(calloc(SCAP, 8));
int64_t* T3 = (int64_t*)(calloc(SCAP, 8));
int64_t* TC = (int64_t*)(calloc(SCAP, 8));
int64_t nt = 0;
hi = 0;
while (hi < HCAP) {
hused[hi] = 0;
hi = (hi + 1);
}
int64_t si = 0;
while (si < ns) {
int64_t db = (-1);
while (db <= 1) {
int64_t nd2 = S2[si];
int64_t nd3 = (S3[si] + db);
int64_t combo = (((nd2 + 5000) * 10007) + (nd3 + 5000));
if (combo < 0) {
combo = (-combo);
}
int64_t h = FLOW_CHECKED_MOD((combo), (HCAP));
int64_t probes = 0;
while (probes < 20000) {
if (hused[h] == 0) {
hused[h] = 1;
hkey[h] = combo;
hidx[h] = nt;
T2[nt] = nd2;
T3[nt] = nd3;
TC[nt] = SC[si];
nt = (nt + 1);
break;
}
if (((hkey[h] == combo && T2[hidx[h]] == nd2) && T3[hidx[h]] == nd3)) {
TC[hidx[h]] = (TC[hidx[h]] + SC[si]);
break;
}
h = (h + 1);
if (h >= HCAP) {
h = 0;
}
probes = (probes + 1);
}
db = (db + 1);
}
si = (si + 1);
}
free(S2);
free(S3);
free(SC);
S2 = T2;
S3 = T3;
SC = TC;
ns = nt;
rep = (rep + 1);
}
rep = 0;
while (rep < 2) {
int64_t* deltas = (int64_t*)(calloc(8, 8));
deltas[0] = (-2);
deltas[1] = 0;
deltas[2] = 1;
deltas[3] = (-1);
deltas[4] = (-1);
deltas[5] = 1;
deltas[6] = 2;
deltas[7] = 0;
int64_t* T2 = (int64_t*)(calloc(SCAP, 8));
int64_t* T3 = (int64_t*)(calloc(SCAP, 8));
int64_t* TC = (int64_t*)(calloc(SCAP, 8));
int64_t nt = 0;
hi = 0;
while (hi < HCAP) {
hused[hi] = 0;
hi = (hi + 1);
}
int64_t si = 0;
while (si < ns) {
int64_t di = 0;
while (di < 4) {
int64_t nd2 = (S2[si] + deltas[(2 * di)]);
int64_t nd3 = (S3[si] + deltas[((2 * di) + 1)]);
int64_t combo = (((nd2 + 5000) * 10007) + (nd3 + 5000));
if (combo < 0) {
combo = (-combo);
}
int64_t h = FLOW_CHECKED_MOD((combo), (HCAP));
int64_t probes = 0;
while (probes < 20000) {
if (hused[h] == 0) {
hused[h] = 1;
hkey[h] = combo;
hidx[h] = nt;
T2[nt] = nd2;
T3[nt] = nd3;
TC[nt] = SC[si];
nt = (nt + 1);
break;
}
if (((hkey[h] == combo && T2[hidx[h]] == nd2) && T3[hidx[h]] == nd3)) {
TC[hidx[h]] = (TC[hidx[h]] + SC[si]);
break;
}
h = (h + 1);
if (h >= HCAP) {
h = 0;
}
probes = (probes + 1);
}
di = (di + 1);
}
si = (si + 1);
}
free(deltas);
free(S2);
free(S3);
free(SC);
S2 = T2;
S3 = T3;
SC = TC;
ns = nt;
rep = (rep + 1);
}
int64_t N_all = 0;
int64_t u2 = 1;
while (u2 <= 98) {
int64_t v2 = (99 - u2);
if ((has_big[u2] == 0 && has_big[v2] == 0)) {
int64_t u3 = 1;
while (u3 <= 49) {
int64_t v3 = (50 - u3);
int32_t okh = 1;
int64_t k = 0;
while (k < 6) {
if ((((vhigh[((u2 * 6) + k)] - vhigh[((v2 * 6) + k)]) + vhigh[((u3 * 6) + k)]) - vhigh[((v3 * 6) + k)]) != 0) {
okh = 0;
}
k = (k + 1);
}
if (okh != 0) {
int64_t* targetR = (int64_t*)(calloc(7, 8));
k = 0;
while (k < 7) {
int64_t d = ((vlow[((u2 * 9) + (k + 2))] - vlow[((v2 * 9) + (k + 2))]) + (vlow[((u3 * 9) + (k + 2))] - vlow[((v3 * 9) + (k + 2))]));
targetR[k] = (0 - d);
k = (k + 1);
}
int64_t tpack = packR_ptr_i64(targetR);
int64_t t2 = (0 - ((vlow[((u2 * 9) + 0)] - vlow[((v2 * 9) + 0)]) + (vlow[((u3 * 9) + 0)] - vlow[((v3 * 9) + 0)])));
int64_t t3 = (0 - ((vlow[((u2 * 9) + 1)] - vlow[((v2 * 9) + 1)]) + (vlow[((u3 * 9) + 1)] - vlow[((v3 * 9) + 1)])));
int64_t sub = 0;
int64_t mi = 0;
while (mi < n0) {
if (R0[mi] == tpack) {
int64_t si = 0;
while (si < ns) {
if ((A0[mi] == (t2 - S2[si]) && B0[mi] == (t3 - S3[si]))) {
sub = (sub + (C0[mi] * SC[si]));
}
si = (si + 1);
}
}
mi = (mi + 1);
}
N_all = (N_all + sub);
free(targetR);
}
u3 = (u3 + 1);
}
}
u2 = (u2 + 1);
}
printf("%lld\n", FLOW_CHECKED_DIV((N_all), (2)));
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func @build_spf(%arg0: i64, %arg1: !llvm.ptr) -> () {
%0 = arith.constant 0 : i32
%1 = arith.extsi %0 : i32 to i64
%2 = llvm.mlir.constant(1 : i64) : i64
%3 = llvm.alloca %2 x i64 : (i64) -> !llvm.ptr
llvm.store %1, %3 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%4 = llvm.load %3 : !llvm.ptr -> i64
%5 = arith.cmpi sle, %4, %arg0 : i64
cf.cond_br %5, ^bb1, ^bb2
^bb1:
%6 = llvm.load %3 : !llvm.ptr -> i64
%7 = arith.trunci %6 : i64 to i32
%8 = llvm.load %3 : !llvm.ptr -> i64
%9 = llvm.getelementptr %arg1[%8] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %7, %9 : i32, !llvm.ptr
%10 = llvm.load %3 : !llvm.ptr -> i64
%11 = arith.constant 1 : i32
%13 = arith.extsi %11 : i32 to i64
%12 = arith.addi %10, %13 : i64
llvm.store %12, %3 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
%14 = arith.constant 0 : i32
%15 = arith.constant 0 : i32
%16 = arith.extsi %15 : i32 to i64
%17 = llvm.getelementptr %arg1[%16] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %14, %17 : i32, !llvm.ptr
%18 = arith.constant 1 : i32
%20 = arith.extsi %18 : i32 to i64
%19 = arith.cmpi sge, %arg0, %20 : i64
cf.cond_br %19, ^bb3, ^bb4
^bb3:
%21 = arith.constant 1 : i32
%22 = arith.constant 1 : i32
%23 = arith.extsi %22 : i32 to i64
%24 = llvm.getelementptr %arg1[%23] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %21, %24 : i32, !llvm.ptr
cf.br ^bb5
^bb4:
cf.br ^bb5
^bb5:
%25 = arith.constant 2 : i32
%26 = arith.extsi %25 : i32 to i64
llvm.store %26, %3 : i64, !llvm.ptr
cf.br ^bb6
^bb6:
%27 = llvm.load %3 : !llvm.ptr -> i64
%28 = llvm.load %3 : !llvm.ptr -> i64
%29 = arith.muli %27, %28 : i64
%30 = arith.cmpi sle, %29, %arg0 : i64
cf.cond_br %30, ^bb7, ^bb8
^bb7:
%32 = llvm.load %3 : !llvm.ptr -> i64
%33 = llvm.getelementptr %arg1[%32] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%31 = llvm.load %33 : !llvm.ptr -> i32
%34 = arith.extsi %31 : i32 to i64
%35 = llvm.load %3 : !llvm.ptr -> i64
%36 = arith.cmpi eq, %34, %35 : i64
cf.cond_br %36, ^bb9, ^bb10
^bb9:
%37 = llvm.load %3 : !llvm.ptr -> i64
%38 = llvm.load %3 : !llvm.ptr -> i64
%39 = arith.muli %37, %38 : i64
%40 = llvm.mlir.constant(1 : i64) : i64
%41 = llvm.alloca %40 x i64 : (i64) -> !llvm.ptr
llvm.store %39, %41 : i64, !llvm.ptr
cf.br ^bb12
^bb12:
%42 = llvm.load %41 : !llvm.ptr -> i64
%43 = arith.cmpi sle, %42, %arg0 : i64
cf.cond_br %43, ^bb13, ^bb14
^bb13:
%45 = llvm.load %41 : !llvm.ptr -> i64
%46 = llvm.getelementptr %arg1[%45] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%44 = llvm.load %46 : !llvm.ptr -> i32
%47 = arith.extsi %44 : i32 to i64
%48 = llvm.load %41 : !llvm.ptr -> i64
%49 = arith.cmpi eq, %47, %48 : i64
cf.cond_br %49, ^bb15, ^bb16
^bb15:
%50 = llvm.load %3 : !llvm.ptr -> i64
%51 = arith.trunci %50 : i64 to i32
%52 = llvm.load %41 : !llvm.ptr -> i64
%53 = llvm.getelementptr %arg1[%52] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %51, %53 : i32, !llvm.ptr
cf.br ^bb17
^bb16:
cf.br ^bb17
^bb17:
%54 = llvm.load %41 : !llvm.ptr -> i64
%55 = llvm.load %3 : !llvm.ptr -> i64
%56 = arith.addi %54, %55 : i64
llvm.store %56, %41 : i64, !llvm.ptr
cf.br ^bb12
^bb14:
cf.br ^bb11
^bb10:
cf.br ^bb11
^bb11:
%57 = llvm.load %3 : !llvm.ptr -> i64
%58 = arith.constant 1 : i32
%60 = arith.extsi %58 : i32 to i64
%59 = arith.addi %57, %60 : i64
llvm.store %59, %3 : i64, !llvm.ptr
cf.br ^bb6
^bb8:
func.return
}
func.func @packR(%arg0: !llvm.ptr) -> i64 {
%61 = arith.constant 0 : i32
%62 = arith.extsi %61 : i32 to i64
%63 = llvm.mlir.constant(1 : i64) : i64
%64 = llvm.alloca %63 x i64 : (i64) -> !llvm.ptr
llvm.store %62, %64 : i64, !llvm.ptr
%65 = arith.constant 0 : i32
%66 = arith.extsi %65 : i32 to i64
%67 = llvm.mlir.constant(1 : i64) : i64
%68 = llvm.alloca %67 x i64 : (i64) -> !llvm.ptr
llvm.store %66, %68 : i64, !llvm.ptr
cf.br ^bb18
^bb18:
%69 = llvm.load %68 : !llvm.ptr -> i64
%70 = arith.constant 7 : i32
%72 = arith.extsi %70 : i32 to i64
%71 = arith.cmpi slt, %69, %72 : i64
cf.cond_br %71, ^bb19, ^bb20
^bb19:
%73 = llvm.load %64 : !llvm.ptr -> i64
%74 = arith.constant 8 : i32
%76 = arith.extsi %74 : i32 to i64
%75 = arith.shli %73, %76 : i64
%78 = llvm.load %68 : !llvm.ptr -> i64
%79 = llvm.getelementptr %arg0[%78] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%77 = llvm.load %79 : !llvm.ptr -> i64
%80 = arith.constant 128 : i32
%82 = arith.extsi %80 : i32 to i64
%81 = arith.addi %77, %82 : i64
%83 = arith.addi %75, %81 : i64
llvm.store %83, %64 : i64, !llvm.ptr
%84 = llvm.load %68 : !llvm.ptr -> i64
%85 = arith.constant 1 : i32
%87 = arith.extsi %85 : i32 to i64
%86 = arith.addi %84, %87 : i64
llvm.store %86, %68 : i64, !llvm.ptr
cf.br ^bb18
^bb20:
%88 = llvm.load %64 : !llvm.ptr -> i64
func.return %88 : i64
}
func.func @main() -> i32 {
%90 = arith.constant 100 : i32
%91 = arith.constant 4 : i32
%92 = arith.extsi %90 : i32 to i64
%93 = arith.extsi %91 : i32 to i64
%89 = func.call @calloc(%92, %93) : (i64, i64) -> !llvm.ptr
%95 = arith.constant 99 : i32
%96 = arith.extsi %95 : i32 to i64
func.call @build_spf(%96, %89) : (i64, !llvm.ptr) -> ()
%98 = arith.constant 9 : i32
%99 = arith.constant 8 : i32
%100 = arith.extsi %98 : i32 to i64
%101 = arith.extsi %99 : i32 to i64
%97 = func.call @calloc(%100, %101) : (i64, i64) -> !llvm.ptr
%102 = arith.constant 2 : i32
%103 = arith.constant 0 : i32
%104 = arith.extsi %102 : i32 to i64
%105 = arith.extsi %103 : i32 to i64
%106 = llvm.getelementptr %97[%105] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %104, %106 : i64, !llvm.ptr
%107 = arith.constant 3 : i32
%108 = arith.constant 1 : i32
%109 = arith.extsi %107 : i32 to i64
%110 = arith.extsi %108 : i32 to i64
%111 = llvm.getelementptr %97[%110] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %109, %111 : i64, !llvm.ptr
%112 = arith.constant 5 : i32
%113 = arith.constant 2 : i32
%114 = arith.extsi %112 : i32 to i64
%115 = arith.extsi %113 : i32 to i64
%116 = llvm.getelementptr %97[%115] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %114, %116 : i64, !llvm.ptr
%117 = arith.constant 7 : i32
%118 = arith.constant 3 : i32
%119 = arith.extsi %117 : i32 to i64
%120 = arith.extsi %118 : i32 to i64
%121 = llvm.getelementptr %97[%120] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %119, %121 : i64, !llvm.ptr
%122 = arith.constant 11 : i32
%123 = arith.constant 4 : i32
%124 = arith.extsi %122 : i32 to i64
%125 = arith.extsi %123 : i32 to i64
%126 = llvm.getelementptr %97[%125] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %124, %126 : i64, !llvm.ptr
%127 = arith.constant 13 : i32
%128 = arith.constant 5 : i32
%129 = arith.extsi %127 : i32 to i64
%130 = arith.extsi %128 : i32 to i64
%131 = llvm.getelementptr %97[%130] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %129, %131 : i64, !llvm.ptr
%132 = arith.constant 17 : i32
%133 = arith.constant 6 : i32
%134 = arith.extsi %132 : i32 to i64
%135 = arith.extsi %133 : i32 to i64
%136 = llvm.getelementptr %97[%135] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %134, %136 : i64, !llvm.ptr
%137 = arith.constant 19 : i32
%138 = arith.constant 7 : i32
%139 = arith.extsi %137 : i32 to i64
%140 = arith.extsi %138 : i32 to i64
%141 = llvm.getelementptr %97[%140] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %139, %141 : i64, !llvm.ptr
%142 = arith.constant 23 : i32
%143 = arith.constant 8 : i32
%144 = arith.extsi %142 : i32 to i64
%145 = arith.extsi %143 : i32 to i64
%146 = llvm.getelementptr %97[%145] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %144, %146 : i64, !llvm.ptr
%148 = arith.constant 6 : i32
%149 = arith.constant 8 : i32
%150 = arith.extsi %148 : i32 to i64
%151 = arith.extsi %149 : i32 to i64
%147 = func.call @calloc(%150, %151) : (i64, i64) -> !llvm.ptr
%152 = arith.constant 29 : i32
%153 = arith.constant 0 : i32
%154 = arith.extsi %152 : i32 to i64
%155 = arith.extsi %153 : i32 to i64
%156 = llvm.getelementptr %147[%155] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %154, %156 : i64, !llvm.ptr
%157 = arith.constant 31 : i32
%158 = arith.constant 1 : i32
%159 = arith.extsi %157 : i32 to i64
%160 = arith.extsi %158 : i32 to i64
%161 = llvm.getelementptr %147[%160] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %159, %161 : i64, !llvm.ptr
%162 = arith.constant 37 : i32
%163 = arith.constant 2 : i32
%164 = arith.extsi %162 : i32 to i64
%165 = arith.extsi %163 : i32 to i64
%166 = llvm.getelementptr %147[%165] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %164, %166 : i64, !llvm.ptr
%167 = arith.constant 41 : i32
%168 = arith.constant 3 : i32
%169 = arith.extsi %167 : i32 to i64
%170 = arith.extsi %168 : i32 to i64
%171 = llvm.getelementptr %147[%170] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %169, %171 : i64, !llvm.ptr
%172 = arith.constant 43 : i32
%173 = arith.constant 4 : i32
%174 = arith.extsi %172 : i32 to i64
%175 = arith.extsi %173 : i32 to i64
%176 = llvm.getelementptr %147[%175] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %174, %176 : i64, !llvm.ptr
%177 = arith.constant 47 : i32
%178 = arith.constant 5 : i32
%179 = arith.extsi %177 : i32 to i64
%180 = arith.extsi %178 : i32 to i64
%181 = llvm.getelementptr %147[%180] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %179, %181 : i64, !llvm.ptr
%183 = arith.constant 100 : i32
%184 = arith.constant 9 : i32
%185 = arith.muli %183, %184 : i32
%186 = arith.constant 8 : i32
%187 = arith.extsi %185 : i32 to i64
%188 = arith.extsi %186 : i32 to i64
%182 = func.call @calloc(%187, %188) : (i64, i64) -> !llvm.ptr
%190 = arith.constant 100 : i32
%191 = arith.constant 6 : i32
%192 = arith.muli %190, %191 : i32
%193 = arith.constant 8 : i32
%194 = arith.extsi %192 : i32 to i64
%195 = arith.extsi %193 : i32 to i64
%189 = func.call @calloc(%194, %195) : (i64, i64) -> !llvm.ptr
%197 = arith.constant 100 : i32
%198 = arith.constant 1 : i32
%199 = arith.extsi %197 : i32 to i64
%200 = arith.extsi %198 : i32 to i64
%196 = func.call @calloc(%199, %200) : (i64, i64) -> !llvm.ptr
%201 = arith.constant 2 : i32
%202 = arith.extsi %201 : i32 to i64
%203 = llvm.mlir.constant(1 : i64) : i64
%204 = llvm.alloca %203 x i64 : (i64) -> !llvm.ptr
llvm.store %202, %204 : i64, !llvm.ptr
cf.br ^bb21
^bb21:
%205 = llvm.load %204 : !llvm.ptr -> i64
%206 = arith.constant 99 : i32
%208 = arith.extsi %206 : i32 to i64
%207 = arith.cmpi sle, %205, %208 : i64
cf.cond_br %207, ^bb22, ^bb23
^bb22:
%209 = llvm.load %204 : !llvm.ptr -> i64
%210 = llvm.mlir.constant(1 : i64) : i64
%211 = llvm.alloca %210 x i64 : (i64) -> !llvm.ptr
llvm.store %209, %211 : i64, !llvm.ptr
cf.br ^bb24
^bb24:
%212 = llvm.load %211 : !llvm.ptr -> i64
%213 = arith.constant 1 : i32
%215 = arith.extsi %213 : i32 to i64
%214 = arith.cmpi sgt, %212, %215 : i64
cf.cond_br %214, ^bb25, ^bb26
^bb25:
%217 = llvm.load %211 : !llvm.ptr -> i64
%218 = llvm.getelementptr %89[%217] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%216 = llvm.load %218 : !llvm.ptr -> i32
%219 = arith.extsi %216 : i32 to i64
%220 = arith.constant 0 : i32
%221 = arith.extsi %220 : i32 to i64
%222 = llvm.mlir.constant(1 : i64) : i64
%223 = llvm.alloca %222 x i64 : (i64) -> !llvm.ptr
llvm.store %221, %223 : i64, !llvm.ptr
cf.br ^bb27
^bb27:
%224 = llvm.load %211 : !llvm.ptr -> i64
%225 = arith.remsi %224, %219 : i64
%226 = arith.constant 0 : i32
%228 = arith.extsi %226 : i32 to i64
%227 = arith.cmpi eq, %225, %228 : i64
cf.cond_br %227, ^bb28, ^bb29
^bb28:
%229 = llvm.load %211 : !llvm.ptr -> i64
%230 = arith.divsi %229, %219 : i64
llvm.store %230, %211 : i64, !llvm.ptr
%231 = llvm.load %223 : !llvm.ptr -> i64
%232 = arith.constant 1 : i32
%234 = arith.extsi %232 : i32 to i64
%233 = arith.addi %231, %234 : i64
llvm.store %233, %223 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
%235 = arith.constant 47 : i32
%237 = arith.extsi %235 : i32 to i64
%236 = arith.cmpi sgt, %219, %237 : i64
cf.cond_br %236, ^bb30, ^bb31
^bb30:
%238 = arith.constant 1 : i32
%239 = llvm.load %204 : !llvm.ptr -> i64
%240 = arith.trunci %238 : i32 to i8
%241 = llvm.getelementptr %196[%239] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %240, %241 : i8, !llvm.ptr
cf.br ^bb32
^bb31:
cf.br ^bb32
^bb32:
%242 = arith.constant 0 : i32
%243 = arith.extsi %242 : i32 to i64
%244 = llvm.mlir.constant(1 : i64) : i64
%245 = llvm.alloca %244 x i64 : (i64) -> !llvm.ptr
llvm.store %243, %245 : i64, !llvm.ptr
cf.br ^bb33
^bb33:
%246 = llvm.load %245 : !llvm.ptr -> i64
%247 = arith.constant 9 : i32
%249 = arith.extsi %247 : i32 to i64
%248 = arith.cmpi slt, %246, %249 : i64
cf.cond_br %248, ^bb34, ^bb35
^bb34:
%251 = llvm.load %245 : !llvm.ptr -> i64
%252 = llvm.getelementptr %97[%251] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%250 = llvm.load %252 : !llvm.ptr -> i64
%253 = arith.cmpi eq, %250, %219 : i64
cf.cond_br %253, ^bb36, ^bb37
^bb36:
%254 = llvm.load %223 : !llvm.ptr -> i64
%255 = llvm.load %204 : !llvm.ptr -> i64
%256 = arith.constant 9 : i32
%258 = arith.extsi %256 : i32 to i64
%257 = arith.muli %255, %258 : i64
%259 = llvm.load %245 : !llvm.ptr -> i64
%260 = arith.addi %257, %259 : i64
%261 = llvm.getelementptr %182[%260] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %254, %261 : i64, !llvm.ptr
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
%262 = llvm.load %245 : !llvm.ptr -> i64
%263 = arith.constant 1 : i32
%265 = arith.extsi %263 : i32 to i64
%264 = arith.addi %262, %265 : i64
llvm.store %264, %245 : i64, !llvm.ptr
cf.br ^bb33
^bb35:
%266 = arith.constant 0 : i32
%267 = arith.extsi %266 : i32 to i64
llvm.store %267, %245 : i64, !llvm.ptr
cf.br ^bb39
^bb39:
%268 = llvm.load %245 : !llvm.ptr -> i64
%269 = arith.constant 6 : i32
%271 = arith.extsi %269 : i32 to i64
%270 = arith.cmpi slt, %268, %271 : i64
cf.cond_br %270, ^bb40, ^bb41
^bb40:
%273 = llvm.load %245 : !llvm.ptr -> i64
%274 = llvm.getelementptr %147[%273] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%272 = llvm.load %274 : !llvm.ptr -> i64
%275 = arith.cmpi eq, %272, %219 : i64
cf.cond_br %275, ^bb42, ^bb43
^bb42:
%276 = llvm.load %223 : !llvm.ptr -> i64
%277 = llvm.load %204 : !llvm.ptr -> i64
%278 = arith.constant 6 : i32
%280 = arith.extsi %278 : i32 to i64
%279 = arith.muli %277, %280 : i64
%281 = llvm.load %245 : !llvm.ptr -> i64
%282 = arith.addi %279, %281 : i64
%283 = llvm.getelementptr %189[%282] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %276, %283 : i64, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%284 = llvm.load %245 : !llvm.ptr -> i64
%285 = arith.constant 1 : i32
%287 = arith.extsi %285 : i32 to i64
%286 = arith.addi %284, %287 : i64
llvm.store %286, %245 : i64, !llvm.ptr
cf.br ^bb39
^bb41:
cf.br ^bb24
^bb26:
%288 = llvm.load %204 : !llvm.ptr -> i64
%289 = arith.constant 1 : i32
%291 = arith.extsi %289 : i32 to i64
%290 = arith.addi %288, %291 : i64
llvm.store %290, %204 : i64, !llvm.ptr
cf.br ^bb21
^bb23:
%293 = arith.constant 7 : i32
%294 = arith.constant 8 : i32
%295 = arith.extsi %293 : i32 to i64
%296 = arith.extsi %294 : i32 to i64
%292 = func.call @calloc(%295, %296) : (i64, i64) -> !llvm.ptr
%298 = arith.constant 7 : i32
%299 = arith.constant 8 : i32
%300 = arith.extsi %298 : i32 to i64
%301 = arith.extsi %299 : i32 to i64
%297 = func.call @calloc(%300, %301) : (i64, i64) -> !llvm.ptr
%302 = arith.constant 5 : i32
%303 = arith.constant 0 : i32
%304 = arith.extsi %302 : i32 to i64
%305 = arith.extsi %303 : i32 to i64
%306 = llvm.getelementptr %297[%305] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %304, %306 : i64, !llvm.ptr
%307 = arith.constant 7 : i32
%308 = arith.constant 1 : i32
%309 = arith.extsi %307 : i32 to i64
%310 = arith.extsi %308 : i32 to i64
%311 = llvm.getelementptr %297[%310] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %309, %311 : i64, !llvm.ptr
%312 = arith.constant 11 : i32
%313 = arith.constant 2 : i32
%314 = arith.extsi %312 : i32 to i64
%315 = arith.extsi %313 : i32 to i64
%316 = llvm.getelementptr %297[%315] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %314, %316 : i64, !llvm.ptr
%317 = arith.constant 13 : i32
%318 = arith.constant 3 : i32
%319 = arith.extsi %317 : i32 to i64
%320 = arith.extsi %318 : i32 to i64
%321 = llvm.getelementptr %297[%320] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %319, %321 : i64, !llvm.ptr
%322 = arith.constant 17 : i32
%323 = arith.constant 4 : i32
%324 = arith.extsi %322 : i32 to i64
%325 = arith.extsi %323 : i32 to i64
%326 = llvm.getelementptr %297[%325] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %324, %326 : i64, !llvm.ptr
%327 = arith.constant 19 : i32
%328 = arith.constant 5 : i32
%329 = arith.extsi %327 : i32 to i64
%330 = arith.extsi %328 : i32 to i64
%331 = llvm.getelementptr %297[%330] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %329, %331 : i64, !llvm.ptr
%332 = arith.constant 23 : i32
%333 = arith.constant 6 : i32
%334 = arith.extsi %332 : i32 to i64
%335 = arith.extsi %333 : i32 to i64
%336 = llvm.getelementptr %297[%335] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %334, %336 : i64, !llvm.ptr
%337 = arith.constant 0 : i32
%338 = arith.extsi %337 : i32 to i64
%339 = llvm.mlir.constant(1 : i64) : i64
%340 = llvm.alloca %339 x i64 : (i64) -> !llvm.ptr
llvm.store %338, %340 : i64, !llvm.ptr
cf.br ^bb45
^bb45:
%341 = llvm.load %340 : !llvm.ptr -> i64
%342 = arith.constant 7 : i32
%344 = arith.extsi %342 : i32 to i64
%343 = arith.cmpi slt, %341, %344 : i64
cf.cond_br %343, ^bb46, ^bb47
^bb46:
%346 = llvm.load %340 : !llvm.ptr -> i64
%347 = llvm.getelementptr %297[%346] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%345 = llvm.load %347 : !llvm.ptr -> i64
%348 = arith.constant 0 : i32
%349 = arith.extsi %348 : i32 to i64
%350 = llvm.mlir.constant(1 : i64) : i64
%351 = llvm.alloca %350 x i64 : (i64) -> !llvm.ptr
llvm.store %349, %351 : i64, !llvm.ptr
%352 = arith.constant 100 : i32
%353 = arith.extsi %352 : i32 to i64
%354 = llvm.mlir.constant(1 : i64) : i64
%355 = llvm.alloca %354 x i64 : (i64) -> !llvm.ptr
llvm.store %353, %355 : i64, !llvm.ptr
cf.br ^bb48
^bb48:
%356 = llvm.load %355 : !llvm.ptr -> i64
%357 = arith.constant 0 : i32
%359 = arith.extsi %357 : i32 to i64
%358 = arith.cmpi sgt, %356, %359 : i64
cf.cond_br %358, ^bb49, ^bb50
^bb49:
%360 = llvm.load %355 : !llvm.ptr -> i64
%361 = arith.divsi %360, %345 : i64
llvm.store %361, %355 : i64, !llvm.ptr
%362 = llvm.load %351 : !llvm.ptr -> i64
%363 = llvm.load %355 : !llvm.ptr -> i64
%364 = arith.addi %362, %363 : i64
llvm.store %364, %351 : i64, !llvm.ptr
cf.br ^bb48
^bb50:
%365 = llvm.load %351 : !llvm.ptr -> i64
%366 = llvm.load %340 : !llvm.ptr -> i64
%367 = llvm.getelementptr %292[%366] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %365, %367 : i64, !llvm.ptr
%368 = llvm.load %340 : !llvm.ptr -> i64
%369 = arith.constant 1 : i32
%371 = arith.extsi %369 : i32 to i64
%370 = arith.addi %368, %371 : i64
llvm.store %370, %340 : i64, !llvm.ptr
cf.br ^bb45
^bb47:
%372 = arith.constant 3000000 : i32
%373 = arith.extsi %372 : i32 to i64
%375 = arith.constant 8 : i32
%376 = arith.extsi %375 : i32 to i64
%374 = func.call @calloc(%373, %376) : (i64, i64) -> !llvm.ptr
%377 = llvm.mlir.constant(1 : i64) : i64
%378 = llvm.alloca %377 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %374, %378 : !llvm.ptr, !llvm.ptr
%380 = arith.constant 8 : i32
%381 = arith.extsi %380 : i32 to i64
%379 = func.call @calloc(%373, %381) : (i64, i64) -> !llvm.ptr
%382 = llvm.mlir.constant(1 : i64) : i64
%383 = llvm.alloca %382 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %379, %383 : !llvm.ptr, !llvm.ptr
%385 = arith.constant 8 : i32
%386 = arith.extsi %385 : i32 to i64
%384 = func.call @calloc(%373, %386) : (i64, i64) -> !llvm.ptr
%387 = llvm.mlir.constant(1 : i64) : i64
%388 = llvm.alloca %387 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %384, %388 : !llvm.ptr, !llvm.ptr
%390 = arith.constant 8 : i32
%391 = arith.extsi %390 : i32 to i64
%389 = func.call @calloc(%373, %391) : (i64, i64) -> !llvm.ptr
%392 = llvm.mlir.constant(1 : i64) : i64
%393 = llvm.alloca %392 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %389, %393 : !llvm.ptr, !llvm.ptr
%394 = arith.constant 1 : i32
%395 = arith.extsi %394 : i32 to i64
%396 = llvm.mlir.constant(1 : i64) : i64
%397 = llvm.alloca %396 x i64 : (i64) -> !llvm.ptr
llvm.store %395, %397 : i64, !llvm.ptr
%399 = arith.constant 7 : i32
%400 = arith.constant 8 : i32
%401 = arith.extsi %399 : i32 to i64
%402 = arith.extsi %400 : i32 to i64
%398 = func.call @calloc(%401, %402) : (i64, i64) -> !llvm.ptr
%403 = func.call @packR(%398) : (!llvm.ptr) -> i64
%404 = llvm.load %378 : !llvm.ptr -> !llvm.ptr
%405 = arith.constant 0 : i32
%406 = arith.extsi %405 : i32 to i64
%407 = llvm.getelementptr %404[%406] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %403, %407 : i64, !llvm.ptr
func.call @free(%398) : (!llvm.ptr) -> ()
%409 = arith.constant 0 : i32
%410 = llvm.load %383 : !llvm.ptr -> !llvm.ptr
%411 = arith.constant 0 : i32
%412 = arith.extsi %409 : i32 to i64
%413 = arith.extsi %411 : i32 to i64
%414 = llvm.getelementptr %410[%413] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %412, %414 : i64, !llvm.ptr
%415 = arith.constant 0 : i32
%416 = llvm.load %388 : !llvm.ptr -> !llvm.ptr
%417 = arith.constant 0 : i32
%418 = arith.extsi %415 : i32 to i64
%419 = arith.extsi %417 : i32 to i64
%420 = llvm.getelementptr %416[%419] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %418, %420 : i64, !llvm.ptr
%421 = arith.constant 1 : i32
%422 = llvm.load %393 : !llvm.ptr -> !llvm.ptr
%423 = arith.constant 0 : i32
%424 = arith.extsi %421 : i32 to i64
%425 = arith.extsi %423 : i32 to i64
%426 = llvm.getelementptr %422[%425] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %424, %426 : i64, !llvm.ptr
%427 = arith.constant 400003 : i32
%428 = arith.extsi %427 : i32 to i64
%429 = arith.constant 0 : i32
%430 = arith.extsi %429 : i32 to i64
%431 = llvm.mlir.constant(1 : i64) : i64
%432 = llvm.alloca %431 x i64 : (i64) -> !llvm.ptr
llvm.store %430, %432 : i64, !llvm.ptr
%434 = arith.constant 8 : i32
%435 = arith.extsi %434 : i32 to i64
%433 = func.call @calloc(%428, %435) : (i64, i64) -> !llvm.ptr
%437 = arith.constant 8 : i32
%438 = arith.extsi %437 : i32 to i64
%436 = func.call @calloc(%428, %438) : (i64, i64) -> !llvm.ptr
%440 = arith.constant 1 : i32
%441 = arith.extsi %440 : i32 to i64
%439 = func.call @calloc(%428, %441) : (i64, i64) -> !llvm.ptr
%443 = arith.constant 8 : i32
%444 = arith.extsi %443 : i32 to i64
%442 = func.call @calloc(%428, %444) : (i64, i64) -> !llvm.ptr
%445 = arith.constant 0 : i32
%446 = arith.extsi %445 : i32 to i64
llvm.store %446, %340 : i64, !llvm.ptr
cf.br ^bb51
^bb51:
%447 = llvm.load %340 : !llvm.ptr -> i64
%448 = arith.constant 7 : i32
%450 = arith.extsi %448 : i32 to i64
%449 = arith.cmpi slt, %447, %450 : i64
cf.cond_br %449, ^bb52, ^bb53
^bb52:
%452 = llvm.load %340 : !llvm.ptr -> i64
%453 = llvm.getelementptr %292[%452] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%451 = llvm.load %453 : !llvm.ptr -> i64
%454 = arith.constant 0 : i32
%455 = arith.extsi %454 : i32 to i64
llvm.store %455, %432 : i64, !llvm.ptr
cf.br ^bb54
^bb54:
%456 = llvm.load %432 : !llvm.ptr -> i64
%457 = arith.cmpi slt, %456, %428 : i64
cf.cond_br %457, ^bb55, ^bb56
^bb55:
%458 = arith.constant 0 : i32
%459 = llvm.load %432 : !llvm.ptr -> i64
%460 = arith.trunci %458 : i32 to i8
%461 = llvm.getelementptr %439[%459] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %460, %461 : i8, !llvm.ptr
%462 = llvm.load %432 : !llvm.ptr -> i64
%463 = arith.constant 1 : i32
%465 = arith.extsi %463 : i32 to i64
%464 = arith.addi %462, %465 : i64
llvm.store %464, %432 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
%467 = arith.constant 8 : i32
%468 = arith.extsi %467 : i32 to i64
%466 = func.call @calloc(%373, %468) : (i64, i64) -> !llvm.ptr
%470 = arith.constant 8 : i32
%471 = arith.extsi %470 : i32 to i64
%469 = func.call @calloc(%373, %471) : (i64, i64) -> !llvm.ptr
%473 = arith.constant 8 : i32
%474 = arith.extsi %473 : i32 to i64
%472 = func.call @calloc(%373, %474) : (i64, i64) -> !llvm.ptr
%476 = arith.constant 8 : i32
%477 = arith.extsi %476 : i32 to i64
%475 = func.call @calloc(%373, %477) : (i64, i64) -> !llvm.ptr
%478 = arith.constant 0 : i32
%479 = arith.extsi %478 : i32 to i64
%480 = llvm.mlir.constant(1 : i64) : i64
%481 = llvm.alloca %480 x i64 : (i64) -> !llvm.ptr
llvm.store %479, %481 : i64, !llvm.ptr
%482 = arith.constant 0 : i32
%483 = arith.extsi %482 : i32 to i64
%484 = llvm.mlir.constant(1 : i64) : i64
%485 = llvm.alloca %484 x i64 : (i64) -> !llvm.ptr
llvm.store %483, %485 : i64, !llvm.ptr
cf.br ^bb57
^bb57:
%486 = llvm.load %485 : !llvm.ptr -> i64
%487 = llvm.load %397 : !llvm.ptr -> i64
%488 = arith.cmpi slt, %486, %487 : i64
cf.cond_br %488, ^bb58, ^bb59
^bb58:
%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.cmpi sle, %493, %451 : i64
cf.cond_br %494, ^bb61, ^bb62
^bb61:
%495 = llvm.load %492 : !llvm.ptr -> i64
%496 = arith.constant 1 : i32
%498 = arith.extsi %496 : i32 to i64
%497 = arith.addi %495, %498 : i64
%499 = llvm.load %492 : !llvm.ptr -> i64
%500 = arith.subi %451, %499 : i64
%501 = arith.constant 1 : i32
%503 = arith.extsi %501 : i32 to i64
%502 = arith.addi %500, %503 : i64
%505 = arith.constant 7 : i32
%506 = arith.constant 8 : i32
%507 = arith.extsi %505 : i32 to i64
%508 = arith.extsi %506 : i32 to i64
%504 = func.call @calloc(%507, %508) : (i64, i64) -> !llvm.ptr
%509 = arith.constant 0 : i32
%510 = arith.extsi %509 : i32 to i64
%511 = llvm.mlir.constant(1 : i64) : i64
%512 = llvm.alloca %511 x i64 : (i64) -> !llvm.ptr
llvm.store %510, %512 : i64, !llvm.ptr
cf.br ^bb63
^bb63:
%513 = llvm.load %512 : !llvm.ptr -> i64
%514 = arith.constant 7 : i32
%516 = arith.extsi %514 : i32 to i64
%515 = arith.cmpi slt, %513, %516 : i64
cf.cond_br %515, ^bb64, ^bb65
^bb64:
%518 = arith.constant 9 : i32
%520 = arith.extsi %518 : i32 to i64
%519 = arith.muli %497, %520 : i64
%521 = llvm.load %512 : !llvm.ptr -> i64
%522 = arith.constant 2 : i32
%524 = arith.extsi %522 : i32 to i64
%523 = arith.addi %521, %524 : i64
%525 = arith.addi %519, %523 : i64
%526 = llvm.getelementptr %182[%525] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%517 = llvm.load %526 : !llvm.ptr -> i64
%528 = arith.constant 9 : i32
%530 = arith.extsi %528 : i32 to i64
%529 = arith.muli %502, %530 : i64
%531 = llvm.load %512 : !llvm.ptr -> i64
%532 = arith.constant 2 : i32
%534 = arith.extsi %532 : i32 to i64
%533 = arith.addi %531, %534 : i64
%535 = arith.addi %529, %533 : i64
%536 = llvm.getelementptr %182[%535] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%527 = llvm.load %536 : !llvm.ptr -> i64
%537 = arith.subi %517, %527 : i64
%538 = llvm.load %512 : !llvm.ptr -> i64
%539 = llvm.getelementptr %504[%538] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %537, %539 : i64, !llvm.ptr
%540 = llvm.load %512 : !llvm.ptr -> i64
%541 = arith.constant 1 : i32
%543 = arith.extsi %541 : i32 to i64
%542 = arith.addi %540, %543 : i64
llvm.store %542, %512 : i64, !llvm.ptr
cf.br ^bb63
^bb65:
%545 = arith.constant 9 : i32
%547 = arith.extsi %545 : i32 to i64
%546 = arith.muli %497, %547 : i64
%548 = arith.constant 0 : i32
%550 = arith.extsi %548 : i32 to i64
%549 = arith.addi %546, %550 : i64
%551 = llvm.getelementptr %182[%549] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%544 = llvm.load %551 : !llvm.ptr -> i64
%553 = arith.constant 9 : i32
%555 = arith.extsi %553 : i32 to i64
%554 = arith.muli %502, %555 : i64
%556 = arith.constant 0 : i32
%558 = arith.extsi %556 : i32 to i64
%557 = arith.addi %554, %558 : i64
%559 = llvm.getelementptr %182[%557] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%552 = llvm.load %559 : !llvm.ptr -> i64
%560 = arith.subi %544, %552 : i64
%562 = arith.constant 9 : i32
%564 = arith.extsi %562 : i32 to i64
%563 = arith.muli %497, %564 : i64
%565 = arith.constant 1 : i32
%567 = arith.extsi %565 : i32 to i64
%566 = arith.addi %563, %567 : i64
%568 = llvm.getelementptr %182[%566] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%561 = llvm.load %568 : !llvm.ptr -> i64
%570 = arith.constant 9 : i32
%572 = arith.extsi %570 : i32 to i64
%571 = arith.muli %502, %572 : i64
%573 = arith.constant 1 : i32
%575 = arith.extsi %573 : i32 to i64
%574 = arith.addi %571, %575 : i64
%576 = llvm.getelementptr %182[%574] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%569 = llvm.load %576 : !llvm.ptr -> i64
%577 = arith.subi %561, %569 : i64
%579 = arith.constant 7 : i32
%580 = arith.constant 8 : i32
%581 = arith.extsi %579 : i32 to i64
%582 = arith.extsi %580 : i32 to i64
%578 = func.call @calloc(%581, %582) : (i64, i64) -> !llvm.ptr
%583 = llvm.mlir.constant(1 : i64) : i64
%584 = llvm.alloca %583 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %578, %584 : !llvm.ptr, !llvm.ptr
%586 = llvm.load %378 : !llvm.ptr -> !llvm.ptr
%587 = llvm.load %485 : !llvm.ptr -> i64
%588 = llvm.getelementptr %586[%587] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%585 = llvm.load %588 : !llvm.ptr -> i64
%589 = llvm.mlir.constant(1 : i64) : i64
%590 = llvm.alloca %589 x i64 : (i64) -> !llvm.ptr
llvm.store %585, %590 : i64, !llvm.ptr
%591 = arith.constant 6 : i32
%592 = arith.extsi %591 : i32 to i64
llvm.store %592, %512 : i64, !llvm.ptr
cf.br ^bb66
^bb66:
%593 = llvm.load %512 : !llvm.ptr -> i64
%594 = arith.constant 0 : i32
%596 = arith.extsi %594 : i32 to i64
%595 = arith.cmpi sge, %593, %596 : i64
cf.cond_br %595, ^bb67, ^bb68
^bb67:
%597 = llvm.load %590 : !llvm.ptr -> i64
%598 = arith.constant 255 : i32
%600 = arith.extsi %598 : i32 to i64
%599 = arith.andi %597, %600 : i64
%601 = arith.constant 128 : i32
%603 = arith.extsi %601 : i32 to i64
%602 = arith.subi %599, %603 : i64
%604 = llvm.load %584 : !llvm.ptr -> !llvm.ptr
%605 = llvm.load %512 : !llvm.ptr -> i64
%606 = llvm.getelementptr %604[%605] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %602, %606 : i64, !llvm.ptr
%607 = llvm.load %590 : !llvm.ptr -> i64
%608 = arith.constant 8 : i32
%610 = arith.extsi %608 : i32 to i64
%609 = arith.shrsi %607, %610 : i64
llvm.store %609, %590 : i64, !llvm.ptr
%611 = llvm.load %512 : !llvm.ptr -> i64
%612 = arith.constant 1 : i32
%614 = arith.extsi %612 : i32 to i64
%613 = arith.subi %611, %614 : i64
llvm.store %613, %512 : i64, !llvm.ptr
cf.br ^bb66
^bb68:
%616 = arith.constant 7 : i32
%617 = arith.constant 8 : i32
%618 = arith.extsi %616 : i32 to i64
%619 = arith.extsi %617 : i32 to i64
%615 = func.call @calloc(%618, %619) : (i64, i64) -> !llvm.ptr
%620 = arith.constant 0 : i32
%621 = arith.extsi %620 : i32 to i64
llvm.store %621, %512 : i64, !llvm.ptr
cf.br ^bb69
^bb69:
%622 = llvm.load %512 : !llvm.ptr -> i64
%623 = arith.constant 7 : i32
%625 = arith.extsi %623 : i32 to i64
%624 = arith.cmpi slt, %622, %625 : i64
cf.cond_br %624, ^bb70, ^bb71
^bb70:
%627 = llvm.load %584 : !llvm.ptr -> !llvm.ptr
%628 = llvm.load %512 : !llvm.ptr -> i64
%629 = llvm.getelementptr %627[%628] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%626 = llvm.load %629 : !llvm.ptr -> i64
%631 = llvm.load %512 : !llvm.ptr -> i64
%632 = llvm.getelementptr %504[%631] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%630 = llvm.load %632 : !llvm.ptr -> i64
%633 = arith.addi %626, %630 : i64
%634 = llvm.load %512 : !llvm.ptr -> i64
%635 = llvm.getelementptr %615[%634] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %633, %635 : i64, !llvm.ptr
%636 = llvm.load %512 : !llvm.ptr -> i64
%637 = arith.constant 1 : i32
%639 = arith.extsi %637 : i32 to i64
%638 = arith.addi %636, %639 : i64
llvm.store %638, %512 : i64, !llvm.ptr
cf.br ^bb69
^bb71:
%640 = func.call @packR(%615) : (!llvm.ptr) -> i64
%642 = llvm.load %383 : !llvm.ptr -> !llvm.ptr
%643 = llvm.load %485 : !llvm.ptr -> i64
%644 = llvm.getelementptr %642[%643] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%641 = llvm.load %644 : !llvm.ptr -> i64
%645 = arith.addi %641, %560 : i64
%647 = llvm.load %388 : !llvm.ptr -> !llvm.ptr
%648 = llvm.load %485 : !llvm.ptr -> i64
%649 = llvm.getelementptr %647[%648] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%646 = llvm.load %649 : !llvm.ptr -> i64
%650 = arith.addi %646, %577 : i64
%651 = arith.constant 5000 : i32
%653 = arith.extsi %651 : i32 to i64
%652 = arith.addi %645, %653 : i64
%654 = arith.constant 1000003 : i32
%656 = arith.extsi %654 : i32 to i64
%655 = arith.muli %652, %656 : i64
%657 = arith.xori %640, %655 : i64
%658 = arith.constant 5000 : i32
%660 = arith.extsi %658 : i32 to i64
%659 = arith.addi %650, %660 : i64
%661 = arith.constant 9176 : i32
%663 = arith.extsi %661 : i32 to i64
%662 = arith.muli %659, %663 : i64
%664 = arith.xori %657, %662 : i64
%665 = llvm.mlir.constant(1 : i64) : i64
%666 = llvm.alloca %665 x i64 : (i64) -> !llvm.ptr
llvm.store %664, %666 : i64, !llvm.ptr
%667 = llvm.load %666 : !llvm.ptr -> i64
%668 = arith.constant 0 : i32
%670 = arith.extsi %668 : i32 to i64
%669 = arith.cmpi slt, %667, %670 : i64
cf.cond_br %669, ^bb72, ^bb73
^bb72:
%671 = llvm.load %666 : !llvm.ptr -> i64
%673 = arith.constant 0 : i64
%672 = arith.subi %673, %671 : i64
llvm.store %672, %666 : i64, !llvm.ptr
cf.br ^bb74
^bb73:
cf.br ^bb74
^bb74:
%674 = llvm.load %666 : !llvm.ptr -> i64
%675 = arith.remsi %674, %428 : i64
%676 = llvm.mlir.constant(1 : i64) : i64
%677 = llvm.alloca %676 x i64 : (i64) -> !llvm.ptr
llvm.store %675, %677 : i64, !llvm.ptr
%678 = arith.constant 0 : i32
%679 = llvm.mlir.constant(1 : i64) : i64
%680 = llvm.alloca %679 x i32 : (i64) -> !llvm.ptr
llvm.store %678, %680 : i32, !llvm.ptr
%681 = arith.constant 0 : i32
%682 = arith.extsi %681 : i32 to i64
%683 = llvm.mlir.constant(1 : i64) : i64
%684 = llvm.alloca %683 x i64 : (i64) -> !llvm.ptr
llvm.store %682, %684 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%685 = llvm.load %684 : !llvm.ptr -> i64
%686 = arith.constant 20000 : i32
%688 = arith.extsi %686 : i32 to i64
%687 = arith.cmpi slt, %685, %688 : i64
cf.cond_br %687, ^bb76, ^bb77
^bb76:
%690 = llvm.load %677 : !llvm.ptr -> i64
%691 = llvm.getelementptr %439[%690] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%689 = llvm.load %691 : !llvm.ptr -> i8
%692 = arith.constant 0 : i32
%694 = arith.extsi %689 : i8 to i32
%693 = arith.cmpi eq, %694, %692 : i32
cf.cond_br %693, ^bb78, ^bb79
^bb78:
%695 = arith.constant 1 : i32
%696 = llvm.load %677 : !llvm.ptr -> i64
%697 = arith.trunci %695 : i32 to i8
%698 = llvm.getelementptr %439[%696] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %697, %698 : i8, !llvm.ptr
%699 = llvm.load %666 : !llvm.ptr -> i64
%700 = llvm.load %677 : !llvm.ptr -> i64
%701 = llvm.getelementptr %433[%700] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %699, %701 : i64, !llvm.ptr
%702 = llvm.load %481 : !llvm.ptr -> i64
%703 = llvm.load %677 : !llvm.ptr -> i64
%704 = llvm.getelementptr %442[%703] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %702, %704 : i64, !llvm.ptr
%705 = llvm.load %481 : !llvm.ptr -> i64
%706 = llvm.getelementptr %466[%705] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %640, %706 : i64, !llvm.ptr
%707 = llvm.load %481 : !llvm.ptr -> i64
%708 = llvm.getelementptr %469[%707] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %645, %708 : i64, !llvm.ptr
%709 = llvm.load %481 : !llvm.ptr -> i64
%710 = llvm.getelementptr %472[%709] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %650, %710 : i64, !llvm.ptr
%712 = llvm.load %393 : !llvm.ptr -> !llvm.ptr
%713 = llvm.load %485 : !llvm.ptr -> i64
%714 = llvm.getelementptr %712[%713] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%711 = llvm.load %714 : !llvm.ptr -> i64
%715 = llvm.load %481 : !llvm.ptr -> i64
%716 = llvm.getelementptr %475[%715] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %711, %716 : i64, !llvm.ptr
%717 = llvm.load %481 : !llvm.ptr -> i64
%718 = arith.constant 1 : i32
%720 = arith.extsi %718 : i32 to i64
%719 = arith.addi %717, %720 : i64
llvm.store %719, %481 : i64, !llvm.ptr
%721 = arith.constant 1 : i32
llvm.store %721, %680 : i32, !llvm.ptr
cf.br ^bb77
^bb79:
cf.br ^bb80
^bb80:
%723 = llvm.load %677 : !llvm.ptr -> i64
%724 = llvm.getelementptr %433[%723] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%722 = llvm.load %724 : !llvm.ptr -> i64
%725 = llvm.load %666 : !llvm.ptr -> i64
%726 = arith.cmpi eq, %722, %725 : i64
%727 = scf.if %726 -> (i1) {
%730 = llvm.load %677 : !llvm.ptr -> i64
%731 = llvm.getelementptr %442[%730] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%729 = llvm.load %731 : !llvm.ptr -> i64
%732 = llvm.getelementptr %466[%729] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%728 = llvm.load %732 : !llvm.ptr -> i64
%733 = arith.cmpi eq, %728, %640 : i64
scf.yield %733 : i1
} else {
%734 = arith.constant false
scf.yield %734 : i1
}
%735 = scf.if %727 -> (i1) {
%738 = llvm.load %677 : !llvm.ptr -> i64
%739 = llvm.getelementptr %442[%738] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%737 = llvm.load %739 : !llvm.ptr -> i64
%740 = llvm.getelementptr %469[%737] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%736 = llvm.load %740 : !llvm.ptr -> i64
%741 = arith.cmpi eq, %736, %645 : i64
scf.yield %741 : i1
} else {
%742 = arith.constant false
scf.yield %742 : i1
}
%743 = scf.if %735 -> (i1) {
%746 = llvm.load %677 : !llvm.ptr -> i64
%747 = llvm.getelementptr %442[%746] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%745 = llvm.load %747 : !llvm.ptr -> i64
%748 = llvm.getelementptr %472[%745] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%744 = llvm.load %748 : !llvm.ptr -> i64
%749 = arith.cmpi eq, %744, %650 : i64
scf.yield %749 : i1
} else {
%750 = arith.constant false
scf.yield %750 : i1
}
cf.cond_br %743, ^bb81, ^bb82
^bb81:
%753 = llvm.load %677 : !llvm.ptr -> i64
%754 = llvm.getelementptr %442[%753] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%752 = llvm.load %754 : !llvm.ptr -> i64
%755 = llvm.getelementptr %475[%752] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%751 = llvm.load %755 : !llvm.ptr -> i64
%757 = llvm.load %393 : !llvm.ptr -> !llvm.ptr
%758 = llvm.load %485 : !llvm.ptr -> i64
%759 = llvm.getelementptr %757[%758] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%756 = llvm.load %759 : !llvm.ptr -> i64
%760 = arith.addi %751, %756 : i64
%762 = llvm.load %677 : !llvm.ptr -> i64
%763 = llvm.getelementptr %442[%762] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%761 = llvm.load %763 : !llvm.ptr -> i64
%764 = llvm.getelementptr %475[%761] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %760, %764 : i64, !llvm.ptr
%765 = arith.constant 1 : i32
llvm.store %765, %680 : i32, !llvm.ptr
cf.br ^bb77
^bb82:
cf.br ^bb83
^bb83:
%766 = llvm.load %677 : !llvm.ptr -> i64
%767 = arith.constant 1 : i32
%769 = arith.extsi %767 : i32 to i64
%768 = arith.addi %766, %769 : i64
llvm.store %768, %677 : i64, !llvm.ptr
%770 = llvm.load %677 : !llvm.ptr -> i64
%771 = arith.cmpi sge, %770, %428 : i64
cf.cond_br %771, ^bb84, ^bb85
^bb84:
%772 = arith.constant 0 : i32
%773 = arith.extsi %772 : i32 to i64
llvm.store %773, %677 : i64, !llvm.ptr
cf.br ^bb86
^bb85:
cf.br ^bb86
^bb86:
%774 = llvm.load %684 : !llvm.ptr -> i64
%775 = arith.constant 1 : i32
%777 = arith.extsi %775 : i32 to i64
%776 = arith.addi %774, %777 : i64
llvm.store %776, %684 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
func.call @free(%504) : (!llvm.ptr) -> ()
%780 = llvm.load %584 : !llvm.ptr -> !llvm.ptr
func.call @free(%780) : (!llvm.ptr) -> ()
func.call @free(%615) : (!llvm.ptr) -> ()
%782 = llvm.load %492 : !llvm.ptr -> i64
%783 = arith.constant 1 : i32
%785 = arith.extsi %783 : i32 to i64
%784 = arith.addi %782, %785 : i64
llvm.store %784, %492 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%786 = llvm.load %485 : !llvm.ptr -> i64
%787 = arith.constant 1 : i32
%789 = arith.extsi %787 : i32 to i64
%788 = arith.addi %786, %789 : i64
llvm.store %788, %485 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
%791 = llvm.load %378 : !llvm.ptr -> !llvm.ptr
func.call @free(%791) : (!llvm.ptr) -> ()
%793 = llvm.load %383 : !llvm.ptr -> !llvm.ptr
func.call @free(%793) : (!llvm.ptr) -> ()
%795 = llvm.load %388 : !llvm.ptr -> !llvm.ptr
func.call @free(%795) : (!llvm.ptr) -> ()
%797 = llvm.load %393 : !llvm.ptr -> !llvm.ptr
func.call @free(%797) : (!llvm.ptr) -> ()
llvm.store %466, %378 : !llvm.ptr, !llvm.ptr
llvm.store %469, %383 : !llvm.ptr, !llvm.ptr
llvm.store %472, %388 : !llvm.ptr, !llvm.ptr
llvm.store %475, %393 : !llvm.ptr, !llvm.ptr
%798 = llvm.load %481 : !llvm.ptr -> i64
llvm.store %798, %397 : i64, !llvm.ptr
%799 = llvm.load %340 : !llvm.ptr -> i64
%800 = arith.constant 1 : i32
%802 = arith.extsi %800 : i32 to i64
%801 = arith.addi %799, %802 : i64
llvm.store %801, %340 : i64, !llvm.ptr
cf.br ^bb51
^bb53:
%803 = arith.constant 200000 : i32
%804 = arith.extsi %803 : i32 to i64
%806 = arith.constant 8 : i32
%807 = arith.extsi %806 : i32 to i64
%805 = func.call @calloc(%804, %807) : (i64, i64) -> !llvm.ptr
%808 = llvm.mlir.constant(1 : i64) : i64
%809 = llvm.alloca %808 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %805, %809 : !llvm.ptr, !llvm.ptr
%811 = arith.constant 8 : i32
%812 = arith.extsi %811 : i32 to i64
%810 = func.call @calloc(%804, %812) : (i64, i64) -> !llvm.ptr
%813 = llvm.mlir.constant(1 : i64) : i64
%814 = llvm.alloca %813 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %810, %814 : !llvm.ptr, !llvm.ptr
%816 = arith.constant 8 : i32
%817 = arith.extsi %816 : i32 to i64
%815 = func.call @calloc(%804, %817) : (i64, i64) -> !llvm.ptr
%818 = llvm.mlir.constant(1 : i64) : i64
%819 = llvm.alloca %818 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %815, %819 : !llvm.ptr, !llvm.ptr
%820 = arith.constant 1 : i32
%821 = arith.extsi %820 : i32 to i64
%822 = llvm.mlir.constant(1 : i64) : i64
%823 = llvm.alloca %822 x i64 : (i64) -> !llvm.ptr
llvm.store %821, %823 : i64, !llvm.ptr
%824 = arith.constant 0 : i32
%825 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
%826 = arith.constant 0 : i32
%827 = arith.extsi %824 : i32 to i64
%828 = arith.extsi %826 : i32 to i64
%829 = llvm.getelementptr %825[%828] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %827, %829 : i64, !llvm.ptr
%830 = arith.constant 0 : i32
%831 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
%832 = arith.constant 0 : i32
%833 = arith.extsi %830 : i32 to i64
%834 = arith.extsi %832 : i32 to i64
%835 = llvm.getelementptr %831[%834] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %833, %835 : i64, !llvm.ptr
%836 = arith.constant 1 : i32
%837 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%838 = arith.constant 0 : i32
%839 = arith.extsi %836 : i32 to i64
%840 = arith.extsi %838 : i32 to i64
%841 = llvm.getelementptr %837[%840] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %839, %841 : i64, !llvm.ptr
%842 = arith.constant 0 : i32
%843 = arith.extsi %842 : i32 to i64
%844 = llvm.mlir.constant(1 : i64) : i64
%845 = llvm.alloca %844 x i64 : (i64) -> !llvm.ptr
llvm.store %843, %845 : i64, !llvm.ptr
cf.br ^bb87
^bb87:
%846 = llvm.load %845 : !llvm.ptr -> i64
%847 = arith.constant 10 : i32
%849 = arith.extsi %847 : i32 to i64
%848 = arith.cmpi slt, %846, %849 : i64
cf.cond_br %848, ^bb88, ^bb89
^bb88:
%851 = arith.constant 8 : i32
%852 = arith.extsi %851 : i32 to i64
%850 = func.call @calloc(%804, %852) : (i64, i64) -> !llvm.ptr
%853 = llvm.mlir.constant(1 : i64) : i64
%854 = llvm.alloca %853 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %850, %854 : !llvm.ptr, !llvm.ptr
%856 = arith.constant 8 : i32
%857 = arith.extsi %856 : i32 to i64
%855 = func.call @calloc(%804, %857) : (i64, i64) -> !llvm.ptr
%858 = llvm.mlir.constant(1 : i64) : i64
%859 = llvm.alloca %858 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %855, %859 : !llvm.ptr, !llvm.ptr
%861 = arith.constant 8 : i32
%862 = arith.extsi %861 : i32 to i64
%860 = func.call @calloc(%804, %862) : (i64, i64) -> !llvm.ptr
%863 = llvm.mlir.constant(1 : i64) : i64
%864 = llvm.alloca %863 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %860, %864 : !llvm.ptr, !llvm.ptr
%865 = arith.constant 0 : i32
%866 = arith.extsi %865 : i32 to i64
%867 = llvm.mlir.constant(1 : i64) : i64
%868 = llvm.alloca %867 x i64 : (i64) -> !llvm.ptr
llvm.store %866, %868 : i64, !llvm.ptr
%869 = arith.constant 0 : i32
%870 = arith.extsi %869 : i32 to i64
llvm.store %870, %432 : i64, !llvm.ptr
cf.br ^bb90
^bb90:
%871 = llvm.load %432 : !llvm.ptr -> i64
%872 = arith.cmpi slt, %871, %428 : i64
cf.cond_br %872, ^bb91, ^bb92
^bb91:
%873 = arith.constant 0 : i32
%874 = llvm.load %432 : !llvm.ptr -> i64
%875 = arith.trunci %873 : i32 to i8
%876 = llvm.getelementptr %439[%874] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %875, %876 : i8, !llvm.ptr
%877 = llvm.load %432 : !llvm.ptr -> i64
%878 = arith.constant 1 : i32
%880 = arith.extsi %878 : i32 to i64
%879 = arith.addi %877, %880 : i64
llvm.store %879, %432 : i64, !llvm.ptr
cf.br ^bb90
^bb92:
%881 = arith.constant 0 : i32
%882 = arith.extsi %881 : i32 to i64
%883 = llvm.mlir.constant(1 : i64) : i64
%884 = llvm.alloca %883 x i64 : (i64) -> !llvm.ptr
llvm.store %882, %884 : i64, !llvm.ptr
cf.br ^bb93
^bb93:
%885 = llvm.load %884 : !llvm.ptr -> i64
%886 = llvm.load %823 : !llvm.ptr -> i64
%887 = arith.cmpi slt, %885, %886 : i64
cf.cond_br %887, ^bb94, ^bb95
^bb94:
%888 = arith.constant 1 : i32
%890 = arith.constant 0 : i32
%889 = arith.subi %890, %888 : i32
%891 = arith.extsi %889 : i32 to i64
%892 = llvm.mlir.constant(1 : i64) : i64
%893 = llvm.alloca %892 x i64 : (i64) -> !llvm.ptr
llvm.store %891, %893 : i64, !llvm.ptr
cf.br ^bb96
^bb96:
%894 = llvm.load %893 : !llvm.ptr -> i64
%895 = arith.constant 1 : i32
%897 = arith.extsi %895 : i32 to i64
%896 = arith.cmpi sle, %894, %897 : i64
cf.cond_br %896, ^bb97, ^bb98
^bb97:
%898 = llvm.load %893 : !llvm.ptr -> i64
%899 = arith.constant 0 : i32
%901 = arith.extsi %899 : i32 to i64
%900 = arith.cmpi ne, %898, %901 : i64
cf.cond_br %900, ^bb99, ^bb100
^bb99:
%903 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
%904 = llvm.load %884 : !llvm.ptr -> i64
%905 = llvm.getelementptr %903[%904] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%902 = llvm.load %905 : !llvm.ptr -> i64
%906 = llvm.load %893 : !llvm.ptr -> i64
%907 = arith.addi %902, %906 : i64
%909 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
%910 = llvm.load %884 : !llvm.ptr -> i64
%911 = llvm.getelementptr %909[%910] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%908 = llvm.load %911 : !llvm.ptr -> i64
%912 = arith.constant 5000 : i32
%914 = arith.extsi %912 : i32 to i64
%913 = arith.addi %907, %914 : i64
%915 = arith.constant 10007 : i32
%917 = arith.extsi %915 : i32 to i64
%916 = arith.muli %913, %917 : i64
%918 = arith.constant 5000 : i32
%920 = arith.extsi %918 : i32 to i64
%919 = arith.addi %908, %920 : i64
%921 = arith.addi %916, %919 : i64
%922 = llvm.mlir.constant(1 : i64) : i64
%923 = llvm.alloca %922 x i64 : (i64) -> !llvm.ptr
llvm.store %921, %923 : i64, !llvm.ptr
%924 = llvm.load %923 : !llvm.ptr -> i64
%925 = arith.constant 0 : i32
%927 = arith.extsi %925 : i32 to i64
%926 = arith.cmpi slt, %924, %927 : i64
cf.cond_br %926, ^bb102, ^bb103
^bb102:
%928 = llvm.load %923 : !llvm.ptr -> i64
%930 = arith.constant 0 : i64
%929 = arith.subi %930, %928 : i64
llvm.store %929, %923 : i64, !llvm.ptr
cf.br ^bb104
^bb103:
cf.br ^bb104
^bb104:
%931 = llvm.load %923 : !llvm.ptr -> i64
%932 = arith.remsi %931, %428 : i64
%933 = llvm.mlir.constant(1 : i64) : i64
%934 = llvm.alloca %933 x i64 : (i64) -> !llvm.ptr
llvm.store %932, %934 : i64, !llvm.ptr
%935 = arith.constant 0 : i32
%936 = arith.extsi %935 : i32 to i64
%937 = llvm.mlir.constant(1 : i64) : i64
%938 = llvm.alloca %937 x i64 : (i64) -> !llvm.ptr
llvm.store %936, %938 : i64, !llvm.ptr
cf.br ^bb105
^bb105:
%939 = llvm.load %938 : !llvm.ptr -> i64
%940 = arith.constant 20000 : i32
%942 = arith.extsi %940 : i32 to i64
%941 = arith.cmpi slt, %939, %942 : i64
cf.cond_br %941, ^bb106, ^bb107
^bb106:
%944 = llvm.load %934 : !llvm.ptr -> i64
%945 = llvm.getelementptr %439[%944] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%943 = llvm.load %945 : !llvm.ptr -> i8
%946 = arith.constant 0 : i32
%948 = arith.extsi %943 : i8 to i32
%947 = arith.cmpi eq, %948, %946 : i32
cf.cond_br %947, ^bb108, ^bb109
^bb108:
%949 = arith.constant 1 : i32
%950 = llvm.load %934 : !llvm.ptr -> i64
%951 = arith.trunci %949 : i32 to i8
%952 = llvm.getelementptr %439[%950] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %951, %952 : i8, !llvm.ptr
%953 = llvm.load %923 : !llvm.ptr -> i64
%954 = llvm.load %934 : !llvm.ptr -> i64
%955 = llvm.getelementptr %433[%954] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %953, %955 : i64, !llvm.ptr
%956 = llvm.load %868 : !llvm.ptr -> i64
%957 = llvm.load %934 : !llvm.ptr -> i64
%958 = llvm.getelementptr %442[%957] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %956, %958 : i64, !llvm.ptr
%959 = llvm.load %854 : !llvm.ptr -> !llvm.ptr
%960 = llvm.load %868 : !llvm.ptr -> i64
%961 = llvm.getelementptr %959[%960] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %907, %961 : i64, !llvm.ptr
%962 = llvm.load %859 : !llvm.ptr -> !llvm.ptr
%963 = llvm.load %868 : !llvm.ptr -> i64
%964 = llvm.getelementptr %962[%963] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %908, %964 : i64, !llvm.ptr
%966 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%967 = llvm.load %884 : !llvm.ptr -> i64
%968 = llvm.getelementptr %966[%967] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%965 = llvm.load %968 : !llvm.ptr -> i64
%969 = llvm.load %864 : !llvm.ptr -> !llvm.ptr
%970 = llvm.load %868 : !llvm.ptr -> i64
%971 = llvm.getelementptr %969[%970] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %965, %971 : i64, !llvm.ptr
%972 = llvm.load %868 : !llvm.ptr -> i64
%973 = arith.constant 1 : i32
%975 = arith.extsi %973 : i32 to i64
%974 = arith.addi %972, %975 : i64
llvm.store %974, %868 : i64, !llvm.ptr
cf.br ^bb107
^bb109:
cf.br ^bb110
^bb110:
%977 = llvm.load %934 : !llvm.ptr -> i64
%978 = llvm.getelementptr %433[%977] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%976 = llvm.load %978 : !llvm.ptr -> i64
%979 = llvm.load %923 : !llvm.ptr -> i64
%980 = arith.cmpi eq, %976, %979 : i64
%981 = scf.if %980 -> (i1) {
%983 = llvm.load %854 : !llvm.ptr -> !llvm.ptr
%985 = llvm.load %934 : !llvm.ptr -> i64
%986 = llvm.getelementptr %442[%985] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%984 = llvm.load %986 : !llvm.ptr -> i64
%987 = llvm.getelementptr %983[%984] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%982 = llvm.load %987 : !llvm.ptr -> i64
%988 = arith.cmpi eq, %982, %907 : i64
scf.yield %988 : i1
} else {
%989 = arith.constant false
scf.yield %989 : i1
}
%990 = scf.if %981 -> (i1) {
%992 = llvm.load %859 : !llvm.ptr -> !llvm.ptr
%994 = llvm.load %934 : !llvm.ptr -> i64
%995 = llvm.getelementptr %442[%994] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%993 = llvm.load %995 : !llvm.ptr -> i64
%996 = llvm.getelementptr %992[%993] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%991 = llvm.load %996 : !llvm.ptr -> i64
%997 = arith.cmpi eq, %991, %908 : i64
scf.yield %997 : i1
} else {
%998 = arith.constant false
scf.yield %998 : i1
}
cf.cond_br %990, ^bb111, ^bb112
^bb111:
%1000 = llvm.load %864 : !llvm.ptr -> !llvm.ptr
%1002 = llvm.load %934 : !llvm.ptr -> i64
%1003 = llvm.getelementptr %442[%1002] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1001 = llvm.load %1003 : !llvm.ptr -> i64
%1004 = llvm.getelementptr %1000[%1001] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%999 = llvm.load %1004 : !llvm.ptr -> i64
%1006 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1007 = llvm.load %884 : !llvm.ptr -> i64
%1008 = llvm.getelementptr %1006[%1007] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1005 = llvm.load %1008 : !llvm.ptr -> i64
%1009 = arith.addi %999, %1005 : i64
%1010 = llvm.load %864 : !llvm.ptr -> !llvm.ptr
%1012 = llvm.load %934 : !llvm.ptr -> i64
%1013 = llvm.getelementptr %442[%1012] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1011 = llvm.load %1013 : !llvm.ptr -> i64
%1014 = llvm.getelementptr %1010[%1011] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1009, %1014 : i64, !llvm.ptr
cf.br ^bb107
^bb112:
cf.br ^bb113
^bb113:
%1015 = llvm.load %934 : !llvm.ptr -> i64
%1016 = arith.constant 1 : i32
%1018 = arith.extsi %1016 : i32 to i64
%1017 = arith.addi %1015, %1018 : i64
llvm.store %1017, %934 : i64, !llvm.ptr
%1019 = llvm.load %934 : !llvm.ptr -> i64
%1020 = arith.cmpi sge, %1019, %428 : i64
cf.cond_br %1020, ^bb114, ^bb115
^bb114:
%1021 = arith.constant 0 : i32
%1022 = arith.extsi %1021 : i32 to i64
llvm.store %1022, %934 : i64, !llvm.ptr
cf.br ^bb116
^bb115:
cf.br ^bb116
^bb116:
%1023 = llvm.load %938 : !llvm.ptr -> i64
%1024 = arith.constant 1 : i32
%1026 = arith.extsi %1024 : i32 to i64
%1025 = arith.addi %1023, %1026 : i64
llvm.store %1025, %938 : i64, !llvm.ptr
cf.br ^bb105
^bb107:
cf.br ^bb101
^bb100:
cf.br ^bb101
^bb101:
%1027 = llvm.load %893 : !llvm.ptr -> i64
%1028 = arith.constant 2 : i32
%1030 = arith.extsi %1028 : i32 to i64
%1029 = arith.addi %1027, %1030 : i64
llvm.store %1029, %893 : i64, !llvm.ptr
cf.br ^bb96
^bb98:
%1031 = llvm.load %884 : !llvm.ptr -> i64
%1032 = arith.constant 1 : i32
%1034 = arith.extsi %1032 : i32 to i64
%1033 = arith.addi %1031, %1034 : i64
llvm.store %1033, %884 : i64, !llvm.ptr
cf.br ^bb93
^bb95:
%1036 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
func.call @free(%1036) : (!llvm.ptr) -> ()
%1038 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
func.call @free(%1038) : (!llvm.ptr) -> ()
%1040 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
func.call @free(%1040) : (!llvm.ptr) -> ()
%1041 = llvm.load %854 : !llvm.ptr -> !llvm.ptr
llvm.store %1041, %809 : !llvm.ptr, !llvm.ptr
%1042 = llvm.load %859 : !llvm.ptr -> !llvm.ptr
llvm.store %1042, %814 : !llvm.ptr, !llvm.ptr
%1043 = llvm.load %864 : !llvm.ptr -> !llvm.ptr
llvm.store %1043, %819 : !llvm.ptr, !llvm.ptr
%1044 = llvm.load %868 : !llvm.ptr -> i64
llvm.store %1044, %823 : i64, !llvm.ptr
%1045 = llvm.load %845 : !llvm.ptr -> i64
%1046 = arith.constant 1 : i32
%1048 = arith.extsi %1046 : i32 to i64
%1047 = arith.addi %1045, %1048 : i64
llvm.store %1047, %845 : i64, !llvm.ptr
cf.br ^bb87
^bb89:
%1049 = arith.constant 0 : i32
%1050 = arith.extsi %1049 : i32 to i64
llvm.store %1050, %845 : i64, !llvm.ptr
cf.br ^bb117
^bb117:
%1051 = llvm.load %845 : !llvm.ptr -> i64
%1052 = arith.constant 4 : i32
%1054 = arith.extsi %1052 : i32 to i64
%1053 = arith.cmpi slt, %1051, %1054 : i64
cf.cond_br %1053, ^bb118, ^bb119
^bb118:
%1056 = arith.constant 8 : i32
%1057 = arith.extsi %1056 : i32 to i64
%1055 = func.call @calloc(%804, %1057) : (i64, i64) -> !llvm.ptr
%1058 = llvm.mlir.constant(1 : i64) : i64
%1059 = llvm.alloca %1058 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1055, %1059 : !llvm.ptr, !llvm.ptr
%1061 = arith.constant 8 : i32
%1062 = arith.extsi %1061 : i32 to i64
%1060 = func.call @calloc(%804, %1062) : (i64, i64) -> !llvm.ptr
%1063 = llvm.mlir.constant(1 : i64) : i64
%1064 = llvm.alloca %1063 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1060, %1064 : !llvm.ptr, !llvm.ptr
%1066 = arith.constant 8 : i32
%1067 = arith.extsi %1066 : i32 to i64
%1065 = func.call @calloc(%804, %1067) : (i64, i64) -> !llvm.ptr
%1068 = llvm.mlir.constant(1 : i64) : i64
%1069 = llvm.alloca %1068 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1065, %1069 : !llvm.ptr, !llvm.ptr
%1070 = arith.constant 0 : i32
%1071 = arith.extsi %1070 : i32 to i64
%1072 = llvm.mlir.constant(1 : i64) : i64
%1073 = llvm.alloca %1072 x i64 : (i64) -> !llvm.ptr
llvm.store %1071, %1073 : i64, !llvm.ptr
%1074 = arith.constant 0 : i32
%1075 = arith.extsi %1074 : i32 to i64
llvm.store %1075, %432 : i64, !llvm.ptr
cf.br ^bb120
^bb120:
%1076 = llvm.load %432 : !llvm.ptr -> i64
%1077 = arith.cmpi slt, %1076, %428 : i64
cf.cond_br %1077, ^bb121, ^bb122
^bb121:
%1078 = arith.constant 0 : i32
%1079 = llvm.load %432 : !llvm.ptr -> i64
%1080 = arith.trunci %1078 : i32 to i8
%1081 = llvm.getelementptr %439[%1079] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %1080, %1081 : i8, !llvm.ptr
%1082 = llvm.load %432 : !llvm.ptr -> i64
%1083 = arith.constant 1 : i32
%1085 = arith.extsi %1083 : i32 to i64
%1084 = arith.addi %1082, %1085 : i64
llvm.store %1084, %432 : i64, !llvm.ptr
cf.br ^bb120
^bb122:
%1086 = arith.constant 0 : i32
%1087 = arith.extsi %1086 : i32 to i64
%1088 = llvm.mlir.constant(1 : i64) : i64
%1089 = llvm.alloca %1088 x i64 : (i64) -> !llvm.ptr
llvm.store %1087, %1089 : i64, !llvm.ptr
cf.br ^bb123
^bb123:
%1090 = llvm.load %1089 : !llvm.ptr -> i64
%1091 = llvm.load %823 : !llvm.ptr -> i64
%1092 = arith.cmpi slt, %1090, %1091 : i64
cf.cond_br %1092, ^bb124, ^bb125
^bb124:
%1093 = arith.constant 1 : i32
%1095 = arith.constant 0 : i32
%1094 = arith.subi %1095, %1093 : i32
%1096 = arith.extsi %1094 : i32 to i64
%1097 = llvm.mlir.constant(1 : i64) : i64
%1098 = llvm.alloca %1097 x i64 : (i64) -> !llvm.ptr
llvm.store %1096, %1098 : i64, !llvm.ptr
cf.br ^bb126
^bb126:
%1099 = llvm.load %1098 : !llvm.ptr -> i64
%1100 = arith.constant 1 : i32
%1102 = arith.extsi %1100 : i32 to i64
%1101 = arith.cmpi sle, %1099, %1102 : i64
cf.cond_br %1101, ^bb127, ^bb128
^bb127:
%1104 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
%1105 = llvm.load %1089 : !llvm.ptr -> i64
%1106 = llvm.getelementptr %1104[%1105] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1103 = llvm.load %1106 : !llvm.ptr -> i64
%1108 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
%1109 = llvm.load %1089 : !llvm.ptr -> i64
%1110 = llvm.getelementptr %1108[%1109] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1107 = llvm.load %1110 : !llvm.ptr -> i64
%1111 = llvm.load %1098 : !llvm.ptr -> i64
%1112 = arith.addi %1107, %1111 : i64
%1113 = arith.constant 5000 : i32
%1115 = arith.extsi %1113 : i32 to i64
%1114 = arith.addi %1103, %1115 : i64
%1116 = arith.constant 10007 : i32
%1118 = arith.extsi %1116 : i32 to i64
%1117 = arith.muli %1114, %1118 : i64
%1119 = arith.constant 5000 : i32
%1121 = arith.extsi %1119 : i32 to i64
%1120 = arith.addi %1112, %1121 : i64
%1122 = arith.addi %1117, %1120 : i64
%1123 = llvm.mlir.constant(1 : i64) : i64
%1124 = llvm.alloca %1123 x i64 : (i64) -> !llvm.ptr
llvm.store %1122, %1124 : i64, !llvm.ptr
%1125 = llvm.load %1124 : !llvm.ptr -> i64
%1126 = arith.constant 0 : i32
%1128 = arith.extsi %1126 : i32 to i64
%1127 = arith.cmpi slt, %1125, %1128 : i64
cf.cond_br %1127, ^bb129, ^bb130
^bb129:
%1129 = llvm.load %1124 : !llvm.ptr -> i64
%1131 = arith.constant 0 : i64
%1130 = arith.subi %1131, %1129 : i64
llvm.store %1130, %1124 : i64, !llvm.ptr
cf.br ^bb131
^bb130:
cf.br ^bb131
^bb131:
%1132 = llvm.load %1124 : !llvm.ptr -> i64
%1133 = arith.remsi %1132, %428 : i64
%1134 = llvm.mlir.constant(1 : i64) : i64
%1135 = llvm.alloca %1134 x i64 : (i64) -> !llvm.ptr
llvm.store %1133, %1135 : i64, !llvm.ptr
%1136 = arith.constant 0 : i32
%1137 = arith.extsi %1136 : i32 to i64
%1138 = llvm.mlir.constant(1 : i64) : i64
%1139 = llvm.alloca %1138 x i64 : (i64) -> !llvm.ptr
llvm.store %1137, %1139 : i64, !llvm.ptr
cf.br ^bb132
^bb132:
%1140 = llvm.load %1139 : !llvm.ptr -> i64
%1141 = arith.constant 20000 : i32
%1143 = arith.extsi %1141 : i32 to i64
%1142 = arith.cmpi slt, %1140, %1143 : i64
cf.cond_br %1142, ^bb133, ^bb134
^bb133:
%1145 = llvm.load %1135 : !llvm.ptr -> i64
%1146 = llvm.getelementptr %439[%1145] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%1144 = llvm.load %1146 : !llvm.ptr -> i8
%1147 = arith.constant 0 : i32
%1149 = arith.extsi %1144 : i8 to i32
%1148 = arith.cmpi eq, %1149, %1147 : i32
cf.cond_br %1148, ^bb135, ^bb136
^bb135:
%1150 = arith.constant 1 : i32
%1151 = llvm.load %1135 : !llvm.ptr -> i64
%1152 = arith.trunci %1150 : i32 to i8
%1153 = llvm.getelementptr %439[%1151] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %1152, %1153 : i8, !llvm.ptr
%1154 = llvm.load %1124 : !llvm.ptr -> i64
%1155 = llvm.load %1135 : !llvm.ptr -> i64
%1156 = llvm.getelementptr %433[%1155] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1154, %1156 : i64, !llvm.ptr
%1157 = llvm.load %1073 : !llvm.ptr -> i64
%1158 = llvm.load %1135 : !llvm.ptr -> i64
%1159 = llvm.getelementptr %442[%1158] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1157, %1159 : i64, !llvm.ptr
%1160 = llvm.load %1059 : !llvm.ptr -> !llvm.ptr
%1161 = llvm.load %1073 : !llvm.ptr -> i64
%1162 = llvm.getelementptr %1160[%1161] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1103, %1162 : i64, !llvm.ptr
%1163 = llvm.load %1064 : !llvm.ptr -> !llvm.ptr
%1164 = llvm.load %1073 : !llvm.ptr -> i64
%1165 = llvm.getelementptr %1163[%1164] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1112, %1165 : i64, !llvm.ptr
%1167 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1168 = llvm.load %1089 : !llvm.ptr -> i64
%1169 = llvm.getelementptr %1167[%1168] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1166 = llvm.load %1169 : !llvm.ptr -> i64
%1170 = llvm.load %1069 : !llvm.ptr -> !llvm.ptr
%1171 = llvm.load %1073 : !llvm.ptr -> i64
%1172 = llvm.getelementptr %1170[%1171] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1166, %1172 : i64, !llvm.ptr
%1173 = llvm.load %1073 : !llvm.ptr -> i64
%1174 = arith.constant 1 : i32
%1176 = arith.extsi %1174 : i32 to i64
%1175 = arith.addi %1173, %1176 : i64
llvm.store %1175, %1073 : i64, !llvm.ptr
cf.br ^bb134
^bb136:
cf.br ^bb137
^bb137:
%1178 = llvm.load %1135 : !llvm.ptr -> i64
%1179 = llvm.getelementptr %433[%1178] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1177 = llvm.load %1179 : !llvm.ptr -> i64
%1180 = llvm.load %1124 : !llvm.ptr -> i64
%1181 = arith.cmpi eq, %1177, %1180 : i64
%1182 = scf.if %1181 -> (i1) {
%1184 = llvm.load %1059 : !llvm.ptr -> !llvm.ptr
%1186 = llvm.load %1135 : !llvm.ptr -> i64
%1187 = llvm.getelementptr %442[%1186] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1185 = llvm.load %1187 : !llvm.ptr -> i64
%1188 = llvm.getelementptr %1184[%1185] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1183 = llvm.load %1188 : !llvm.ptr -> i64
%1189 = arith.cmpi eq, %1183, %1103 : i64
scf.yield %1189 : i1
} else {
%1190 = arith.constant false
scf.yield %1190 : i1
}
%1191 = scf.if %1182 -> (i1) {
%1193 = llvm.load %1064 : !llvm.ptr -> !llvm.ptr
%1195 = llvm.load %1135 : !llvm.ptr -> i64
%1196 = llvm.getelementptr %442[%1195] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1194 = llvm.load %1196 : !llvm.ptr -> i64
%1197 = llvm.getelementptr %1193[%1194] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1192 = llvm.load %1197 : !llvm.ptr -> i64
%1198 = arith.cmpi eq, %1192, %1112 : i64
scf.yield %1198 : i1
} else {
%1199 = arith.constant false
scf.yield %1199 : i1
}
cf.cond_br %1191, ^bb138, ^bb139
^bb138:
%1201 = llvm.load %1069 : !llvm.ptr -> !llvm.ptr
%1203 = llvm.load %1135 : !llvm.ptr -> i64
%1204 = llvm.getelementptr %442[%1203] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1202 = llvm.load %1204 : !llvm.ptr -> i64
%1205 = llvm.getelementptr %1201[%1202] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1200 = llvm.load %1205 : !llvm.ptr -> i64
%1207 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1208 = llvm.load %1089 : !llvm.ptr -> i64
%1209 = llvm.getelementptr %1207[%1208] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1206 = llvm.load %1209 : !llvm.ptr -> i64
%1210 = arith.addi %1200, %1206 : i64
%1211 = llvm.load %1069 : !llvm.ptr -> !llvm.ptr
%1213 = llvm.load %1135 : !llvm.ptr -> i64
%1214 = llvm.getelementptr %442[%1213] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1212 = llvm.load %1214 : !llvm.ptr -> i64
%1215 = llvm.getelementptr %1211[%1212] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1210, %1215 : i64, !llvm.ptr
cf.br ^bb134
^bb139:
cf.br ^bb140
^bb140:
%1216 = llvm.load %1135 : !llvm.ptr -> i64
%1217 = arith.constant 1 : i32
%1219 = arith.extsi %1217 : i32 to i64
%1218 = arith.addi %1216, %1219 : i64
llvm.store %1218, %1135 : i64, !llvm.ptr
%1220 = llvm.load %1135 : !llvm.ptr -> i64
%1221 = arith.cmpi sge, %1220, %428 : i64
cf.cond_br %1221, ^bb141, ^bb142
^bb141:
%1222 = arith.constant 0 : i32
%1223 = arith.extsi %1222 : i32 to i64
llvm.store %1223, %1135 : i64, !llvm.ptr
cf.br ^bb143
^bb142:
cf.br ^bb143
^bb143:
%1224 = llvm.load %1139 : !llvm.ptr -> i64
%1225 = arith.constant 1 : i32
%1227 = arith.extsi %1225 : i32 to i64
%1226 = arith.addi %1224, %1227 : i64
llvm.store %1226, %1139 : i64, !llvm.ptr
cf.br ^bb132
^bb134:
%1228 = llvm.load %1098 : !llvm.ptr -> i64
%1229 = arith.constant 1 : i32
%1231 = arith.extsi %1229 : i32 to i64
%1230 = arith.addi %1228, %1231 : i64
llvm.store %1230, %1098 : i64, !llvm.ptr
cf.br ^bb126
^bb128:
%1232 = llvm.load %1089 : !llvm.ptr -> i64
%1233 = arith.constant 1 : i32
%1235 = arith.extsi %1233 : i32 to i64
%1234 = arith.addi %1232, %1235 : i64
llvm.store %1234, %1089 : i64, !llvm.ptr
cf.br ^bb123
^bb125:
%1237 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
func.call @free(%1237) : (!llvm.ptr) -> ()
%1239 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
func.call @free(%1239) : (!llvm.ptr) -> ()
%1241 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
func.call @free(%1241) : (!llvm.ptr) -> ()
%1242 = llvm.load %1059 : !llvm.ptr -> !llvm.ptr
llvm.store %1242, %809 : !llvm.ptr, !llvm.ptr
%1243 = llvm.load %1064 : !llvm.ptr -> !llvm.ptr
llvm.store %1243, %814 : !llvm.ptr, !llvm.ptr
%1244 = llvm.load %1069 : !llvm.ptr -> !llvm.ptr
llvm.store %1244, %819 : !llvm.ptr, !llvm.ptr
%1245 = llvm.load %1073 : !llvm.ptr -> i64
llvm.store %1245, %823 : i64, !llvm.ptr
%1246 = llvm.load %845 : !llvm.ptr -> i64
%1247 = arith.constant 1 : i32
%1249 = arith.extsi %1247 : i32 to i64
%1248 = arith.addi %1246, %1249 : i64
llvm.store %1248, %845 : i64, !llvm.ptr
cf.br ^bb117
^bb119:
%1250 = arith.constant 0 : i32
%1251 = arith.extsi %1250 : i32 to i64
llvm.store %1251, %845 : i64, !llvm.ptr
cf.br ^bb144
^bb144:
%1252 = llvm.load %845 : !llvm.ptr -> i64
%1253 = arith.constant 2 : i32
%1255 = arith.extsi %1253 : i32 to i64
%1254 = arith.cmpi slt, %1252, %1255 : i64
cf.cond_br %1254, ^bb145, ^bb146
^bb145:
%1257 = arith.constant 8 : i32
%1258 = arith.constant 8 : i32
%1259 = arith.extsi %1257 : i32 to i64
%1260 = arith.extsi %1258 : i32 to i64
%1256 = func.call @calloc(%1259, %1260) : (i64, i64) -> !llvm.ptr
%1261 = arith.constant 2 : i32
%1263 = arith.constant 0 : i32
%1262 = arith.subi %1263, %1261 : i32
%1264 = arith.constant 0 : i32
%1265 = arith.extsi %1262 : i32 to i64
%1266 = arith.extsi %1264 : i32 to i64
%1267 = llvm.getelementptr %1256[%1266] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1265, %1267 : i64, !llvm.ptr
%1268 = arith.constant 0 : i32
%1269 = arith.constant 1 : i32
%1270 = arith.extsi %1268 : i32 to i64
%1271 = arith.extsi %1269 : i32 to i64
%1272 = llvm.getelementptr %1256[%1271] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1270, %1272 : i64, !llvm.ptr
%1273 = arith.constant 1 : i32
%1274 = arith.constant 2 : i32
%1275 = arith.extsi %1273 : i32 to i64
%1276 = arith.extsi %1274 : i32 to i64
%1277 = llvm.getelementptr %1256[%1276] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1275, %1277 : i64, !llvm.ptr
%1278 = arith.constant 1 : i32
%1280 = arith.constant 0 : i32
%1279 = arith.subi %1280, %1278 : i32
%1281 = arith.constant 3 : i32
%1282 = arith.extsi %1279 : i32 to i64
%1283 = arith.extsi %1281 : i32 to i64
%1284 = llvm.getelementptr %1256[%1283] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1282, %1284 : i64, !llvm.ptr
%1285 = arith.constant 1 : i32
%1287 = arith.constant 0 : i32
%1286 = arith.subi %1287, %1285 : i32
%1288 = arith.constant 4 : i32
%1289 = arith.extsi %1286 : i32 to i64
%1290 = arith.extsi %1288 : i32 to i64
%1291 = llvm.getelementptr %1256[%1290] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1289, %1291 : i64, !llvm.ptr
%1292 = arith.constant 1 : i32
%1293 = arith.constant 5 : i32
%1294 = arith.extsi %1292 : i32 to i64
%1295 = arith.extsi %1293 : i32 to i64
%1296 = llvm.getelementptr %1256[%1295] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1294, %1296 : i64, !llvm.ptr
%1297 = arith.constant 2 : i32
%1298 = arith.constant 6 : i32
%1299 = arith.extsi %1297 : i32 to i64
%1300 = arith.extsi %1298 : i32 to i64
%1301 = llvm.getelementptr %1256[%1300] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1299, %1301 : i64, !llvm.ptr
%1302 = arith.constant 0 : i32
%1303 = arith.constant 7 : i32
%1304 = arith.extsi %1302 : i32 to i64
%1305 = arith.extsi %1303 : i32 to i64
%1306 = llvm.getelementptr %1256[%1305] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1304, %1306 : i64, !llvm.ptr
%1308 = arith.constant 8 : i32
%1309 = arith.extsi %1308 : i32 to i64
%1307 = func.call @calloc(%804, %1309) : (i64, i64) -> !llvm.ptr
%1310 = llvm.mlir.constant(1 : i64) : i64
%1311 = llvm.alloca %1310 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1307, %1311 : !llvm.ptr, !llvm.ptr
%1313 = arith.constant 8 : i32
%1314 = arith.extsi %1313 : i32 to i64
%1312 = func.call @calloc(%804, %1314) : (i64, i64) -> !llvm.ptr
%1315 = llvm.mlir.constant(1 : i64) : i64
%1316 = llvm.alloca %1315 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1312, %1316 : !llvm.ptr, !llvm.ptr
%1318 = arith.constant 8 : i32
%1319 = arith.extsi %1318 : i32 to i64
%1317 = func.call @calloc(%804, %1319) : (i64, i64) -> !llvm.ptr
%1320 = llvm.mlir.constant(1 : i64) : i64
%1321 = llvm.alloca %1320 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1317, %1321 : !llvm.ptr, !llvm.ptr
%1322 = arith.constant 0 : i32
%1323 = arith.extsi %1322 : i32 to i64
%1324 = llvm.mlir.constant(1 : i64) : i64
%1325 = llvm.alloca %1324 x i64 : (i64) -> !llvm.ptr
llvm.store %1323, %1325 : i64, !llvm.ptr
%1326 = arith.constant 0 : i32
%1327 = arith.extsi %1326 : i32 to i64
llvm.store %1327, %432 : i64, !llvm.ptr
cf.br ^bb147
^bb147:
%1328 = llvm.load %432 : !llvm.ptr -> i64
%1329 = arith.cmpi slt, %1328, %428 : i64
cf.cond_br %1329, ^bb148, ^bb149
^bb148:
%1330 = arith.constant 0 : i32
%1331 = llvm.load %432 : !llvm.ptr -> i64
%1332 = arith.trunci %1330 : i32 to i8
%1333 = llvm.getelementptr %439[%1331] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %1332, %1333 : i8, !llvm.ptr
%1334 = llvm.load %432 : !llvm.ptr -> i64
%1335 = arith.constant 1 : i32
%1337 = arith.extsi %1335 : i32 to i64
%1336 = arith.addi %1334, %1337 : i64
llvm.store %1336, %432 : i64, !llvm.ptr
cf.br ^bb147
^bb149:
%1338 = arith.constant 0 : i32
%1339 = arith.extsi %1338 : i32 to i64
%1340 = llvm.mlir.constant(1 : i64) : i64
%1341 = llvm.alloca %1340 x i64 : (i64) -> !llvm.ptr
llvm.store %1339, %1341 : i64, !llvm.ptr
cf.br ^bb150
^bb150:
%1342 = llvm.load %1341 : !llvm.ptr -> i64
%1343 = llvm.load %823 : !llvm.ptr -> i64
%1344 = arith.cmpi slt, %1342, %1343 : i64
cf.cond_br %1344, ^bb151, ^bb152
^bb151:
%1345 = arith.constant 0 : i32
%1346 = arith.extsi %1345 : i32 to i64
%1347 = llvm.mlir.constant(1 : i64) : i64
%1348 = llvm.alloca %1347 x i64 : (i64) -> !llvm.ptr
llvm.store %1346, %1348 : i64, !llvm.ptr
cf.br ^bb153
^bb153:
%1349 = llvm.load %1348 : !llvm.ptr -> i64
%1350 = arith.constant 4 : i32
%1352 = arith.extsi %1350 : i32 to i64
%1351 = arith.cmpi slt, %1349, %1352 : i64
cf.cond_br %1351, ^bb154, ^bb155
^bb154:
%1354 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
%1355 = llvm.load %1341 : !llvm.ptr -> i64
%1356 = llvm.getelementptr %1354[%1355] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1353 = llvm.load %1356 : !llvm.ptr -> i64
%1358 = arith.constant 2 : i32
%1359 = llvm.load %1348 : !llvm.ptr -> i64
%1361 = arith.extsi %1358 : i32 to i64
%1360 = arith.muli %1361, %1359 : i64
%1362 = llvm.getelementptr %1256[%1360] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1357 = llvm.load %1362 : !llvm.ptr -> i64
%1363 = arith.addi %1353, %1357 : i64
%1365 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
%1366 = llvm.load %1341 : !llvm.ptr -> i64
%1367 = llvm.getelementptr %1365[%1366] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1364 = llvm.load %1367 : !llvm.ptr -> i64
%1369 = arith.constant 2 : i32
%1370 = llvm.load %1348 : !llvm.ptr -> i64
%1372 = arith.extsi %1369 : i32 to i64
%1371 = arith.muli %1372, %1370 : i64
%1373 = arith.constant 1 : i32
%1375 = arith.extsi %1373 : i32 to i64
%1374 = arith.addi %1371, %1375 : i64
%1376 = llvm.getelementptr %1256[%1374] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1368 = llvm.load %1376 : !llvm.ptr -> i64
%1377 = arith.addi %1364, %1368 : i64
%1378 = arith.constant 5000 : i32
%1380 = arith.extsi %1378 : i32 to i64
%1379 = arith.addi %1363, %1380 : i64
%1381 = arith.constant 10007 : i32
%1383 = arith.extsi %1381 : i32 to i64
%1382 = arith.muli %1379, %1383 : i64
%1384 = arith.constant 5000 : i32
%1386 = arith.extsi %1384 : i32 to i64
%1385 = arith.addi %1377, %1386 : i64
%1387 = arith.addi %1382, %1385 : i64
%1388 = llvm.mlir.constant(1 : i64) : i64
%1389 = llvm.alloca %1388 x i64 : (i64) -> !llvm.ptr
llvm.store %1387, %1389 : i64, !llvm.ptr
%1390 = llvm.load %1389 : !llvm.ptr -> i64
%1391 = arith.constant 0 : i32
%1393 = arith.extsi %1391 : i32 to i64
%1392 = arith.cmpi slt, %1390, %1393 : i64
cf.cond_br %1392, ^bb156, ^bb157
^bb156:
%1394 = llvm.load %1389 : !llvm.ptr -> i64
%1396 = arith.constant 0 : i64
%1395 = arith.subi %1396, %1394 : i64
llvm.store %1395, %1389 : i64, !llvm.ptr
cf.br ^bb158
^bb157:
cf.br ^bb158
^bb158:
%1397 = llvm.load %1389 : !llvm.ptr -> i64
%1398 = arith.remsi %1397, %428 : i64
%1399 = llvm.mlir.constant(1 : i64) : i64
%1400 = llvm.alloca %1399 x i64 : (i64) -> !llvm.ptr
llvm.store %1398, %1400 : i64, !llvm.ptr
%1401 = arith.constant 0 : i32
%1402 = arith.extsi %1401 : i32 to i64
%1403 = llvm.mlir.constant(1 : i64) : i64
%1404 = llvm.alloca %1403 x i64 : (i64) -> !llvm.ptr
llvm.store %1402, %1404 : i64, !llvm.ptr
cf.br ^bb159
^bb159:
%1405 = llvm.load %1404 : !llvm.ptr -> i64
%1406 = arith.constant 20000 : i32
%1408 = arith.extsi %1406 : i32 to i64
%1407 = arith.cmpi slt, %1405, %1408 : i64
cf.cond_br %1407, ^bb160, ^bb161
^bb160:
%1410 = llvm.load %1400 : !llvm.ptr -> i64
%1411 = llvm.getelementptr %439[%1410] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%1409 = llvm.load %1411 : !llvm.ptr -> i8
%1412 = arith.constant 0 : i32
%1414 = arith.extsi %1409 : i8 to i32
%1413 = arith.cmpi eq, %1414, %1412 : i32
cf.cond_br %1413, ^bb162, ^bb163
^bb162:
%1415 = arith.constant 1 : i32
%1416 = llvm.load %1400 : !llvm.ptr -> i64
%1417 = arith.trunci %1415 : i32 to i8
%1418 = llvm.getelementptr %439[%1416] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %1417, %1418 : i8, !llvm.ptr
%1419 = llvm.load %1389 : !llvm.ptr -> i64
%1420 = llvm.load %1400 : !llvm.ptr -> i64
%1421 = llvm.getelementptr %433[%1420] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1419, %1421 : i64, !llvm.ptr
%1422 = llvm.load %1325 : !llvm.ptr -> i64
%1423 = llvm.load %1400 : !llvm.ptr -> i64
%1424 = llvm.getelementptr %442[%1423] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1422, %1424 : i64, !llvm.ptr
%1425 = llvm.load %1311 : !llvm.ptr -> !llvm.ptr
%1426 = llvm.load %1325 : !llvm.ptr -> i64
%1427 = llvm.getelementptr %1425[%1426] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1363, %1427 : i64, !llvm.ptr
%1428 = llvm.load %1316 : !llvm.ptr -> !llvm.ptr
%1429 = llvm.load %1325 : !llvm.ptr -> i64
%1430 = llvm.getelementptr %1428[%1429] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1377, %1430 : i64, !llvm.ptr
%1432 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1433 = llvm.load %1341 : !llvm.ptr -> i64
%1434 = llvm.getelementptr %1432[%1433] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1431 = llvm.load %1434 : !llvm.ptr -> i64
%1435 = llvm.load %1321 : !llvm.ptr -> !llvm.ptr
%1436 = llvm.load %1325 : !llvm.ptr -> i64
%1437 = llvm.getelementptr %1435[%1436] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1431, %1437 : i64, !llvm.ptr
%1438 = llvm.load %1325 : !llvm.ptr -> i64
%1439 = arith.constant 1 : i32
%1441 = arith.extsi %1439 : i32 to i64
%1440 = arith.addi %1438, %1441 : i64
llvm.store %1440, %1325 : i64, !llvm.ptr
cf.br ^bb161
^bb163:
cf.br ^bb164
^bb164:
%1443 = llvm.load %1400 : !llvm.ptr -> i64
%1444 = llvm.getelementptr %433[%1443] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1442 = llvm.load %1444 : !llvm.ptr -> i64
%1445 = llvm.load %1389 : !llvm.ptr -> i64
%1446 = arith.cmpi eq, %1442, %1445 : i64
%1447 = scf.if %1446 -> (i1) {
%1449 = llvm.load %1311 : !llvm.ptr -> !llvm.ptr
%1451 = llvm.load %1400 : !llvm.ptr -> i64
%1452 = llvm.getelementptr %442[%1451] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1450 = llvm.load %1452 : !llvm.ptr -> i64
%1453 = llvm.getelementptr %1449[%1450] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1448 = llvm.load %1453 : !llvm.ptr -> i64
%1454 = arith.cmpi eq, %1448, %1363 : i64
scf.yield %1454 : i1
} else {
%1455 = arith.constant false
scf.yield %1455 : i1
}
%1456 = scf.if %1447 -> (i1) {
%1458 = llvm.load %1316 : !llvm.ptr -> !llvm.ptr
%1460 = llvm.load %1400 : !llvm.ptr -> i64
%1461 = llvm.getelementptr %442[%1460] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1459 = llvm.load %1461 : !llvm.ptr -> i64
%1462 = llvm.getelementptr %1458[%1459] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1457 = llvm.load %1462 : !llvm.ptr -> i64
%1463 = arith.cmpi eq, %1457, %1377 : i64
scf.yield %1463 : i1
} else {
%1464 = arith.constant false
scf.yield %1464 : i1
}
cf.cond_br %1456, ^bb165, ^bb166
^bb165:
%1466 = llvm.load %1321 : !llvm.ptr -> !llvm.ptr
%1468 = llvm.load %1400 : !llvm.ptr -> i64
%1469 = llvm.getelementptr %442[%1468] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1467 = llvm.load %1469 : !llvm.ptr -> i64
%1470 = llvm.getelementptr %1466[%1467] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1465 = llvm.load %1470 : !llvm.ptr -> i64
%1472 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1473 = llvm.load %1341 : !llvm.ptr -> i64
%1474 = llvm.getelementptr %1472[%1473] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1471 = llvm.load %1474 : !llvm.ptr -> i64
%1475 = arith.addi %1465, %1471 : i64
%1476 = llvm.load %1321 : !llvm.ptr -> !llvm.ptr
%1478 = llvm.load %1400 : !llvm.ptr -> i64
%1479 = llvm.getelementptr %442[%1478] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1477 = llvm.load %1479 : !llvm.ptr -> i64
%1480 = llvm.getelementptr %1476[%1477] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1475, %1480 : i64, !llvm.ptr
cf.br ^bb161
^bb166:
cf.br ^bb167
^bb167:
%1481 = llvm.load %1400 : !llvm.ptr -> i64
%1482 = arith.constant 1 : i32
%1484 = arith.extsi %1482 : i32 to i64
%1483 = arith.addi %1481, %1484 : i64
llvm.store %1483, %1400 : i64, !llvm.ptr
%1485 = llvm.load %1400 : !llvm.ptr -> i64
%1486 = arith.cmpi sge, %1485, %428 : i64
cf.cond_br %1486, ^bb168, ^bb169
^bb168:
%1487 = arith.constant 0 : i32
%1488 = arith.extsi %1487 : i32 to i64
llvm.store %1488, %1400 : i64, !llvm.ptr
cf.br ^bb170
^bb169:
cf.br ^bb170
^bb170:
%1489 = llvm.load %1404 : !llvm.ptr -> i64
%1490 = arith.constant 1 : i32
%1492 = arith.extsi %1490 : i32 to i64
%1491 = arith.addi %1489, %1492 : i64
llvm.store %1491, %1404 : i64, !llvm.ptr
cf.br ^bb159
^bb161:
%1493 = llvm.load %1348 : !llvm.ptr -> i64
%1494 = arith.constant 1 : i32
%1496 = arith.extsi %1494 : i32 to i64
%1495 = arith.addi %1493, %1496 : i64
llvm.store %1495, %1348 : i64, !llvm.ptr
cf.br ^bb153
^bb155:
%1497 = llvm.load %1341 : !llvm.ptr -> i64
%1498 = arith.constant 1 : i32
%1500 = arith.extsi %1498 : i32 to i64
%1499 = arith.addi %1497, %1500 : i64
llvm.store %1499, %1341 : i64, !llvm.ptr
cf.br ^bb150
^bb152:
func.call @free(%1256) : (!llvm.ptr) -> ()
%1503 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
func.call @free(%1503) : (!llvm.ptr) -> ()
%1505 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
func.call @free(%1505) : (!llvm.ptr) -> ()
%1507 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
func.call @free(%1507) : (!llvm.ptr) -> ()
%1508 = llvm.load %1311 : !llvm.ptr -> !llvm.ptr
llvm.store %1508, %809 : !llvm.ptr, !llvm.ptr
%1509 = llvm.load %1316 : !llvm.ptr -> !llvm.ptr
llvm.store %1509, %814 : !llvm.ptr, !llvm.ptr
%1510 = llvm.load %1321 : !llvm.ptr -> !llvm.ptr
llvm.store %1510, %819 : !llvm.ptr, !llvm.ptr
%1511 = llvm.load %1325 : !llvm.ptr -> i64
llvm.store %1511, %823 : i64, !llvm.ptr
%1512 = llvm.load %845 : !llvm.ptr -> i64
%1513 = arith.constant 1 : i32
%1515 = arith.extsi %1513 : i32 to i64
%1514 = arith.addi %1512, %1515 : i64
llvm.store %1514, %845 : i64, !llvm.ptr
cf.br ^bb144
^bb146:
%1516 = arith.constant 0 : i32
%1517 = arith.extsi %1516 : i32 to i64
%1518 = llvm.mlir.constant(1 : i64) : i64
%1519 = llvm.alloca %1518 x i64 : (i64) -> !llvm.ptr
llvm.store %1517, %1519 : i64, !llvm.ptr
%1520 = arith.constant 1 : i32
%1521 = arith.extsi %1520 : i32 to i64
%1522 = llvm.mlir.constant(1 : i64) : i64
%1523 = llvm.alloca %1522 x i64 : (i64) -> !llvm.ptr
llvm.store %1521, %1523 : i64, !llvm.ptr
cf.br ^bb171
^bb171:
%1524 = llvm.load %1523 : !llvm.ptr -> i64
%1525 = arith.constant 98 : i32
%1527 = arith.extsi %1525 : i32 to i64
%1526 = arith.cmpi sle, %1524, %1527 : i64
cf.cond_br %1526, ^bb172, ^bb173
^bb172:
%1528 = arith.constant 99 : i32
%1529 = llvm.load %1523 : !llvm.ptr -> i64
%1531 = arith.extsi %1528 : i32 to i64
%1530 = arith.subi %1531, %1529 : i64
%1533 = llvm.load %1523 : !llvm.ptr -> i64
%1534 = llvm.getelementptr %196[%1533] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%1532 = llvm.load %1534 : !llvm.ptr -> i8
%1535 = arith.constant 0 : i32
%1537 = arith.extsi %1532 : i8 to i32
%1536 = arith.cmpi eq, %1537, %1535 : i32
%1538 = scf.if %1536 -> (i1) {
%1540 = llvm.getelementptr %196[%1530] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%1539 = llvm.load %1540 : !llvm.ptr -> i8
%1541 = arith.constant 0 : i32
%1543 = arith.extsi %1539 : i8 to i32
%1542 = arith.cmpi eq, %1543, %1541 : i32
scf.yield %1542 : i1
} else {
%1544 = arith.constant false
scf.yield %1544 : i1
}
cf.cond_br %1538, ^bb174, ^bb175
^bb174:
%1545 = arith.constant 1 : i32
%1546 = arith.extsi %1545 : i32 to i64
%1547 = llvm.mlir.constant(1 : i64) : i64
%1548 = llvm.alloca %1547 x i64 : (i64) -> !llvm.ptr
llvm.store %1546, %1548 : i64, !llvm.ptr
cf.br ^bb177
^bb177:
%1549 = llvm.load %1548 : !llvm.ptr -> i64
%1550 = arith.constant 49 : i32
%1552 = arith.extsi %1550 : i32 to i64
%1551 = arith.cmpi sle, %1549, %1552 : i64
cf.cond_br %1551, ^bb178, ^bb179
^bb178:
%1553 = arith.constant 50 : i32
%1554 = llvm.load %1548 : !llvm.ptr -> i64
%1556 = arith.extsi %1553 : i32 to i64
%1555 = arith.subi %1556, %1554 : i64
%1557 = arith.constant 1 : i32
%1558 = llvm.mlir.constant(1 : i64) : i64
%1559 = llvm.alloca %1558 x i32 : (i64) -> !llvm.ptr
llvm.store %1557, %1559 : i32, !llvm.ptr
%1560 = arith.constant 0 : i32
%1561 = arith.extsi %1560 : i32 to i64
%1562 = llvm.mlir.constant(1 : i64) : i64
%1563 = llvm.alloca %1562 x i64 : (i64) -> !llvm.ptr
llvm.store %1561, %1563 : i64, !llvm.ptr
cf.br ^bb180
^bb180:
%1564 = llvm.load %1563 : !llvm.ptr -> i64
%1565 = arith.constant 6 : i32
%1567 = arith.extsi %1565 : i32 to i64
%1566 = arith.cmpi slt, %1564, %1567 : i64
cf.cond_br %1566, ^bb181, ^bb182
^bb181:
%1569 = llvm.load %1523 : !llvm.ptr -> i64
%1570 = arith.constant 6 : i32
%1572 = arith.extsi %1570 : i32 to i64
%1571 = arith.muli %1569, %1572 : i64
%1573 = llvm.load %1563 : !llvm.ptr -> i64
%1574 = arith.addi %1571, %1573 : i64
%1575 = llvm.getelementptr %189[%1574] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1568 = llvm.load %1575 : !llvm.ptr -> i64
%1577 = arith.constant 6 : i32
%1579 = arith.extsi %1577 : i32 to i64
%1578 = arith.muli %1530, %1579 : i64
%1580 = llvm.load %1563 : !llvm.ptr -> i64
%1581 = arith.addi %1578, %1580 : i64
%1582 = llvm.getelementptr %189[%1581] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1576 = llvm.load %1582 : !llvm.ptr -> i64
%1583 = arith.subi %1568, %1576 : i64
%1585 = llvm.load %1548 : !llvm.ptr -> i64
%1586 = arith.constant 6 : i32
%1588 = arith.extsi %1586 : i32 to i64
%1587 = arith.muli %1585, %1588 : i64
%1589 = llvm.load %1563 : !llvm.ptr -> i64
%1590 = arith.addi %1587, %1589 : i64
%1591 = llvm.getelementptr %189[%1590] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1584 = llvm.load %1591 : !llvm.ptr -> i64
%1592 = arith.addi %1583, %1584 : i64
%1594 = arith.constant 6 : i32
%1596 = arith.extsi %1594 : i32 to i64
%1595 = arith.muli %1555, %1596 : i64
%1597 = llvm.load %1563 : !llvm.ptr -> i64
%1598 = arith.addi %1595, %1597 : i64
%1599 = llvm.getelementptr %189[%1598] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1593 = llvm.load %1599 : !llvm.ptr -> i64
%1600 = arith.subi %1592, %1593 : i64
%1601 = arith.constant 0 : i32
%1603 = arith.extsi %1601 : i32 to i64
%1602 = arith.cmpi ne, %1600, %1603 : i64
cf.cond_br %1602, ^bb183, ^bb184
^bb183:
%1604 = arith.constant 0 : i32
llvm.store %1604, %1559 : i32, !llvm.ptr
cf.br ^bb185
^bb184:
cf.br ^bb185
^bb185:
%1605 = llvm.load %1563 : !llvm.ptr -> i64
%1606 = arith.constant 1 : i32
%1608 = arith.extsi %1606 : i32 to i64
%1607 = arith.addi %1605, %1608 : i64
llvm.store %1607, %1563 : i64, !llvm.ptr
cf.br ^bb180
^bb182:
%1609 = llvm.load %1559 : !llvm.ptr -> i32
%1610 = arith.constant 0 : i32
%1611 = arith.cmpi ne, %1609, %1610 : i32
cf.cond_br %1611, ^bb186, ^bb187
^bb186:
%1613 = arith.constant 7 : i32
%1614 = arith.constant 8 : i32
%1615 = arith.extsi %1613 : i32 to i64
%1616 = arith.extsi %1614 : i32 to i64
%1612 = func.call @calloc(%1615, %1616) : (i64, i64) -> !llvm.ptr
%1617 = arith.constant 0 : i32
%1618 = arith.extsi %1617 : i32 to i64
llvm.store %1618, %1563 : i64, !llvm.ptr
cf.br ^bb189
^bb189:
%1619 = llvm.load %1563 : !llvm.ptr -> i64
%1620 = arith.constant 7 : i32
%1622 = arith.extsi %1620 : i32 to i64
%1621 = arith.cmpi slt, %1619, %1622 : i64
cf.cond_br %1621, ^bb190, ^bb191
^bb190:
%1624 = llvm.load %1523 : !llvm.ptr -> i64
%1625 = arith.constant 9 : i32
%1627 = arith.extsi %1625 : i32 to i64
%1626 = arith.muli %1624, %1627 : i64
%1628 = llvm.load %1563 : !llvm.ptr -> i64
%1629 = arith.constant 2 : i32
%1631 = arith.extsi %1629 : i32 to i64
%1630 = arith.addi %1628, %1631 : i64
%1632 = arith.addi %1626, %1630 : i64
%1633 = llvm.getelementptr %182[%1632] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1623 = llvm.load %1633 : !llvm.ptr -> i64
%1635 = arith.constant 9 : i32
%1637 = arith.extsi %1635 : i32 to i64
%1636 = arith.muli %1530, %1637 : i64
%1638 = llvm.load %1563 : !llvm.ptr -> i64
%1639 = arith.constant 2 : i32
%1641 = arith.extsi %1639 : i32 to i64
%1640 = arith.addi %1638, %1641 : i64
%1642 = arith.addi %1636, %1640 : i64
%1643 = llvm.getelementptr %182[%1642] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1634 = llvm.load %1643 : !llvm.ptr -> i64
%1644 = arith.subi %1623, %1634 : i64
%1646 = llvm.load %1548 : !llvm.ptr -> i64
%1647 = arith.constant 9 : i32
%1649 = arith.extsi %1647 : i32 to i64
%1648 = arith.muli %1646, %1649 : i64
%1650 = llvm.load %1563 : !llvm.ptr -> i64
%1651 = arith.constant 2 : i32
%1653 = arith.extsi %1651 : i32 to i64
%1652 = arith.addi %1650, %1653 : i64
%1654 = arith.addi %1648, %1652 : i64
%1655 = llvm.getelementptr %182[%1654] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1645 = llvm.load %1655 : !llvm.ptr -> i64
%1657 = arith.constant 9 : i32
%1659 = arith.extsi %1657 : i32 to i64
%1658 = arith.muli %1555, %1659 : i64
%1660 = llvm.load %1563 : !llvm.ptr -> i64
%1661 = arith.constant 2 : i32
%1663 = arith.extsi %1661 : i32 to i64
%1662 = arith.addi %1660, %1663 : i64
%1664 = arith.addi %1658, %1662 : i64
%1665 = llvm.getelementptr %182[%1664] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1656 = llvm.load %1665 : !llvm.ptr -> i64
%1666 = arith.subi %1645, %1656 : i64
%1667 = arith.addi %1644, %1666 : i64
%1668 = arith.constant 0 : i32
%1670 = arith.extsi %1668 : i32 to i64
%1669 = arith.subi %1670, %1667 : i64
%1671 = llvm.load %1563 : !llvm.ptr -> i64
%1672 = llvm.getelementptr %1612[%1671] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1669, %1672 : i64, !llvm.ptr
%1673 = llvm.load %1563 : !llvm.ptr -> i64
%1674 = arith.constant 1 : i32
%1676 = arith.extsi %1674 : i32 to i64
%1675 = arith.addi %1673, %1676 : i64
llvm.store %1675, %1563 : i64, !llvm.ptr
cf.br ^bb189
^bb191:
%1677 = func.call @packR(%1612) : (!llvm.ptr) -> i64
%1678 = arith.constant 0 : i32
%1680 = llvm.load %1523 : !llvm.ptr -> i64
%1681 = arith.constant 9 : i32
%1683 = arith.extsi %1681 : i32 to i64
%1682 = arith.muli %1680, %1683 : i64
%1684 = arith.constant 0 : i32
%1686 = arith.extsi %1684 : i32 to i64
%1685 = arith.addi %1682, %1686 : i64
%1687 = llvm.getelementptr %182[%1685] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1679 = llvm.load %1687 : !llvm.ptr -> i64
%1689 = arith.constant 9 : i32
%1691 = arith.extsi %1689 : i32 to i64
%1690 = arith.muli %1530, %1691 : i64
%1692 = arith.constant 0 : i32
%1694 = arith.extsi %1692 : i32 to i64
%1693 = arith.addi %1690, %1694 : i64
%1695 = llvm.getelementptr %182[%1693] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1688 = llvm.load %1695 : !llvm.ptr -> i64
%1696 = arith.subi %1679, %1688 : i64
%1698 = llvm.load %1548 : !llvm.ptr -> i64
%1699 = arith.constant 9 : i32
%1701 = arith.extsi %1699 : i32 to i64
%1700 = arith.muli %1698, %1701 : i64
%1702 = arith.constant 0 : i32
%1704 = arith.extsi %1702 : i32 to i64
%1703 = arith.addi %1700, %1704 : i64
%1705 = llvm.getelementptr %182[%1703] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1697 = llvm.load %1705 : !llvm.ptr -> i64
%1707 = arith.constant 9 : i32
%1709 = arith.extsi %1707 : i32 to i64
%1708 = arith.muli %1555, %1709 : i64
%1710 = arith.constant 0 : i32
%1712 = arith.extsi %1710 : i32 to i64
%1711 = arith.addi %1708, %1712 : i64
%1713 = llvm.getelementptr %182[%1711] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1706 = llvm.load %1713 : !llvm.ptr -> i64
%1714 = arith.subi %1697, %1706 : i64
%1715 = arith.addi %1696, %1714 : i64
%1717 = arith.extsi %1678 : i32 to i64
%1716 = arith.subi %1717, %1715 : i64
%1718 = arith.constant 0 : i32
%1720 = llvm.load %1523 : !llvm.ptr -> i64
%1721 = arith.constant 9 : i32
%1723 = arith.extsi %1721 : i32 to i64
%1722 = arith.muli %1720, %1723 : i64
%1724 = arith.constant 1 : i32
%1726 = arith.extsi %1724 : i32 to i64
%1725 = arith.addi %1722, %1726 : i64
%1727 = llvm.getelementptr %182[%1725] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1719 = llvm.load %1727 : !llvm.ptr -> i64
%1729 = arith.constant 9 : i32
%1731 = arith.extsi %1729 : i32 to i64
%1730 = arith.muli %1530, %1731 : i64
%1732 = arith.constant 1 : i32
%1734 = arith.extsi %1732 : i32 to i64
%1733 = arith.addi %1730, %1734 : i64
%1735 = llvm.getelementptr %182[%1733] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1728 = llvm.load %1735 : !llvm.ptr -> i64
%1736 = arith.subi %1719, %1728 : i64
%1738 = llvm.load %1548 : !llvm.ptr -> i64
%1739 = arith.constant 9 : i32
%1741 = arith.extsi %1739 : i32 to i64
%1740 = arith.muli %1738, %1741 : i64
%1742 = arith.constant 1 : i32
%1744 = arith.extsi %1742 : i32 to i64
%1743 = arith.addi %1740, %1744 : i64
%1745 = llvm.getelementptr %182[%1743] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1737 = llvm.load %1745 : !llvm.ptr -> i64
%1747 = arith.constant 9 : i32
%1749 = arith.extsi %1747 : i32 to i64
%1748 = arith.muli %1555, %1749 : i64
%1750 = arith.constant 1 : i32
%1752 = arith.extsi %1750 : i32 to i64
%1751 = arith.addi %1748, %1752 : i64
%1753 = llvm.getelementptr %182[%1751] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1746 = llvm.load %1753 : !llvm.ptr -> i64
%1754 = arith.subi %1737, %1746 : i64
%1755 = arith.addi %1736, %1754 : i64
%1757 = arith.extsi %1718 : i32 to i64
%1756 = arith.subi %1757, %1755 : i64
%1758 = arith.constant 0 : i32
%1759 = arith.extsi %1758 : i32 to i64
%1760 = llvm.mlir.constant(1 : i64) : i64
%1761 = llvm.alloca %1760 x i64 : (i64) -> !llvm.ptr
llvm.store %1759, %1761 : i64, !llvm.ptr
%1762 = arith.constant 0 : i32
%1763 = arith.extsi %1762 : i32 to i64
%1764 = llvm.mlir.constant(1 : i64) : i64
%1765 = llvm.alloca %1764 x i64 : (i64) -> !llvm.ptr
llvm.store %1763, %1765 : i64, !llvm.ptr
cf.br ^bb192
^bb192:
%1766 = llvm.load %1765 : !llvm.ptr -> i64
%1767 = llvm.load %397 : !llvm.ptr -> i64
%1768 = arith.cmpi slt, %1766, %1767 : i64
cf.cond_br %1768, ^bb193, ^bb194
^bb193:
%1770 = llvm.load %378 : !llvm.ptr -> !llvm.ptr
%1771 = llvm.load %1765 : !llvm.ptr -> i64
%1772 = llvm.getelementptr %1770[%1771] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1769 = llvm.load %1772 : !llvm.ptr -> i64
%1773 = arith.cmpi eq, %1769, %1677 : i64
cf.cond_br %1773, ^bb195, ^bb196
^bb195:
%1774 = arith.constant 0 : i32
%1775 = arith.extsi %1774 : i32 to i64
%1776 = llvm.mlir.constant(1 : i64) : i64
%1777 = llvm.alloca %1776 x i64 : (i64) -> !llvm.ptr
llvm.store %1775, %1777 : i64, !llvm.ptr
cf.br ^bb198
^bb198:
%1778 = llvm.load %1777 : !llvm.ptr -> i64
%1779 = llvm.load %823 : !llvm.ptr -> i64
%1780 = arith.cmpi slt, %1778, %1779 : i64
cf.cond_br %1780, ^bb199, ^bb200
^bb199:
%1782 = llvm.load %383 : !llvm.ptr -> !llvm.ptr
%1783 = llvm.load %1765 : !llvm.ptr -> i64
%1784 = llvm.getelementptr %1782[%1783] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1781 = llvm.load %1784 : !llvm.ptr -> i64
%1786 = llvm.load %809 : !llvm.ptr -> !llvm.ptr
%1787 = llvm.load %1777 : !llvm.ptr -> i64
%1788 = llvm.getelementptr %1786[%1787] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1785 = llvm.load %1788 : !llvm.ptr -> i64
%1789 = arith.subi %1716, %1785 : i64
%1790 = arith.cmpi eq, %1781, %1789 : i64
%1791 = scf.if %1790 -> (i1) {
%1793 = llvm.load %388 : !llvm.ptr -> !llvm.ptr
%1794 = llvm.load %1765 : !llvm.ptr -> i64
%1795 = llvm.getelementptr %1793[%1794] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1792 = llvm.load %1795 : !llvm.ptr -> i64
%1797 = llvm.load %814 : !llvm.ptr -> !llvm.ptr
%1798 = llvm.load %1777 : !llvm.ptr -> i64
%1799 = llvm.getelementptr %1797[%1798] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1796 = llvm.load %1799 : !llvm.ptr -> i64
%1800 = arith.subi %1756, %1796 : i64
%1801 = arith.cmpi eq, %1792, %1800 : i64
scf.yield %1801 : i1
} else {
%1802 = arith.constant false
scf.yield %1802 : i1
}
cf.cond_br %1791, ^bb201, ^bb202
^bb201:
%1803 = llvm.load %1761 : !llvm.ptr -> i64
%1805 = llvm.load %393 : !llvm.ptr -> !llvm.ptr
%1806 = llvm.load %1765 : !llvm.ptr -> i64
%1807 = llvm.getelementptr %1805[%1806] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1804 = llvm.load %1807 : !llvm.ptr -> i64
%1809 = llvm.load %819 : !llvm.ptr -> !llvm.ptr
%1810 = llvm.load %1777 : !llvm.ptr -> i64
%1811 = llvm.getelementptr %1809[%1810] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1808 = llvm.load %1811 : !llvm.ptr -> i64
%1812 = arith.muli %1804, %1808 : i64
%1813 = arith.addi %1803, %1812 : i64
llvm.store %1813, %1761 : i64, !llvm.ptr
cf.br ^bb203
^bb202:
cf.br ^bb203
^bb203:
%1814 = llvm.load %1777 : !llvm.ptr -> i64
%1815 = arith.constant 1 : i32
%1817 = arith.extsi %1815 : i32 to i64
%1816 = arith.addi %1814, %1817 : i64
llvm.store %1816, %1777 : i64, !llvm.ptr
cf.br ^bb198
^bb200:
cf.br ^bb197
^bb196:
cf.br ^bb197
^bb197:
%1818 = llvm.load %1765 : !llvm.ptr -> i64
%1819 = arith.constant 1 : i32
%1821 = arith.extsi %1819 : i32 to i64
%1820 = arith.addi %1818, %1821 : i64
llvm.store %1820, %1765 : i64, !llvm.ptr
cf.br ^bb192
^bb194:
%1822 = llvm.load %1519 : !llvm.ptr -> i64
%1823 = llvm.load %1761 : !llvm.ptr -> i64
%1824 = arith.addi %1822, %1823 : i64
llvm.store %1824, %1519 : i64, !llvm.ptr
func.call @free(%1612) : (!llvm.ptr) -> ()
cf.br ^bb188
^bb187:
cf.br ^bb188
^bb188:
%1826 = llvm.load %1548 : !llvm.ptr -> i64
%1827 = arith.constant 1 : i32
%1829 = arith.extsi %1827 : i32 to i64
%1828 = arith.addi %1826, %1829 : i64
llvm.store %1828, %1548 : i64, !llvm.ptr
cf.br ^bb177
^bb179:
cf.br ^bb176
^bb175:
cf.br ^bb176
^bb176:
%1830 = llvm.load %1523 : !llvm.ptr -> i64
%1831 = arith.constant 1 : i32
%1833 = arith.extsi %1831 : i32 to i64
%1832 = arith.addi %1830, %1833 : i64
llvm.store %1832, %1523 : i64, !llvm.ptr
cf.br ^bb171
^bb173:
%1834 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1835 = llvm.load %1519 : !llvm.ptr -> i64
%1836 = arith.constant 2 : i32
%1838 = arith.extsi %1836 : i32 to i64
%1837 = arith.divsi %1835, %1838 : i64
%1839 = llvm.call @printf(%1834, %1837) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%1840 = arith.constant 0 : i32
func.return %1840 : i32
}
}