← All problems Problem 765
Optimal betting strategy via fair-coin martingale bound. Pure Flow port of the native C helper. GMP big integers are replaced by a base-10000 big integer library implemented in Flow.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^2)O(n * m)Space complexity O(n^2)O(n)Approach Flow solution Dynamic programming or generating function Verdict Unknown
Flow source
# Project Euler 765: Trillionaire
# Optimal betting strategy via fair-coin martingale bound.
# Pure Flow port of the native C helper. GMP big integers are replaced by
# a base-10000 big integer library implemented in Flow.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function malloc(n: i64) -> ptr<void>
}
const BASE: i64 = 10000
struct Big {
data: ptr<i32>,
len: i32
}
function big_norm(data: ptr<i32>, len: i32) -> Big {
let mut n: i32 = len
while n > 1 {
if data[n - 1] != 0 {
break
}
n = n - 1
}
return Big { data: data, len: n }
}
function big_from_i32(val: i32) -> Big {
let data: ptr<i32> = malloc(4)
data[0] = val
return Big { data: data, len: 1 }
}
function big_is_zero(a: Big) -> i32 {
if a.len == 1 {
if a.data[0] == 0 {
return 1
}
}
return 0
}
function big_cmp(a: Big, b: Big) -> i32 {
if a.len != b.len {
if a.len > b.len {
return 1
}
return -1
}
let mut i: i32 = a.len - 1
while i >= 0 {
if a.data[i] != b.data[i] {
if a.data[i] > b.data[i] {
return 1
}
return -1
}
i = i - 1
}
return 0
}
function big_add(a: Big, b: Big) -> Big {
let mut max_len: i32 = a.len
if b.len > max_len {
max_len = b.len
}
let data: ptr<i32> = malloc(((max_len + 1) as i64) * 4)
let mut carry: i32 = 0
let mut i: i32 = 0
while i < max_len {
let mut sum: i32 = carry
if i < a.len {
sum = sum + a.data[i]
}
if i < b.len {
sum = sum + b.data[i]
}
data[i] = sum % (BASE as i32)
carry = sum / (BASE as i32)
i = i + 1
}
data[max_len] = carry
return big_norm(data, max_len + 1)
}
function big_sub(a: Big, b: Big) -> Big {
let data: ptr<i32> = malloc((a.len as i64) * 4)
let mut borrow: i32 = 0
let mut i: i32 = 0
while i < a.len {
let mut diff: i32 = a.data[i] - borrow
if i < b.len {
diff = diff - b.data[i]
}
if diff < 0 {
diff = diff + (BASE as i32)
borrow = 1
} else {
borrow = 0
}
data[i] = diff
i = i + 1
}
return big_norm(data, a.len)
}
function big_mul_small(a: Big, m: i32) -> Big {
let data: ptr<i32> = malloc(((a.len + 1) as i64) * 4)
let mut carry: i64 = 0
let mut i: i32 = 0
while i < a.len {
let prod: i64 = (a.data[i] as i64) * (m as i64) + carry
data[i] = (prod % BASE) as i32
carry = prod / BASE
i = i + 1
}
data[a.len] = carry as i32
return big_norm(data, a.len + 1)
}
function big_mul(a: Big, b: Big) -> Big {
let total: i32 = a.len + b.len
let result: ptr<i64> = calloc((total as i64), 8)
let mut i: i32 = 0
while i < a.len {
let mut j: i32 = 0
while j < b.len {
result[i + j] = result[i + j] + (a.data[i] as i64) * (b.data[j] as i64)
j = j + 1
}
i = i + 1
}
let data: ptr<i32> = malloc((total as i64) * 4)
let mut carry: i64 = 0
let mut k: i32 = 0
while k < total {
let val: i64 = result[k] + carry
data[k] = (val % BASE) as i32
carry = val / BASE
k = k + 1
}
free(result)
return big_norm(data, total)
}
function big_div_small(a: Big, d: i32) -> Big {
let data: ptr<i32> = malloc((a.len as i64) * 4)
let mut rem: i64 = 0
let mut i: i32 = a.len - 1
while i >= 0 {
let cur: i64 = rem * BASE + (a.data[i] as i64)
data[i] = (cur / (d as i64)) as i32
rem = cur % (d as i64)
i = i - 1
}
return big_norm(data, a.len)
}
function big_to_double(a: Big) -> f64 {
let mut result: f64 = 0.0
let mut i: i32 = a.len - 1
while i >= 0 {
result = result * (BASE as f64) + (a.data[i] as f64)
i = i - 1
}
return result
}
function main() -> i32 {
let n: i32 = 1000
# total_paths = 2^n
let mut total_paths: Big = big_from_i32(1)
let mut i: i32 = 0
while i < n {
total_paths = big_mul_small(total_paths, 2)
i = i + 1
}
# budget_paths = total_paths / 10^12 (divide by 10 twelve times)
let mut budget_paths: Big = total_paths
let mut j: i32 = 0
while j < 12 {
budget_paths = big_div_small(budget_paths, 10)
j = j + 1
}
# Compute C(n, k) for k = 0..n
let comb: ptr<Big> = malloc(((n + 1) as i64) * 16)
comb[0] = big_from_i32(1)
let mut k: i32 = 1
while k <= n {
let mul_val: Big = big_mul_small(comb[k - 1], n - k + 1)
comb[k] = big_div_small(mul_val, k)
k = k + 1
}
# Compute suffix[k] = sum_{j>=k} C(n, j)
let suffix: ptr<Big> = malloc(((n + 2) as i64) * 16)
suffix[n + 1] = big_from_i32(0)
let mut k2: i32 = n
while k2 >= 0 {
suffix[k2] = big_add(suffix[k2 + 1], comb[k2])
k2 = k2 - 1
}
# Find k0: largest k such that suffix[k] > budget_paths and budget_paths >= suffix[k+1]
let mut k0: i32 = -1
let mut k3: i32 = n
while k3 >= 0 {
if big_cmp(suffix[k3], budget_paths) > 0 {
if big_cmp(budget_paths, suffix[k3 + 1]) >= 0 {
k0 = k3
break
}
}
k3 = k3 - 1
}
# rem = budget_paths - suffix[k0 + 1]
let rem: Big = big_sub(budget_paths, suffix[k0 + 1])
# Precompute pow2[i] = 2^i, pow3[i] = 3^i
let pow2: ptr<Big> = malloc(((n + 1) as i64) * 16)
let pow3: ptr<Big> = malloc(((n + 1) as i64) * 16)
pow2[0] = big_from_i32(1)
pow3[0] = big_from_i32(1)
let mut i4: i32 = 1
while i4 <= n {
pow2[i4] = big_mul_small(pow2[i4 - 1], 2)
pow3[i4] = big_mul_small(pow3[i4 - 1], 3)
i4 = i4 + 1
}
# den = 5^n
let mut den: Big = big_from_i32(1)
let mut i5: i32 = 0
while i5 < n {
den = big_mul_small(den, 5)
i5 = i5 + 1
}
# num = sum over k>=k0+1 of C(n,k)*3^k*2^(n-k) + rem*3^k0*2^(n-k0)
let mut num: Big = big_from_i32(0)
let mut k4: i32 = k0 + 1
while k4 <= n {
let term: Big = big_mul(comb[k4], pow3[k4])
let term2: Big = big_mul(term, pow2[n - k4])
num = big_add(num, term2)
k4 = k4 + 1
}
if big_is_zero(rem) == 0 {
let term: Big = big_mul(rem, pow3[k0])
let term2: Big = big_mul(term, pow2[n - k0])
num = big_add(num, term2)
}
# scaled_num = num * 10^10 (multiply by 10 ten times)
let mut scaled_num: Big = num
let mut i6: i32 = 0
while i6 < 10 {
scaled_num = big_mul_small(scaled_num, 10)
i6 = i6 + 1
}
# q = scaled_num / den (divide by 5 n times since den = 5^n)
let mut q: Big = scaled_num
let mut i7: i32 = 0
while i7 < n {
q = big_div_small(q, 5)
i7 = i7 + 1
}
# r = scaled_num - q * den
let q_den: Big = big_mul(q, den)
let r: Big = big_sub(scaled_num, q_den)
# if 2*r >= den: q += 1
let r2: Big = big_mul_small(r, 2)
if big_cmp(r2, den) >= 0 {
q = big_add(q, big_from_i32(1))
}
# result = q / 10^10 as double
let q_double: f64 = big_to_double(q)
let result: f64 = q_double / 1e10
printf("%.10f\n", result)
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 Big Big;
struct Big {
int32_t* data;
int32_t len;
};
Big big_norm_ptr_i32_i32(int32_t* data, int32_t len);
Big big_from_i32_i32(int32_t val);
int32_t big_is_zero_Big(Big a);
int32_t big_cmp_Big_Big(Big a, Big b);
Big big_add_Big_Big(Big a, Big b);
Big big_sub_Big_Big(Big a, Big b);
Big big_mul_small_Big_i32(Big a, int32_t m);
Big big_mul_Big_Big(Big a, Big b);
Big big_div_small_Big_i32(Big a, int32_t d);
double big_to_double_Big(Big a);
int32_t main(void);
static const int64_t BASE = 10000;
Big big_norm_ptr_i32_i32(int32_t* data, int32_t len) {
int32_t n = len;
while (n > 1) {
if (data[(n - 1)] != 0) {
break;
}
n = (n - 1);
}
return (Big){ .data = data, .len = n };
}
Big big_from_i32_i32(int32_t val) {
int32_t* data = (int32_t*)(malloc(4));
data[0] = val;
return (Big){ .data = data, .len = 1 };
}
int32_t big_is_zero_Big(Big a) {
if (a.len == 1) {
if (a.data[0] == 0) {
return 1;
}
}
return 0;
}
int32_t big_cmp_Big_Big(Big a, Big b) {
if (a.len != b.len) {
if (a.len > b.len) {
return 1;
}
return (-1);
}
int32_t i = (a.len - 1);
while (i >= 0) {
if (a.data[i] != b.data[i]) {
if (a.data[i] > b.data[i]) {
return 1;
}
return (-1);
}
i = (i - 1);
}
return 0;
}
Big big_add_Big_Big(Big a, Big b) {
int32_t max_len = a.len;
if (b.len > max_len) {
max_len = b.len;
}
int32_t* data = (int32_t*)(malloc((((int64_t)((max_len + 1))) * 4)));
int32_t carry = 0;
int32_t i = 0;
while (i < max_len) {
int32_t sum = carry;
if (i < a.len) {
sum = (sum + a.data[i]);
}
if (i < b.len) {
sum = (sum + b.data[i]);
}
data[i] = FLOW_CHECKED_MOD((sum), (((int32_t)(BASE))));
carry = FLOW_CHECKED_DIV((sum), (((int32_t)(BASE))));
i = (i + 1);
}
data[max_len] = carry;
return big_norm_ptr_i32_i32(data, (max_len + 1));
}
Big big_sub_Big_Big(Big a, Big b) {
int32_t* data = (int32_t*)(malloc((((int64_t)(a.len)) * 4)));
int32_t borrow = 0;
int32_t i = 0;
while (i < a.len) {
int32_t diff = (a.data[i] - borrow);
if (i < b.len) {
diff = (diff - b.data[i]);
}
if (diff < 0) {
diff = (diff + ((int32_t)(BASE)));
borrow = 1;
} else {
borrow = 0;
}
data[i] = diff;
i = (i + 1);
}
return big_norm_ptr_i32_i32(data, a.len);
}
Big big_mul_small_Big_i32(Big a, int32_t m) {
int32_t* data = (int32_t*)(malloc((((int64_t)((a.len + 1))) * 4)));
int64_t carry = 0;
int32_t i = 0;
while (i < a.len) {
int64_t prod = ((((int64_t)(a.data[i])) * ((int64_t)(m))) + carry);
data[i] = ((int32_t)(FLOW_CHECKED_MOD((prod), (BASE))));
carry = FLOW_CHECKED_DIV((prod), (BASE));
i = (i + 1);
}
data[a.len] = ((int32_t)(carry));
return big_norm_ptr_i32_i32(data, (a.len + 1));
}
Big big_mul_Big_Big(Big a, Big b) {
int32_t total = (a.len + b.len);
int64_t* result = (int64_t*)(calloc(((int64_t)(total)), 8));
int32_t i = 0;
while (i < a.len) {
int32_t j = 0;
while (j < b.len) {
result[(i + j)] = (result[(i + j)] + (((int64_t)(a.data[i])) * ((int64_t)(b.data[j]))));
j = (j + 1);
}
i = (i + 1);
}
int32_t* data = (int32_t*)(malloc((((int64_t)(total)) * 4)));
int64_t carry = 0;
int32_t k = 0;
while (k < total) {
int64_t val = (result[k] + carry);
data[k] = ((int32_t)(FLOW_CHECKED_MOD((val), (BASE))));
carry = FLOW_CHECKED_DIV((val), (BASE));
k = (k + 1);
}
free(result);
return big_norm_ptr_i32_i32(data, total);
}
Big big_div_small_Big_i32(Big a, int32_t d) {
int32_t* data = (int32_t*)(malloc((((int64_t)(a.len)) * 4)));
int64_t rem = 0;
int32_t i = (a.len - 1);
while (i >= 0) {
int64_t cur = ((rem * BASE) + ((int64_t)(a.data[i])));
data[i] = ((int32_t)(FLOW_CHECKED_DIV((cur), (((int64_t)(d))))));
rem = FLOW_CHECKED_MOD((cur), (((int64_t)(d))));
i = (i - 1);
}
return big_norm_ptr_i32_i32(data, a.len);
}
double big_to_double_Big(Big a) {
double result = 0.0;
int32_t i = (a.len - 1);
while (i >= 0) {
result = ((result * ((double)(BASE))) + ((double)(a.data[i])));
i = (i - 1);
}
return result;
}
int32_t main(void) {
int32_t n = 1000;
Big total_paths = big_from_i32_i32(1);
int32_t i = 0;
while (i < n) {
total_paths = big_mul_small_Big_i32(total_paths, 2);
i = (i + 1);
}
Big budget_paths = total_paths;
int32_t j = 0;
while (j < 12) {
budget_paths = big_div_small_Big_i32(budget_paths, 10);
j = (j + 1);
}
Big* comb = (Big*)(malloc((((int64_t)((n + 1))) * 16)));
comb[0] = big_from_i32_i32(1);
int32_t k = 1;
while (k <= n) {
Big mul_val = big_mul_small_Big_i32(comb[(k - 1)], ((n - k) + 1));
comb[k] = big_div_small_Big_i32(mul_val, k);
k = (k + 1);
}
Big* suffix = (Big*)(malloc((((int64_t)((n + 2))) * 16)));
suffix[(n + 1)] = big_from_i32_i32(0);
int32_t k2 = n;
while (k2 >= 0) {
suffix[k2] = big_add_Big_Big(suffix[(k2 + 1)], comb[k2]);
k2 = (k2 - 1);
}
int32_t k0 = (-1);
int32_t k3 = n;
while (k3 >= 0) {
if (big_cmp_Big_Big(suffix[k3], budget_paths) > 0) {
if (big_cmp_Big_Big(budget_paths, suffix[(k3 + 1)]) >= 0) {
k0 = k3;
break;
}
}
k3 = (k3 - 1);
}
Big rem = big_sub_Big_Big(budget_paths, suffix[(k0 + 1)]);
Big* pow2 = (Big*)(malloc((((int64_t)((n + 1))) * 16)));
Big* pow3 = (Big*)(malloc((((int64_t)((n + 1))) * 16)));
pow2[0] = big_from_i32_i32(1);
pow3[0] = big_from_i32_i32(1);
int32_t i4 = 1;
while (i4 <= n) {
pow2[i4] = big_mul_small_Big_i32(pow2[(i4 - 1)], 2);
pow3[i4] = big_mul_small_Big_i32(pow3[(i4 - 1)], 3);
i4 = (i4 + 1);
}
Big den = big_from_i32_i32(1);
int32_t i5 = 0;
while (i5 < n) {
den = big_mul_small_Big_i32(den, 5);
i5 = (i5 + 1);
}
Big num = big_from_i32_i32(0);
int32_t k4 = (k0 + 1);
while (k4 <= n) {
Big term = big_mul_Big_Big(comb[k4], pow3[k4]);
Big term2 = big_mul_Big_Big(term, pow2[(n - k4)]);
num = big_add_Big_Big(num, term2);
k4 = (k4 + 1);
}
if (big_is_zero_Big(rem) == 0) {
Big term = big_mul_Big_Big(rem, pow3[k0]);
Big term2 = big_mul_Big_Big(term, pow2[(n - k0)]);
num = big_add_Big_Big(num, term2);
}
Big scaled_num = num;
int32_t i6 = 0;
while (i6 < 10) {
scaled_num = big_mul_small_Big_i32(scaled_num, 10);
i6 = (i6 + 1);
}
Big q = scaled_num;
int32_t i7 = 0;
while (i7 < n) {
q = big_div_small_Big_i32(q, 5);
i7 = (i7 + 1);
}
Big q_den = big_mul_Big_Big(q, den);
Big r = big_sub_Big_Big(scaled_num, q_den);
Big r2 = big_mul_small_Big_i32(r, 2);
if (big_cmp_Big_Big(r2, den) >= 0) {
q = big_add_Big_Big(q, big_from_i32_i32(1));
}
double q_double = big_to_double_Big(q);
double result = (q_double / 1e10);
printf("%.10f\n", result);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%.10f\n\00") {addr_space = 0 : i32} : !llvm.array<7 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @malloc(i64) -> !llvm.ptr
// Constant: BASE
llvm.mlir.global internal constant @BASE(10000 : i64) : i64
// Struct: Big
// Fields:
// data: !llvm.ptr
// len: i32
func.func @big_norm(%arg0: !llvm.ptr, %arg1: i32) -> !llvm.struct<(!llvm.ptr, i32)> {
%0 = llvm.mlir.constant(1 : i64) : i64
%1 = llvm.alloca %0 x i32 : (i64) -> !llvm.ptr
llvm.store %arg1, %1 : i32, !llvm.ptr
cf.br ^bb0
^bb0:
%2 = llvm.load %1 : !llvm.ptr -> i32
%3 = arith.constant 1 : i32
%4 = arith.cmpi sgt, %2, %3 : i32
cf.cond_br %4, ^bb1, ^bb2
^bb1:
%6 = llvm.load %1 : !llvm.ptr -> i32
%7 = arith.constant 1 : i32
%8 = arith.subi %6, %7 : i32
%9 = arith.extsi %8 : i32 to i64
%10 = llvm.getelementptr %arg0[%9] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%5 = llvm.load %10 : !llvm.ptr -> i32
%11 = arith.constant 0 : i32
%12 = arith.cmpi ne, %5, %11 : i32
cf.cond_br %12, ^bb3, ^bb4
^bb3:
cf.br ^bb2
^bb4:
cf.br ^bb5
^bb5:
%13 = llvm.load %1 : !llvm.ptr -> i32
%14 = arith.constant 1 : i32
%15 = arith.subi %13, %14 : i32
llvm.store %15, %1 : i32, !llvm.ptr
cf.br ^bb0
^bb2:
%16 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%17 = llvm.insertvalue %arg0, %16[0] : !llvm.struct<(!llvm.ptr, i32)>
%18 = llvm.load %1 : !llvm.ptr -> i32
%19 = llvm.insertvalue %18, %17[1] : !llvm.struct<(!llvm.ptr, i32)>
%20 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%21 = llvm.extractvalue %19[0] : !llvm.struct<(!llvm.ptr, i32)>
%22 = llvm.insertvalue %21, %20[0] : !llvm.struct<(!llvm.ptr, i32)>
%23 = llvm.extractvalue %19[1] : !llvm.struct<(!llvm.ptr, i32)>
%24 = llvm.insertvalue %23, %22[1] : !llvm.struct<(!llvm.ptr, i32)>
%25 = llvm.mlir.constant(1 : i64) : i64
%26 = llvm.alloca %25 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %24, %26 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%27 = llvm.load %26 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %27 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_from_i32(%arg0: i32) -> !llvm.struct<(!llvm.ptr, i32)> {
%29 = arith.constant 4 : i32
%30 = arith.extsi %29 : i32 to i64
%28 = func.call @malloc(%30) : (i64) -> !llvm.ptr
%31 = arith.constant 0 : i32
%32 = arith.extsi %31 : i32 to i64
%33 = llvm.getelementptr %28[%32] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %arg0, %33 : i32, !llvm.ptr
%34 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%35 = llvm.insertvalue %28, %34[0] : !llvm.struct<(!llvm.ptr, i32)>
%36 = arith.constant 1 : i32
%37 = llvm.insertvalue %36, %35[1] : !llvm.struct<(!llvm.ptr, i32)>
%38 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%39 = llvm.extractvalue %37[0] : !llvm.struct<(!llvm.ptr, i32)>
%40 = llvm.insertvalue %39, %38[0] : !llvm.struct<(!llvm.ptr, i32)>
%41 = llvm.extractvalue %37[1] : !llvm.struct<(!llvm.ptr, i32)>
%42 = llvm.insertvalue %41, %40[1] : !llvm.struct<(!llvm.ptr, i32)>
%43 = llvm.mlir.constant(1 : i64) : i64
%44 = llvm.alloca %43 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %42, %44 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%45 = llvm.load %44 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %45 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_is_zero(%arg0: !llvm.struct<(!llvm.ptr, i32)>) -> i32 {
%46 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%47 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%48 = llvm.insertvalue %47, %46[0] : !llvm.struct<(!llvm.ptr, i32)>
%49 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%50 = llvm.insertvalue %49, %48[1] : !llvm.struct<(!llvm.ptr, i32)>
%51 = llvm.mlir.constant(1 : i64) : i64
%52 = llvm.alloca %51 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %50, %52 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%53 = llvm.load %52 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%54 = llvm.getelementptr %52[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%55 = llvm.load %54 : !llvm.ptr -> i32
%56 = arith.constant 1 : i32
%57 = arith.cmpi eq, %55, %56 : i32
cf.cond_br %57, ^bb6, ^bb7
^bb6:
%59 = llvm.load %52 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%60 = llvm.getelementptr %52[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%61 = llvm.load %60 : !llvm.ptr -> !llvm.ptr
%62 = arith.constant 0 : i32
%63 = arith.extsi %62 : i32 to i64
%64 = llvm.getelementptr %61[%63] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%58 = llvm.load %64 : !llvm.ptr -> i32
%65 = arith.constant 0 : i32
%66 = arith.cmpi eq, %58, %65 : i32
cf.cond_br %66, ^bb9, ^bb10
^bb9:
%67 = arith.constant 1 : i32
func.return %67 : i32
^bb10:
cf.br ^bb11
^bb11:
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%68 = arith.constant 0 : i32
func.return %68 : i32
}
func.func @big_cmp(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: !llvm.struct<(!llvm.ptr, i32)>) -> i32 {
%69 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%70 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%71 = llvm.insertvalue %70, %69[0] : !llvm.struct<(!llvm.ptr, i32)>
%72 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%73 = llvm.insertvalue %72, %71[1] : !llvm.struct<(!llvm.ptr, i32)>
%74 = llvm.mlir.constant(1 : i64) : i64
%75 = llvm.alloca %74 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %73, %75 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%76 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%77 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i32)>
%78 = llvm.insertvalue %77, %76[0] : !llvm.struct<(!llvm.ptr, i32)>
%79 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i32)>
%80 = llvm.insertvalue %79, %78[1] : !llvm.struct<(!llvm.ptr, i32)>
%81 = llvm.mlir.constant(1 : i64) : i64
%82 = llvm.alloca %81 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %80, %82 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%83 = llvm.load %75 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%84 = llvm.getelementptr %75[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%85 = llvm.load %84 : !llvm.ptr -> i32
%86 = llvm.load %82 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%87 = llvm.getelementptr %82[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%88 = llvm.load %87 : !llvm.ptr -> i32
%89 = arith.cmpi ne, %85, %88 : i32
cf.cond_br %89, ^bb12, ^bb13
^bb12:
%90 = llvm.load %75 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%91 = llvm.getelementptr %75[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%92 = llvm.load %91 : !llvm.ptr -> i32
%93 = llvm.load %82 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%94 = llvm.getelementptr %82[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%95 = llvm.load %94 : !llvm.ptr -> i32
%96 = arith.cmpi sgt, %92, %95 : i32
cf.cond_br %96, ^bb15, ^bb16
^bb15:
%97 = arith.constant 1 : i32
func.return %97 : i32
^bb16:
cf.br ^bb17
^bb17:
%98 = arith.constant 1 : i32
%100 = arith.constant 0 : i32
%99 = arith.subi %100, %98 : i32
func.return %99 : i32
^bb13:
cf.br ^bb14
^bb14:
%101 = llvm.load %75 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%102 = llvm.getelementptr %75[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%103 = llvm.load %102 : !llvm.ptr -> i32
%104 = arith.constant 1 : i32
%105 = arith.subi %103, %104 : i32
%106 = llvm.mlir.constant(1 : i64) : i64
%107 = llvm.alloca %106 x i32 : (i64) -> !llvm.ptr
llvm.store %105, %107 : i32, !llvm.ptr
cf.br ^bb18
^bb18:
%108 = llvm.load %107 : !llvm.ptr -> i32
%109 = arith.constant 0 : i32
%110 = arith.cmpi sge, %108, %109 : i32
cf.cond_br %110, ^bb19, ^bb20
^bb19:
%112 = llvm.load %75 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%113 = llvm.getelementptr %75[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%114 = llvm.load %113 : !llvm.ptr -> !llvm.ptr
%115 = llvm.load %107 : !llvm.ptr -> i32
%116 = arith.extsi %115 : i32 to i64
%117 = llvm.getelementptr %114[%116] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%111 = llvm.load %117 : !llvm.ptr -> i32
%119 = llvm.load %82 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%120 = llvm.getelementptr %82[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%121 = llvm.load %120 : !llvm.ptr -> !llvm.ptr
%122 = llvm.load %107 : !llvm.ptr -> i32
%123 = arith.extsi %122 : i32 to i64
%124 = llvm.getelementptr %121[%123] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%118 = llvm.load %124 : !llvm.ptr -> i32
%125 = arith.cmpi ne, %111, %118 : i32
cf.cond_br %125, ^bb21, ^bb22
^bb21:
%127 = llvm.load %75 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%128 = llvm.getelementptr %75[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%129 = llvm.load %128 : !llvm.ptr -> !llvm.ptr
%130 = llvm.load %107 : !llvm.ptr -> i32
%131 = arith.extsi %130 : i32 to i64
%132 = llvm.getelementptr %129[%131] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%126 = llvm.load %132 : !llvm.ptr -> i32
%134 = llvm.load %82 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%135 = llvm.getelementptr %82[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%136 = llvm.load %135 : !llvm.ptr -> !llvm.ptr
%137 = llvm.load %107 : !llvm.ptr -> i32
%138 = arith.extsi %137 : i32 to i64
%139 = llvm.getelementptr %136[%138] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%133 = llvm.load %139 : !llvm.ptr -> i32
%140 = arith.cmpi sgt, %126, %133 : i32
cf.cond_br %140, ^bb24, ^bb25
^bb24:
%141 = arith.constant 1 : i32
func.return %141 : i32
^bb25:
cf.br ^bb26
^bb26:
%142 = arith.constant 1 : i32
%144 = arith.constant 0 : i32
%143 = arith.subi %144, %142 : i32
func.return %143 : i32
^bb22:
cf.br ^bb23
^bb23:
%145 = llvm.load %107 : !llvm.ptr -> i32
%146 = arith.constant 1 : i32
%147 = arith.subi %145, %146 : i32
llvm.store %147, %107 : i32, !llvm.ptr
cf.br ^bb18
^bb20:
%148 = arith.constant 0 : i32
func.return %148 : i32
}
func.func @big_add(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)> {
%149 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%150 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%151 = llvm.insertvalue %150, %149[0] : !llvm.struct<(!llvm.ptr, i32)>
%152 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%153 = llvm.insertvalue %152, %151[1] : !llvm.struct<(!llvm.ptr, i32)>
%154 = llvm.mlir.constant(1 : i64) : i64
%155 = llvm.alloca %154 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %153, %155 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%156 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%157 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i32)>
%158 = llvm.insertvalue %157, %156[0] : !llvm.struct<(!llvm.ptr, i32)>
%159 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i32)>
%160 = llvm.insertvalue %159, %158[1] : !llvm.struct<(!llvm.ptr, i32)>
%161 = llvm.mlir.constant(1 : i64) : i64
%162 = llvm.alloca %161 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %160, %162 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%163 = llvm.load %155 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%164 = llvm.getelementptr %155[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%165 = llvm.load %164 : !llvm.ptr -> i32
%166 = llvm.mlir.constant(1 : i64) : i64
%167 = llvm.alloca %166 x i32 : (i64) -> !llvm.ptr
llvm.store %165, %167 : i32, !llvm.ptr
%168 = llvm.load %162 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%169 = llvm.getelementptr %162[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%170 = llvm.load %169 : !llvm.ptr -> i32
%171 = llvm.load %167 : !llvm.ptr -> i32
%172 = arith.cmpi sgt, %170, %171 : i32
cf.cond_br %172, ^bb27, ^bb28
^bb27:
%173 = llvm.load %162 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%174 = llvm.getelementptr %162[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%175 = llvm.load %174 : !llvm.ptr -> i32
llvm.store %175, %167 : i32, !llvm.ptr
cf.br ^bb29
^bb28:
cf.br ^bb29
^bb29:
%177 = llvm.load %167 : !llvm.ptr -> i32
%178 = arith.constant 1 : i32
%179 = arith.addi %177, %178 : i32
%180 = arith.extsi %179 : i32 to i64
%181 = arith.constant 4 : i32
%183 = arith.extsi %181 : i32 to i64
%182 = arith.muli %180, %183 : i64
%176 = func.call @malloc(%182) : (i64) -> !llvm.ptr
%184 = arith.constant 0 : i32
%185 = llvm.mlir.constant(1 : i64) : i64
%186 = llvm.alloca %185 x i32 : (i64) -> !llvm.ptr
llvm.store %184, %186 : i32, !llvm.ptr
%187 = arith.constant 0 : i32
%188 = llvm.mlir.constant(1 : i64) : i64
%189 = llvm.alloca %188 x i32 : (i64) -> !llvm.ptr
llvm.store %187, %189 : i32, !llvm.ptr
cf.br ^bb30
^bb30:
%190 = llvm.load %189 : !llvm.ptr -> i32
%191 = llvm.load %167 : !llvm.ptr -> i32
%192 = arith.cmpi slt, %190, %191 : i32
cf.cond_br %192, ^bb31, ^bb32
^bb31:
%193 = llvm.load %186 : !llvm.ptr -> i32
%194 = llvm.mlir.constant(1 : i64) : i64
%195 = llvm.alloca %194 x i32 : (i64) -> !llvm.ptr
llvm.store %193, %195 : i32, !llvm.ptr
%196 = llvm.load %189 : !llvm.ptr -> i32
%197 = llvm.load %155 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%198 = llvm.getelementptr %155[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%199 = llvm.load %198 : !llvm.ptr -> i32
%200 = arith.cmpi slt, %196, %199 : i32
cf.cond_br %200, ^bb33, ^bb34
^bb33:
%201 = llvm.load %195 : !llvm.ptr -> i32
%203 = llvm.load %155 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%204 = llvm.getelementptr %155[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%205 = llvm.load %204 : !llvm.ptr -> !llvm.ptr
%206 = llvm.load %189 : !llvm.ptr -> i32
%207 = arith.extsi %206 : i32 to i64
%208 = llvm.getelementptr %205[%207] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%202 = llvm.load %208 : !llvm.ptr -> i32
%209 = arith.addi %201, %202 : i32
llvm.store %209, %195 : i32, !llvm.ptr
cf.br ^bb35
^bb34:
cf.br ^bb35
^bb35:
%210 = llvm.load %189 : !llvm.ptr -> i32
%211 = llvm.load %162 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%212 = llvm.getelementptr %162[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%213 = llvm.load %212 : !llvm.ptr -> i32
%214 = arith.cmpi slt, %210, %213 : i32
cf.cond_br %214, ^bb36, ^bb37
^bb36:
%215 = llvm.load %195 : !llvm.ptr -> i32
%217 = llvm.load %162 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%218 = llvm.getelementptr %162[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%219 = llvm.load %218 : !llvm.ptr -> !llvm.ptr
%220 = llvm.load %189 : !llvm.ptr -> i32
%221 = arith.extsi %220 : i32 to i64
%222 = llvm.getelementptr %219[%221] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%216 = llvm.load %222 : !llvm.ptr -> i32
%223 = arith.addi %215, %216 : i32
llvm.store %223, %195 : i32, !llvm.ptr
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
%224 = llvm.load %195 : !llvm.ptr -> i32
%225 = llvm.mlir.addressof @BASE : !llvm.ptr
%226 = llvm.load %225 : !llvm.ptr -> i64
%227 = arith.trunci %226 : i64 to i32
%228 = arith.remsi %224, %227 : i32
%229 = llvm.load %189 : !llvm.ptr -> i32
%230 = arith.extsi %229 : i32 to i64
%231 = llvm.getelementptr %176[%230] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %228, %231 : i32, !llvm.ptr
%232 = llvm.load %195 : !llvm.ptr -> i32
%233 = llvm.mlir.addressof @BASE : !llvm.ptr
%234 = llvm.load %233 : !llvm.ptr -> i64
%235 = arith.trunci %234 : i64 to i32
%236 = arith.divsi %232, %235 : i32
llvm.store %236, %186 : i32, !llvm.ptr
%237 = llvm.load %189 : !llvm.ptr -> i32
%238 = arith.constant 1 : i32
%239 = arith.addi %237, %238 : i32
llvm.store %239, %189 : i32, !llvm.ptr
cf.br ^bb30
^bb32:
%240 = llvm.load %186 : !llvm.ptr -> i32
%241 = llvm.load %167 : !llvm.ptr -> i32
%242 = arith.extsi %241 : i32 to i64
%243 = llvm.getelementptr %176[%242] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %240, %243 : i32, !llvm.ptr
%245 = llvm.load %167 : !llvm.ptr -> i32
%246 = arith.constant 1 : i32
%247 = arith.addi %245, %246 : i32
%244 = func.call @big_norm(%176, %247) : (!llvm.ptr, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%248 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%249 = llvm.extractvalue %244[0] : !llvm.struct<(!llvm.ptr, i32)>
%250 = llvm.insertvalue %249, %248[0] : !llvm.struct<(!llvm.ptr, i32)>
%251 = llvm.extractvalue %244[1] : !llvm.struct<(!llvm.ptr, i32)>
%252 = llvm.insertvalue %251, %250[1] : !llvm.struct<(!llvm.ptr, i32)>
%253 = llvm.mlir.constant(1 : i64) : i64
%254 = llvm.alloca %253 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %252, %254 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%255 = llvm.load %254 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%256 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%257 = llvm.extractvalue %255[0] : !llvm.struct<(!llvm.ptr, i32)>
%258 = llvm.insertvalue %257, %256[0] : !llvm.struct<(!llvm.ptr, i32)>
%259 = llvm.extractvalue %255[1] : !llvm.struct<(!llvm.ptr, i32)>
%260 = llvm.insertvalue %259, %258[1] : !llvm.struct<(!llvm.ptr, i32)>
%261 = llvm.mlir.constant(1 : i64) : i64
%262 = llvm.alloca %261 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %260, %262 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%263 = llvm.load %262 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %263 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_sub(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)> {
%264 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%265 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%266 = llvm.insertvalue %265, %264[0] : !llvm.struct<(!llvm.ptr, i32)>
%267 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%268 = llvm.insertvalue %267, %266[1] : !llvm.struct<(!llvm.ptr, i32)>
%269 = llvm.mlir.constant(1 : i64) : i64
%270 = llvm.alloca %269 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %268, %270 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%271 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%272 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i32)>
%273 = llvm.insertvalue %272, %271[0] : !llvm.struct<(!llvm.ptr, i32)>
%274 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i32)>
%275 = llvm.insertvalue %274, %273[1] : !llvm.struct<(!llvm.ptr, i32)>
%276 = llvm.mlir.constant(1 : i64) : i64
%277 = llvm.alloca %276 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %275, %277 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%279 = llvm.load %270 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%280 = llvm.getelementptr %270[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%281 = llvm.load %280 : !llvm.ptr -> i32
%282 = arith.extsi %281 : i32 to i64
%283 = arith.constant 4 : i32
%285 = arith.extsi %283 : i32 to i64
%284 = arith.muli %282, %285 : i64
%278 = func.call @malloc(%284) : (i64) -> !llvm.ptr
%286 = arith.constant 0 : i32
%287 = llvm.mlir.constant(1 : i64) : i64
%288 = llvm.alloca %287 x i32 : (i64) -> !llvm.ptr
llvm.store %286, %288 : i32, !llvm.ptr
%289 = arith.constant 0 : i32
%290 = llvm.mlir.constant(1 : i64) : i64
%291 = llvm.alloca %290 x i32 : (i64) -> !llvm.ptr
llvm.store %289, %291 : i32, !llvm.ptr
cf.br ^bb39
^bb39:
%292 = llvm.load %291 : !llvm.ptr -> i32
%293 = llvm.load %270 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%294 = llvm.getelementptr %270[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%295 = llvm.load %294 : !llvm.ptr -> i32
%296 = arith.cmpi slt, %292, %295 : i32
cf.cond_br %296, ^bb40, ^bb41
^bb40:
%298 = llvm.load %270 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%299 = llvm.getelementptr %270[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%300 = llvm.load %299 : !llvm.ptr -> !llvm.ptr
%301 = llvm.load %291 : !llvm.ptr -> i32
%302 = arith.extsi %301 : i32 to i64
%303 = llvm.getelementptr %300[%302] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%297 = llvm.load %303 : !llvm.ptr -> i32
%304 = llvm.load %288 : !llvm.ptr -> i32
%305 = arith.subi %297, %304 : i32
%306 = llvm.mlir.constant(1 : i64) : i64
%307 = llvm.alloca %306 x i32 : (i64) -> !llvm.ptr
llvm.store %305, %307 : i32, !llvm.ptr
%308 = llvm.load %291 : !llvm.ptr -> i32
%309 = llvm.load %277 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%310 = llvm.getelementptr %277[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%311 = llvm.load %310 : !llvm.ptr -> i32
%312 = arith.cmpi slt, %308, %311 : i32
cf.cond_br %312, ^bb42, ^bb43
^bb42:
%313 = llvm.load %307 : !llvm.ptr -> i32
%315 = llvm.load %277 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%316 = llvm.getelementptr %277[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%317 = llvm.load %316 : !llvm.ptr -> !llvm.ptr
%318 = llvm.load %291 : !llvm.ptr -> i32
%319 = arith.extsi %318 : i32 to i64
%320 = llvm.getelementptr %317[%319] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%314 = llvm.load %320 : !llvm.ptr -> i32
%321 = arith.subi %313, %314 : i32
llvm.store %321, %307 : i32, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%322 = llvm.load %307 : !llvm.ptr -> i32
%323 = arith.constant 0 : i32
%324 = arith.cmpi slt, %322, %323 : i32
cf.cond_br %324, ^bb45, ^bb46
^bb45:
%325 = llvm.load %307 : !llvm.ptr -> i32
%326 = llvm.mlir.addressof @BASE : !llvm.ptr
%327 = llvm.load %326 : !llvm.ptr -> i64
%328 = arith.trunci %327 : i64 to i32
%329 = arith.addi %325, %328 : i32
llvm.store %329, %307 : i32, !llvm.ptr
%330 = arith.constant 1 : i32
llvm.store %330, %288 : i32, !llvm.ptr
cf.br ^bb47
^bb46:
%331 = arith.constant 0 : i32
llvm.store %331, %288 : i32, !llvm.ptr
cf.br ^bb47
^bb47:
%332 = llvm.load %307 : !llvm.ptr -> i32
%333 = llvm.load %291 : !llvm.ptr -> i32
%334 = arith.extsi %333 : i32 to i64
%335 = llvm.getelementptr %278[%334] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %332, %335 : i32, !llvm.ptr
%336 = llvm.load %291 : !llvm.ptr -> i32
%337 = arith.constant 1 : i32
%338 = arith.addi %336, %337 : i32
llvm.store %338, %291 : i32, !llvm.ptr
cf.br ^bb39
^bb41:
%340 = llvm.load %270 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%341 = llvm.getelementptr %270[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%342 = llvm.load %341 : !llvm.ptr -> i32
%339 = func.call @big_norm(%278, %342) : (!llvm.ptr, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%343 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%344 = llvm.extractvalue %339[0] : !llvm.struct<(!llvm.ptr, i32)>
%345 = llvm.insertvalue %344, %343[0] : !llvm.struct<(!llvm.ptr, i32)>
%346 = llvm.extractvalue %339[1] : !llvm.struct<(!llvm.ptr, i32)>
%347 = llvm.insertvalue %346, %345[1] : !llvm.struct<(!llvm.ptr, i32)>
%348 = llvm.mlir.constant(1 : i64) : i64
%349 = llvm.alloca %348 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %347, %349 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%350 = llvm.load %349 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%351 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%352 = llvm.extractvalue %350[0] : !llvm.struct<(!llvm.ptr, i32)>
%353 = llvm.insertvalue %352, %351[0] : !llvm.struct<(!llvm.ptr, i32)>
%354 = llvm.extractvalue %350[1] : !llvm.struct<(!llvm.ptr, i32)>
%355 = llvm.insertvalue %354, %353[1] : !llvm.struct<(!llvm.ptr, i32)>
%356 = llvm.mlir.constant(1 : i64) : i64
%357 = llvm.alloca %356 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %355, %357 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%358 = llvm.load %357 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %358 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_mul_small(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: i32) -> !llvm.struct<(!llvm.ptr, i32)> {
%359 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%360 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%361 = llvm.insertvalue %360, %359[0] : !llvm.struct<(!llvm.ptr, i32)>
%362 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%363 = llvm.insertvalue %362, %361[1] : !llvm.struct<(!llvm.ptr, i32)>
%364 = llvm.mlir.constant(1 : i64) : i64
%365 = llvm.alloca %364 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %363, %365 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%367 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%368 = llvm.getelementptr %365[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%369 = llvm.load %368 : !llvm.ptr -> i32
%370 = arith.constant 1 : i32
%371 = arith.addi %369, %370 : i32
%372 = arith.extsi %371 : i32 to i64
%373 = arith.constant 4 : i32
%375 = arith.extsi %373 : i32 to i64
%374 = arith.muli %372, %375 : i64
%366 = func.call @malloc(%374) : (i64) -> !llvm.ptr
%376 = arith.constant 0 : i32
%377 = arith.extsi %376 : i32 to i64
%378 = llvm.mlir.constant(1 : i64) : i64
%379 = llvm.alloca %378 x i64 : (i64) -> !llvm.ptr
llvm.store %377, %379 : i64, !llvm.ptr
%380 = arith.constant 0 : i32
%381 = llvm.mlir.constant(1 : i64) : i64
%382 = llvm.alloca %381 x i32 : (i64) -> !llvm.ptr
llvm.store %380, %382 : i32, !llvm.ptr
cf.br ^bb48
^bb48:
%383 = llvm.load %382 : !llvm.ptr -> i32
%384 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%385 = llvm.getelementptr %365[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%386 = llvm.load %385 : !llvm.ptr -> i32
%387 = arith.cmpi slt, %383, %386 : i32
cf.cond_br %387, ^bb49, ^bb50
^bb49:
%389 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%390 = llvm.getelementptr %365[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%391 = llvm.load %390 : !llvm.ptr -> !llvm.ptr
%392 = llvm.load %382 : !llvm.ptr -> i32
%393 = arith.extsi %392 : i32 to i64
%394 = llvm.getelementptr %391[%393] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%388 = llvm.load %394 : !llvm.ptr -> i32
%395 = arith.extsi %388 : i32 to i64
%396 = arith.extsi %arg1 : i32 to i64
%397 = arith.muli %395, %396 : i64
%398 = llvm.load %379 : !llvm.ptr -> i64
%399 = arith.addi %397, %398 : i64
%400 = llvm.mlir.addressof @BASE : !llvm.ptr
%401 = llvm.load %400 : !llvm.ptr -> i64
%402 = arith.remsi %399, %401 : i64
%403 = arith.trunci %402 : i64 to i32
%404 = llvm.load %382 : !llvm.ptr -> i32
%405 = arith.extsi %404 : i32 to i64
%406 = llvm.getelementptr %366[%405] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %403, %406 : i32, !llvm.ptr
%407 = llvm.mlir.addressof @BASE : !llvm.ptr
%408 = llvm.load %407 : !llvm.ptr -> i64
%409 = arith.divsi %399, %408 : i64
llvm.store %409, %379 : i64, !llvm.ptr
%410 = llvm.load %382 : !llvm.ptr -> i32
%411 = arith.constant 1 : i32
%412 = arith.addi %410, %411 : i32
llvm.store %412, %382 : i32, !llvm.ptr
cf.br ^bb48
^bb50:
%413 = llvm.load %379 : !llvm.ptr -> i64
%414 = arith.trunci %413 : i64 to i32
%415 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%416 = llvm.getelementptr %365[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%417 = llvm.load %416 : !llvm.ptr -> i32
%418 = arith.extsi %417 : i32 to i64
%419 = llvm.getelementptr %366[%418] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %414, %419 : i32, !llvm.ptr
%421 = llvm.load %365 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%422 = llvm.getelementptr %365[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%423 = llvm.load %422 : !llvm.ptr -> i32
%424 = arith.constant 1 : i32
%425 = arith.addi %423, %424 : i32
%420 = func.call @big_norm(%366, %425) : (!llvm.ptr, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%426 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%427 = llvm.extractvalue %420[0] : !llvm.struct<(!llvm.ptr, i32)>
%428 = llvm.insertvalue %427, %426[0] : !llvm.struct<(!llvm.ptr, i32)>
%429 = llvm.extractvalue %420[1] : !llvm.struct<(!llvm.ptr, i32)>
%430 = llvm.insertvalue %429, %428[1] : !llvm.struct<(!llvm.ptr, i32)>
%431 = llvm.mlir.constant(1 : i64) : i64
%432 = llvm.alloca %431 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %430, %432 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%433 = llvm.load %432 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%434 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%435 = llvm.extractvalue %433[0] : !llvm.struct<(!llvm.ptr, i32)>
%436 = llvm.insertvalue %435, %434[0] : !llvm.struct<(!llvm.ptr, i32)>
%437 = llvm.extractvalue %433[1] : !llvm.struct<(!llvm.ptr, i32)>
%438 = llvm.insertvalue %437, %436[1] : !llvm.struct<(!llvm.ptr, i32)>
%439 = llvm.mlir.constant(1 : i64) : i64
%440 = llvm.alloca %439 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %438, %440 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%441 = llvm.load %440 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %441 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_mul(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)> {
%442 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%443 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%444 = llvm.insertvalue %443, %442[0] : !llvm.struct<(!llvm.ptr, i32)>
%445 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%446 = llvm.insertvalue %445, %444[1] : !llvm.struct<(!llvm.ptr, i32)>
%447 = llvm.mlir.constant(1 : i64) : i64
%448 = llvm.alloca %447 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %446, %448 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%449 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%450 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i32)>
%451 = llvm.insertvalue %450, %449[0] : !llvm.struct<(!llvm.ptr, i32)>
%452 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i32)>
%453 = llvm.insertvalue %452, %451[1] : !llvm.struct<(!llvm.ptr, i32)>
%454 = llvm.mlir.constant(1 : i64) : i64
%455 = llvm.alloca %454 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %453, %455 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%456 = llvm.load %448 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%457 = llvm.getelementptr %448[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%458 = llvm.load %457 : !llvm.ptr -> i32
%459 = llvm.load %455 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%460 = llvm.getelementptr %455[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%461 = llvm.load %460 : !llvm.ptr -> i32
%462 = arith.addi %458, %461 : i32
%464 = arith.extsi %462 : i32 to i64
%465 = arith.constant 8 : i32
%466 = arith.extsi %465 : i32 to i64
%463 = func.call @calloc(%464, %466) : (i64, i64) -> !llvm.ptr
%467 = arith.constant 0 : i32
%468 = llvm.mlir.constant(1 : i64) : i64
%469 = llvm.alloca %468 x i32 : (i64) -> !llvm.ptr
llvm.store %467, %469 : i32, !llvm.ptr
cf.br ^bb51
^bb51:
%470 = llvm.load %469 : !llvm.ptr -> i32
%471 = llvm.load %448 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%472 = llvm.getelementptr %448[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%473 = llvm.load %472 : !llvm.ptr -> i32
%474 = arith.cmpi slt, %470, %473 : i32
cf.cond_br %474, ^bb52, ^bb53
^bb52:
%475 = arith.constant 0 : i32
%476 = llvm.mlir.constant(1 : i64) : i64
%477 = llvm.alloca %476 x i32 : (i64) -> !llvm.ptr
llvm.store %475, %477 : i32, !llvm.ptr
cf.br ^bb54
^bb54:
%478 = llvm.load %477 : !llvm.ptr -> i32
%479 = llvm.load %455 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%480 = llvm.getelementptr %455[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%481 = llvm.load %480 : !llvm.ptr -> i32
%482 = arith.cmpi slt, %478, %481 : i32
cf.cond_br %482, ^bb55, ^bb56
^bb55:
%484 = llvm.load %469 : !llvm.ptr -> i32
%485 = llvm.load %477 : !llvm.ptr -> i32
%486 = arith.addi %484, %485 : i32
%487 = arith.extsi %486 : i32 to i64
%488 = llvm.getelementptr %463[%487] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%483 = llvm.load %488 : !llvm.ptr -> i64
%490 = llvm.load %448 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%491 = llvm.getelementptr %448[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%492 = llvm.load %491 : !llvm.ptr -> !llvm.ptr
%493 = llvm.load %469 : !llvm.ptr -> i32
%494 = arith.extsi %493 : i32 to i64
%495 = llvm.getelementptr %492[%494] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%489 = llvm.load %495 : !llvm.ptr -> i32
%496 = arith.extsi %489 : i32 to i64
%498 = llvm.load %455 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%499 = llvm.getelementptr %455[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%500 = llvm.load %499 : !llvm.ptr -> !llvm.ptr
%501 = llvm.load %477 : !llvm.ptr -> i32
%502 = arith.extsi %501 : i32 to i64
%503 = llvm.getelementptr %500[%502] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%497 = llvm.load %503 : !llvm.ptr -> i32
%504 = arith.extsi %497 : i32 to i64
%505 = arith.muli %496, %504 : i64
%506 = arith.addi %483, %505 : i64
%507 = llvm.load %469 : !llvm.ptr -> i32
%508 = llvm.load %477 : !llvm.ptr -> i32
%509 = arith.addi %507, %508 : i32
%510 = arith.extsi %509 : i32 to i64
%511 = llvm.getelementptr %463[%510] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %506, %511 : i64, !llvm.ptr
%512 = llvm.load %477 : !llvm.ptr -> i32
%513 = arith.constant 1 : i32
%514 = arith.addi %512, %513 : i32
llvm.store %514, %477 : i32, !llvm.ptr
cf.br ^bb54
^bb56:
%515 = llvm.load %469 : !llvm.ptr -> i32
%516 = arith.constant 1 : i32
%517 = arith.addi %515, %516 : i32
llvm.store %517, %469 : i32, !llvm.ptr
cf.br ^bb51
^bb53:
%519 = arith.extsi %462 : i32 to i64
%520 = arith.constant 4 : i32
%522 = arith.extsi %520 : i32 to i64
%521 = arith.muli %519, %522 : i64
%518 = func.call @malloc(%521) : (i64) -> !llvm.ptr
%523 = arith.constant 0 : i32
%524 = arith.extsi %523 : i32 to i64
%525 = llvm.mlir.constant(1 : i64) : i64
%526 = llvm.alloca %525 x i64 : (i64) -> !llvm.ptr
llvm.store %524, %526 : i64, !llvm.ptr
%527 = arith.constant 0 : i32
%528 = llvm.mlir.constant(1 : i64) : i64
%529 = llvm.alloca %528 x i32 : (i64) -> !llvm.ptr
llvm.store %527, %529 : i32, !llvm.ptr
cf.br ^bb57
^bb57:
%530 = llvm.load %529 : !llvm.ptr -> i32
%531 = arith.cmpi slt, %530, %462 : i32
cf.cond_br %531, ^bb58, ^bb59
^bb58:
%533 = llvm.load %529 : !llvm.ptr -> i32
%534 = arith.extsi %533 : i32 to i64
%535 = llvm.getelementptr %463[%534] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%532 = llvm.load %535 : !llvm.ptr -> i64
%536 = llvm.load %526 : !llvm.ptr -> i64
%537 = arith.addi %532, %536 : i64
%538 = llvm.mlir.addressof @BASE : !llvm.ptr
%539 = llvm.load %538 : !llvm.ptr -> i64
%540 = arith.remsi %537, %539 : i64
%541 = arith.trunci %540 : i64 to i32
%542 = llvm.load %529 : !llvm.ptr -> i32
%543 = arith.extsi %542 : i32 to i64
%544 = llvm.getelementptr %518[%543] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %541, %544 : i32, !llvm.ptr
%545 = llvm.mlir.addressof @BASE : !llvm.ptr
%546 = llvm.load %545 : !llvm.ptr -> i64
%547 = arith.divsi %537, %546 : i64
llvm.store %547, %526 : i64, !llvm.ptr
%548 = llvm.load %529 : !llvm.ptr -> i32
%549 = arith.constant 1 : i32
%550 = arith.addi %548, %549 : i32
llvm.store %550, %529 : i32, !llvm.ptr
cf.br ^bb57
^bb59:
func.call @free(%463) : (!llvm.ptr) -> ()
%552 = func.call @big_norm(%518, %462) : (!llvm.ptr, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%553 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%554 = llvm.extractvalue %552[0] : !llvm.struct<(!llvm.ptr, i32)>
%555 = llvm.insertvalue %554, %553[0] : !llvm.struct<(!llvm.ptr, i32)>
%556 = llvm.extractvalue %552[1] : !llvm.struct<(!llvm.ptr, i32)>
%557 = llvm.insertvalue %556, %555[1] : !llvm.struct<(!llvm.ptr, i32)>
%558 = llvm.mlir.constant(1 : i64) : i64
%559 = llvm.alloca %558 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %557, %559 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%560 = llvm.load %559 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%561 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%562 = llvm.extractvalue %560[0] : !llvm.struct<(!llvm.ptr, i32)>
%563 = llvm.insertvalue %562, %561[0] : !llvm.struct<(!llvm.ptr, i32)>
%564 = llvm.extractvalue %560[1] : !llvm.struct<(!llvm.ptr, i32)>
%565 = llvm.insertvalue %564, %563[1] : !llvm.struct<(!llvm.ptr, i32)>
%566 = llvm.mlir.constant(1 : i64) : i64
%567 = llvm.alloca %566 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %565, %567 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%568 = llvm.load %567 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %568 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_div_small(%arg0: !llvm.struct<(!llvm.ptr, i32)>, %arg1: i32) -> !llvm.struct<(!llvm.ptr, i32)> {
%569 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%570 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%571 = llvm.insertvalue %570, %569[0] : !llvm.struct<(!llvm.ptr, i32)>
%572 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%573 = llvm.insertvalue %572, %571[1] : !llvm.struct<(!llvm.ptr, i32)>
%574 = llvm.mlir.constant(1 : i64) : i64
%575 = llvm.alloca %574 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %573, %575 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%577 = llvm.load %575 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%578 = llvm.getelementptr %575[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%579 = llvm.load %578 : !llvm.ptr -> i32
%580 = arith.extsi %579 : i32 to i64
%581 = arith.constant 4 : i32
%583 = arith.extsi %581 : i32 to i64
%582 = arith.muli %580, %583 : i64
%576 = func.call @malloc(%582) : (i64) -> !llvm.ptr
%584 = arith.constant 0 : i32
%585 = arith.extsi %584 : i32 to i64
%586 = llvm.mlir.constant(1 : i64) : i64
%587 = llvm.alloca %586 x i64 : (i64) -> !llvm.ptr
llvm.store %585, %587 : i64, !llvm.ptr
%588 = llvm.load %575 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%589 = llvm.getelementptr %575[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%590 = llvm.load %589 : !llvm.ptr -> i32
%591 = arith.constant 1 : i32
%592 = arith.subi %590, %591 : i32
%593 = llvm.mlir.constant(1 : i64) : i64
%594 = llvm.alloca %593 x i32 : (i64) -> !llvm.ptr
llvm.store %592, %594 : i32, !llvm.ptr
cf.br ^bb60
^bb60:
%595 = llvm.load %594 : !llvm.ptr -> i32
%596 = arith.constant 0 : i32
%597 = arith.cmpi sge, %595, %596 : i32
cf.cond_br %597, ^bb61, ^bb62
^bb61:
%598 = llvm.load %587 : !llvm.ptr -> i64
%599 = llvm.mlir.addressof @BASE : !llvm.ptr
%600 = llvm.load %599 : !llvm.ptr -> i64
%601 = arith.muli %598, %600 : i64
%603 = llvm.load %575 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%604 = llvm.getelementptr %575[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%605 = llvm.load %604 : !llvm.ptr -> !llvm.ptr
%606 = llvm.load %594 : !llvm.ptr -> i32
%607 = arith.extsi %606 : i32 to i64
%608 = llvm.getelementptr %605[%607] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%602 = llvm.load %608 : !llvm.ptr -> i32
%609 = arith.extsi %602 : i32 to i64
%610 = arith.addi %601, %609 : i64
%611 = arith.extsi %arg1 : i32 to i64
%612 = arith.divsi %610, %611 : i64
%613 = arith.trunci %612 : i64 to i32
%614 = llvm.load %594 : !llvm.ptr -> i32
%615 = arith.extsi %614 : i32 to i64
%616 = llvm.getelementptr %576[%615] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %613, %616 : i32, !llvm.ptr
%617 = arith.extsi %arg1 : i32 to i64
%618 = arith.remsi %610, %617 : i64
llvm.store %618, %587 : i64, !llvm.ptr
%619 = llvm.load %594 : !llvm.ptr -> i32
%620 = arith.constant 1 : i32
%621 = arith.subi %619, %620 : i32
llvm.store %621, %594 : i32, !llvm.ptr
cf.br ^bb60
^bb62:
%623 = llvm.load %575 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%624 = llvm.getelementptr %575[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%625 = llvm.load %624 : !llvm.ptr -> i32
%622 = func.call @big_norm(%576, %625) : (!llvm.ptr, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%626 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%627 = llvm.extractvalue %622[0] : !llvm.struct<(!llvm.ptr, i32)>
%628 = llvm.insertvalue %627, %626[0] : !llvm.struct<(!llvm.ptr, i32)>
%629 = llvm.extractvalue %622[1] : !llvm.struct<(!llvm.ptr, i32)>
%630 = llvm.insertvalue %629, %628[1] : !llvm.struct<(!llvm.ptr, i32)>
%631 = llvm.mlir.constant(1 : i64) : i64
%632 = llvm.alloca %631 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %630, %632 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%633 = llvm.load %632 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%634 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%635 = llvm.extractvalue %633[0] : !llvm.struct<(!llvm.ptr, i32)>
%636 = llvm.insertvalue %635, %634[0] : !llvm.struct<(!llvm.ptr, i32)>
%637 = llvm.extractvalue %633[1] : !llvm.struct<(!llvm.ptr, i32)>
%638 = llvm.insertvalue %637, %636[1] : !llvm.struct<(!llvm.ptr, i32)>
%639 = llvm.mlir.constant(1 : i64) : i64
%640 = llvm.alloca %639 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %638, %640 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%641 = llvm.load %640 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
func.return %641 : !llvm.struct<(!llvm.ptr, i32)>
}
func.func @big_to_double(%arg0: !llvm.struct<(!llvm.ptr, i32)>) -> f64 {
%642 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%643 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i32)>
%644 = llvm.insertvalue %643, %642[0] : !llvm.struct<(!llvm.ptr, i32)>
%645 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i32)>
%646 = llvm.insertvalue %645, %644[1] : !llvm.struct<(!llvm.ptr, i32)>
%647 = llvm.mlir.constant(1 : i64) : i64
%648 = llvm.alloca %647 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %646, %648 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%649 = arith.constant 0.0 : f32
%650 = arith.extf %649 : f32 to f64
%651 = llvm.mlir.constant(1 : i64) : i64
%652 = llvm.alloca %651 x f64 : (i64) -> !llvm.ptr
llvm.store %650, %652 : f64, !llvm.ptr
%653 = llvm.load %648 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%654 = llvm.getelementptr %648[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%655 = llvm.load %654 : !llvm.ptr -> i32
%656 = arith.constant 1 : i32
%657 = arith.subi %655, %656 : i32
%658 = llvm.mlir.constant(1 : i64) : i64
%659 = llvm.alloca %658 x i32 : (i64) -> !llvm.ptr
llvm.store %657, %659 : i32, !llvm.ptr
cf.br ^bb63
^bb63:
%660 = llvm.load %659 : !llvm.ptr -> i32
%661 = arith.constant 0 : i32
%662 = arith.cmpi sge, %660, %661 : i32
cf.cond_br %662, ^bb64, ^bb65
^bb64:
%663 = llvm.load %652 : !llvm.ptr -> f64
%664 = llvm.mlir.addressof @BASE : !llvm.ptr
%665 = llvm.load %664 : !llvm.ptr -> i64
%666 = arith.sitofp %665 : i64 to f64
%667 = arith.mulf %663, %666 : f64
%669 = llvm.load %648 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%670 = llvm.getelementptr %648[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%671 = llvm.load %670 : !llvm.ptr -> !llvm.ptr
%672 = llvm.load %659 : !llvm.ptr -> i32
%673 = arith.extsi %672 : i32 to i64
%674 = llvm.getelementptr %671[%673] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%668 = llvm.load %674 : !llvm.ptr -> i32
%675 = arith.sitofp %668 : i32 to f64
%676 = arith.addf %667, %675 : f64
llvm.store %676, %652 : f64, !llvm.ptr
%677 = llvm.load %659 : !llvm.ptr -> i32
%678 = arith.constant 1 : i32
%679 = arith.subi %677, %678 : i32
llvm.store %679, %659 : i32, !llvm.ptr
cf.br ^bb63
^bb65:
%680 = llvm.load %652 : !llvm.ptr -> f64
func.return %680 : f64
}
func.func @main() -> i32 {
%681 = arith.constant 1000 : i32
%683 = arith.constant 1 : i32
%682 = func.call @big_from_i32(%683) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%684 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%685 = llvm.extractvalue %682[0] : !llvm.struct<(!llvm.ptr, i32)>
%686 = llvm.insertvalue %685, %684[0] : !llvm.struct<(!llvm.ptr, i32)>
%687 = llvm.extractvalue %682[1] : !llvm.struct<(!llvm.ptr, i32)>
%688 = llvm.insertvalue %687, %686[1] : !llvm.struct<(!llvm.ptr, i32)>
%689 = llvm.mlir.constant(1 : i64) : i64
%690 = llvm.alloca %689 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %688, %690 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%691 = llvm.load %690 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%692 = llvm.mlir.constant(1 : i64) : i64
%693 = llvm.alloca %692 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %691, %693 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%694 = arith.constant 0 : i32
%695 = llvm.mlir.constant(1 : i64) : i64
%696 = llvm.alloca %695 x i32 : (i64) -> !llvm.ptr
llvm.store %694, %696 : i32, !llvm.ptr
cf.br ^bb66
^bb66:
%697 = llvm.load %696 : !llvm.ptr -> i32
%698 = arith.cmpi slt, %697, %681 : i32
cf.cond_br %698, ^bb67, ^bb68
^bb67:
%700 = arith.constant 2 : i32
%701 = llvm.load %693 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%702 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%703 = llvm.extractvalue %701[0] : !llvm.struct<(!llvm.ptr, i32)>
%704 = llvm.insertvalue %703, %702[0] : !llvm.struct<(!llvm.ptr, i32)>
%705 = llvm.extractvalue %701[1] : !llvm.struct<(!llvm.ptr, i32)>
%706 = llvm.insertvalue %705, %704[1] : !llvm.struct<(!llvm.ptr, i32)>
%699 = func.call @big_mul_small(%706, %700) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%707 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%708 = llvm.extractvalue %699[0] : !llvm.struct<(!llvm.ptr, i32)>
%709 = llvm.insertvalue %708, %707[0] : !llvm.struct<(!llvm.ptr, i32)>
%710 = llvm.extractvalue %699[1] : !llvm.struct<(!llvm.ptr, i32)>
%711 = llvm.insertvalue %710, %709[1] : !llvm.struct<(!llvm.ptr, i32)>
%712 = llvm.mlir.constant(1 : i64) : i64
%713 = llvm.alloca %712 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %711, %713 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%714 = llvm.load %713 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%715 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%716 = llvm.extractvalue %706[0] : !llvm.struct<(!llvm.ptr, i32)>
%717 = llvm.insertvalue %716, %715[0] : !llvm.struct<(!llvm.ptr, i32)>
%718 = llvm.extractvalue %706[1] : !llvm.struct<(!llvm.ptr, i32)>
%719 = llvm.insertvalue %718, %717[1] : !llvm.struct<(!llvm.ptr, i32)>
%720 = llvm.mlir.constant(1 : i64) : i64
%721 = llvm.alloca %720 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %719, %721 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%722 = llvm.load %721 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %722, %693 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %714, %693 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%723 = llvm.load %696 : !llvm.ptr -> i32
%724 = arith.constant 1 : i32
%725 = arith.addi %723, %724 : i32
llvm.store %725, %696 : i32, !llvm.ptr
cf.br ^bb66
^bb68:
%726 = llvm.load %693 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%727 = llvm.mlir.constant(1 : i64) : i64
%728 = llvm.alloca %727 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %726, %728 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%729 = arith.constant 0 : i32
%730 = llvm.mlir.constant(1 : i64) : i64
%731 = llvm.alloca %730 x i32 : (i64) -> !llvm.ptr
llvm.store %729, %731 : i32, !llvm.ptr
cf.br ^bb69
^bb69:
%732 = llvm.load %731 : !llvm.ptr -> i32
%733 = arith.constant 12 : i32
%734 = arith.cmpi slt, %732, %733 : i32
cf.cond_br %734, ^bb70, ^bb71
^bb70:
%736 = arith.constant 10 : i32
%737 = llvm.load %728 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%738 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%739 = llvm.extractvalue %737[0] : !llvm.struct<(!llvm.ptr, i32)>
%740 = llvm.insertvalue %739, %738[0] : !llvm.struct<(!llvm.ptr, i32)>
%741 = llvm.extractvalue %737[1] : !llvm.struct<(!llvm.ptr, i32)>
%742 = llvm.insertvalue %741, %740[1] : !llvm.struct<(!llvm.ptr, i32)>
%735 = func.call @big_div_small(%742, %736) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%743 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%744 = llvm.extractvalue %735[0] : !llvm.struct<(!llvm.ptr, i32)>
%745 = llvm.insertvalue %744, %743[0] : !llvm.struct<(!llvm.ptr, i32)>
%746 = llvm.extractvalue %735[1] : !llvm.struct<(!llvm.ptr, i32)>
%747 = llvm.insertvalue %746, %745[1] : !llvm.struct<(!llvm.ptr, i32)>
%748 = llvm.mlir.constant(1 : i64) : i64
%749 = llvm.alloca %748 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %747, %749 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%750 = llvm.load %749 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%751 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%752 = llvm.extractvalue %742[0] : !llvm.struct<(!llvm.ptr, i32)>
%753 = llvm.insertvalue %752, %751[0] : !llvm.struct<(!llvm.ptr, i32)>
%754 = llvm.extractvalue %742[1] : !llvm.struct<(!llvm.ptr, i32)>
%755 = llvm.insertvalue %754, %753[1] : !llvm.struct<(!llvm.ptr, i32)>
%756 = llvm.mlir.constant(1 : i64) : i64
%757 = llvm.alloca %756 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %755, %757 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%758 = llvm.load %757 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %758, %728 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %750, %728 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%759 = llvm.load %731 : !llvm.ptr -> i32
%760 = arith.constant 1 : i32
%761 = arith.addi %759, %760 : i32
llvm.store %761, %731 : i32, !llvm.ptr
cf.br ^bb69
^bb71:
%763 = arith.constant 1 : i32
%764 = arith.addi %681, %763 : i32
%765 = arith.extsi %764 : i32 to i64
%766 = arith.constant 16 : i32
%768 = arith.extsi %766 : i32 to i64
%767 = arith.muli %765, %768 : i64
%762 = func.call @malloc(%767) : (i64) -> !llvm.ptr
%770 = arith.constant 1 : i32
%769 = func.call @big_from_i32(%770) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%771 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%772 = llvm.extractvalue %769[0] : !llvm.struct<(!llvm.ptr, i32)>
%773 = llvm.insertvalue %772, %771[0] : !llvm.struct<(!llvm.ptr, i32)>
%774 = llvm.extractvalue %769[1] : !llvm.struct<(!llvm.ptr, i32)>
%775 = llvm.insertvalue %774, %773[1] : !llvm.struct<(!llvm.ptr, i32)>
%776 = llvm.mlir.constant(1 : i64) : i64
%777 = llvm.alloca %776 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %775, %777 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%778 = llvm.load %777 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%779 = arith.constant 0 : i32
%780 = arith.extsi %779 : i32 to i64
%781 = llvm.getelementptr %762[%780] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %778, %781 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%782 = arith.constant 1 : i32
%783 = llvm.mlir.constant(1 : i64) : i64
%784 = llvm.alloca %783 x i32 : (i64) -> !llvm.ptr
llvm.store %782, %784 : i32, !llvm.ptr
cf.br ^bb72
^bb72:
%785 = llvm.load %784 : !llvm.ptr -> i32
%786 = arith.cmpi sle, %785, %681 : i32
cf.cond_br %786, ^bb73, ^bb74
^bb73:
%788 = llvm.load %784 : !llvm.ptr -> i32
%789 = arith.subi %681, %788 : i32
%790 = arith.constant 1 : i32
%791 = arith.addi %789, %790 : i32
%793 = llvm.load %784 : !llvm.ptr -> i32
%794 = arith.constant 1 : i32
%795 = arith.subi %793, %794 : i32
%796 = arith.extsi %795 : i32 to i64
%797 = llvm.getelementptr %762[%796] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%792 = llvm.load %797 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%798 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%799 = llvm.extractvalue %792[0] : !llvm.struct<(!llvm.ptr, i32)>
%800 = llvm.insertvalue %799, %798[0] : !llvm.struct<(!llvm.ptr, i32)>
%801 = llvm.extractvalue %792[1] : !llvm.struct<(!llvm.ptr, i32)>
%802 = llvm.insertvalue %801, %800[1] : !llvm.struct<(!llvm.ptr, i32)>
%787 = func.call @big_mul_small(%802, %791) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%803 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%804 = llvm.extractvalue %787[0] : !llvm.struct<(!llvm.ptr, i32)>
%805 = llvm.insertvalue %804, %803[0] : !llvm.struct<(!llvm.ptr, i32)>
%806 = llvm.extractvalue %787[1] : !llvm.struct<(!llvm.ptr, i32)>
%807 = llvm.insertvalue %806, %805[1] : !llvm.struct<(!llvm.ptr, i32)>
%808 = llvm.mlir.constant(1 : i64) : i64
%809 = llvm.alloca %808 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %807, %809 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%810 = llvm.load %809 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%811 = llvm.mlir.constant(1 : i64) : i64
%812 = llvm.alloca %811 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %810, %812 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%814 = llvm.load %784 : !llvm.ptr -> i32
%815 = llvm.load %812 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%816 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%817 = llvm.extractvalue %815[0] : !llvm.struct<(!llvm.ptr, i32)>
%818 = llvm.insertvalue %817, %816[0] : !llvm.struct<(!llvm.ptr, i32)>
%819 = llvm.extractvalue %815[1] : !llvm.struct<(!llvm.ptr, i32)>
%820 = llvm.insertvalue %819, %818[1] : !llvm.struct<(!llvm.ptr, i32)>
%813 = func.call @big_div_small(%820, %814) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%821 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%822 = llvm.extractvalue %813[0] : !llvm.struct<(!llvm.ptr, i32)>
%823 = llvm.insertvalue %822, %821[0] : !llvm.struct<(!llvm.ptr, i32)>
%824 = llvm.extractvalue %813[1] : !llvm.struct<(!llvm.ptr, i32)>
%825 = llvm.insertvalue %824, %823[1] : !llvm.struct<(!llvm.ptr, i32)>
%826 = llvm.mlir.constant(1 : i64) : i64
%827 = llvm.alloca %826 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %825, %827 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%828 = llvm.load %827 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%829 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%830 = llvm.extractvalue %820[0] : !llvm.struct<(!llvm.ptr, i32)>
%831 = llvm.insertvalue %830, %829[0] : !llvm.struct<(!llvm.ptr, i32)>
%832 = llvm.extractvalue %820[1] : !llvm.struct<(!llvm.ptr, i32)>
%833 = llvm.insertvalue %832, %831[1] : !llvm.struct<(!llvm.ptr, i32)>
%834 = llvm.mlir.constant(1 : i64) : i64
%835 = llvm.alloca %834 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %833, %835 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%836 = llvm.load %835 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %836, %812 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%837 = llvm.load %784 : !llvm.ptr -> i32
%838 = arith.extsi %837 : i32 to i64
%839 = llvm.getelementptr %762[%838] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %828, %839 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%840 = llvm.load %784 : !llvm.ptr -> i32
%841 = arith.constant 1 : i32
%842 = arith.addi %840, %841 : i32
llvm.store %842, %784 : i32, !llvm.ptr
cf.br ^bb72
^bb74:
%844 = arith.constant 2 : i32
%845 = arith.addi %681, %844 : i32
%846 = arith.extsi %845 : i32 to i64
%847 = arith.constant 16 : i32
%849 = arith.extsi %847 : i32 to i64
%848 = arith.muli %846, %849 : i64
%843 = func.call @malloc(%848) : (i64) -> !llvm.ptr
%851 = arith.constant 0 : i32
%850 = func.call @big_from_i32(%851) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%852 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%853 = llvm.extractvalue %850[0] : !llvm.struct<(!llvm.ptr, i32)>
%854 = llvm.insertvalue %853, %852[0] : !llvm.struct<(!llvm.ptr, i32)>
%855 = llvm.extractvalue %850[1] : !llvm.struct<(!llvm.ptr, i32)>
%856 = llvm.insertvalue %855, %854[1] : !llvm.struct<(!llvm.ptr, i32)>
%857 = llvm.mlir.constant(1 : i64) : i64
%858 = llvm.alloca %857 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %856, %858 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%859 = llvm.load %858 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%860 = arith.constant 1 : i32
%861 = arith.addi %681, %860 : i32
%862 = arith.extsi %861 : i32 to i64
%863 = llvm.getelementptr %843[%862] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %859, %863 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%864 = llvm.mlir.constant(1 : i64) : i64
%865 = llvm.alloca %864 x i32 : (i64) -> !llvm.ptr
llvm.store %681, %865 : i32, !llvm.ptr
cf.br ^bb75
^bb75:
%866 = llvm.load %865 : !llvm.ptr -> i32
%867 = arith.constant 0 : i32
%868 = arith.cmpi sge, %866, %867 : i32
cf.cond_br %868, ^bb76, ^bb77
^bb76:
%871 = llvm.load %865 : !llvm.ptr -> i32
%872 = arith.extsi %871 : i32 to i64
%873 = llvm.getelementptr %762[%872] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%870 = llvm.load %873 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%875 = llvm.load %865 : !llvm.ptr -> i32
%876 = arith.constant 1 : i32
%877 = arith.addi %875, %876 : i32
%878 = arith.extsi %877 : i32 to i64
%879 = llvm.getelementptr %843[%878] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%874 = llvm.load %879 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%880 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%881 = llvm.extractvalue %874[0] : !llvm.struct<(!llvm.ptr, i32)>
%882 = llvm.insertvalue %881, %880[0] : !llvm.struct<(!llvm.ptr, i32)>
%883 = llvm.extractvalue %874[1] : !llvm.struct<(!llvm.ptr, i32)>
%884 = llvm.insertvalue %883, %882[1] : !llvm.struct<(!llvm.ptr, i32)>
%885 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%886 = llvm.extractvalue %870[0] : !llvm.struct<(!llvm.ptr, i32)>
%887 = llvm.insertvalue %886, %885[0] : !llvm.struct<(!llvm.ptr, i32)>
%888 = llvm.extractvalue %870[1] : !llvm.struct<(!llvm.ptr, i32)>
%889 = llvm.insertvalue %888, %887[1] : !llvm.struct<(!llvm.ptr, i32)>
%869 = func.call @big_add(%884, %889) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%890 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%891 = llvm.extractvalue %869[0] : !llvm.struct<(!llvm.ptr, i32)>
%892 = llvm.insertvalue %891, %890[0] : !llvm.struct<(!llvm.ptr, i32)>
%893 = llvm.extractvalue %869[1] : !llvm.struct<(!llvm.ptr, i32)>
%894 = llvm.insertvalue %893, %892[1] : !llvm.struct<(!llvm.ptr, i32)>
%895 = llvm.mlir.constant(1 : i64) : i64
%896 = llvm.alloca %895 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %894, %896 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%897 = llvm.load %896 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%898 = llvm.load %865 : !llvm.ptr -> i32
%899 = arith.extsi %898 : i32 to i64
%900 = llvm.getelementptr %843[%899] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %897, %900 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%901 = llvm.load %865 : !llvm.ptr -> i32
%902 = arith.constant 1 : i32
%903 = arith.subi %901, %902 : i32
llvm.store %903, %865 : i32, !llvm.ptr
cf.br ^bb75
^bb77:
%904 = arith.constant 1 : i32
%906 = arith.constant 0 : i32
%905 = arith.subi %906, %904 : i32
%907 = llvm.mlir.constant(1 : i64) : i64
%908 = llvm.alloca %907 x i32 : (i64) -> !llvm.ptr
llvm.store %905, %908 : i32, !llvm.ptr
%909 = llvm.mlir.constant(1 : i64) : i64
%910 = llvm.alloca %909 x i32 : (i64) -> !llvm.ptr
llvm.store %681, %910 : i32, !llvm.ptr
cf.br ^bb78
^bb78:
%911 = llvm.load %910 : !llvm.ptr -> i32
%912 = arith.constant 0 : i32
%913 = arith.cmpi sge, %911, %912 : i32
cf.cond_br %913, ^bb79, ^bb80
^bb79:
%916 = llvm.load %910 : !llvm.ptr -> i32
%917 = arith.extsi %916 : i32 to i64
%918 = llvm.getelementptr %843[%917] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%915 = llvm.load %918 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%919 = llvm.load %728 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%914 = func.call @big_cmp(%915, %919) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> i32
%920 = arith.constant 0 : i32
%921 = arith.cmpi sgt, %914, %920 : i32
cf.cond_br %921, ^bb81, ^bb82
^bb81:
%923 = llvm.load %728 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%925 = llvm.load %910 : !llvm.ptr -> i32
%926 = arith.constant 1 : i32
%927 = arith.addi %925, %926 : i32
%928 = arith.extsi %927 : i32 to i64
%929 = llvm.getelementptr %843[%928] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%924 = llvm.load %929 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%922 = func.call @big_cmp(%923, %924) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> i32
%930 = arith.constant 0 : i32
%931 = arith.cmpi sge, %922, %930 : i32
cf.cond_br %931, ^bb84, ^bb85
^bb84:
%932 = llvm.load %910 : !llvm.ptr -> i32
llvm.store %932, %908 : i32, !llvm.ptr
cf.br ^bb80
^bb85:
cf.br ^bb86
^bb86:
cf.br ^bb83
^bb82:
cf.br ^bb83
^bb83:
%933 = llvm.load %910 : !llvm.ptr -> i32
%934 = arith.constant 1 : i32
%935 = arith.subi %933, %934 : i32
llvm.store %935, %910 : i32, !llvm.ptr
cf.br ^bb78
^bb80:
%938 = llvm.load %908 : !llvm.ptr -> i32
%939 = arith.constant 1 : i32
%940 = arith.addi %938, %939 : i32
%941 = arith.extsi %940 : i32 to i64
%942 = llvm.getelementptr %843[%941] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%937 = llvm.load %942 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%943 = llvm.load %728 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%944 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%945 = llvm.extractvalue %943[0] : !llvm.struct<(!llvm.ptr, i32)>
%946 = llvm.insertvalue %945, %944[0] : !llvm.struct<(!llvm.ptr, i32)>
%947 = llvm.extractvalue %943[1] : !llvm.struct<(!llvm.ptr, i32)>
%948 = llvm.insertvalue %947, %946[1] : !llvm.struct<(!llvm.ptr, i32)>
%949 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%950 = llvm.extractvalue %937[0] : !llvm.struct<(!llvm.ptr, i32)>
%951 = llvm.insertvalue %950, %949[0] : !llvm.struct<(!llvm.ptr, i32)>
%952 = llvm.extractvalue %937[1] : !llvm.struct<(!llvm.ptr, i32)>
%953 = llvm.insertvalue %952, %951[1] : !llvm.struct<(!llvm.ptr, i32)>
%936 = func.call @big_sub(%948, %953) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%954 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%955 = llvm.extractvalue %936[0] : !llvm.struct<(!llvm.ptr, i32)>
%956 = llvm.insertvalue %955, %954[0] : !llvm.struct<(!llvm.ptr, i32)>
%957 = llvm.extractvalue %936[1] : !llvm.struct<(!llvm.ptr, i32)>
%958 = llvm.insertvalue %957, %956[1] : !llvm.struct<(!llvm.ptr, i32)>
%959 = llvm.mlir.constant(1 : i64) : i64
%960 = llvm.alloca %959 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %958, %960 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%961 = llvm.load %960 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%962 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%963 = llvm.extractvalue %948[0] : !llvm.struct<(!llvm.ptr, i32)>
%964 = llvm.insertvalue %963, %962[0] : !llvm.struct<(!llvm.ptr, i32)>
%965 = llvm.extractvalue %948[1] : !llvm.struct<(!llvm.ptr, i32)>
%966 = llvm.insertvalue %965, %964[1] : !llvm.struct<(!llvm.ptr, i32)>
%967 = llvm.mlir.constant(1 : i64) : i64
%968 = llvm.alloca %967 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %966, %968 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%969 = llvm.load %968 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %969, %728 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%970 = llvm.mlir.constant(1 : i64) : i64
%971 = llvm.alloca %970 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %961, %971 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%973 = arith.constant 1 : i32
%974 = arith.addi %681, %973 : i32
%975 = arith.extsi %974 : i32 to i64
%976 = arith.constant 16 : i32
%978 = arith.extsi %976 : i32 to i64
%977 = arith.muli %975, %978 : i64
%972 = func.call @malloc(%977) : (i64) -> !llvm.ptr
%980 = arith.constant 1 : i32
%981 = arith.addi %681, %980 : i32
%982 = arith.extsi %981 : i32 to i64
%983 = arith.constant 16 : i32
%985 = arith.extsi %983 : i32 to i64
%984 = arith.muli %982, %985 : i64
%979 = func.call @malloc(%984) : (i64) -> !llvm.ptr
%987 = arith.constant 1 : i32
%986 = func.call @big_from_i32(%987) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%988 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%989 = llvm.extractvalue %986[0] : !llvm.struct<(!llvm.ptr, i32)>
%990 = llvm.insertvalue %989, %988[0] : !llvm.struct<(!llvm.ptr, i32)>
%991 = llvm.extractvalue %986[1] : !llvm.struct<(!llvm.ptr, i32)>
%992 = llvm.insertvalue %991, %990[1] : !llvm.struct<(!llvm.ptr, i32)>
%993 = llvm.mlir.constant(1 : i64) : i64
%994 = llvm.alloca %993 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %992, %994 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%995 = llvm.load %994 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%996 = arith.constant 0 : i32
%997 = arith.extsi %996 : i32 to i64
%998 = llvm.getelementptr %972[%997] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %995, %998 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1000 = arith.constant 1 : i32
%999 = func.call @big_from_i32(%1000) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1001 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1002 = llvm.extractvalue %999[0] : !llvm.struct<(!llvm.ptr, i32)>
%1003 = llvm.insertvalue %1002, %1001[0] : !llvm.struct<(!llvm.ptr, i32)>
%1004 = llvm.extractvalue %999[1] : !llvm.struct<(!llvm.ptr, i32)>
%1005 = llvm.insertvalue %1004, %1003[1] : !llvm.struct<(!llvm.ptr, i32)>
%1006 = llvm.mlir.constant(1 : i64) : i64
%1007 = llvm.alloca %1006 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1005, %1007 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1008 = llvm.load %1007 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1009 = arith.constant 0 : i32
%1010 = arith.extsi %1009 : i32 to i64
%1011 = llvm.getelementptr %979[%1010] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1008, %1011 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1012 = arith.constant 1 : i32
%1013 = llvm.mlir.constant(1 : i64) : i64
%1014 = llvm.alloca %1013 x i32 : (i64) -> !llvm.ptr
llvm.store %1012, %1014 : i32, !llvm.ptr
cf.br ^bb87
^bb87:
%1015 = llvm.load %1014 : !llvm.ptr -> i32
%1016 = arith.cmpi sle, %1015, %681 : i32
cf.cond_br %1016, ^bb88, ^bb89
^bb88:
%1018 = arith.constant 2 : i32
%1020 = llvm.load %1014 : !llvm.ptr -> i32
%1021 = arith.constant 1 : i32
%1022 = arith.subi %1020, %1021 : i32
%1023 = arith.extsi %1022 : i32 to i64
%1024 = llvm.getelementptr %972[%1023] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1019 = llvm.load %1024 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1025 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1026 = llvm.extractvalue %1019[0] : !llvm.struct<(!llvm.ptr, i32)>
%1027 = llvm.insertvalue %1026, %1025[0] : !llvm.struct<(!llvm.ptr, i32)>
%1028 = llvm.extractvalue %1019[1] : !llvm.struct<(!llvm.ptr, i32)>
%1029 = llvm.insertvalue %1028, %1027[1] : !llvm.struct<(!llvm.ptr, i32)>
%1017 = func.call @big_mul_small(%1029, %1018) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1030 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1031 = llvm.extractvalue %1017[0] : !llvm.struct<(!llvm.ptr, i32)>
%1032 = llvm.insertvalue %1031, %1030[0] : !llvm.struct<(!llvm.ptr, i32)>
%1033 = llvm.extractvalue %1017[1] : !llvm.struct<(!llvm.ptr, i32)>
%1034 = llvm.insertvalue %1033, %1032[1] : !llvm.struct<(!llvm.ptr, i32)>
%1035 = llvm.mlir.constant(1 : i64) : i64
%1036 = llvm.alloca %1035 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1034, %1036 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1037 = llvm.load %1036 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1038 = llvm.load %1014 : !llvm.ptr -> i32
%1039 = arith.extsi %1038 : i32 to i64
%1040 = llvm.getelementptr %972[%1039] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1037, %1040 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1042 = arith.constant 3 : i32
%1044 = llvm.load %1014 : !llvm.ptr -> i32
%1045 = arith.constant 1 : i32
%1046 = arith.subi %1044, %1045 : i32
%1047 = arith.extsi %1046 : i32 to i64
%1048 = llvm.getelementptr %979[%1047] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1043 = llvm.load %1048 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1049 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1050 = llvm.extractvalue %1043[0] : !llvm.struct<(!llvm.ptr, i32)>
%1051 = llvm.insertvalue %1050, %1049[0] : !llvm.struct<(!llvm.ptr, i32)>
%1052 = llvm.extractvalue %1043[1] : !llvm.struct<(!llvm.ptr, i32)>
%1053 = llvm.insertvalue %1052, %1051[1] : !llvm.struct<(!llvm.ptr, i32)>
%1041 = func.call @big_mul_small(%1053, %1042) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1054 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1055 = llvm.extractvalue %1041[0] : !llvm.struct<(!llvm.ptr, i32)>
%1056 = llvm.insertvalue %1055, %1054[0] : !llvm.struct<(!llvm.ptr, i32)>
%1057 = llvm.extractvalue %1041[1] : !llvm.struct<(!llvm.ptr, i32)>
%1058 = llvm.insertvalue %1057, %1056[1] : !llvm.struct<(!llvm.ptr, i32)>
%1059 = llvm.mlir.constant(1 : i64) : i64
%1060 = llvm.alloca %1059 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1058, %1060 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1061 = llvm.load %1060 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1062 = llvm.load %1014 : !llvm.ptr -> i32
%1063 = arith.extsi %1062 : i32 to i64
%1064 = llvm.getelementptr %979[%1063] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1061, %1064 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1065 = llvm.load %1014 : !llvm.ptr -> i32
%1066 = arith.constant 1 : i32
%1067 = arith.addi %1065, %1066 : i32
llvm.store %1067, %1014 : i32, !llvm.ptr
cf.br ^bb87
^bb89:
%1069 = arith.constant 1 : i32
%1068 = func.call @big_from_i32(%1069) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1070 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1071 = llvm.extractvalue %1068[0] : !llvm.struct<(!llvm.ptr, i32)>
%1072 = llvm.insertvalue %1071, %1070[0] : !llvm.struct<(!llvm.ptr, i32)>
%1073 = llvm.extractvalue %1068[1] : !llvm.struct<(!llvm.ptr, i32)>
%1074 = llvm.insertvalue %1073, %1072[1] : !llvm.struct<(!llvm.ptr, i32)>
%1075 = llvm.mlir.constant(1 : i64) : i64
%1076 = llvm.alloca %1075 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1074, %1076 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1077 = llvm.load %1076 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1078 = llvm.mlir.constant(1 : i64) : i64
%1079 = llvm.alloca %1078 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1077, %1079 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1080 = arith.constant 0 : i32
%1081 = llvm.mlir.constant(1 : i64) : i64
%1082 = llvm.alloca %1081 x i32 : (i64) -> !llvm.ptr
llvm.store %1080, %1082 : i32, !llvm.ptr
cf.br ^bb90
^bb90:
%1083 = llvm.load %1082 : !llvm.ptr -> i32
%1084 = arith.cmpi slt, %1083, %681 : i32
cf.cond_br %1084, ^bb91, ^bb92
^bb91:
%1086 = arith.constant 5 : i32
%1087 = llvm.load %1079 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1088 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1089 = llvm.extractvalue %1087[0] : !llvm.struct<(!llvm.ptr, i32)>
%1090 = llvm.insertvalue %1089, %1088[0] : !llvm.struct<(!llvm.ptr, i32)>
%1091 = llvm.extractvalue %1087[1] : !llvm.struct<(!llvm.ptr, i32)>
%1092 = llvm.insertvalue %1091, %1090[1] : !llvm.struct<(!llvm.ptr, i32)>
%1085 = func.call @big_mul_small(%1092, %1086) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1093 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1094 = llvm.extractvalue %1085[0] : !llvm.struct<(!llvm.ptr, i32)>
%1095 = llvm.insertvalue %1094, %1093[0] : !llvm.struct<(!llvm.ptr, i32)>
%1096 = llvm.extractvalue %1085[1] : !llvm.struct<(!llvm.ptr, i32)>
%1097 = llvm.insertvalue %1096, %1095[1] : !llvm.struct<(!llvm.ptr, i32)>
%1098 = llvm.mlir.constant(1 : i64) : i64
%1099 = llvm.alloca %1098 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1097, %1099 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1100 = llvm.load %1099 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1101 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1102 = llvm.extractvalue %1092[0] : !llvm.struct<(!llvm.ptr, i32)>
%1103 = llvm.insertvalue %1102, %1101[0] : !llvm.struct<(!llvm.ptr, i32)>
%1104 = llvm.extractvalue %1092[1] : !llvm.struct<(!llvm.ptr, i32)>
%1105 = llvm.insertvalue %1104, %1103[1] : !llvm.struct<(!llvm.ptr, i32)>
%1106 = llvm.mlir.constant(1 : i64) : i64
%1107 = llvm.alloca %1106 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1105, %1107 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1108 = llvm.load %1107 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1108, %1079 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1100, %1079 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1109 = llvm.load %1082 : !llvm.ptr -> i32
%1110 = arith.constant 1 : i32
%1111 = arith.addi %1109, %1110 : i32
llvm.store %1111, %1082 : i32, !llvm.ptr
cf.br ^bb90
^bb92:
%1113 = arith.constant 0 : i32
%1112 = func.call @big_from_i32(%1113) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1114 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1115 = llvm.extractvalue %1112[0] : !llvm.struct<(!llvm.ptr, i32)>
%1116 = llvm.insertvalue %1115, %1114[0] : !llvm.struct<(!llvm.ptr, i32)>
%1117 = llvm.extractvalue %1112[1] : !llvm.struct<(!llvm.ptr, i32)>
%1118 = llvm.insertvalue %1117, %1116[1] : !llvm.struct<(!llvm.ptr, i32)>
%1119 = llvm.mlir.constant(1 : i64) : i64
%1120 = llvm.alloca %1119 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1118, %1120 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1121 = llvm.load %1120 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1122 = llvm.mlir.constant(1 : i64) : i64
%1123 = llvm.alloca %1122 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1121, %1123 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1124 = llvm.load %908 : !llvm.ptr -> i32
%1125 = arith.constant 1 : i32
%1126 = arith.addi %1124, %1125 : i32
%1127 = llvm.mlir.constant(1 : i64) : i64
%1128 = llvm.alloca %1127 x i32 : (i64) -> !llvm.ptr
llvm.store %1126, %1128 : i32, !llvm.ptr
cf.br ^bb93
^bb93:
%1129 = llvm.load %1128 : !llvm.ptr -> i32
%1130 = arith.cmpi sle, %1129, %681 : i32
cf.cond_br %1130, ^bb94, ^bb95
^bb94:
%1133 = llvm.load %1128 : !llvm.ptr -> i32
%1134 = arith.extsi %1133 : i32 to i64
%1135 = llvm.getelementptr %979[%1134] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1132 = llvm.load %1135 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1137 = llvm.load %1128 : !llvm.ptr -> i32
%1138 = arith.extsi %1137 : i32 to i64
%1139 = llvm.getelementptr %762[%1138] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1136 = llvm.load %1139 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1140 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1141 = llvm.extractvalue %1136[0] : !llvm.struct<(!llvm.ptr, i32)>
%1142 = llvm.insertvalue %1141, %1140[0] : !llvm.struct<(!llvm.ptr, i32)>
%1143 = llvm.extractvalue %1136[1] : !llvm.struct<(!llvm.ptr, i32)>
%1144 = llvm.insertvalue %1143, %1142[1] : !llvm.struct<(!llvm.ptr, i32)>
%1145 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1146 = llvm.extractvalue %1132[0] : !llvm.struct<(!llvm.ptr, i32)>
%1147 = llvm.insertvalue %1146, %1145[0] : !llvm.struct<(!llvm.ptr, i32)>
%1148 = llvm.extractvalue %1132[1] : !llvm.struct<(!llvm.ptr, i32)>
%1149 = llvm.insertvalue %1148, %1147[1] : !llvm.struct<(!llvm.ptr, i32)>
%1131 = func.call @big_mul(%1144, %1149) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1150 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1151 = llvm.extractvalue %1131[0] : !llvm.struct<(!llvm.ptr, i32)>
%1152 = llvm.insertvalue %1151, %1150[0] : !llvm.struct<(!llvm.ptr, i32)>
%1153 = llvm.extractvalue %1131[1] : !llvm.struct<(!llvm.ptr, i32)>
%1154 = llvm.insertvalue %1153, %1152[1] : !llvm.struct<(!llvm.ptr, i32)>
%1155 = llvm.mlir.constant(1 : i64) : i64
%1156 = llvm.alloca %1155 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1154, %1156 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1157 = llvm.load %1156 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1158 = llvm.mlir.constant(1 : i64) : i64
%1159 = llvm.alloca %1158 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1157, %1159 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1162 = llvm.load %1128 : !llvm.ptr -> i32
%1163 = arith.subi %681, %1162 : i32
%1164 = arith.extsi %1163 : i32 to i64
%1165 = llvm.getelementptr %972[%1164] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1161 = llvm.load %1165 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1166 = llvm.load %1159 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1167 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1168 = llvm.extractvalue %1166[0] : !llvm.struct<(!llvm.ptr, i32)>
%1169 = llvm.insertvalue %1168, %1167[0] : !llvm.struct<(!llvm.ptr, i32)>
%1170 = llvm.extractvalue %1166[1] : !llvm.struct<(!llvm.ptr, i32)>
%1171 = llvm.insertvalue %1170, %1169[1] : !llvm.struct<(!llvm.ptr, i32)>
%1172 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1173 = llvm.extractvalue %1161[0] : !llvm.struct<(!llvm.ptr, i32)>
%1174 = llvm.insertvalue %1173, %1172[0] : !llvm.struct<(!llvm.ptr, i32)>
%1175 = llvm.extractvalue %1161[1] : !llvm.struct<(!llvm.ptr, i32)>
%1176 = llvm.insertvalue %1175, %1174[1] : !llvm.struct<(!llvm.ptr, i32)>
%1160 = func.call @big_mul(%1171, %1176) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1177 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1178 = llvm.extractvalue %1160[0] : !llvm.struct<(!llvm.ptr, i32)>
%1179 = llvm.insertvalue %1178, %1177[0] : !llvm.struct<(!llvm.ptr, i32)>
%1180 = llvm.extractvalue %1160[1] : !llvm.struct<(!llvm.ptr, i32)>
%1181 = llvm.insertvalue %1180, %1179[1] : !llvm.struct<(!llvm.ptr, i32)>
%1182 = llvm.mlir.constant(1 : i64) : i64
%1183 = llvm.alloca %1182 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1181, %1183 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1184 = llvm.load %1183 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1185 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1186 = llvm.extractvalue %1171[0] : !llvm.struct<(!llvm.ptr, i32)>
%1187 = llvm.insertvalue %1186, %1185[0] : !llvm.struct<(!llvm.ptr, i32)>
%1188 = llvm.extractvalue %1171[1] : !llvm.struct<(!llvm.ptr, i32)>
%1189 = llvm.insertvalue %1188, %1187[1] : !llvm.struct<(!llvm.ptr, i32)>
%1190 = llvm.mlir.constant(1 : i64) : i64
%1191 = llvm.alloca %1190 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1189, %1191 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1192 = llvm.load %1191 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1192, %1159 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1193 = llvm.mlir.constant(1 : i64) : i64
%1194 = llvm.alloca %1193 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1184, %1194 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1196 = llvm.load %1194 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1197 = llvm.load %1123 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1198 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1199 = llvm.extractvalue %1197[0] : !llvm.struct<(!llvm.ptr, i32)>
%1200 = llvm.insertvalue %1199, %1198[0] : !llvm.struct<(!llvm.ptr, i32)>
%1201 = llvm.extractvalue %1197[1] : !llvm.struct<(!llvm.ptr, i32)>
%1202 = llvm.insertvalue %1201, %1200[1] : !llvm.struct<(!llvm.ptr, i32)>
%1203 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1204 = llvm.extractvalue %1196[0] : !llvm.struct<(!llvm.ptr, i32)>
%1205 = llvm.insertvalue %1204, %1203[0] : !llvm.struct<(!llvm.ptr, i32)>
%1206 = llvm.extractvalue %1196[1] : !llvm.struct<(!llvm.ptr, i32)>
%1207 = llvm.insertvalue %1206, %1205[1] : !llvm.struct<(!llvm.ptr, i32)>
%1195 = func.call @big_add(%1202, %1207) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1208 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1209 = llvm.extractvalue %1195[0] : !llvm.struct<(!llvm.ptr, i32)>
%1210 = llvm.insertvalue %1209, %1208[0] : !llvm.struct<(!llvm.ptr, i32)>
%1211 = llvm.extractvalue %1195[1] : !llvm.struct<(!llvm.ptr, i32)>
%1212 = llvm.insertvalue %1211, %1210[1] : !llvm.struct<(!llvm.ptr, i32)>
%1213 = llvm.mlir.constant(1 : i64) : i64
%1214 = llvm.alloca %1213 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1212, %1214 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1215 = llvm.load %1214 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1216 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1217 = llvm.extractvalue %1202[0] : !llvm.struct<(!llvm.ptr, i32)>
%1218 = llvm.insertvalue %1217, %1216[0] : !llvm.struct<(!llvm.ptr, i32)>
%1219 = llvm.extractvalue %1202[1] : !llvm.struct<(!llvm.ptr, i32)>
%1220 = llvm.insertvalue %1219, %1218[1] : !llvm.struct<(!llvm.ptr, i32)>
%1221 = llvm.mlir.constant(1 : i64) : i64
%1222 = llvm.alloca %1221 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1220, %1222 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1223 = llvm.load %1222 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1223, %1123 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1224 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1225 = llvm.extractvalue %1207[0] : !llvm.struct<(!llvm.ptr, i32)>
%1226 = llvm.insertvalue %1225, %1224[0] : !llvm.struct<(!llvm.ptr, i32)>
%1227 = llvm.extractvalue %1207[1] : !llvm.struct<(!llvm.ptr, i32)>
%1228 = llvm.insertvalue %1227, %1226[1] : !llvm.struct<(!llvm.ptr, i32)>
%1229 = llvm.mlir.constant(1 : i64) : i64
%1230 = llvm.alloca %1229 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1228, %1230 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1231 = llvm.load %1230 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1231, %1194 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1215, %1123 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1232 = llvm.load %1128 : !llvm.ptr -> i32
%1233 = arith.constant 1 : i32
%1234 = arith.addi %1232, %1233 : i32
llvm.store %1234, %1128 : i32, !llvm.ptr
cf.br ^bb93
^bb95:
%1236 = llvm.load %971 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1235 = func.call @big_is_zero(%1236) : (!llvm.struct<(!llvm.ptr, i32)>) -> i32
%1237 = arith.constant 0 : i32
%1238 = arith.cmpi eq, %1235, %1237 : i32
cf.cond_br %1238, ^bb96, ^bb97
^bb96:
%1241 = llvm.load %908 : !llvm.ptr -> i32
%1242 = arith.extsi %1241 : i32 to i64
%1243 = llvm.getelementptr %979[%1242] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1240 = llvm.load %1243 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1244 = llvm.load %971 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1245 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1246 = llvm.extractvalue %1244[0] : !llvm.struct<(!llvm.ptr, i32)>
%1247 = llvm.insertvalue %1246, %1245[0] : !llvm.struct<(!llvm.ptr, i32)>
%1248 = llvm.extractvalue %1244[1] : !llvm.struct<(!llvm.ptr, i32)>
%1249 = llvm.insertvalue %1248, %1247[1] : !llvm.struct<(!llvm.ptr, i32)>
%1250 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1251 = llvm.extractvalue %1240[0] : !llvm.struct<(!llvm.ptr, i32)>
%1252 = llvm.insertvalue %1251, %1250[0] : !llvm.struct<(!llvm.ptr, i32)>
%1253 = llvm.extractvalue %1240[1] : !llvm.struct<(!llvm.ptr, i32)>
%1254 = llvm.insertvalue %1253, %1252[1] : !llvm.struct<(!llvm.ptr, i32)>
%1239 = func.call @big_mul(%1249, %1254) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1255 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1256 = llvm.extractvalue %1239[0] : !llvm.struct<(!llvm.ptr, i32)>
%1257 = llvm.insertvalue %1256, %1255[0] : !llvm.struct<(!llvm.ptr, i32)>
%1258 = llvm.extractvalue %1239[1] : !llvm.struct<(!llvm.ptr, i32)>
%1259 = llvm.insertvalue %1258, %1257[1] : !llvm.struct<(!llvm.ptr, i32)>
%1260 = llvm.mlir.constant(1 : i64) : i64
%1261 = llvm.alloca %1260 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1259, %1261 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1262 = llvm.load %1261 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1263 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1264 = llvm.extractvalue %1249[0] : !llvm.struct<(!llvm.ptr, i32)>
%1265 = llvm.insertvalue %1264, %1263[0] : !llvm.struct<(!llvm.ptr, i32)>
%1266 = llvm.extractvalue %1249[1] : !llvm.struct<(!llvm.ptr, i32)>
%1267 = llvm.insertvalue %1266, %1265[1] : !llvm.struct<(!llvm.ptr, i32)>
%1268 = llvm.mlir.constant(1 : i64) : i64
%1269 = llvm.alloca %1268 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1267, %1269 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1270 = llvm.load %1269 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1270, %971 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1271 = llvm.mlir.constant(1 : i64) : i64
%1272 = llvm.alloca %1271 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1262, %1272 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1275 = llvm.load %908 : !llvm.ptr -> i32
%1276 = arith.subi %681, %1275 : i32
%1277 = arith.extsi %1276 : i32 to i64
%1278 = llvm.getelementptr %972[%1277] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i32)>
%1274 = llvm.load %1278 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1279 = llvm.load %1272 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1280 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1281 = llvm.extractvalue %1279[0] : !llvm.struct<(!llvm.ptr, i32)>
%1282 = llvm.insertvalue %1281, %1280[0] : !llvm.struct<(!llvm.ptr, i32)>
%1283 = llvm.extractvalue %1279[1] : !llvm.struct<(!llvm.ptr, i32)>
%1284 = llvm.insertvalue %1283, %1282[1] : !llvm.struct<(!llvm.ptr, i32)>
%1285 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1286 = llvm.extractvalue %1274[0] : !llvm.struct<(!llvm.ptr, i32)>
%1287 = llvm.insertvalue %1286, %1285[0] : !llvm.struct<(!llvm.ptr, i32)>
%1288 = llvm.extractvalue %1274[1] : !llvm.struct<(!llvm.ptr, i32)>
%1289 = llvm.insertvalue %1288, %1287[1] : !llvm.struct<(!llvm.ptr, i32)>
%1273 = func.call @big_mul(%1284, %1289) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1290 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1291 = llvm.extractvalue %1273[0] : !llvm.struct<(!llvm.ptr, i32)>
%1292 = llvm.insertvalue %1291, %1290[0] : !llvm.struct<(!llvm.ptr, i32)>
%1293 = llvm.extractvalue %1273[1] : !llvm.struct<(!llvm.ptr, i32)>
%1294 = llvm.insertvalue %1293, %1292[1] : !llvm.struct<(!llvm.ptr, i32)>
%1295 = llvm.mlir.constant(1 : i64) : i64
%1296 = llvm.alloca %1295 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1294, %1296 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1297 = llvm.load %1296 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1298 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1299 = llvm.extractvalue %1284[0] : !llvm.struct<(!llvm.ptr, i32)>
%1300 = llvm.insertvalue %1299, %1298[0] : !llvm.struct<(!llvm.ptr, i32)>
%1301 = llvm.extractvalue %1284[1] : !llvm.struct<(!llvm.ptr, i32)>
%1302 = llvm.insertvalue %1301, %1300[1] : !llvm.struct<(!llvm.ptr, i32)>
%1303 = llvm.mlir.constant(1 : i64) : i64
%1304 = llvm.alloca %1303 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1302, %1304 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1305 = llvm.load %1304 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1305, %1272 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1306 = llvm.mlir.constant(1 : i64) : i64
%1307 = llvm.alloca %1306 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1297, %1307 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1309 = llvm.load %1307 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1310 = llvm.load %1123 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1311 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1312 = llvm.extractvalue %1310[0] : !llvm.struct<(!llvm.ptr, i32)>
%1313 = llvm.insertvalue %1312, %1311[0] : !llvm.struct<(!llvm.ptr, i32)>
%1314 = llvm.extractvalue %1310[1] : !llvm.struct<(!llvm.ptr, i32)>
%1315 = llvm.insertvalue %1314, %1313[1] : !llvm.struct<(!llvm.ptr, i32)>
%1316 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1317 = llvm.extractvalue %1309[0] : !llvm.struct<(!llvm.ptr, i32)>
%1318 = llvm.insertvalue %1317, %1316[0] : !llvm.struct<(!llvm.ptr, i32)>
%1319 = llvm.extractvalue %1309[1] : !llvm.struct<(!llvm.ptr, i32)>
%1320 = llvm.insertvalue %1319, %1318[1] : !llvm.struct<(!llvm.ptr, i32)>
%1308 = func.call @big_add(%1315, %1320) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1321 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1322 = llvm.extractvalue %1308[0] : !llvm.struct<(!llvm.ptr, i32)>
%1323 = llvm.insertvalue %1322, %1321[0] : !llvm.struct<(!llvm.ptr, i32)>
%1324 = llvm.extractvalue %1308[1] : !llvm.struct<(!llvm.ptr, i32)>
%1325 = llvm.insertvalue %1324, %1323[1] : !llvm.struct<(!llvm.ptr, i32)>
%1326 = llvm.mlir.constant(1 : i64) : i64
%1327 = llvm.alloca %1326 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1325, %1327 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1328 = llvm.load %1327 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1329 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1330 = llvm.extractvalue %1315[0] : !llvm.struct<(!llvm.ptr, i32)>
%1331 = llvm.insertvalue %1330, %1329[0] : !llvm.struct<(!llvm.ptr, i32)>
%1332 = llvm.extractvalue %1315[1] : !llvm.struct<(!llvm.ptr, i32)>
%1333 = llvm.insertvalue %1332, %1331[1] : !llvm.struct<(!llvm.ptr, i32)>
%1334 = llvm.mlir.constant(1 : i64) : i64
%1335 = llvm.alloca %1334 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1333, %1335 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1336 = llvm.load %1335 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1336, %1123 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1337 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1338 = llvm.extractvalue %1320[0] : !llvm.struct<(!llvm.ptr, i32)>
%1339 = llvm.insertvalue %1338, %1337[0] : !llvm.struct<(!llvm.ptr, i32)>
%1340 = llvm.extractvalue %1320[1] : !llvm.struct<(!llvm.ptr, i32)>
%1341 = llvm.insertvalue %1340, %1339[1] : !llvm.struct<(!llvm.ptr, i32)>
%1342 = llvm.mlir.constant(1 : i64) : i64
%1343 = llvm.alloca %1342 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1341, %1343 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1344 = llvm.load %1343 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1344, %1307 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1328, %1123 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
cf.br ^bb98
^bb97:
cf.br ^bb98
^bb98:
%1345 = llvm.load %1123 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1346 = llvm.mlir.constant(1 : i64) : i64
%1347 = llvm.alloca %1346 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1345, %1347 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1348 = arith.constant 0 : i32
%1349 = llvm.mlir.constant(1 : i64) : i64
%1350 = llvm.alloca %1349 x i32 : (i64) -> !llvm.ptr
llvm.store %1348, %1350 : i32, !llvm.ptr
cf.br ^bb99
^bb99:
%1351 = llvm.load %1350 : !llvm.ptr -> i32
%1352 = arith.constant 10 : i32
%1353 = arith.cmpi slt, %1351, %1352 : i32
cf.cond_br %1353, ^bb100, ^bb101
^bb100:
%1355 = arith.constant 10 : i32
%1356 = llvm.load %1347 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1357 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1358 = llvm.extractvalue %1356[0] : !llvm.struct<(!llvm.ptr, i32)>
%1359 = llvm.insertvalue %1358, %1357[0] : !llvm.struct<(!llvm.ptr, i32)>
%1360 = llvm.extractvalue %1356[1] : !llvm.struct<(!llvm.ptr, i32)>
%1361 = llvm.insertvalue %1360, %1359[1] : !llvm.struct<(!llvm.ptr, i32)>
%1354 = func.call @big_mul_small(%1361, %1355) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1362 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1363 = llvm.extractvalue %1354[0] : !llvm.struct<(!llvm.ptr, i32)>
%1364 = llvm.insertvalue %1363, %1362[0] : !llvm.struct<(!llvm.ptr, i32)>
%1365 = llvm.extractvalue %1354[1] : !llvm.struct<(!llvm.ptr, i32)>
%1366 = llvm.insertvalue %1365, %1364[1] : !llvm.struct<(!llvm.ptr, i32)>
%1367 = llvm.mlir.constant(1 : i64) : i64
%1368 = llvm.alloca %1367 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1366, %1368 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1369 = llvm.load %1368 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1370 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1371 = llvm.extractvalue %1361[0] : !llvm.struct<(!llvm.ptr, i32)>
%1372 = llvm.insertvalue %1371, %1370[0] : !llvm.struct<(!llvm.ptr, i32)>
%1373 = llvm.extractvalue %1361[1] : !llvm.struct<(!llvm.ptr, i32)>
%1374 = llvm.insertvalue %1373, %1372[1] : !llvm.struct<(!llvm.ptr, i32)>
%1375 = llvm.mlir.constant(1 : i64) : i64
%1376 = llvm.alloca %1375 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1374, %1376 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1377 = llvm.load %1376 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1377, %1347 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1369, %1347 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1378 = llvm.load %1350 : !llvm.ptr -> i32
%1379 = arith.constant 1 : i32
%1380 = arith.addi %1378, %1379 : i32
llvm.store %1380, %1350 : i32, !llvm.ptr
cf.br ^bb99
^bb101:
%1381 = llvm.load %1347 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1382 = llvm.mlir.constant(1 : i64) : i64
%1383 = llvm.alloca %1382 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1381, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1384 = arith.constant 0 : i32
%1385 = llvm.mlir.constant(1 : i64) : i64
%1386 = llvm.alloca %1385 x i32 : (i64) -> !llvm.ptr
llvm.store %1384, %1386 : i32, !llvm.ptr
cf.br ^bb102
^bb102:
%1387 = llvm.load %1386 : !llvm.ptr -> i32
%1388 = arith.cmpi slt, %1387, %681 : i32
cf.cond_br %1388, ^bb103, ^bb104
^bb103:
%1390 = arith.constant 5 : i32
%1391 = llvm.load %1383 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1392 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1393 = llvm.extractvalue %1391[0] : !llvm.struct<(!llvm.ptr, i32)>
%1394 = llvm.insertvalue %1393, %1392[0] : !llvm.struct<(!llvm.ptr, i32)>
%1395 = llvm.extractvalue %1391[1] : !llvm.struct<(!llvm.ptr, i32)>
%1396 = llvm.insertvalue %1395, %1394[1] : !llvm.struct<(!llvm.ptr, i32)>
%1389 = func.call @big_div_small(%1396, %1390) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1397 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1398 = llvm.extractvalue %1389[0] : !llvm.struct<(!llvm.ptr, i32)>
%1399 = llvm.insertvalue %1398, %1397[0] : !llvm.struct<(!llvm.ptr, i32)>
%1400 = llvm.extractvalue %1389[1] : !llvm.struct<(!llvm.ptr, i32)>
%1401 = llvm.insertvalue %1400, %1399[1] : !llvm.struct<(!llvm.ptr, i32)>
%1402 = llvm.mlir.constant(1 : i64) : i64
%1403 = llvm.alloca %1402 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1401, %1403 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1404 = llvm.load %1403 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1405 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1406 = llvm.extractvalue %1396[0] : !llvm.struct<(!llvm.ptr, i32)>
%1407 = llvm.insertvalue %1406, %1405[0] : !llvm.struct<(!llvm.ptr, i32)>
%1408 = llvm.extractvalue %1396[1] : !llvm.struct<(!llvm.ptr, i32)>
%1409 = llvm.insertvalue %1408, %1407[1] : !llvm.struct<(!llvm.ptr, i32)>
%1410 = llvm.mlir.constant(1 : i64) : i64
%1411 = llvm.alloca %1410 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1409, %1411 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1412 = llvm.load %1411 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1412, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1404, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1413 = llvm.load %1386 : !llvm.ptr -> i32
%1414 = arith.constant 1 : i32
%1415 = arith.addi %1413, %1414 : i32
llvm.store %1415, %1386 : i32, !llvm.ptr
cf.br ^bb102
^bb104:
%1417 = llvm.load %1079 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1418 = llvm.load %1383 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1419 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1420 = llvm.extractvalue %1418[0] : !llvm.struct<(!llvm.ptr, i32)>
%1421 = llvm.insertvalue %1420, %1419[0] : !llvm.struct<(!llvm.ptr, i32)>
%1422 = llvm.extractvalue %1418[1] : !llvm.struct<(!llvm.ptr, i32)>
%1423 = llvm.insertvalue %1422, %1421[1] : !llvm.struct<(!llvm.ptr, i32)>
%1424 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1425 = llvm.extractvalue %1417[0] : !llvm.struct<(!llvm.ptr, i32)>
%1426 = llvm.insertvalue %1425, %1424[0] : !llvm.struct<(!llvm.ptr, i32)>
%1427 = llvm.extractvalue %1417[1] : !llvm.struct<(!llvm.ptr, i32)>
%1428 = llvm.insertvalue %1427, %1426[1] : !llvm.struct<(!llvm.ptr, i32)>
%1416 = func.call @big_mul(%1423, %1428) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1429 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1430 = llvm.extractvalue %1416[0] : !llvm.struct<(!llvm.ptr, i32)>
%1431 = llvm.insertvalue %1430, %1429[0] : !llvm.struct<(!llvm.ptr, i32)>
%1432 = llvm.extractvalue %1416[1] : !llvm.struct<(!llvm.ptr, i32)>
%1433 = llvm.insertvalue %1432, %1431[1] : !llvm.struct<(!llvm.ptr, i32)>
%1434 = llvm.mlir.constant(1 : i64) : i64
%1435 = llvm.alloca %1434 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1433, %1435 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1436 = llvm.load %1435 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1437 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1438 = llvm.extractvalue %1423[0] : !llvm.struct<(!llvm.ptr, i32)>
%1439 = llvm.insertvalue %1438, %1437[0] : !llvm.struct<(!llvm.ptr, i32)>
%1440 = llvm.extractvalue %1423[1] : !llvm.struct<(!llvm.ptr, i32)>
%1441 = llvm.insertvalue %1440, %1439[1] : !llvm.struct<(!llvm.ptr, i32)>
%1442 = llvm.mlir.constant(1 : i64) : i64
%1443 = llvm.alloca %1442 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1441, %1443 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1444 = llvm.load %1443 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1444, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1445 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1446 = llvm.extractvalue %1428[0] : !llvm.struct<(!llvm.ptr, i32)>
%1447 = llvm.insertvalue %1446, %1445[0] : !llvm.struct<(!llvm.ptr, i32)>
%1448 = llvm.extractvalue %1428[1] : !llvm.struct<(!llvm.ptr, i32)>
%1449 = llvm.insertvalue %1448, %1447[1] : !llvm.struct<(!llvm.ptr, i32)>
%1450 = llvm.mlir.constant(1 : i64) : i64
%1451 = llvm.alloca %1450 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1449, %1451 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1452 = llvm.load %1451 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1452, %1079 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1453 = llvm.mlir.constant(1 : i64) : i64
%1454 = llvm.alloca %1453 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1436, %1454 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1456 = llvm.load %1454 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1457 = llvm.load %1347 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1458 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1459 = llvm.extractvalue %1457[0] : !llvm.struct<(!llvm.ptr, i32)>
%1460 = llvm.insertvalue %1459, %1458[0] : !llvm.struct<(!llvm.ptr, i32)>
%1461 = llvm.extractvalue %1457[1] : !llvm.struct<(!llvm.ptr, i32)>
%1462 = llvm.insertvalue %1461, %1460[1] : !llvm.struct<(!llvm.ptr, i32)>
%1463 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1464 = llvm.extractvalue %1456[0] : !llvm.struct<(!llvm.ptr, i32)>
%1465 = llvm.insertvalue %1464, %1463[0] : !llvm.struct<(!llvm.ptr, i32)>
%1466 = llvm.extractvalue %1456[1] : !llvm.struct<(!llvm.ptr, i32)>
%1467 = llvm.insertvalue %1466, %1465[1] : !llvm.struct<(!llvm.ptr, i32)>
%1455 = func.call @big_sub(%1462, %1467) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1468 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1469 = llvm.extractvalue %1455[0] : !llvm.struct<(!llvm.ptr, i32)>
%1470 = llvm.insertvalue %1469, %1468[0] : !llvm.struct<(!llvm.ptr, i32)>
%1471 = llvm.extractvalue %1455[1] : !llvm.struct<(!llvm.ptr, i32)>
%1472 = llvm.insertvalue %1471, %1470[1] : !llvm.struct<(!llvm.ptr, i32)>
%1473 = llvm.mlir.constant(1 : i64) : i64
%1474 = llvm.alloca %1473 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1472, %1474 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1475 = llvm.load %1474 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1476 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1477 = llvm.extractvalue %1462[0] : !llvm.struct<(!llvm.ptr, i32)>
%1478 = llvm.insertvalue %1477, %1476[0] : !llvm.struct<(!llvm.ptr, i32)>
%1479 = llvm.extractvalue %1462[1] : !llvm.struct<(!llvm.ptr, i32)>
%1480 = llvm.insertvalue %1479, %1478[1] : !llvm.struct<(!llvm.ptr, i32)>
%1481 = llvm.mlir.constant(1 : i64) : i64
%1482 = llvm.alloca %1481 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1480, %1482 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1483 = llvm.load %1482 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1483, %1347 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1484 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1485 = llvm.extractvalue %1467[0] : !llvm.struct<(!llvm.ptr, i32)>
%1486 = llvm.insertvalue %1485, %1484[0] : !llvm.struct<(!llvm.ptr, i32)>
%1487 = llvm.extractvalue %1467[1] : !llvm.struct<(!llvm.ptr, i32)>
%1488 = llvm.insertvalue %1487, %1486[1] : !llvm.struct<(!llvm.ptr, i32)>
%1489 = llvm.mlir.constant(1 : i64) : i64
%1490 = llvm.alloca %1489 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1488, %1490 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1491 = llvm.load %1490 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1491, %1454 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1492 = llvm.mlir.constant(1 : i64) : i64
%1493 = llvm.alloca %1492 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1475, %1493 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1495 = arith.constant 2 : i32
%1496 = llvm.load %1493 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1497 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1498 = llvm.extractvalue %1496[0] : !llvm.struct<(!llvm.ptr, i32)>
%1499 = llvm.insertvalue %1498, %1497[0] : !llvm.struct<(!llvm.ptr, i32)>
%1500 = llvm.extractvalue %1496[1] : !llvm.struct<(!llvm.ptr, i32)>
%1501 = llvm.insertvalue %1500, %1499[1] : !llvm.struct<(!llvm.ptr, i32)>
%1494 = func.call @big_mul_small(%1501, %1495) : (!llvm.struct<(!llvm.ptr, i32)>, i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1502 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1503 = llvm.extractvalue %1494[0] : !llvm.struct<(!llvm.ptr, i32)>
%1504 = llvm.insertvalue %1503, %1502[0] : !llvm.struct<(!llvm.ptr, i32)>
%1505 = llvm.extractvalue %1494[1] : !llvm.struct<(!llvm.ptr, i32)>
%1506 = llvm.insertvalue %1505, %1504[1] : !llvm.struct<(!llvm.ptr, i32)>
%1507 = llvm.mlir.constant(1 : i64) : i64
%1508 = llvm.alloca %1507 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1506, %1508 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1509 = llvm.load %1508 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1510 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1511 = llvm.extractvalue %1501[0] : !llvm.struct<(!llvm.ptr, i32)>
%1512 = llvm.insertvalue %1511, %1510[0] : !llvm.struct<(!llvm.ptr, i32)>
%1513 = llvm.extractvalue %1501[1] : !llvm.struct<(!llvm.ptr, i32)>
%1514 = llvm.insertvalue %1513, %1512[1] : !llvm.struct<(!llvm.ptr, i32)>
%1515 = llvm.mlir.constant(1 : i64) : i64
%1516 = llvm.alloca %1515 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1514, %1516 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1517 = llvm.load %1516 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1517, %1493 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1518 = llvm.mlir.constant(1 : i64) : i64
%1519 = llvm.alloca %1518 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1509, %1519 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1521 = llvm.load %1519 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1522 = llvm.load %1079 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1520 = func.call @big_cmp(%1521, %1522) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> i32
%1523 = arith.constant 0 : i32
%1524 = arith.cmpi sge, %1520, %1523 : i32
cf.cond_br %1524, ^bb105, ^bb106
^bb105:
%1527 = arith.constant 1 : i32
%1526 = func.call @big_from_i32(%1527) : (i32) -> !llvm.struct<(!llvm.ptr, i32)>
%1528 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1529 = llvm.extractvalue %1526[0] : !llvm.struct<(!llvm.ptr, i32)>
%1530 = llvm.insertvalue %1529, %1528[0] : !llvm.struct<(!llvm.ptr, i32)>
%1531 = llvm.extractvalue %1526[1] : !llvm.struct<(!llvm.ptr, i32)>
%1532 = llvm.insertvalue %1531, %1530[1] : !llvm.struct<(!llvm.ptr, i32)>
%1533 = llvm.mlir.constant(1 : i64) : i64
%1534 = llvm.alloca %1533 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1532, %1534 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1535 = llvm.load %1534 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1536 = llvm.load %1383 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1537 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1538 = llvm.extractvalue %1536[0] : !llvm.struct<(!llvm.ptr, i32)>
%1539 = llvm.insertvalue %1538, %1537[0] : !llvm.struct<(!llvm.ptr, i32)>
%1540 = llvm.extractvalue %1536[1] : !llvm.struct<(!llvm.ptr, i32)>
%1541 = llvm.insertvalue %1540, %1539[1] : !llvm.struct<(!llvm.ptr, i32)>
%1542 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1543 = llvm.extractvalue %1535[0] : !llvm.struct<(!llvm.ptr, i32)>
%1544 = llvm.insertvalue %1543, %1542[0] : !llvm.struct<(!llvm.ptr, i32)>
%1545 = llvm.extractvalue %1535[1] : !llvm.struct<(!llvm.ptr, i32)>
%1546 = llvm.insertvalue %1545, %1544[1] : !llvm.struct<(!llvm.ptr, i32)>
%1525 = func.call @big_add(%1541, %1546) : (!llvm.struct<(!llvm.ptr, i32)>, !llvm.struct<(!llvm.ptr, i32)>) -> !llvm.struct<(!llvm.ptr, i32)>
%1547 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1548 = llvm.extractvalue %1525[0] : !llvm.struct<(!llvm.ptr, i32)>
%1549 = llvm.insertvalue %1548, %1547[0] : !llvm.struct<(!llvm.ptr, i32)>
%1550 = llvm.extractvalue %1525[1] : !llvm.struct<(!llvm.ptr, i32)>
%1551 = llvm.insertvalue %1550, %1549[1] : !llvm.struct<(!llvm.ptr, i32)>
%1552 = llvm.mlir.constant(1 : i64) : i64
%1553 = llvm.alloca %1552 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1551, %1553 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1554 = llvm.load %1553 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1555 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i32)>
%1556 = llvm.extractvalue %1541[0] : !llvm.struct<(!llvm.ptr, i32)>
%1557 = llvm.insertvalue %1556, %1555[0] : !llvm.struct<(!llvm.ptr, i32)>
%1558 = llvm.extractvalue %1541[1] : !llvm.struct<(!llvm.ptr, i32)>
%1559 = llvm.insertvalue %1558, %1557[1] : !llvm.struct<(!llvm.ptr, i32)>
%1560 = llvm.mlir.constant(1 : i64) : i64
%1561 = llvm.alloca %1560 x !llvm.struct<(!llvm.ptr, i32)> : (i64) -> !llvm.ptr
llvm.store %1559, %1561 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
%1562 = llvm.load %1561 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
llvm.store %1562, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
llvm.store %1554, %1383 : !llvm.struct<(!llvm.ptr, i32)>, !llvm.ptr
cf.br ^bb107
^bb106:
cf.br ^bb107
^bb107:
%1564 = llvm.load %1383 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i32)>
%1563 = func.call @big_to_double(%1564) : (!llvm.struct<(!llvm.ptr, i32)>) -> f64
%1565 = arith.constant 10000000000 : f32
%1567 = arith.extf %1565 : f32 to f64
%1566 = arith.divf %1563, %1567 : f64
%1568 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1569 = llvm.call @printf(%1568, %1566) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, f64) -> i32
%1570 = arith.constant 0 : i32
func.return %1570 : i32
}
}