Problem 834
Add and Divide - U(1234567). Pure Flow port of the native C solver.
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n^2) | ? |
|---|
| Space complexity | O(n^2) | ? |
|---|
| Approach | Flow solution | Not curated |
|---|
| Verdict | Unknown |
|---|
Flow source
# Project Euler 834
# Add and Divide - U(1234567).
# Pure Flow port of the native C solver.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function malloc(n: i64) -> ptr<void>
}
const N_LIMIT: i32 = 1234567
# Global SPF array
let mut g_spf: ptr<i32> = null
let mut g_cnt: i64 = 0
let mut g_sum: i64 = 0
function build_spf(limit: i32) -> void {
g_spf = calloc((limit as i64) + 1, 4)
let primes: ptr<i32> = malloc(((limit as i64) + 1) * 4)
let mut pcnt: i32 = 0
let mut i: i32 = 2
while i <= limit {
if g_spf[i] == 0 {
g_spf[i] = i
primes[pcnt] = i
pcnt = pcnt + 1
}
let mut j: i32 = 0
while j < pcnt {
let ip: i32 = i * primes[j]
if ip > limit { break }
g_spf[ip] = primes[j]
if primes[j] == g_spf[i] { break }
j = j + 1
}
i = i + 1
}
free(primes)
g_spf[0] = 0
if limit >= 1 { g_spf[1] = 1 }
}
# Divisor data: sorted divisors, prefix sums, total sum
struct DivData {
divs: ptr<i32>
pre: ptr<i64>
count: i32
total: i64
}
function insertion_sort(arr: ptr<i32>, n: i32) -> void {
let mut i: i32 = 1
while i < n {
let key: i32 = arr[i]
let mut j: i32 = i - 1
while j >= 0 {
if arr[j] > key {
arr[j + 1] = arr[j]
j = j - 1
} else {
break
}
}
arr[j + 1] = key
i = i + 1
}
}
function divisors_with_prefix(odd_x: i32) -> DivData {
if odd_x == 1 {
let divs: ptr<i32> = malloc(4)
divs[0] = 1
let pre: ptr<i64> = malloc(16)
pre[0] = 0
pre[1] = 1
return DivData { divs: divs, pre: pre, count: 1, total: 1 }
}
# Factorize using SPF
let factors_p: ptr<i32> = malloc(256)
let factors_e: ptr<i32> = malloc(256)
let mut nfac: i32 = 0
let mut x: i32 = odd_x
while x > 1 {
let p: i32 = g_spf[x]
let mut e: i32 = 0
while x % p == 0 {
x = x / p
e = e + 1
}
factors_p[nfac] = p
factors_e[nfac] = e
nfac = nfac + 1
}
# Generate divisors
let mut cap: i32 = 1
let mut i: i32 = 0
while i < nfac {
cap = cap * (factors_e[i] + 1)
i = i + 1
}
let divs: ptr<i32> = malloc((cap as i64) * 4)
let mut ndiv: i32 = 1
divs[0] = 1
let mut i2: i32 = 0
while i2 < nfac {
let p: i32 = factors_p[i2]
let e: i32 = factors_e[i2]
let base_ndiv: i32 = ndiv
let mut mult: i32 = 1
let mut k: i32 = 1
while k <= e {
mult = mult * p
let mut j: i32 = 0
while j < base_ndiv {
divs[ndiv] = divs[j] * mult
ndiv = ndiv + 1
j = j + 1
}
k = k + 1
}
i2 = i2 + 1
}
insertion_sort(divs, ndiv)
let pre: ptr<i64> = malloc(((ndiv as i64) + 1) * 8)
let mut s: i64 = 0
let mut i3: i32 = 0
while i3 < ndiv {
s = s + (divs[i3] as i64)
pre[i3 + 1] = s
i3 = i3 + 1
}
free(factors_p)
free(factors_e)
return DivData { divs: divs, pre: pre, count: ndiv, total: s }
}
# Binary search: rightmost index where divs[idx] <= bound
function bisect_right(divs: ptr<i32>, count: i32, bound: i32) -> i32 {
let mut lo: i32 = 0
let mut hi: i32 = count
while lo < hi {
let mid: i32 = (lo + hi) / 2
if divs[mid] <= bound {
lo = mid + 1
} else {
hi = mid
}
}
return lo
}
# Over pairs (a in small, b in large), count and sum where a*b > bound
# Results stored in g_cnt and g_sum
function count_sum_products_gt(
small: ptr<i32>, ns: i32, large: ptr<i32>, nl: i32,
lpre: ptr<i64>, ltotal: i64,
bound: i32) -> void {
g_cnt = 0
g_sum = 0
let mut i: i32 = 0
while i < ns {
let a: i32 = small[i]
let idx: i32 = bisect_right(large, nl, bound / a)
if idx != nl {
g_cnt = g_cnt + (nl - idx) as i64
g_sum = g_sum + (a as i64) * (ltotal - lpre[idx])
}
i = i + 1
}
}
function compute_T(n: i64, two: i32, dA: DivData, dB: DivData) -> i64 {
let mut small: ptr<i32> = null
let mut large: ptr<i32> = null
let mut ns: i32 = 0
let mut nl: i32 = 0
let mut preL: ptr<i64> = null
let mut sumL: i64 = 0
if dA.count <= dB.count {
small = dA.divs; ns = dA.count
large = dB.divs; nl = dB.count
preL = dB.pre; sumL = dB.total
} else {
small = dB.divs; ns = dB.count
large = dA.divs; nl = dA.count
preL = dA.pre; sumL = dA.total
}
let n_i32: i32 = n as i32
let bound1: i32 = n_i32
let bound2: i32 = n_i32 / two
count_sum_products_gt(small, ns, large, nl, preL, sumL, bound1)
let cnt1: i64 = g_cnt
let sum1: i64 = g_sum
count_sum_products_gt(small, ns, large, nl, preL, sumL, bound2)
let cnt2: i64 = g_cnt
let sum2: i64 = g_sum
let count_total: i64 = cnt1 + cnt2
let sum_d: i64 = sum1 + (two as i64) * sum2
return sum_d - n * count_total
}
function main() -> i32 {
let N: i32 = N_LIMIT
build_spf(N)
let mut total: i64 = 0
let mut lastA: i32 = -1
let mut lastB: i32 = -1
let mut dataA: DivData = DivData { divs: null, pre: null, count: 0, total: 0 }
let mut dataB: DivData = DivData { divs: null, pre: null, count: 0, total: 0 }
let mut n: i32 = 3
while n <= N {
let even: i32
let B: i32
if (n & 1) != 0 {
even = n - 1
B = n
} else {
even = n
B = n - 1
}
# odd part and 2^v2
let two: i32 = even & (0 - even)
let A: i32 = even / two
if A != lastA {
if lastA != -1 {
free(dataA.divs)
free(dataA.pre)
}
dataA = divisors_with_prefix(A)
lastA = A
}
if B != lastB {
if lastB != -1 {
free(dataB.divs)
free(dataB.pre)
}
dataB = divisors_with_prefix(B)
lastB = B
}
total = total + compute_T(n as i64, two, dataA, dataB)
n = n + 1
}
free(dataA.divs)
free(dataA.pre)
free(dataB.divs)
free(dataB.pre)
free(g_spf)
printf("%lld\n", total)
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 DivData DivData;
struct DivData {
int32_t* divs;
int64_t* pre;
int32_t count;
int64_t total;
};
void build_spf_i32(int32_t limit);
void insertion_sort_ptr_i32_i32(int32_t* arr, int32_t n);
DivData divisors_with_prefix_i32(int32_t odd_x);
int32_t bisect_right_ptr_i32_i32_i32(int32_t* divs, int32_t count, int32_t bound);
void count_sum_products_gt_ptr_i32_i32_ptr_i32_i32_ptr_i64_i64_i32(int32_t* small, int32_t ns, int32_t* large, int32_t nl, int64_t* lpre, int64_t ltotal, int32_t bound);
int64_t compute_T_i64_i32_DivData_DivData(int64_t n, int32_t two, DivData dA, DivData dB);
int32_t main(void);
static const int32_t N_LIMIT = 1234567;
/* Module statics */
static int32_t* g_spf = NULL;
static int64_t g_cnt = 0;
static int64_t g_sum = 0;
void build_spf_i32(int32_t limit) {
g_spf = calloc((((int64_t)(limit)) + 1), 4);
int32_t* primes = (int32_t*)(malloc(((((int64_t)(limit)) + 1) * 4)));
int32_t pcnt = 0;
int32_t i = 2;
while (i <= limit) {
if (g_spf[i] == 0) {
g_spf[i] = i;
primes[pcnt] = i;
pcnt = (pcnt + 1);
}
int32_t j = 0;
while (j < pcnt) {
int32_t ip = (i * primes[j]);
if (ip > limit) {
break;
}
g_spf[ip] = primes[j];
if (primes[j] == g_spf[i]) {
break;
}
j = (j + 1);
}
i = (i + 1);
}
free(primes);
g_spf[0] = 0;
if (limit >= 1) {
g_spf[1] = 1;
}
}
void insertion_sort_ptr_i32_i32(int32_t* arr, int32_t n) {
int32_t i = 1;
while (i < n) {
int32_t key = arr[i];
int32_t j = (i - 1);
while (j >= 0) {
if (arr[j] > key) {
arr[(j + 1)] = arr[j];
j = (j - 1);
} else {
break;
}
}
arr[(j + 1)] = key;
i = (i + 1);
}
}
DivData divisors_with_prefix_i32(int32_t odd_x) {
if (odd_x == 1) {
int32_t* divs = (int32_t*)(malloc(4));
divs[0] = 1;
int64_t* pre = (int64_t*)(malloc(16));
pre[0] = 0;
pre[1] = 1;
return (DivData){ .divs = divs, .pre = pre, .count = 1, .total = 1 };
}
int32_t* factors_p = (int32_t*)(malloc(256));
int32_t* factors_e = (int32_t*)(malloc(256));
int32_t nfac = 0;
int32_t x = odd_x;
while (x > 1) {
int32_t p = g_spf[x];
int32_t e = 0;
while (FLOW_CHECKED_MOD((x), (p)) == 0) {
x = FLOW_CHECKED_DIV((x), (p));
e = (e + 1);
}
factors_p[nfac] = p;
factors_e[nfac] = e;
nfac = (nfac + 1);
}
int32_t cap = 1;
int32_t i = 0;
while (i < nfac) {
cap = (cap * (factors_e[i] + 1));
i = (i + 1);
}
int32_t* divs = (int32_t*)(malloc((((int64_t)(cap)) * 4)));
int32_t ndiv = 1;
divs[0] = 1;
int32_t i2 = 0;
while (i2 < nfac) {
int32_t p = factors_p[i2];
int32_t e = factors_e[i2];
int32_t base_ndiv = ndiv;
int32_t mult = 1;
int32_t k = 1;
while (k <= e) {
mult = (mult * p);
int32_t j = 0;
while (j < base_ndiv) {
divs[ndiv] = (divs[j] * mult);
ndiv = (ndiv + 1);
j = (j + 1);
}
k = (k + 1);
}
i2 = (i2 + 1);
}
insertion_sort_ptr_i32_i32(divs, ndiv);
int64_t* pre = (int64_t*)(malloc(((((int64_t)(ndiv)) + 1) * 8)));
int64_t s = 0;
int32_t i3 = 0;
while (i3 < ndiv) {
s = (s + ((int64_t)(divs[i3])));
pre[(i3 + 1)] = s;
i3 = (i3 + 1);
}
free(factors_p);
free(factors_e);
return (DivData){ .divs = divs, .pre = pre, .count = ndiv, .total = s };
}
int32_t bisect_right_ptr_i32_i32_i32(int32_t* divs, int32_t count, int32_t bound) {
int32_t lo = 0;
int32_t hi = count;
while (lo < hi) {
int32_t mid = FLOW_CHECKED_DIV(((lo + hi)), (2));
if (divs[mid] <= bound) {
lo = (mid + 1);
} else {
hi = mid;
}
}
return lo;
}
void count_sum_products_gt_ptr_i32_i32_ptr_i32_i32_ptr_i64_i64_i32(int32_t* small, int32_t ns, int32_t* large, int32_t nl, int64_t* lpre, int64_t ltotal, int32_t bound) {
g_cnt = 0;
g_sum = 0;
int32_t i = 0;
while (i < ns) {
int32_t a = small[i];
int32_t idx = bisect_right_ptr_i32_i32_i32(large, nl, FLOW_CHECKED_DIV((bound), (a)));
if (idx != nl) {
g_cnt = (g_cnt + ((int64_t)((nl - idx))));
g_sum = (g_sum + (((int64_t)(a)) * (ltotal - lpre[idx])));
}
i = (i + 1);
}
}
int64_t compute_T_i64_i32_DivData_DivData(int64_t n, int32_t two, DivData dA, DivData dB) {
int32_t* small = (int32_t*)(NULL);
int32_t* large = (int32_t*)(NULL);
int32_t ns = 0;
int32_t nl = 0;
int64_t* preL = (int64_t*)(NULL);
int64_t sumL = 0;
if (dA.count <= dB.count) {
small = dA.divs;
ns = dA.count;
large = dB.divs;
nl = dB.count;
preL = dB.pre;
sumL = dB.total;
} else {
small = dB.divs;
ns = dB.count;
large = dA.divs;
nl = dA.count;
preL = dA.pre;
sumL = dA.total;
}
int32_t n_i32 = ((int32_t)(n));
int32_t bound1 = n_i32;
int32_t bound2 = FLOW_CHECKED_DIV((n_i32), (two));
count_sum_products_gt_ptr_i32_i32_ptr_i32_i32_ptr_i64_i64_i32(small, ns, large, nl, preL, sumL, bound1);
int64_t cnt1 = g_cnt;
int64_t sum1 = g_sum;
count_sum_products_gt_ptr_i32_i32_ptr_i32_i32_ptr_i64_i64_i32(small, ns, large, nl, preL, sumL, bound2);
int64_t cnt2 = g_cnt;
int64_t sum2 = g_sum;
int64_t count_total = (cnt1 + cnt2);
int64_t sum_d = (sum1 + (((int64_t)(two)) * sum2));
return (sum_d - (n * count_total));
}
int32_t main(void) {
int32_t N = N_LIMIT;
build_spf_i32(N);
int64_t total = 0;
int32_t lastA = (-1);
int32_t lastB = (-1);
DivData dataA = (DivData){ .divs = NULL, .pre = NULL, .count = 0, .total = 0 };
DivData dataB = (DivData){ .divs = NULL, .pre = NULL, .count = 0, .total = 0 };
int32_t n = 3;
while (n <= N) {
int32_t even;
int32_t B;
if ((n & 1) != 0) {
even = (n - 1);
B = n;
} else {
even = n;
B = (n - 1);
}
int32_t two = (even & (0 - even));
int32_t A = FLOW_CHECKED_DIV((even), (two));
if (A != lastA) {
if (lastA != (-1)) {
free(dataA.divs);
free(dataA.pre);
}
dataA = divisors_with_prefix_i32(A);
lastA = A;
}
if (B != lastB) {
if (lastB != (-1)) {
free(dataB.divs);
free(dataB.pre);
}
dataB = divisors_with_prefix_i32(B);
lastB = B;
}
total = (total + compute_T_i64_i32_DivData_DivData(((int64_t)(n)), two, dataA, dataB));
n = (n + 1);
}
free(dataA.divs);
free(dataA.pre);
free(dataB.divs);
free(dataB.pre);
free(g_spf);
printf("%lld\n", total);
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 @malloc(i64) -> !llvm.ptr
// Constant: N_LIMIT
llvm.mlir.global internal constant @N_LIMIT(1234567 : i32) : i32
// Module static: g_spf
llvm.mlir.global internal @g_spf() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: g_cnt
llvm.mlir.global internal @g_cnt(0 : i64) : i64
// Module static: g_sum
llvm.mlir.global internal @g_sum(0 : i64) : i64
func.func @build_spf(%arg0: i32) -> () {
%2 = arith.extsi %arg0 : i32 to i64
%3 = arith.constant 1 : i32
%5 = arith.extsi %3 : i32 to i64
%4 = arith.addi %2, %5 : i64
%6 = arith.constant 4 : i32
%7 = arith.extsi %6 : i32 to i64
%1 = func.call @calloc(%4, %7) : (i64, i64) -> !llvm.ptr
%8 = llvm.mlir.addressof @g_spf : !llvm.ptr
llvm.store %1, %8 : !llvm.ptr, !llvm.ptr
%10 = arith.extsi %arg0 : i32 to i64
%11 = arith.constant 1 : i32
%13 = arith.extsi %11 : i32 to i64
%12 = arith.addi %10, %13 : i64
%14 = arith.constant 4 : i32
%16 = arith.extsi %14 : i32 to i64
%15 = arith.muli %12, %16 : i64
%9 = func.call @malloc(%15) : (i64) -> !llvm.ptr
%17 = arith.constant 0 : i32
%18 = llvm.mlir.constant(1 : i64) : i64
%19 = llvm.alloca %18 x i32 : (i64) -> !llvm.ptr
llvm.store %17, %19 : i32, !llvm.ptr
%20 = arith.constant 2 : i32
%21 = llvm.mlir.constant(1 : i64) : i64
%22 = llvm.alloca %21 x i32 : (i64) -> !llvm.ptr
llvm.store %20, %22 : i32, !llvm.ptr
cf.br ^bb0
^bb0:
%23 = llvm.load %22 : !llvm.ptr -> i32
%24 = arith.cmpi sle, %23, %arg0 : i32
cf.cond_br %24, ^bb1, ^bb2
^bb1:
%26 = llvm.mlir.addressof @g_spf : !llvm.ptr
%27 = llvm.load %26 : !llvm.ptr -> !llvm.ptr
%28 = llvm.load %22 : !llvm.ptr -> i32
%29 = arith.extsi %28 : i32 to i64
%30 = llvm.getelementptr %27[%29] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%25 = llvm.load %30 : !llvm.ptr -> i32
%31 = arith.constant 0 : i32
%32 = arith.cmpi eq, %25, %31 : i32
cf.cond_br %32, ^bb3, ^bb4
^bb3:
%33 = llvm.load %22 : !llvm.ptr -> i32
%34 = llvm.mlir.addressof @g_spf : !llvm.ptr
%35 = llvm.load %34 : !llvm.ptr -> !llvm.ptr
%36 = llvm.load %22 : !llvm.ptr -> i32
%37 = arith.extsi %36 : i32 to i64
%38 = llvm.getelementptr %35[%37] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %33, %38 : i32, !llvm.ptr
%39 = llvm.load %22 : !llvm.ptr -> i32
%40 = llvm.load %19 : !llvm.ptr -> i32
%41 = arith.extsi %40 : i32 to i64
%42 = llvm.getelementptr %9[%41] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %39, %42 : i32, !llvm.ptr
%43 = llvm.load %19 : !llvm.ptr -> i32
%44 = arith.constant 1 : i32
%45 = arith.addi %43, %44 : i32
llvm.store %45, %19 : i32, !llvm.ptr
cf.br ^bb5
^bb4:
cf.br ^bb5
^bb5:
%46 = arith.constant 0 : i32
%47 = llvm.mlir.constant(1 : i64) : i64
%48 = llvm.alloca %47 x i32 : (i64) -> !llvm.ptr
llvm.store %46, %48 : i32, !llvm.ptr
cf.br ^bb6
^bb6:
%49 = llvm.load %48 : !llvm.ptr -> i32
%50 = llvm.load %19 : !llvm.ptr -> i32
%51 = arith.cmpi slt, %49, %50 : i32
cf.cond_br %51, ^bb7, ^bb8
^bb7:
%52 = llvm.load %22 : !llvm.ptr -> i32
%54 = llvm.load %48 : !llvm.ptr -> i32
%55 = arith.extsi %54 : i32 to i64
%56 = llvm.getelementptr %9[%55] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%53 = llvm.load %56 : !llvm.ptr -> i32
%57 = arith.muli %52, %53 : i32
%58 = arith.cmpi sgt, %57, %arg0 : i32
cf.cond_br %58, ^bb9, ^bb10
^bb9:
cf.br ^bb8
^bb10:
cf.br ^bb11
^bb11:
%60 = llvm.load %48 : !llvm.ptr -> i32
%61 = arith.extsi %60 : i32 to i64
%62 = llvm.getelementptr %9[%61] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%59 = llvm.load %62 : !llvm.ptr -> i32
%63 = llvm.mlir.addressof @g_spf : !llvm.ptr
%64 = llvm.load %63 : !llvm.ptr -> !llvm.ptr
%65 = arith.extsi %57 : i32 to i64
%66 = llvm.getelementptr %64[%65] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %59, %66 : i32, !llvm.ptr
%68 = llvm.load %48 : !llvm.ptr -> i32
%69 = arith.extsi %68 : i32 to i64
%70 = llvm.getelementptr %9[%69] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%67 = llvm.load %70 : !llvm.ptr -> i32
%72 = llvm.mlir.addressof @g_spf : !llvm.ptr
%73 = llvm.load %72 : !llvm.ptr -> !llvm.ptr
%74 = llvm.load %22 : !llvm.ptr -> i32
%75 = arith.extsi %74 : i32 to i64
%76 = llvm.getelementptr %73[%75] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%71 = llvm.load %76 : !llvm.ptr -> i32
%77 = arith.cmpi eq, %67, %71 : i32
cf.cond_br %77, ^bb12, ^bb13
^bb12:
cf.br ^bb8
^bb13:
cf.br ^bb14
^bb14:
%78 = llvm.load %48 : !llvm.ptr -> i32
%79 = arith.constant 1 : i32
%80 = arith.addi %78, %79 : i32
llvm.store %80, %48 : i32, !llvm.ptr
cf.br ^bb6
^bb8:
%81 = llvm.load %22 : !llvm.ptr -> i32
%82 = arith.constant 1 : i32
%83 = arith.addi %81, %82 : i32
llvm.store %83, %22 : i32, !llvm.ptr
cf.br ^bb0
^bb2:
func.call @free(%9) : (!llvm.ptr) -> ()
%85 = arith.constant 0 : i32
%86 = llvm.mlir.addressof @g_spf : !llvm.ptr
%87 = llvm.load %86 : !llvm.ptr -> !llvm.ptr
%88 = arith.constant 0 : i32
%89 = arith.extsi %88 : i32 to i64
%90 = llvm.getelementptr %87[%89] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %85, %90 : i32, !llvm.ptr
%91 = arith.constant 1 : i32
%92 = arith.cmpi sge, %arg0, %91 : i32
cf.cond_br %92, ^bb15, ^bb16
^bb15:
%93 = arith.constant 1 : i32
%94 = llvm.mlir.addressof @g_spf : !llvm.ptr
%95 = llvm.load %94 : !llvm.ptr -> !llvm.ptr
%96 = arith.constant 1 : i32
%97 = arith.extsi %96 : i32 to i64
%98 = llvm.getelementptr %95[%97] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %93, %98 : i32, !llvm.ptr
cf.br ^bb17
^bb16:
cf.br ^bb17
^bb17:
func.return
}
// Struct: DivData
// Fields:
// divs: !llvm.ptr
// pre: !llvm.ptr
// count: i32
// total: i64
func.func @insertion_sort(%arg0: !llvm.ptr, %arg1: i32) -> () {
%99 = arith.constant 1 : i32
%100 = llvm.mlir.constant(1 : i64) : i64
%101 = llvm.alloca %100 x i32 : (i64) -> !llvm.ptr
llvm.store %99, %101 : i32, !llvm.ptr
cf.br ^bb18
^bb18:
%102 = llvm.load %101 : !llvm.ptr -> i32
%103 = arith.cmpi slt, %102, %arg1 : i32
cf.cond_br %103, ^bb19, ^bb20
^bb19:
%105 = llvm.load %101 : !llvm.ptr -> i32
%106 = arith.extsi %105 : i32 to i64
%107 = llvm.getelementptr %arg0[%106] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%104 = llvm.load %107 : !llvm.ptr -> i32
%108 = llvm.load %101 : !llvm.ptr -> i32
%109 = arith.constant 1 : i32
%110 = arith.subi %108, %109 : i32
%111 = llvm.mlir.constant(1 : i64) : i64
%112 = llvm.alloca %111 x i32 : (i64) -> !llvm.ptr
llvm.store %110, %112 : i32, !llvm.ptr
cf.br ^bb21
^bb21:
%113 = llvm.load %112 : !llvm.ptr -> i32
%114 = arith.constant 0 : i32
%115 = arith.cmpi sge, %113, %114 : i32
cf.cond_br %115, ^bb22, ^bb23
^bb22:
%117 = llvm.load %112 : !llvm.ptr -> i32
%118 = arith.extsi %117 : i32 to i64
%119 = llvm.getelementptr %arg0[%118] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%116 = llvm.load %119 : !llvm.ptr -> i32
%120 = arith.cmpi sgt, %116, %104 : i32
cf.cond_br %120, ^bb24, ^bb25
^bb24:
%122 = llvm.load %112 : !llvm.ptr -> i32
%123 = arith.extsi %122 : i32 to i64
%124 = llvm.getelementptr %arg0[%123] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%121 = llvm.load %124 : !llvm.ptr -> i32
%125 = llvm.load %112 : !llvm.ptr -> i32
%126 = arith.constant 1 : i32
%127 = arith.addi %125, %126 : i32
%128 = arith.extsi %127 : i32 to i64
%129 = llvm.getelementptr %arg0[%128] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %121, %129 : i32, !llvm.ptr
%130 = llvm.load %112 : !llvm.ptr -> i32
%131 = arith.constant 1 : i32
%132 = arith.subi %130, %131 : i32
llvm.store %132, %112 : i32, !llvm.ptr
cf.br ^bb26
^bb25:
cf.br ^bb23
^bb26:
cf.br ^bb21
^bb23:
%133 = llvm.load %112 : !llvm.ptr -> i32
%134 = arith.constant 1 : i32
%135 = arith.addi %133, %134 : i32
%136 = arith.extsi %135 : i32 to i64
%137 = llvm.getelementptr %arg0[%136] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %104, %137 : i32, !llvm.ptr
%138 = llvm.load %101 : !llvm.ptr -> i32
%139 = arith.constant 1 : i32
%140 = arith.addi %138, %139 : i32
llvm.store %140, %101 : i32, !llvm.ptr
cf.br ^bb18
^bb20:
func.return
}
func.func @divisors_with_prefix(%arg0: i32) -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> {
%141 = arith.constant 1 : i32
%142 = arith.cmpi eq, %arg0, %141 : i32
cf.cond_br %142, ^bb27, ^bb28
^bb27:
%144 = arith.constant 4 : i32
%145 = arith.extsi %144 : i32 to i64
%143 = func.call @malloc(%145) : (i64) -> !llvm.ptr
%146 = arith.constant 1 : i32
%147 = arith.constant 0 : i32
%148 = arith.extsi %147 : i32 to i64
%149 = llvm.getelementptr %143[%148] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %146, %149 : i32, !llvm.ptr
%151 = arith.constant 16 : i32
%152 = arith.extsi %151 : i32 to i64
%150 = func.call @malloc(%152) : (i64) -> !llvm.ptr
%153 = arith.constant 0 : i32
%154 = arith.constant 0 : i32
%155 = arith.extsi %153 : i32 to i64
%156 = arith.extsi %154 : i32 to i64
%157 = llvm.getelementptr %150[%156] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %155, %157 : i64, !llvm.ptr
%158 = arith.constant 1 : i32
%159 = arith.constant 1 : i32
%160 = arith.extsi %158 : i32 to i64
%161 = arith.extsi %159 : i32 to i64
%162 = llvm.getelementptr %150[%161] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %160, %162 : i64, !llvm.ptr
%163 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%164 = llvm.insertvalue %143, %163[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%165 = llvm.insertvalue %150, %164[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%166 = arith.constant 1 : i32
%167 = llvm.insertvalue %166, %165[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%168 = arith.constant 1 : i32
%169 = arith.extsi %168 : i32 to i64
%170 = llvm.insertvalue %169, %167[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%171 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%172 = llvm.extractvalue %170[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%173 = llvm.insertvalue %172, %171[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%174 = llvm.extractvalue %170[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%175 = llvm.insertvalue %174, %173[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%176 = llvm.extractvalue %170[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%177 = llvm.insertvalue %176, %175[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%178 = llvm.extractvalue %170[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%179 = llvm.insertvalue %178, %177[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%180 = llvm.mlir.constant(1 : i64) : i64
%181 = llvm.alloca %180 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %179, %181 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%182 = llvm.load %181 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
func.return %182 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
^bb28:
cf.br ^bb29
^bb29:
%184 = arith.constant 256 : i32
%185 = arith.extsi %184 : i32 to i64
%183 = func.call @malloc(%185) : (i64) -> !llvm.ptr
%187 = arith.constant 256 : i32
%188 = arith.extsi %187 : i32 to i64
%186 = func.call @malloc(%188) : (i64) -> !llvm.ptr
%189 = arith.constant 0 : i32
%190 = llvm.mlir.constant(1 : i64) : i64
%191 = llvm.alloca %190 x i32 : (i64) -> !llvm.ptr
llvm.store %189, %191 : i32, !llvm.ptr
%192 = llvm.mlir.constant(1 : i64) : i64
%193 = llvm.alloca %192 x i32 : (i64) -> !llvm.ptr
llvm.store %arg0, %193 : i32, !llvm.ptr
cf.br ^bb30
^bb30:
%194 = llvm.load %193 : !llvm.ptr -> i32
%195 = arith.constant 1 : i32
%196 = arith.cmpi sgt, %194, %195 : i32
cf.cond_br %196, ^bb31, ^bb32
^bb31:
%198 = llvm.mlir.addressof @g_spf : !llvm.ptr
%199 = llvm.load %198 : !llvm.ptr -> !llvm.ptr
%200 = llvm.load %193 : !llvm.ptr -> i32
%201 = arith.extsi %200 : i32 to i64
%202 = llvm.getelementptr %199[%201] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%197 = llvm.load %202 : !llvm.ptr -> i32
%203 = arith.constant 0 : i32
%204 = llvm.mlir.constant(1 : i64) : i64
%205 = llvm.alloca %204 x i32 : (i64) -> !llvm.ptr
llvm.store %203, %205 : i32, !llvm.ptr
cf.br ^bb33
^bb33:
%206 = llvm.load %193 : !llvm.ptr -> i32
%207 = arith.remsi %206, %197 : i32
%208 = arith.constant 0 : i32
%209 = arith.cmpi eq, %207, %208 : i32
cf.cond_br %209, ^bb34, ^bb35
^bb34:
%210 = llvm.load %193 : !llvm.ptr -> i32
%211 = arith.divsi %210, %197 : i32
llvm.store %211, %193 : i32, !llvm.ptr
%212 = llvm.load %205 : !llvm.ptr -> i32
%213 = arith.constant 1 : i32
%214 = arith.addi %212, %213 : i32
llvm.store %214, %205 : i32, !llvm.ptr
cf.br ^bb33
^bb35:
%215 = llvm.load %191 : !llvm.ptr -> i32
%216 = arith.extsi %215 : i32 to i64
%217 = llvm.getelementptr %183[%216] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %197, %217 : i32, !llvm.ptr
%218 = llvm.load %205 : !llvm.ptr -> i32
%219 = llvm.load %191 : !llvm.ptr -> i32
%220 = arith.extsi %219 : i32 to i64
%221 = llvm.getelementptr %186[%220] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %218, %221 : i32, !llvm.ptr
%222 = llvm.load %191 : !llvm.ptr -> i32
%223 = arith.constant 1 : i32
%224 = arith.addi %222, %223 : i32
llvm.store %224, %191 : i32, !llvm.ptr
cf.br ^bb30
^bb32:
%225 = arith.constant 1 : i32
%226 = llvm.mlir.constant(1 : i64) : i64
%227 = llvm.alloca %226 x i32 : (i64) -> !llvm.ptr
llvm.store %225, %227 : i32, !llvm.ptr
%228 = arith.constant 0 : i32
%229 = llvm.mlir.constant(1 : i64) : i64
%230 = llvm.alloca %229 x i32 : (i64) -> !llvm.ptr
llvm.store %228, %230 : i32, !llvm.ptr
cf.br ^bb36
^bb36:
%231 = llvm.load %230 : !llvm.ptr -> i32
%232 = llvm.load %191 : !llvm.ptr -> i32
%233 = arith.cmpi slt, %231, %232 : i32
cf.cond_br %233, ^bb37, ^bb38
^bb37:
%234 = llvm.load %227 : !llvm.ptr -> i32
%236 = llvm.load %230 : !llvm.ptr -> i32
%237 = arith.extsi %236 : i32 to i64
%238 = llvm.getelementptr %186[%237] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%235 = llvm.load %238 : !llvm.ptr -> i32
%239 = arith.constant 1 : i32
%240 = arith.addi %235, %239 : i32
%241 = arith.muli %234, %240 : i32
llvm.store %241, %227 : i32, !llvm.ptr
%242 = llvm.load %230 : !llvm.ptr -> i32
%243 = arith.constant 1 : i32
%244 = arith.addi %242, %243 : i32
llvm.store %244, %230 : i32, !llvm.ptr
cf.br ^bb36
^bb38:
%246 = llvm.load %227 : !llvm.ptr -> i32
%247 = arith.extsi %246 : i32 to i64
%248 = arith.constant 4 : i32
%250 = arith.extsi %248 : i32 to i64
%249 = arith.muli %247, %250 : i64
%245 = func.call @malloc(%249) : (i64) -> !llvm.ptr
%251 = arith.constant 1 : i32
%252 = llvm.mlir.constant(1 : i64) : i64
%253 = llvm.alloca %252 x i32 : (i64) -> !llvm.ptr
llvm.store %251, %253 : i32, !llvm.ptr
%254 = arith.constant 1 : i32
%255 = arith.constant 0 : i32
%256 = arith.extsi %255 : i32 to i64
%257 = llvm.getelementptr %245[%256] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %254, %257 : i32, !llvm.ptr
%258 = arith.constant 0 : i32
%259 = llvm.mlir.constant(1 : i64) : i64
%260 = llvm.alloca %259 x i32 : (i64) -> !llvm.ptr
llvm.store %258, %260 : i32, !llvm.ptr
cf.br ^bb39
^bb39:
%261 = llvm.load %260 : !llvm.ptr -> i32
%262 = llvm.load %191 : !llvm.ptr -> i32
%263 = arith.cmpi slt, %261, %262 : i32
cf.cond_br %263, ^bb40, ^bb41
^bb40:
%265 = llvm.load %260 : !llvm.ptr -> i32
%266 = arith.extsi %265 : i32 to i64
%267 = llvm.getelementptr %183[%266] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%264 = llvm.load %267 : !llvm.ptr -> i32
%269 = llvm.load %260 : !llvm.ptr -> i32
%270 = arith.extsi %269 : i32 to i64
%271 = llvm.getelementptr %186[%270] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%268 = llvm.load %271 : !llvm.ptr -> i32
%272 = llvm.load %253 : !llvm.ptr -> i32
%273 = arith.constant 1 : i32
%274 = llvm.mlir.constant(1 : i64) : i64
%275 = llvm.alloca %274 x i32 : (i64) -> !llvm.ptr
llvm.store %273, %275 : i32, !llvm.ptr
%276 = arith.constant 1 : i32
%277 = llvm.mlir.constant(1 : i64) : i64
%278 = llvm.alloca %277 x i32 : (i64) -> !llvm.ptr
llvm.store %276, %278 : i32, !llvm.ptr
cf.br ^bb42
^bb42:
%279 = llvm.load %278 : !llvm.ptr -> i32
%280 = arith.cmpi sle, %279, %268 : i32
cf.cond_br %280, ^bb43, ^bb44
^bb43:
%281 = llvm.load %275 : !llvm.ptr -> i32
%282 = arith.muli %281, %264 : i32
llvm.store %282, %275 : i32, !llvm.ptr
%283 = arith.constant 0 : i32
%284 = llvm.mlir.constant(1 : i64) : i64
%285 = llvm.alloca %284 x i32 : (i64) -> !llvm.ptr
llvm.store %283, %285 : i32, !llvm.ptr
cf.br ^bb45
^bb45:
%286 = llvm.load %285 : !llvm.ptr -> i32
%287 = arith.cmpi slt, %286, %272 : i32
cf.cond_br %287, ^bb46, ^bb47
^bb46:
%289 = llvm.load %285 : !llvm.ptr -> i32
%290 = arith.extsi %289 : i32 to i64
%291 = llvm.getelementptr %245[%290] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%288 = llvm.load %291 : !llvm.ptr -> i32
%292 = llvm.load %275 : !llvm.ptr -> i32
%293 = arith.muli %288, %292 : i32
%294 = llvm.load %253 : !llvm.ptr -> i32
%295 = arith.extsi %294 : i32 to i64
%296 = llvm.getelementptr %245[%295] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %293, %296 : i32, !llvm.ptr
%297 = llvm.load %253 : !llvm.ptr -> i32
%298 = arith.constant 1 : i32
%299 = arith.addi %297, %298 : i32
llvm.store %299, %253 : i32, !llvm.ptr
%300 = llvm.load %285 : !llvm.ptr -> i32
%301 = arith.constant 1 : i32
%302 = arith.addi %300, %301 : i32
llvm.store %302, %285 : i32, !llvm.ptr
cf.br ^bb45
^bb47:
%303 = llvm.load %278 : !llvm.ptr -> i32
%304 = arith.constant 1 : i32
%305 = arith.addi %303, %304 : i32
llvm.store %305, %278 : i32, !llvm.ptr
cf.br ^bb42
^bb44:
%306 = llvm.load %260 : !llvm.ptr -> i32
%307 = arith.constant 1 : i32
%308 = arith.addi %306, %307 : i32
llvm.store %308, %260 : i32, !llvm.ptr
cf.br ^bb39
^bb41:
%310 = llvm.load %253 : !llvm.ptr -> i32
func.call @insertion_sort(%245, %310) : (!llvm.ptr, i32) -> ()
%312 = llvm.load %253 : !llvm.ptr -> i32
%313 = arith.extsi %312 : i32 to i64
%314 = arith.constant 1 : i32
%316 = arith.extsi %314 : i32 to i64
%315 = arith.addi %313, %316 : i64
%317 = arith.constant 8 : i32
%319 = arith.extsi %317 : i32 to i64
%318 = arith.muli %315, %319 : i64
%311 = func.call @malloc(%318) : (i64) -> !llvm.ptr
%320 = arith.constant 0 : i32
%321 = arith.extsi %320 : i32 to i64
%322 = llvm.mlir.constant(1 : i64) : i64
%323 = llvm.alloca %322 x i64 : (i64) -> !llvm.ptr
llvm.store %321, %323 : i64, !llvm.ptr
%324 = arith.constant 0 : i32
%325 = llvm.mlir.constant(1 : i64) : i64
%326 = llvm.alloca %325 x i32 : (i64) -> !llvm.ptr
llvm.store %324, %326 : i32, !llvm.ptr
cf.br ^bb48
^bb48:
%327 = llvm.load %326 : !llvm.ptr -> i32
%328 = llvm.load %253 : !llvm.ptr -> i32
%329 = arith.cmpi slt, %327, %328 : i32
cf.cond_br %329, ^bb49, ^bb50
^bb49:
%330 = llvm.load %323 : !llvm.ptr -> i64
%332 = llvm.load %326 : !llvm.ptr -> i32
%333 = arith.extsi %332 : i32 to i64
%334 = llvm.getelementptr %245[%333] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%331 = llvm.load %334 : !llvm.ptr -> i32
%335 = arith.extsi %331 : i32 to i64
%336 = arith.addi %330, %335 : i64
llvm.store %336, %323 : i64, !llvm.ptr
%337 = llvm.load %323 : !llvm.ptr -> i64
%338 = llvm.load %326 : !llvm.ptr -> i32
%339 = arith.constant 1 : i32
%340 = arith.addi %338, %339 : i32
%341 = arith.extsi %340 : i32 to i64
%342 = llvm.getelementptr %311[%341] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %337, %342 : i64, !llvm.ptr
%343 = llvm.load %326 : !llvm.ptr -> i32
%344 = arith.constant 1 : i32
%345 = arith.addi %343, %344 : i32
llvm.store %345, %326 : i32, !llvm.ptr
cf.br ^bb48
^bb50:
func.call @free(%183) : (!llvm.ptr) -> ()
func.call @free(%186) : (!llvm.ptr) -> ()
%348 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%349 = llvm.insertvalue %245, %348[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%350 = llvm.insertvalue %311, %349[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%351 = llvm.load %253 : !llvm.ptr -> i32
%352 = llvm.insertvalue %351, %350[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%353 = llvm.load %323 : !llvm.ptr -> i64
%354 = llvm.insertvalue %353, %352[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%355 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%356 = llvm.extractvalue %354[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%357 = llvm.insertvalue %356, %355[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%358 = llvm.extractvalue %354[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%359 = llvm.insertvalue %358, %357[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%360 = llvm.extractvalue %354[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%361 = llvm.insertvalue %360, %359[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%362 = llvm.extractvalue %354[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%363 = llvm.insertvalue %362, %361[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%364 = llvm.mlir.constant(1 : i64) : i64
%365 = llvm.alloca %364 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %363, %365 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%366 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
func.return %366 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
}
func.func @bisect_right(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> i32 {
%367 = arith.constant 0 : i32
%368 = llvm.mlir.constant(1 : i64) : i64
%369 = llvm.alloca %368 x i32 : (i64) -> !llvm.ptr
llvm.store %367, %369 : i32, !llvm.ptr
%370 = llvm.mlir.constant(1 : i64) : i64
%371 = llvm.alloca %370 x i32 : (i64) -> !llvm.ptr
llvm.store %arg1, %371 : i32, !llvm.ptr
cf.br ^bb51
^bb51:
%372 = llvm.load %369 : !llvm.ptr -> i32
%373 = llvm.load %371 : !llvm.ptr -> i32
%374 = arith.cmpi slt, %372, %373 : i32
cf.cond_br %374, ^bb52, ^bb53
^bb52:
%375 = llvm.load %369 : !llvm.ptr -> i32
%376 = llvm.load %371 : !llvm.ptr -> i32
%377 = arith.addi %375, %376 : i32
%378 = arith.constant 2 : i32
%379 = arith.divsi %377, %378 : i32
%381 = arith.extsi %379 : i32 to i64
%382 = llvm.getelementptr %arg0[%381] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%380 = llvm.load %382 : !llvm.ptr -> i32
%383 = arith.cmpi sle, %380, %arg2 : i32
cf.cond_br %383, ^bb54, ^bb55
^bb54:
%384 = arith.constant 1 : i32
%385 = arith.addi %379, %384 : i32
llvm.store %385, %369 : i32, !llvm.ptr
cf.br ^bb56
^bb55:
llvm.store %379, %371 : i32, !llvm.ptr
cf.br ^bb56
^bb56:
cf.br ^bb51
^bb53:
%386 = llvm.load %369 : !llvm.ptr -> i32
func.return %386 : i32
}
func.func @count_sum_products_gt(%arg0: !llvm.ptr, %arg1: i32, %arg2: !llvm.ptr, %arg3: i32, %arg4: !llvm.ptr, %arg5: i64, %arg6: i32) -> () {
%387 = arith.constant 0 : i32
%388 = arith.extsi %387 : i32 to i64
%389 = llvm.mlir.addressof @g_cnt : !llvm.ptr
llvm.store %388, %389 : i64, !llvm.ptr
%390 = arith.constant 0 : i32
%391 = arith.extsi %390 : i32 to i64
%392 = llvm.mlir.addressof @g_sum : !llvm.ptr
llvm.store %391, %392 : i64, !llvm.ptr
%393 = arith.constant 0 : i32
%394 = llvm.mlir.constant(1 : i64) : i64
%395 = llvm.alloca %394 x i32 : (i64) -> !llvm.ptr
llvm.store %393, %395 : i32, !llvm.ptr
cf.br ^bb57
^bb57:
%396 = llvm.load %395 : !llvm.ptr -> i32
%397 = arith.cmpi slt, %396, %arg1 : i32
cf.cond_br %397, ^bb58, ^bb59
^bb58:
%399 = llvm.load %395 : !llvm.ptr -> i32
%400 = arith.extsi %399 : i32 to i64
%401 = llvm.getelementptr %arg0[%400] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%398 = llvm.load %401 : !llvm.ptr -> i32
%403 = arith.divsi %arg6, %398 : i32
%402 = func.call @bisect_right(%arg2, %arg3, %403) : (!llvm.ptr, i32, i32) -> i32
%404 = arith.cmpi ne, %402, %arg3 : i32
cf.cond_br %404, ^bb60, ^bb61
^bb60:
%405 = llvm.mlir.addressof @g_cnt : !llvm.ptr
%406 = llvm.load %405 : !llvm.ptr -> i64
%407 = arith.subi %arg3, %402 : i32
%408 = arith.extsi %407 : i32 to i64
%409 = arith.addi %406, %408 : i64
%410 = llvm.mlir.addressof @g_cnt : !llvm.ptr
llvm.store %409, %410 : i64, !llvm.ptr
%411 = llvm.mlir.addressof @g_sum : !llvm.ptr
%412 = llvm.load %411 : !llvm.ptr -> i64
%413 = arith.extsi %398 : i32 to i64
%415 = arith.extsi %402 : i32 to i64
%416 = llvm.getelementptr %arg4[%415] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%414 = llvm.load %416 : !llvm.ptr -> i64
%417 = arith.subi %arg5, %414 : i64
%418 = arith.muli %413, %417 : i64
%419 = arith.addi %412, %418 : i64
%420 = llvm.mlir.addressof @g_sum : !llvm.ptr
llvm.store %419, %420 : i64, !llvm.ptr
cf.br ^bb62
^bb61:
cf.br ^bb62
^bb62:
%421 = llvm.load %395 : !llvm.ptr -> i32
%422 = arith.constant 1 : i32
%423 = arith.addi %421, %422 : i32
llvm.store %423, %395 : i32, !llvm.ptr
cf.br ^bb57
^bb59:
func.return
}
func.func @compute_T(%arg0: i64, %arg1: i32, %arg2: !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, %arg3: !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>) -> i64 {
%424 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%425 = llvm.extractvalue %arg2[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%426 = llvm.insertvalue %425, %424[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%427 = llvm.extractvalue %arg2[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%428 = llvm.insertvalue %427, %426[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%429 = llvm.extractvalue %arg2[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%430 = llvm.insertvalue %429, %428[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%431 = llvm.extractvalue %arg2[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%432 = llvm.insertvalue %431, %430[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%433 = llvm.mlir.constant(1 : i64) : i64
%434 = llvm.alloca %433 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %432, %434 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%435 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%436 = llvm.extractvalue %arg3[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%437 = llvm.insertvalue %436, %435[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%438 = llvm.extractvalue %arg3[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%439 = llvm.insertvalue %438, %437[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%440 = llvm.extractvalue %arg3[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%441 = llvm.insertvalue %440, %439[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%442 = llvm.extractvalue %arg3[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%443 = llvm.insertvalue %442, %441[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%444 = llvm.mlir.constant(1 : i64) : i64
%445 = llvm.alloca %444 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %443, %445 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%446 = llvm.mlir.zero : !llvm.ptr
%447 = llvm.mlir.constant(1 : i64) : i64
%448 = llvm.alloca %447 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %446, %448 : !llvm.ptr, !llvm.ptr
%449 = llvm.mlir.zero : !llvm.ptr
%450 = llvm.mlir.constant(1 : i64) : i64
%451 = llvm.alloca %450 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %449, %451 : !llvm.ptr, !llvm.ptr
%452 = arith.constant 0 : i32
%453 = llvm.mlir.constant(1 : i64) : i64
%454 = llvm.alloca %453 x i32 : (i64) -> !llvm.ptr
llvm.store %452, %454 : i32, !llvm.ptr
%455 = arith.constant 0 : i32
%456 = llvm.mlir.constant(1 : i64) : i64
%457 = llvm.alloca %456 x i32 : (i64) -> !llvm.ptr
llvm.store %455, %457 : i32, !llvm.ptr
%458 = llvm.mlir.zero : !llvm.ptr
%459 = llvm.mlir.constant(1 : i64) : i64
%460 = llvm.alloca %459 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %458, %460 : !llvm.ptr, !llvm.ptr
%461 = arith.constant 0 : i32
%462 = arith.extsi %461 : i32 to i64
%463 = llvm.mlir.constant(1 : i64) : i64
%464 = llvm.alloca %463 x i64 : (i64) -> !llvm.ptr
llvm.store %462, %464 : i64, !llvm.ptr
%465 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%466 = llvm.getelementptr %434[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%467 = llvm.load %466 : !llvm.ptr -> i32
%468 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%469 = llvm.getelementptr %445[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%470 = llvm.load %469 : !llvm.ptr -> i32
%471 = arith.cmpi sle, %467, %470 : i32
cf.cond_br %471, ^bb63, ^bb64
^bb63:
%472 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%473 = llvm.getelementptr %434[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%474 = llvm.load %473 : !llvm.ptr -> !llvm.ptr
llvm.store %474, %448 : !llvm.ptr, !llvm.ptr
%475 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%476 = llvm.getelementptr %434[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%477 = llvm.load %476 : !llvm.ptr -> i32
llvm.store %477, %454 : i32, !llvm.ptr
%478 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%479 = llvm.getelementptr %445[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%480 = llvm.load %479 : !llvm.ptr -> !llvm.ptr
llvm.store %480, %451 : !llvm.ptr, !llvm.ptr
%481 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%482 = llvm.getelementptr %445[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%483 = llvm.load %482 : !llvm.ptr -> i32
llvm.store %483, %457 : i32, !llvm.ptr
%484 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%485 = llvm.getelementptr %445[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%486 = llvm.load %485 : !llvm.ptr -> !llvm.ptr
llvm.store %486, %460 : !llvm.ptr, !llvm.ptr
%487 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%488 = llvm.getelementptr %445[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%489 = llvm.load %488 : !llvm.ptr -> i64
llvm.store %489, %464 : i64, !llvm.ptr
cf.br ^bb65
^bb64:
%490 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%491 = llvm.getelementptr %445[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%492 = llvm.load %491 : !llvm.ptr -> !llvm.ptr
llvm.store %492, %448 : !llvm.ptr, !llvm.ptr
%493 = llvm.load %445 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%494 = llvm.getelementptr %445[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%495 = llvm.load %494 : !llvm.ptr -> i32
llvm.store %495, %454 : i32, !llvm.ptr
%496 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%497 = llvm.getelementptr %434[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%498 = llvm.load %497 : !llvm.ptr -> !llvm.ptr
llvm.store %498, %451 : !llvm.ptr, !llvm.ptr
%499 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%500 = llvm.getelementptr %434[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%501 = llvm.load %500 : !llvm.ptr -> i32
llvm.store %501, %457 : i32, !llvm.ptr
%502 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%503 = llvm.getelementptr %434[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%504 = llvm.load %503 : !llvm.ptr -> !llvm.ptr
llvm.store %504, %460 : !llvm.ptr, !llvm.ptr
%505 = llvm.load %434 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%506 = llvm.getelementptr %434[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%507 = llvm.load %506 : !llvm.ptr -> i64
llvm.store %507, %464 : i64, !llvm.ptr
cf.br ^bb65
^bb65:
%508 = arith.trunci %arg0 : i64 to i32
%509 = arith.divsi %508, %arg1 : i32
%511 = llvm.load %448 : !llvm.ptr -> !llvm.ptr
%512 = llvm.load %454 : !llvm.ptr -> i32
%513 = llvm.load %451 : !llvm.ptr -> !llvm.ptr
%514 = llvm.load %457 : !llvm.ptr -> i32
%515 = llvm.load %460 : !llvm.ptr -> !llvm.ptr
%516 = llvm.load %464 : !llvm.ptr -> i64
func.call @count_sum_products_gt(%511, %512, %513, %514, %515, %516, %508) : (!llvm.ptr, i32, !llvm.ptr, i32, !llvm.ptr, i64, i32) -> ()
%517 = llvm.mlir.addressof @g_cnt : !llvm.ptr
%518 = llvm.load %517 : !llvm.ptr -> i64
%519 = llvm.mlir.addressof @g_sum : !llvm.ptr
%520 = llvm.load %519 : !llvm.ptr -> i64
%522 = llvm.load %448 : !llvm.ptr -> !llvm.ptr
%523 = llvm.load %454 : !llvm.ptr -> i32
%524 = llvm.load %451 : !llvm.ptr -> !llvm.ptr
%525 = llvm.load %457 : !llvm.ptr -> i32
%526 = llvm.load %460 : !llvm.ptr -> !llvm.ptr
%527 = llvm.load %464 : !llvm.ptr -> i64
func.call @count_sum_products_gt(%522, %523, %524, %525, %526, %527, %509) : (!llvm.ptr, i32, !llvm.ptr, i32, !llvm.ptr, i64, i32) -> ()
%528 = llvm.mlir.addressof @g_cnt : !llvm.ptr
%529 = llvm.load %528 : !llvm.ptr -> i64
%530 = llvm.mlir.addressof @g_sum : !llvm.ptr
%531 = llvm.load %530 : !llvm.ptr -> i64
%532 = arith.addi %518, %529 : i64
%533 = arith.extsi %arg1 : i32 to i64
%534 = arith.muli %533, %531 : i64
%535 = arith.addi %520, %534 : i64
%536 = arith.muli %arg0, %532 : i64
%537 = arith.subi %535, %536 : i64
func.return %537 : i64
}
func.func @main() -> i32 {
%538 = llvm.mlir.addressof @N_LIMIT : !llvm.ptr
%539 = llvm.load %538 : !llvm.ptr -> i32
func.call @build_spf(%539) : (i32) -> ()
%541 = arith.constant 0 : i32
%542 = arith.extsi %541 : i32 to i64
%543 = llvm.mlir.constant(1 : i64) : i64
%544 = llvm.alloca %543 x i64 : (i64) -> !llvm.ptr
llvm.store %542, %544 : i64, !llvm.ptr
%545 = arith.constant 1 : i32
%547 = arith.constant 0 : i32
%546 = arith.subi %547, %545 : i32
%548 = llvm.mlir.constant(1 : i64) : i64
%549 = llvm.alloca %548 x i32 : (i64) -> !llvm.ptr
llvm.store %546, %549 : i32, !llvm.ptr
%550 = arith.constant 1 : i32
%552 = arith.constant 0 : i32
%551 = arith.subi %552, %550 : i32
%553 = llvm.mlir.constant(1 : i64) : i64
%554 = llvm.alloca %553 x i32 : (i64) -> !llvm.ptr
llvm.store %551, %554 : i32, !llvm.ptr
%555 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%556 = llvm.mlir.zero : !llvm.ptr
%557 = llvm.insertvalue %556, %555[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%558 = llvm.mlir.zero : !llvm.ptr
%559 = llvm.insertvalue %558, %557[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%560 = arith.constant 0 : i32
%561 = llvm.insertvalue %560, %559[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%562 = arith.constant 0 : i32
%563 = arith.extsi %562 : i32 to i64
%564 = llvm.insertvalue %563, %561[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%565 = llvm.mlir.constant(1 : i64) : i64
%566 = llvm.alloca %565 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %564, %566 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%567 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%568 = llvm.mlir.zero : !llvm.ptr
%569 = llvm.insertvalue %568, %567[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%570 = llvm.mlir.zero : !llvm.ptr
%571 = llvm.insertvalue %570, %569[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%572 = arith.constant 0 : i32
%573 = llvm.insertvalue %572, %571[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%574 = arith.constant 0 : i32
%575 = arith.extsi %574 : i32 to i64
%576 = llvm.insertvalue %575, %573[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%577 = llvm.mlir.constant(1 : i64) : i64
%578 = llvm.alloca %577 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %576, %578 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%579 = arith.constant 3 : i32
%580 = llvm.mlir.constant(1 : i64) : i64
%581 = llvm.alloca %580 x i32 : (i64) -> !llvm.ptr
llvm.store %579, %581 : i32, !llvm.ptr
cf.br ^bb66
^bb66:
%582 = llvm.load %581 : !llvm.ptr -> i32
%583 = arith.cmpi sle, %582, %539 : i32
cf.cond_br %583, ^bb67, ^bb68
^bb67:
%584 = llvm.mlir.undef : i32
%585 = llvm.mlir.undef : i32
%586 = llvm.load %581 : !llvm.ptr -> i32
%587 = arith.constant 1 : i32
%588 = arith.andi %586, %587 : i32
%589 = arith.constant 0 : i32
%590 = arith.cmpi ne, %588, %589 : i32
%591, %592 = scf.if %590 -> (i32, i32) {
%593 = llvm.load %581 : !llvm.ptr -> i32
%594 = arith.constant 1 : i32
%595 = arith.subi %593, %594 : i32
%596 = llvm.load %581 : !llvm.ptr -> i32
scf.yield %595, %596 : i32, i32
} else {
%597 = llvm.load %581 : !llvm.ptr -> i32
%598 = llvm.load %581 : !llvm.ptr -> i32
%599 = arith.constant 1 : i32
%600 = arith.subi %598, %599 : i32
scf.yield %597, %600 : i32, i32
}
%601 = arith.constant 0 : i32
%602 = arith.subi %601, %591 : i32
%603 = arith.andi %591, %602 : i32
%604 = arith.divsi %591, %603 : i32
%605 = llvm.load %549 : !llvm.ptr -> i32
%606 = arith.cmpi ne, %604, %605 : i32
cf.cond_br %606, ^bb69, ^bb70
^bb69:
%607 = llvm.load %549 : !llvm.ptr -> i32
%608 = arith.constant 1 : i32
%610 = arith.constant 0 : i32
%609 = arith.subi %610, %608 : i32
%611 = arith.cmpi ne, %607, %609 : i32
cf.cond_br %611, ^bb72, ^bb73
^bb72:
%613 = llvm.load %566 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%614 = llvm.getelementptr %566[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%615 = llvm.load %614 : !llvm.ptr -> !llvm.ptr
func.call @free(%615) : (!llvm.ptr) -> ()
%617 = llvm.load %566 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%618 = llvm.getelementptr %566[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%619 = llvm.load %618 : !llvm.ptr -> !llvm.ptr
func.call @free(%619) : (!llvm.ptr) -> ()
cf.br ^bb74
^bb73:
cf.br ^bb74
^bb74:
%620 = func.call @divisors_with_prefix(%604) : (i32) -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%621 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%622 = llvm.extractvalue %620[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%623 = llvm.insertvalue %622, %621[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%624 = llvm.extractvalue %620[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%625 = llvm.insertvalue %624, %623[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%626 = llvm.extractvalue %620[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%627 = llvm.insertvalue %626, %625[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%628 = llvm.extractvalue %620[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%629 = llvm.insertvalue %628, %627[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%630 = llvm.mlir.constant(1 : i64) : i64
%631 = llvm.alloca %630 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %629, %631 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%632 = llvm.load %631 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
llvm.store %632, %566 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
llvm.store %604, %549 : i32, !llvm.ptr
cf.br ^bb71
^bb70:
cf.br ^bb71
^bb71:
%633 = llvm.load %554 : !llvm.ptr -> i32
%634 = arith.cmpi ne, %592, %633 : i32
cf.cond_br %634, ^bb75, ^bb76
^bb75:
%635 = llvm.load %554 : !llvm.ptr -> i32
%636 = arith.constant 1 : i32
%638 = arith.constant 0 : i32
%637 = arith.subi %638, %636 : i32
%639 = arith.cmpi ne, %635, %637 : i32
cf.cond_br %639, ^bb78, ^bb79
^bb78:
%641 = llvm.load %578 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%642 = llvm.getelementptr %578[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%643 = llvm.load %642 : !llvm.ptr -> !llvm.ptr
func.call @free(%643) : (!llvm.ptr) -> ()
%645 = llvm.load %578 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%646 = llvm.getelementptr %578[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%647 = llvm.load %646 : !llvm.ptr -> !llvm.ptr
func.call @free(%647) : (!llvm.ptr) -> ()
cf.br ^bb80
^bb79:
cf.br ^bb80
^bb80:
%648 = func.call @divisors_with_prefix(%592) : (i32) -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%649 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%650 = llvm.extractvalue %648[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%651 = llvm.insertvalue %650, %649[0] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%652 = llvm.extractvalue %648[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%653 = llvm.insertvalue %652, %651[1] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%654 = llvm.extractvalue %648[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%655 = llvm.insertvalue %654, %653[2] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%656 = llvm.extractvalue %648[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%657 = llvm.insertvalue %656, %655[3] : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%658 = llvm.mlir.constant(1 : i64) : i64
%659 = llvm.alloca %658 x !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)> : (i64) -> !llvm.ptr
llvm.store %657, %659 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
%660 = llvm.load %659 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
llvm.store %660, %578 : !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.ptr
llvm.store %592, %554 : i32, !llvm.ptr
cf.br ^bb77
^bb76:
cf.br ^bb77
^bb77:
%661 = llvm.load %544 : !llvm.ptr -> i64
%663 = llvm.load %581 : !llvm.ptr -> i32
%664 = arith.extsi %663 : i32 to i64
%665 = llvm.load %566 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%666 = llvm.load %578 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%662 = func.call @compute_T(%664, %603, %665, %666) : (i64, i32, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>) -> i64
%667 = arith.addi %661, %662 : i64
llvm.store %667, %544 : i64, !llvm.ptr
%668 = llvm.load %581 : !llvm.ptr -> i32
%669 = arith.constant 1 : i32
%670 = arith.addi %668, %669 : i32
llvm.store %670, %581 : i32, !llvm.ptr
cf.br ^bb66
^bb68:
%672 = llvm.load %566 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%673 = llvm.getelementptr %566[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%674 = llvm.load %673 : !llvm.ptr -> !llvm.ptr
func.call @free(%674) : (!llvm.ptr) -> ()
%676 = llvm.load %566 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%677 = llvm.getelementptr %566[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%678 = llvm.load %677 : !llvm.ptr -> !llvm.ptr
func.call @free(%678) : (!llvm.ptr) -> ()
%680 = llvm.load %578 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%681 = llvm.getelementptr %578[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%682 = llvm.load %681 : !llvm.ptr -> !llvm.ptr
func.call @free(%682) : (!llvm.ptr) -> ()
%684 = llvm.load %578 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%685 = llvm.getelementptr %578[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, !llvm.ptr, i32, i64)>
%686 = llvm.load %685 : !llvm.ptr -> !llvm.ptr
func.call @free(%686) : (!llvm.ptr) -> ()
%688 = llvm.mlir.addressof @g_spf : !llvm.ptr
%689 = llvm.load %688 : !llvm.ptr -> !llvm.ptr
func.call @free(%689) : (!llvm.ptr) -> ()
%690 = llvm.mlir.addressof @str_0 : !llvm.ptr
%691 = llvm.load %544 : !llvm.ptr -> i64
%692 = llvm.call @printf(%690, %691) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%693 = arith.constant 0 : i32
func.return %693 : i32
}
}