← All problems Problem 913
i128, sieve, factorization, number theory.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^2)O(sqrt(n))Space complexity O(n^2)O(1)Approach Flow solution Trial division or Pollard rho Verdict Suboptimal
Flow source
# Project Euler 913
# i128, sieve, factorization, number theory.
import euler.nt { gcd, lcm }
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function memset(dst: ptr<void>, val: i32, n: i64) -> void
}
const SIEVE_LIMIT: i64 = 100000
const MAX_PF: i32 = 20
const MAX_EX: i32 = 64
let mut g_primes: ptr<i64> = null
let mut g_prime_count: i32 = 0
let mut g_sieve_done: i32 = 0
let mut g_phi: ptr<i64> = null
let mut g_ord: ptr<i64> = null
let mut g_exps: ptr<i32> = null
struct Factors {
p: array<i64, 32>
e: array<i32, 32>
n: i32
}
function factors_zero() -> Factors {
return Factors {
p: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
e: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
n: 0
}
}
function init_sieve() -> void {
if g_sieve_done != 0 { return }
g_sieve_done = 1
let is_comp: ptr<i8> = calloc(SIEVE_LIMIT + 1, 1)
memset(is_comp as ptr<void>, 0, SIEVE_LIMIT + 1)
let mut p: i64 = 2
while p * p <= SIEVE_LIMIT {
if is_comp[p] == 0 {
let mut i: i64 = p * p
while i <= SIEVE_LIMIT {
is_comp[i] = 1
i = i + p
}
}
p = p + 1
}
g_primes = calloc(10000, 8)
let mut i: i64 = 2
while i <= SIEVE_LIMIT {
if is_comp[i] == 0 {
g_primes[g_prime_count] = i
g_prime_count = g_prime_count + 1
}
i = i + 1
}
free(is_comp as ptr<void>)
}
function factorize(n_in: i64) -> Factors {
let mut f: Factors = factors_zero()
let mut n: i64 = n_in
if n <= 1 { return f }
let mut i: i32 = 0
while i < g_prime_count {
let p: i64 = g_primes[i]
if p * p > n { break }
if n % p == 0 {
f.p[f.n] = p
f.e[f.n] = 0
while n % p == 0 {
n = n / p
f.e[f.n] = f.e[f.n] + 1
}
f.n = f.n + 1
}
i = i + 1
}
if n > 1 {
f.p[f.n] = n
f.e[f.n] = 1
f.n = f.n + 1
}
return f
}
function merge_factors(a: Factors, b: Factors) -> Factors {
let mut r: Factors = a
for i in 0..b.n {
let mut found: i32 = 0 - 1
for j in 0..r.n {
if r.p[j] == b.p[i] {
found = j
break
}
}
if found >= 0 {
r.e[found] = r.e[found] + b.e[i]
} else {
r.p[r.n] = b.p[i]
r.e[r.n] = b.e[i]
r.n = r.n + 1
}
}
return r
}
function factorize_t4m1(t: i64) -> Factors {
let f1: Factors = factorize(t - 1)
let f2: Factors = factorize(t + 1)
let f3: Factors = factorize(t * t + 1)
let r: Factors = merge_factors(f1, f2)
return merge_factors(r, f3)
}
function lcm64(a: i64, b: i64) -> i64 {
return (a / gcd(a, b)) * b
}
function powmod128(a_in: i64, e_in: i64, mod: i64) -> i64 {
let mut r: i128 = 1
let mut b: i128 = a_in % mod
if b < 0 { b = b + (mod as i128) }
let mut e: i64 = e_in
while e > 0 {
if (e & 1) != 0 {
r = r * b % (mod as i128)
}
b = b * b % (mod as i128)
e = e >> 1
}
return r as i64
}
function phi_pp(p: i64, a: i32) -> i64 {
if a == 0 { return 1 }
if p == 2 { return (1 as i64) << (a - 1) }
let mut r: i64 = p - 1
let mut i: i32 = 1
while i < a {
r = r * p
i = i + 1
}
return r
}
function carmichael(p: i64, exp: i32) -> i64 {
if exp <= 0 { return 1 }
if p == 2 {
if exp == 1 { return 1 }
if exp == 2 { return 2 }
return (1 as i64) << (exp - 2)
}
let mut r: i64 = p - 1
let mut i: i32 = 1
while i < exp {
r = r * p
i = i + 1
}
return r
}
function mult_order(a_in: i64, p: i64, exp: i32) -> i64 {
let mut mod_: i64 = 1
let mut i: i32 = 0
while i < exp {
mod_ = mod_ * p
i = i + 1
}
if mod_ == 1 { return 1 }
let a: i64 = a_in % mod_
let lam: i64 = carmichael(p, exp)
let q: array<i64, 32> = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let mut qn: i32 = 0
if p == 2 {
if exp >= 2 {
q[qn] = 2
qn = qn + 1
}
} else {
let pf: Factors = factorize(p - 1)
for i in 0..pf.n {
q[qn] = pf.p[i]
qn = qn + 1
}
if exp >= 2 {
q[qn] = p
qn = qn + 1
}
}
let mut order: i64 = lam
for i in 0..qn {
while order % q[i] == 0 {
if powmod128(a, order / q[i], mod_) == 1 {
order = order / q[i]
} else {
break
}
}
}
return order
}
function dfs(i: i32, np: i32, cur_phi: i64, cur_ord: i64, total: ptr<i64>) -> void {
if i == np {
total[0] = total[0] + cur_phi / cur_ord
return
}
let mut a: i32 = 0
while a <= g_exps[i] {
let phi_val: i64 = g_phi[(i as i64) * (MAX_EX as i64) + (a as i64)]
let ord_val: i64 = g_ord[(i as i64) * (MAX_EX as i64) + (a as i64)]
dfs(i + 1, np, cur_phi * phi_val, lcm64(cur_ord, ord_val), total)
a = a + 1
}
}
function sum_phi_over_order(mult: i64, fac: ptr<Factors>) -> i64 {
let np: i32 = fac[0].n
let mut i: i32 = 0
while i < np {
let p: i64 = fac[0].p[i]
let e: i32 = fac[0].e[i]
g_exps[i] = e
let mut a: i32 = 0
while a <= e {
g_phi[(i as i64) * (MAX_EX as i64) + (a as i64)] = phi_pp(p, a)
if a == 0 {
g_ord[(i as i64) * (MAX_EX as i64) + (a as i64)] = 1
} else {
g_ord[(i as i64) * (MAX_EX as i64) + (a as i64)] = mult_order(mult, p, a)
}
a = a + 1
}
i = i + 1
}
let mut total: i64 = 0
dfs(0, np, 1, 1, &total)
return total
}
function main() -> i32 {
init_sieve()
g_phi = calloc((MAX_PF as i64) * (MAX_EX as i64), 8)
g_ord = calloc((MAX_PF as i64) * (MAX_EX as i64), 8)
g_exps = calloc(MAX_PF as i64, 4)
let mut ans: i128 = 0
for n in 2..101 {
for m in n..101 {
let t: i64 = (n as i64) * (m as i64)
let N: i64 = t * t * t * t
let fac: Factors = factorize_t4m1(t)
let mult: i64 = (m as i64) * (m as i64) * (m as i64) * (m as i64)
let contrib: i64 = sum_phi_over_order(mult, &fac)
let S: i64 = (N - 1) - contrib
ans = ans + (S as i128)
}
}
printf("%lld\n", ans as i64)
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 Factors Factors;
struct Factors {
int64_t p[32];
int32_t e[32];
int32_t n;
};
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);
Factors factors_zero(void);
void init_sieve(void);
Factors factorize_i64(int64_t n_in);
Factors merge_factors_Factors_Factors(Factors a, Factors b);
Factors factorize_t4m1_i64(int64_t t);
int64_t lcm64_i64_i64(int64_t a, int64_t b);
int64_t powmod128_i64_i64_i64(int64_t a_in, int64_t e_in, int64_t mod);
int64_t phi_pp_i64_i32(int64_t p, int32_t a);
int64_t carmichael_i64_i32(int64_t p, int32_t exp);
int64_t mult_order_i64_i64_i32(int64_t a_in, int64_t p, int32_t exp);
void dfs_i32_i32_i64_i64_ptr_i64(int32_t i, int32_t np, int64_t cur_phi, int64_t cur_ord, int64_t* total);
int64_t sum_phi_over_order_i64_ptr_Factors(int64_t mult, Factors* fac);
int32_t main(void);
static const int64_t SIEVE_LIMIT = 100000;
static const int32_t MAX_PF = 20;
static const int32_t MAX_EX = 64;
/* Module statics */
static int64_t* g_primes = NULL;
static int32_t g_prime_count = 0;
static int32_t g_sieve_done = 0;
static int64_t* g_phi = NULL;
static int64_t* g_ord = NULL;
static int32_t* g_exps = NULL;
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;
}
Factors factors_zero(void) {
return (Factors){ .p = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, .e = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, .n = 0 };
}
void init_sieve(void) {
if (g_sieve_done != 0) {
return;
}
g_sieve_done = 1;
int8_t* is_comp = (int8_t*)(calloc((SIEVE_LIMIT + 1), 1));
memset(((void*)(is_comp)), 0, (SIEVE_LIMIT + 1));
int64_t p = 2;
while ((p * p) <= SIEVE_LIMIT) {
if (is_comp[p] == 0) {
int64_t i = (p * p);
while (i <= SIEVE_LIMIT) {
is_comp[i] = 1;
i = (i + p);
}
}
p = (p + 1);
}
g_primes = calloc(10000, 8);
int64_t i = 2;
while (i <= SIEVE_LIMIT) {
if (is_comp[i] == 0) {
g_primes[g_prime_count] = i;
g_prime_count = (g_prime_count + 1);
}
i = (i + 1);
}
free(((void*)(is_comp)));
}
Factors factorize_i64(int64_t n_in) {
Factors f = factors_zero();
int64_t n = n_in;
if (n <= 1) {
return f;
}
int32_t i = 0;
while (i < g_prime_count) {
int64_t p = g_primes[i];
if ((p * p) > n) {
break;
}
if (FLOW_CHECKED_MOD((n), (p)) == 0) {
f.p[f.n] = p;
f.e[f.n] = 0;
while (FLOW_CHECKED_MOD((n), (p)) == 0) {
n = FLOW_CHECKED_DIV((n), (p));
f.e[f.n] = (f.e[f.n] + 1);
}
f.n = (f.n + 1);
}
i = (i + 1);
}
if (n > 1) {
f.p[f.n] = n;
f.e[f.n] = 1;
f.n = (f.n + 1);
}
return f;
}
Factors merge_factors_Factors_Factors(Factors a, Factors b) {
Factors r = a;
int32_t __flow_step_1 = 1;
for (int32_t i = 0; (0 <= b.n) ? i < b.n : i > b.n; i += (0 <= b.n) ? 1 : -1) {
int32_t found = (0 - 1);
int32_t __flow_step_2 = 1;
for (int32_t j = 0; (0 <= r.n) ? j < r.n : j > r.n; j += (0 <= r.n) ? 1 : -1) {
if (r.p[j] == b.p[i]) {
found = j;
break;
}
}
if (found >= 0) {
r.e[found] = (r.e[found] + b.e[i]);
} else {
r.p[r.n] = b.p[i];
r.e[r.n] = b.e[i];
r.n = (r.n + 1);
}
}
return r;
}
Factors factorize_t4m1_i64(int64_t t) {
Factors f1 = factorize_i64((t - 1));
Factors f2 = factorize_i64((t + 1));
Factors f3 = factorize_i64(((t * t) + 1));
Factors r = merge_factors_Factors_Factors(f1, f2);
return merge_factors_Factors_Factors(r, f3);
}
int64_t lcm64_i64_i64(int64_t a, int64_t b) {
return (FLOW_CHECKED_DIV((a), (gcd_i64_i64(a, b))) * b);
}
int64_t powmod128_i64_i64_i64(int64_t a_in, int64_t e_in, int64_t mod) {
__int128 r = 1;
__int128 b = FLOW_CHECKED_MOD((a_in), (mod));
if (b < 0) {
b = (b + ((__int128)(mod)));
}
int64_t e = e_in;
while (e > 0) {
if ((e & 1) != 0) {
r = FLOW_CHECKED_MOD(((r * b)), (((__int128)(mod))));
}
b = FLOW_CHECKED_MOD(((b * b)), (((__int128)(mod))));
e = FLOW_CHECKED_SHR((e), (1));
}
return ((int64_t)(r));
}
int64_t phi_pp_i64_i32(int64_t p, int32_t a) {
if (a == 0) {
return 1;
}
if (p == 2) {
return FLOW_CHECKED_SHL((((int64_t)(1))), ((a - 1)));
}
int64_t r = (p - 1);
int32_t i = 1;
while (i < a) {
r = (r * p);
i = (i + 1);
}
return r;
}
int64_t carmichael_i64_i32(int64_t p, int32_t exp) {
if (exp <= 0) {
return 1;
}
if (p == 2) {
if (exp == 1) {
return 1;
}
if (exp == 2) {
return 2;
}
return FLOW_CHECKED_SHL((((int64_t)(1))), ((exp - 2)));
}
int64_t r = (p - 1);
int32_t i = 1;
while (i < exp) {
r = (r * p);
i = (i + 1);
}
return r;
}
int64_t mult_order_i64_i64_i32(int64_t a_in, int64_t p, int32_t exp) {
int64_t mod_ = 1;
int32_t i = 0;
while (i < exp) {
mod_ = (mod_ * p);
i = (i + 1);
}
if (mod_ == 1) {
return 1;
}
int64_t a = FLOW_CHECKED_MOD((a_in), (mod_));
int64_t lam = carmichael_i64_i32(p, exp);
int64_t q[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int32_t qn = 0;
if (p == 2) {
if (exp >= 2) {
q[qn] = 2;
qn = (qn + 1);
}
} else {
Factors pf = factorize_i64((p - 1));
int32_t __flow_step_3 = 1;
for (int32_t i = 0; (0 <= pf.n) ? i < pf.n : i > pf.n; i += (0 <= pf.n) ? 1 : -1) {
q[qn] = pf.p[i];
qn = (qn + 1);
}
if (exp >= 2) {
q[qn] = p;
qn = (qn + 1);
}
}
int64_t order = lam;
int32_t __flow_step_4 = 1;
for (int32_t i = 0; (0 <= qn) ? i < qn : i > qn; i += (0 <= qn) ? 1 : -1) {
while (FLOW_CHECKED_MOD((order), ((((unsigned)(i) < 32) ? q[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 32), flow_fault_handler("array index out of bounds"), q[0])))) == 0) {
if (powmod128_i64_i64_i64(a, FLOW_CHECKED_DIV((order), ((((unsigned)(i) < 32) ? q[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 32), flow_fault_handler("array index out of bounds"), q[0])))), mod_) == 1) {
order = FLOW_CHECKED_DIV((order), ((((unsigned)(i) < 32) ? q[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 32), flow_fault_handler("array index out of bounds"), q[0]))));
} else {
break;
}
}
}
return order;
}
void dfs_i32_i32_i64_i64_ptr_i64(int32_t i, int32_t np, int64_t cur_phi, int64_t cur_ord, int64_t* total) {
if (i == np) {
total[0] = (total[0] + FLOW_CHECKED_DIV((cur_phi), (cur_ord)));
return;
}
int32_t a = 0;
while (a <= g_exps[i]) {
int64_t phi_val = g_phi[((((int64_t)(i)) * ((int64_t)(MAX_EX))) + ((int64_t)(a)))];
int64_t ord_val = g_ord[((((int64_t)(i)) * ((int64_t)(MAX_EX))) + ((int64_t)(a)))];
dfs_i32_i32_i64_i64_ptr_i64((i + 1), np, (cur_phi * phi_val), lcm64_i64_i64(cur_ord, ord_val), total);
a = (a + 1);
}
}
int64_t sum_phi_over_order_i64_ptr_Factors(int64_t mult, Factors* fac) {
int32_t np = fac[0].n;
int32_t i = 0;
while (i < np) {
int64_t p = fac[0].p[i];
int32_t e = fac[0].e[i];
g_exps[i] = e;
int32_t a = 0;
while (a <= e) {
g_phi[((((int64_t)(i)) * ((int64_t)(MAX_EX))) + ((int64_t)(a)))] = phi_pp_i64_i32(p, a);
if (a == 0) {
g_ord[((((int64_t)(i)) * ((int64_t)(MAX_EX))) + ((int64_t)(a)))] = 1;
} else {
g_ord[((((int64_t)(i)) * ((int64_t)(MAX_EX))) + ((int64_t)(a)))] = mult_order_i64_i64_i32(mult, p, a);
}
a = (a + 1);
}
i = (i + 1);
}
int64_t total = 0;
dfs_i32_i32_i64_i64_ptr_i64(0, np, 1, 1, (&(total)));
return total;
}
int32_t main(void) {
init_sieve();
g_phi = calloc((((int64_t)(MAX_PF)) * ((int64_t)(MAX_EX))), 8);
g_ord = calloc((((int64_t)(MAX_PF)) * ((int64_t)(MAX_EX))), 8);
g_exps = calloc(((int64_t)(MAX_PF)), 4);
__int128 ans = 0;
int32_t __flow_step_5 = 1;
for (int32_t n = 2; (2 <= 101) ? n < 101 : n > 101; n += (2 <= 101) ? 1 : -1) {
int32_t __flow_step_6 = 1;
for (int32_t m = n; (n <= 101) ? m < 101 : m > 101; m += (n <= 101) ? 1 : -1) {
int64_t t = (((int64_t)(n)) * ((int64_t)(m)));
int64_t N = (((t * t) * t) * t);
Factors fac = factorize_t4m1_i64(t);
int64_t mult = (((((int64_t)(m)) * ((int64_t)(m))) * ((int64_t)(m))) * ((int64_t)(m)));
int64_t contrib = sum_phi_over_order_i64_ptr_Factors(mult, (&(fac)));
int64_t S = ((N - 1) - contrib);
ans = (ans + ((__int128)(S)));
}
}
printf("%lld\n", ((int64_t)(ans)));
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 @memset(!llvm.ptr, i32, i64) -> ()
// Constant: SIEVE_LIMIT
llvm.mlir.global internal constant @SIEVE_LIMIT(100000 : i64) : i64
// Constant: MAX_PF
llvm.mlir.global internal constant @MAX_PF(20 : i32) : i32
// Constant: MAX_EX
llvm.mlir.global internal constant @MAX_EX(64 : i32) : i32
// Module static: g_primes
llvm.mlir.global internal @g_primes() {addr_space = 0 : i32} : !llvm.ptr {
%175 = llvm.mlir.zero : !llvm.ptr
llvm.return %175 : !llvm.ptr
}
// Module static: g_prime_count
llvm.mlir.global internal @g_prime_count(0 : i32) : i32
// Module static: g_sieve_done
llvm.mlir.global internal @g_sieve_done(0 : i32) : i32
// Module static: g_phi
llvm.mlir.global internal @g_phi() {addr_space = 0 : i32} : !llvm.ptr {
%176 = llvm.mlir.zero : !llvm.ptr
llvm.return %176 : !llvm.ptr
}
// Module static: g_ord
llvm.mlir.global internal @g_ord() {addr_space = 0 : i32} : !llvm.ptr {
%177 = llvm.mlir.zero : !llvm.ptr
llvm.return %177 : !llvm.ptr
}
// Module static: g_exps
llvm.mlir.global internal @g_exps() {addr_space = 0 : i32} : !llvm.ptr {
%178 = llvm.mlir.zero : !llvm.ptr
llvm.return %178 : !llvm.ptr
}
// Struct: Factors
// Fields:
// p: memref<32xi64>
// e: memref<32xi32>
// n: i32
func.func @factors_zero() -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> {
%179 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%180 = llvm.mlir.zero : !llvm.array<32 x i64>
%181 = arith.constant 0 : i32
%182 = arith.extsi %181 : i32 to i64
%183 = llvm.insertvalue %182, %180[0] : !llvm.array<32 x i64>
%184 = arith.constant 0 : i32
%185 = arith.extsi %184 : i32 to i64
%186 = llvm.insertvalue %185, %183[1] : !llvm.array<32 x i64>
%187 = arith.constant 0 : i32
%188 = arith.extsi %187 : i32 to i64
%189 = llvm.insertvalue %188, %186[2] : !llvm.array<32 x i64>
%190 = arith.constant 0 : i32
%191 = arith.extsi %190 : i32 to i64
%192 = llvm.insertvalue %191, %189[3] : !llvm.array<32 x i64>
%193 = arith.constant 0 : i32
%194 = arith.extsi %193 : i32 to i64
%195 = llvm.insertvalue %194, %192[4] : !llvm.array<32 x i64>
%196 = arith.constant 0 : i32
%197 = arith.extsi %196 : i32 to i64
%198 = llvm.insertvalue %197, %195[5] : !llvm.array<32 x i64>
%199 = arith.constant 0 : i32
%200 = arith.extsi %199 : i32 to i64
%201 = llvm.insertvalue %200, %198[6] : !llvm.array<32 x i64>
%202 = arith.constant 0 : i32
%203 = arith.extsi %202 : i32 to i64
%204 = llvm.insertvalue %203, %201[7] : !llvm.array<32 x i64>
%205 = arith.constant 0 : i32
%206 = arith.extsi %205 : i32 to i64
%207 = llvm.insertvalue %206, %204[8] : !llvm.array<32 x i64>
%208 = arith.constant 0 : i32
%209 = arith.extsi %208 : i32 to i64
%210 = llvm.insertvalue %209, %207[9] : !llvm.array<32 x i64>
%211 = arith.constant 0 : i32
%212 = arith.extsi %211 : i32 to i64
%213 = llvm.insertvalue %212, %210[10] : !llvm.array<32 x i64>
%214 = arith.constant 0 : i32
%215 = arith.extsi %214 : i32 to i64
%216 = llvm.insertvalue %215, %213[11] : !llvm.array<32 x i64>
%217 = arith.constant 0 : i32
%218 = arith.extsi %217 : i32 to i64
%219 = llvm.insertvalue %218, %216[12] : !llvm.array<32 x i64>
%220 = arith.constant 0 : i32
%221 = arith.extsi %220 : i32 to i64
%222 = llvm.insertvalue %221, %219[13] : !llvm.array<32 x i64>
%223 = arith.constant 0 : i32
%224 = arith.extsi %223 : i32 to i64
%225 = llvm.insertvalue %224, %222[14] : !llvm.array<32 x i64>
%226 = arith.constant 0 : i32
%227 = arith.extsi %226 : i32 to i64
%228 = llvm.insertvalue %227, %225[15] : !llvm.array<32 x i64>
%229 = arith.constant 0 : i32
%230 = arith.extsi %229 : i32 to i64
%231 = llvm.insertvalue %230, %228[16] : !llvm.array<32 x i64>
%232 = arith.constant 0 : i32
%233 = arith.extsi %232 : i32 to i64
%234 = llvm.insertvalue %233, %231[17] : !llvm.array<32 x i64>
%235 = arith.constant 0 : i32
%236 = arith.extsi %235 : i32 to i64
%237 = llvm.insertvalue %236, %234[18] : !llvm.array<32 x i64>
%238 = arith.constant 0 : i32
%239 = arith.extsi %238 : i32 to i64
%240 = llvm.insertvalue %239, %237[19] : !llvm.array<32 x i64>
%241 = arith.constant 0 : i32
%242 = arith.extsi %241 : i32 to i64
%243 = llvm.insertvalue %242, %240[20] : !llvm.array<32 x i64>
%244 = arith.constant 0 : i32
%245 = arith.extsi %244 : i32 to i64
%246 = llvm.insertvalue %245, %243[21] : !llvm.array<32 x i64>
%247 = arith.constant 0 : i32
%248 = arith.extsi %247 : i32 to i64
%249 = llvm.insertvalue %248, %246[22] : !llvm.array<32 x i64>
%250 = arith.constant 0 : i32
%251 = arith.extsi %250 : i32 to i64
%252 = llvm.insertvalue %251, %249[23] : !llvm.array<32 x i64>
%253 = arith.constant 0 : i32
%254 = arith.extsi %253 : i32 to i64
%255 = llvm.insertvalue %254, %252[24] : !llvm.array<32 x i64>
%256 = arith.constant 0 : i32
%257 = arith.extsi %256 : i32 to i64
%258 = llvm.insertvalue %257, %255[25] : !llvm.array<32 x i64>
%259 = arith.constant 0 : i32
%260 = arith.extsi %259 : i32 to i64
%261 = llvm.insertvalue %260, %258[26] : !llvm.array<32 x i64>
%262 = arith.constant 0 : i32
%263 = arith.extsi %262 : i32 to i64
%264 = llvm.insertvalue %263, %261[27] : !llvm.array<32 x i64>
%265 = arith.constant 0 : i32
%266 = arith.extsi %265 : i32 to i64
%267 = llvm.insertvalue %266, %264[28] : !llvm.array<32 x i64>
%268 = arith.constant 0 : i32
%269 = arith.extsi %268 : i32 to i64
%270 = llvm.insertvalue %269, %267[29] : !llvm.array<32 x i64>
%271 = arith.constant 0 : i32
%272 = arith.extsi %271 : i32 to i64
%273 = llvm.insertvalue %272, %270[30] : !llvm.array<32 x i64>
%274 = arith.constant 0 : i32
%275 = arith.extsi %274 : i32 to i64
%276 = llvm.insertvalue %275, %273[31] : !llvm.array<32 x i64>
%277 = llvm.insertvalue %276, %179[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%278 = llvm.mlir.zero : !llvm.array<32 x i32>
%279 = arith.constant 0 : i32
%280 = llvm.insertvalue %279, %278[0] : !llvm.array<32 x i32>
%281 = arith.constant 0 : i32
%282 = llvm.insertvalue %281, %280[1] : !llvm.array<32 x i32>
%283 = arith.constant 0 : i32
%284 = llvm.insertvalue %283, %282[2] : !llvm.array<32 x i32>
%285 = arith.constant 0 : i32
%286 = llvm.insertvalue %285, %284[3] : !llvm.array<32 x i32>
%287 = arith.constant 0 : i32
%288 = llvm.insertvalue %287, %286[4] : !llvm.array<32 x i32>
%289 = arith.constant 0 : i32
%290 = llvm.insertvalue %289, %288[5] : !llvm.array<32 x i32>
%291 = arith.constant 0 : i32
%292 = llvm.insertvalue %291, %290[6] : !llvm.array<32 x i32>
%293 = arith.constant 0 : i32
%294 = llvm.insertvalue %293, %292[7] : !llvm.array<32 x i32>
%295 = arith.constant 0 : i32
%296 = llvm.insertvalue %295, %294[8] : !llvm.array<32 x i32>
%297 = arith.constant 0 : i32
%298 = llvm.insertvalue %297, %296[9] : !llvm.array<32 x i32>
%299 = arith.constant 0 : i32
%300 = llvm.insertvalue %299, %298[10] : !llvm.array<32 x i32>
%301 = arith.constant 0 : i32
%302 = llvm.insertvalue %301, %300[11] : !llvm.array<32 x i32>
%303 = arith.constant 0 : i32
%304 = llvm.insertvalue %303, %302[12] : !llvm.array<32 x i32>
%305 = arith.constant 0 : i32
%306 = llvm.insertvalue %305, %304[13] : !llvm.array<32 x i32>
%307 = arith.constant 0 : i32
%308 = llvm.insertvalue %307, %306[14] : !llvm.array<32 x i32>
%309 = arith.constant 0 : i32
%310 = llvm.insertvalue %309, %308[15] : !llvm.array<32 x i32>
%311 = arith.constant 0 : i32
%312 = llvm.insertvalue %311, %310[16] : !llvm.array<32 x i32>
%313 = arith.constant 0 : i32
%314 = llvm.insertvalue %313, %312[17] : !llvm.array<32 x i32>
%315 = arith.constant 0 : i32
%316 = llvm.insertvalue %315, %314[18] : !llvm.array<32 x i32>
%317 = arith.constant 0 : i32
%318 = llvm.insertvalue %317, %316[19] : !llvm.array<32 x i32>
%319 = arith.constant 0 : i32
%320 = llvm.insertvalue %319, %318[20] : !llvm.array<32 x i32>
%321 = arith.constant 0 : i32
%322 = llvm.insertvalue %321, %320[21] : !llvm.array<32 x i32>
%323 = arith.constant 0 : i32
%324 = llvm.insertvalue %323, %322[22] : !llvm.array<32 x i32>
%325 = arith.constant 0 : i32
%326 = llvm.insertvalue %325, %324[23] : !llvm.array<32 x i32>
%327 = arith.constant 0 : i32
%328 = llvm.insertvalue %327, %326[24] : !llvm.array<32 x i32>
%329 = arith.constant 0 : i32
%330 = llvm.insertvalue %329, %328[25] : !llvm.array<32 x i32>
%331 = arith.constant 0 : i32
%332 = llvm.insertvalue %331, %330[26] : !llvm.array<32 x i32>
%333 = arith.constant 0 : i32
%334 = llvm.insertvalue %333, %332[27] : !llvm.array<32 x i32>
%335 = arith.constant 0 : i32
%336 = llvm.insertvalue %335, %334[28] : !llvm.array<32 x i32>
%337 = arith.constant 0 : i32
%338 = llvm.insertvalue %337, %336[29] : !llvm.array<32 x i32>
%339 = arith.constant 0 : i32
%340 = llvm.insertvalue %339, %338[30] : !llvm.array<32 x i32>
%341 = arith.constant 0 : i32
%342 = llvm.insertvalue %341, %340[31] : !llvm.array<32 x i32>
%343 = llvm.insertvalue %342, %277[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%344 = arith.constant 0 : i32
%345 = llvm.insertvalue %344, %343[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%346 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%347 = llvm.extractvalue %345[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%348 = llvm.insertvalue %347, %346[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%349 = llvm.extractvalue %345[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%350 = llvm.insertvalue %349, %348[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%351 = llvm.extractvalue %345[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%352 = llvm.insertvalue %351, %350[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%353 = llvm.mlir.constant(1 : i64) : i64
%354 = llvm.alloca %353 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %352, %354 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%355 = llvm.load %354 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
func.return %355 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
}
func.func @init_sieve() -> () {
%356 = llvm.mlir.addressof @g_sieve_done : !llvm.ptr
%357 = llvm.load %356 : !llvm.ptr -> i32
%358 = arith.constant 0 : i32
%359 = arith.cmpi ne, %357, %358 : i32
cf.cond_br %359, ^bb42, ^bb43
^bb42:
func.return
^bb43:
cf.br ^bb44
^bb44:
%360 = arith.constant 1 : i32
%361 = llvm.mlir.addressof @g_sieve_done : !llvm.ptr
llvm.store %360, %361 : i32, !llvm.ptr
%363 = llvm.mlir.addressof @SIEVE_LIMIT : !llvm.ptr
%364 = llvm.load %363 : !llvm.ptr -> i64
%365 = arith.constant 1 : i32
%367 = arith.extsi %365 : i32 to i64
%366 = arith.addi %364, %367 : i64
%368 = arith.constant 1 : i32
%369 = arith.extsi %368 : i32 to i64
%362 = func.call @calloc(%366, %369) : (i64, i64) -> !llvm.ptr
%371 = arith.constant 0 : i32
%372 = llvm.mlir.addressof @SIEVE_LIMIT : !llvm.ptr
%373 = llvm.load %372 : !llvm.ptr -> i64
%374 = arith.constant 1 : i32
%376 = arith.extsi %374 : i32 to i64
%375 = arith.addi %373, %376 : i64
func.call @memset(%362, %371, %375) : (!llvm.ptr, i32, i64) -> ()
%377 = arith.constant 2 : i32
%378 = arith.extsi %377 : i32 to i64
%379 = llvm.mlir.constant(1 : i64) : i64
%380 = llvm.alloca %379 x i64 : (i64) -> !llvm.ptr
llvm.store %378, %380 : i64, !llvm.ptr
cf.br ^bb45
^bb45:
%381 = llvm.load %380 : !llvm.ptr -> i64
%382 = llvm.load %380 : !llvm.ptr -> i64
%383 = arith.muli %381, %382 : i64
%384 = llvm.mlir.addressof @SIEVE_LIMIT : !llvm.ptr
%385 = llvm.load %384 : !llvm.ptr -> i64
%386 = arith.cmpi sle, %383, %385 : i64
cf.cond_br %386, ^bb46, ^bb47
^bb46:
%388 = llvm.load %380 : !llvm.ptr -> i64
%389 = llvm.getelementptr %362[%388] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%387 = llvm.load %389 : !llvm.ptr -> i8
%390 = arith.constant 0 : i32
%392 = arith.extsi %387 : i8 to i32
%391 = arith.cmpi eq, %392, %390 : i32
cf.cond_br %391, ^bb48, ^bb49
^bb48:
%393 = llvm.load %380 : !llvm.ptr -> i64
%394 = llvm.load %380 : !llvm.ptr -> i64
%395 = arith.muli %393, %394 : i64
%396 = llvm.mlir.constant(1 : i64) : i64
%397 = llvm.alloca %396 x i64 : (i64) -> !llvm.ptr
llvm.store %395, %397 : i64, !llvm.ptr
cf.br ^bb51
^bb51:
%398 = llvm.load %397 : !llvm.ptr -> i64
%399 = llvm.mlir.addressof @SIEVE_LIMIT : !llvm.ptr
%400 = llvm.load %399 : !llvm.ptr -> i64
%401 = arith.cmpi sle, %398, %400 : i64
cf.cond_br %401, ^bb52, ^bb53
^bb52:
%402 = arith.constant 1 : i32
%403 = llvm.load %397 : !llvm.ptr -> i64
%404 = arith.trunci %402 : i32 to i8
%405 = llvm.getelementptr %362[%403] : (!llvm.ptr, i64) -> !llvm.ptr, i8
llvm.store %404, %405 : i8, !llvm.ptr
%406 = llvm.load %397 : !llvm.ptr -> i64
%407 = llvm.load %380 : !llvm.ptr -> i64
%408 = arith.addi %406, %407 : i64
llvm.store %408, %397 : i64, !llvm.ptr
cf.br ^bb51
^bb53:
cf.br ^bb50
^bb49:
cf.br ^bb50
^bb50:
%409 = llvm.load %380 : !llvm.ptr -> i64
%410 = arith.constant 1 : i32
%412 = arith.extsi %410 : i32 to i64
%411 = arith.addi %409, %412 : i64
llvm.store %411, %380 : i64, !llvm.ptr
cf.br ^bb45
^bb47:
%414 = arith.constant 10000 : i32
%415 = arith.constant 8 : i32
%416 = arith.extsi %414 : i32 to i64
%417 = arith.extsi %415 : i32 to i64
%413 = func.call @calloc(%416, %417) : (i64, i64) -> !llvm.ptr
%418 = llvm.mlir.addressof @g_primes : !llvm.ptr
llvm.store %413, %418 : !llvm.ptr, !llvm.ptr
%419 = arith.constant 2 : i32
%420 = arith.extsi %419 : i32 to i64
%421 = llvm.mlir.constant(1 : i64) : i64
%422 = llvm.alloca %421 x i64 : (i64) -> !llvm.ptr
llvm.store %420, %422 : i64, !llvm.ptr
cf.br ^bb54
^bb54:
%423 = llvm.load %422 : !llvm.ptr -> i64
%424 = llvm.mlir.addressof @SIEVE_LIMIT : !llvm.ptr
%425 = llvm.load %424 : !llvm.ptr -> i64
%426 = arith.cmpi sle, %423, %425 : i64
cf.cond_br %426, ^bb55, ^bb56
^bb55:
%428 = llvm.load %422 : !llvm.ptr -> i64
%429 = llvm.getelementptr %362[%428] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%427 = llvm.load %429 : !llvm.ptr -> i8
%430 = arith.constant 0 : i32
%432 = arith.extsi %427 : i8 to i32
%431 = arith.cmpi eq, %432, %430 : i32
cf.cond_br %431, ^bb57, ^bb58
^bb57:
%433 = llvm.load %422 : !llvm.ptr -> i64
%434 = llvm.mlir.addressof @g_primes : !llvm.ptr
%435 = llvm.load %434 : !llvm.ptr -> !llvm.ptr
%436 = llvm.mlir.addressof @g_prime_count : !llvm.ptr
%437 = llvm.load %436 : !llvm.ptr -> i32
%438 = arith.extsi %437 : i32 to i64
%439 = llvm.getelementptr %435[%438] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %433, %439 : i64, !llvm.ptr
%440 = llvm.mlir.addressof @g_prime_count : !llvm.ptr
%441 = llvm.load %440 : !llvm.ptr -> i32
%442 = arith.constant 1 : i32
%443 = arith.addi %441, %442 : i32
%444 = llvm.mlir.addressof @g_prime_count : !llvm.ptr
llvm.store %443, %444 : i32, !llvm.ptr
cf.br ^bb59
^bb58:
cf.br ^bb59
^bb59:
%445 = llvm.load %422 : !llvm.ptr -> i64
%446 = arith.constant 1 : i32
%448 = arith.extsi %446 : i32 to i64
%447 = arith.addi %445, %448 : i64
llvm.store %447, %422 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
func.call @free(%362) : (!llvm.ptr) -> ()
func.return
}
func.func @factorize(%arg0: i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> {
%450 = func.call @factors_zero() : () -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%451 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%452 = llvm.extractvalue %450[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%453 = llvm.insertvalue %452, %451[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%454 = llvm.extractvalue %450[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%455 = llvm.insertvalue %454, %453[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%456 = llvm.extractvalue %450[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%457 = llvm.insertvalue %456, %455[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%458 = llvm.mlir.constant(1 : i64) : i64
%459 = llvm.alloca %458 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %457, %459 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%460 = llvm.load %459 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%461 = llvm.mlir.constant(1 : i64) : i64
%462 = llvm.alloca %461 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %460, %462 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%463 = llvm.mlir.constant(1 : i64) : i64
%464 = llvm.alloca %463 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %464 : i64, !llvm.ptr
%465 = llvm.load %464 : !llvm.ptr -> i64
%466 = arith.constant 1 : i32
%468 = arith.extsi %466 : i32 to i64
%467 = arith.cmpi sle, %465, %468 : i64
cf.cond_br %467, ^bb60, ^bb61
^bb60:
%469 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%470 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%471 = llvm.extractvalue %469[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%472 = llvm.insertvalue %471, %470[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%473 = llvm.extractvalue %469[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%474 = llvm.insertvalue %473, %472[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%475 = llvm.extractvalue %469[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%476 = llvm.insertvalue %475, %474[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%477 = llvm.mlir.constant(1 : i64) : i64
%478 = llvm.alloca %477 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %476, %478 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%479 = llvm.load %478 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
func.return %479 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
^bb61:
cf.br ^bb62
^bb62:
%480 = arith.constant 0 : i32
%481 = llvm.mlir.constant(1 : i64) : i64
%482 = llvm.alloca %481 x i32 : (i64) -> !llvm.ptr
llvm.store %480, %482 : i32, !llvm.ptr
cf.br ^bb63
^bb63:
%483 = llvm.load %482 : !llvm.ptr -> i32
%484 = llvm.mlir.addressof @g_prime_count : !llvm.ptr
%485 = llvm.load %484 : !llvm.ptr -> i32
%486 = arith.cmpi slt, %483, %485 : i32
cf.cond_br %486, ^bb64, ^bb65
^bb64:
%488 = llvm.mlir.addressof @g_primes : !llvm.ptr
%489 = llvm.load %488 : !llvm.ptr -> !llvm.ptr
%490 = llvm.load %482 : !llvm.ptr -> i32
%491 = arith.extsi %490 : i32 to i64
%492 = llvm.getelementptr %489[%491] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%487 = llvm.load %492 : !llvm.ptr -> i64
%493 = arith.muli %487, %487 : i64
%494 = llvm.load %464 : !llvm.ptr -> i64
%495 = arith.cmpi sgt, %493, %494 : i64
cf.cond_br %495, ^bb66, ^bb67
^bb66:
cf.br ^bb65
^bb67:
cf.br ^bb68
^bb68:
%496 = llvm.load %464 : !llvm.ptr -> i64
%497 = arith.remsi %496, %487 : i64
%498 = arith.constant 0 : i32
%500 = arith.extsi %498 : i32 to i64
%499 = arith.cmpi eq, %497, %500 : i64
cf.cond_br %499, ^bb69, ^bb70
^bb69:
%501 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%502 = llvm.getelementptr %462[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%503 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%504 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%505 = llvm.load %504 : !llvm.ptr -> i32
%506 = arith.extsi %505 : i32 to i64
%507 = llvm.getelementptr %502[0, %506] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %487, %507 : i64, !llvm.ptr
%508 = arith.constant 0 : i32
%509 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%510 = llvm.getelementptr %462[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%511 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%512 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%513 = llvm.load %512 : !llvm.ptr -> i32
%514 = arith.extsi %513 : i32 to i64
%515 = llvm.getelementptr %510[0, %514] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %508, %515 : i32, !llvm.ptr
cf.br ^bb72
^bb72:
%516 = llvm.load %464 : !llvm.ptr -> i64
%517 = arith.remsi %516, %487 : i64
%518 = arith.constant 0 : i32
%520 = arith.extsi %518 : i32 to i64
%519 = arith.cmpi eq, %517, %520 : i64
cf.cond_br %519, ^bb73, ^bb74
^bb73:
%521 = llvm.load %464 : !llvm.ptr -> i64
%522 = arith.divsi %521, %487 : i64
llvm.store %522, %464 : i64, !llvm.ptr
%524 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%525 = llvm.getelementptr %462[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%526 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%527 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%528 = llvm.load %527 : !llvm.ptr -> i32
%529 = arith.extsi %528 : i32 to i64
%530 = llvm.getelementptr %525[0, %529] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%523 = llvm.load %530 : !llvm.ptr -> i32
%531 = arith.constant 1 : i32
%532 = arith.addi %523, %531 : i32
%533 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%534 = llvm.getelementptr %462[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%535 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%536 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%537 = llvm.load %536 : !llvm.ptr -> i32
%538 = arith.extsi %537 : i32 to i64
%539 = llvm.getelementptr %534[0, %538] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %532, %539 : i32, !llvm.ptr
cf.br ^bb72
^bb74:
%540 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%541 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%542 = llvm.load %541 : !llvm.ptr -> i32
%543 = arith.constant 1 : i32
%544 = arith.addi %542, %543 : i32
%545 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %544, %545 : i32, !llvm.ptr
cf.br ^bb71
^bb70:
cf.br ^bb71
^bb71:
%546 = llvm.load %482 : !llvm.ptr -> i32
%547 = arith.constant 1 : i32
%548 = arith.addi %546, %547 : i32
llvm.store %548, %482 : i32, !llvm.ptr
cf.br ^bb63
^bb65:
%549 = llvm.load %464 : !llvm.ptr -> i64
%550 = arith.constant 1 : i32
%552 = arith.extsi %550 : i32 to i64
%551 = arith.cmpi sgt, %549, %552 : i64
cf.cond_br %551, ^bb75, ^bb76
^bb75:
%553 = llvm.load %464 : !llvm.ptr -> i64
%554 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%555 = llvm.getelementptr %462[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%556 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%557 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%558 = llvm.load %557 : !llvm.ptr -> i32
%559 = arith.extsi %558 : i32 to i64
%560 = llvm.getelementptr %555[0, %559] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %553, %560 : i64, !llvm.ptr
%561 = arith.constant 1 : i32
%562 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%563 = llvm.getelementptr %462[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%564 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%565 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%566 = llvm.load %565 : !llvm.ptr -> i32
%567 = arith.extsi %566 : i32 to i64
%568 = llvm.getelementptr %563[0, %567] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %561, %568 : i32, !llvm.ptr
%569 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%570 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%571 = llvm.load %570 : !llvm.ptr -> i32
%572 = arith.constant 1 : i32
%573 = arith.addi %571, %572 : i32
%574 = llvm.getelementptr %462[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %573, %574 : i32, !llvm.ptr
cf.br ^bb77
^bb76:
cf.br ^bb77
^bb77:
%575 = llvm.load %462 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%576 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%577 = llvm.extractvalue %575[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%578 = llvm.insertvalue %577, %576[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%579 = llvm.extractvalue %575[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%580 = llvm.insertvalue %579, %578[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%581 = llvm.extractvalue %575[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%582 = llvm.insertvalue %581, %580[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%583 = llvm.mlir.constant(1 : i64) : i64
%584 = llvm.alloca %583 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %582, %584 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%585 = llvm.load %584 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
func.return %585 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
}
func.func @merge_factors(%arg0: !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, %arg1: !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> {
%586 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%587 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%588 = llvm.insertvalue %587, %586[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%589 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%590 = llvm.insertvalue %589, %588[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%591 = llvm.extractvalue %arg0[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%592 = llvm.insertvalue %591, %590[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%593 = llvm.mlir.constant(1 : i64) : i64
%594 = llvm.alloca %593 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %592, %594 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%595 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%596 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%597 = llvm.insertvalue %596, %595[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%598 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%599 = llvm.insertvalue %598, %597[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%600 = llvm.extractvalue %arg1[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%601 = llvm.insertvalue %600, %599[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%602 = llvm.mlir.constant(1 : i64) : i64
%603 = llvm.alloca %602 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %601, %603 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%604 = llvm.load %594 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%605 = llvm.mlir.constant(1 : i64) : i64
%606 = llvm.alloca %605 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %604, %606 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%607 = arith.constant 0 : i32
%608 = llvm.load %603 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%609 = llvm.getelementptr %603[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%610 = llvm.load %609 : !llvm.ptr -> i32
%611 = arith.index_cast %607 : i32 to index
%612 = arith.index_cast %610 : i32 to index
%614 = arith.constant 1 : index
%615 = arith.constant -1 : index
%616 = arith.cmpi sle, %611, %612 : index
%613 = arith.select %616, %614, %615 : index
cf.br ^bb78(%611 : index)
^bb78(%617: index):
%618 = arith.cmpi slt, %617, %612 : index
%619 = arith.cmpi sgt, %617, %612 : index
%620 = arith.select %616, %618, %619 : i1
cf.cond_br %620, ^bb79(%617 : index), ^bb80(%617 : index)
^bb79(%621: index):
%622 = arith.constant 0 : i32
%623 = arith.constant 1 : i32
%624 = arith.subi %622, %623 : i32
%625 = llvm.mlir.constant(1 : i64) : i64
%626 = llvm.alloca %625 x i32 : (i64) -> !llvm.ptr
llvm.store %624, %626 : i32, !llvm.ptr
%627 = arith.constant 0 : i32
%628 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%629 = llvm.getelementptr %606[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%630 = llvm.load %629 : !llvm.ptr -> i32
%631 = arith.index_cast %627 : i32 to index
%632 = arith.index_cast %630 : i32 to index
%634 = arith.constant 1 : index
%635 = arith.constant -1 : index
%636 = arith.cmpi sle, %631, %632 : index
%633 = arith.select %636, %634, %635 : index
cf.br ^bb81(%631 : index)
^bb81(%637: index):
%638 = arith.cmpi slt, %637, %632 : index
%639 = arith.cmpi sgt, %637, %632 : index
%640 = arith.select %636, %638, %639 : i1
cf.cond_br %640, ^bb82(%637 : index), ^bb83(%637 : index)
^bb82(%641: index):
%643 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%644 = llvm.getelementptr %606[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%645 = arith.index_cast %641 : index to i64
%646 = llvm.getelementptr %644[0, %645] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%642 = llvm.load %646 : !llvm.ptr -> i64
%648 = llvm.load %603 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%649 = llvm.getelementptr %603[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%650 = arith.index_cast %621 : index to i64
%651 = llvm.getelementptr %649[0, %650] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%647 = llvm.load %651 : !llvm.ptr -> i64
%652 = arith.cmpi eq, %642, %647 : i64
cf.cond_br %652, ^bb84, ^bb85
^bb84:
%653 = arith.index_cast %641 : index to i32
llvm.store %653, %626 : i32, !llvm.ptr
cf.br ^bb83(%641 : index)
^bb85:
cf.br ^bb86
^bb86:
%654 = arith.addi %641, %633 : index
cf.br ^bb81(%654 : index)
^bb83(%655: index):
%656 = llvm.load %626 : !llvm.ptr -> i32
%657 = arith.constant 0 : i32
%658 = arith.cmpi sge, %656, %657 : i32
cf.cond_br %658, ^bb87, ^bb88
^bb87:
%660 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%661 = llvm.getelementptr %606[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%662 = llvm.load %626 : !llvm.ptr -> i32
%663 = arith.extsi %662 : i32 to i64
%664 = llvm.getelementptr %661[0, %663] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%659 = llvm.load %664 : !llvm.ptr -> i32
%666 = llvm.load %603 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%667 = llvm.getelementptr %603[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%668 = arith.index_cast %621 : index to i64
%669 = llvm.getelementptr %667[0, %668] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%665 = llvm.load %669 : !llvm.ptr -> i32
%670 = arith.addi %659, %665 : i32
%671 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%672 = llvm.getelementptr %606[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%673 = llvm.load %626 : !llvm.ptr -> i32
%674 = arith.extsi %673 : i32 to i64
%675 = llvm.getelementptr %672[0, %674] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %670, %675 : i32, !llvm.ptr
cf.br ^bb89
^bb88:
%677 = llvm.load %603 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%678 = llvm.getelementptr %603[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%679 = arith.index_cast %621 : index to i64
%680 = llvm.getelementptr %678[0, %679] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%676 = llvm.load %680 : !llvm.ptr -> i64
%681 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%682 = llvm.getelementptr %606[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%683 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%684 = llvm.getelementptr %606[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%685 = llvm.load %684 : !llvm.ptr -> i32
%686 = arith.extsi %685 : i32 to i64
%687 = llvm.getelementptr %682[0, %686] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %676, %687 : i64, !llvm.ptr
%689 = llvm.load %603 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%690 = llvm.getelementptr %603[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%691 = arith.index_cast %621 : index to i64
%692 = llvm.getelementptr %690[0, %691] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%688 = llvm.load %692 : !llvm.ptr -> i32
%693 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%694 = llvm.getelementptr %606[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%695 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%696 = llvm.getelementptr %606[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%697 = llvm.load %696 : !llvm.ptr -> i32
%698 = arith.extsi %697 : i32 to i64
%699 = llvm.getelementptr %694[0, %698] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %688, %699 : i32, !llvm.ptr
%700 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%701 = llvm.getelementptr %606[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%702 = llvm.load %701 : !llvm.ptr -> i32
%703 = arith.constant 1 : i32
%704 = arith.addi %702, %703 : i32
%705 = llvm.getelementptr %606[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %704, %705 : i32, !llvm.ptr
cf.br ^bb89
^bb89:
%706 = arith.addi %621, %613 : index
cf.br ^bb78(%706 : index)
^bb80(%707: index):
%708 = llvm.load %606 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%709 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%710 = llvm.extractvalue %708[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%711 = llvm.insertvalue %710, %709[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%712 = llvm.extractvalue %708[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%713 = llvm.insertvalue %712, %711[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%714 = llvm.extractvalue %708[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%715 = llvm.insertvalue %714, %713[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%716 = llvm.mlir.constant(1 : i64) : i64
%717 = llvm.alloca %716 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %715, %717 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%718 = llvm.load %717 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
func.return %718 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
}
func.func @factorize_t4m1(%arg0: i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> {
%720 = arith.constant 1 : i32
%722 = arith.extsi %720 : i32 to i64
%721 = arith.subi %arg0, %722 : i64
%719 = func.call @factorize(%721) : (i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%723 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%724 = llvm.extractvalue %719[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%725 = llvm.insertvalue %724, %723[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%726 = llvm.extractvalue %719[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%727 = llvm.insertvalue %726, %725[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%728 = llvm.extractvalue %719[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%729 = llvm.insertvalue %728, %727[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%730 = llvm.mlir.constant(1 : i64) : i64
%731 = llvm.alloca %730 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %729, %731 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%732 = llvm.load %731 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%733 = llvm.mlir.constant(1 : i64) : i64
%734 = llvm.alloca %733 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %732, %734 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%736 = arith.constant 1 : i32
%738 = arith.extsi %736 : i32 to i64
%737 = arith.addi %arg0, %738 : i64
%735 = func.call @factorize(%737) : (i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%739 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%740 = llvm.extractvalue %735[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%741 = llvm.insertvalue %740, %739[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%742 = llvm.extractvalue %735[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%743 = llvm.insertvalue %742, %741[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%744 = llvm.extractvalue %735[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%745 = llvm.insertvalue %744, %743[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%746 = llvm.mlir.constant(1 : i64) : i64
%747 = llvm.alloca %746 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %745, %747 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%748 = llvm.load %747 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%749 = llvm.mlir.constant(1 : i64) : i64
%750 = llvm.alloca %749 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %748, %750 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%752 = arith.muli %arg0, %arg0 : i64
%753 = arith.constant 1 : i32
%755 = arith.extsi %753 : i32 to i64
%754 = arith.addi %752, %755 : i64
%751 = func.call @factorize(%754) : (i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%756 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%757 = llvm.extractvalue %751[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%758 = llvm.insertvalue %757, %756[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%759 = llvm.extractvalue %751[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%760 = llvm.insertvalue %759, %758[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%761 = llvm.extractvalue %751[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%762 = llvm.insertvalue %761, %760[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%763 = llvm.mlir.constant(1 : i64) : i64
%764 = llvm.alloca %763 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %762, %764 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%765 = llvm.load %764 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%766 = llvm.mlir.constant(1 : i64) : i64
%767 = llvm.alloca %766 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %765, %767 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%769 = llvm.load %750 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%770 = llvm.load %734 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%771 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%772 = llvm.extractvalue %770[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%773 = llvm.insertvalue %772, %771[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%774 = llvm.extractvalue %770[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%775 = llvm.insertvalue %774, %773[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%776 = llvm.extractvalue %770[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%777 = llvm.insertvalue %776, %775[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%778 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%779 = llvm.extractvalue %769[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%780 = llvm.insertvalue %779, %778[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%781 = llvm.extractvalue %769[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%782 = llvm.insertvalue %781, %780[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%783 = llvm.extractvalue %769[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%784 = llvm.insertvalue %783, %782[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%768 = func.call @merge_factors(%777, %784) : (!llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%785 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%786 = llvm.extractvalue %768[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%787 = llvm.insertvalue %786, %785[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%788 = llvm.extractvalue %768[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%789 = llvm.insertvalue %788, %787[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%790 = llvm.extractvalue %768[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%791 = llvm.insertvalue %790, %789[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%792 = llvm.mlir.constant(1 : i64) : i64
%793 = llvm.alloca %792 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %791, %793 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%794 = llvm.load %793 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%795 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%796 = llvm.extractvalue %777[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%797 = llvm.insertvalue %796, %795[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%798 = llvm.extractvalue %777[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%799 = llvm.insertvalue %798, %797[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%800 = llvm.extractvalue %777[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%801 = llvm.insertvalue %800, %799[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%802 = llvm.mlir.constant(1 : i64) : i64
%803 = llvm.alloca %802 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %801, %803 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%804 = llvm.load %803 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %804, %734 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%805 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%806 = llvm.extractvalue %784[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%807 = llvm.insertvalue %806, %805[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%808 = llvm.extractvalue %784[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%809 = llvm.insertvalue %808, %807[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%810 = llvm.extractvalue %784[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%811 = llvm.insertvalue %810, %809[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%812 = llvm.mlir.constant(1 : i64) : i64
%813 = llvm.alloca %812 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %811, %813 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%814 = llvm.load %813 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %814, %750 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%815 = llvm.mlir.constant(1 : i64) : i64
%816 = llvm.alloca %815 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %794, %816 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%818 = llvm.load %767 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%819 = llvm.load %816 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%820 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%821 = llvm.extractvalue %819[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%822 = llvm.insertvalue %821, %820[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%823 = llvm.extractvalue %819[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%824 = llvm.insertvalue %823, %822[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%825 = llvm.extractvalue %819[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%826 = llvm.insertvalue %825, %824[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%827 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%828 = llvm.extractvalue %818[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%829 = llvm.insertvalue %828, %827[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%830 = llvm.extractvalue %818[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%831 = llvm.insertvalue %830, %829[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%832 = llvm.extractvalue %818[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%833 = llvm.insertvalue %832, %831[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%817 = func.call @merge_factors(%826, %833) : (!llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%834 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%835 = llvm.extractvalue %817[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%836 = llvm.insertvalue %835, %834[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%837 = llvm.extractvalue %817[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%838 = llvm.insertvalue %837, %836[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%839 = llvm.extractvalue %817[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%840 = llvm.insertvalue %839, %838[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%841 = llvm.mlir.constant(1 : i64) : i64
%842 = llvm.alloca %841 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %840, %842 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%843 = llvm.load %842 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%844 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%845 = llvm.extractvalue %826[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%846 = llvm.insertvalue %845, %844[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%847 = llvm.extractvalue %826[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%848 = llvm.insertvalue %847, %846[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%849 = llvm.extractvalue %826[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%850 = llvm.insertvalue %849, %848[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%851 = llvm.mlir.constant(1 : i64) : i64
%852 = llvm.alloca %851 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %850, %852 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%853 = llvm.load %852 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %853, %816 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%854 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%855 = llvm.extractvalue %833[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%856 = llvm.insertvalue %855, %854[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%857 = llvm.extractvalue %833[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%858 = llvm.insertvalue %857, %856[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%859 = llvm.extractvalue %833[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%860 = llvm.insertvalue %859, %858[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%861 = llvm.mlir.constant(1 : i64) : i64
%862 = llvm.alloca %861 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %860, %862 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%863 = llvm.load %862 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
llvm.store %863, %767 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%864 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%865 = llvm.extractvalue %843[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%866 = llvm.insertvalue %865, %864[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%867 = llvm.extractvalue %843[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%868 = llvm.insertvalue %867, %866[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%869 = llvm.extractvalue %843[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%870 = llvm.insertvalue %869, %868[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%871 = llvm.mlir.constant(1 : i64) : i64
%872 = llvm.alloca %871 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %870, %872 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%873 = llvm.load %872 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
func.return %873 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
}
func.func @lcm64(%arg0: i64, %arg1: i64) -> i64 {
%874 = func.call @gcd(%arg0, %arg1) : (i64, i64) -> i64
%875 = arith.divsi %arg0, %874 : i64
%876 = arith.muli %875, %arg1 : i64
func.return %876 : i64
}
func.func @powmod128(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%877 = arith.constant 1 : i32
%878 = arith.extsi %877 : i32 to i128
%879 = llvm.mlir.constant(1 : i64) : i64
%880 = llvm.alloca %879 x i128 : (i64) -> !llvm.ptr
llvm.store %878, %880 : i128, !llvm.ptr
%881 = arith.remsi %arg0, %arg2 : i64
%882 = arith.extsi %881 : i64 to i128
%883 = llvm.mlir.constant(1 : i64) : i64
%884 = llvm.alloca %883 x i128 : (i64) -> !llvm.ptr
llvm.store %882, %884 : i128, !llvm.ptr
%885 = llvm.load %884 : !llvm.ptr -> i128
%886 = arith.constant 0 : i32
%888 = arith.trunci %885 : i128 to i64
%889 = arith.extsi %886 : i32 to i64
%887 = arith.cmpi slt, %888, %889 : i64
cf.cond_br %887, ^bb90, ^bb91
^bb90:
%890 = llvm.load %884 : !llvm.ptr -> i128
%891 = arith.extsi %arg2 : i64 to i128
%893 = arith.trunci %890 : i128 to i64
%894 = arith.trunci %891 : i128 to i64
%892 = arith.addi %893, %894 : i64
%895 = arith.extsi %892 : i64 to i128
llvm.store %895, %884 : i128, !llvm.ptr
cf.br ^bb92
^bb91:
cf.br ^bb92
^bb92:
%896 = llvm.mlir.constant(1 : i64) : i64
%897 = llvm.alloca %896 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %897 : i64, !llvm.ptr
cf.br ^bb93
^bb93:
%898 = llvm.load %897 : !llvm.ptr -> i64
%899 = arith.constant 0 : i32
%901 = arith.extsi %899 : i32 to i64
%900 = arith.cmpi sgt, %898, %901 : i64
cf.cond_br %900, ^bb94, ^bb95
^bb94:
%902 = llvm.load %897 : !llvm.ptr -> i64
%903 = arith.constant 1 : i32
%905 = arith.extsi %903 : i32 to i64
%904 = arith.andi %902, %905 : i64
%906 = arith.constant 0 : i32
%908 = arith.extsi %906 : i32 to i64
%907 = arith.cmpi ne, %904, %908 : i64
cf.cond_br %907, ^bb96, ^bb97
^bb96:
%909 = llvm.load %880 : !llvm.ptr -> i128
%910 = llvm.load %884 : !llvm.ptr -> i128
%912 = arith.trunci %909 : i128 to i64
%913 = arith.trunci %910 : i128 to i64
%911 = arith.muli %912, %913 : i64
%914 = arith.extsi %arg2 : i64 to i128
%916 = arith.trunci %914 : i128 to i64
%915 = arith.remsi %911, %916 : i64
%917 = arith.extsi %915 : i64 to i128
llvm.store %917, %880 : i128, !llvm.ptr
cf.br ^bb98
^bb97:
cf.br ^bb98
^bb98:
%918 = llvm.load %884 : !llvm.ptr -> i128
%919 = llvm.load %884 : !llvm.ptr -> i128
%921 = arith.trunci %918 : i128 to i64
%922 = arith.trunci %919 : i128 to i64
%920 = arith.muli %921, %922 : i64
%923 = arith.extsi %arg2 : i64 to i128
%925 = arith.trunci %923 : i128 to i64
%924 = arith.remsi %920, %925 : i64
%926 = arith.extsi %924 : i64 to i128
llvm.store %926, %884 : i128, !llvm.ptr
%927 = llvm.load %897 : !llvm.ptr -> i64
%928 = arith.constant 1 : i32
%930 = arith.extsi %928 : i32 to i64
%929 = arith.shrsi %927, %930 : i64
llvm.store %929, %897 : i64, !llvm.ptr
cf.br ^bb93
^bb95:
%931 = llvm.load %880 : !llvm.ptr -> i128
%932 = arith.trunci %931 : i128 to i64
func.return %932 : i64
}
func.func @phi_pp(%arg0: i64, %arg1: i32) -> i64 {
%933 = arith.constant 0 : i32
%934 = arith.cmpi eq, %arg1, %933 : i32
cf.cond_br %934, ^bb99, ^bb100
^bb99:
%935 = arith.constant 1 : i32
%936 = arith.extsi %935 : i32 to i64
func.return %936 : i64
^bb100:
cf.br ^bb101
^bb101:
%937 = arith.constant 2 : i32
%939 = arith.extsi %937 : i32 to i64
%938 = arith.cmpi eq, %arg0, %939 : i64
cf.cond_br %938, ^bb102, ^bb103
^bb102:
%940 = arith.constant 1 : i32
%941 = arith.extsi %940 : i32 to i64
%942 = arith.constant 1 : i32
%943 = arith.subi %arg1, %942 : i32
%945 = arith.extsi %943 : i32 to i64
%944 = arith.shli %941, %945 : i64
func.return %944 : i64
^bb103:
cf.br ^bb104
^bb104:
%946 = arith.constant 1 : i32
%948 = arith.extsi %946 : i32 to i64
%947 = arith.subi %arg0, %948 : i64
%949 = llvm.mlir.constant(1 : i64) : i64
%950 = llvm.alloca %949 x i64 : (i64) -> !llvm.ptr
llvm.store %947, %950 : i64, !llvm.ptr
%951 = arith.constant 1 : i32
%952 = llvm.mlir.constant(1 : i64) : i64
%953 = llvm.alloca %952 x i32 : (i64) -> !llvm.ptr
llvm.store %951, %953 : i32, !llvm.ptr
cf.br ^bb105
^bb105:
%954 = llvm.load %953 : !llvm.ptr -> i32
%955 = arith.cmpi slt, %954, %arg1 : i32
cf.cond_br %955, ^bb106, ^bb107
^bb106:
%956 = llvm.load %950 : !llvm.ptr -> i64
%957 = arith.muli %956, %arg0 : i64
llvm.store %957, %950 : i64, !llvm.ptr
%958 = llvm.load %953 : !llvm.ptr -> i32
%959 = arith.constant 1 : i32
%960 = arith.addi %958, %959 : i32
llvm.store %960, %953 : i32, !llvm.ptr
cf.br ^bb105
^bb107:
%961 = llvm.load %950 : !llvm.ptr -> i64
func.return %961 : i64
}
func.func @carmichael(%arg0: i64, %arg1: i32) -> i64 {
%962 = arith.constant 0 : i32
%963 = arith.cmpi sle, %arg1, %962 : i32
cf.cond_br %963, ^bb108, ^bb109
^bb108:
%964 = arith.constant 1 : i32
%965 = arith.extsi %964 : i32 to i64
func.return %965 : i64
^bb109:
cf.br ^bb110
^bb110:
%966 = arith.constant 2 : i32
%968 = arith.extsi %966 : i32 to i64
%967 = arith.cmpi eq, %arg0, %968 : i64
cf.cond_br %967, ^bb111, ^bb112
^bb111:
%969 = arith.constant 1 : i32
%970 = arith.cmpi eq, %arg1, %969 : i32
cf.cond_br %970, ^bb114, ^bb115
^bb114:
%971 = arith.constant 1 : i32
%972 = arith.extsi %971 : i32 to i64
func.return %972 : i64
^bb115:
cf.br ^bb116
^bb116:
%973 = arith.constant 2 : i32
%974 = arith.cmpi eq, %arg1, %973 : i32
cf.cond_br %974, ^bb117, ^bb118
^bb117:
%975 = arith.constant 2 : i32
%976 = arith.extsi %975 : i32 to i64
func.return %976 : i64
^bb118:
cf.br ^bb119
^bb119:
%977 = arith.constant 1 : i32
%978 = arith.extsi %977 : i32 to i64
%979 = arith.constant 2 : i32
%980 = arith.subi %arg1, %979 : i32
%982 = arith.extsi %980 : i32 to i64
%981 = arith.shli %978, %982 : i64
func.return %981 : i64
^bb112:
cf.br ^bb113
^bb113:
%983 = arith.constant 1 : i32
%985 = arith.extsi %983 : i32 to i64
%984 = arith.subi %arg0, %985 : i64
%986 = llvm.mlir.constant(1 : i64) : i64
%987 = llvm.alloca %986 x i64 : (i64) -> !llvm.ptr
llvm.store %984, %987 : i64, !llvm.ptr
%988 = arith.constant 1 : i32
%989 = llvm.mlir.constant(1 : i64) : i64
%990 = llvm.alloca %989 x i32 : (i64) -> !llvm.ptr
llvm.store %988, %990 : i32, !llvm.ptr
cf.br ^bb120
^bb120:
%991 = llvm.load %990 : !llvm.ptr -> i32
%992 = arith.cmpi slt, %991, %arg1 : i32
cf.cond_br %992, ^bb121, ^bb122
^bb121:
%993 = llvm.load %987 : !llvm.ptr -> i64
%994 = arith.muli %993, %arg0 : i64
llvm.store %994, %987 : i64, !llvm.ptr
%995 = llvm.load %990 : !llvm.ptr -> i32
%996 = arith.constant 1 : i32
%997 = arith.addi %995, %996 : i32
llvm.store %997, %990 : i32, !llvm.ptr
cf.br ^bb120
^bb122:
%998 = llvm.load %987 : !llvm.ptr -> i64
func.return %998 : i64
}
func.func @mult_order(%arg0: i64, %arg1: i64, %arg2: i32) -> i64 {
%999 = arith.constant 1 : i32
%1000 = arith.extsi %999 : i32 to i64
%1001 = llvm.mlir.constant(1 : i64) : i64
%1002 = llvm.alloca %1001 x i64 : (i64) -> !llvm.ptr
llvm.store %1000, %1002 : i64, !llvm.ptr
%1003 = arith.constant 0 : i32
%1004 = llvm.mlir.constant(1 : i64) : i64
%1005 = llvm.alloca %1004 x i32 : (i64) -> !llvm.ptr
llvm.store %1003, %1005 : i32, !llvm.ptr
cf.br ^bb123
^bb123:
%1006 = llvm.load %1005 : !llvm.ptr -> i32
%1007 = arith.cmpi slt, %1006, %arg2 : i32
cf.cond_br %1007, ^bb124, ^bb125
^bb124:
%1008 = llvm.load %1002 : !llvm.ptr -> i64
%1009 = arith.muli %1008, %arg1 : i64
llvm.store %1009, %1002 : i64, !llvm.ptr
%1010 = llvm.load %1005 : !llvm.ptr -> i32
%1011 = arith.constant 1 : i32
%1012 = arith.addi %1010, %1011 : i32
llvm.store %1012, %1005 : i32, !llvm.ptr
cf.br ^bb123
^bb125:
%1013 = llvm.load %1002 : !llvm.ptr -> i64
%1014 = arith.constant 1 : i32
%1016 = arith.extsi %1014 : i32 to i64
%1015 = arith.cmpi eq, %1013, %1016 : i64
cf.cond_br %1015, ^bb126, ^bb127
^bb126:
%1017 = arith.constant 1 : i32
%1018 = arith.extsi %1017 : i32 to i64
func.return %1018 : i64
^bb127:
cf.br ^bb128
^bb128:
%1019 = llvm.load %1002 : !llvm.ptr -> i64
%1020 = arith.remsi %arg0, %1019 : i64
%1021 = func.call @carmichael(%arg1, %arg2) : (i64, i32) -> i64
%1023 = arith.constant 0 : i32
%1024 = arith.constant 0 : i32
%1025 = arith.constant 0 : i32
%1026 = arith.constant 0 : i32
%1027 = arith.constant 0 : i32
%1028 = arith.constant 0 : i32
%1029 = arith.constant 0 : i32
%1030 = arith.constant 0 : i32
%1031 = arith.constant 0 : i32
%1032 = arith.constant 0 : i32
%1033 = arith.constant 0 : i32
%1034 = arith.constant 0 : i32
%1035 = arith.constant 0 : i32
%1036 = arith.constant 0 : i32
%1037 = arith.constant 0 : i32
%1038 = arith.constant 0 : i32
%1039 = arith.constant 0 : i32
%1040 = arith.constant 0 : i32
%1041 = arith.constant 0 : i32
%1042 = arith.constant 0 : i32
%1043 = arith.constant 0 : i32
%1044 = arith.constant 0 : i32
%1045 = arith.constant 0 : i32
%1046 = arith.constant 0 : i32
%1047 = arith.constant 0 : i32
%1048 = arith.constant 0 : i32
%1049 = arith.constant 0 : i32
%1050 = arith.constant 0 : i32
%1051 = arith.constant 0 : i32
%1052 = arith.constant 0 : i32
%1053 = arith.constant 0 : i32
%1054 = arith.constant 0 : i32
%1055 = llvm.mlir.constant(1 : i64) : i64
%1056 = llvm.alloca %1055 x !llvm.array<32 x i64> : (i64) -> !llvm.ptr
%1057 = llvm.mlir.zero : !llvm.array<32 x i64>
llvm.store %1057, %1056 : !llvm.array<32 x i64>, !llvm.ptr
%1058 = arith.extsi %1023 : i32 to i64
%1059 = arith.extsi %1024 : i32 to i64
%1060 = arith.extsi %1025 : i32 to i64
%1061 = arith.extsi %1026 : i32 to i64
%1062 = arith.extsi %1027 : i32 to i64
%1063 = arith.extsi %1028 : i32 to i64
%1064 = arith.extsi %1029 : i32 to i64
%1065 = arith.extsi %1030 : i32 to i64
%1066 = arith.extsi %1031 : i32 to i64
%1067 = arith.extsi %1032 : i32 to i64
%1068 = arith.extsi %1033 : i32 to i64
%1069 = arith.extsi %1034 : i32 to i64
%1070 = arith.extsi %1035 : i32 to i64
%1071 = arith.extsi %1036 : i32 to i64
%1072 = arith.extsi %1037 : i32 to i64
%1073 = arith.extsi %1038 : i32 to i64
%1074 = arith.extsi %1039 : i32 to i64
%1075 = arith.extsi %1040 : i32 to i64
%1076 = arith.extsi %1041 : i32 to i64
%1077 = arith.extsi %1042 : i32 to i64
%1078 = arith.extsi %1043 : i32 to i64
%1079 = arith.extsi %1044 : i32 to i64
%1080 = arith.extsi %1045 : i32 to i64
%1081 = arith.extsi %1046 : i32 to i64
%1082 = arith.extsi %1047 : i32 to i64
%1083 = arith.extsi %1048 : i32 to i64
%1084 = arith.extsi %1049 : i32 to i64
%1085 = arith.extsi %1050 : i32 to i64
%1086 = arith.extsi %1051 : i32 to i64
%1087 = arith.extsi %1052 : i32 to i64
%1088 = arith.extsi %1053 : i32 to i64
%1089 = arith.extsi %1054 : i32 to i64
%1090 = llvm.mlir.constant(0 : i64) : i64
%1091 = llvm.getelementptr %1056[0, %1090] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1058, %1091 : i64, !llvm.ptr
%1092 = llvm.mlir.constant(1 : i64) : i64
%1093 = llvm.getelementptr %1056[0, %1092] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1059, %1093 : i64, !llvm.ptr
%1094 = llvm.mlir.constant(2 : i64) : i64
%1095 = llvm.getelementptr %1056[0, %1094] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1060, %1095 : i64, !llvm.ptr
%1096 = llvm.mlir.constant(3 : i64) : i64
%1097 = llvm.getelementptr %1056[0, %1096] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1061, %1097 : i64, !llvm.ptr
%1098 = llvm.mlir.constant(4 : i64) : i64
%1099 = llvm.getelementptr %1056[0, %1098] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1062, %1099 : i64, !llvm.ptr
%1100 = llvm.mlir.constant(5 : i64) : i64
%1101 = llvm.getelementptr %1056[0, %1100] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1063, %1101 : i64, !llvm.ptr
%1102 = llvm.mlir.constant(6 : i64) : i64
%1103 = llvm.getelementptr %1056[0, %1102] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1064, %1103 : i64, !llvm.ptr
%1104 = llvm.mlir.constant(7 : i64) : i64
%1105 = llvm.getelementptr %1056[0, %1104] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1065, %1105 : i64, !llvm.ptr
%1106 = llvm.mlir.constant(8 : i64) : i64
%1107 = llvm.getelementptr %1056[0, %1106] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1066, %1107 : i64, !llvm.ptr
%1108 = llvm.mlir.constant(9 : i64) : i64
%1109 = llvm.getelementptr %1056[0, %1108] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1067, %1109 : i64, !llvm.ptr
%1110 = llvm.mlir.constant(10 : i64) : i64
%1111 = llvm.getelementptr %1056[0, %1110] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1068, %1111 : i64, !llvm.ptr
%1112 = llvm.mlir.constant(11 : i64) : i64
%1113 = llvm.getelementptr %1056[0, %1112] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1069, %1113 : i64, !llvm.ptr
%1114 = llvm.mlir.constant(12 : i64) : i64
%1115 = llvm.getelementptr %1056[0, %1114] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1070, %1115 : i64, !llvm.ptr
%1116 = llvm.mlir.constant(13 : i64) : i64
%1117 = llvm.getelementptr %1056[0, %1116] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1071, %1117 : i64, !llvm.ptr
%1118 = llvm.mlir.constant(14 : i64) : i64
%1119 = llvm.getelementptr %1056[0, %1118] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1072, %1119 : i64, !llvm.ptr
%1120 = llvm.mlir.constant(15 : i64) : i64
%1121 = llvm.getelementptr %1056[0, %1120] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1073, %1121 : i64, !llvm.ptr
%1122 = llvm.mlir.constant(16 : i64) : i64
%1123 = llvm.getelementptr %1056[0, %1122] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1074, %1123 : i64, !llvm.ptr
%1124 = llvm.mlir.constant(17 : i64) : i64
%1125 = llvm.getelementptr %1056[0, %1124] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1075, %1125 : i64, !llvm.ptr
%1126 = llvm.mlir.constant(18 : i64) : i64
%1127 = llvm.getelementptr %1056[0, %1126] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1076, %1127 : i64, !llvm.ptr
%1128 = llvm.mlir.constant(19 : i64) : i64
%1129 = llvm.getelementptr %1056[0, %1128] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1077, %1129 : i64, !llvm.ptr
%1130 = llvm.mlir.constant(20 : i64) : i64
%1131 = llvm.getelementptr %1056[0, %1130] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1078, %1131 : i64, !llvm.ptr
%1132 = llvm.mlir.constant(21 : i64) : i64
%1133 = llvm.getelementptr %1056[0, %1132] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1079, %1133 : i64, !llvm.ptr
%1134 = llvm.mlir.constant(22 : i64) : i64
%1135 = llvm.getelementptr %1056[0, %1134] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1080, %1135 : i64, !llvm.ptr
%1136 = llvm.mlir.constant(23 : i64) : i64
%1137 = llvm.getelementptr %1056[0, %1136] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1081, %1137 : i64, !llvm.ptr
%1138 = llvm.mlir.constant(24 : i64) : i64
%1139 = llvm.getelementptr %1056[0, %1138] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1082, %1139 : i64, !llvm.ptr
%1140 = llvm.mlir.constant(25 : i64) : i64
%1141 = llvm.getelementptr %1056[0, %1140] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1083, %1141 : i64, !llvm.ptr
%1142 = llvm.mlir.constant(26 : i64) : i64
%1143 = llvm.getelementptr %1056[0, %1142] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1084, %1143 : i64, !llvm.ptr
%1144 = llvm.mlir.constant(27 : i64) : i64
%1145 = llvm.getelementptr %1056[0, %1144] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1085, %1145 : i64, !llvm.ptr
%1146 = llvm.mlir.constant(28 : i64) : i64
%1147 = llvm.getelementptr %1056[0, %1146] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1086, %1147 : i64, !llvm.ptr
%1148 = llvm.mlir.constant(29 : i64) : i64
%1149 = llvm.getelementptr %1056[0, %1148] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1087, %1149 : i64, !llvm.ptr
%1150 = llvm.mlir.constant(30 : i64) : i64
%1151 = llvm.getelementptr %1056[0, %1150] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1088, %1151 : i64, !llvm.ptr
%1152 = llvm.mlir.constant(31 : i64) : i64
%1153 = llvm.getelementptr %1056[0, %1152] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1089, %1153 : i64, !llvm.ptr
%1154 = arith.constant 0 : i32
%1155 = llvm.mlir.constant(1 : i64) : i64
%1156 = llvm.alloca %1155 x i32 : (i64) -> !llvm.ptr
llvm.store %1154, %1156 : i32, !llvm.ptr
%1157 = arith.constant 2 : i32
%1159 = arith.extsi %1157 : i32 to i64
%1158 = arith.cmpi eq, %arg1, %1159 : i64
cf.cond_br %1158, ^bb129, ^bb130
^bb129:
%1160 = arith.constant 2 : i32
%1161 = arith.cmpi sge, %arg2, %1160 : i32
cf.cond_br %1161, ^bb132, ^bb133
^bb132:
%1162 = arith.constant 2 : i32
%1163 = llvm.load %1156 : !llvm.ptr -> i32
%1164 = arith.extsi %1162 : i32 to i64
%1165 = arith.extsi %1163 : i32 to i64
%1166 = llvm.getelementptr %1056[0, %1165] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1164, %1166 : i64, !llvm.ptr
%1167 = llvm.load %1156 : !llvm.ptr -> i32
%1168 = arith.constant 1 : i32
%1169 = arith.addi %1167, %1168 : i32
llvm.store %1169, %1156 : i32, !llvm.ptr
cf.br ^bb134
^bb133:
cf.br ^bb134
^bb134:
cf.br ^bb131
^bb130:
%1171 = arith.constant 1 : i32
%1173 = arith.extsi %1171 : i32 to i64
%1172 = arith.subi %arg1, %1173 : i64
%1170 = func.call @factorize(%1172) : (i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1174 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1175 = llvm.extractvalue %1170[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1176 = llvm.insertvalue %1175, %1174[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1177 = llvm.extractvalue %1170[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1178 = llvm.insertvalue %1177, %1176[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1179 = llvm.extractvalue %1170[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1180 = llvm.insertvalue %1179, %1178[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1181 = llvm.mlir.constant(1 : i64) : i64
%1182 = llvm.alloca %1181 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %1180, %1182 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%1183 = llvm.load %1182 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1184 = llvm.mlir.constant(1 : i64) : i64
%1185 = llvm.alloca %1184 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %1183, %1185 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%1186 = arith.constant 0 : i32
%1187 = llvm.load %1185 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1188 = llvm.getelementptr %1185[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1189 = llvm.load %1188 : !llvm.ptr -> i32
%1190 = arith.index_cast %1186 : i32 to index
%1191 = arith.index_cast %1189 : i32 to index
%1193 = arith.constant 1 : index
%1194 = arith.constant -1 : index
%1195 = arith.cmpi sle, %1190, %1191 : index
%1192 = arith.select %1195, %1193, %1194 : index
cf.br ^bb135(%1190 : index)
^bb135(%1196: index):
%1197 = arith.cmpi slt, %1196, %1191 : index
%1198 = arith.cmpi sgt, %1196, %1191 : index
%1199 = arith.select %1195, %1197, %1198 : i1
cf.cond_br %1199, ^bb136(%1196 : index), ^bb137(%1196 : index)
^bb136(%1200: index):
%1202 = llvm.load %1185 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1203 = llvm.getelementptr %1185[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1204 = arith.index_cast %1200 : index to i64
%1205 = llvm.getelementptr %1203[0, %1204] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%1201 = llvm.load %1205 : !llvm.ptr -> i64
%1206 = llvm.load %1156 : !llvm.ptr -> i32
%1207 = arith.extsi %1206 : i32 to i64
%1208 = llvm.getelementptr %1056[0, %1207] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %1201, %1208 : i64, !llvm.ptr
%1209 = llvm.load %1156 : !llvm.ptr -> i32
%1210 = arith.constant 1 : i32
%1211 = arith.addi %1209, %1210 : i32
llvm.store %1211, %1156 : i32, !llvm.ptr
%1212 = arith.addi %1200, %1192 : index
cf.br ^bb135(%1212 : index)
^bb137(%1213: index):
%1214 = arith.constant 2 : i32
%1215 = arith.cmpi sge, %arg2, %1214 : i32
cf.cond_br %1215, ^bb138, ^bb139
^bb138:
%1216 = llvm.load %1156 : !llvm.ptr -> i32
%1217 = arith.extsi %1216 : i32 to i64
%1218 = llvm.getelementptr %1056[0, %1217] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
llvm.store %arg1, %1218 : i64, !llvm.ptr
%1219 = llvm.load %1156 : !llvm.ptr -> i32
%1220 = arith.constant 1 : i32
%1221 = arith.addi %1219, %1220 : i32
llvm.store %1221, %1156 : i32, !llvm.ptr
cf.br ^bb140
^bb139:
cf.br ^bb140
^bb140:
cf.br ^bb131
^bb131:
%1222 = llvm.mlir.constant(1 : i64) : i64
%1223 = llvm.alloca %1222 x i64 : (i64) -> !llvm.ptr
llvm.store %1021, %1223 : i64, !llvm.ptr
%1224 = arith.constant 0 : i32
%1225 = llvm.load %1156 : !llvm.ptr -> i32
%1226 = arith.index_cast %1224 : i32 to index
%1227 = arith.index_cast %1225 : i32 to index
%1229 = arith.constant 1 : index
%1230 = arith.constant -1 : index
%1231 = arith.cmpi sle, %1226, %1227 : index
%1228 = arith.select %1231, %1229, %1230 : index
cf.br ^bb141(%1226 : index)
^bb141(%1232: index):
%1233 = arith.cmpi slt, %1232, %1227 : index
%1234 = arith.cmpi sgt, %1232, %1227 : index
%1235 = arith.select %1231, %1233, %1234 : i1
cf.cond_br %1235, ^bb142(%1232 : index), ^bb143(%1232 : index)
^bb142(%1236: index):
cf.br ^bb144
^bb144:
%1237 = llvm.load %1223 : !llvm.ptr -> i64
%1239 = arith.index_cast %1236 : index to i64
%1240 = llvm.getelementptr %1056[0, %1239] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%1238 = llvm.load %1240 : !llvm.ptr -> i64
%1241 = arith.remsi %1237, %1238 : i64
%1242 = arith.constant 0 : i32
%1244 = arith.extsi %1242 : i32 to i64
%1243 = arith.cmpi eq, %1241, %1244 : i64
cf.cond_br %1243, ^bb145, ^bb146
^bb145:
%1246 = llvm.load %1223 : !llvm.ptr -> i64
%1248 = arith.index_cast %1236 : index to i64
%1249 = llvm.getelementptr %1056[0, %1248] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%1247 = llvm.load %1249 : !llvm.ptr -> i64
%1250 = arith.divsi %1246, %1247 : i64
%1251 = llvm.load %1002 : !llvm.ptr -> i64
%1245 = func.call @powmod128(%1020, %1250, %1251) : (i64, i64, i64) -> i64
%1252 = arith.constant 1 : i32
%1254 = arith.extsi %1252 : i32 to i64
%1253 = arith.cmpi eq, %1245, %1254 : i64
cf.cond_br %1253, ^bb147, ^bb148
^bb147:
%1255 = llvm.load %1223 : !llvm.ptr -> i64
%1257 = arith.index_cast %1236 : index to i64
%1258 = llvm.getelementptr %1056[0, %1257] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%1256 = llvm.load %1258 : !llvm.ptr -> i64
%1259 = arith.divsi %1255, %1256 : i64
llvm.store %1259, %1223 : i64, !llvm.ptr
cf.br ^bb149
^bb148:
cf.br ^bb146
^bb149:
cf.br ^bb144
^bb146:
%1260 = arith.addi %1236, %1228 : index
cf.br ^bb141(%1260 : index)
^bb143(%1261: index):
%1262 = llvm.load %1223 : !llvm.ptr -> i64
func.return %1262 : i64
}
func.func @dfs(%arg0: i32, %arg1: i32, %arg2: i64, %arg3: i64, %arg4: !llvm.ptr) -> () {
%1263 = arith.cmpi eq, %arg0, %arg1 : i32
cf.cond_br %1263, ^bb150, ^bb151
^bb150:
%1265 = arith.constant 0 : i32
%1266 = arith.extsi %1265 : i32 to i64
%1267 = llvm.getelementptr %arg4[%1266] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1264 = llvm.load %1267 : !llvm.ptr -> i64
%1268 = arith.divsi %arg2, %arg3 : i64
%1269 = arith.addi %1264, %1268 : i64
%1270 = arith.constant 0 : i32
%1271 = arith.extsi %1270 : i32 to i64
%1272 = llvm.getelementptr %arg4[%1271] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1269, %1272 : i64, !llvm.ptr
func.return
^bb151:
cf.br ^bb152
^bb152:
%1273 = arith.constant 0 : i32
%1274 = llvm.mlir.constant(1 : i64) : i64
%1275 = llvm.alloca %1274 x i32 : (i64) -> !llvm.ptr
llvm.store %1273, %1275 : i32, !llvm.ptr
cf.br ^bb153
^bb153:
%1276 = llvm.load %1275 : !llvm.ptr -> i32
%1278 = llvm.mlir.addressof @g_exps : !llvm.ptr
%1279 = llvm.load %1278 : !llvm.ptr -> !llvm.ptr
%1280 = arith.extsi %arg0 : i32 to i64
%1281 = llvm.getelementptr %1279[%1280] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1277 = llvm.load %1281 : !llvm.ptr -> i32
%1282 = arith.cmpi sle, %1276, %1277 : i32
cf.cond_br %1282, ^bb154, ^bb155
^bb154:
%1284 = llvm.mlir.addressof @g_phi : !llvm.ptr
%1285 = llvm.load %1284 : !llvm.ptr -> !llvm.ptr
%1286 = arith.extsi %arg0 : i32 to i64
%1287 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1288 = llvm.load %1287 : !llvm.ptr -> i32
%1289 = arith.extsi %1288 : i32 to i64
%1290 = arith.muli %1286, %1289 : i64
%1291 = llvm.load %1275 : !llvm.ptr -> i32
%1292 = arith.extsi %1291 : i32 to i64
%1293 = arith.addi %1290, %1292 : i64
%1294 = llvm.getelementptr %1285[%1293] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1283 = llvm.load %1294 : !llvm.ptr -> i64
%1296 = llvm.mlir.addressof @g_ord : !llvm.ptr
%1297 = llvm.load %1296 : !llvm.ptr -> !llvm.ptr
%1298 = arith.extsi %arg0 : i32 to i64
%1299 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1300 = llvm.load %1299 : !llvm.ptr -> i32
%1301 = arith.extsi %1300 : i32 to i64
%1302 = arith.muli %1298, %1301 : i64
%1303 = llvm.load %1275 : !llvm.ptr -> i32
%1304 = arith.extsi %1303 : i32 to i64
%1305 = arith.addi %1302, %1304 : i64
%1306 = llvm.getelementptr %1297[%1305] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1295 = llvm.load %1306 : !llvm.ptr -> i64
%1308 = arith.constant 1 : i32
%1309 = arith.addi %arg0, %1308 : i32
%1310 = arith.muli %arg2, %1283 : i64
%1311 = func.call @lcm64(%arg3, %1295) : (i64, i64) -> i64
func.call @dfs(%1309, %arg1, %1310, %1311, %arg4) : (i32, i32, i64, i64, !llvm.ptr) -> ()
%1312 = llvm.load %1275 : !llvm.ptr -> i32
%1313 = arith.constant 1 : i32
%1314 = arith.addi %1312, %1313 : i32
llvm.store %1314, %1275 : i32, !llvm.ptr
cf.br ^bb153
^bb155:
func.return
}
func.func @sum_phi_over_order(%arg0: i64, %arg1: !llvm.ptr) -> i64 {
%1316 = arith.constant 0 : i32
%1317 = arith.extsi %1316 : i32 to i64
%1318 = llvm.getelementptr %arg1[%1317] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1315 = llvm.load %1318 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1319 = arith.constant 0 : i32
%1320 = arith.extsi %1319 : i32 to i64
%1321 = llvm.getelementptr %arg1[%1320] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1322 = llvm.getelementptr %1321[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1323 = llvm.load %1322 : !llvm.ptr -> i32
%1324 = arith.constant 0 : i32
%1325 = llvm.mlir.constant(1 : i64) : i64
%1326 = llvm.alloca %1325 x i32 : (i64) -> !llvm.ptr
llvm.store %1324, %1326 : i32, !llvm.ptr
cf.br ^bb156
^bb156:
%1327 = llvm.load %1326 : !llvm.ptr -> i32
%1328 = arith.cmpi slt, %1327, %1323 : i32
cf.cond_br %1328, ^bb157, ^bb158
^bb157:
%1331 = arith.constant 0 : i32
%1332 = arith.extsi %1331 : i32 to i64
%1333 = llvm.getelementptr %arg1[%1332] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1330 = llvm.load %1333 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1334 = arith.constant 0 : i32
%1335 = arith.extsi %1334 : i32 to i64
%1336 = llvm.getelementptr %arg1[%1335] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1337 = llvm.getelementptr %1336[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1338 = llvm.load %1326 : !llvm.ptr -> i32
%1339 = arith.extsi %1338 : i32 to i64
%1340 = llvm.getelementptr %1337[0, %1339] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i64>
%1329 = llvm.load %1340 : !llvm.ptr -> i64
%1343 = arith.constant 0 : i32
%1344 = arith.extsi %1343 : i32 to i64
%1345 = llvm.getelementptr %arg1[%1344] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1342 = llvm.load %1345 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1346 = arith.constant 0 : i32
%1347 = arith.extsi %1346 : i32 to i64
%1348 = llvm.getelementptr %arg1[%1347] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1349 = llvm.getelementptr %1348[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1350 = llvm.load %1326 : !llvm.ptr -> i32
%1351 = arith.extsi %1350 : i32 to i64
%1352 = llvm.getelementptr %1349[0, %1351] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%1341 = llvm.load %1352 : !llvm.ptr -> i32
%1353 = llvm.mlir.addressof @g_exps : !llvm.ptr
%1354 = llvm.load %1353 : !llvm.ptr -> !llvm.ptr
%1355 = llvm.load %1326 : !llvm.ptr -> i32
%1356 = arith.extsi %1355 : i32 to i64
%1357 = llvm.getelementptr %1354[%1356] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1341, %1357 : i32, !llvm.ptr
%1358 = arith.constant 0 : i32
%1359 = llvm.mlir.constant(1 : i64) : i64
%1360 = llvm.alloca %1359 x i32 : (i64) -> !llvm.ptr
llvm.store %1358, %1360 : i32, !llvm.ptr
cf.br ^bb159
^bb159:
%1361 = llvm.load %1360 : !llvm.ptr -> i32
%1362 = arith.cmpi sle, %1361, %1341 : i32
cf.cond_br %1362, ^bb160, ^bb161
^bb160:
%1364 = llvm.load %1360 : !llvm.ptr -> i32
%1363 = func.call @phi_pp(%1329, %1364) : (i64, i32) -> i64
%1365 = llvm.mlir.addressof @g_phi : !llvm.ptr
%1366 = llvm.load %1365 : !llvm.ptr -> !llvm.ptr
%1367 = llvm.load %1326 : !llvm.ptr -> i32
%1368 = arith.extsi %1367 : i32 to i64
%1369 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1370 = llvm.load %1369 : !llvm.ptr -> i32
%1371 = arith.extsi %1370 : i32 to i64
%1372 = arith.muli %1368, %1371 : i64
%1373 = llvm.load %1360 : !llvm.ptr -> i32
%1374 = arith.extsi %1373 : i32 to i64
%1375 = arith.addi %1372, %1374 : i64
%1376 = llvm.getelementptr %1366[%1375] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1363, %1376 : i64, !llvm.ptr
%1377 = llvm.load %1360 : !llvm.ptr -> i32
%1378 = arith.constant 0 : i32
%1379 = arith.cmpi eq, %1377, %1378 : i32
cf.cond_br %1379, ^bb162, ^bb163
^bb162:
%1380 = arith.constant 1 : i32
%1381 = llvm.mlir.addressof @g_ord : !llvm.ptr
%1382 = llvm.load %1381 : !llvm.ptr -> !llvm.ptr
%1383 = llvm.load %1326 : !llvm.ptr -> i32
%1384 = arith.extsi %1383 : i32 to i64
%1385 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1386 = llvm.load %1385 : !llvm.ptr -> i32
%1387 = arith.extsi %1386 : i32 to i64
%1388 = arith.muli %1384, %1387 : i64
%1389 = llvm.load %1360 : !llvm.ptr -> i32
%1390 = arith.extsi %1389 : i32 to i64
%1391 = arith.addi %1388, %1390 : i64
%1392 = arith.extsi %1380 : i32 to i64
%1393 = llvm.getelementptr %1382[%1391] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1392, %1393 : i64, !llvm.ptr
cf.br ^bb164
^bb163:
%1395 = llvm.load %1360 : !llvm.ptr -> i32
%1394 = func.call @mult_order(%arg0, %1329, %1395) : (i64, i64, i32) -> i64
%1396 = llvm.mlir.addressof @g_ord : !llvm.ptr
%1397 = llvm.load %1396 : !llvm.ptr -> !llvm.ptr
%1398 = llvm.load %1326 : !llvm.ptr -> i32
%1399 = arith.extsi %1398 : i32 to i64
%1400 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1401 = llvm.load %1400 : !llvm.ptr -> i32
%1402 = arith.extsi %1401 : i32 to i64
%1403 = arith.muli %1399, %1402 : i64
%1404 = llvm.load %1360 : !llvm.ptr -> i32
%1405 = arith.extsi %1404 : i32 to i64
%1406 = arith.addi %1403, %1405 : i64
%1407 = llvm.getelementptr %1397[%1406] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1394, %1407 : i64, !llvm.ptr
cf.br ^bb164
^bb164:
%1408 = llvm.load %1360 : !llvm.ptr -> i32
%1409 = arith.constant 1 : i32
%1410 = arith.addi %1408, %1409 : i32
llvm.store %1410, %1360 : i32, !llvm.ptr
cf.br ^bb159
^bb161:
%1411 = llvm.load %1326 : !llvm.ptr -> i32
%1412 = arith.constant 1 : i32
%1413 = arith.addi %1411, %1412 : i32
llvm.store %1413, %1326 : i32, !llvm.ptr
cf.br ^bb156
^bb158:
%1414 = arith.constant 0 : i32
%1415 = arith.extsi %1414 : i32 to i64
%1416 = llvm.mlir.constant(1 : i64) : i64
%1417 = llvm.alloca %1416 x i64 : (i64) -> !llvm.ptr
llvm.store %1415, %1417 : i64, !llvm.ptr
%1419 = arith.constant 0 : i32
%1420 = arith.constant 1 : i32
%1421 = arith.constant 1 : i32
%1422 = arith.extsi %1420 : i32 to i64
%1423 = arith.extsi %1421 : i32 to i64
func.call @dfs(%1419, %1323, %1422, %1423, %1417) : (i32, i32, i64, i64, !llvm.ptr) -> ()
%1424 = llvm.load %1417 : !llvm.ptr -> i64
func.return %1424 : i64
}
func.func @main() -> i32 {
func.call @init_sieve() : () -> ()
%1427 = llvm.mlir.addressof @MAX_PF : !llvm.ptr
%1428 = llvm.load %1427 : !llvm.ptr -> i32
%1429 = arith.extsi %1428 : i32 to i64
%1430 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1431 = llvm.load %1430 : !llvm.ptr -> i32
%1432 = arith.extsi %1431 : i32 to i64
%1433 = arith.muli %1429, %1432 : i64
%1434 = arith.constant 8 : i32
%1435 = arith.extsi %1434 : i32 to i64
%1426 = func.call @calloc(%1433, %1435) : (i64, i64) -> !llvm.ptr
%1436 = llvm.mlir.addressof @g_phi : !llvm.ptr
llvm.store %1426, %1436 : !llvm.ptr, !llvm.ptr
%1438 = llvm.mlir.addressof @MAX_PF : !llvm.ptr
%1439 = llvm.load %1438 : !llvm.ptr -> i32
%1440 = arith.extsi %1439 : i32 to i64
%1441 = llvm.mlir.addressof @MAX_EX : !llvm.ptr
%1442 = llvm.load %1441 : !llvm.ptr -> i32
%1443 = arith.extsi %1442 : i32 to i64
%1444 = arith.muli %1440, %1443 : i64
%1445 = arith.constant 8 : i32
%1446 = arith.extsi %1445 : i32 to i64
%1437 = func.call @calloc(%1444, %1446) : (i64, i64) -> !llvm.ptr
%1447 = llvm.mlir.addressof @g_ord : !llvm.ptr
llvm.store %1437, %1447 : !llvm.ptr, !llvm.ptr
%1449 = llvm.mlir.addressof @MAX_PF : !llvm.ptr
%1450 = llvm.load %1449 : !llvm.ptr -> i32
%1451 = arith.extsi %1450 : i32 to i64
%1452 = arith.constant 4 : i32
%1453 = arith.extsi %1452 : i32 to i64
%1448 = func.call @calloc(%1451, %1453) : (i64, i64) -> !llvm.ptr
%1454 = llvm.mlir.addressof @g_exps : !llvm.ptr
llvm.store %1448, %1454 : !llvm.ptr, !llvm.ptr
%1455 = arith.constant 0 : i32
%1456 = arith.extsi %1455 : i32 to i128
%1457 = llvm.mlir.constant(1 : i64) : i64
%1458 = llvm.alloca %1457 x i128 : (i64) -> !llvm.ptr
llvm.store %1456, %1458 : i128, !llvm.ptr
%1459 = arith.constant 2 : i32
%1460 = arith.constant 101 : i32
%1461 = arith.index_cast %1459 : i32 to index
%1462 = arith.index_cast %1460 : i32 to index
%1464 = arith.constant 1 : index
%1465 = arith.constant -1 : index
%1466 = arith.cmpi sle, %1461, %1462 : index
%1463 = arith.select %1466, %1464, %1465 : index
cf.br ^bb165(%1461 : index)
^bb165(%1467: index):
%1468 = arith.cmpi slt, %1467, %1462 : index
%1469 = arith.cmpi sgt, %1467, %1462 : index
%1470 = arith.select %1466, %1468, %1469 : i1
cf.cond_br %1470, ^bb166(%1467 : index), ^bb167(%1467 : index)
^bb166(%1471: index):
%1472 = arith.constant 101 : i32
%1473 = arith.index_cast %1471 : i32 to index
%1474 = arith.index_cast %1472 : i32 to index
%1476 = arith.constant 1 : index
%1477 = arith.constant -1 : index
%1478 = arith.cmpi sle, %1473, %1474 : index
%1475 = arith.select %1478, %1476, %1477 : index
cf.br ^bb168(%1473 : index)
^bb168(%1479: index):
%1480 = arith.cmpi slt, %1479, %1474 : index
%1481 = arith.cmpi sgt, %1479, %1474 : index
%1482 = arith.select %1478, %1480, %1481 : i1
cf.cond_br %1482, ^bb169(%1479 : index), ^bb170(%1479 : index)
^bb169(%1483: index):
%1484 = arith.index_cast %1471 : index to i64
%1485 = arith.index_cast %1483 : index to i64
%1486 = arith.muli %1484, %1485 : i64
%1487 = arith.muli %1486, %1486 : i64
%1488 = arith.muli %1487, %1486 : i64
%1489 = arith.muli %1488, %1486 : i64
%1490 = func.call @factorize_t4m1(%1486) : (i64) -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1491 = llvm.mlir.undef : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1492 = llvm.extractvalue %1490[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1493 = llvm.insertvalue %1492, %1491[0] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1494 = llvm.extractvalue %1490[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1495 = llvm.insertvalue %1494, %1493[1] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1496 = llvm.extractvalue %1490[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1497 = llvm.insertvalue %1496, %1495[2] : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1498 = llvm.mlir.constant(1 : i64) : i64
%1499 = llvm.alloca %1498 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %1497, %1499 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%1500 = llvm.load %1499 : !llvm.ptr -> !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>
%1501 = llvm.mlir.constant(1 : i64) : i64
%1502 = llvm.alloca %1501 x !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)> : (i64) -> !llvm.ptr
llvm.store %1500, %1502 : !llvm.struct<(!llvm.array<32 x i64>, !llvm.array<32 x i32>, i32)>, !llvm.ptr
%1503 = arith.index_cast %1483 : index to i64
%1504 = arith.index_cast %1483 : index to i64
%1505 = arith.muli %1503, %1504 : i64
%1506 = arith.index_cast %1483 : index to i64
%1507 = arith.muli %1505, %1506 : i64
%1508 = arith.index_cast %1483 : index to i64
%1509 = arith.muli %1507, %1508 : i64
%1510 = func.call @sum_phi_over_order(%1509, %1502) : (i64, !llvm.ptr) -> i64
%1511 = arith.constant 1 : i32
%1513 = arith.extsi %1511 : i32 to i64
%1512 = arith.subi %1489, %1513 : i64
%1514 = arith.subi %1512, %1510 : i64
%1515 = llvm.load %1458 : !llvm.ptr -> i128
%1516 = arith.extsi %1514 : i64 to i128
%1518 = arith.trunci %1515 : i128 to i64
%1519 = arith.trunci %1516 : i128 to i64
%1517 = arith.addi %1518, %1519 : i64
%1520 = arith.extsi %1517 : i64 to i128
llvm.store %1520, %1458 : i128, !llvm.ptr
%1521 = arith.addi %1483, %1475 : index
cf.br ^bb168(%1521 : index)
^bb170(%1522: index):
%1523 = arith.addi %1471, %1463 : index
cf.br ^bb165(%1523 : index)
^bb167(%1524: index):
%1525 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1526 = llvm.load %1458 : !llvm.ptr -> i128
%1527 = arith.trunci %1526 : i128 to i64
%1528 = llvm.call @printf(%1525, %1527) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%1529 = arith.constant 0 : i32
func.return %1529 : i32
}
}