← All problems Problem 502
Counting Castles — height/width generating-function recurrence mod 10^9+7. Ported from C to pure Flow.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^2)O(n log n)Space complexity O(n^2)O(n)Approach Flow solution Modular DP or matrix exponentiation Verdict Suboptimal
Flow source
# Project Euler 502
# Counting Castles — height/width generating-function recurrence mod 10^9+7.
# Ported from C to pure Flow.
import euler.nt { mod_pow }
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function malloc(n: i64) -> ptr<void>
}
const MOD: i64 = 1000000007
const INV2: i64 = 500000004
const P1: i64 = 998244353
const P2: i64 = 1004535809
const P3: i64 = 469762049
let mut g_inv_p1_mod_p2: i64 = -1
let mut g_inv_p12_mod_p3: i64 = -1
let mut g_P12_lo: i64 = 0
let mut g_P12_hi: i64 = 0
function mod_inv(a: i64, mod: i64) -> i64 {
return mod_pow(a, mod - 2, mod)
}
function ntt(a: ptr<i64>, n: i64, invert: i32, mod: i64, root: i64) -> void {
let mut j: i64 = 0
let mut i: i64 = 1
while i < n {
let mut bit: i64 = n >> 1
while (j & bit) != 0 {
j = j ^ bit
bit = bit >> 1
}
j = j ^ bit
if i < j {
let tmp: i64 = a[i]
a[i] = a[j]
a[j] = tmp
}
i = i + 1
}
let mut length: i64 = 2
while length <= n {
let wlen: i64 = mod_pow(root, (mod - 1) / length, mod)
let mut wl: i64 = wlen
if invert == 1 { wl = mod_pow(wlen, mod - 2, mod) }
let half: i64 = length >> 1
i = 0
while i < n {
let mut w: i64 = 1
let mut jj: i64 = 0
while jj < half {
let u: i64 = a[i + jj]
let v: i64 = ((a[i + jj + half] as i128) * (w as i128) % (mod as i128)) as i64
let mut x: i64 = u + v
if x >= mod { x = x - mod }
let mut y: i64 = u - v
if y < 0 { y = y + mod }
a[i + jj] = x
a[i + jj + half] = y
w = ((w as i128) * (wl as i128) % (mod as i128)) as i64
jj = jj + 1
}
i = i + length
}
length = length << 1
}
if invert == 1 {
let inv_n: i64 = mod_pow(n, mod - 2, mod)
i = 0
while i < n {
a[i] = ((a[i] as i128) * (inv_n as i128) % (mod as i128)) as i64
i = i + 1
}
}
}
function convolve_one(a: ptr<i64>, n1: i64, b: ptr<i64>, n2: i64, mod: i64, root: i64, out_n: ptr<i64>) -> ptr<i64> {
let need: i64 = n1 + n2 - 1
let mut n: i64 = 1
while n < need { n = n << 1 }
let fa: ptr<i64> = calloc(n, 8) as ptr<i64>
let fb: ptr<i64> = calloc(n, 8) as ptr<i64>
let mut i: i64 = 0
while i < n1 { fa[i] = a[i] % mod; i = i + 1 }
i = 0
while i < n2 { fb[i] = b[i] % mod; i = i + 1 }
ntt(fa, n, 0, mod, root)
ntt(fb, n, 0, mod, root)
i = 0
while i < n {
fa[i] = ((fa[i] as i128) * (fb[i] as i128) % (mod as i128)) as i64
i = i + 1
}
ntt(fa, n, 1, mod, root)
out_n[0] = need
let res: ptr<i64> = malloc(need * 8) as ptr<i64>
i = 0
while i < need { res[i] = fa[i]; i = i + 1 }
free(fa as ptr<void>)
free(fb as ptr<void>)
return res
}
function crt3(a1: i64, a2: i64, a3: i64) -> i64 {
if g_inv_p1_mod_p2 < 0 {
g_inv_p1_mod_p2 = mod_inv(P1 % P2, P2)
let p12: i128 = (P1 as i128) * (P2 as i128)
g_P12_lo = (p12 & ((1 as i128) << 63) - 1) as i64
g_P12_hi = (p12 >> 63) as i64
g_inv_p12_mod_p3 = mod_inv((p12 % (P3 as i128)) as i64, P3)
}
let mut t1: i64 = ((a2 - a1) % P2)
if t1 < 0 { t1 = t1 + P2 }
t1 = ((t1 as i128) * (g_inv_p1_mod_p2 as i128) % (P2 as i128)) as i64
let x2: i128 = (a1 as i128) + (P1 as i128) * (t1 as i128)
let mut t2: i64 = ((a3 - (x2 % (P3 as i128)) as i64) % P3)
if t2 < 0 { t2 = t2 + P3 }
t2 = ((t2 as i128) * (g_inv_p12_mod_p3 as i128) % (P3 as i128)) as i64
let p12: i128 = ((g_P12_hi as i128) << 63) + (g_P12_lo as i128)
let x: i128 = x2 + p12 * (t2 as i128)
let mut r: i64 = (x % (MOD as i128)) as i64
if r < 0 { r = r + MOD }
return r
}
function convolve_mod(a: ptr<i64>, n1: i64, b: ptr<i64>, n2: i64, out_n: ptr<i64>) -> ptr<i64> {
if n1 == 0 || n2 == 0 { out_n[0] = 0; return null as ptr<i64> }
let o1p: ptr<i64> = calloc(1, 8) as ptr<i64>
let o2p: ptr<i64> = calloc(1, 8) as ptr<i64>
let o3p: ptr<i64> = calloc(1, 8) as ptr<i64>
let c1: ptr<i64> = convolve_one(a, n1, b, n2, P1, 3, o1p)
let c2: ptr<i64> = convolve_one(a, n1, b, n2, P2, 3, o2p)
let c3: ptr<i64> = convolve_one(a, n1, b, n2, P3, 3, o3p)
let need: i64 = n1 + n2 - 1
let res: ptr<i64> = malloc(need * 8) as ptr<i64>
let mut i: i64 = 0
while i < need { res[i] = crt3(c1[i], c2[i], c3[i]); i = i + 1 }
free(c1 as ptr<void>)
free(c2 as ptr<void>)
free(c3 as ptr<void>)
free(o1p as ptr<void>)
free(o2p as ptr<void>)
free(o3p as ptr<void>)
out_n[0] = need
return res
}
function poly_mul_trunc(a: ptr<i64>, na: i64, b: ptr<i64>, nb: i64, n: i64) -> ptr<i64> {
let onp: ptr<i64> = calloc(1, 8) as ptr<i64>
let c: ptr<i64> = convolve_mod(a, na, b, nb, onp)
let on: i64 = onp[0]
free(onp as ptr<void>)
let res: ptr<i64> = calloc(n, 8) as ptr<i64>
let mut i: i64 = 0
while i < n && i < on { res[i] = c[i]; i = i + 1 }
free(c as ptr<void>)
return res
}
function inv_series(q: ptr<i64>, n: i64) -> ptr<i64> {
let mut g: ptr<i64> = calloc(n, 8) as ptr<i64>
g[0] = mod_inv(q[0], MOD)
let mut m: i64 = 1
while m < n {
let m2: i64 = m * 2
let mut m2c: i64 = m2
if m2c > n { m2c = n }
let fg: ptr<i64> = poly_mul_trunc(q, m2c, g, m, m2c)
let mut i: i64 = 0
while i < m2c {
fg[i] = (MOD - fg[i]) % MOD
i = i + 1
}
fg[0] = (fg[0] + 2) % MOD
let ng: ptr<i64> = poly_mul_trunc(g, m, fg, m2c, m2c)
free(g as ptr<void>)
free(fg as ptr<void>)
g = ng
m = m2c
}
return g
}
function build_PQ_mod(h: i64, y: i64, deg_limit: i64, P_out: ptr<ptr<i64> >, Pn_out: ptr<i64>, Q_out: ptr<ptr<i64> >, Qn_out: ptr<i64>) -> void {
if h <= 0 {
P_out[0] = calloc(1, 8) as ptr<i64>
Pn_out[0] = 1
Q_out[0] = malloc(8) as ptr<i64>
Q_out[0][0] = 1
Qn_out[0] = 1
return
}
let y_mod: i64 = if y == 1 { 1 } else { MOD - 1 }
let cap: i64 = deg_limit + 1
let mut P: ptr<i64> = calloc(cap, 8) as ptr<i64>
let mut Q: ptr<i64> = calloc(cap, 8) as ptr<i64>
P[1] = y_mod
Q[0] = 1
Q[1] = MOD - 1
let mut plen: i64 = if deg_limit >= 1 { 2 } else { 1 }
let mut qlen: i64 = 2
if h == 1 {
P_out[0] = P
Pn_out[0] = plen
Q_out[0] = Q
Qn_out[0] = qlen
return
}
let mut step: i64 = 2
while step <= h {
let old_len: i64 = plen
let mut new_len: i64 = old_len + 1
if new_len > cap { new_len = cap }
let nP: ptr<i64> = calloc(new_len, 8) as ptr<i64>
let nQ: ptr<i64> = calloc(new_len, 8) as ptr<i64>
nQ[0] = 1
let mut i: i64 = 1
while i < new_len {
let pv: i64 = if i - 1 < plen { P[i - 1] } else { 0 }
let qv: i64 = if i - 1 < qlen { Q[i - 1] } else { 0 }
let s: i64 = (pv + qv) % MOD
let p_i: i64 = if i < old_len { P[i] } else { 0 }
if y == 1 {
nP[i] = (p_i + s) % MOD
} else {
let v: i64 = (p_i + s) % MOD
nP[i] = if v != 0 { MOD - v } else { 0 }
}
let q_i: i64 = if i < old_len { Q[i] } else { 0 }
let mut qvv: i64 = q_i - s
if qvv < 0 { qvv = qvv + MOD }
nQ[i] = qvv
i = i + 1
}
free(P as ptr<void>)
free(Q as ptr<void>)
P = nP
Q = nQ
plen = new_len
qlen = new_len
step = step + 1
}
P_out[0] = P
Pn_out[0] = plen
Q_out[0] = Q
Qn_out[0] = qlen
}
function series_coeff_mod(P: ptr<i64>, Pn: i64, Q: ptr<i64>, Qn: i64, w: i64) -> i64 {
let n: i64 = w + 1
if w < 2048 {
let f: ptr<i64> = calloc(n, 8) as ptr<i64>
let mut i: i64 = 0
while i < n {
let mut val: i128 = if i < Pn { P[i] as i128 } else { 0 }
let mut j: i64 = 1
while j <= i && j < Qn {
val = val - (Q[j] as i128) * (f[i - j] as i128)
j = j + 1
}
let mut vi: i64 = (val % (MOD as i128)) as i64
if vi < 0 { vi = vi + MOD }
f[i] = vi
i = i + 1
}
let ans: i64 = f[w]
free(f as ptr<void>)
return ans
}
let Qtrunc: ptr<i64> = calloc(n, 8) as ptr<i64>
let mut i: i64 = 0
while i < n && i < Qn { Qtrunc[i] = Q[i]; i = i + 1 }
let invQ: ptr<i64> = inv_series(Qtrunc, n)
free(Qtrunc as ptr<void>)
let Ptrunc: ptr<i64> = calloc(n, 8) as ptr<i64>
i = 0
while i < n && i < Pn { Ptrunc[i] = P[i]; i = i + 1 }
let prod: ptr<i64> = poly_mul_trunc(Ptrunc, n, invQ, n, n)
let ans2: i64 = prod[w]
free(invQ as ptr<void>)
free(Ptrunc as ptr<void>)
free(prod as ptr<void>)
return ans2
}
function kitamasa(init: ptr<i64>, coef: ptr<i64>, d: i64, k: i64) -> i64 {
if k < d { return init[k] }
let mut pol: ptr<i64> = calloc(d, 8) as ptr<i64>
pol[0] = 1
let mut base: ptr<i64> = calloc(d, 8) as ptr<i64>
if d > 1 { base[1] = 1 }
let mut e: i64 = k
while e != 0 {
if e % 2 == 1 {
let tmp: ptr<i64> = calloc(2 * d - 1, 8) as ptr<i64>
let mut i: i64 = 0
while i < d {
if pol[i] != 0 {
let mut j: i64 = 0
while j < d {
tmp[i + j] = (tmp[i + j] + ((pol[i] as i128) * (base[j] as i128) % (MOD as i128)) as i64) % MOD
j = j + 1
}
}
i = i + 1
}
let mut i2: i64 = 2 * d - 2
while i2 >= d {
let t: i64 = tmp[i2]
if t != 0 {
let mut j: i64 = 0
while j < d {
tmp[i2 - 1 - j] = (tmp[i2 - 1 - j] + ((t as i128) * (coef[j] as i128) % (MOD as i128)) as i64) % MOD
j = j + 1
}
}
i2 = i2 - 1
}
let mut i3: i64 = 0
while i3 < d { pol[i3] = tmp[i3]; i3 = i3 + 1 }
free(tmp as ptr<void>)
}
let tmp2: ptr<i64> = calloc(2 * d - 1, 8) as ptr<i64>
let mut i: i64 = 0
while i < d {
if base[i] != 0 {
let mut j: i64 = 0
while j < d {
tmp2[i + j] = (tmp2[i + j] + ((base[i] as i128) * (base[j] as i128) % (MOD as i128)) as i64) % MOD
j = j + 1
}
}
i = i + 1
}
let mut i2: i64 = 2 * d - 2
while i2 >= d {
let t: i64 = tmp2[i2]
if t != 0 {
let mut j: i64 = 0
while j < d {
tmp2[i2 - 1 - j] = (tmp2[i2 - 1 - j] + ((t as i128) * (coef[j] as i128) % (MOD as i128)) as i64) % MOD
j = j + 1
}
}
i2 = i2 - 1
}
let mut i3: i64 = 0
while i3 < d { base[i3] = tmp2[i3]; i3 = i3 + 1 }
free(tmp2 as ptr<void>)
e = e / 2
}
let mut ans: i64 = 0
let mut i: i64 = 0
while i < d {
ans = (ans + ((pol[i] as i128) * (init[i] as i128) % (MOD as i128)) as i64) % MOD
i = i + 1
}
free(pol as ptr<void>)
free(base as ptr<void>)
return ans
}
function coeff_large_w_small_h(w: i64, h: i64, y: i64) -> i64 {
let Pp: ptr<ptr<i64> > = calloc(1, 8) as ptr<ptr<i64> >
let Pnp: ptr<i64> = calloc(1, 8) as ptr<i64>
let Qp: ptr<ptr<i64> > = calloc(1, 8) as ptr<ptr<i64> >
let Qnp: ptr<i64> = calloc(1, 8) as ptr<i64>
build_PQ_mod(h, y, h, Pp, Pnp, Qp, Qnp)
let P: ptr<i64> = Pp[0]
let Pn: i64 = Pnp[0]
let Q: ptr<i64> = Qp[0]
let Qn: i64 = Qnp[0]
free(Pp as ptr<void>)
free(Pnp as ptr<void>)
free(Qp as ptr<void>)
free(Qnp as ptr<void>)
let f: ptr<i64> = malloc((h + 1) * 8) as ptr<i64>
let mut n: i64 = 0
while n <= h {
let mut val: i128 = if n < Pn { P[n] as i128 } else { 0 }
let mut j: i64 = 1
while j <= n && j < Qn {
val = val - (Q[j] as i128) * (f[n - j] as i128)
j = j + 1
}
let mut vi: i64 = (val % (MOD as i128)) as i64
if vi < 0 { vi = vi + MOD }
f[n] = vi
n = n + 1
}
if w <= h {
let ans: i64 = f[w]
free(P as ptr<void>)
free(Q as ptr<void>)
free(f as ptr<void>)
return ans
}
let coef: ptr<i64> = malloc(h * 8) as ptr<i64>
let mut i: i64 = 1
while i <= h {
let qv: i64 = if i < Qn { Q[i] } else { 0 }
coef[i - 1] = (MOD - qv) % MOD
i = i + 1
}
let init: ptr<i64> = malloc(h * 8) as ptr<i64>
i = 0
while i < h {
init[i] = f[i + 1]
i = i + 1
}
let ans2: i64 = kitamasa(init, coef, h, w - 1)
free(P as ptr<void>)
free(Q as ptr<void>)
free(f as ptr<void>)
free(coef as ptr<void>)
free(init as ptr<void>)
return ans2
}
function poly_mul_small(a: ptr<i64>, na: i64, b: ptr<i64>, nb: i64, limit: i64, out_n: ptr<i64>) -> ptr<i64> {
let mut need: i64 = na + nb - 1
if need > limit { need = limit }
let res: ptr<i64> = calloc(need, 8) as ptr<i64>
let mut i: i64 = 0
while i < na {
if a[i] != 0 {
let mut j: i64 = 0
while j < nb {
let ij: i64 = i + j
if ij >= limit { break }
res[ij] = (res[ij] + ((a[i] as i128) * (b[j] as i128) % (MOD as i128)) as i64) % MOD
j = j + 1
}
}
i = i + 1
}
out_n[0] = need
return res
}
function poly_add_small(a: ptr<i64>, na: i64, b: ptr<i64>, nb: i64, limit: i64) -> ptr<i64> {
let res: ptr<i64> = calloc(limit, 8) as ptr<i64>
let mut i: i64 = 0
while i < limit {
let av: i64 = if i < na { a[i] } else { 0 }
let bv: i64 = if i < nb { b[i] } else { 0 }
res[i] = (av + bv) % MOD
i = i + 1
}
return res
}
struct Mat {
m00p: ptr<i64>, m00n: i64,
m01p: ptr<i64>, m01n: i64,
m10p: ptr<i64>, m10n: i64,
m11p: ptr<i64>, m11n: i64
}
function mat_mul(A: Mat, B: Mat, limit: i64) -> Mat {
let onp: ptr<i64> = calloc(1, 8) as ptr<i64>
let t1: ptr<i64> = poly_mul_small(A.m00p, A.m00n, B.m00p, B.m00n, limit, onp)
let n1: i64 = onp[0]
let t2: ptr<i64> = poly_mul_small(A.m01p, A.m01n, B.m10p, B.m10n, limit, onp)
let n2: i64 = onp[0]
let s00: ptr<i64> = poly_add_small(t1, n1, t2, n2, limit)
free(t1 as ptr<void>)
free(t2 as ptr<void>)
let t3: ptr<i64> = poly_mul_small(A.m00p, A.m00n, B.m01p, B.m01n, limit, onp)
let n3: i64 = onp[0]
let t4: ptr<i64> = poly_mul_small(A.m01p, A.m01n, B.m11p, B.m11n, limit, onp)
let n4: i64 = onp[0]
let s01: ptr<i64> = poly_add_small(t3, n3, t4, n4, limit)
free(t3 as ptr<void>)
free(t4 as ptr<void>)
let t5: ptr<i64> = poly_mul_small(A.m10p, A.m10n, B.m00p, B.m00n, limit, onp)
let n5: i64 = onp[0]
let t6: ptr<i64> = poly_mul_small(A.m11p, A.m11n, B.m10p, B.m10n, limit, onp)
let n6: i64 = onp[0]
let s10: ptr<i64> = poly_add_small(t5, n5, t6, n6, limit)
free(t5 as ptr<void>)
free(t6 as ptr<void>)
let t7: ptr<i64> = poly_mul_small(A.m10p, A.m10n, B.m01p, B.m01n, limit, onp)
let n7: i64 = onp[0]
let t8: ptr<i64> = poly_mul_small(A.m11p, A.m11n, B.m11p, B.m11n, limit, onp)
let n8: i64 = onp[0]
let s11: ptr<i64> = poly_add_small(t7, n7, t8, n8, limit)
free(t7 as ptr<void>)
free(t8 as ptr<void>)
free(onp as ptr<void>)
return Mat { m00p: s00, m00n: limit, m01p: s01, m01n: limit, m10p: s10, m10n: limit, m11p: s11, m11n: limit }
}
function mat_free(M: Mat) -> void {
free(M.m00p as ptr<void>)
free(M.m01p as ptr<void>)
free(M.m10p as ptr<void>)
free(M.m11p as ptr<void>)
}
function mat_pow(M0: Mat, e0: i64, limit: i64) -> Mat {
let mut I: Mat = Mat { m00p: null, m00n: 0, m01p: null, m01n: 0, m10p: null, m10n: 0, m11p: null, m11n: 0 }
let p00: ptr<i64> = calloc(limit, 8) as ptr<i64>
p00[0] = 1
let p11: ptr<i64> = calloc(limit, 8) as ptr<i64>
p11[0] = 1
let p01: ptr<i64> = calloc(limit, 8) as ptr<i64>
let p10: ptr<i64> = calloc(limit, 8) as ptr<i64>
I = Mat { m00p: p00, m00n: limit, m01p: p01, m01n: limit, m10p: p10, m10n: limit, m11p: p11, m11n: limit }
let mut base: Mat = M0
let mut base_owned: bool = false
let mut e: i64 = e0
while e != 0 {
if e % 2 == 1 {
let nI: Mat = mat_mul(I, base, limit)
mat_free(I)
I = nI
}
let nB: Mat = mat_mul(base, base, limit)
if base_owned { mat_free(base) }
base = nB
base_owned = true
e = e / 2
}
if base_owned { mat_free(base) }
return I
}
function coeff_large_h_small_w(w: i64, h: i64, y: i64) -> i64 {
if h <= 0 { return 0 }
let limit: i64 = w + 1
let y_mod: i64 = if y == 1 { 1 } else { MOD - 1 }
let P: ptr<i64> = calloc(limit, 8) as ptr<i64>
let Q: ptr<i64> = calloc(limit, 8) as ptr<i64>
if w >= 1 {
P[1] = y_mod
Q[1] = MOD - 1
}
Q[0] = 1
if h == 1 {
let ans: i64 = series_coeff_mod(P, limit, Q, limit, w)
free(P as ptr<void>)
free(Q as ptr<void>)
return ans
}
let y_one_plus_x: ptr<i64> = calloc(limit, 8) as ptr<i64>
y_one_plus_x[0] = y_mod
if limit >= 2 { y_one_plus_x[1] = y_mod }
let y_x: ptr<i64> = calloc(limit, 8) as ptr<i64>
if limit >= 2 { y_x[1] = y_mod }
let minus_x: ptr<i64> = calloc(limit, 8) as ptr<i64>
if limit >= 2 { minus_x[1] = MOD - 1 }
let one_minus_x: ptr<i64> = calloc(limit, 8) as ptr<i64>
one_minus_x[0] = 1
if limit >= 2 { one_minus_x[1] = MOD - 1 }
let A: Mat = Mat { m00p: y_one_plus_x, m00n: limit, m01p: y_x, m01n: limit, m10p: minus_x, m10n: limit, m11p: one_minus_x, m11n: limit }
let Mp: Mat = mat_pow(A, h - 1, limit)
mat_free(A)
let onp: ptr<i64> = calloc(1, 8) as ptr<i64>
let t1: ptr<i64> = poly_mul_small(Mp.m00p, limit, P, limit, limit, onp)
let n1: i64 = onp[0]
let t2: ptr<i64> = poly_mul_small(Mp.m01p, limit, Q, limit, limit, onp)
let n2: i64 = onp[0]
let Pn: ptr<i64> = poly_add_small(t1, n1, t2, n2, limit)
free(t1 as ptr<void>)
free(t2 as ptr<void>)
let t3: ptr<i64> = poly_mul_small(Mp.m10p, limit, P, limit, limit, onp)
let n3: i64 = onp[0]
let t4: ptr<i64> = poly_mul_small(Mp.m11p, limit, Q, limit, limit, onp)
let n4: i64 = onp[0]
let Qn: ptr<i64> = poly_add_small(t3, n3, t4, n4, limit)
free(t3 as ptr<void>)
free(t4 as ptr<void>)
free(onp as ptr<void>)
mat_free(Mp)
free(P as ptr<void>)
free(Q as ptr<void>)
let ans: i64 = series_coeff_mod(Pn, limit, Qn, limit, w)
free(Pn as ptr<void>)
free(Qn as ptr<void>)
return ans
}
function coeff_C_mod(w: i64, h: i64, y: i64) -> i64 {
if h <= 0 { return 0 }
if w <= 200 && h > 2000 { return coeff_large_h_small_w(w, h, y) }
if h <= 200 && w > 2000 { return coeff_large_w_small_h(w, h, y) }
let Pp: ptr<ptr<i64> > = calloc(1, 8) as ptr<ptr<i64> >
let Pnp: ptr<i64> = calloc(1, 8) as ptr<i64>
let Qp: ptr<ptr<i64> > = calloc(1, 8) as ptr<ptr<i64> >
let Qnp: ptr<i64> = calloc(1, 8) as ptr<i64>
let mut deg: i64 = w
if deg < 0 { deg = 0 }
build_PQ_mod(h, y, deg, Pp, Pnp, Qp, Qnp)
let P: ptr<i64> = Pp[0]
let Pn: i64 = Pnp[0]
let Q: ptr<i64> = Qp[0]
let Qn: i64 = Qnp[0]
free(Pp as ptr<void>)
free(Pnp as ptr<void>)
free(Qp as ptr<void>)
free(Qnp as ptr<void>)
let ans: i64 = series_coeff_mod(P, Pn, Q, Qn, w)
free(P as ptr<void>)
free(Q as ptr<void>)
return ans
}
function E_leq_mod(w: i64, h: i64) -> i64 {
if h <= 0 { return 0 }
let T: i64 = coeff_C_mod(w, h, 1)
let S: i64 = coeff_C_mod(w, h, -1)
return (((T + S) % MOD) as i128 * (INV2 as i128) % (MOD as i128)) as i64
}
function F_mod(w: i64, h: i64) -> i64 {
let a: i64 = E_leq_mod(w, h)
let b: i64 = E_leq_mod(w, h - 1)
let mut r: i64 = a - b
if r < 0 { r = r + MOD }
return r
}
function main() -> i32 {
let a: i64 = F_mod(1000000000000, 100)
let b: i64 = F_mod(10000, 10000)
let c: i64 = F_mod(100, 1000000000000)
printf("%lld\n", (a + b + c) % MOD)
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; }
typedef struct Mat Mat;
struct Mat {
int64_t* m00p;
int64_t m00n;
int64_t* m01p;
int64_t m01n;
int64_t* m10p;
int64_t m10n;
int64_t* m11p;
int64_t m11n;
};
int64_t gcd_i64_i64(int64_t a0, int64_t b0);
int64_t lcm_i64_i64(int64_t a, int64_t b);
int64_t isqrt_i64(int64_t n);
int64_t mulmod_i64_i64_i64(int64_t a0, int64_t b0, int64_t mod);
int64_t mod_pow_i64_i64_i64(int64_t base, int64_t exp, int64_t mod);
bool is_prime_i64(int64_t n);
int64_t mod_inv_i64_i64(int64_t a, int64_t mod);
void ntt_ptr_i64_i64_i32_i64_i64(int64_t* a, int64_t n, int32_t invert, int64_t mod, int64_t root);
int64_t* convolve_one_ptr_i64_i64_ptr_i64_i64_i64_i64_ptr_i64(int64_t* a, int64_t n1, int64_t* b, int64_t n2, int64_t mod, int64_t root, int64_t* out_n);
int64_t crt3_i64_i64_i64(int64_t a1, int64_t a2, int64_t a3);
int64_t* convolve_mod_ptr_i64_i64_ptr_i64_i64_ptr_i64(int64_t* a, int64_t n1, int64_t* b, int64_t n2, int64_t* out_n);
int64_t* poly_mul_trunc_ptr_i64_i64_ptr_i64_i64_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t n);
int64_t* inv_series_ptr_i64_i64(int64_t* q, int64_t n);
void build_PQ_mod_i64_i64_i64_ptr_ptr_i64_ptr_i64_ptr_ptr_i64_ptr_i64(int64_t h, int64_t y, int64_t deg_limit, int64_t** P_out, int64_t* Pn_out, int64_t** Q_out, int64_t* Qn_out);
int64_t series_coeff_mod_ptr_i64_i64_ptr_i64_i64_i64(int64_t* P, int64_t Pn, int64_t* Q, int64_t Qn, int64_t w);
int64_t kitamasa_ptr_i64_ptr_i64_i64_i64(int64_t* init, int64_t* coef, int64_t d, int64_t k);
int64_t coeff_large_w_small_h_i64_i64_i64(int64_t w, int64_t h, int64_t y);
int64_t* poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t limit, int64_t* out_n);
int64_t* poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t limit);
Mat mat_mul_Mat_Mat_i64(Mat A, Mat B, int64_t limit);
void mat_free_Mat(Mat M);
Mat mat_pow_Mat_i64_i64(Mat M0, int64_t e0, int64_t limit);
int64_t coeff_large_h_small_w_i64_i64_i64(int64_t w, int64_t h, int64_t y);
int64_t coeff_C_mod_i64_i64_i64(int64_t w, int64_t h, int64_t y);
int64_t E_leq_mod_i64_i64(int64_t w, int64_t h);
int64_t F_mod_i64_i64(int64_t w, int64_t h);
int32_t main(void);
static const int64_t MOD = 1000000007;
static const int64_t INV2 = 500000004;
static const int64_t P1 = 998244353;
static const int64_t P2 = 1004535809;
static const int64_t P3 = 469762049;
/* Module statics */
static int64_t g_inv_p1_mod_p2 = (-1);
static int64_t g_inv_p12_mod_p3 = (-1);
static int64_t g_P12_lo = 0;
static int64_t g_P12_hi = 0;
int64_t gcd_i64_i64(int64_t a0, int64_t b0) {
int64_t a = a0;
int64_t b = b0;
while (b != 0) {
int64_t t = FLOW_CHECKED_MOD((a), (b));
a = b;
b = t;
}
return a;
}
int64_t lcm_i64_i64(int64_t a, int64_t b) {
if ((a == 0 || b == 0)) {
return 0;
}
return (FLOW_CHECKED_DIV((a), (gcd_i64_i64(a, b))) * b);
}
int64_t isqrt_i64(int64_t n) {
if (n < 2) {
return n;
}
int64_t x = n;
int64_t y = FLOW_CHECKED_DIV(((x + 1)), (2));
while (y < x) {
x = y;
y = FLOW_CHECKED_DIV(((x + FLOW_CHECKED_DIV((n), (x)))), (2));
}
return x;
}
int64_t mulmod_i64_i64_i64(int64_t a0, int64_t b0, int64_t mod) {
int64_t a = FLOW_CHECKED_MOD((a0), (mod));
int64_t b = FLOW_CHECKED_MOD((b0), (mod));
int64_t result = 0;
while (b > 0) {
if (FLOW_CHECKED_MOD((b), (2)) == 1) {
result = FLOW_CHECKED_MOD(((result + a)), (mod));
}
a = FLOW_CHECKED_MOD(((a * 2)), (mod));
b = FLOW_CHECKED_DIV((b), (2));
}
return result;
}
int64_t mod_pow_i64_i64_i64(int64_t base, int64_t exp, int64_t mod) {
if (mod == 1) {
return 0;
}
int64_t result = 1;
int64_t b = FLOW_CHECKED_MOD((base), (mod));
int64_t e = exp;
while (e > 0) {
if (FLOW_CHECKED_MOD((e), (2)) == 1) {
result = mulmod_i64_i64_i64(result, b, mod);
}
b = mulmod_i64_i64_i64(b, b, mod);
e = FLOW_CHECKED_DIV((e), (2));
}
return result;
}
bool is_prime_i64(int64_t n) {
if (n < 2) {
return 0;
}
if (n < 4) {
return 1;
}
if ((FLOW_CHECKED_MOD((n), (2)) == 0 || FLOW_CHECKED_MOD((n), (3)) == 0)) {
return 0;
}
int64_t i = 5;
while ((i * i) <= n) {
if ((FLOW_CHECKED_MOD((n), (i)) == 0 || FLOW_CHECKED_MOD((n), ((i + 2))) == 0)) {
return 0;
}
i = (i + 6);
}
return 1;
}
int64_t mod_inv_i64_i64(int64_t a, int64_t mod) {
return mod_pow_i64_i64_i64(a, (mod - 2), mod);
}
void ntt_ptr_i64_i64_i32_i64_i64(int64_t* a, int64_t n, int32_t invert, int64_t mod, int64_t root) {
int64_t j = 0;
int64_t i = 1;
while (i < n) {
int64_t bit = FLOW_CHECKED_SHR((n), (1));
while ((j & bit) != 0) {
j = (j ^ bit);
bit = FLOW_CHECKED_SHR((bit), (1));
}
j = (j ^ bit);
if (i < j) {
int64_t tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
i = (i + 1);
}
int64_t length = 2;
while (length <= n) {
int64_t wlen = mod_pow_i64_i64_i64(root, FLOW_CHECKED_DIV(((mod - 1)), (length)), mod);
int64_t wl = wlen;
if (invert == 1) {
wl = mod_pow_i64_i64_i64(wlen, (mod - 2), mod);
}
int64_t half = FLOW_CHECKED_SHR((length), (1));
i = 0;
while (i < n) {
int64_t w = 1;
int64_t jj = 0;
while (jj < half) {
int64_t u = a[(i + jj)];
int64_t v = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(a[((i + jj) + half)])) * ((__int128)(w)))), (((__int128)(mod))))));
int64_t x = (u + v);
if (x >= mod) {
x = (x - mod);
}
int64_t y = (u - v);
if (y < 0) {
y = (y + mod);
}
a[(i + jj)] = x;
a[((i + jj) + half)] = y;
w = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(w)) * ((__int128)(wl)))), (((__int128)(mod))))));
jj = (jj + 1);
}
i = (i + length);
}
length = FLOW_CHECKED_SHL((length), (1));
}
if (invert == 1) {
int64_t inv_n = mod_pow_i64_i64_i64(n, (mod - 2), mod);
i = 0;
while (i < n) {
a[i] = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(a[i])) * ((__int128)(inv_n)))), (((__int128)(mod))))));
i = (i + 1);
}
}
}
int64_t* convolve_one_ptr_i64_i64_ptr_i64_i64_i64_i64_ptr_i64(int64_t* a, int64_t n1, int64_t* b, int64_t n2, int64_t mod, int64_t root, int64_t* out_n) {
int64_t need = ((n1 + n2) - 1);
int64_t n = 1;
while (n < need) {
n = FLOW_CHECKED_SHL((n), (1));
}
int64_t* fa = (int64_t*)(((int64_t*)(calloc(n, 8))));
int64_t* fb = (int64_t*)(((int64_t*)(calloc(n, 8))));
int64_t i = 0;
while (i < n1) {
fa[i] = FLOW_CHECKED_MOD((a[i]), (mod));
i = (i + 1);
}
i = 0;
while (i < n2) {
fb[i] = FLOW_CHECKED_MOD((b[i]), (mod));
i = (i + 1);
}
ntt_ptr_i64_i64_i32_i64_i64(fa, n, 0, mod, root);
ntt_ptr_i64_i64_i32_i64_i64(fb, n, 0, mod, root);
i = 0;
while (i < n) {
fa[i] = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(fa[i])) * ((__int128)(fb[i])))), (((__int128)(mod))))));
i = (i + 1);
}
ntt_ptr_i64_i64_i32_i64_i64(fa, n, 1, mod, root);
out_n[0] = need;
int64_t* res = (int64_t*)(((int64_t*)(malloc((need * 8)))));
i = 0;
while (i < need) {
res[i] = fa[i];
i = (i + 1);
}
free(((void*)(fa)));
free(((void*)(fb)));
return res;
}
int64_t crt3_i64_i64_i64(int64_t a1, int64_t a2, int64_t a3) {
if (g_inv_p1_mod_p2 < 0) {
g_inv_p1_mod_p2 = mod_inv_i64_i64(FLOW_CHECKED_MOD((P1), (P2)), P2);
__int128 p12 = (((__int128)(P1)) * ((__int128)(P2)));
g_P12_lo = ((int64_t)((p12 & (FLOW_CHECKED_SHL((((__int128)(1))), (63)) - 1))));
g_P12_hi = ((int64_t)(FLOW_CHECKED_SHR((p12), (63))));
g_inv_p12_mod_p3 = mod_inv_i64_i64(((int64_t)(FLOW_CHECKED_MOD((p12), (((__int128)(P3)))))), P3);
}
int64_t t1 = FLOW_CHECKED_MOD(((a2 - a1)), (P2));
if (t1 < 0) {
t1 = (t1 + P2);
}
t1 = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(t1)) * ((__int128)(g_inv_p1_mod_p2)))), (((__int128)(P2))))));
__int128 x2 = (((__int128)(a1)) + (((__int128)(P1)) * ((__int128)(t1))));
int64_t t2 = FLOW_CHECKED_MOD(((a3 - ((int64_t)(FLOW_CHECKED_MOD((x2), (((__int128)(P3)))))))), (P3));
if (t2 < 0) {
t2 = (t2 + P3);
}
t2 = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(t2)) * ((__int128)(g_inv_p12_mod_p3)))), (((__int128)(P3))))));
__int128 p12 = (FLOW_CHECKED_SHL((((__int128)(g_P12_hi))), (63)) + ((__int128)(g_P12_lo)));
__int128 x = (x2 + (p12 * ((__int128)(t2))));
int64_t r = ((int64_t)(FLOW_CHECKED_MOD((x), (((__int128)(MOD))))));
if (r < 0) {
r = (r + MOD);
}
return r;
}
int64_t* convolve_mod_ptr_i64_i64_ptr_i64_i64_ptr_i64(int64_t* a, int64_t n1, int64_t* b, int64_t n2, int64_t* out_n) {
if ((n1 == 0 || n2 == 0)) {
out_n[0] = 0;
return ((int64_t*)(NULL));
}
int64_t* o1p = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* o2p = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* o3p = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* c1 = (int64_t*)(convolve_one_ptr_i64_i64_ptr_i64_i64_i64_i64_ptr_i64(a, n1, b, n2, P1, 3, o1p));
int64_t* c2 = (int64_t*)(convolve_one_ptr_i64_i64_ptr_i64_i64_i64_i64_ptr_i64(a, n1, b, n2, P2, 3, o2p));
int64_t* c3 = (int64_t*)(convolve_one_ptr_i64_i64_ptr_i64_i64_i64_i64_ptr_i64(a, n1, b, n2, P3, 3, o3p));
int64_t need = ((n1 + n2) - 1);
int64_t* res = (int64_t*)(((int64_t*)(malloc((need * 8)))));
int64_t i = 0;
while (i < need) {
res[i] = crt3_i64_i64_i64(c1[i], c2[i], c3[i]);
i = (i + 1);
}
free(((void*)(c1)));
free(((void*)(c2)));
free(((void*)(c3)));
free(((void*)(o1p)));
free(((void*)(o2p)));
free(((void*)(o3p)));
out_n[0] = need;
return res;
}
int64_t* poly_mul_trunc_ptr_i64_i64_ptr_i64_i64_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t n) {
int64_t* onp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* c = (int64_t*)(convolve_mod_ptr_i64_i64_ptr_i64_i64_ptr_i64(a, na, b, nb, onp));
int64_t on = onp[0];
free(((void*)(onp)));
int64_t* res = (int64_t*)(((int64_t*)(calloc(n, 8))));
int64_t i = 0;
while ((i < n && i < on)) {
res[i] = c[i];
i = (i + 1);
}
free(((void*)(c)));
return res;
}
int64_t* inv_series_ptr_i64_i64(int64_t* q, int64_t n) {
int64_t* g = (int64_t*)(((int64_t*)(calloc(n, 8))));
g[0] = mod_inv_i64_i64(q[0], MOD);
int64_t m = 1;
while (m < n) {
int64_t m2 = (m * 2);
int64_t m2c = m2;
if (m2c > n) {
m2c = n;
}
int64_t* fg = (int64_t*)(poly_mul_trunc_ptr_i64_i64_ptr_i64_i64_i64(q, m2c, g, m, m2c));
int64_t i = 0;
while (i < m2c) {
fg[i] = FLOW_CHECKED_MOD(((MOD - fg[i])), (MOD));
i = (i + 1);
}
fg[0] = FLOW_CHECKED_MOD(((fg[0] + 2)), (MOD));
int64_t* ng = (int64_t*)(poly_mul_trunc_ptr_i64_i64_ptr_i64_i64_i64(g, m, fg, m2c, m2c));
free(((void*)(g)));
free(((void*)(fg)));
g = ng;
m = m2c;
}
return g;
}
void build_PQ_mod_i64_i64_i64_ptr_ptr_i64_ptr_i64_ptr_ptr_i64_ptr_i64(int64_t h, int64_t y, int64_t deg_limit, int64_t** P_out, int64_t* Pn_out, int64_t** Q_out, int64_t* Qn_out) {
if (h <= 0) {
P_out[0] = ((int64_t*)(calloc(1, 8)));
Pn_out[0] = 1;
Q_out[0] = ((int64_t*)(malloc(8)));
Q_out[0][0] = 1;
Qn_out[0] = 1;
return;
}
int64_t y_mod = ((y == 1) ? (1) : ((MOD - 1)));
int64_t cap = (deg_limit + 1);
int64_t* P = (int64_t*)(((int64_t*)(calloc(cap, 8))));
int64_t* Q = (int64_t*)(((int64_t*)(calloc(cap, 8))));
P[1] = y_mod;
Q[0] = 1;
Q[1] = (MOD - 1);
int64_t plen = ((deg_limit >= 1) ? (2) : (1));
int64_t qlen = 2;
if (h == 1) {
P_out[0] = P;
Pn_out[0] = plen;
Q_out[0] = Q;
Qn_out[0] = qlen;
return;
}
int64_t step = 2;
while (step <= h) {
int64_t old_len = plen;
int64_t new_len = (old_len + 1);
if (new_len > cap) {
new_len = cap;
}
int64_t* nP = (int64_t*)(((int64_t*)(calloc(new_len, 8))));
int64_t* nQ = (int64_t*)(((int64_t*)(calloc(new_len, 8))));
nQ[0] = 1;
int64_t i = 1;
while (i < new_len) {
int64_t pv = (((i - 1) < plen) ? (P[(i - 1)]) : (0));
int64_t qv = (((i - 1) < qlen) ? (Q[(i - 1)]) : (0));
int64_t s = FLOW_CHECKED_MOD(((pv + qv)), (MOD));
int64_t p_i = ((i < old_len) ? (P[i]) : (0));
if (y == 1) {
nP[i] = FLOW_CHECKED_MOD(((p_i + s)), (MOD));
} else {
int64_t v = FLOW_CHECKED_MOD(((p_i + s)), (MOD));
nP[i] = ((v != 0) ? ((MOD - v)) : (0));
}
int64_t q_i = ((i < old_len) ? (Q[i]) : (0));
int64_t qvv = (q_i - s);
if (qvv < 0) {
qvv = (qvv + MOD);
}
nQ[i] = qvv;
i = (i + 1);
}
free(((void*)(P)));
free(((void*)(Q)));
P = nP;
Q = nQ;
plen = new_len;
qlen = new_len;
step = (step + 1);
}
P_out[0] = P;
Pn_out[0] = plen;
Q_out[0] = Q;
Qn_out[0] = qlen;
}
int64_t series_coeff_mod_ptr_i64_i64_ptr_i64_i64_i64(int64_t* P, int64_t Pn, int64_t* Q, int64_t Qn, int64_t w) {
int64_t n = (w + 1);
if (w < 2048) {
int64_t* f = (int64_t*)(((int64_t*)(calloc(n, 8))));
int64_t i = 0;
while (i < n) {
__int128 val = ((i < Pn) ? (((__int128)(P[i]))) : (0));
int64_t j = 1;
while ((j <= i && j < Qn)) {
val = (val - (((__int128)(Q[j])) * ((__int128)(f[(i - j)]))));
j = (j + 1);
}
int64_t vi = ((int64_t)(FLOW_CHECKED_MOD((val), (((__int128)(MOD))))));
if (vi < 0) {
vi = (vi + MOD);
}
f[i] = vi;
i = (i + 1);
}
int64_t ans = f[w];
free(((void*)(f)));
return ans;
}
int64_t* Qtrunc = (int64_t*)(((int64_t*)(calloc(n, 8))));
int64_t i = 0;
while ((i < n && i < Qn)) {
Qtrunc[i] = Q[i];
i = (i + 1);
}
int64_t* invQ = (int64_t*)(inv_series_ptr_i64_i64(Qtrunc, n));
free(((void*)(Qtrunc)));
int64_t* Ptrunc = (int64_t*)(((int64_t*)(calloc(n, 8))));
i = 0;
while ((i < n && i < Pn)) {
Ptrunc[i] = P[i];
i = (i + 1);
}
int64_t* prod = (int64_t*)(poly_mul_trunc_ptr_i64_i64_ptr_i64_i64_i64(Ptrunc, n, invQ, n, n));
int64_t ans2 = prod[w];
free(((void*)(invQ)));
free(((void*)(Ptrunc)));
free(((void*)(prod)));
return ans2;
}
int64_t kitamasa_ptr_i64_ptr_i64_i64_i64(int64_t* init, int64_t* coef, int64_t d, int64_t k) {
if (k < d) {
return init[k];
}
int64_t* pol = (int64_t*)(((int64_t*)(calloc(d, 8))));
pol[0] = 1;
int64_t* base = (int64_t*)(((int64_t*)(calloc(d, 8))));
if (d > 1) {
base[1] = 1;
}
int64_t e = k;
while (e != 0) {
if (FLOW_CHECKED_MOD((e), (2)) == 1) {
int64_t* tmp = (int64_t*)(((int64_t*)(calloc(((2 * d) - 1), 8))));
int64_t i = 0;
while (i < d) {
if (pol[i] != 0) {
int64_t j = 0;
while (j < d) {
tmp[(i + j)] = FLOW_CHECKED_MOD(((tmp[(i + j)] + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(pol[i])) * ((__int128)(base[j])))), (((__int128)(MOD)))))))), (MOD));
j = (j + 1);
}
}
i = (i + 1);
}
int64_t i2 = ((2 * d) - 2);
while (i2 >= d) {
int64_t t = tmp[i2];
if (t != 0) {
int64_t j = 0;
while (j < d) {
tmp[((i2 - 1) - j)] = FLOW_CHECKED_MOD(((tmp[((i2 - 1) - j)] + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(t)) * ((__int128)(coef[j])))), (((__int128)(MOD)))))))), (MOD));
j = (j + 1);
}
}
i2 = (i2 - 1);
}
int64_t i3 = 0;
while (i3 < d) {
pol[i3] = tmp[i3];
i3 = (i3 + 1);
}
free(((void*)(tmp)));
}
int64_t* tmp2 = (int64_t*)(((int64_t*)(calloc(((2 * d) - 1), 8))));
int64_t i = 0;
while (i < d) {
if (base[i] != 0) {
int64_t j = 0;
while (j < d) {
tmp2[(i + j)] = FLOW_CHECKED_MOD(((tmp2[(i + j)] + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(base[i])) * ((__int128)(base[j])))), (((__int128)(MOD)))))))), (MOD));
j = (j + 1);
}
}
i = (i + 1);
}
int64_t i2 = ((2 * d) - 2);
while (i2 >= d) {
int64_t t = tmp2[i2];
if (t != 0) {
int64_t j = 0;
while (j < d) {
tmp2[((i2 - 1) - j)] = FLOW_CHECKED_MOD(((tmp2[((i2 - 1) - j)] + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(t)) * ((__int128)(coef[j])))), (((__int128)(MOD)))))))), (MOD));
j = (j + 1);
}
}
i2 = (i2 - 1);
}
int64_t i3 = 0;
while (i3 < d) {
base[i3] = tmp2[i3];
i3 = (i3 + 1);
}
free(((void*)(tmp2)));
e = FLOW_CHECKED_DIV((e), (2));
}
int64_t ans = 0;
int64_t i = 0;
while (i < d) {
ans = FLOW_CHECKED_MOD(((ans + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(pol[i])) * ((__int128)(init[i])))), (((__int128)(MOD)))))))), (MOD));
i = (i + 1);
}
free(((void*)(pol)));
free(((void*)(base)));
return ans;
}
int64_t coeff_large_w_small_h_i64_i64_i64(int64_t w, int64_t h, int64_t y) {
int64_t** Pp = (int64_t**)(((int64_t**)(calloc(1, 8))));
int64_t* Pnp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t** Qp = (int64_t**)(((int64_t**)(calloc(1, 8))));
int64_t* Qnp = (int64_t*)(((int64_t*)(calloc(1, 8))));
build_PQ_mod_i64_i64_i64_ptr_ptr_i64_ptr_i64_ptr_ptr_i64_ptr_i64(h, y, h, Pp, Pnp, Qp, Qnp);
int64_t* P = (int64_t*)(Pp[0]);
int64_t Pn = Pnp[0];
int64_t* Q = (int64_t*)(Qp[0]);
int64_t Qn = Qnp[0];
free(((void*)(Pp)));
free(((void*)(Pnp)));
free(((void*)(Qp)));
free(((void*)(Qnp)));
int64_t* f = (int64_t*)(((int64_t*)(malloc(((h + 1) * 8)))));
int64_t n = 0;
while (n <= h) {
__int128 val = ((n < Pn) ? (((__int128)(P[n]))) : (0));
int64_t j = 1;
while ((j <= n && j < Qn)) {
val = (val - (((__int128)(Q[j])) * ((__int128)(f[(n - j)]))));
j = (j + 1);
}
int64_t vi = ((int64_t)(FLOW_CHECKED_MOD((val), (((__int128)(MOD))))));
if (vi < 0) {
vi = (vi + MOD);
}
f[n] = vi;
n = (n + 1);
}
if (w <= h) {
int64_t ans = f[w];
free(((void*)(P)));
free(((void*)(Q)));
free(((void*)(f)));
return ans;
}
int64_t* coef = (int64_t*)(((int64_t*)(malloc((h * 8)))));
int64_t i = 1;
while (i <= h) {
int64_t qv = ((i < Qn) ? (Q[i]) : (0));
coef[(i - 1)] = FLOW_CHECKED_MOD(((MOD - qv)), (MOD));
i = (i + 1);
}
int64_t* init = (int64_t*)(((int64_t*)(malloc((h * 8)))));
i = 0;
while (i < h) {
init[i] = f[(i + 1)];
i = (i + 1);
}
int64_t ans2 = kitamasa_ptr_i64_ptr_i64_i64_i64(init, coef, h, (w - 1));
free(((void*)(P)));
free(((void*)(Q)));
free(((void*)(f)));
free(((void*)(coef)));
free(((void*)(init)));
return ans2;
}
int64_t* poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t limit, int64_t* out_n) {
int64_t need = ((na + nb) - 1);
if (need > limit) {
need = limit;
}
int64_t* res = (int64_t*)(((int64_t*)(calloc(need, 8))));
int64_t i = 0;
while (i < na) {
if (a[i] != 0) {
int64_t j = 0;
while (j < nb) {
int64_t ij = (i + j);
if (ij >= limit) {
break;
}
res[ij] = FLOW_CHECKED_MOD(((res[ij] + ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(a[i])) * ((__int128)(b[j])))), (((__int128)(MOD)))))))), (MOD));
j = (j + 1);
}
}
i = (i + 1);
}
out_n[0] = need;
return res;
}
int64_t* poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(int64_t* a, int64_t na, int64_t* b, int64_t nb, int64_t limit) {
int64_t* res = (int64_t*)(((int64_t*)(calloc(limit, 8))));
int64_t i = 0;
while (i < limit) {
int64_t av = ((i < na) ? (a[i]) : (0));
int64_t bv = ((i < nb) ? (b[i]) : (0));
res[i] = FLOW_CHECKED_MOD(((av + bv)), (MOD));
i = (i + 1);
}
return res;
}
Mat mat_mul_Mat_Mat_i64(Mat A, Mat B, int64_t limit) {
int64_t* onp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* t1 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m00p, A.m00n, B.m00p, B.m00n, limit, onp));
int64_t n1 = onp[0];
int64_t* t2 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m01p, A.m01n, B.m10p, B.m10n, limit, onp));
int64_t n2 = onp[0];
int64_t* s00 = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t1, n1, t2, n2, limit));
free(((void*)(t1)));
free(((void*)(t2)));
int64_t* t3 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m00p, A.m00n, B.m01p, B.m01n, limit, onp));
int64_t n3 = onp[0];
int64_t* t4 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m01p, A.m01n, B.m11p, B.m11n, limit, onp));
int64_t n4 = onp[0];
int64_t* s01 = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t3, n3, t4, n4, limit));
free(((void*)(t3)));
free(((void*)(t4)));
int64_t* t5 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m10p, A.m10n, B.m00p, B.m00n, limit, onp));
int64_t n5 = onp[0];
int64_t* t6 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m11p, A.m11n, B.m10p, B.m10n, limit, onp));
int64_t n6 = onp[0];
int64_t* s10 = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t5, n5, t6, n6, limit));
free(((void*)(t5)));
free(((void*)(t6)));
int64_t* t7 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m10p, A.m10n, B.m01p, B.m01n, limit, onp));
int64_t n7 = onp[0];
int64_t* t8 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(A.m11p, A.m11n, B.m11p, B.m11n, limit, onp));
int64_t n8 = onp[0];
int64_t* s11 = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t7, n7, t8, n8, limit));
free(((void*)(t7)));
free(((void*)(t8)));
free(((void*)(onp)));
return (Mat){ .m00p = s00, .m00n = limit, .m01p = s01, .m01n = limit, .m10p = s10, .m10n = limit, .m11p = s11, .m11n = limit };
}
void mat_free_Mat(Mat M) {
free(((void*)(M.m00p)));
free(((void*)(M.m01p)));
free(((void*)(M.m10p)));
free(((void*)(M.m11p)));
}
Mat mat_pow_Mat_i64_i64(Mat M0, int64_t e0, int64_t limit) {
Mat I = (Mat){ .m00p = NULL, .m00n = 0, .m01p = NULL, .m01n = 0, .m10p = NULL, .m10n = 0, .m11p = NULL, .m11n = 0 };
int64_t* p00 = (int64_t*)(((int64_t*)(calloc(limit, 8))));
p00[0] = 1;
int64_t* p11 = (int64_t*)(((int64_t*)(calloc(limit, 8))));
p11[0] = 1;
int64_t* p01 = (int64_t*)(((int64_t*)(calloc(limit, 8))));
int64_t* p10 = (int64_t*)(((int64_t*)(calloc(limit, 8))));
I = (Mat){ .m00p = p00, .m00n = limit, .m01p = p01, .m01n = limit, .m10p = p10, .m10n = limit, .m11p = p11, .m11n = limit };
Mat base = M0;
bool base_owned = 0;
int64_t e = e0;
while (e != 0) {
if (FLOW_CHECKED_MOD((e), (2)) == 1) {
Mat nI = mat_mul_Mat_Mat_i64(I, base, limit);
mat_free_Mat(I);
I = nI;
}
Mat nB = mat_mul_Mat_Mat_i64(base, base, limit);
if (base_owned) {
mat_free_Mat(base);
}
base = nB;
base_owned = 1;
e = FLOW_CHECKED_DIV((e), (2));
}
if (base_owned) {
mat_free_Mat(base);
}
return I;
}
int64_t coeff_large_h_small_w_i64_i64_i64(int64_t w, int64_t h, int64_t y) {
if (h <= 0) {
return 0;
}
int64_t limit = (w + 1);
int64_t y_mod = ((y == 1) ? (1) : ((MOD - 1)));
int64_t* P = (int64_t*)(((int64_t*)(calloc(limit, 8))));
int64_t* Q = (int64_t*)(((int64_t*)(calloc(limit, 8))));
if (w >= 1) {
P[1] = y_mod;
Q[1] = (MOD - 1);
}
Q[0] = 1;
if (h == 1) {
int64_t ans = series_coeff_mod_ptr_i64_i64_ptr_i64_i64_i64(P, limit, Q, limit, w);
free(((void*)(P)));
free(((void*)(Q)));
return ans;
}
int64_t* y_one_plus_x = (int64_t*)(((int64_t*)(calloc(limit, 8))));
y_one_plus_x[0] = y_mod;
if (limit >= 2) {
y_one_plus_x[1] = y_mod;
}
int64_t* y_x = (int64_t*)(((int64_t*)(calloc(limit, 8))));
if (limit >= 2) {
y_x[1] = y_mod;
}
int64_t* minus_x = (int64_t*)(((int64_t*)(calloc(limit, 8))));
if (limit >= 2) {
minus_x[1] = (MOD - 1);
}
int64_t* one_minus_x = (int64_t*)(((int64_t*)(calloc(limit, 8))));
one_minus_x[0] = 1;
if (limit >= 2) {
one_minus_x[1] = (MOD - 1);
}
Mat A = (Mat){ .m00p = y_one_plus_x, .m00n = limit, .m01p = y_x, .m01n = limit, .m10p = minus_x, .m10n = limit, .m11p = one_minus_x, .m11n = limit };
Mat Mp = mat_pow_Mat_i64_i64(A, (h - 1), limit);
mat_free_Mat(A);
int64_t* onp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t* t1 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(Mp.m00p, limit, P, limit, limit, onp));
int64_t n1 = onp[0];
int64_t* t2 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(Mp.m01p, limit, Q, limit, limit, onp));
int64_t n2 = onp[0];
int64_t* Pn = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t1, n1, t2, n2, limit));
free(((void*)(t1)));
free(((void*)(t2)));
int64_t* t3 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(Mp.m10p, limit, P, limit, limit, onp));
int64_t n3 = onp[0];
int64_t* t4 = (int64_t*)(poly_mul_small_ptr_i64_i64_ptr_i64_i64_i64_ptr_i64(Mp.m11p, limit, Q, limit, limit, onp));
int64_t n4 = onp[0];
int64_t* Qn = (int64_t*)(poly_add_small_ptr_i64_i64_ptr_i64_i64_i64(t3, n3, t4, n4, limit));
free(((void*)(t3)));
free(((void*)(t4)));
free(((void*)(onp)));
mat_free_Mat(Mp);
free(((void*)(P)));
free(((void*)(Q)));
int64_t ans = series_coeff_mod_ptr_i64_i64_ptr_i64_i64_i64(Pn, limit, Qn, limit, w);
free(((void*)(Pn)));
free(((void*)(Qn)));
return ans;
}
int64_t coeff_C_mod_i64_i64_i64(int64_t w, int64_t h, int64_t y) {
if (h <= 0) {
return 0;
}
if ((w <= 200 && h > 2000)) {
return coeff_large_h_small_w_i64_i64_i64(w, h, y);
}
if ((h <= 200 && w > 2000)) {
return coeff_large_w_small_h_i64_i64_i64(w, h, y);
}
int64_t** Pp = (int64_t**)(((int64_t**)(calloc(1, 8))));
int64_t* Pnp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t** Qp = (int64_t**)(((int64_t**)(calloc(1, 8))));
int64_t* Qnp = (int64_t*)(((int64_t*)(calloc(1, 8))));
int64_t deg = w;
if (deg < 0) {
deg = 0;
}
build_PQ_mod_i64_i64_i64_ptr_ptr_i64_ptr_i64_ptr_ptr_i64_ptr_i64(h, y, deg, Pp, Pnp, Qp, Qnp);
int64_t* P = (int64_t*)(Pp[0]);
int64_t Pn = Pnp[0];
int64_t* Q = (int64_t*)(Qp[0]);
int64_t Qn = Qnp[0];
free(((void*)(Pp)));
free(((void*)(Pnp)));
free(((void*)(Qp)));
free(((void*)(Qnp)));
int64_t ans = series_coeff_mod_ptr_i64_i64_ptr_i64_i64_i64(P, Pn, Q, Qn, w);
free(((void*)(P)));
free(((void*)(Q)));
return ans;
}
int64_t E_leq_mod_i64_i64(int64_t w, int64_t h) {
if (h <= 0) {
return 0;
}
int64_t T = coeff_C_mod_i64_i64_i64(w, h, 1);
int64_t S = coeff_C_mod_i64_i64_i64(w, h, (-1));
return ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(FLOW_CHECKED_MOD(((T + S)), (MOD)))) * ((__int128)(INV2)))), (((__int128)(MOD))))));
}
int64_t F_mod_i64_i64(int64_t w, int64_t h) {
int64_t a = E_leq_mod_i64_i64(w, h);
int64_t b = E_leq_mod_i64_i64(w, (h - 1));
int64_t r = (a - b);
if (r < 0) {
r = (r + MOD);
}
return r;
}
int32_t main(void) {
int64_t a = F_mod_i64_i64(1000000000000, 100);
int64_t b = F_mod_i64_i64(10000, 10000);
int64_t c = F_mod_i64_i64(100, 1000000000000);
printf("%lld\n", FLOW_CHECKED_MOD((((a + b) + c)), (MOD)));
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 @gcd(%arg0: i64, %arg1: i64) -> i64 {
%0 = llvm.mlir.constant(1 : i64) : i64
%1 = llvm.alloca %0 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %1 : i64, !llvm.ptr
%2 = llvm.mlir.constant(1 : i64) : i64
%3 = llvm.alloca %2 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %3 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%4 = llvm.load %3 : !llvm.ptr -> i64
%5 = arith.constant 0 : i32
%7 = arith.extsi %5 : i32 to i64
%6 = arith.cmpi ne, %4, %7 : i64
cf.cond_br %6, ^bb1, ^bb2
^bb1:
%8 = llvm.load %1 : !llvm.ptr -> i64
%9 = llvm.load %3 : !llvm.ptr -> i64
%10 = arith.remsi %8, %9 : i64
%11 = llvm.load %3 : !llvm.ptr -> i64
llvm.store %11, %1 : i64, !llvm.ptr
llvm.store %10, %3 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
%12 = llvm.load %1 : !llvm.ptr -> i64
func.return %12 : i64
}
func.func @lcm(%arg0: i64, %arg1: i64) -> i64 {
%13 = arith.constant 0 : i32
%15 = arith.extsi %13 : i32 to i64
%14 = arith.cmpi eq, %arg0, %15 : i64
%16 = scf.if %14 -> (i1) {
%17 = arith.constant true
scf.yield %17 : i1
} else {
%18 = arith.constant 0 : i32
%20 = arith.extsi %18 : i32 to i64
%19 = arith.cmpi eq, %arg1, %20 : i64
scf.yield %19 : i1
}
cf.cond_br %16, ^bb3, ^bb4
^bb3:
%21 = arith.constant 0 : i32
%22 = arith.extsi %21 : i32 to i64
func.return %22 : i64
^bb4:
cf.br ^bb5
^bb5:
%23 = func.call @gcd(%arg0, %arg1) : (i64, i64) -> i64
%24 = arith.divsi %arg0, %23 : i64
%25 = arith.muli %24, %arg1 : i64
func.return %25 : i64
}
func.func @isqrt(%arg0: i64) -> i64 {
%26 = arith.constant 2 : i32
%28 = arith.extsi %26 : i32 to i64
%27 = arith.cmpi slt, %arg0, %28 : i64
cf.cond_br %27, ^bb6, ^bb7
^bb6:
func.return %arg0 : i64
^bb7:
cf.br ^bb8
^bb8:
%29 = llvm.mlir.constant(1 : i64) : i64
%30 = llvm.alloca %29 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %30 : i64, !llvm.ptr
%31 = llvm.load %30 : !llvm.ptr -> i64
%32 = arith.constant 1 : i32
%34 = arith.extsi %32 : i32 to i64
%33 = arith.addi %31, %34 : i64
%35 = arith.constant 2 : i32
%37 = arith.extsi %35 : i32 to i64
%36 = arith.divsi %33, %37 : i64
%38 = llvm.mlir.constant(1 : i64) : i64
%39 = llvm.alloca %38 x i64 : (i64) -> !llvm.ptr
llvm.store %36, %39 : i64, !llvm.ptr
cf.br ^bb9
^bb9:
%40 = llvm.load %39 : !llvm.ptr -> i64
%41 = llvm.load %30 : !llvm.ptr -> i64
%42 = arith.cmpi slt, %40, %41 : i64
cf.cond_br %42, ^bb10, ^bb11
^bb10:
%43 = llvm.load %39 : !llvm.ptr -> i64
llvm.store %43, %30 : i64, !llvm.ptr
%44 = llvm.load %30 : !llvm.ptr -> i64
%45 = llvm.load %30 : !llvm.ptr -> i64
%46 = arith.divsi %arg0, %45 : i64
%47 = arith.addi %44, %46 : i64
%48 = arith.constant 2 : i32
%50 = arith.extsi %48 : i32 to i64
%49 = arith.divsi %47, %50 : i64
llvm.store %49, %39 : i64, !llvm.ptr
cf.br ^bb9
^bb11:
%51 = llvm.load %30 : !llvm.ptr -> i64
func.return %51 : i64
}
func.func @mulmod(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%52 = arith.remsi %arg0, %arg2 : i64
%53 = llvm.mlir.constant(1 : i64) : i64
%54 = llvm.alloca %53 x i64 : (i64) -> !llvm.ptr
llvm.store %52, %54 : i64, !llvm.ptr
%55 = arith.remsi %arg1, %arg2 : i64
%56 = llvm.mlir.constant(1 : i64) : i64
%57 = llvm.alloca %56 x i64 : (i64) -> !llvm.ptr
llvm.store %55, %57 : i64, !llvm.ptr
%58 = arith.constant 0 : i32
%59 = arith.extsi %58 : i32 to i64
%60 = llvm.mlir.constant(1 : i64) : i64
%61 = llvm.alloca %60 x i64 : (i64) -> !llvm.ptr
llvm.store %59, %61 : i64, !llvm.ptr
cf.br ^bb12
^bb12:
%62 = llvm.load %57 : !llvm.ptr -> i64
%63 = arith.constant 0 : i32
%65 = arith.extsi %63 : i32 to i64
%64 = arith.cmpi sgt, %62, %65 : i64
cf.cond_br %64, ^bb13, ^bb14
^bb13:
%66 = llvm.load %57 : !llvm.ptr -> i64
%67 = arith.constant 2 : i32
%69 = arith.extsi %67 : i32 to i64
%68 = arith.remsi %66, %69 : i64
%70 = arith.constant 1 : i32
%72 = arith.extsi %70 : i32 to i64
%71 = arith.cmpi eq, %68, %72 : i64
cf.cond_br %71, ^bb15, ^bb16
^bb15:
%73 = llvm.load %61 : !llvm.ptr -> i64
%74 = llvm.load %54 : !llvm.ptr -> i64
%75 = arith.addi %73, %74 : i64
%76 = arith.remsi %75, %arg2 : i64
llvm.store %76, %61 : i64, !llvm.ptr
cf.br ^bb17
^bb16:
cf.br ^bb17
^bb17:
%77 = llvm.load %54 : !llvm.ptr -> i64
%78 = arith.constant 2 : i32
%80 = arith.extsi %78 : i32 to i64
%79 = arith.muli %77, %80 : i64
%81 = arith.remsi %79, %arg2 : i64
llvm.store %81, %54 : i64, !llvm.ptr
%82 = llvm.load %57 : !llvm.ptr -> i64
%83 = arith.constant 2 : i32
%85 = arith.extsi %83 : i32 to i64
%84 = arith.divsi %82, %85 : i64
llvm.store %84, %57 : i64, !llvm.ptr
cf.br ^bb12
^bb14:
%86 = llvm.load %61 : !llvm.ptr -> i64
func.return %86 : i64
}
func.func @mod_pow(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%87 = arith.constant 1 : i32
%89 = arith.extsi %87 : i32 to i64
%88 = arith.cmpi eq, %arg2, %89 : i64
cf.cond_br %88, ^bb18, ^bb19
^bb18:
%90 = arith.constant 0 : i32
%91 = arith.extsi %90 : i32 to i64
func.return %91 : i64
^bb19:
cf.br ^bb20
^bb20:
%92 = arith.constant 1 : i32
%93 = arith.extsi %92 : i32 to i64
%94 = llvm.mlir.constant(1 : i64) : i64
%95 = llvm.alloca %94 x i64 : (i64) -> !llvm.ptr
llvm.store %93, %95 : i64, !llvm.ptr
%96 = arith.remsi %arg0, %arg2 : i64
%97 = llvm.mlir.constant(1 : i64) : i64
%98 = llvm.alloca %97 x i64 : (i64) -> !llvm.ptr
llvm.store %96, %98 : i64, !llvm.ptr
%99 = llvm.mlir.constant(1 : i64) : i64
%100 = llvm.alloca %99 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %100 : i64, !llvm.ptr
cf.br ^bb21
^bb21:
%101 = llvm.load %100 : !llvm.ptr -> i64
%102 = arith.constant 0 : i32
%104 = arith.extsi %102 : i32 to i64
%103 = arith.cmpi sgt, %101, %104 : i64
cf.cond_br %103, ^bb22, ^bb23
^bb22:
%105 = llvm.load %100 : !llvm.ptr -> i64
%106 = arith.constant 2 : i32
%108 = arith.extsi %106 : i32 to i64
%107 = arith.remsi %105, %108 : i64
%109 = arith.constant 1 : i32
%111 = arith.extsi %109 : i32 to i64
%110 = arith.cmpi eq, %107, %111 : i64
cf.cond_br %110, ^bb24, ^bb25
^bb24:
%113 = llvm.load %95 : !llvm.ptr -> i64
%114 = llvm.load %98 : !llvm.ptr -> i64
%112 = func.call @mulmod(%113, %114, %arg2) : (i64, i64, i64) -> i64
llvm.store %112, %95 : i64, !llvm.ptr
cf.br ^bb26
^bb25:
cf.br ^bb26
^bb26:
%116 = llvm.load %98 : !llvm.ptr -> i64
%117 = llvm.load %98 : !llvm.ptr -> i64
%115 = func.call @mulmod(%116, %117, %arg2) : (i64, i64, i64) -> i64
llvm.store %115, %98 : i64, !llvm.ptr
%118 = llvm.load %100 : !llvm.ptr -> i64
%119 = arith.constant 2 : i32
%121 = arith.extsi %119 : i32 to i64
%120 = arith.divsi %118, %121 : i64
llvm.store %120, %100 : i64, !llvm.ptr
cf.br ^bb21
^bb23:
%122 = llvm.load %95 : !llvm.ptr -> i64
func.return %122 : i64
}
func.func @is_prime(%arg0: i64) -> i1 {
%123 = arith.constant 2 : i32
%125 = arith.extsi %123 : i32 to i64
%124 = arith.cmpi slt, %arg0, %125 : i64
cf.cond_br %124, ^bb27, ^bb28
^bb27:
%126 = arith.constant 0 : i1
func.return %126 : i1
^bb28:
cf.br ^bb29
^bb29:
%127 = arith.constant 4 : i32
%129 = arith.extsi %127 : i32 to i64
%128 = arith.cmpi slt, %arg0, %129 : i64
cf.cond_br %128, ^bb30, ^bb31
^bb30:
%130 = arith.constant 1 : i1
func.return %130 : i1
^bb31:
cf.br ^bb32
^bb32:
%131 = arith.constant 2 : i32
%133 = arith.extsi %131 : i32 to i64
%132 = arith.remsi %arg0, %133 : i64
%134 = arith.constant 0 : i32
%136 = arith.extsi %134 : i32 to i64
%135 = arith.cmpi eq, %132, %136 : i64
%137 = scf.if %135 -> (i1) {
%138 = arith.constant true
scf.yield %138 : i1
} else {
%139 = arith.constant 3 : i32
%141 = arith.extsi %139 : i32 to i64
%140 = arith.remsi %arg0, %141 : i64
%142 = arith.constant 0 : i32
%144 = arith.extsi %142 : i32 to i64
%143 = arith.cmpi eq, %140, %144 : i64
scf.yield %143 : i1
}
cf.cond_br %137, ^bb33, ^bb34
^bb33:
%145 = arith.constant 0 : i1
func.return %145 : i1
^bb34:
cf.br ^bb35
^bb35:
%146 = arith.constant 5 : i32
%147 = arith.extsi %146 : i32 to i64
%148 = llvm.mlir.constant(1 : i64) : i64
%149 = llvm.alloca %148 x i64 : (i64) -> !llvm.ptr
llvm.store %147, %149 : i64, !llvm.ptr
cf.br ^bb36
^bb36:
%150 = llvm.load %149 : !llvm.ptr -> i64
%151 = llvm.load %149 : !llvm.ptr -> i64
%152 = arith.muli %150, %151 : i64
%153 = arith.cmpi sle, %152, %arg0 : i64
cf.cond_br %153, ^bb37, ^bb38
^bb37:
%154 = llvm.load %149 : !llvm.ptr -> i64
%155 = arith.remsi %arg0, %154 : i64
%156 = arith.constant 0 : i32
%158 = arith.extsi %156 : i32 to i64
%157 = arith.cmpi eq, %155, %158 : i64
%159 = scf.if %157 -> (i1) {
%160 = arith.constant true
scf.yield %160 : i1
} else {
%161 = llvm.load %149 : !llvm.ptr -> i64
%162 = arith.constant 2 : i32
%164 = arith.extsi %162 : i32 to i64
%163 = arith.addi %161, %164 : i64
%165 = arith.remsi %arg0, %163 : i64
%166 = arith.constant 0 : i32
%168 = arith.extsi %166 : i32 to i64
%167 = arith.cmpi eq, %165, %168 : i64
scf.yield %167 : i1
}
cf.cond_br %159, ^bb39, ^bb40
^bb39:
%169 = arith.constant 0 : i1
func.return %169 : i1
^bb40:
cf.br ^bb41
^bb41:
%170 = llvm.load %149 : !llvm.ptr -> i64
%171 = arith.constant 6 : i32
%173 = arith.extsi %171 : i32 to i64
%172 = arith.addi %170, %173 : i64
llvm.store %172, %149 : i64, !llvm.ptr
cf.br ^bb36
^bb38:
%174 = arith.constant 1 : i1
func.return %174 : i1
}
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @malloc(i64) -> !llvm.ptr
// Constant: MOD
llvm.mlir.global internal constant @MOD(1000000007 : i64) : i64
// Constant: INV2
llvm.mlir.global internal constant @INV2(500000004 : i64) : i64
// Constant: P1
llvm.mlir.global internal constant @P1(998244353 : i64) : i64
// Constant: P2
llvm.mlir.global internal constant @P2(1004535809 : i64) : i64
// Constant: P3
llvm.mlir.global internal constant @P3(469762049 : i64) : i64
// Module static: g_inv_p1_mod_p2
llvm.mlir.global internal @g_inv_p1_mod_p2(0 : i64) : i64
// Module static: g_inv_p12_mod_p3
llvm.mlir.global internal @g_inv_p12_mod_p3(0 : i64) : i64
// Module static: g_P12_lo
llvm.mlir.global internal @g_P12_lo(0 : i64) : i64
// Module static: g_P12_hi
llvm.mlir.global internal @g_P12_hi(0 : i64) : i64
func.func @mod_inv(%arg0: i64, %arg1: i64) -> i64 {
%176 = arith.constant 2 : i32
%178 = arith.extsi %176 : i32 to i64
%177 = arith.subi %arg1, %178 : i64
%175 = func.call @mod_pow(%arg0, %177, %arg1) : (i64, i64, i64) -> i64
func.return %175 : i64
}
func.func @ntt(%arg0: !llvm.ptr, %arg1: i64, %arg2: i32, %arg3: i64, %arg4: i64) -> () {
%179 = arith.constant 0 : i32
%180 = arith.extsi %179 : i32 to i64
%181 = llvm.mlir.constant(1 : i64) : i64
%182 = llvm.alloca %181 x i64 : (i64) -> !llvm.ptr
llvm.store %180, %182 : i64, !llvm.ptr
%183 = arith.constant 1 : i32
%184 = arith.extsi %183 : i32 to i64
%185 = llvm.mlir.constant(1 : i64) : i64
%186 = llvm.alloca %185 x i64 : (i64) -> !llvm.ptr
llvm.store %184, %186 : i64, !llvm.ptr
cf.br ^bb42
^bb42:
%187 = llvm.load %186 : !llvm.ptr -> i64
%188 = arith.cmpi slt, %187, %arg1 : i64
cf.cond_br %188, ^bb43, ^bb44
^bb43:
%189 = arith.constant 1 : i32
%191 = arith.extsi %189 : i32 to i64
%190 = arith.shrsi %arg1, %191 : i64
%192 = llvm.mlir.constant(1 : i64) : i64
%193 = llvm.alloca %192 x i64 : (i64) -> !llvm.ptr
llvm.store %190, %193 : i64, !llvm.ptr
cf.br ^bb45
^bb45:
%194 = llvm.load %182 : !llvm.ptr -> i64
%195 = llvm.load %193 : !llvm.ptr -> i64
%196 = arith.andi %194, %195 : i64
%197 = arith.constant 0 : i32
%199 = arith.extsi %197 : i32 to i64
%198 = arith.cmpi ne, %196, %199 : i64
cf.cond_br %198, ^bb46, ^bb47
^bb46:
%200 = llvm.load %182 : !llvm.ptr -> i64
%201 = llvm.load %193 : !llvm.ptr -> i64
%202 = arith.xori %200, %201 : i64
llvm.store %202, %182 : i64, !llvm.ptr
%203 = llvm.load %193 : !llvm.ptr -> i64
%204 = arith.constant 1 : i32
%206 = arith.extsi %204 : i32 to i64
%205 = arith.shrsi %203, %206 : i64
llvm.store %205, %193 : i64, !llvm.ptr
cf.br ^bb45
^bb47:
%207 = llvm.load %182 : !llvm.ptr -> i64
%208 = llvm.load %193 : !llvm.ptr -> i64
%209 = arith.xori %207, %208 : i64
llvm.store %209, %182 : i64, !llvm.ptr
%210 = llvm.load %186 : !llvm.ptr -> i64
%211 = llvm.load %182 : !llvm.ptr -> i64
%212 = arith.cmpi slt, %210, %211 : i64
cf.cond_br %212, ^bb48, ^bb49
^bb48:
%214 = llvm.load %186 : !llvm.ptr -> i64
%215 = llvm.getelementptr %arg0[%214] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%213 = llvm.load %215 : !llvm.ptr -> i64
%217 = llvm.load %182 : !llvm.ptr -> i64
%218 = llvm.getelementptr %arg0[%217] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%216 = llvm.load %218 : !llvm.ptr -> i64
%219 = llvm.load %186 : !llvm.ptr -> i64
%220 = llvm.getelementptr %arg0[%219] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %216, %220 : i64, !llvm.ptr
%221 = llvm.load %182 : !llvm.ptr -> i64
%222 = llvm.getelementptr %arg0[%221] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %213, %222 : i64, !llvm.ptr
cf.br ^bb50
^bb49:
cf.br ^bb50
^bb50:
%223 = llvm.load %186 : !llvm.ptr -> i64
%224 = arith.constant 1 : i32
%226 = arith.extsi %224 : i32 to i64
%225 = arith.addi %223, %226 : i64
llvm.store %225, %186 : i64, !llvm.ptr
cf.br ^bb42
^bb44:
%227 = arith.constant 2 : i32
%228 = arith.extsi %227 : i32 to i64
%229 = llvm.mlir.constant(1 : i64) : i64
%230 = llvm.alloca %229 x i64 : (i64) -> !llvm.ptr
llvm.store %228, %230 : i64, !llvm.ptr
cf.br ^bb51
^bb51:
%231 = llvm.load %230 : !llvm.ptr -> i64
%232 = arith.cmpi sle, %231, %arg1 : i64
cf.cond_br %232, ^bb52, ^bb53
^bb52:
%234 = arith.constant 1 : i32
%236 = arith.extsi %234 : i32 to i64
%235 = arith.subi %arg3, %236 : i64
%237 = llvm.load %230 : !llvm.ptr -> i64
%238 = arith.divsi %235, %237 : i64
%233 = func.call @mod_pow(%arg4, %238, %arg3) : (i64, i64, i64) -> i64
%239 = llvm.mlir.constant(1 : i64) : i64
%240 = llvm.alloca %239 x i64 : (i64) -> !llvm.ptr
llvm.store %233, %240 : i64, !llvm.ptr
%241 = arith.constant 1 : i32
%242 = arith.cmpi eq, %arg2, %241 : i32
cf.cond_br %242, ^bb54, ^bb55
^bb54:
%244 = arith.constant 2 : i32
%246 = arith.extsi %244 : i32 to i64
%245 = arith.subi %arg3, %246 : i64
%243 = func.call @mod_pow(%233, %245, %arg3) : (i64, i64, i64) -> i64
llvm.store %243, %240 : i64, !llvm.ptr
cf.br ^bb56
^bb55:
cf.br ^bb56
^bb56:
%247 = llvm.load %230 : !llvm.ptr -> i64
%248 = arith.constant 1 : i32
%250 = arith.extsi %248 : i32 to i64
%249 = arith.shrsi %247, %250 : i64
%251 = arith.constant 0 : i32
%252 = arith.extsi %251 : i32 to i64
llvm.store %252, %186 : i64, !llvm.ptr
cf.br ^bb57
^bb57:
%253 = llvm.load %186 : !llvm.ptr -> i64
%254 = arith.cmpi slt, %253, %arg1 : i64
cf.cond_br %254, ^bb58, ^bb59
^bb58:
%255 = arith.constant 1 : i32
%256 = arith.extsi %255 : i32 to i64
%257 = llvm.mlir.constant(1 : i64) : i64
%258 = llvm.alloca %257 x i64 : (i64) -> !llvm.ptr
llvm.store %256, %258 : i64, !llvm.ptr
%259 = arith.constant 0 : i32
%260 = arith.extsi %259 : i32 to i64
%261 = llvm.mlir.constant(1 : i64) : i64
%262 = llvm.alloca %261 x i64 : (i64) -> !llvm.ptr
llvm.store %260, %262 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%263 = llvm.load %262 : !llvm.ptr -> i64
%264 = arith.cmpi slt, %263, %249 : i64
cf.cond_br %264, ^bb61, ^bb62
^bb61:
%266 = llvm.load %186 : !llvm.ptr -> i64
%267 = llvm.load %262 : !llvm.ptr -> i64
%268 = arith.addi %266, %267 : i64
%269 = llvm.getelementptr %arg0[%268] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%265 = llvm.load %269 : !llvm.ptr -> i64
%271 = llvm.load %186 : !llvm.ptr -> i64
%272 = llvm.load %262 : !llvm.ptr -> i64
%273 = arith.addi %271, %272 : i64
%274 = arith.addi %273, %249 : i64
%275 = llvm.getelementptr %arg0[%274] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%270 = llvm.load %275 : !llvm.ptr -> i64
%276 = arith.extsi %270 : i64 to i128
%277 = llvm.load %258 : !llvm.ptr -> i64
%278 = arith.extsi %277 : i64 to i128
%280 = arith.trunci %276 : i128 to i64
%281 = arith.trunci %278 : i128 to i64
%279 = arith.muli %280, %281 : i64
%282 = arith.extsi %arg3 : i64 to i128
%284 = arith.trunci %282 : i128 to i64
%283 = arith.remsi %279, %284 : i64
%285 = arith.addi %265, %283 : i64
%286 = llvm.mlir.constant(1 : i64) : i64
%287 = llvm.alloca %286 x i64 : (i64) -> !llvm.ptr
llvm.store %285, %287 : i64, !llvm.ptr
%288 = llvm.load %287 : !llvm.ptr -> i64
%289 = arith.cmpi sge, %288, %arg3 : i64
cf.cond_br %289, ^bb63, ^bb64
^bb63:
%290 = llvm.load %287 : !llvm.ptr -> i64
%291 = arith.subi %290, %arg3 : i64
llvm.store %291, %287 : i64, !llvm.ptr
cf.br ^bb65
^bb64:
cf.br ^bb65
^bb65:
%292 = arith.subi %265, %283 : i64
%293 = llvm.mlir.constant(1 : i64) : i64
%294 = llvm.alloca %293 x i64 : (i64) -> !llvm.ptr
llvm.store %292, %294 : i64, !llvm.ptr
%295 = llvm.load %294 : !llvm.ptr -> i64
%296 = arith.constant 0 : i32
%298 = arith.extsi %296 : i32 to i64
%297 = arith.cmpi slt, %295, %298 : i64
cf.cond_br %297, ^bb66, ^bb67
^bb66:
%299 = llvm.load %294 : !llvm.ptr -> i64
%300 = arith.addi %299, %arg3 : i64
llvm.store %300, %294 : i64, !llvm.ptr
cf.br ^bb68
^bb67:
cf.br ^bb68
^bb68:
%301 = llvm.load %287 : !llvm.ptr -> i64
%302 = llvm.load %186 : !llvm.ptr -> i64
%303 = llvm.load %262 : !llvm.ptr -> i64
%304 = arith.addi %302, %303 : i64
%305 = llvm.getelementptr %arg0[%304] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %301, %305 : i64, !llvm.ptr
%306 = llvm.load %294 : !llvm.ptr -> i64
%307 = llvm.load %186 : !llvm.ptr -> i64
%308 = llvm.load %262 : !llvm.ptr -> i64
%309 = arith.addi %307, %308 : i64
%310 = arith.addi %309, %249 : i64
%311 = llvm.getelementptr %arg0[%310] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %306, %311 : i64, !llvm.ptr
%312 = llvm.load %258 : !llvm.ptr -> i64
%313 = arith.extsi %312 : i64 to i128
%314 = llvm.load %240 : !llvm.ptr -> i64
%315 = arith.extsi %314 : i64 to i128
%317 = arith.trunci %313 : i128 to i64
%318 = arith.trunci %315 : i128 to i64
%316 = arith.muli %317, %318 : i64
%319 = arith.extsi %arg3 : i64 to i128
%321 = arith.trunci %319 : i128 to i64
%320 = arith.remsi %316, %321 : i64
llvm.store %320, %258 : i64, !llvm.ptr
%322 = llvm.load %262 : !llvm.ptr -> i64
%323 = arith.constant 1 : i32
%325 = arith.extsi %323 : i32 to i64
%324 = arith.addi %322, %325 : i64
llvm.store %324, %262 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%326 = llvm.load %186 : !llvm.ptr -> i64
%327 = llvm.load %230 : !llvm.ptr -> i64
%328 = arith.addi %326, %327 : i64
llvm.store %328, %186 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
%329 = llvm.load %230 : !llvm.ptr -> i64
%330 = arith.constant 1 : i32
%332 = arith.extsi %330 : i32 to i64
%331 = arith.shli %329, %332 : i64
llvm.store %331, %230 : i64, !llvm.ptr
cf.br ^bb51
^bb53:
%333 = arith.constant 1 : i32
%334 = arith.cmpi eq, %arg2, %333 : i32
cf.cond_br %334, ^bb69, ^bb70
^bb69:
%336 = arith.constant 2 : i32
%338 = arith.extsi %336 : i32 to i64
%337 = arith.subi %arg3, %338 : i64
%335 = func.call @mod_pow(%arg1, %337, %arg3) : (i64, i64, i64) -> i64
%339 = arith.constant 0 : i32
%340 = arith.extsi %339 : i32 to i64
llvm.store %340, %186 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%341 = llvm.load %186 : !llvm.ptr -> i64
%342 = arith.cmpi slt, %341, %arg1 : i64
cf.cond_br %342, ^bb73, ^bb74
^bb73:
%344 = llvm.load %186 : !llvm.ptr -> i64
%345 = llvm.getelementptr %arg0[%344] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%343 = llvm.load %345 : !llvm.ptr -> i64
%346 = arith.extsi %343 : i64 to i128
%347 = arith.extsi %335 : i64 to i128
%349 = arith.trunci %346 : i128 to i64
%350 = arith.trunci %347 : i128 to i64
%348 = arith.muli %349, %350 : i64
%351 = arith.extsi %arg3 : i64 to i128
%353 = arith.trunci %351 : i128 to i64
%352 = arith.remsi %348, %353 : i64
%354 = llvm.load %186 : !llvm.ptr -> i64
%355 = llvm.getelementptr %arg0[%354] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %352, %355 : i64, !llvm.ptr
%356 = llvm.load %186 : !llvm.ptr -> i64
%357 = arith.constant 1 : i32
%359 = arith.extsi %357 : i32 to i64
%358 = arith.addi %356, %359 : i64
llvm.store %358, %186 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
cf.br ^bb71
^bb70:
cf.br ^bb71
^bb71:
func.return
}
func.func @convolve_one(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: !llvm.ptr) -> !llvm.ptr {
%360 = arith.addi %arg1, %arg3 : i64
%361 = arith.constant 1 : i32
%363 = arith.extsi %361 : i32 to i64
%362 = arith.subi %360, %363 : i64
%364 = arith.constant 1 : i32
%365 = arith.extsi %364 : i32 to i64
%366 = llvm.mlir.constant(1 : i64) : i64
%367 = llvm.alloca %366 x i64 : (i64) -> !llvm.ptr
llvm.store %365, %367 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%368 = llvm.load %367 : !llvm.ptr -> i64
%369 = arith.cmpi slt, %368, %362 : i64
cf.cond_br %369, ^bb76, ^bb77
^bb76:
%370 = llvm.load %367 : !llvm.ptr -> i64
%371 = arith.constant 1 : i32
%373 = arith.extsi %371 : i32 to i64
%372 = arith.shli %370, %373 : i64
llvm.store %372, %367 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
%375 = llvm.load %367 : !llvm.ptr -> i64
%376 = arith.constant 8 : i32
%377 = arith.extsi %376 : i32 to i64
%374 = func.call @calloc(%375, %377) : (i64, i64) -> !llvm.ptr
%379 = llvm.load %367 : !llvm.ptr -> i64
%380 = arith.constant 8 : i32
%381 = arith.extsi %380 : i32 to i64
%378 = func.call @calloc(%379, %381) : (i64, i64) -> !llvm.ptr
%382 = arith.constant 0 : i32
%383 = arith.extsi %382 : i32 to i64
%384 = llvm.mlir.constant(1 : i64) : i64
%385 = llvm.alloca %384 x i64 : (i64) -> !llvm.ptr
llvm.store %383, %385 : i64, !llvm.ptr
cf.br ^bb78
^bb78:
%386 = llvm.load %385 : !llvm.ptr -> i64
%387 = arith.cmpi slt, %386, %arg1 : i64
cf.cond_br %387, ^bb79, ^bb80
^bb79:
%389 = llvm.load %385 : !llvm.ptr -> i64
%390 = llvm.getelementptr %arg0[%389] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%388 = llvm.load %390 : !llvm.ptr -> i64
%391 = arith.remsi %388, %arg4 : i64
%392 = llvm.load %385 : !llvm.ptr -> i64
%393 = llvm.getelementptr %374[%392] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %391, %393 : i64, !llvm.ptr
%394 = llvm.load %385 : !llvm.ptr -> i64
%395 = arith.constant 1 : i32
%397 = arith.extsi %395 : i32 to i64
%396 = arith.addi %394, %397 : i64
llvm.store %396, %385 : i64, !llvm.ptr
cf.br ^bb78
^bb80:
%398 = arith.constant 0 : i32
%399 = arith.extsi %398 : i32 to i64
llvm.store %399, %385 : i64, !llvm.ptr
cf.br ^bb81
^bb81:
%400 = llvm.load %385 : !llvm.ptr -> i64
%401 = arith.cmpi slt, %400, %arg3 : i64
cf.cond_br %401, ^bb82, ^bb83
^bb82:
%403 = llvm.load %385 : !llvm.ptr -> i64
%404 = llvm.getelementptr %arg2[%403] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%402 = llvm.load %404 : !llvm.ptr -> i64
%405 = arith.remsi %402, %arg4 : i64
%406 = llvm.load %385 : !llvm.ptr -> i64
%407 = llvm.getelementptr %378[%406] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %405, %407 : i64, !llvm.ptr
%408 = llvm.load %385 : !llvm.ptr -> i64
%409 = arith.constant 1 : i32
%411 = arith.extsi %409 : i32 to i64
%410 = arith.addi %408, %411 : i64
llvm.store %410, %385 : i64, !llvm.ptr
cf.br ^bb81
^bb83:
%413 = llvm.load %367 : !llvm.ptr -> i64
%414 = arith.constant 0 : i32
func.call @ntt(%374, %413, %414, %arg4, %arg5) : (!llvm.ptr, i64, i32, i64, i64) -> ()
%416 = llvm.load %367 : !llvm.ptr -> i64
%417 = arith.constant 0 : i32
func.call @ntt(%378, %416, %417, %arg4, %arg5) : (!llvm.ptr, i64, i32, i64, i64) -> ()
%418 = arith.constant 0 : i32
%419 = arith.extsi %418 : i32 to i64
llvm.store %419, %385 : i64, !llvm.ptr
cf.br ^bb84
^bb84:
%420 = llvm.load %385 : !llvm.ptr -> i64
%421 = llvm.load %367 : !llvm.ptr -> i64
%422 = arith.cmpi slt, %420, %421 : i64
cf.cond_br %422, ^bb85, ^bb86
^bb85:
%424 = llvm.load %385 : !llvm.ptr -> i64
%425 = llvm.getelementptr %374[%424] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%423 = llvm.load %425 : !llvm.ptr -> i64
%426 = arith.extsi %423 : i64 to i128
%428 = llvm.load %385 : !llvm.ptr -> i64
%429 = llvm.getelementptr %378[%428] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%427 = llvm.load %429 : !llvm.ptr -> i64
%430 = arith.extsi %427 : i64 to i128
%432 = arith.trunci %426 : i128 to i64
%433 = arith.trunci %430 : i128 to i64
%431 = arith.muli %432, %433 : i64
%434 = arith.extsi %arg4 : i64 to i128
%436 = arith.trunci %434 : i128 to i64
%435 = arith.remsi %431, %436 : i64
%437 = llvm.load %385 : !llvm.ptr -> i64
%438 = llvm.getelementptr %374[%437] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %435, %438 : i64, !llvm.ptr
%439 = llvm.load %385 : !llvm.ptr -> i64
%440 = arith.constant 1 : i32
%442 = arith.extsi %440 : i32 to i64
%441 = arith.addi %439, %442 : i64
llvm.store %441, %385 : i64, !llvm.ptr
cf.br ^bb84
^bb86:
%444 = llvm.load %367 : !llvm.ptr -> i64
%445 = arith.constant 1 : i32
func.call @ntt(%374, %444, %445, %arg4, %arg5) : (!llvm.ptr, i64, i32, i64, i64) -> ()
%446 = arith.constant 0 : i32
%447 = arith.extsi %446 : i32 to i64
%448 = llvm.getelementptr %arg6[%447] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %362, %448 : i64, !llvm.ptr
%450 = arith.constant 8 : i32
%452 = arith.extsi %450 : i32 to i64
%451 = arith.muli %362, %452 : i64
%449 = func.call @malloc(%451) : (i64) -> !llvm.ptr
%453 = arith.constant 0 : i32
%454 = arith.extsi %453 : i32 to i64
llvm.store %454, %385 : i64, !llvm.ptr
cf.br ^bb87
^bb87:
%455 = llvm.load %385 : !llvm.ptr -> i64
%456 = arith.cmpi slt, %455, %362 : i64
cf.cond_br %456, ^bb88, ^bb89
^bb88:
%458 = llvm.load %385 : !llvm.ptr -> i64
%459 = llvm.getelementptr %374[%458] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%457 = llvm.load %459 : !llvm.ptr -> i64
%460 = llvm.load %385 : !llvm.ptr -> i64
%461 = llvm.getelementptr %449[%460] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %457, %461 : i64, !llvm.ptr
%462 = llvm.load %385 : !llvm.ptr -> i64
%463 = arith.constant 1 : i32
%465 = arith.extsi %463 : i32 to i64
%464 = arith.addi %462, %465 : i64
llvm.store %464, %385 : i64, !llvm.ptr
cf.br ^bb87
^bb89:
func.call @free(%374) : (!llvm.ptr) -> ()
func.call @free(%378) : (!llvm.ptr) -> ()
func.return %449 : !llvm.ptr
}
func.func @crt3(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%468 = llvm.mlir.addressof @g_inv_p1_mod_p2 : !llvm.ptr
%469 = llvm.load %468 : !llvm.ptr -> i64
%470 = arith.constant 0 : i32
%472 = arith.extsi %470 : i32 to i64
%471 = arith.cmpi slt, %469, %472 : i64
cf.cond_br %471, ^bb90, ^bb91
^bb90:
%474 = llvm.mlir.addressof @P1 : !llvm.ptr
%475 = llvm.load %474 : !llvm.ptr -> i64
%476 = llvm.mlir.addressof @P2 : !llvm.ptr
%477 = llvm.load %476 : !llvm.ptr -> i64
%478 = arith.remsi %475, %477 : i64
%479 = llvm.mlir.addressof @P2 : !llvm.ptr
%480 = llvm.load %479 : !llvm.ptr -> i64
%473 = func.call @mod_inv(%478, %480) : (i64, i64) -> i64
%481 = llvm.mlir.addressof @g_inv_p1_mod_p2 : !llvm.ptr
llvm.store %473, %481 : i64, !llvm.ptr
%482 = llvm.mlir.addressof @P1 : !llvm.ptr
%483 = llvm.load %482 : !llvm.ptr -> i64
%484 = arith.extsi %483 : i64 to i128
%485 = llvm.mlir.addressof @P2 : !llvm.ptr
%486 = llvm.load %485 : !llvm.ptr -> i64
%487 = arith.extsi %486 : i64 to i128
%489 = arith.trunci %484 : i128 to i64
%490 = arith.trunci %487 : i128 to i64
%488 = arith.muli %489, %490 : i64
%491 = arith.extsi %488 : i64 to i128
%492 = arith.constant 1 : i32
%493 = arith.extsi %492 : i32 to i128
%494 = arith.constant 63 : i32
%496 = arith.trunci %493 : i128 to i64
%497 = arith.extsi %494 : i32 to i64
%495 = arith.shli %496, %497 : i64
%498 = arith.constant 1 : i32
%500 = arith.extsi %498 : i32 to i64
%499 = arith.subi %495, %500 : i64
%502 = arith.trunci %491 : i128 to i64
%501 = arith.andi %502, %499 : i64
%503 = llvm.mlir.addressof @g_P12_lo : !llvm.ptr
llvm.store %501, %503 : i64, !llvm.ptr
%504 = arith.constant 63 : i32
%506 = arith.trunci %491 : i128 to i64
%507 = arith.extsi %504 : i32 to i64
%505 = arith.shrsi %506, %507 : i64
%508 = llvm.mlir.addressof @g_P12_hi : !llvm.ptr
llvm.store %505, %508 : i64, !llvm.ptr
%510 = llvm.mlir.addressof @P3 : !llvm.ptr
%511 = llvm.load %510 : !llvm.ptr -> i64
%512 = arith.extsi %511 : i64 to i128
%514 = arith.trunci %491 : i128 to i64
%515 = arith.trunci %512 : i128 to i64
%513 = arith.remsi %514, %515 : i64
%516 = llvm.mlir.addressof @P3 : !llvm.ptr
%517 = llvm.load %516 : !llvm.ptr -> i64
%509 = func.call @mod_inv(%513, %517) : (i64, i64) -> i64
%518 = llvm.mlir.addressof @g_inv_p12_mod_p3 : !llvm.ptr
llvm.store %509, %518 : i64, !llvm.ptr
cf.br ^bb92
^bb91:
cf.br ^bb92
^bb92:
%519 = arith.subi %arg1, %arg0 : i64
%520 = llvm.mlir.addressof @P2 : !llvm.ptr
%521 = llvm.load %520 : !llvm.ptr -> i64
%522 = arith.remsi %519, %521 : i64
%523 = llvm.mlir.constant(1 : i64) : i64
%524 = llvm.alloca %523 x i64 : (i64) -> !llvm.ptr
llvm.store %522, %524 : i64, !llvm.ptr
%525 = llvm.load %524 : !llvm.ptr -> i64
%526 = arith.constant 0 : i32
%528 = arith.extsi %526 : i32 to i64
%527 = arith.cmpi slt, %525, %528 : i64
cf.cond_br %527, ^bb93, ^bb94
^bb93:
%529 = llvm.load %524 : !llvm.ptr -> i64
%530 = llvm.mlir.addressof @P2 : !llvm.ptr
%531 = llvm.load %530 : !llvm.ptr -> i64
%532 = arith.addi %529, %531 : i64
llvm.store %532, %524 : i64, !llvm.ptr
cf.br ^bb95
^bb94:
cf.br ^bb95
^bb95:
%533 = llvm.load %524 : !llvm.ptr -> i64
%534 = arith.extsi %533 : i64 to i128
%535 = llvm.mlir.addressof @g_inv_p1_mod_p2 : !llvm.ptr
%536 = llvm.load %535 : !llvm.ptr -> i64
%537 = arith.extsi %536 : i64 to i128
%539 = arith.trunci %534 : i128 to i64
%540 = arith.trunci %537 : i128 to i64
%538 = arith.muli %539, %540 : i64
%541 = llvm.mlir.addressof @P2 : !llvm.ptr
%542 = llvm.load %541 : !llvm.ptr -> i64
%543 = arith.extsi %542 : i64 to i128
%545 = arith.trunci %543 : i128 to i64
%544 = arith.remsi %538, %545 : i64
llvm.store %544, %524 : i64, !llvm.ptr
%546 = arith.extsi %arg0 : i64 to i128
%547 = llvm.mlir.addressof @P1 : !llvm.ptr
%548 = llvm.load %547 : !llvm.ptr -> i64
%549 = arith.extsi %548 : i64 to i128
%550 = llvm.load %524 : !llvm.ptr -> i64
%551 = arith.extsi %550 : i64 to i128
%553 = arith.trunci %549 : i128 to i64
%554 = arith.trunci %551 : i128 to i64
%552 = arith.muli %553, %554 : i64
%556 = arith.trunci %546 : i128 to i64
%555 = arith.addi %556, %552 : i64
%557 = arith.extsi %555 : i64 to i128
%558 = llvm.mlir.addressof @P3 : !llvm.ptr
%559 = llvm.load %558 : !llvm.ptr -> i64
%560 = arith.extsi %559 : i64 to i128
%562 = arith.trunci %557 : i128 to i64
%563 = arith.trunci %560 : i128 to i64
%561 = arith.remsi %562, %563 : i64
%564 = arith.subi %arg2, %561 : i64
%565 = llvm.mlir.addressof @P3 : !llvm.ptr
%566 = llvm.load %565 : !llvm.ptr -> i64
%567 = arith.remsi %564, %566 : i64
%568 = llvm.mlir.constant(1 : i64) : i64
%569 = llvm.alloca %568 x i64 : (i64) -> !llvm.ptr
llvm.store %567, %569 : i64, !llvm.ptr
%570 = llvm.load %569 : !llvm.ptr -> i64
%571 = arith.constant 0 : i32
%573 = arith.extsi %571 : i32 to i64
%572 = arith.cmpi slt, %570, %573 : i64
cf.cond_br %572, ^bb96, ^bb97
^bb96:
%574 = llvm.load %569 : !llvm.ptr -> i64
%575 = llvm.mlir.addressof @P3 : !llvm.ptr
%576 = llvm.load %575 : !llvm.ptr -> i64
%577 = arith.addi %574, %576 : i64
llvm.store %577, %569 : i64, !llvm.ptr
cf.br ^bb98
^bb97:
cf.br ^bb98
^bb98:
%578 = llvm.load %569 : !llvm.ptr -> i64
%579 = arith.extsi %578 : i64 to i128
%580 = llvm.mlir.addressof @g_inv_p12_mod_p3 : !llvm.ptr
%581 = llvm.load %580 : !llvm.ptr -> i64
%582 = arith.extsi %581 : i64 to i128
%584 = arith.trunci %579 : i128 to i64
%585 = arith.trunci %582 : i128 to i64
%583 = arith.muli %584, %585 : i64
%586 = llvm.mlir.addressof @P3 : !llvm.ptr
%587 = llvm.load %586 : !llvm.ptr -> i64
%588 = arith.extsi %587 : i64 to i128
%590 = arith.trunci %588 : i128 to i64
%589 = arith.remsi %583, %590 : i64
llvm.store %589, %569 : i64, !llvm.ptr
%591 = llvm.mlir.addressof @g_P12_hi : !llvm.ptr
%592 = llvm.load %591 : !llvm.ptr -> i64
%593 = arith.extsi %592 : i64 to i128
%594 = arith.constant 63 : i32
%596 = arith.trunci %593 : i128 to i64
%597 = arith.extsi %594 : i32 to i64
%595 = arith.shli %596, %597 : i64
%598 = llvm.mlir.addressof @g_P12_lo : !llvm.ptr
%599 = llvm.load %598 : !llvm.ptr -> i64
%600 = arith.extsi %599 : i64 to i128
%602 = arith.trunci %600 : i128 to i64
%601 = arith.addi %595, %602 : i64
%603 = arith.extsi %601 : i64 to i128
%604 = llvm.load %569 : !llvm.ptr -> i64
%605 = arith.extsi %604 : i64 to i128
%607 = arith.trunci %603 : i128 to i64
%608 = arith.trunci %605 : i128 to i64
%606 = arith.muli %607, %608 : i64
%610 = arith.trunci %557 : i128 to i64
%609 = arith.addi %610, %606 : i64
%611 = arith.extsi %609 : i64 to i128
%612 = llvm.mlir.addressof @MOD : !llvm.ptr
%613 = llvm.load %612 : !llvm.ptr -> i64
%614 = arith.extsi %613 : i64 to i128
%616 = arith.trunci %611 : i128 to i64
%617 = arith.trunci %614 : i128 to i64
%615 = arith.remsi %616, %617 : i64
%618 = llvm.mlir.constant(1 : i64) : i64
%619 = llvm.alloca %618 x i64 : (i64) -> !llvm.ptr
llvm.store %615, %619 : i64, !llvm.ptr
%620 = llvm.load %619 : !llvm.ptr -> i64
%621 = arith.constant 0 : i32
%623 = arith.extsi %621 : i32 to i64
%622 = arith.cmpi slt, %620, %623 : i64
cf.cond_br %622, ^bb99, ^bb100
^bb99:
%624 = llvm.load %619 : !llvm.ptr -> i64
%625 = llvm.mlir.addressof @MOD : !llvm.ptr
%626 = llvm.load %625 : !llvm.ptr -> i64
%627 = arith.addi %624, %626 : i64
llvm.store %627, %619 : i64, !llvm.ptr
cf.br ^bb101
^bb100:
cf.br ^bb101
^bb101:
%628 = llvm.load %619 : !llvm.ptr -> i64
func.return %628 : i64
}
func.func @convolve_mod(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: !llvm.ptr) -> !llvm.ptr {
%629 = arith.constant 0 : i32
%631 = arith.extsi %629 : i32 to i64
%630 = arith.cmpi eq, %arg1, %631 : i64
%632 = scf.if %630 -> (i1) {
%633 = arith.constant true
scf.yield %633 : i1
} else {
%634 = arith.constant 0 : i32
%636 = arith.extsi %634 : i32 to i64
%635 = arith.cmpi eq, %arg3, %636 : i64
scf.yield %635 : i1
}
cf.cond_br %632, ^bb102, ^bb103
^bb102:
%637 = arith.constant 0 : i32
%638 = arith.constant 0 : i32
%639 = arith.extsi %637 : i32 to i64
%640 = arith.extsi %638 : i32 to i64
%641 = llvm.getelementptr %arg4[%640] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %639, %641 : i64, !llvm.ptr
%642 = llvm.mlir.zero : !llvm.ptr
func.return %642 : !llvm.ptr
^bb103:
cf.br ^bb104
^bb104:
%644 = arith.constant 1 : i32
%645 = arith.constant 8 : i32
%646 = arith.extsi %644 : i32 to i64
%647 = arith.extsi %645 : i32 to i64
%643 = func.call @calloc(%646, %647) : (i64, i64) -> !llvm.ptr
%649 = arith.constant 1 : i32
%650 = arith.constant 8 : i32
%651 = arith.extsi %649 : i32 to i64
%652 = arith.extsi %650 : i32 to i64
%648 = func.call @calloc(%651, %652) : (i64, i64) -> !llvm.ptr
%654 = arith.constant 1 : i32
%655 = arith.constant 8 : i32
%656 = arith.extsi %654 : i32 to i64
%657 = arith.extsi %655 : i32 to i64
%653 = func.call @calloc(%656, %657) : (i64, i64) -> !llvm.ptr
%659 = llvm.mlir.addressof @P1 : !llvm.ptr
%660 = llvm.load %659 : !llvm.ptr -> i64
%661 = arith.constant 3 : i32
%662 = arith.extsi %661 : i32 to i64
%658 = func.call @convolve_one(%arg0, %arg1, %arg2, %arg3, %660, %662, %643) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, i64, !llvm.ptr) -> !llvm.ptr
%664 = llvm.mlir.addressof @P2 : !llvm.ptr
%665 = llvm.load %664 : !llvm.ptr -> i64
%666 = arith.constant 3 : i32
%667 = arith.extsi %666 : i32 to i64
%663 = func.call @convolve_one(%arg0, %arg1, %arg2, %arg3, %665, %667, %648) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, i64, !llvm.ptr) -> !llvm.ptr
%669 = llvm.mlir.addressof @P3 : !llvm.ptr
%670 = llvm.load %669 : !llvm.ptr -> i64
%671 = arith.constant 3 : i32
%672 = arith.extsi %671 : i32 to i64
%668 = func.call @convolve_one(%arg0, %arg1, %arg2, %arg3, %670, %672, %653) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, i64, !llvm.ptr) -> !llvm.ptr
%673 = arith.addi %arg1, %arg3 : i64
%674 = arith.constant 1 : i32
%676 = arith.extsi %674 : i32 to i64
%675 = arith.subi %673, %676 : i64
%678 = arith.constant 8 : i32
%680 = arith.extsi %678 : i32 to i64
%679 = arith.muli %675, %680 : i64
%677 = func.call @malloc(%679) : (i64) -> !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 ^bb105
^bb105:
%685 = llvm.load %684 : !llvm.ptr -> i64
%686 = arith.cmpi slt, %685, %675 : i64
cf.cond_br %686, ^bb106, ^bb107
^bb106:
%689 = llvm.load %684 : !llvm.ptr -> i64
%690 = llvm.getelementptr %658[%689] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%688 = llvm.load %690 : !llvm.ptr -> i64
%692 = llvm.load %684 : !llvm.ptr -> i64
%693 = llvm.getelementptr %663[%692] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%691 = llvm.load %693 : !llvm.ptr -> i64
%695 = llvm.load %684 : !llvm.ptr -> i64
%696 = llvm.getelementptr %668[%695] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%694 = llvm.load %696 : !llvm.ptr -> i64
%687 = func.call @crt3(%688, %691, %694) : (i64, i64, i64) -> i64
%697 = llvm.load %684 : !llvm.ptr -> i64
%698 = llvm.getelementptr %677[%697] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %687, %698 : i64, !llvm.ptr
%699 = llvm.load %684 : !llvm.ptr -> i64
%700 = arith.constant 1 : i32
%702 = arith.extsi %700 : i32 to i64
%701 = arith.addi %699, %702 : i64
llvm.store %701, %684 : i64, !llvm.ptr
cf.br ^bb105
^bb107:
func.call @free(%658) : (!llvm.ptr) -> ()
func.call @free(%663) : (!llvm.ptr) -> ()
func.call @free(%668) : (!llvm.ptr) -> ()
func.call @free(%643) : (!llvm.ptr) -> ()
func.call @free(%648) : (!llvm.ptr) -> ()
func.call @free(%653) : (!llvm.ptr) -> ()
%709 = arith.constant 0 : i32
%710 = arith.extsi %709 : i32 to i64
%711 = llvm.getelementptr %arg4[%710] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %675, %711 : i64, !llvm.ptr
func.return %677 : !llvm.ptr
}
func.func @poly_mul_trunc(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64) -> !llvm.ptr {
%713 = arith.constant 1 : i32
%714 = arith.constant 8 : i32
%715 = arith.extsi %713 : i32 to i64
%716 = arith.extsi %714 : i32 to i64
%712 = func.call @calloc(%715, %716) : (i64, i64) -> !llvm.ptr
%717 = func.call @convolve_mod(%arg0, %arg1, %arg2, %arg3, %712) : (!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr) -> !llvm.ptr
%719 = arith.constant 0 : i32
%720 = arith.extsi %719 : i32 to i64
%721 = llvm.getelementptr %712[%720] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%718 = llvm.load %721 : !llvm.ptr -> i64
func.call @free(%712) : (!llvm.ptr) -> ()
%724 = arith.constant 8 : i32
%725 = arith.extsi %724 : i32 to i64
%723 = func.call @calloc(%arg4, %725) : (i64, i64) -> !llvm.ptr
%726 = arith.constant 0 : i32
%727 = arith.extsi %726 : i32 to i64
%728 = llvm.mlir.constant(1 : i64) : i64
%729 = llvm.alloca %728 x i64 : (i64) -> !llvm.ptr
llvm.store %727, %729 : i64, !llvm.ptr
cf.br ^bb108
^bb108:
%730 = llvm.load %729 : !llvm.ptr -> i64
%731 = arith.cmpi slt, %730, %arg4 : i64
%732 = scf.if %731 -> (i1) {
%733 = llvm.load %729 : !llvm.ptr -> i64
%734 = arith.cmpi slt, %733, %718 : i64
scf.yield %734 : i1
} else {
%735 = arith.constant false
scf.yield %735 : i1
}
cf.cond_br %732, ^bb109, ^bb110
^bb109:
%737 = llvm.load %729 : !llvm.ptr -> i64
%738 = llvm.getelementptr %717[%737] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%736 = llvm.load %738 : !llvm.ptr -> i64
%739 = llvm.load %729 : !llvm.ptr -> i64
%740 = llvm.getelementptr %723[%739] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %736, %740 : i64, !llvm.ptr
%741 = llvm.load %729 : !llvm.ptr -> i64
%742 = arith.constant 1 : i32
%744 = arith.extsi %742 : i32 to i64
%743 = arith.addi %741, %744 : i64
llvm.store %743, %729 : i64, !llvm.ptr
cf.br ^bb108
^bb110:
func.call @free(%717) : (!llvm.ptr) -> ()
func.return %723 : !llvm.ptr
}
func.func @inv_series(%arg0: !llvm.ptr, %arg1: i64) -> !llvm.ptr {
%747 = arith.constant 8 : i32
%748 = arith.extsi %747 : i32 to i64
%746 = func.call @calloc(%arg1, %748) : (i64, i64) -> !llvm.ptr
%749 = llvm.mlir.constant(1 : i64) : i64
%750 = llvm.alloca %749 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %746, %750 : !llvm.ptr, !llvm.ptr
%753 = arith.constant 0 : i32
%754 = arith.extsi %753 : i32 to i64
%755 = llvm.getelementptr %arg0[%754] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%752 = llvm.load %755 : !llvm.ptr -> i64
%756 = llvm.mlir.addressof @MOD : !llvm.ptr
%757 = llvm.load %756 : !llvm.ptr -> i64
%751 = func.call @mod_inv(%752, %757) : (i64, i64) -> i64
%758 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
%759 = arith.constant 0 : i32
%760 = arith.extsi %759 : i32 to i64
%761 = llvm.getelementptr %758[%760] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %751, %761 : i64, !llvm.ptr
%762 = arith.constant 1 : i32
%763 = arith.extsi %762 : i32 to i64
%764 = llvm.mlir.constant(1 : i64) : i64
%765 = llvm.alloca %764 x i64 : (i64) -> !llvm.ptr
llvm.store %763, %765 : i64, !llvm.ptr
cf.br ^bb111
^bb111:
%766 = llvm.load %765 : !llvm.ptr -> i64
%767 = arith.cmpi slt, %766, %arg1 : i64
cf.cond_br %767, ^bb112, ^bb113
^bb112:
%768 = llvm.load %765 : !llvm.ptr -> i64
%769 = arith.constant 2 : i32
%771 = arith.extsi %769 : i32 to i64
%770 = arith.muli %768, %771 : i64
%772 = llvm.mlir.constant(1 : i64) : i64
%773 = llvm.alloca %772 x i64 : (i64) -> !llvm.ptr
llvm.store %770, %773 : i64, !llvm.ptr
%774 = llvm.load %773 : !llvm.ptr -> i64
%775 = arith.cmpi sgt, %774, %arg1 : i64
cf.cond_br %775, ^bb114, ^bb115
^bb114:
llvm.store %arg1, %773 : i64, !llvm.ptr
cf.br ^bb116
^bb115:
cf.br ^bb116
^bb116:
%777 = llvm.load %773 : !llvm.ptr -> i64
%778 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
%779 = llvm.load %765 : !llvm.ptr -> i64
%780 = llvm.load %773 : !llvm.ptr -> i64
%776 = func.call @poly_mul_trunc(%arg0, %777, %778, %779, %780) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
%781 = arith.constant 0 : i32
%782 = arith.extsi %781 : i32 to i64
%783 = llvm.mlir.constant(1 : i64) : i64
%784 = llvm.alloca %783 x i64 : (i64) -> !llvm.ptr
llvm.store %782, %784 : i64, !llvm.ptr
cf.br ^bb117
^bb117:
%785 = llvm.load %784 : !llvm.ptr -> i64
%786 = llvm.load %773 : !llvm.ptr -> i64
%787 = arith.cmpi slt, %785, %786 : i64
cf.cond_br %787, ^bb118, ^bb119
^bb118:
%788 = llvm.mlir.addressof @MOD : !llvm.ptr
%789 = llvm.load %788 : !llvm.ptr -> i64
%791 = llvm.load %784 : !llvm.ptr -> i64
%792 = llvm.getelementptr %776[%791] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%790 = llvm.load %792 : !llvm.ptr -> i64
%793 = arith.subi %789, %790 : i64
%794 = llvm.mlir.addressof @MOD : !llvm.ptr
%795 = llvm.load %794 : !llvm.ptr -> i64
%796 = arith.remsi %793, %795 : i64
%797 = llvm.load %784 : !llvm.ptr -> i64
%798 = llvm.getelementptr %776[%797] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %796, %798 : i64, !llvm.ptr
%799 = llvm.load %784 : !llvm.ptr -> i64
%800 = arith.constant 1 : i32
%802 = arith.extsi %800 : i32 to i64
%801 = arith.addi %799, %802 : i64
llvm.store %801, %784 : i64, !llvm.ptr
cf.br ^bb117
^bb119:
%804 = arith.constant 0 : i32
%805 = arith.extsi %804 : i32 to i64
%806 = llvm.getelementptr %776[%805] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%803 = llvm.load %806 : !llvm.ptr -> i64
%807 = arith.constant 2 : i32
%809 = arith.extsi %807 : i32 to i64
%808 = arith.addi %803, %809 : i64
%810 = llvm.mlir.addressof @MOD : !llvm.ptr
%811 = llvm.load %810 : !llvm.ptr -> i64
%812 = arith.remsi %808, %811 : i64
%813 = arith.constant 0 : i32
%814 = arith.extsi %813 : i32 to i64
%815 = llvm.getelementptr %776[%814] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %812, %815 : i64, !llvm.ptr
%817 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
%818 = llvm.load %765 : !llvm.ptr -> i64
%819 = llvm.load %773 : !llvm.ptr -> i64
%820 = llvm.load %773 : !llvm.ptr -> i64
%816 = func.call @poly_mul_trunc(%817, %818, %776, %819, %820) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
%822 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
func.call @free(%822) : (!llvm.ptr) -> ()
func.call @free(%776) : (!llvm.ptr) -> ()
llvm.store %816, %750 : !llvm.ptr, !llvm.ptr
%824 = llvm.load %773 : !llvm.ptr -> i64
llvm.store %824, %765 : i64, !llvm.ptr
cf.br ^bb111
^bb113:
%825 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
func.return %825 : !llvm.ptr
}
func.func @build_PQ_mod(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: !llvm.ptr, %arg4: !llvm.ptr, %arg5: !llvm.ptr, %arg6: !llvm.ptr) -> () {
%826 = arith.constant 0 : i32
%828 = arith.extsi %826 : i32 to i64
%827 = arith.cmpi sle, %arg0, %828 : i64
cf.cond_br %827, ^bb120, ^bb121
^bb120:
%830 = arith.constant 1 : i32
%831 = arith.constant 8 : i32
%832 = arith.extsi %830 : i32 to i64
%833 = arith.extsi %831 : i32 to i64
%829 = func.call @calloc(%832, %833) : (i64, i64) -> !llvm.ptr
%834 = arith.constant 0 : i32
%835 = arith.extsi %834 : i32 to i64
%836 = llvm.getelementptr %arg3[%835] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %829, %836 : !llvm.ptr, !llvm.ptr
%837 = arith.constant 1 : i32
%838 = arith.constant 0 : i32
%839 = arith.extsi %837 : i32 to i64
%840 = arith.extsi %838 : i32 to i64
%841 = llvm.getelementptr %arg4[%840] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %839, %841 : i64, !llvm.ptr
%843 = arith.constant 8 : i32
%844 = arith.extsi %843 : i32 to i64
%842 = func.call @malloc(%844) : (i64) -> !llvm.ptr
%845 = arith.constant 0 : i32
%846 = arith.extsi %845 : i32 to i64
%847 = llvm.getelementptr %arg5[%846] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %842, %847 : !llvm.ptr, !llvm.ptr
%848 = arith.constant 1 : i32
%850 = arith.constant 0 : i32
%851 = arith.extsi %850 : i32 to i64
%852 = llvm.getelementptr %arg5[%851] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%849 = llvm.load %852 : !llvm.ptr -> !llvm.ptr
%853 = arith.constant 0 : i32
%854 = arith.extsi %848 : i32 to i64
%855 = arith.extsi %853 : i32 to i64
%856 = llvm.getelementptr %849[%855] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %854, %856 : i64, !llvm.ptr
%857 = arith.constant 1 : i32
%858 = arith.constant 0 : i32
%859 = arith.extsi %857 : i32 to i64
%860 = arith.extsi %858 : i32 to i64
%861 = llvm.getelementptr %arg6[%860] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %859, %861 : i64, !llvm.ptr
func.return
^bb121:
cf.br ^bb122
^bb122:
%862 = arith.constant 1 : i32
%864 = arith.extsi %862 : i32 to i64
%863 = arith.cmpi eq, %arg1, %864 : i64
%865 = scf.if %863 -> (i32) {
%866 = arith.constant 1 : i32
scf.yield %866 : i32
} else {
%867 = llvm.mlir.addressof @MOD : !llvm.ptr
%868 = llvm.load %867 : !llvm.ptr -> i64
%869 = arith.constant 1 : i32
%871 = arith.extsi %869 : i32 to i64
%870 = arith.subi %868, %871 : i64
scf.yield %870 : i64
}
%872 = arith.extsi %865 : i32 to i64
%873 = arith.constant 1 : i32
%875 = arith.extsi %873 : i32 to i64
%874 = arith.addi %arg2, %875 : i64
%877 = arith.constant 8 : i32
%878 = arith.extsi %877 : i32 to i64
%876 = func.call @calloc(%874, %878) : (i64, i64) -> !llvm.ptr
%879 = llvm.mlir.constant(1 : i64) : i64
%880 = llvm.alloca %879 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %876, %880 : !llvm.ptr, !llvm.ptr
%882 = arith.constant 8 : i32
%883 = arith.extsi %882 : i32 to i64
%881 = func.call @calloc(%874, %883) : (i64, i64) -> !llvm.ptr
%884 = llvm.mlir.constant(1 : i64) : i64
%885 = llvm.alloca %884 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %881, %885 : !llvm.ptr, !llvm.ptr
%886 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
%887 = arith.constant 1 : i32
%888 = arith.extsi %887 : i32 to i64
%889 = llvm.getelementptr %886[%888] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %872, %889 : i64, !llvm.ptr
%890 = arith.constant 1 : i32
%891 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%892 = arith.constant 0 : i32
%893 = arith.extsi %890 : i32 to i64
%894 = arith.extsi %892 : i32 to i64
%895 = llvm.getelementptr %891[%894] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %893, %895 : i64, !llvm.ptr
%896 = llvm.mlir.addressof @MOD : !llvm.ptr
%897 = llvm.load %896 : !llvm.ptr -> i64
%898 = arith.constant 1 : i32
%900 = arith.extsi %898 : i32 to i64
%899 = arith.subi %897, %900 : i64
%901 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%902 = arith.constant 1 : i32
%903 = arith.extsi %902 : i32 to i64
%904 = llvm.getelementptr %901[%903] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %899, %904 : i64, !llvm.ptr
%905 = arith.constant 1 : i32
%907 = arith.extsi %905 : i32 to i64
%906 = arith.cmpi sge, %arg2, %907 : i64
%908 = scf.if %906 -> (i32) {
%909 = arith.constant 2 : i32
scf.yield %909 : i32
} else {
%910 = arith.constant 1 : i32
scf.yield %910 : i32
}
%911 = arith.extsi %908 : i32 to i64
%912 = llvm.mlir.constant(1 : i64) : i64
%913 = llvm.alloca %912 x i64 : (i64) -> !llvm.ptr
llvm.store %911, %913 : i64, !llvm.ptr
%914 = arith.constant 2 : i32
%915 = arith.extsi %914 : i32 to i64
%916 = llvm.mlir.constant(1 : i64) : i64
%917 = llvm.alloca %916 x i64 : (i64) -> !llvm.ptr
llvm.store %915, %917 : i64, !llvm.ptr
%918 = arith.constant 1 : i32
%920 = arith.extsi %918 : i32 to i64
%919 = arith.cmpi eq, %arg0, %920 : i64
cf.cond_br %919, ^bb123, ^bb124
^bb123:
%921 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
%922 = arith.constant 0 : i32
%923 = arith.extsi %922 : i32 to i64
%924 = llvm.getelementptr %arg3[%923] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %921, %924 : !llvm.ptr, !llvm.ptr
%925 = llvm.load %913 : !llvm.ptr -> i64
%926 = arith.constant 0 : i32
%927 = arith.extsi %926 : i32 to i64
%928 = llvm.getelementptr %arg4[%927] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %925, %928 : i64, !llvm.ptr
%929 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%930 = arith.constant 0 : i32
%931 = arith.extsi %930 : i32 to i64
%932 = llvm.getelementptr %arg5[%931] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %929, %932 : !llvm.ptr, !llvm.ptr
%933 = llvm.load %917 : !llvm.ptr -> i64
%934 = arith.constant 0 : i32
%935 = arith.extsi %934 : i32 to i64
%936 = llvm.getelementptr %arg6[%935] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %933, %936 : i64, !llvm.ptr
func.return
^bb124:
cf.br ^bb125
^bb125:
%937 = arith.constant 2 : i32
%938 = arith.extsi %937 : i32 to i64
%939 = llvm.mlir.constant(1 : i64) : i64
%940 = llvm.alloca %939 x i64 : (i64) -> !llvm.ptr
llvm.store %938, %940 : i64, !llvm.ptr
cf.br ^bb126
^bb126:
%941 = llvm.load %940 : !llvm.ptr -> i64
%942 = arith.cmpi sle, %941, %arg0 : i64
cf.cond_br %942, ^bb127, ^bb128
^bb127:
%943 = llvm.load %913 : !llvm.ptr -> i64
%944 = arith.constant 1 : i32
%946 = arith.extsi %944 : i32 to i64
%945 = arith.addi %943, %946 : i64
%947 = llvm.mlir.constant(1 : i64) : i64
%948 = llvm.alloca %947 x i64 : (i64) -> !llvm.ptr
llvm.store %945, %948 : i64, !llvm.ptr
%949 = llvm.load %948 : !llvm.ptr -> i64
%950 = arith.cmpi sgt, %949, %874 : i64
cf.cond_br %950, ^bb129, ^bb130
^bb129:
llvm.store %874, %948 : i64, !llvm.ptr
cf.br ^bb131
^bb130:
cf.br ^bb131
^bb131:
%952 = llvm.load %948 : !llvm.ptr -> i64
%953 = arith.constant 8 : i32
%954 = arith.extsi %953 : i32 to i64
%951 = func.call @calloc(%952, %954) : (i64, i64) -> !llvm.ptr
%956 = llvm.load %948 : !llvm.ptr -> i64
%957 = arith.constant 8 : i32
%958 = arith.extsi %957 : i32 to i64
%955 = func.call @calloc(%956, %958) : (i64, i64) -> !llvm.ptr
%959 = arith.constant 1 : i32
%960 = arith.constant 0 : i32
%961 = arith.extsi %959 : i32 to i64
%962 = arith.extsi %960 : i32 to i64
%963 = llvm.getelementptr %955[%962] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %961, %963 : i64, !llvm.ptr
%964 = arith.constant 1 : i32
%965 = arith.extsi %964 : i32 to i64
%966 = llvm.mlir.constant(1 : i64) : i64
%967 = llvm.alloca %966 x i64 : (i64) -> !llvm.ptr
llvm.store %965, %967 : i64, !llvm.ptr
cf.br ^bb132
^bb132:
%968 = llvm.load %967 : !llvm.ptr -> i64
%969 = llvm.load %948 : !llvm.ptr -> i64
%970 = arith.cmpi slt, %968, %969 : i64
cf.cond_br %970, ^bb133, ^bb134
^bb133:
%971 = llvm.load %967 : !llvm.ptr -> i64
%972 = arith.constant 1 : i32
%974 = arith.extsi %972 : i32 to i64
%973 = arith.subi %971, %974 : i64
%975 = llvm.load %913 : !llvm.ptr -> i64
%976 = arith.cmpi slt, %973, %975 : i64
%977 = scf.if %976 -> (i64) {
%979 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
%980 = llvm.load %967 : !llvm.ptr -> i64
%981 = arith.constant 1 : i32
%983 = arith.extsi %981 : i32 to i64
%982 = arith.subi %980, %983 : i64
%984 = llvm.getelementptr %979[%982] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%978 = llvm.load %984 : !llvm.ptr -> i64
scf.yield %978 : i64
} else {
%985 = arith.constant 0 : i32
scf.yield %985 : i32
}
%986 = llvm.load %967 : !llvm.ptr -> i64
%987 = arith.constant 1 : i32
%989 = arith.extsi %987 : i32 to i64
%988 = arith.subi %986, %989 : i64
%990 = llvm.load %917 : !llvm.ptr -> i64
%991 = arith.cmpi slt, %988, %990 : i64
%992 = scf.if %991 -> (i64) {
%994 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%995 = llvm.load %967 : !llvm.ptr -> i64
%996 = arith.constant 1 : i32
%998 = arith.extsi %996 : i32 to i64
%997 = arith.subi %995, %998 : i64
%999 = llvm.getelementptr %994[%997] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%993 = llvm.load %999 : !llvm.ptr -> i64
scf.yield %993 : i64
} else {
%1000 = arith.constant 0 : i32
scf.yield %1000 : i32
}
%1001 = arith.addi %977, %992 : i64
%1002 = llvm.mlir.addressof @MOD : !llvm.ptr
%1003 = llvm.load %1002 : !llvm.ptr -> i64
%1004 = arith.remsi %1001, %1003 : i64
%1005 = llvm.load %967 : !llvm.ptr -> i64
%1006 = arith.cmpi slt, %1005, %943 : i64
%1007 = scf.if %1006 -> (i64) {
%1009 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
%1010 = llvm.load %967 : !llvm.ptr -> i64
%1011 = llvm.getelementptr %1009[%1010] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1008 = llvm.load %1011 : !llvm.ptr -> i64
scf.yield %1008 : i64
} else {
%1012 = arith.constant 0 : i32
scf.yield %1012 : i32
}
%1013 = arith.constant 1 : i32
%1015 = arith.extsi %1013 : i32 to i64
%1014 = arith.cmpi eq, %arg1, %1015 : i64
cf.cond_br %1014, ^bb135, ^bb136
^bb135:
%1016 = arith.addi %1007, %1004 : i64
%1017 = llvm.mlir.addressof @MOD : !llvm.ptr
%1018 = llvm.load %1017 : !llvm.ptr -> i64
%1019 = arith.remsi %1016, %1018 : i64
%1020 = llvm.load %967 : !llvm.ptr -> i64
%1021 = llvm.getelementptr %951[%1020] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1019, %1021 : i64, !llvm.ptr
cf.br ^bb137
^bb136:
%1022 = arith.addi %1007, %1004 : i64
%1023 = llvm.mlir.addressof @MOD : !llvm.ptr
%1024 = llvm.load %1023 : !llvm.ptr -> i64
%1025 = arith.remsi %1022, %1024 : i64
%1026 = arith.constant 0 : i32
%1028 = arith.extsi %1026 : i32 to i64
%1027 = arith.cmpi ne, %1025, %1028 : i64
%1029 = scf.if %1027 -> (i64) {
%1030 = llvm.mlir.addressof @MOD : !llvm.ptr
%1031 = llvm.load %1030 : !llvm.ptr -> i64
%1032 = arith.subi %1031, %1025 : i64
scf.yield %1032 : i64
} else {
%1033 = arith.constant 0 : i32
scf.yield %1033 : i32
}
%1034 = llvm.load %967 : !llvm.ptr -> i64
%1035 = llvm.getelementptr %951[%1034] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1029, %1035 : i64, !llvm.ptr
cf.br ^bb137
^bb137:
%1036 = llvm.load %967 : !llvm.ptr -> i64
%1037 = arith.cmpi slt, %1036, %943 : i64
%1038 = scf.if %1037 -> (i64) {
%1040 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%1041 = llvm.load %967 : !llvm.ptr -> i64
%1042 = llvm.getelementptr %1040[%1041] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1039 = llvm.load %1042 : !llvm.ptr -> i64
scf.yield %1039 : i64
} else {
%1043 = arith.constant 0 : i32
scf.yield %1043 : i32
}
%1044 = arith.subi %1038, %1004 : i64
%1045 = llvm.mlir.constant(1 : i64) : i64
%1046 = llvm.alloca %1045 x i64 : (i64) -> !llvm.ptr
llvm.store %1044, %1046 : i64, !llvm.ptr
%1047 = llvm.load %1046 : !llvm.ptr -> i64
%1048 = arith.constant 0 : i32
%1050 = arith.extsi %1048 : i32 to i64
%1049 = arith.cmpi slt, %1047, %1050 : i64
cf.cond_br %1049, ^bb138, ^bb139
^bb138:
%1051 = llvm.load %1046 : !llvm.ptr -> i64
%1052 = llvm.mlir.addressof @MOD : !llvm.ptr
%1053 = llvm.load %1052 : !llvm.ptr -> i64
%1054 = arith.addi %1051, %1053 : i64
llvm.store %1054, %1046 : i64, !llvm.ptr
cf.br ^bb140
^bb139:
cf.br ^bb140
^bb140:
%1055 = llvm.load %1046 : !llvm.ptr -> i64
%1056 = llvm.load %967 : !llvm.ptr -> i64
%1057 = llvm.getelementptr %955[%1056] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1055, %1057 : i64, !llvm.ptr
%1058 = llvm.load %967 : !llvm.ptr -> i64
%1059 = arith.constant 1 : i32
%1061 = arith.extsi %1059 : i32 to i64
%1060 = arith.addi %1058, %1061 : i64
llvm.store %1060, %967 : i64, !llvm.ptr
cf.br ^bb132
^bb134:
%1063 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
func.call @free(%1063) : (!llvm.ptr) -> ()
%1065 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
func.call @free(%1065) : (!llvm.ptr) -> ()
llvm.store %951, %880 : !llvm.ptr, !llvm.ptr
llvm.store %955, %885 : !llvm.ptr, !llvm.ptr
%1066 = llvm.load %948 : !llvm.ptr -> i64
llvm.store %1066, %913 : i64, !llvm.ptr
%1067 = llvm.load %948 : !llvm.ptr -> i64
llvm.store %1067, %917 : i64, !llvm.ptr
%1068 = llvm.load %940 : !llvm.ptr -> i64
%1069 = arith.constant 1 : i32
%1071 = arith.extsi %1069 : i32 to i64
%1070 = arith.addi %1068, %1071 : i64
llvm.store %1070, %940 : i64, !llvm.ptr
cf.br ^bb126
^bb128:
%1072 = llvm.load %880 : !llvm.ptr -> !llvm.ptr
%1073 = arith.constant 0 : i32
%1074 = arith.extsi %1073 : i32 to i64
%1075 = llvm.getelementptr %arg3[%1074] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %1072, %1075 : !llvm.ptr, !llvm.ptr
%1076 = llvm.load %913 : !llvm.ptr -> i64
%1077 = arith.constant 0 : i32
%1078 = arith.extsi %1077 : i32 to i64
%1079 = llvm.getelementptr %arg4[%1078] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1076, %1079 : i64, !llvm.ptr
%1080 = llvm.load %885 : !llvm.ptr -> !llvm.ptr
%1081 = arith.constant 0 : i32
%1082 = arith.extsi %1081 : i32 to i64
%1083 = llvm.getelementptr %arg5[%1082] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
llvm.store %1080, %1083 : !llvm.ptr, !llvm.ptr
%1084 = llvm.load %917 : !llvm.ptr -> i64
%1085 = arith.constant 0 : i32
%1086 = arith.extsi %1085 : i32 to i64
%1087 = llvm.getelementptr %arg6[%1086] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1084, %1087 : i64, !llvm.ptr
func.return
}
func.func @series_coeff_mod(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64) -> i64 {
%1088 = arith.constant 1 : i32
%1090 = arith.extsi %1088 : i32 to i64
%1089 = arith.addi %arg4, %1090 : i64
%1091 = arith.constant 2048 : i32
%1093 = arith.extsi %1091 : i32 to i64
%1092 = arith.cmpi slt, %arg4, %1093 : i64
cf.cond_br %1092, ^bb141, ^bb142
^bb141:
%1095 = arith.constant 8 : i32
%1096 = arith.extsi %1095 : i32 to i64
%1094 = func.call @calloc(%1089, %1096) : (i64, i64) -> !llvm.ptr
%1097 = arith.constant 0 : i32
%1098 = arith.extsi %1097 : i32 to i64
%1099 = llvm.mlir.constant(1 : i64) : i64
%1100 = llvm.alloca %1099 x i64 : (i64) -> !llvm.ptr
llvm.store %1098, %1100 : i64, !llvm.ptr
cf.br ^bb144
^bb144:
%1101 = llvm.load %1100 : !llvm.ptr -> i64
%1102 = arith.cmpi slt, %1101, %1089 : i64
cf.cond_br %1102, ^bb145, ^bb146
^bb145:
%1103 = llvm.load %1100 : !llvm.ptr -> i64
%1104 = arith.cmpi slt, %1103, %arg1 : i64
%1105 = scf.if %1104 -> (i128) {
%1107 = llvm.load %1100 : !llvm.ptr -> i64
%1108 = llvm.getelementptr %arg0[%1107] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1106 = llvm.load %1108 : !llvm.ptr -> i64
%1109 = arith.extsi %1106 : i64 to i128
scf.yield %1109 : i128
} else {
%1110 = arith.constant 0 : i32
scf.yield %1110 : i32
}
%1111 = llvm.mlir.constant(1 : i64) : i64
%1112 = llvm.alloca %1111 x i128 : (i64) -> !llvm.ptr
llvm.store %1105, %1112 : i128, !llvm.ptr
%1113 = arith.constant 1 : i32
%1114 = arith.extsi %1113 : i32 to i64
%1115 = llvm.mlir.constant(1 : i64) : i64
%1116 = llvm.alloca %1115 x i64 : (i64) -> !llvm.ptr
llvm.store %1114, %1116 : i64, !llvm.ptr
cf.br ^bb147
^bb147:
%1117 = llvm.load %1116 : !llvm.ptr -> i64
%1118 = llvm.load %1100 : !llvm.ptr -> i64
%1119 = arith.cmpi sle, %1117, %1118 : i64
%1120 = scf.if %1119 -> (i1) {
%1121 = llvm.load %1116 : !llvm.ptr -> i64
%1122 = arith.cmpi slt, %1121, %arg3 : i64
scf.yield %1122 : i1
} else {
%1123 = arith.constant false
scf.yield %1123 : i1
}
cf.cond_br %1120, ^bb148, ^bb149
^bb148:
%1124 = llvm.load %1112 : !llvm.ptr -> i128
%1126 = llvm.load %1116 : !llvm.ptr -> i64
%1127 = llvm.getelementptr %arg2[%1126] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1125 = llvm.load %1127 : !llvm.ptr -> i64
%1128 = arith.extsi %1125 : i64 to i128
%1130 = llvm.load %1100 : !llvm.ptr -> i64
%1131 = llvm.load %1116 : !llvm.ptr -> i64
%1132 = arith.subi %1130, %1131 : i64
%1133 = llvm.getelementptr %1094[%1132] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1129 = llvm.load %1133 : !llvm.ptr -> i64
%1134 = arith.extsi %1129 : i64 to i128
%1136 = arith.trunci %1128 : i128 to i64
%1137 = arith.trunci %1134 : i128 to i64
%1135 = arith.muli %1136, %1137 : i64
%1139 = arith.trunci %1124 : i128 to i64
%1138 = arith.subi %1139, %1135 : i64
%1140 = arith.extsi %1138 : i64 to i128
llvm.store %1140, %1112 : i128, !llvm.ptr
%1141 = llvm.load %1116 : !llvm.ptr -> i64
%1142 = arith.constant 1 : i32
%1144 = arith.extsi %1142 : i32 to i64
%1143 = arith.addi %1141, %1144 : i64
llvm.store %1143, %1116 : i64, !llvm.ptr
cf.br ^bb147
^bb149:
%1145 = llvm.load %1112 : !llvm.ptr -> i128
%1146 = llvm.mlir.addressof @MOD : !llvm.ptr
%1147 = llvm.load %1146 : !llvm.ptr -> i64
%1148 = arith.extsi %1147 : i64 to i128
%1150 = arith.trunci %1145 : i128 to i64
%1151 = arith.trunci %1148 : i128 to i64
%1149 = arith.remsi %1150, %1151 : i64
%1152 = llvm.mlir.constant(1 : i64) : i64
%1153 = llvm.alloca %1152 x i64 : (i64) -> !llvm.ptr
llvm.store %1149, %1153 : i64, !llvm.ptr
%1154 = llvm.load %1153 : !llvm.ptr -> i64
%1155 = arith.constant 0 : i32
%1157 = arith.extsi %1155 : i32 to i64
%1156 = arith.cmpi slt, %1154, %1157 : i64
cf.cond_br %1156, ^bb150, ^bb151
^bb150:
%1158 = llvm.load %1153 : !llvm.ptr -> i64
%1159 = llvm.mlir.addressof @MOD : !llvm.ptr
%1160 = llvm.load %1159 : !llvm.ptr -> i64
%1161 = arith.addi %1158, %1160 : i64
llvm.store %1161, %1153 : i64, !llvm.ptr
cf.br ^bb152
^bb151:
cf.br ^bb152
^bb152:
%1162 = llvm.load %1153 : !llvm.ptr -> i64
%1163 = llvm.load %1100 : !llvm.ptr -> i64
%1164 = llvm.getelementptr %1094[%1163] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1162, %1164 : i64, !llvm.ptr
%1165 = llvm.load %1100 : !llvm.ptr -> i64
%1166 = arith.constant 1 : i32
%1168 = arith.extsi %1166 : i32 to i64
%1167 = arith.addi %1165, %1168 : i64
llvm.store %1167, %1100 : i64, !llvm.ptr
cf.br ^bb144
^bb146:
%1170 = llvm.getelementptr %1094[%arg4] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1169 = llvm.load %1170 : !llvm.ptr -> i64
func.call @free(%1094) : (!llvm.ptr) -> ()
func.return %1169 : i64
^bb142:
cf.br ^bb143
^bb143:
%1173 = arith.constant 8 : i32
%1174 = arith.extsi %1173 : i32 to i64
%1172 = func.call @calloc(%1089, %1174) : (i64, i64) -> !llvm.ptr
%1175 = arith.constant 0 : i32
%1176 = arith.extsi %1175 : i32 to i64
%1177 = llvm.mlir.constant(1 : i64) : i64
%1178 = llvm.alloca %1177 x i64 : (i64) -> !llvm.ptr
llvm.store %1176, %1178 : i64, !llvm.ptr
cf.br ^bb153
^bb153:
%1179 = llvm.load %1178 : !llvm.ptr -> i64
%1180 = arith.cmpi slt, %1179, %1089 : i64
%1181 = scf.if %1180 -> (i1) {
%1182 = llvm.load %1178 : !llvm.ptr -> i64
%1183 = arith.cmpi slt, %1182, %arg3 : i64
scf.yield %1183 : i1
} else {
%1184 = arith.constant false
scf.yield %1184 : i1
}
cf.cond_br %1181, ^bb154, ^bb155
^bb154:
%1186 = llvm.load %1178 : !llvm.ptr -> i64
%1187 = llvm.getelementptr %arg2[%1186] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1185 = llvm.load %1187 : !llvm.ptr -> i64
%1188 = llvm.load %1178 : !llvm.ptr -> i64
%1189 = llvm.getelementptr %1172[%1188] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1185, %1189 : i64, !llvm.ptr
%1190 = llvm.load %1178 : !llvm.ptr -> i64
%1191 = arith.constant 1 : i32
%1193 = arith.extsi %1191 : i32 to i64
%1192 = arith.addi %1190, %1193 : i64
llvm.store %1192, %1178 : i64, !llvm.ptr
cf.br ^bb153
^bb155:
%1194 = func.call @inv_series(%1172, %1089) : (!llvm.ptr, i64) -> !llvm.ptr
func.call @free(%1172) : (!llvm.ptr) -> ()
%1197 = arith.constant 8 : i32
%1198 = arith.extsi %1197 : i32 to i64
%1196 = func.call @calloc(%1089, %1198) : (i64, i64) -> !llvm.ptr
%1199 = arith.constant 0 : i32
%1200 = arith.extsi %1199 : i32 to i64
llvm.store %1200, %1178 : i64, !llvm.ptr
cf.br ^bb156
^bb156:
%1201 = llvm.load %1178 : !llvm.ptr -> i64
%1202 = arith.cmpi slt, %1201, %1089 : i64
%1203 = scf.if %1202 -> (i1) {
%1204 = llvm.load %1178 : !llvm.ptr -> i64
%1205 = arith.cmpi slt, %1204, %arg1 : i64
scf.yield %1205 : i1
} else {
%1206 = arith.constant false
scf.yield %1206 : i1
}
cf.cond_br %1203, ^bb157, ^bb158
^bb157:
%1208 = llvm.load %1178 : !llvm.ptr -> i64
%1209 = llvm.getelementptr %arg0[%1208] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1207 = llvm.load %1209 : !llvm.ptr -> i64
%1210 = llvm.load %1178 : !llvm.ptr -> i64
%1211 = llvm.getelementptr %1196[%1210] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1207, %1211 : i64, !llvm.ptr
%1212 = llvm.load %1178 : !llvm.ptr -> i64
%1213 = arith.constant 1 : i32
%1215 = arith.extsi %1213 : i32 to i64
%1214 = arith.addi %1212, %1215 : i64
llvm.store %1214, %1178 : i64, !llvm.ptr
cf.br ^bb156
^bb158:
%1216 = func.call @poly_mul_trunc(%1196, %1089, %1194, %1089, %1089) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
%1218 = llvm.getelementptr %1216[%arg4] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1217 = llvm.load %1218 : !llvm.ptr -> i64
func.call @free(%1194) : (!llvm.ptr) -> ()
func.call @free(%1196) : (!llvm.ptr) -> ()
func.call @free(%1216) : (!llvm.ptr) -> ()
func.return %1217 : i64
}
func.func @kitamasa(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64, %arg3: i64) -> i64 {
%1222 = arith.cmpi slt, %arg3, %arg2 : i64
cf.cond_br %1222, ^bb159, ^bb160
^bb159:
%1224 = llvm.getelementptr %arg0[%arg3] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1223 = llvm.load %1224 : !llvm.ptr -> i64
func.return %1223 : i64
^bb160:
cf.br ^bb161
^bb161:
%1226 = arith.constant 8 : i32
%1227 = arith.extsi %1226 : i32 to i64
%1225 = func.call @calloc(%arg2, %1227) : (i64, i64) -> !llvm.ptr
%1228 = llvm.mlir.constant(1 : i64) : i64
%1229 = llvm.alloca %1228 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1225, %1229 : !llvm.ptr, !llvm.ptr
%1230 = arith.constant 1 : i32
%1231 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
%1232 = arith.constant 0 : i32
%1233 = arith.extsi %1230 : i32 to i64
%1234 = arith.extsi %1232 : i32 to i64
%1235 = llvm.getelementptr %1231[%1234] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1233, %1235 : i64, !llvm.ptr
%1237 = arith.constant 8 : i32
%1238 = arith.extsi %1237 : i32 to i64
%1236 = func.call @calloc(%arg2, %1238) : (i64, i64) -> !llvm.ptr
%1239 = llvm.mlir.constant(1 : i64) : i64
%1240 = llvm.alloca %1239 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %1236, %1240 : !llvm.ptr, !llvm.ptr
%1241 = arith.constant 1 : i32
%1243 = arith.extsi %1241 : i32 to i64
%1242 = arith.cmpi sgt, %arg2, %1243 : i64
cf.cond_br %1242, ^bb162, ^bb163
^bb162:
%1244 = arith.constant 1 : i32
%1245 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1246 = arith.constant 1 : i32
%1247 = arith.extsi %1244 : i32 to i64
%1248 = arith.extsi %1246 : i32 to i64
%1249 = llvm.getelementptr %1245[%1248] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1247, %1249 : i64, !llvm.ptr
cf.br ^bb164
^bb163:
cf.br ^bb164
^bb164:
%1250 = llvm.mlir.constant(1 : i64) : i64
%1251 = llvm.alloca %1250 x i64 : (i64) -> !llvm.ptr
llvm.store %arg3, %1251 : i64, !llvm.ptr
cf.br ^bb165
^bb165:
%1252 = llvm.load %1251 : !llvm.ptr -> i64
%1253 = arith.constant 0 : i32
%1255 = arith.extsi %1253 : i32 to i64
%1254 = arith.cmpi ne, %1252, %1255 : i64
cf.cond_br %1254, ^bb166, ^bb167
^bb166:
%1256 = llvm.load %1251 : !llvm.ptr -> i64
%1257 = arith.constant 2 : i32
%1259 = arith.extsi %1257 : i32 to i64
%1258 = arith.remsi %1256, %1259 : i64
%1260 = arith.constant 1 : i32
%1262 = arith.extsi %1260 : i32 to i64
%1261 = arith.cmpi eq, %1258, %1262 : i64
cf.cond_br %1261, ^bb168, ^bb169
^bb168:
%1264 = arith.constant 2 : i32
%1266 = arith.extsi %1264 : i32 to i64
%1265 = arith.muli %1266, %arg2 : i64
%1267 = arith.constant 1 : i32
%1269 = arith.extsi %1267 : i32 to i64
%1268 = arith.subi %1265, %1269 : i64
%1270 = arith.constant 8 : i32
%1271 = arith.extsi %1270 : i32 to i64
%1263 = func.call @calloc(%1268, %1271) : (i64, i64) -> !llvm.ptr
%1272 = arith.constant 0 : i32
%1273 = arith.extsi %1272 : i32 to i64
%1274 = llvm.mlir.constant(1 : i64) : i64
%1275 = llvm.alloca %1274 x i64 : (i64) -> !llvm.ptr
llvm.store %1273, %1275 : i64, !llvm.ptr
cf.br ^bb171
^bb171:
%1276 = llvm.load %1275 : !llvm.ptr -> i64
%1277 = arith.cmpi slt, %1276, %arg2 : i64
cf.cond_br %1277, ^bb172, ^bb173
^bb172:
%1279 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
%1280 = llvm.load %1275 : !llvm.ptr -> i64
%1281 = llvm.getelementptr %1279[%1280] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1278 = llvm.load %1281 : !llvm.ptr -> i64
%1282 = arith.constant 0 : i32
%1284 = arith.extsi %1282 : i32 to i64
%1283 = arith.cmpi ne, %1278, %1284 : i64
cf.cond_br %1283, ^bb174, ^bb175
^bb174:
%1285 = arith.constant 0 : i32
%1286 = arith.extsi %1285 : i32 to i64
%1287 = llvm.mlir.constant(1 : i64) : i64
%1288 = llvm.alloca %1287 x i64 : (i64) -> !llvm.ptr
llvm.store %1286, %1288 : i64, !llvm.ptr
cf.br ^bb177
^bb177:
%1289 = llvm.load %1288 : !llvm.ptr -> i64
%1290 = arith.cmpi slt, %1289, %arg2 : i64
cf.cond_br %1290, ^bb178, ^bb179
^bb178:
%1292 = llvm.load %1275 : !llvm.ptr -> i64
%1293 = llvm.load %1288 : !llvm.ptr -> i64
%1294 = arith.addi %1292, %1293 : i64
%1295 = llvm.getelementptr %1263[%1294] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1291 = llvm.load %1295 : !llvm.ptr -> i64
%1297 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
%1298 = llvm.load %1275 : !llvm.ptr -> i64
%1299 = llvm.getelementptr %1297[%1298] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1296 = llvm.load %1299 : !llvm.ptr -> i64
%1300 = arith.extsi %1296 : i64 to i128
%1302 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1303 = llvm.load %1288 : !llvm.ptr -> i64
%1304 = llvm.getelementptr %1302[%1303] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1301 = llvm.load %1304 : !llvm.ptr -> i64
%1305 = arith.extsi %1301 : i64 to i128
%1307 = arith.trunci %1300 : i128 to i64
%1308 = arith.trunci %1305 : i128 to i64
%1306 = arith.muli %1307, %1308 : i64
%1309 = llvm.mlir.addressof @MOD : !llvm.ptr
%1310 = llvm.load %1309 : !llvm.ptr -> i64
%1311 = arith.extsi %1310 : i64 to i128
%1313 = arith.trunci %1311 : i128 to i64
%1312 = arith.remsi %1306, %1313 : i64
%1314 = arith.addi %1291, %1312 : i64
%1315 = llvm.mlir.addressof @MOD : !llvm.ptr
%1316 = llvm.load %1315 : !llvm.ptr -> i64
%1317 = arith.remsi %1314, %1316 : i64
%1318 = llvm.load %1275 : !llvm.ptr -> i64
%1319 = llvm.load %1288 : !llvm.ptr -> i64
%1320 = arith.addi %1318, %1319 : i64
%1321 = llvm.getelementptr %1263[%1320] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1317, %1321 : i64, !llvm.ptr
%1322 = llvm.load %1288 : !llvm.ptr -> i64
%1323 = arith.constant 1 : i32
%1325 = arith.extsi %1323 : i32 to i64
%1324 = arith.addi %1322, %1325 : i64
llvm.store %1324, %1288 : i64, !llvm.ptr
cf.br ^bb177
^bb179:
cf.br ^bb176
^bb175:
cf.br ^bb176
^bb176:
%1326 = llvm.load %1275 : !llvm.ptr -> i64
%1327 = arith.constant 1 : i32
%1329 = arith.extsi %1327 : i32 to i64
%1328 = arith.addi %1326, %1329 : i64
llvm.store %1328, %1275 : i64, !llvm.ptr
cf.br ^bb171
^bb173:
%1330 = arith.constant 2 : i32
%1332 = arith.extsi %1330 : i32 to i64
%1331 = arith.muli %1332, %arg2 : i64
%1333 = arith.constant 2 : i32
%1335 = arith.extsi %1333 : i32 to i64
%1334 = arith.subi %1331, %1335 : i64
%1336 = llvm.mlir.constant(1 : i64) : i64
%1337 = llvm.alloca %1336 x i64 : (i64) -> !llvm.ptr
llvm.store %1334, %1337 : i64, !llvm.ptr
cf.br ^bb180
^bb180:
%1338 = llvm.load %1337 : !llvm.ptr -> i64
%1339 = arith.cmpi sge, %1338, %arg2 : i64
cf.cond_br %1339, ^bb181, ^bb182
^bb181:
%1341 = llvm.load %1337 : !llvm.ptr -> i64
%1342 = llvm.getelementptr %1263[%1341] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1340 = llvm.load %1342 : !llvm.ptr -> i64
%1343 = arith.constant 0 : i32
%1345 = arith.extsi %1343 : i32 to i64
%1344 = arith.cmpi ne, %1340, %1345 : i64
cf.cond_br %1344, ^bb183, ^bb184
^bb183:
%1346 = arith.constant 0 : i32
%1347 = arith.extsi %1346 : i32 to i64
%1348 = llvm.mlir.constant(1 : i64) : i64
%1349 = llvm.alloca %1348 x i64 : (i64) -> !llvm.ptr
llvm.store %1347, %1349 : i64, !llvm.ptr
cf.br ^bb186
^bb186:
%1350 = llvm.load %1349 : !llvm.ptr -> i64
%1351 = arith.cmpi slt, %1350, %arg2 : i64
cf.cond_br %1351, ^bb187, ^bb188
^bb187:
%1353 = llvm.load %1337 : !llvm.ptr -> i64
%1354 = arith.constant 1 : i32
%1356 = arith.extsi %1354 : i32 to i64
%1355 = arith.subi %1353, %1356 : i64
%1357 = llvm.load %1349 : !llvm.ptr -> i64
%1358 = arith.subi %1355, %1357 : i64
%1359 = llvm.getelementptr %1263[%1358] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1352 = llvm.load %1359 : !llvm.ptr -> i64
%1360 = arith.extsi %1340 : i64 to i128
%1362 = llvm.load %1349 : !llvm.ptr -> i64
%1363 = llvm.getelementptr %arg1[%1362] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1361 = llvm.load %1363 : !llvm.ptr -> i64
%1364 = arith.extsi %1361 : i64 to i128
%1366 = arith.trunci %1360 : i128 to i64
%1367 = arith.trunci %1364 : i128 to i64
%1365 = arith.muli %1366, %1367 : i64
%1368 = llvm.mlir.addressof @MOD : !llvm.ptr
%1369 = llvm.load %1368 : !llvm.ptr -> i64
%1370 = arith.extsi %1369 : i64 to i128
%1372 = arith.trunci %1370 : i128 to i64
%1371 = arith.remsi %1365, %1372 : i64
%1373 = arith.addi %1352, %1371 : i64
%1374 = llvm.mlir.addressof @MOD : !llvm.ptr
%1375 = llvm.load %1374 : !llvm.ptr -> i64
%1376 = arith.remsi %1373, %1375 : i64
%1377 = llvm.load %1337 : !llvm.ptr -> i64
%1378 = arith.constant 1 : i32
%1380 = arith.extsi %1378 : i32 to i64
%1379 = arith.subi %1377, %1380 : i64
%1381 = llvm.load %1349 : !llvm.ptr -> i64
%1382 = arith.subi %1379, %1381 : i64
%1383 = llvm.getelementptr %1263[%1382] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1376, %1383 : i64, !llvm.ptr
%1384 = llvm.load %1349 : !llvm.ptr -> i64
%1385 = arith.constant 1 : i32
%1387 = arith.extsi %1385 : i32 to i64
%1386 = arith.addi %1384, %1387 : i64
llvm.store %1386, %1349 : i64, !llvm.ptr
cf.br ^bb186
^bb188:
cf.br ^bb185
^bb184:
cf.br ^bb185
^bb185:
%1388 = llvm.load %1337 : !llvm.ptr -> i64
%1389 = arith.constant 1 : i32
%1391 = arith.extsi %1389 : i32 to i64
%1390 = arith.subi %1388, %1391 : i64
llvm.store %1390, %1337 : i64, !llvm.ptr
cf.br ^bb180
^bb182:
%1392 = arith.constant 0 : i32
%1393 = arith.extsi %1392 : i32 to i64
%1394 = llvm.mlir.constant(1 : i64) : i64
%1395 = llvm.alloca %1394 x i64 : (i64) -> !llvm.ptr
llvm.store %1393, %1395 : i64, !llvm.ptr
cf.br ^bb189
^bb189:
%1396 = llvm.load %1395 : !llvm.ptr -> i64
%1397 = arith.cmpi slt, %1396, %arg2 : i64
cf.cond_br %1397, ^bb190, ^bb191
^bb190:
%1399 = llvm.load %1395 : !llvm.ptr -> i64
%1400 = llvm.getelementptr %1263[%1399] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1398 = llvm.load %1400 : !llvm.ptr -> i64
%1401 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
%1402 = llvm.load %1395 : !llvm.ptr -> i64
%1403 = llvm.getelementptr %1401[%1402] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1398, %1403 : i64, !llvm.ptr
%1404 = llvm.load %1395 : !llvm.ptr -> i64
%1405 = arith.constant 1 : i32
%1407 = arith.extsi %1405 : i32 to i64
%1406 = arith.addi %1404, %1407 : i64
llvm.store %1406, %1395 : i64, !llvm.ptr
cf.br ^bb189
^bb191:
func.call @free(%1263) : (!llvm.ptr) -> ()
cf.br ^bb170
^bb169:
cf.br ^bb170
^bb170:
%1410 = arith.constant 2 : i32
%1412 = arith.extsi %1410 : i32 to i64
%1411 = arith.muli %1412, %arg2 : i64
%1413 = arith.constant 1 : i32
%1415 = arith.extsi %1413 : i32 to i64
%1414 = arith.subi %1411, %1415 : i64
%1416 = arith.constant 8 : i32
%1417 = arith.extsi %1416 : i32 to i64
%1409 = func.call @calloc(%1414, %1417) : (i64, i64) -> !llvm.ptr
%1418 = arith.constant 0 : i32
%1419 = arith.extsi %1418 : i32 to i64
%1420 = llvm.mlir.constant(1 : i64) : i64
%1421 = llvm.alloca %1420 x i64 : (i64) -> !llvm.ptr
llvm.store %1419, %1421 : i64, !llvm.ptr
cf.br ^bb192
^bb192:
%1422 = llvm.load %1421 : !llvm.ptr -> i64
%1423 = arith.cmpi slt, %1422, %arg2 : i64
cf.cond_br %1423, ^bb193, ^bb194
^bb193:
%1425 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1426 = llvm.load %1421 : !llvm.ptr -> i64
%1427 = llvm.getelementptr %1425[%1426] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1424 = llvm.load %1427 : !llvm.ptr -> i64
%1428 = arith.constant 0 : i32
%1430 = arith.extsi %1428 : i32 to i64
%1429 = arith.cmpi ne, %1424, %1430 : i64
cf.cond_br %1429, ^bb195, ^bb196
^bb195:
%1431 = arith.constant 0 : i32
%1432 = arith.extsi %1431 : i32 to i64
%1433 = llvm.mlir.constant(1 : i64) : i64
%1434 = llvm.alloca %1433 x i64 : (i64) -> !llvm.ptr
llvm.store %1432, %1434 : i64, !llvm.ptr
cf.br ^bb198
^bb198:
%1435 = llvm.load %1434 : !llvm.ptr -> i64
%1436 = arith.cmpi slt, %1435, %arg2 : i64
cf.cond_br %1436, ^bb199, ^bb200
^bb199:
%1438 = llvm.load %1421 : !llvm.ptr -> i64
%1439 = llvm.load %1434 : !llvm.ptr -> i64
%1440 = arith.addi %1438, %1439 : i64
%1441 = llvm.getelementptr %1409[%1440] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1437 = llvm.load %1441 : !llvm.ptr -> i64
%1443 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1444 = llvm.load %1421 : !llvm.ptr -> i64
%1445 = llvm.getelementptr %1443[%1444] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1442 = llvm.load %1445 : !llvm.ptr -> i64
%1446 = arith.extsi %1442 : i64 to i128
%1448 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1449 = llvm.load %1434 : !llvm.ptr -> i64
%1450 = llvm.getelementptr %1448[%1449] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1447 = llvm.load %1450 : !llvm.ptr -> i64
%1451 = arith.extsi %1447 : i64 to i128
%1453 = arith.trunci %1446 : i128 to i64
%1454 = arith.trunci %1451 : i128 to i64
%1452 = arith.muli %1453, %1454 : i64
%1455 = llvm.mlir.addressof @MOD : !llvm.ptr
%1456 = llvm.load %1455 : !llvm.ptr -> i64
%1457 = arith.extsi %1456 : i64 to i128
%1459 = arith.trunci %1457 : i128 to i64
%1458 = arith.remsi %1452, %1459 : i64
%1460 = arith.addi %1437, %1458 : i64
%1461 = llvm.mlir.addressof @MOD : !llvm.ptr
%1462 = llvm.load %1461 : !llvm.ptr -> i64
%1463 = arith.remsi %1460, %1462 : i64
%1464 = llvm.load %1421 : !llvm.ptr -> i64
%1465 = llvm.load %1434 : !llvm.ptr -> i64
%1466 = arith.addi %1464, %1465 : i64
%1467 = llvm.getelementptr %1409[%1466] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1463, %1467 : i64, !llvm.ptr
%1468 = llvm.load %1434 : !llvm.ptr -> i64
%1469 = arith.constant 1 : i32
%1471 = arith.extsi %1469 : i32 to i64
%1470 = arith.addi %1468, %1471 : i64
llvm.store %1470, %1434 : i64, !llvm.ptr
cf.br ^bb198
^bb200:
cf.br ^bb197
^bb196:
cf.br ^bb197
^bb197:
%1472 = llvm.load %1421 : !llvm.ptr -> i64
%1473 = arith.constant 1 : i32
%1475 = arith.extsi %1473 : i32 to i64
%1474 = arith.addi %1472, %1475 : i64
llvm.store %1474, %1421 : i64, !llvm.ptr
cf.br ^bb192
^bb194:
%1476 = arith.constant 2 : i32
%1478 = arith.extsi %1476 : i32 to i64
%1477 = arith.muli %1478, %arg2 : i64
%1479 = arith.constant 2 : i32
%1481 = arith.extsi %1479 : i32 to i64
%1480 = arith.subi %1477, %1481 : i64
%1482 = llvm.mlir.constant(1 : i64) : i64
%1483 = llvm.alloca %1482 x i64 : (i64) -> !llvm.ptr
llvm.store %1480, %1483 : i64, !llvm.ptr
cf.br ^bb201
^bb201:
%1484 = llvm.load %1483 : !llvm.ptr -> i64
%1485 = arith.cmpi sge, %1484, %arg2 : i64
cf.cond_br %1485, ^bb202, ^bb203
^bb202:
%1487 = llvm.load %1483 : !llvm.ptr -> i64
%1488 = llvm.getelementptr %1409[%1487] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1486 = llvm.load %1488 : !llvm.ptr -> i64
%1489 = arith.constant 0 : i32
%1491 = arith.extsi %1489 : i32 to i64
%1490 = arith.cmpi ne, %1486, %1491 : i64
cf.cond_br %1490, ^bb204, ^bb205
^bb204:
%1492 = arith.constant 0 : i32
%1493 = arith.extsi %1492 : i32 to i64
%1494 = llvm.mlir.constant(1 : i64) : i64
%1495 = llvm.alloca %1494 x i64 : (i64) -> !llvm.ptr
llvm.store %1493, %1495 : i64, !llvm.ptr
cf.br ^bb207
^bb207:
%1496 = llvm.load %1495 : !llvm.ptr -> i64
%1497 = arith.cmpi slt, %1496, %arg2 : i64
cf.cond_br %1497, ^bb208, ^bb209
^bb208:
%1499 = llvm.load %1483 : !llvm.ptr -> i64
%1500 = arith.constant 1 : i32
%1502 = arith.extsi %1500 : i32 to i64
%1501 = arith.subi %1499, %1502 : i64
%1503 = llvm.load %1495 : !llvm.ptr -> i64
%1504 = arith.subi %1501, %1503 : i64
%1505 = llvm.getelementptr %1409[%1504] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1498 = llvm.load %1505 : !llvm.ptr -> i64
%1506 = arith.extsi %1486 : i64 to i128
%1508 = llvm.load %1495 : !llvm.ptr -> i64
%1509 = llvm.getelementptr %arg1[%1508] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1507 = llvm.load %1509 : !llvm.ptr -> i64
%1510 = arith.extsi %1507 : i64 to i128
%1512 = arith.trunci %1506 : i128 to i64
%1513 = arith.trunci %1510 : i128 to i64
%1511 = arith.muli %1512, %1513 : i64
%1514 = llvm.mlir.addressof @MOD : !llvm.ptr
%1515 = llvm.load %1514 : !llvm.ptr -> i64
%1516 = arith.extsi %1515 : i64 to i128
%1518 = arith.trunci %1516 : i128 to i64
%1517 = arith.remsi %1511, %1518 : i64
%1519 = arith.addi %1498, %1517 : i64
%1520 = llvm.mlir.addressof @MOD : !llvm.ptr
%1521 = llvm.load %1520 : !llvm.ptr -> i64
%1522 = arith.remsi %1519, %1521 : i64
%1523 = llvm.load %1483 : !llvm.ptr -> i64
%1524 = arith.constant 1 : i32
%1526 = arith.extsi %1524 : i32 to i64
%1525 = arith.subi %1523, %1526 : i64
%1527 = llvm.load %1495 : !llvm.ptr -> i64
%1528 = arith.subi %1525, %1527 : i64
%1529 = llvm.getelementptr %1409[%1528] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1522, %1529 : i64, !llvm.ptr
%1530 = llvm.load %1495 : !llvm.ptr -> i64
%1531 = arith.constant 1 : i32
%1533 = arith.extsi %1531 : i32 to i64
%1532 = arith.addi %1530, %1533 : i64
llvm.store %1532, %1495 : i64, !llvm.ptr
cf.br ^bb207
^bb209:
cf.br ^bb206
^bb205:
cf.br ^bb206
^bb206:
%1534 = llvm.load %1483 : !llvm.ptr -> i64
%1535 = arith.constant 1 : i32
%1537 = arith.extsi %1535 : i32 to i64
%1536 = arith.subi %1534, %1537 : i64
llvm.store %1536, %1483 : i64, !llvm.ptr
cf.br ^bb201
^bb203:
%1538 = arith.constant 0 : i32
%1539 = arith.extsi %1538 : i32 to i64
%1540 = llvm.mlir.constant(1 : i64) : i64
%1541 = llvm.alloca %1540 x i64 : (i64) -> !llvm.ptr
llvm.store %1539, %1541 : i64, !llvm.ptr
cf.br ^bb210
^bb210:
%1542 = llvm.load %1541 : !llvm.ptr -> i64
%1543 = arith.cmpi slt, %1542, %arg2 : i64
cf.cond_br %1543, ^bb211, ^bb212
^bb211:
%1545 = llvm.load %1541 : !llvm.ptr -> i64
%1546 = llvm.getelementptr %1409[%1545] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1544 = llvm.load %1546 : !llvm.ptr -> i64
%1547 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
%1548 = llvm.load %1541 : !llvm.ptr -> i64
%1549 = llvm.getelementptr %1547[%1548] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1544, %1549 : i64, !llvm.ptr
%1550 = llvm.load %1541 : !llvm.ptr -> i64
%1551 = arith.constant 1 : i32
%1553 = arith.extsi %1551 : i32 to i64
%1552 = arith.addi %1550, %1553 : i64
llvm.store %1552, %1541 : i64, !llvm.ptr
cf.br ^bb210
^bb212:
func.call @free(%1409) : (!llvm.ptr) -> ()
%1555 = llvm.load %1251 : !llvm.ptr -> i64
%1556 = arith.constant 2 : i32
%1558 = arith.extsi %1556 : i32 to i64
%1557 = arith.divsi %1555, %1558 : i64
llvm.store %1557, %1251 : i64, !llvm.ptr
cf.br ^bb165
^bb167:
%1559 = arith.constant 0 : i32
%1560 = arith.extsi %1559 : i32 to i64
%1561 = llvm.mlir.constant(1 : i64) : i64
%1562 = llvm.alloca %1561 x i64 : (i64) -> !llvm.ptr
llvm.store %1560, %1562 : i64, !llvm.ptr
%1563 = arith.constant 0 : i32
%1564 = arith.extsi %1563 : i32 to i64
%1565 = llvm.mlir.constant(1 : i64) : i64
%1566 = llvm.alloca %1565 x i64 : (i64) -> !llvm.ptr
llvm.store %1564, %1566 : i64, !llvm.ptr
cf.br ^bb213
^bb213:
%1567 = llvm.load %1566 : !llvm.ptr -> i64
%1568 = arith.cmpi slt, %1567, %arg2 : i64
cf.cond_br %1568, ^bb214, ^bb215
^bb214:
%1569 = llvm.load %1562 : !llvm.ptr -> i64
%1571 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
%1572 = llvm.load %1566 : !llvm.ptr -> i64
%1573 = llvm.getelementptr %1571[%1572] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1570 = llvm.load %1573 : !llvm.ptr -> i64
%1574 = arith.extsi %1570 : i64 to i128
%1576 = llvm.load %1566 : !llvm.ptr -> i64
%1577 = llvm.getelementptr %arg0[%1576] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1575 = llvm.load %1577 : !llvm.ptr -> i64
%1578 = arith.extsi %1575 : i64 to i128
%1580 = arith.trunci %1574 : i128 to i64
%1581 = arith.trunci %1578 : i128 to i64
%1579 = arith.muli %1580, %1581 : i64
%1582 = llvm.mlir.addressof @MOD : !llvm.ptr
%1583 = llvm.load %1582 : !llvm.ptr -> i64
%1584 = arith.extsi %1583 : i64 to i128
%1586 = arith.trunci %1584 : i128 to i64
%1585 = arith.remsi %1579, %1586 : i64
%1587 = arith.addi %1569, %1585 : i64
%1588 = llvm.mlir.addressof @MOD : !llvm.ptr
%1589 = llvm.load %1588 : !llvm.ptr -> i64
%1590 = arith.remsi %1587, %1589 : i64
llvm.store %1590, %1562 : i64, !llvm.ptr
%1591 = llvm.load %1566 : !llvm.ptr -> i64
%1592 = arith.constant 1 : i32
%1594 = arith.extsi %1592 : i32 to i64
%1593 = arith.addi %1591, %1594 : i64
llvm.store %1593, %1566 : i64, !llvm.ptr
cf.br ^bb213
^bb215:
%1596 = llvm.load %1229 : !llvm.ptr -> !llvm.ptr
func.call @free(%1596) : (!llvm.ptr) -> ()
%1598 = llvm.load %1240 : !llvm.ptr -> !llvm.ptr
func.call @free(%1598) : (!llvm.ptr) -> ()
%1599 = llvm.load %1562 : !llvm.ptr -> i64
func.return %1599 : i64
}
func.func @coeff_large_w_small_h(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%1601 = arith.constant 1 : i32
%1602 = arith.constant 8 : i32
%1603 = arith.extsi %1601 : i32 to i64
%1604 = arith.extsi %1602 : i32 to i64
%1600 = func.call @calloc(%1603, %1604) : (i64, i64) -> !llvm.ptr
%1606 = arith.constant 1 : i32
%1607 = arith.constant 8 : i32
%1608 = arith.extsi %1606 : i32 to i64
%1609 = arith.extsi %1607 : i32 to i64
%1605 = func.call @calloc(%1608, %1609) : (i64, i64) -> !llvm.ptr
%1611 = arith.constant 1 : i32
%1612 = arith.constant 8 : i32
%1613 = arith.extsi %1611 : i32 to i64
%1614 = arith.extsi %1612 : i32 to i64
%1610 = func.call @calloc(%1613, %1614) : (i64, i64) -> !llvm.ptr
%1616 = arith.constant 1 : i32
%1617 = arith.constant 8 : i32
%1618 = arith.extsi %1616 : i32 to i64
%1619 = arith.extsi %1617 : i32 to i64
%1615 = func.call @calloc(%1618, %1619) : (i64, i64) -> !llvm.ptr
func.call @build_PQ_mod(%arg1, %arg2, %arg1, %1600, %1605, %1610, %1615) : (i64, i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
%1622 = arith.constant 0 : i32
%1623 = arith.extsi %1622 : i32 to i64
%1624 = llvm.getelementptr %1600[%1623] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%1621 = llvm.load %1624 : !llvm.ptr -> !llvm.ptr
%1626 = arith.constant 0 : i32
%1627 = arith.extsi %1626 : i32 to i64
%1628 = llvm.getelementptr %1605[%1627] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1625 = llvm.load %1628 : !llvm.ptr -> i64
%1630 = arith.constant 0 : i32
%1631 = arith.extsi %1630 : i32 to i64
%1632 = llvm.getelementptr %1610[%1631] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%1629 = llvm.load %1632 : !llvm.ptr -> !llvm.ptr
%1634 = arith.constant 0 : i32
%1635 = arith.extsi %1634 : i32 to i64
%1636 = llvm.getelementptr %1615[%1635] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1633 = llvm.load %1636 : !llvm.ptr -> i64
func.call @free(%1600) : (!llvm.ptr) -> ()
func.call @free(%1605) : (!llvm.ptr) -> ()
func.call @free(%1610) : (!llvm.ptr) -> ()
func.call @free(%1615) : (!llvm.ptr) -> ()
%1642 = arith.constant 1 : i32
%1644 = arith.extsi %1642 : i32 to i64
%1643 = arith.addi %arg1, %1644 : i64
%1645 = arith.constant 8 : i32
%1647 = arith.extsi %1645 : i32 to i64
%1646 = arith.muli %1643, %1647 : i64
%1641 = func.call @malloc(%1646) : (i64) -> !llvm.ptr
%1648 = arith.constant 0 : i32
%1649 = arith.extsi %1648 : i32 to i64
%1650 = llvm.mlir.constant(1 : i64) : i64
%1651 = llvm.alloca %1650 x i64 : (i64) -> !llvm.ptr
llvm.store %1649, %1651 : i64, !llvm.ptr
cf.br ^bb216
^bb216:
%1652 = llvm.load %1651 : !llvm.ptr -> i64
%1653 = arith.cmpi sle, %1652, %arg1 : i64
cf.cond_br %1653, ^bb217, ^bb218
^bb217:
%1654 = llvm.load %1651 : !llvm.ptr -> i64
%1655 = arith.cmpi slt, %1654, %1625 : i64
%1656 = scf.if %1655 -> (i128) {
%1658 = llvm.load %1651 : !llvm.ptr -> i64
%1659 = llvm.getelementptr %1621[%1658] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1657 = llvm.load %1659 : !llvm.ptr -> i64
%1660 = arith.extsi %1657 : i64 to i128
scf.yield %1660 : i128
} else {
%1661 = arith.constant 0 : i32
scf.yield %1661 : i32
}
%1662 = llvm.mlir.constant(1 : i64) : i64
%1663 = llvm.alloca %1662 x i128 : (i64) -> !llvm.ptr
llvm.store %1656, %1663 : i128, !llvm.ptr
%1664 = arith.constant 1 : i32
%1665 = arith.extsi %1664 : i32 to i64
%1666 = llvm.mlir.constant(1 : i64) : i64
%1667 = llvm.alloca %1666 x i64 : (i64) -> !llvm.ptr
llvm.store %1665, %1667 : i64, !llvm.ptr
cf.br ^bb219
^bb219:
%1668 = llvm.load %1667 : !llvm.ptr -> i64
%1669 = llvm.load %1651 : !llvm.ptr -> i64
%1670 = arith.cmpi sle, %1668, %1669 : i64
%1671 = scf.if %1670 -> (i1) {
%1672 = llvm.load %1667 : !llvm.ptr -> i64
%1673 = arith.cmpi slt, %1672, %1633 : i64
scf.yield %1673 : i1
} else {
%1674 = arith.constant false
scf.yield %1674 : i1
}
cf.cond_br %1671, ^bb220, ^bb221
^bb220:
%1675 = llvm.load %1663 : !llvm.ptr -> i128
%1677 = llvm.load %1667 : !llvm.ptr -> i64
%1678 = llvm.getelementptr %1629[%1677] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1676 = llvm.load %1678 : !llvm.ptr -> i64
%1679 = arith.extsi %1676 : i64 to i128
%1681 = llvm.load %1651 : !llvm.ptr -> i64
%1682 = llvm.load %1667 : !llvm.ptr -> i64
%1683 = arith.subi %1681, %1682 : i64
%1684 = llvm.getelementptr %1641[%1683] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1680 = llvm.load %1684 : !llvm.ptr -> i64
%1685 = arith.extsi %1680 : i64 to i128
%1687 = arith.trunci %1679 : i128 to i64
%1688 = arith.trunci %1685 : i128 to i64
%1686 = arith.muli %1687, %1688 : i64
%1690 = arith.trunci %1675 : i128 to i64
%1689 = arith.subi %1690, %1686 : i64
%1691 = arith.extsi %1689 : i64 to i128
llvm.store %1691, %1663 : i128, !llvm.ptr
%1692 = llvm.load %1667 : !llvm.ptr -> i64
%1693 = arith.constant 1 : i32
%1695 = arith.extsi %1693 : i32 to i64
%1694 = arith.addi %1692, %1695 : i64
llvm.store %1694, %1667 : i64, !llvm.ptr
cf.br ^bb219
^bb221:
%1696 = llvm.load %1663 : !llvm.ptr -> i128
%1697 = llvm.mlir.addressof @MOD : !llvm.ptr
%1698 = llvm.load %1697 : !llvm.ptr -> i64
%1699 = arith.extsi %1698 : i64 to i128
%1701 = arith.trunci %1696 : i128 to i64
%1702 = arith.trunci %1699 : i128 to i64
%1700 = arith.remsi %1701, %1702 : i64
%1703 = llvm.mlir.constant(1 : i64) : i64
%1704 = llvm.alloca %1703 x i64 : (i64) -> !llvm.ptr
llvm.store %1700, %1704 : i64, !llvm.ptr
%1705 = llvm.load %1704 : !llvm.ptr -> i64
%1706 = arith.constant 0 : i32
%1708 = arith.extsi %1706 : i32 to i64
%1707 = arith.cmpi slt, %1705, %1708 : i64
cf.cond_br %1707, ^bb222, ^bb223
^bb222:
%1709 = llvm.load %1704 : !llvm.ptr -> i64
%1710 = llvm.mlir.addressof @MOD : !llvm.ptr
%1711 = llvm.load %1710 : !llvm.ptr -> i64
%1712 = arith.addi %1709, %1711 : i64
llvm.store %1712, %1704 : i64, !llvm.ptr
cf.br ^bb224
^bb223:
cf.br ^bb224
^bb224:
%1713 = llvm.load %1704 : !llvm.ptr -> i64
%1714 = llvm.load %1651 : !llvm.ptr -> i64
%1715 = llvm.getelementptr %1641[%1714] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1713, %1715 : i64, !llvm.ptr
%1716 = llvm.load %1651 : !llvm.ptr -> i64
%1717 = arith.constant 1 : i32
%1719 = arith.extsi %1717 : i32 to i64
%1718 = arith.addi %1716, %1719 : i64
llvm.store %1718, %1651 : i64, !llvm.ptr
cf.br ^bb216
^bb218:
%1720 = arith.cmpi sle, %arg0, %arg1 : i64
cf.cond_br %1720, ^bb225, ^bb226
^bb225:
%1722 = llvm.getelementptr %1641[%arg0] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1721 = llvm.load %1722 : !llvm.ptr -> i64
func.call @free(%1621) : (!llvm.ptr) -> ()
func.call @free(%1629) : (!llvm.ptr) -> ()
func.call @free(%1641) : (!llvm.ptr) -> ()
func.return %1721 : i64
^bb226:
cf.br ^bb227
^bb227:
%1727 = arith.constant 8 : i32
%1729 = arith.extsi %1727 : i32 to i64
%1728 = arith.muli %arg1, %1729 : i64
%1726 = func.call @malloc(%1728) : (i64) -> !llvm.ptr
%1730 = arith.constant 1 : i32
%1731 = arith.extsi %1730 : i32 to i64
%1732 = llvm.mlir.constant(1 : i64) : i64
%1733 = llvm.alloca %1732 x i64 : (i64) -> !llvm.ptr
llvm.store %1731, %1733 : i64, !llvm.ptr
cf.br ^bb228
^bb228:
%1734 = llvm.load %1733 : !llvm.ptr -> i64
%1735 = arith.cmpi sle, %1734, %arg1 : i64
cf.cond_br %1735, ^bb229, ^bb230
^bb229:
%1736 = llvm.load %1733 : !llvm.ptr -> i64
%1737 = arith.cmpi slt, %1736, %1633 : i64
%1738 = scf.if %1737 -> (i64) {
%1740 = llvm.load %1733 : !llvm.ptr -> i64
%1741 = llvm.getelementptr %1629[%1740] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1739 = llvm.load %1741 : !llvm.ptr -> i64
scf.yield %1739 : i64
} else {
%1742 = arith.constant 0 : i32
scf.yield %1742 : i32
}
%1743 = llvm.mlir.addressof @MOD : !llvm.ptr
%1744 = llvm.load %1743 : !llvm.ptr -> i64
%1745 = arith.subi %1744, %1738 : i64
%1746 = llvm.mlir.addressof @MOD : !llvm.ptr
%1747 = llvm.load %1746 : !llvm.ptr -> i64
%1748 = arith.remsi %1745, %1747 : i64
%1749 = llvm.load %1733 : !llvm.ptr -> i64
%1750 = arith.constant 1 : i32
%1752 = arith.extsi %1750 : i32 to i64
%1751 = arith.subi %1749, %1752 : i64
%1753 = llvm.getelementptr %1726[%1751] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1748, %1753 : i64, !llvm.ptr
%1754 = llvm.load %1733 : !llvm.ptr -> i64
%1755 = arith.constant 1 : i32
%1757 = arith.extsi %1755 : i32 to i64
%1756 = arith.addi %1754, %1757 : i64
llvm.store %1756, %1733 : i64, !llvm.ptr
cf.br ^bb228
^bb230:
%1759 = arith.constant 8 : i32
%1761 = arith.extsi %1759 : i32 to i64
%1760 = arith.muli %arg1, %1761 : i64
%1758 = func.call @malloc(%1760) : (i64) -> !llvm.ptr
%1762 = arith.constant 0 : i32
%1763 = arith.extsi %1762 : i32 to i64
llvm.store %1763, %1733 : i64, !llvm.ptr
cf.br ^bb231
^bb231:
%1764 = llvm.load %1733 : !llvm.ptr -> i64
%1765 = arith.cmpi slt, %1764, %arg1 : i64
cf.cond_br %1765, ^bb232, ^bb233
^bb232:
%1767 = llvm.load %1733 : !llvm.ptr -> i64
%1768 = arith.constant 1 : i32
%1770 = arith.extsi %1768 : i32 to i64
%1769 = arith.addi %1767, %1770 : i64
%1771 = llvm.getelementptr %1641[%1769] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1766 = llvm.load %1771 : !llvm.ptr -> i64
%1772 = llvm.load %1733 : !llvm.ptr -> i64
%1773 = llvm.getelementptr %1758[%1772] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1766, %1773 : i64, !llvm.ptr
%1774 = llvm.load %1733 : !llvm.ptr -> i64
%1775 = arith.constant 1 : i32
%1777 = arith.extsi %1775 : i32 to i64
%1776 = arith.addi %1774, %1777 : i64
llvm.store %1776, %1733 : i64, !llvm.ptr
cf.br ^bb231
^bb233:
%1779 = arith.constant 1 : i32
%1781 = arith.extsi %1779 : i32 to i64
%1780 = arith.subi %arg0, %1781 : i64
%1778 = func.call @kitamasa(%1758, %1726, %arg1, %1780) : (!llvm.ptr, !llvm.ptr, i64, i64) -> i64
func.call @free(%1621) : (!llvm.ptr) -> ()
func.call @free(%1629) : (!llvm.ptr) -> ()
func.call @free(%1641) : (!llvm.ptr) -> ()
func.call @free(%1726) : (!llvm.ptr) -> ()
func.call @free(%1758) : (!llvm.ptr) -> ()
func.return %1778 : i64
}
func.func @poly_mul_small(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64, %arg5: !llvm.ptr) -> !llvm.ptr {
%1787 = arith.addi %arg1, %arg3 : i64
%1788 = arith.constant 1 : i32
%1790 = arith.extsi %1788 : i32 to i64
%1789 = arith.subi %1787, %1790 : i64
%1791 = llvm.mlir.constant(1 : i64) : i64
%1792 = llvm.alloca %1791 x i64 : (i64) -> !llvm.ptr
llvm.store %1789, %1792 : i64, !llvm.ptr
%1793 = llvm.load %1792 : !llvm.ptr -> i64
%1794 = arith.cmpi sgt, %1793, %arg4 : i64
cf.cond_br %1794, ^bb234, ^bb235
^bb234:
llvm.store %arg4, %1792 : i64, !llvm.ptr
cf.br ^bb236
^bb235:
cf.br ^bb236
^bb236:
%1796 = llvm.load %1792 : !llvm.ptr -> i64
%1797 = arith.constant 8 : i32
%1798 = arith.extsi %1797 : i32 to i64
%1795 = func.call @calloc(%1796, %1798) : (i64, i64) -> !llvm.ptr
%1799 = arith.constant 0 : i32
%1800 = arith.extsi %1799 : i32 to i64
%1801 = llvm.mlir.constant(1 : i64) : i64
%1802 = llvm.alloca %1801 x i64 : (i64) -> !llvm.ptr
llvm.store %1800, %1802 : i64, !llvm.ptr
cf.br ^bb237
^bb237:
%1803 = llvm.load %1802 : !llvm.ptr -> i64
%1804 = arith.cmpi slt, %1803, %arg1 : i64
cf.cond_br %1804, ^bb238, ^bb239
^bb238:
%1806 = llvm.load %1802 : !llvm.ptr -> i64
%1807 = llvm.getelementptr %arg0[%1806] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1805 = llvm.load %1807 : !llvm.ptr -> i64
%1808 = arith.constant 0 : i32
%1810 = arith.extsi %1808 : i32 to i64
%1809 = arith.cmpi ne, %1805, %1810 : i64
cf.cond_br %1809, ^bb240, ^bb241
^bb240:
%1811 = arith.constant 0 : i32
%1812 = arith.extsi %1811 : i32 to i64
%1813 = llvm.mlir.constant(1 : i64) : i64
%1814 = llvm.alloca %1813 x i64 : (i64) -> !llvm.ptr
llvm.store %1812, %1814 : i64, !llvm.ptr
cf.br ^bb243
^bb243:
%1815 = llvm.load %1814 : !llvm.ptr -> i64
%1816 = arith.cmpi slt, %1815, %arg3 : i64
cf.cond_br %1816, ^bb244, ^bb245
^bb244:
%1817 = llvm.load %1802 : !llvm.ptr -> i64
%1818 = llvm.load %1814 : !llvm.ptr -> i64
%1819 = arith.addi %1817, %1818 : i64
%1820 = arith.cmpi sge, %1819, %arg4 : i64
cf.cond_br %1820, ^bb246, ^bb247
^bb246:
cf.br ^bb245
^bb247:
cf.br ^bb248
^bb248:
%1822 = llvm.getelementptr %1795[%1819] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1821 = llvm.load %1822 : !llvm.ptr -> i64
%1824 = llvm.load %1802 : !llvm.ptr -> i64
%1825 = llvm.getelementptr %arg0[%1824] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1823 = llvm.load %1825 : !llvm.ptr -> i64
%1826 = arith.extsi %1823 : i64 to i128
%1828 = llvm.load %1814 : !llvm.ptr -> i64
%1829 = llvm.getelementptr %arg2[%1828] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1827 = llvm.load %1829 : !llvm.ptr -> i64
%1830 = arith.extsi %1827 : i64 to i128
%1832 = arith.trunci %1826 : i128 to i64
%1833 = arith.trunci %1830 : i128 to i64
%1831 = arith.muli %1832, %1833 : i64
%1834 = llvm.mlir.addressof @MOD : !llvm.ptr
%1835 = llvm.load %1834 : !llvm.ptr -> i64
%1836 = arith.extsi %1835 : i64 to i128
%1838 = arith.trunci %1836 : i128 to i64
%1837 = arith.remsi %1831, %1838 : i64
%1839 = arith.addi %1821, %1837 : i64
%1840 = llvm.mlir.addressof @MOD : !llvm.ptr
%1841 = llvm.load %1840 : !llvm.ptr -> i64
%1842 = arith.remsi %1839, %1841 : i64
%1843 = llvm.getelementptr %1795[%1819] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1842, %1843 : i64, !llvm.ptr
%1844 = llvm.load %1814 : !llvm.ptr -> i64
%1845 = arith.constant 1 : i32
%1847 = arith.extsi %1845 : i32 to i64
%1846 = arith.addi %1844, %1847 : i64
llvm.store %1846, %1814 : i64, !llvm.ptr
cf.br ^bb243
^bb245:
cf.br ^bb242
^bb241:
cf.br ^bb242
^bb242:
%1848 = llvm.load %1802 : !llvm.ptr -> i64
%1849 = arith.constant 1 : i32
%1851 = arith.extsi %1849 : i32 to i64
%1850 = arith.addi %1848, %1851 : i64
llvm.store %1850, %1802 : i64, !llvm.ptr
cf.br ^bb237
^bb239:
%1852 = llvm.load %1792 : !llvm.ptr -> i64
%1853 = arith.constant 0 : i32
%1854 = arith.extsi %1853 : i32 to i64
%1855 = llvm.getelementptr %arg5[%1854] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1852, %1855 : i64, !llvm.ptr
func.return %1795 : !llvm.ptr
}
func.func @poly_add_small(%arg0: !llvm.ptr, %arg1: i64, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64) -> !llvm.ptr {
%1857 = arith.constant 8 : i32
%1858 = arith.extsi %1857 : i32 to i64
%1856 = func.call @calloc(%arg4, %1858) : (i64, i64) -> !llvm.ptr
%1859 = arith.constant 0 : i32
%1860 = arith.extsi %1859 : i32 to i64
%1861 = llvm.mlir.constant(1 : i64) : i64
%1862 = llvm.alloca %1861 x i64 : (i64) -> !llvm.ptr
llvm.store %1860, %1862 : i64, !llvm.ptr
cf.br ^bb249
^bb249:
%1863 = llvm.load %1862 : !llvm.ptr -> i64
%1864 = arith.cmpi slt, %1863, %arg4 : i64
cf.cond_br %1864, ^bb250, ^bb251
^bb250:
%1865 = llvm.load %1862 : !llvm.ptr -> i64
%1866 = arith.cmpi slt, %1865, %arg1 : i64
%1867 = scf.if %1866 -> (i64) {
%1869 = llvm.load %1862 : !llvm.ptr -> i64
%1870 = llvm.getelementptr %arg0[%1869] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1868 = llvm.load %1870 : !llvm.ptr -> i64
scf.yield %1868 : i64
} else {
%1871 = arith.constant 0 : i32
scf.yield %1871 : i32
}
%1872 = llvm.load %1862 : !llvm.ptr -> i64
%1873 = arith.cmpi slt, %1872, %arg3 : i64
%1874 = scf.if %1873 -> (i64) {
%1876 = llvm.load %1862 : !llvm.ptr -> i64
%1877 = llvm.getelementptr %arg2[%1876] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1875 = llvm.load %1877 : !llvm.ptr -> i64
scf.yield %1875 : i64
} else {
%1878 = arith.constant 0 : i32
scf.yield %1878 : i32
}
%1879 = arith.addi %1867, %1874 : i64
%1880 = llvm.mlir.addressof @MOD : !llvm.ptr
%1881 = llvm.load %1880 : !llvm.ptr -> i64
%1882 = arith.remsi %1879, %1881 : i64
%1883 = llvm.load %1862 : !llvm.ptr -> i64
%1884 = llvm.getelementptr %1856[%1883] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1882, %1884 : i64, !llvm.ptr
%1885 = llvm.load %1862 : !llvm.ptr -> i64
%1886 = arith.constant 1 : i32
%1888 = arith.extsi %1886 : i32 to i64
%1887 = arith.addi %1885, %1888 : i64
llvm.store %1887, %1862 : i64, !llvm.ptr
cf.br ^bb249
^bb251:
func.return %1856 : !llvm.ptr
}
// Struct: Mat
// Fields:
// m00p: !llvm.ptr
// m00n: i64
// m01p: !llvm.ptr
// m01n: i64
// m10p: !llvm.ptr
// m10n: i64
// m11p: !llvm.ptr
// m11n: i64
func.func @mat_mul(%arg0: !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, %arg1: !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, %arg2: i64) -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> {
%1889 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1890 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1891 = llvm.insertvalue %1890, %1889[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1892 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1893 = llvm.insertvalue %1892, %1891[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1894 = llvm.extractvalue %arg0[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1895 = llvm.insertvalue %1894, %1893[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1896 = llvm.extractvalue %arg0[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1897 = llvm.insertvalue %1896, %1895[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1898 = llvm.extractvalue %arg0[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1899 = llvm.insertvalue %1898, %1897[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1900 = llvm.extractvalue %arg0[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1901 = llvm.insertvalue %1900, %1899[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1902 = llvm.extractvalue %arg0[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1903 = llvm.insertvalue %1902, %1901[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1904 = llvm.extractvalue %arg0[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1905 = llvm.insertvalue %1904, %1903[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1906 = llvm.mlir.constant(1 : i64) : i64
%1907 = llvm.alloca %1906 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1905, %1907 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%1908 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1909 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1910 = llvm.insertvalue %1909, %1908[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1911 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1912 = llvm.insertvalue %1911, %1910[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1913 = llvm.extractvalue %arg1[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1914 = llvm.insertvalue %1913, %1912[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1915 = llvm.extractvalue %arg1[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1916 = llvm.insertvalue %1915, %1914[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1917 = llvm.extractvalue %arg1[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1918 = llvm.insertvalue %1917, %1916[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1919 = llvm.extractvalue %arg1[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1920 = llvm.insertvalue %1919, %1918[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1921 = llvm.extractvalue %arg1[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1922 = llvm.insertvalue %1921, %1920[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1923 = llvm.extractvalue %arg1[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1924 = llvm.insertvalue %1923, %1922[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1925 = llvm.mlir.constant(1 : i64) : i64
%1926 = llvm.alloca %1925 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1924, %1926 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%1928 = arith.constant 1 : i32
%1929 = arith.constant 8 : i32
%1930 = arith.extsi %1928 : i32 to i64
%1931 = arith.extsi %1929 : i32 to i64
%1927 = func.call @calloc(%1930, %1931) : (i64, i64) -> !llvm.ptr
%1933 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1934 = llvm.getelementptr %1907[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1935 = llvm.load %1934 : !llvm.ptr -> !llvm.ptr
%1936 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1937 = llvm.getelementptr %1907[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1938 = llvm.load %1937 : !llvm.ptr -> i64
%1939 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1940 = llvm.getelementptr %1926[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1941 = llvm.load %1940 : !llvm.ptr -> !llvm.ptr
%1942 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1943 = llvm.getelementptr %1926[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1944 = llvm.load %1943 : !llvm.ptr -> i64
%1932 = func.call @poly_mul_small(%1935, %1938, %1941, %1944, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%1946 = arith.constant 0 : i32
%1947 = arith.extsi %1946 : i32 to i64
%1948 = llvm.getelementptr %1927[%1947] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1945 = llvm.load %1948 : !llvm.ptr -> i64
%1950 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1951 = llvm.getelementptr %1907[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1952 = llvm.load %1951 : !llvm.ptr -> !llvm.ptr
%1953 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1954 = llvm.getelementptr %1907[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1955 = llvm.load %1954 : !llvm.ptr -> i64
%1956 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1957 = llvm.getelementptr %1926[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1958 = llvm.load %1957 : !llvm.ptr -> !llvm.ptr
%1959 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1960 = llvm.getelementptr %1926[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1961 = llvm.load %1960 : !llvm.ptr -> i64
%1949 = func.call @poly_mul_small(%1952, %1955, %1958, %1961, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%1963 = arith.constant 0 : i32
%1964 = arith.extsi %1963 : i32 to i64
%1965 = llvm.getelementptr %1927[%1964] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1962 = llvm.load %1965 : !llvm.ptr -> i64
%1966 = func.call @poly_add_small(%1932, %1945, %1949, %1962, %arg2) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%1932) : (!llvm.ptr) -> ()
func.call @free(%1949) : (!llvm.ptr) -> ()
%1970 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1971 = llvm.getelementptr %1907[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1972 = llvm.load %1971 : !llvm.ptr -> !llvm.ptr
%1973 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1974 = llvm.getelementptr %1907[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1975 = llvm.load %1974 : !llvm.ptr -> i64
%1976 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1977 = llvm.getelementptr %1926[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1978 = llvm.load %1977 : !llvm.ptr -> !llvm.ptr
%1979 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1980 = llvm.getelementptr %1926[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1981 = llvm.load %1980 : !llvm.ptr -> i64
%1969 = func.call @poly_mul_small(%1972, %1975, %1978, %1981, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%1983 = arith.constant 0 : i32
%1984 = arith.extsi %1983 : i32 to i64
%1985 = llvm.getelementptr %1927[%1984] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1982 = llvm.load %1985 : !llvm.ptr -> i64
%1987 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1988 = llvm.getelementptr %1907[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1989 = llvm.load %1988 : !llvm.ptr -> !llvm.ptr
%1990 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1991 = llvm.getelementptr %1907[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1992 = llvm.load %1991 : !llvm.ptr -> i64
%1993 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1994 = llvm.getelementptr %1926[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1995 = llvm.load %1994 : !llvm.ptr -> !llvm.ptr
%1996 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1997 = llvm.getelementptr %1926[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%1998 = llvm.load %1997 : !llvm.ptr -> i64
%1986 = func.call @poly_mul_small(%1989, %1992, %1995, %1998, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2000 = arith.constant 0 : i32
%2001 = arith.extsi %2000 : i32 to i64
%2002 = llvm.getelementptr %1927[%2001] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1999 = llvm.load %2002 : !llvm.ptr -> i64
%2003 = func.call @poly_add_small(%1969, %1982, %1986, %1999, %arg2) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%1969) : (!llvm.ptr) -> ()
func.call @free(%1986) : (!llvm.ptr) -> ()
%2007 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2008 = llvm.getelementptr %1907[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2009 = llvm.load %2008 : !llvm.ptr -> !llvm.ptr
%2010 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2011 = llvm.getelementptr %1907[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2012 = llvm.load %2011 : !llvm.ptr -> i64
%2013 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2014 = llvm.getelementptr %1926[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2015 = llvm.load %2014 : !llvm.ptr -> !llvm.ptr
%2016 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2017 = llvm.getelementptr %1926[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2018 = llvm.load %2017 : !llvm.ptr -> i64
%2006 = func.call @poly_mul_small(%2009, %2012, %2015, %2018, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2020 = arith.constant 0 : i32
%2021 = arith.extsi %2020 : i32 to i64
%2022 = llvm.getelementptr %1927[%2021] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2019 = llvm.load %2022 : !llvm.ptr -> i64
%2024 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2025 = llvm.getelementptr %1907[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2026 = llvm.load %2025 : !llvm.ptr -> !llvm.ptr
%2027 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2028 = llvm.getelementptr %1907[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2029 = llvm.load %2028 : !llvm.ptr -> i64
%2030 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2031 = llvm.getelementptr %1926[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2032 = llvm.load %2031 : !llvm.ptr -> !llvm.ptr
%2033 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2034 = llvm.getelementptr %1926[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2035 = llvm.load %2034 : !llvm.ptr -> i64
%2023 = func.call @poly_mul_small(%2026, %2029, %2032, %2035, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2037 = arith.constant 0 : i32
%2038 = arith.extsi %2037 : i32 to i64
%2039 = llvm.getelementptr %1927[%2038] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2036 = llvm.load %2039 : !llvm.ptr -> i64
%2040 = func.call @poly_add_small(%2006, %2019, %2023, %2036, %arg2) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%2006) : (!llvm.ptr) -> ()
func.call @free(%2023) : (!llvm.ptr) -> ()
%2044 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2045 = llvm.getelementptr %1907[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2046 = llvm.load %2045 : !llvm.ptr -> !llvm.ptr
%2047 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2048 = llvm.getelementptr %1907[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2049 = llvm.load %2048 : !llvm.ptr -> i64
%2050 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2051 = llvm.getelementptr %1926[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2052 = llvm.load %2051 : !llvm.ptr -> !llvm.ptr
%2053 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2054 = llvm.getelementptr %1926[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2055 = llvm.load %2054 : !llvm.ptr -> i64
%2043 = func.call @poly_mul_small(%2046, %2049, %2052, %2055, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2057 = arith.constant 0 : i32
%2058 = arith.extsi %2057 : i32 to i64
%2059 = llvm.getelementptr %1927[%2058] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2056 = llvm.load %2059 : !llvm.ptr -> i64
%2061 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2062 = llvm.getelementptr %1907[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2063 = llvm.load %2062 : !llvm.ptr -> !llvm.ptr
%2064 = llvm.load %1907 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2065 = llvm.getelementptr %1907[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2066 = llvm.load %2065 : !llvm.ptr -> i64
%2067 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2068 = llvm.getelementptr %1926[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2069 = llvm.load %2068 : !llvm.ptr -> !llvm.ptr
%2070 = llvm.load %1926 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2071 = llvm.getelementptr %1926[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2072 = llvm.load %2071 : !llvm.ptr -> i64
%2060 = func.call @poly_mul_small(%2063, %2066, %2069, %2072, %arg2, %1927) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2074 = arith.constant 0 : i32
%2075 = arith.extsi %2074 : i32 to i64
%2076 = llvm.getelementptr %1927[%2075] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2073 = llvm.load %2076 : !llvm.ptr -> i64
%2077 = func.call @poly_add_small(%2043, %2056, %2060, %2073, %arg2) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%2043) : (!llvm.ptr) -> ()
func.call @free(%2060) : (!llvm.ptr) -> ()
func.call @free(%1927) : (!llvm.ptr) -> ()
%2081 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2082 = llvm.insertvalue %1966, %2081[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2083 = llvm.insertvalue %arg2, %2082[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2084 = llvm.insertvalue %2003, %2083[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2085 = llvm.insertvalue %arg2, %2084[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2086 = llvm.insertvalue %2040, %2085[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2087 = llvm.insertvalue %arg2, %2086[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2088 = llvm.insertvalue %2077, %2087[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2089 = llvm.insertvalue %arg2, %2088[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2090 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2091 = llvm.extractvalue %2089[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2092 = llvm.insertvalue %2091, %2090[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2093 = llvm.extractvalue %2089[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2094 = llvm.insertvalue %2093, %2092[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2095 = llvm.extractvalue %2089[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2096 = llvm.insertvalue %2095, %2094[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2097 = llvm.extractvalue %2089[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2098 = llvm.insertvalue %2097, %2096[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2099 = llvm.extractvalue %2089[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2100 = llvm.insertvalue %2099, %2098[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2101 = llvm.extractvalue %2089[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2102 = llvm.insertvalue %2101, %2100[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2103 = llvm.extractvalue %2089[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2104 = llvm.insertvalue %2103, %2102[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2105 = llvm.extractvalue %2089[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2106 = llvm.insertvalue %2105, %2104[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2107 = llvm.mlir.constant(1 : i64) : i64
%2108 = llvm.alloca %2107 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2106, %2108 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2109 = llvm.load %2108 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.return %2109 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
}
func.func @mat_free(%arg0: !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> () {
%2110 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2111 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2112 = llvm.insertvalue %2111, %2110[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2113 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2114 = llvm.insertvalue %2113, %2112[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2115 = llvm.extractvalue %arg0[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2116 = llvm.insertvalue %2115, %2114[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2117 = llvm.extractvalue %arg0[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2118 = llvm.insertvalue %2117, %2116[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2119 = llvm.extractvalue %arg0[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2120 = llvm.insertvalue %2119, %2118[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2121 = llvm.extractvalue %arg0[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2122 = llvm.insertvalue %2121, %2120[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2123 = llvm.extractvalue %arg0[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2124 = llvm.insertvalue %2123, %2122[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2125 = llvm.extractvalue %arg0[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2126 = llvm.insertvalue %2125, %2124[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2127 = llvm.mlir.constant(1 : i64) : i64
%2128 = llvm.alloca %2127 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2126, %2128 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2130 = llvm.load %2128 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2131 = llvm.getelementptr %2128[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2132 = llvm.load %2131 : !llvm.ptr -> !llvm.ptr
func.call @free(%2132) : (!llvm.ptr) -> ()
%2134 = llvm.load %2128 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2135 = llvm.getelementptr %2128[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2136 = llvm.load %2135 : !llvm.ptr -> !llvm.ptr
func.call @free(%2136) : (!llvm.ptr) -> ()
%2138 = llvm.load %2128 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2139 = llvm.getelementptr %2128[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2140 = llvm.load %2139 : !llvm.ptr -> !llvm.ptr
func.call @free(%2140) : (!llvm.ptr) -> ()
%2142 = llvm.load %2128 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2143 = llvm.getelementptr %2128[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2144 = llvm.load %2143 : !llvm.ptr -> !llvm.ptr
func.call @free(%2144) : (!llvm.ptr) -> ()
func.return
}
func.func @mat_pow(%arg0: !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, %arg1: i64, %arg2: i64) -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> {
%2145 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2146 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2147 = llvm.insertvalue %2146, %2145[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2148 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2149 = llvm.insertvalue %2148, %2147[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2150 = llvm.extractvalue %arg0[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2151 = llvm.insertvalue %2150, %2149[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2152 = llvm.extractvalue %arg0[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2153 = llvm.insertvalue %2152, %2151[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2154 = llvm.extractvalue %arg0[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2155 = llvm.insertvalue %2154, %2153[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2156 = llvm.extractvalue %arg0[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2157 = llvm.insertvalue %2156, %2155[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2158 = llvm.extractvalue %arg0[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2159 = llvm.insertvalue %2158, %2157[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2160 = llvm.extractvalue %arg0[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2161 = llvm.insertvalue %2160, %2159[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2162 = llvm.mlir.constant(1 : i64) : i64
%2163 = llvm.alloca %2162 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2161, %2163 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2164 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2165 = llvm.mlir.zero : !llvm.ptr
%2166 = llvm.insertvalue %2165, %2164[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2167 = arith.constant 0 : i32
%2168 = arith.extsi %2167 : i32 to i64
%2169 = llvm.insertvalue %2168, %2166[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2170 = llvm.mlir.zero : !llvm.ptr
%2171 = llvm.insertvalue %2170, %2169[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2172 = arith.constant 0 : i32
%2173 = arith.extsi %2172 : i32 to i64
%2174 = llvm.insertvalue %2173, %2171[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2175 = llvm.mlir.zero : !llvm.ptr
%2176 = llvm.insertvalue %2175, %2174[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2177 = arith.constant 0 : i32
%2178 = arith.extsi %2177 : i32 to i64
%2179 = llvm.insertvalue %2178, %2176[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2180 = llvm.mlir.zero : !llvm.ptr
%2181 = llvm.insertvalue %2180, %2179[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2182 = arith.constant 0 : i32
%2183 = arith.extsi %2182 : i32 to i64
%2184 = llvm.insertvalue %2183, %2181[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2185 = llvm.mlir.constant(1 : i64) : i64
%2186 = llvm.alloca %2185 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2184, %2186 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2188 = arith.constant 8 : i32
%2189 = arith.extsi %2188 : i32 to i64
%2187 = func.call @calloc(%arg2, %2189) : (i64, i64) -> !llvm.ptr
%2190 = arith.constant 1 : i32
%2191 = arith.constant 0 : i32
%2192 = arith.extsi %2190 : i32 to i64
%2193 = arith.extsi %2191 : i32 to i64
%2194 = llvm.getelementptr %2187[%2193] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2192, %2194 : i64, !llvm.ptr
%2196 = arith.constant 8 : i32
%2197 = arith.extsi %2196 : i32 to i64
%2195 = func.call @calloc(%arg2, %2197) : (i64, i64) -> !llvm.ptr
%2198 = arith.constant 1 : i32
%2199 = arith.constant 0 : i32
%2200 = arith.extsi %2198 : i32 to i64
%2201 = arith.extsi %2199 : i32 to i64
%2202 = llvm.getelementptr %2195[%2201] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2200, %2202 : i64, !llvm.ptr
%2204 = arith.constant 8 : i32
%2205 = arith.extsi %2204 : i32 to i64
%2203 = func.call @calloc(%arg2, %2205) : (i64, i64) -> !llvm.ptr
%2207 = arith.constant 8 : i32
%2208 = arith.extsi %2207 : i32 to i64
%2206 = func.call @calloc(%arg2, %2208) : (i64, i64) -> !llvm.ptr
%2209 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2210 = llvm.insertvalue %2187, %2209[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2211 = llvm.insertvalue %arg2, %2210[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2212 = llvm.insertvalue %2203, %2211[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2213 = llvm.insertvalue %arg2, %2212[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2214 = llvm.insertvalue %2206, %2213[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2215 = llvm.insertvalue %arg2, %2214[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2216 = llvm.insertvalue %2195, %2215[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2217 = llvm.insertvalue %arg2, %2216[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2217, %2186 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2218 = llvm.load %2163 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2219 = llvm.mlir.constant(1 : i64) : i64
%2220 = llvm.alloca %2219 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2218, %2220 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2221 = arith.constant 0 : i1
%2222 = llvm.mlir.constant(1 : i64) : i64
%2223 = llvm.alloca %2222 x i1 : (i64) -> !llvm.ptr
llvm.store %2221, %2223 : i1, !llvm.ptr
%2224 = llvm.mlir.constant(1 : i64) : i64
%2225 = llvm.alloca %2224 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %2225 : i64, !llvm.ptr
cf.br ^bb252
^bb252:
%2226 = llvm.load %2225 : !llvm.ptr -> i64
%2227 = arith.constant 0 : i32
%2229 = arith.extsi %2227 : i32 to i64
%2228 = arith.cmpi ne, %2226, %2229 : i64
cf.cond_br %2228, ^bb253, ^bb254
^bb253:
%2230 = llvm.load %2225 : !llvm.ptr -> i64
%2231 = arith.constant 2 : i32
%2233 = arith.extsi %2231 : i32 to i64
%2232 = arith.remsi %2230, %2233 : i64
%2234 = arith.constant 1 : i32
%2236 = arith.extsi %2234 : i32 to i64
%2235 = arith.cmpi eq, %2232, %2236 : i64
cf.cond_br %2235, ^bb255, ^bb256
^bb255:
%2238 = llvm.load %2220 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2239 = llvm.load %2186 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2240 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2241 = llvm.extractvalue %2239[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2242 = llvm.insertvalue %2241, %2240[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2243 = llvm.extractvalue %2239[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2244 = llvm.insertvalue %2243, %2242[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2245 = llvm.extractvalue %2239[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2246 = llvm.insertvalue %2245, %2244[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2247 = llvm.extractvalue %2239[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2248 = llvm.insertvalue %2247, %2246[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2249 = llvm.extractvalue %2239[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2250 = llvm.insertvalue %2249, %2248[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2251 = llvm.extractvalue %2239[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2252 = llvm.insertvalue %2251, %2250[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2253 = llvm.extractvalue %2239[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2254 = llvm.insertvalue %2253, %2252[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2255 = llvm.extractvalue %2239[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2256 = llvm.insertvalue %2255, %2254[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2257 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2258 = llvm.extractvalue %2238[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2259 = llvm.insertvalue %2258, %2257[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2260 = llvm.extractvalue %2238[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2261 = llvm.insertvalue %2260, %2259[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2262 = llvm.extractvalue %2238[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2263 = llvm.insertvalue %2262, %2261[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2264 = llvm.extractvalue %2238[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2265 = llvm.insertvalue %2264, %2263[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2266 = llvm.extractvalue %2238[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2267 = llvm.insertvalue %2266, %2265[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2268 = llvm.extractvalue %2238[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2269 = llvm.insertvalue %2268, %2267[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2270 = llvm.extractvalue %2238[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2271 = llvm.insertvalue %2270, %2269[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2272 = llvm.extractvalue %2238[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2273 = llvm.insertvalue %2272, %2271[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2237 = func.call @mat_mul(%2256, %2273, %arg2) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, i64) -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2274 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2275 = llvm.extractvalue %2237[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2276 = llvm.insertvalue %2275, %2274[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2277 = llvm.extractvalue %2237[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2278 = llvm.insertvalue %2277, %2276[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2279 = llvm.extractvalue %2237[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2280 = llvm.insertvalue %2279, %2278[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2281 = llvm.extractvalue %2237[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2282 = llvm.insertvalue %2281, %2280[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2283 = llvm.extractvalue %2237[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2284 = llvm.insertvalue %2283, %2282[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2285 = llvm.extractvalue %2237[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2286 = llvm.insertvalue %2285, %2284[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2287 = llvm.extractvalue %2237[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2288 = llvm.insertvalue %2287, %2286[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2289 = llvm.extractvalue %2237[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2290 = llvm.insertvalue %2289, %2288[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2291 = llvm.mlir.constant(1 : i64) : i64
%2292 = llvm.alloca %2291 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2290, %2292 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2293 = llvm.load %2292 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2294 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2295 = llvm.extractvalue %2256[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2296 = llvm.insertvalue %2295, %2294[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2297 = llvm.extractvalue %2256[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2298 = llvm.insertvalue %2297, %2296[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2299 = llvm.extractvalue %2256[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2300 = llvm.insertvalue %2299, %2298[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2301 = llvm.extractvalue %2256[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2302 = llvm.insertvalue %2301, %2300[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2303 = llvm.extractvalue %2256[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2304 = llvm.insertvalue %2303, %2302[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2305 = llvm.extractvalue %2256[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2306 = llvm.insertvalue %2305, %2304[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2307 = llvm.extractvalue %2256[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2308 = llvm.insertvalue %2307, %2306[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2309 = llvm.extractvalue %2256[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2310 = llvm.insertvalue %2309, %2308[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2311 = llvm.mlir.constant(1 : i64) : i64
%2312 = llvm.alloca %2311 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2310, %2312 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2313 = llvm.load %2312 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2313, %2186 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2314 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2315 = llvm.extractvalue %2273[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2316 = llvm.insertvalue %2315, %2314[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2317 = llvm.extractvalue %2273[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2318 = llvm.insertvalue %2317, %2316[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2319 = llvm.extractvalue %2273[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2320 = llvm.insertvalue %2319, %2318[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2321 = llvm.extractvalue %2273[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2322 = llvm.insertvalue %2321, %2320[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2323 = llvm.extractvalue %2273[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2324 = llvm.insertvalue %2323, %2322[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2325 = llvm.extractvalue %2273[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2326 = llvm.insertvalue %2325, %2324[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2327 = llvm.extractvalue %2273[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2328 = llvm.insertvalue %2327, %2326[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2329 = llvm.extractvalue %2273[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2330 = llvm.insertvalue %2329, %2328[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2331 = llvm.mlir.constant(1 : i64) : i64
%2332 = llvm.alloca %2331 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2330, %2332 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2333 = llvm.load %2332 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2333, %2220 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2334 = llvm.mlir.constant(1 : i64) : i64
%2335 = llvm.alloca %2334 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2293, %2335 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2337 = llvm.load %2186 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.call @mat_free(%2337) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> ()
%2338 = llvm.load %2335 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2338, %2186 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
cf.br ^bb257
^bb256:
cf.br ^bb257
^bb257:
%2340 = llvm.load %2220 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2341 = llvm.load %2220 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2342 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2343 = llvm.extractvalue %2341[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2344 = llvm.insertvalue %2343, %2342[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2345 = llvm.extractvalue %2341[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2346 = llvm.insertvalue %2345, %2344[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2347 = llvm.extractvalue %2341[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2348 = llvm.insertvalue %2347, %2346[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2349 = llvm.extractvalue %2341[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2350 = llvm.insertvalue %2349, %2348[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2351 = llvm.extractvalue %2341[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2352 = llvm.insertvalue %2351, %2350[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2353 = llvm.extractvalue %2341[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2354 = llvm.insertvalue %2353, %2352[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2355 = llvm.extractvalue %2341[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2356 = llvm.insertvalue %2355, %2354[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2357 = llvm.extractvalue %2341[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2358 = llvm.insertvalue %2357, %2356[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2359 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2360 = llvm.extractvalue %2340[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2361 = llvm.insertvalue %2360, %2359[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2362 = llvm.extractvalue %2340[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2363 = llvm.insertvalue %2362, %2361[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2364 = llvm.extractvalue %2340[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2365 = llvm.insertvalue %2364, %2363[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2366 = llvm.extractvalue %2340[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2367 = llvm.insertvalue %2366, %2365[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2368 = llvm.extractvalue %2340[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2369 = llvm.insertvalue %2368, %2367[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2370 = llvm.extractvalue %2340[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2371 = llvm.insertvalue %2370, %2369[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2372 = llvm.extractvalue %2340[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2373 = llvm.insertvalue %2372, %2371[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2374 = llvm.extractvalue %2340[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2375 = llvm.insertvalue %2374, %2373[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2339 = func.call @mat_mul(%2358, %2375, %arg2) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, i64) -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2376 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2377 = llvm.extractvalue %2339[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2378 = llvm.insertvalue %2377, %2376[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2379 = llvm.extractvalue %2339[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2380 = llvm.insertvalue %2379, %2378[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2381 = llvm.extractvalue %2339[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2382 = llvm.insertvalue %2381, %2380[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2383 = llvm.extractvalue %2339[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2384 = llvm.insertvalue %2383, %2382[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2385 = llvm.extractvalue %2339[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2386 = llvm.insertvalue %2385, %2384[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2387 = llvm.extractvalue %2339[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2388 = llvm.insertvalue %2387, %2386[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2389 = llvm.extractvalue %2339[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2390 = llvm.insertvalue %2389, %2388[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2391 = llvm.extractvalue %2339[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2392 = llvm.insertvalue %2391, %2390[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2393 = llvm.mlir.constant(1 : i64) : i64
%2394 = llvm.alloca %2393 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2392, %2394 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2395 = llvm.load %2394 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2396 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2397 = llvm.extractvalue %2358[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2398 = llvm.insertvalue %2397, %2396[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2399 = llvm.extractvalue %2358[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2400 = llvm.insertvalue %2399, %2398[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2401 = llvm.extractvalue %2358[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2402 = llvm.insertvalue %2401, %2400[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2403 = llvm.extractvalue %2358[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2404 = llvm.insertvalue %2403, %2402[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2405 = llvm.extractvalue %2358[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2406 = llvm.insertvalue %2405, %2404[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2407 = llvm.extractvalue %2358[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2408 = llvm.insertvalue %2407, %2406[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2409 = llvm.extractvalue %2358[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2410 = llvm.insertvalue %2409, %2408[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2411 = llvm.extractvalue %2358[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2412 = llvm.insertvalue %2411, %2410[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2413 = llvm.mlir.constant(1 : i64) : i64
%2414 = llvm.alloca %2413 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2412, %2414 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2415 = llvm.load %2414 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2415, %2220 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2416 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2417 = llvm.extractvalue %2375[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2418 = llvm.insertvalue %2417, %2416[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2419 = llvm.extractvalue %2375[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2420 = llvm.insertvalue %2419, %2418[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2421 = llvm.extractvalue %2375[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2422 = llvm.insertvalue %2421, %2420[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2423 = llvm.extractvalue %2375[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2424 = llvm.insertvalue %2423, %2422[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2425 = llvm.extractvalue %2375[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2426 = llvm.insertvalue %2425, %2424[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2427 = llvm.extractvalue %2375[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2428 = llvm.insertvalue %2427, %2426[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2429 = llvm.extractvalue %2375[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2430 = llvm.insertvalue %2429, %2428[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2431 = llvm.extractvalue %2375[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2432 = llvm.insertvalue %2431, %2430[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2433 = llvm.mlir.constant(1 : i64) : i64
%2434 = llvm.alloca %2433 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2432, %2434 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2435 = llvm.load %2434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2435, %2220 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2436 = llvm.mlir.constant(1 : i64) : i64
%2437 = llvm.alloca %2436 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2395, %2437 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2438 = llvm.load %2223 : !llvm.ptr -> i1
cf.cond_br %2438, ^bb258, ^bb259
^bb258:
%2440 = llvm.load %2220 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.call @mat_free(%2440) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> ()
cf.br ^bb260
^bb259:
cf.br ^bb260
^bb260:
%2441 = llvm.load %2437 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2441, %2220 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2442 = arith.constant 1 : i1
llvm.store %2442, %2223 : i1, !llvm.ptr
%2443 = llvm.load %2225 : !llvm.ptr -> i64
%2444 = arith.constant 2 : i32
%2446 = arith.extsi %2444 : i32 to i64
%2445 = arith.divsi %2443, %2446 : i64
llvm.store %2445, %2225 : i64, !llvm.ptr
cf.br ^bb252
^bb254:
%2447 = llvm.load %2223 : !llvm.ptr -> i1
cf.cond_br %2447, ^bb261, ^bb262
^bb261:
%2449 = llvm.load %2220 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.call @mat_free(%2449) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> ()
cf.br ^bb263
^bb262:
cf.br ^bb263
^bb263:
%2450 = llvm.load %2186 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2451 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2452 = llvm.extractvalue %2450[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2453 = llvm.insertvalue %2452, %2451[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2454 = llvm.extractvalue %2450[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2455 = llvm.insertvalue %2454, %2453[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2456 = llvm.extractvalue %2450[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2457 = llvm.insertvalue %2456, %2455[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2458 = llvm.extractvalue %2450[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2459 = llvm.insertvalue %2458, %2457[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2460 = llvm.extractvalue %2450[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2461 = llvm.insertvalue %2460, %2459[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2462 = llvm.extractvalue %2450[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2463 = llvm.insertvalue %2462, %2461[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2464 = llvm.extractvalue %2450[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2465 = llvm.insertvalue %2464, %2463[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2466 = llvm.extractvalue %2450[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2467 = llvm.insertvalue %2466, %2465[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2468 = llvm.mlir.constant(1 : i64) : i64
%2469 = llvm.alloca %2468 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2467, %2469 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2470 = llvm.load %2469 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.return %2470 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
}
func.func @coeff_large_h_small_w(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%2471 = arith.constant 0 : i32
%2473 = arith.extsi %2471 : i32 to i64
%2472 = arith.cmpi sle, %arg1, %2473 : i64
cf.cond_br %2472, ^bb264, ^bb265
^bb264:
%2474 = arith.constant 0 : i32
%2475 = arith.extsi %2474 : i32 to i64
func.return %2475 : i64
^bb265:
cf.br ^bb266
^bb266:
%2476 = arith.constant 1 : i32
%2478 = arith.extsi %2476 : i32 to i64
%2477 = arith.addi %arg0, %2478 : i64
%2479 = arith.constant 1 : i32
%2481 = arith.extsi %2479 : i32 to i64
%2480 = arith.cmpi eq, %arg2, %2481 : i64
%2482 = scf.if %2480 -> (i32) {
%2483 = arith.constant 1 : i32
scf.yield %2483 : i32
} else {
%2484 = llvm.mlir.addressof @MOD : !llvm.ptr
%2485 = llvm.load %2484 : !llvm.ptr -> i64
%2486 = arith.constant 1 : i32
%2488 = arith.extsi %2486 : i32 to i64
%2487 = arith.subi %2485, %2488 : i64
scf.yield %2487 : i64
}
%2489 = arith.extsi %2482 : i32 to i64
%2491 = arith.constant 8 : i32
%2492 = arith.extsi %2491 : i32 to i64
%2490 = func.call @calloc(%2477, %2492) : (i64, i64) -> !llvm.ptr
%2494 = arith.constant 8 : i32
%2495 = arith.extsi %2494 : i32 to i64
%2493 = func.call @calloc(%2477, %2495) : (i64, i64) -> !llvm.ptr
%2496 = arith.constant 1 : i32
%2498 = arith.extsi %2496 : i32 to i64
%2497 = arith.cmpi sge, %arg0, %2498 : i64
cf.cond_br %2497, ^bb267, ^bb268
^bb267:
%2499 = arith.constant 1 : i32
%2500 = arith.extsi %2499 : i32 to i64
%2501 = llvm.getelementptr %2490[%2500] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2489, %2501 : i64, !llvm.ptr
%2502 = llvm.mlir.addressof @MOD : !llvm.ptr
%2503 = llvm.load %2502 : !llvm.ptr -> i64
%2504 = arith.constant 1 : i32
%2506 = arith.extsi %2504 : i32 to i64
%2505 = arith.subi %2503, %2506 : i64
%2507 = arith.constant 1 : i32
%2508 = arith.extsi %2507 : i32 to i64
%2509 = llvm.getelementptr %2493[%2508] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2505, %2509 : i64, !llvm.ptr
cf.br ^bb269
^bb268:
cf.br ^bb269
^bb269:
%2510 = arith.constant 1 : i32
%2511 = arith.constant 0 : i32
%2512 = arith.extsi %2510 : i32 to i64
%2513 = arith.extsi %2511 : i32 to i64
%2514 = llvm.getelementptr %2493[%2513] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2512, %2514 : i64, !llvm.ptr
%2515 = arith.constant 1 : i32
%2517 = arith.extsi %2515 : i32 to i64
%2516 = arith.cmpi eq, %arg1, %2517 : i64
cf.cond_br %2516, ^bb270, ^bb271
^bb270:
%2518 = func.call @series_coeff_mod(%2490, %2477, %2493, %2477, %arg0) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> i64
func.call @free(%2490) : (!llvm.ptr) -> ()
func.call @free(%2493) : (!llvm.ptr) -> ()
func.return %2518 : i64
^bb271:
cf.br ^bb272
^bb272:
%2522 = arith.constant 8 : i32
%2523 = arith.extsi %2522 : i32 to i64
%2521 = func.call @calloc(%2477, %2523) : (i64, i64) -> !llvm.ptr
%2524 = arith.constant 0 : i32
%2525 = arith.extsi %2524 : i32 to i64
%2526 = llvm.getelementptr %2521[%2525] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2489, %2526 : i64, !llvm.ptr
%2527 = arith.constant 2 : i32
%2529 = arith.extsi %2527 : i32 to i64
%2528 = arith.cmpi sge, %2477, %2529 : i64
cf.cond_br %2528, ^bb273, ^bb274
^bb273:
%2530 = arith.constant 1 : i32
%2531 = arith.extsi %2530 : i32 to i64
%2532 = llvm.getelementptr %2521[%2531] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2489, %2532 : i64, !llvm.ptr
cf.br ^bb275
^bb274:
cf.br ^bb275
^bb275:
%2534 = arith.constant 8 : i32
%2535 = arith.extsi %2534 : i32 to i64
%2533 = func.call @calloc(%2477, %2535) : (i64, i64) -> !llvm.ptr
%2536 = arith.constant 2 : i32
%2538 = arith.extsi %2536 : i32 to i64
%2537 = arith.cmpi sge, %2477, %2538 : i64
cf.cond_br %2537, ^bb276, ^bb277
^bb276:
%2539 = arith.constant 1 : i32
%2540 = arith.extsi %2539 : i32 to i64
%2541 = llvm.getelementptr %2533[%2540] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2489, %2541 : i64, !llvm.ptr
cf.br ^bb278
^bb277:
cf.br ^bb278
^bb278:
%2543 = arith.constant 8 : i32
%2544 = arith.extsi %2543 : i32 to i64
%2542 = func.call @calloc(%2477, %2544) : (i64, i64) -> !llvm.ptr
%2545 = arith.constant 2 : i32
%2547 = arith.extsi %2545 : i32 to i64
%2546 = arith.cmpi sge, %2477, %2547 : i64
cf.cond_br %2546, ^bb279, ^bb280
^bb279:
%2548 = llvm.mlir.addressof @MOD : !llvm.ptr
%2549 = llvm.load %2548 : !llvm.ptr -> i64
%2550 = arith.constant 1 : i32
%2552 = arith.extsi %2550 : i32 to i64
%2551 = arith.subi %2549, %2552 : i64
%2553 = arith.constant 1 : i32
%2554 = arith.extsi %2553 : i32 to i64
%2555 = llvm.getelementptr %2542[%2554] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2551, %2555 : i64, !llvm.ptr
cf.br ^bb281
^bb280:
cf.br ^bb281
^bb281:
%2557 = arith.constant 8 : i32
%2558 = arith.extsi %2557 : i32 to i64
%2556 = func.call @calloc(%2477, %2558) : (i64, i64) -> !llvm.ptr
%2559 = arith.constant 1 : i32
%2560 = arith.constant 0 : i32
%2561 = arith.extsi %2559 : i32 to i64
%2562 = arith.extsi %2560 : i32 to i64
%2563 = llvm.getelementptr %2556[%2562] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2561, %2563 : i64, !llvm.ptr
%2564 = arith.constant 2 : i32
%2566 = arith.extsi %2564 : i32 to i64
%2565 = arith.cmpi sge, %2477, %2566 : i64
cf.cond_br %2565, ^bb282, ^bb283
^bb282:
%2567 = llvm.mlir.addressof @MOD : !llvm.ptr
%2568 = llvm.load %2567 : !llvm.ptr -> i64
%2569 = arith.constant 1 : i32
%2571 = arith.extsi %2569 : i32 to i64
%2570 = arith.subi %2568, %2571 : i64
%2572 = arith.constant 1 : i32
%2573 = arith.extsi %2572 : i32 to i64
%2574 = llvm.getelementptr %2556[%2573] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %2570, %2574 : i64, !llvm.ptr
cf.br ^bb284
^bb283:
cf.br ^bb284
^bb284:
%2575 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2576 = llvm.insertvalue %2521, %2575[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2577 = llvm.insertvalue %2477, %2576[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2578 = llvm.insertvalue %2533, %2577[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2579 = llvm.insertvalue %2477, %2578[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2580 = llvm.insertvalue %2542, %2579[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2581 = llvm.insertvalue %2477, %2580[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2582 = llvm.insertvalue %2556, %2581[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2583 = llvm.insertvalue %2477, %2582[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2584 = llvm.mlir.constant(1 : i64) : i64
%2585 = llvm.alloca %2584 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2583, %2585 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2587 = arith.constant 1 : i32
%2589 = arith.extsi %2587 : i32 to i64
%2588 = arith.subi %arg1, %2589 : i64
%2590 = llvm.load %2585 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2591 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2592 = llvm.extractvalue %2590[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2593 = llvm.insertvalue %2592, %2591[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2594 = llvm.extractvalue %2590[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2595 = llvm.insertvalue %2594, %2593[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2596 = llvm.extractvalue %2590[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2597 = llvm.insertvalue %2596, %2595[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2598 = llvm.extractvalue %2590[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2599 = llvm.insertvalue %2598, %2597[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2600 = llvm.extractvalue %2590[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2601 = llvm.insertvalue %2600, %2599[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2602 = llvm.extractvalue %2590[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2603 = llvm.insertvalue %2602, %2601[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2604 = llvm.extractvalue %2590[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2605 = llvm.insertvalue %2604, %2603[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2606 = llvm.extractvalue %2590[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2607 = llvm.insertvalue %2606, %2605[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2586 = func.call @mat_pow(%2607, %2588, %2477) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, i64, i64) -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2608 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2609 = llvm.extractvalue %2586[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2610 = llvm.insertvalue %2609, %2608[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2611 = llvm.extractvalue %2586[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2612 = llvm.insertvalue %2611, %2610[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2613 = llvm.extractvalue %2586[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2614 = llvm.insertvalue %2613, %2612[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2615 = llvm.extractvalue %2586[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2616 = llvm.insertvalue %2615, %2614[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2617 = llvm.extractvalue %2586[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2618 = llvm.insertvalue %2617, %2616[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2619 = llvm.extractvalue %2586[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2620 = llvm.insertvalue %2619, %2618[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2621 = llvm.extractvalue %2586[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2622 = llvm.insertvalue %2621, %2620[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2623 = llvm.extractvalue %2586[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2624 = llvm.insertvalue %2623, %2622[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2625 = llvm.mlir.constant(1 : i64) : i64
%2626 = llvm.alloca %2625 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2624, %2626 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2627 = llvm.load %2626 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2628 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2629 = llvm.extractvalue %2607[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2630 = llvm.insertvalue %2629, %2628[0] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2631 = llvm.extractvalue %2607[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2632 = llvm.insertvalue %2631, %2630[1] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2633 = llvm.extractvalue %2607[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2634 = llvm.insertvalue %2633, %2632[2] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2635 = llvm.extractvalue %2607[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2636 = llvm.insertvalue %2635, %2634[3] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2637 = llvm.extractvalue %2607[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2638 = llvm.insertvalue %2637, %2636[4] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2639 = llvm.extractvalue %2607[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2640 = llvm.insertvalue %2639, %2638[5] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2641 = llvm.extractvalue %2607[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2642 = llvm.insertvalue %2641, %2640[6] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2643 = llvm.extractvalue %2607[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2644 = llvm.insertvalue %2643, %2642[7] : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2645 = llvm.mlir.constant(1 : i64) : i64
%2646 = llvm.alloca %2645 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2644, %2646 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2647 = llvm.load %2646 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
llvm.store %2647, %2585 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2648 = llvm.mlir.constant(1 : i64) : i64
%2649 = llvm.alloca %2648 x !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %2627, %2649 : !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>, !llvm.ptr
%2651 = llvm.load %2585 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.call @mat_free(%2651) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> ()
%2653 = arith.constant 1 : i32
%2654 = arith.constant 8 : i32
%2655 = arith.extsi %2653 : i32 to i64
%2656 = arith.extsi %2654 : i32 to i64
%2652 = func.call @calloc(%2655, %2656) : (i64, i64) -> !llvm.ptr
%2658 = llvm.load %2649 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2659 = llvm.getelementptr %2649[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2660 = llvm.load %2659 : !llvm.ptr -> !llvm.ptr
%2657 = func.call @poly_mul_small(%2660, %2477, %2490, %2477, %2477, %2652) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2662 = arith.constant 0 : i32
%2663 = arith.extsi %2662 : i32 to i64
%2664 = llvm.getelementptr %2652[%2663] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2661 = llvm.load %2664 : !llvm.ptr -> i64
%2666 = llvm.load %2649 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2667 = llvm.getelementptr %2649[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2668 = llvm.load %2667 : !llvm.ptr -> !llvm.ptr
%2665 = func.call @poly_mul_small(%2668, %2477, %2493, %2477, %2477, %2652) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2670 = arith.constant 0 : i32
%2671 = arith.extsi %2670 : i32 to i64
%2672 = llvm.getelementptr %2652[%2671] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2669 = llvm.load %2672 : !llvm.ptr -> i64
%2673 = func.call @poly_add_small(%2657, %2661, %2665, %2669, %2477) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%2657) : (!llvm.ptr) -> ()
func.call @free(%2665) : (!llvm.ptr) -> ()
%2677 = llvm.load %2649 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2678 = llvm.getelementptr %2649[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2679 = llvm.load %2678 : !llvm.ptr -> !llvm.ptr
%2676 = func.call @poly_mul_small(%2679, %2477, %2490, %2477, %2477, %2652) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2681 = arith.constant 0 : i32
%2682 = arith.extsi %2681 : i32 to i64
%2683 = llvm.getelementptr %2652[%2682] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2680 = llvm.load %2683 : !llvm.ptr -> i64
%2685 = llvm.load %2649 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2686 = llvm.getelementptr %2649[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
%2687 = llvm.load %2686 : !llvm.ptr -> !llvm.ptr
%2684 = func.call @poly_mul_small(%2687, %2477, %2493, %2477, %2477, %2652) : (!llvm.ptr, i64, !llvm.ptr, i64, i64, !llvm.ptr) -> !llvm.ptr
%2689 = arith.constant 0 : i32
%2690 = arith.extsi %2689 : i32 to i64
%2691 = llvm.getelementptr %2652[%2690] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2688 = llvm.load %2691 : !llvm.ptr -> i64
%2692 = func.call @poly_add_small(%2676, %2680, %2684, %2688, %2477) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> !llvm.ptr
func.call @free(%2676) : (!llvm.ptr) -> ()
func.call @free(%2684) : (!llvm.ptr) -> ()
func.call @free(%2652) : (!llvm.ptr) -> ()
%2697 = llvm.load %2649 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>
func.call @mat_free(%2697) : (!llvm.struct<(!llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64, !llvm.ptr, i64)>) -> ()
func.call @free(%2490) : (!llvm.ptr) -> ()
func.call @free(%2493) : (!llvm.ptr) -> ()
%2700 = func.call @series_coeff_mod(%2673, %2477, %2692, %2477, %arg0) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> i64
func.call @free(%2673) : (!llvm.ptr) -> ()
func.call @free(%2692) : (!llvm.ptr) -> ()
func.return %2700 : i64
}
func.func @coeff_C_mod(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%2703 = arith.constant 0 : i32
%2705 = arith.extsi %2703 : i32 to i64
%2704 = arith.cmpi sle, %arg1, %2705 : i64
cf.cond_br %2704, ^bb285, ^bb286
^bb285:
%2706 = arith.constant 0 : i32
%2707 = arith.extsi %2706 : i32 to i64
func.return %2707 : i64
^bb286:
cf.br ^bb287
^bb287:
%2708 = arith.constant 200 : i32
%2710 = arith.extsi %2708 : i32 to i64
%2709 = arith.cmpi sle, %arg0, %2710 : i64
%2711 = scf.if %2709 -> (i1) {
%2712 = arith.constant 2000 : i32
%2714 = arith.extsi %2712 : i32 to i64
%2713 = arith.cmpi sgt, %arg1, %2714 : i64
scf.yield %2713 : i1
} else {
%2715 = arith.constant false
scf.yield %2715 : i1
}
cf.cond_br %2711, ^bb288, ^bb289
^bb288:
%2716 = func.call @coeff_large_h_small_w(%arg0, %arg1, %arg2) : (i64, i64, i64) -> i64
func.return %2716 : i64
^bb289:
cf.br ^bb290
^bb290:
%2717 = arith.constant 200 : i32
%2719 = arith.extsi %2717 : i32 to i64
%2718 = arith.cmpi sle, %arg1, %2719 : i64
%2720 = scf.if %2718 -> (i1) {
%2721 = arith.constant 2000 : i32
%2723 = arith.extsi %2721 : i32 to i64
%2722 = arith.cmpi sgt, %arg0, %2723 : i64
scf.yield %2722 : i1
} else {
%2724 = arith.constant false
scf.yield %2724 : i1
}
cf.cond_br %2720, ^bb291, ^bb292
^bb291:
%2725 = func.call @coeff_large_w_small_h(%arg0, %arg1, %arg2) : (i64, i64, i64) -> i64
func.return %2725 : i64
^bb292:
cf.br ^bb293
^bb293:
%2727 = arith.constant 1 : i32
%2728 = arith.constant 8 : i32
%2729 = arith.extsi %2727 : i32 to i64
%2730 = arith.extsi %2728 : i32 to i64
%2726 = func.call @calloc(%2729, %2730) : (i64, i64) -> !llvm.ptr
%2732 = arith.constant 1 : i32
%2733 = arith.constant 8 : i32
%2734 = arith.extsi %2732 : i32 to i64
%2735 = arith.extsi %2733 : i32 to i64
%2731 = func.call @calloc(%2734, %2735) : (i64, i64) -> !llvm.ptr
%2737 = arith.constant 1 : i32
%2738 = arith.constant 8 : i32
%2739 = arith.extsi %2737 : i32 to i64
%2740 = arith.extsi %2738 : i32 to i64
%2736 = func.call @calloc(%2739, %2740) : (i64, i64) -> !llvm.ptr
%2742 = arith.constant 1 : i32
%2743 = arith.constant 8 : i32
%2744 = arith.extsi %2742 : i32 to i64
%2745 = arith.extsi %2743 : i32 to i64
%2741 = func.call @calloc(%2744, %2745) : (i64, i64) -> !llvm.ptr
%2746 = llvm.mlir.constant(1 : i64) : i64
%2747 = llvm.alloca %2746 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %2747 : i64, !llvm.ptr
%2748 = llvm.load %2747 : !llvm.ptr -> i64
%2749 = arith.constant 0 : i32
%2751 = arith.extsi %2749 : i32 to i64
%2750 = arith.cmpi slt, %2748, %2751 : i64
cf.cond_br %2750, ^bb294, ^bb295
^bb294:
%2752 = arith.constant 0 : i32
%2753 = arith.extsi %2752 : i32 to i64
llvm.store %2753, %2747 : i64, !llvm.ptr
cf.br ^bb296
^bb295:
cf.br ^bb296
^bb296:
%2755 = llvm.load %2747 : !llvm.ptr -> i64
func.call @build_PQ_mod(%arg1, %arg2, %2755, %2726, %2731, %2736, %2741) : (i64, i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
%2757 = arith.constant 0 : i32
%2758 = arith.extsi %2757 : i32 to i64
%2759 = llvm.getelementptr %2726[%2758] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%2756 = llvm.load %2759 : !llvm.ptr -> !llvm.ptr
%2761 = arith.constant 0 : i32
%2762 = arith.extsi %2761 : i32 to i64
%2763 = llvm.getelementptr %2731[%2762] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2760 = llvm.load %2763 : !llvm.ptr -> i64
%2765 = arith.constant 0 : i32
%2766 = arith.extsi %2765 : i32 to i64
%2767 = llvm.getelementptr %2736[%2766] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.ptr
%2764 = llvm.load %2767 : !llvm.ptr -> !llvm.ptr
%2769 = arith.constant 0 : i32
%2770 = arith.extsi %2769 : i32 to i64
%2771 = llvm.getelementptr %2741[%2770] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%2768 = llvm.load %2771 : !llvm.ptr -> i64
func.call @free(%2726) : (!llvm.ptr) -> ()
func.call @free(%2731) : (!llvm.ptr) -> ()
func.call @free(%2736) : (!llvm.ptr) -> ()
func.call @free(%2741) : (!llvm.ptr) -> ()
%2776 = func.call @series_coeff_mod(%2756, %2760, %2764, %2768, %arg0) : (!llvm.ptr, i64, !llvm.ptr, i64, i64) -> i64
func.call @free(%2756) : (!llvm.ptr) -> ()
func.call @free(%2764) : (!llvm.ptr) -> ()
func.return %2776 : i64
}
func.func @E_leq_mod(%arg0: i64, %arg1: i64) -> i64 {
%2779 = arith.constant 0 : i32
%2781 = arith.extsi %2779 : i32 to i64
%2780 = arith.cmpi sle, %arg1, %2781 : i64
cf.cond_br %2780, ^bb297, ^bb298
^bb297:
%2782 = arith.constant 0 : i32
%2783 = arith.extsi %2782 : i32 to i64
func.return %2783 : i64
^bb298:
cf.br ^bb299
^bb299:
%2785 = arith.constant 1 : i32
%2786 = arith.extsi %2785 : i32 to i64
%2784 = func.call @coeff_C_mod(%arg0, %arg1, %2786) : (i64, i64, i64) -> i64
%2788 = arith.constant 1 : i32
%2790 = arith.constant 0 : i32
%2789 = arith.subi %2790, %2788 : i32
%2791 = arith.extsi %2789 : i32 to i64
%2787 = func.call @coeff_C_mod(%arg0, %arg1, %2791) : (i64, i64, i64) -> i64
%2792 = arith.addi %2784, %2787 : i64
%2793 = llvm.mlir.addressof @MOD : !llvm.ptr
%2794 = llvm.load %2793 : !llvm.ptr -> i64
%2795 = arith.remsi %2792, %2794 : i64
%2796 = arith.extsi %2795 : i64 to i128
%2797 = llvm.mlir.addressof @INV2 : !llvm.ptr
%2798 = llvm.load %2797 : !llvm.ptr -> i64
%2799 = arith.extsi %2798 : i64 to i128
%2801 = arith.trunci %2796 : i128 to i64
%2802 = arith.trunci %2799 : i128 to i64
%2800 = arith.muli %2801, %2802 : i64
%2803 = llvm.mlir.addressof @MOD : !llvm.ptr
%2804 = llvm.load %2803 : !llvm.ptr -> i64
%2805 = arith.extsi %2804 : i64 to i128
%2807 = arith.trunci %2805 : i128 to i64
%2806 = arith.remsi %2800, %2807 : i64
func.return %2806 : i64
}
func.func @F_mod(%arg0: i64, %arg1: i64) -> i64 {
%2808 = func.call @E_leq_mod(%arg0, %arg1) : (i64, i64) -> i64
%2810 = arith.constant 1 : i32
%2812 = arith.extsi %2810 : i32 to i64
%2811 = arith.subi %arg1, %2812 : i64
%2809 = func.call @E_leq_mod(%arg0, %2811) : (i64, i64) -> i64
%2813 = arith.subi %2808, %2809 : i64
%2814 = llvm.mlir.constant(1 : i64) : i64
%2815 = llvm.alloca %2814 x i64 : (i64) -> !llvm.ptr
llvm.store %2813, %2815 : i64, !llvm.ptr
%2816 = llvm.load %2815 : !llvm.ptr -> i64
%2817 = arith.constant 0 : i32
%2819 = arith.extsi %2817 : i32 to i64
%2818 = arith.cmpi slt, %2816, %2819 : i64
cf.cond_br %2818, ^bb300, ^bb301
^bb300:
%2820 = llvm.load %2815 : !llvm.ptr -> i64
%2821 = llvm.mlir.addressof @MOD : !llvm.ptr
%2822 = llvm.load %2821 : !llvm.ptr -> i64
%2823 = arith.addi %2820, %2822 : i64
llvm.store %2823, %2815 : i64, !llvm.ptr
cf.br ^bb302
^bb301:
cf.br ^bb302
^bb302:
%2824 = llvm.load %2815 : !llvm.ptr -> i64
func.return %2824 : i64
}
func.func @main() -> i32 {
%2826 = arith.constant 995705032704 : i32
%2827 = arith.constant 100 : i32
%2828 = arith.extsi %2826 : i32 to i64
%2829 = arith.extsi %2827 : i32 to i64
%2825 = func.call @F_mod(%2828, %2829) : (i64, i64) -> i64
%2831 = arith.constant 10000 : i32
%2832 = arith.constant 10000 : i32
%2833 = arith.extsi %2831 : i32 to i64
%2834 = arith.extsi %2832 : i32 to i64
%2830 = func.call @F_mod(%2833, %2834) : (i64, i64) -> i64
%2836 = arith.constant 100 : i32
%2837 = arith.constant 995705032704 : i32
%2838 = arith.extsi %2836 : i32 to i64
%2839 = arith.extsi %2837 : i32 to i64
%2835 = func.call @F_mod(%2838, %2839) : (i64, i64) -> i64
%2840 = llvm.mlir.addressof @str_0 : !llvm.ptr
%2841 = arith.addi %2825, %2830 : i64
%2842 = arith.addi %2841, %2835 : i64
%2843 = llvm.mlir.addressof @MOD : !llvm.ptr
%2844 = llvm.load %2843 : !llvm.ptr -> i64
%2845 = arith.remsi %2842, %2844 : i64
%2846 = llvm.call @printf(%2840, %2845) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%2847 = arith.constant 0 : i32
func.return %2847 : i32
}
}