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