← All problems Problem 807
P(n) = A(2n-1, n) / (2n-1)! where A is an Eulerian number (OEIS A025585). a(n) = sum_{j=0..n-1} (-1)^j * C(2n, j) * (n-j)^(2n-1) Exact bignum arithmetic in Flow, then round half-up to 10 decimals.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^2)O(n * m)Space complexity O(n)O(n)Approach Flow solution Dynamic programming or generating function Verdict Unknown
Flow source
# Project Euler 807 - Loops of Ropes
# P(n) = A(2n-1, n) / (2n-1)! where A is an Eulerian number (OEIS A025585).
# a(n) = sum_{j=0..n-1} (-1)^j * C(2n, j) * (n-j)^(2n-1)
# Exact bignum arithmetic in Flow, then round half-up to 10 decimals.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
}
const BASE: i64 = 1000000000
const CAP: i64 = 60
struct Big {
d: ptr<i64>
len: i64
}
function bn_alloc(cap: i64) -> Big {
let d: ptr<i64> = calloc(cap, 8) as ptr<i64>
return Big { d: d, len: 0 }
}
function bn_from_i64(v: i64) -> Big {
let b: Big = bn_alloc(CAP)
if v == 0 {
return b
}
let mut r: i64 = v
let mut i: i64 = 0
while r > 0 {
b.d[i] = r % BASE
r = r / BASE
i = i + 1
}
b.len = i
return b
}
function bn_copy(a: Big) -> Big {
let b: Big = bn_alloc(CAP)
let mut i: i64 = 0
while i < a.len {
b.d[i] = a.d[i]
i = i + 1
}
b.len = a.len
return b
}
# Compare a and b. Returns -1, 0, or 1.
function bn_cmp(a: Big, b: Big) -> i32 {
if a.len < b.len { return -1 }
if a.len > b.len { return 1 }
if a.len == 0 { return 0 }
let mut i: i64 = a.len - 1
while i >= 0 {
if a.d[i] < b.d[i] { return -1 }
if a.d[i] > b.d[i] { return 1 }
i = i - 1
}
return 0
}
# a += b (modifies a in place)
function bn_add(a: ptr<Big>, b: Big) -> void {
let mut i: i64 = 0
let mut carry: i64 = 0
while i < a[0].len || i < b.len || carry > 0 {
let mut v: i64 = carry
if i < a[0].len {
v = v + a[0].d[i]
}
if i < b.len {
v = v + b.d[i]
}
a[0].d[i] = v % BASE
carry = v / BASE
i = i + 1
}
a[0].len = i
while a[0].len > 0 && a[0].d[a[0].len - 1] == 0 {
a[0].len = a[0].len - 1
}
}
# a -= b (modifies a in place, assumes a >= b)
function bn_sub(a: ptr<Big>, b: Big) -> void {
let mut i: i64 = 0
let mut borrow: i64 = 0
while i < a[0].len {
let mut v: i64 = a[0].d[i] - borrow
if i < b.len {
v = v - b.d[i]
}
if v < 0 {
v = v + BASE
borrow = 1
} else {
borrow = 0
}
a[0].d[i] = v
i = i + 1
}
while a[0].len > 0 && a[0].d[a[0].len - 1] == 0 {
a[0].len = a[0].len - 1
}
}
# a *= v (modifies a in place)
function bn_mul_small(a: ptr<Big>, v: i64) -> void {
if v == 0 {
a[0].len = 0
return
}
let mut carry: i64 = 0
let mut i: i64 = 0
while i < a[0].len {
let v128: i128 = (a[0].d[i] as i128) * (v as i128) + (carry as i128)
a[0].d[i] = (v128 % (BASE as i128)) as i64
carry = (v128 / (BASE as i128)) as i64
i = i + 1
}
while carry > 0 {
a[0].d[a[0].len] = carry % BASE
carry = carry / BASE
a[0].len = a[0].len + 1
}
}
# a /= v, returns remainder. (modifies a in place)
function bn_div_small(a: ptr<Big>, v: i64) -> i64 {
let mut rem: i64 = 0
let mut i: i64 = a[0].len - 1
while i >= 0 {
let cur: i64 = rem * BASE + a[0].d[i]
a[0].d[i] = cur / v
rem = cur % v
i = i - 1
}
while a[0].len > 0 && a[0].d[a[0].len - 1] == 0 {
a[0].len = a[0].len - 1
}
return rem
}
# Returns a * b as a new Big.
function bn_mul(a: Big, b: Big) -> Big {
let result: Big = bn_alloc(CAP)
let mut i: i64 = 0
while i < a.len {
let mut carry: i64 = 0
let mut k: i64 = 0
while k < b.len {
let idx: i64 = i + k
let v: i64 = result.d[idx] + a.d[i] * b.d[k] + carry
result.d[idx] = v % BASE
carry = v / BASE
k = k + 1
}
let mut idx: i64 = i + b.len
while carry > 0 {
let v: i64 = result.d[idx] + carry
result.d[idx] = v % BASE
carry = v / BASE
idx = idx + 1
}
i = i + 1
}
result.len = a.len + b.len
while result.len > 0 && result.d[result.len - 1] == 0 {
result.len = result.len - 1
}
return result
}
# Compute base^exp as a Big.
function bn_pow_small(base: i64, exp: i64) -> Big {
let result: Big = bn_from_i64(1)
let mut i: i64 = 0
while i < exp {
bn_mul_small(&result, base)
i = i + 1
}
return result
}
function main() -> i32 {
let n: i64 = 80
let m: i64 = 2 * n - 1
# total = sum_{j=0..n-1} (-1)^j * C(2n, j) * (n-j)^m
# Split into pos (even j) and neg (odd j), then total = pos - neg.
let mut pos: Big = bn_from_i64(0)
let mut neg: Big = bn_from_i64(0)
# C(2n, j) computed incrementally as a bignum.
let mut binom: Big = bn_from_i64(1)
let mut j: i64 = 0
while j < n {
let power: Big = bn_pow_small(n - j, m)
let term: Big = bn_mul(binom, power)
free(power.d)
if j % 2 == 0 {
bn_add(&pos, term)
} else {
bn_add(&neg, term)
}
free(term.d)
# Update binom: C(2n, j+1) = C(2n, j) * (2n - j) / (j + 1)
if j + 1 < n {
bn_mul_small(&binom, 2 * n - j)
let rem: i64 = bn_div_small(&binom, j + 1)
}
j = j + 1
}
# total = pos - neg
let mut total: Big = bn_copy(pos)
bn_sub(&total, neg)
free(pos.d)
free(neg.d)
free(binom.d)
# den = m!
let mut den: Big = bn_from_i64(1)
let mut i: i64 = 2
while i <= m {
bn_mul_small(&den, i)
i = i + 1
}
# scaled = total * 10^10
let mut scaled: Big = bn_copy(total)
bn_mul_small(&scaled, 10000000000)
free(total.d)
# Binary search for q = floor(scaled / den)
let mut lo: i64 = 0
let mut hi: i64 = 100000000000
while lo < hi {
let mid: i64 = (lo + hi + 1) / 2
let temp: Big = bn_copy(den)
bn_mul_small(&temp, mid)
if bn_cmp(temp, scaled) <= 0 {
lo = mid
} else {
hi = mid - 1
}
free(temp.d)
}
let q: i64 = lo
# r = scaled - q * den
let qden: Big = bn_copy(den)
bn_mul_small(&qden, q)
let mut r: Big = bn_copy(scaled)
bn_sub(&r, qden)
free(qden.d)
free(scaled.d)
# Check if 2*r >= den -> round up
bn_mul_small(&r, 2)
let mut qv: i64 = q
if bn_cmp(r, den) >= 0 {
qv = q + 1
}
let int_part: i64 = qv / 10000000000
let frac_part: i64 = qv % 10000000000
printf("%lld.%010lld\n", int_part, frac_part)
free(r.d)
free(den.d)
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 {
int64_t* d;
int64_t len;
};
Big bn_alloc_i64(int64_t cap);
Big bn_from_i64_i64(int64_t v);
Big bn_copy_Big(Big a);
int32_t bn_cmp_Big_Big(Big a, Big b);
void bn_add_ptr_Big_Big(Big* a, Big b);
void bn_sub_ptr_Big_Big(Big* a, Big b);
void bn_mul_small_ptr_Big_i64(Big* a, int64_t v);
int64_t bn_div_small_ptr_Big_i64(Big* a, int64_t v);
Big bn_mul_Big_Big(Big a, Big b);
Big bn_pow_small_i64_i64(int64_t base, int64_t exp);
int32_t main(void);
static const int64_t BASE = 1000000000;
static const int64_t CAP = 60;
Big bn_alloc_i64(int64_t cap) {
int64_t* d = (int64_t*)(((int64_t*)(calloc(cap, 8))));
return (Big){ .d = d, .len = 0 };
}
Big bn_from_i64_i64(int64_t v) {
Big b = bn_alloc_i64(CAP);
if (v == 0) {
return b;
}
int64_t r = v;
int64_t i = 0;
while (r > 0) {
b.d[i] = FLOW_CHECKED_MOD((r), (BASE));
r = FLOW_CHECKED_DIV((r), (BASE));
i = (i + 1);
}
b.len = i;
return b;
}
Big bn_copy_Big(Big a) {
Big b = bn_alloc_i64(CAP);
int64_t i = 0;
while (i < a.len) {
b.d[i] = a.d[i];
i = (i + 1);
}
b.len = a.len;
return b;
}
int32_t bn_cmp_Big_Big(Big a, Big b) {
if (a.len < b.len) {
return (-1);
}
if (a.len > b.len) {
return 1;
}
if (a.len == 0) {
return 0;
}
int64_t i = (a.len - 1);
while (i >= 0) {
if (a.d[i] < b.d[i]) {
return (-1);
}
if (a.d[i] > b.d[i]) {
return 1;
}
i = (i - 1);
}
return 0;
}
void bn_add_ptr_Big_Big(Big* a, Big b) {
int64_t i = 0;
int64_t carry = 0;
while (((i < a[0].len || i < b.len) || carry > 0)) {
int64_t v = carry;
if (i < a[0].len) {
v = (v + a[0].d[i]);
}
if (i < b.len) {
v = (v + b.d[i]);
}
a[0].d[i] = FLOW_CHECKED_MOD((v), (BASE));
carry = FLOW_CHECKED_DIV((v), (BASE));
i = (i + 1);
}
a[0].len = i;
while ((a[0].len > 0 && a[0].d[(a[0].len - 1)] == 0)) {
a[0].len = (a[0].len - 1);
}
}
void bn_sub_ptr_Big_Big(Big* a, Big b) {
int64_t i = 0;
int64_t borrow = 0;
while (i < a[0].len) {
int64_t v = (a[0].d[i] - borrow);
if (i < b.len) {
v = (v - b.d[i]);
}
if (v < 0) {
v = (v + BASE);
borrow = 1;
} else {
borrow = 0;
}
a[0].d[i] = v;
i = (i + 1);
}
while ((a[0].len > 0 && a[0].d[(a[0].len - 1)] == 0)) {
a[0].len = (a[0].len - 1);
}
}
void bn_mul_small_ptr_Big_i64(Big* a, int64_t v) {
if (v == 0) {
a[0].len = 0;
return;
}
int64_t carry = 0;
int64_t i = 0;
while (i < a[0].len) {
__int128 v128 = ((((__int128)(a[0].d[i])) * ((__int128)(v))) + ((__int128)(carry)));
a[0].d[i] = ((int64_t)(FLOW_CHECKED_MOD((v128), (((__int128)(BASE))))));
carry = ((int64_t)(FLOW_CHECKED_DIV((v128), (((__int128)(BASE))))));
i = (i + 1);
}
while (carry > 0) {
a[0].d[a[0].len] = FLOW_CHECKED_MOD((carry), (BASE));
carry = FLOW_CHECKED_DIV((carry), (BASE));
a[0].len = (a[0].len + 1);
}
}
int64_t bn_div_small_ptr_Big_i64(Big* a, int64_t v) {
int64_t rem = 0;
int64_t i = (a[0].len - 1);
while (i >= 0) {
int64_t cur = ((rem * BASE) + a[0].d[i]);
a[0].d[i] = FLOW_CHECKED_DIV((cur), (v));
rem = FLOW_CHECKED_MOD((cur), (v));
i = (i - 1);
}
while ((a[0].len > 0 && a[0].d[(a[0].len - 1)] == 0)) {
a[0].len = (a[0].len - 1);
}
return rem;
}
Big bn_mul_Big_Big(Big a, Big b) {
Big result = bn_alloc_i64(CAP);
int64_t i = 0;
while (i < a.len) {
int64_t carry = 0;
int64_t k = 0;
while (k < b.len) {
int64_t idx = (i + k);
int64_t v = ((result.d[idx] + (a.d[i] * b.d[k])) + carry);
result.d[idx] = FLOW_CHECKED_MOD((v), (BASE));
carry = FLOW_CHECKED_DIV((v), (BASE));
k = (k + 1);
}
int64_t idx = (i + b.len);
while (carry > 0) {
int64_t v = (result.d[idx] + carry);
result.d[idx] = FLOW_CHECKED_MOD((v), (BASE));
carry = FLOW_CHECKED_DIV((v), (BASE));
idx = (idx + 1);
}
i = (i + 1);
}
result.len = (a.len + b.len);
while ((result.len > 0 && result.d[(result.len - 1)] == 0)) {
result.len = (result.len - 1);
}
return result;
}
Big bn_pow_small_i64_i64(int64_t base, int64_t exp) {
Big result = bn_from_i64_i64(1);
int64_t i = 0;
while (i < exp) {
bn_mul_small_ptr_Big_i64((&(result)), base);
i = (i + 1);
}
return result;
}
int32_t main(void) {
int64_t n = 80;
int64_t m = ((2 * n) - 1);
Big pos = bn_from_i64_i64(0);
Big neg = bn_from_i64_i64(0);
Big binom = bn_from_i64_i64(1);
int64_t j = 0;
while (j < n) {
Big power = bn_pow_small_i64_i64((n - j), m);
Big term = bn_mul_Big_Big(binom, power);
free(power.d);
if (FLOW_CHECKED_MOD((j), (2)) == 0) {
bn_add_ptr_Big_Big((&(pos)), term);
} else {
bn_add_ptr_Big_Big((&(neg)), term);
}
free(term.d);
if ((j + 1) < n) {
bn_mul_small_ptr_Big_i64((&(binom)), ((2 * n) - j));
int64_t rem = bn_div_small_ptr_Big_i64((&(binom)), (j + 1));
}
j = (j + 1);
}
Big total = bn_copy_Big(pos);
bn_sub_ptr_Big_Big((&(total)), neg);
free(pos.d);
free(neg.d);
free(binom.d);
Big den = bn_from_i64_i64(1);
int64_t i = 2;
while (i <= m) {
bn_mul_small_ptr_Big_i64((&(den)), i);
i = (i + 1);
}
Big scaled = bn_copy_Big(total);
bn_mul_small_ptr_Big_i64((&(scaled)), 10000000000);
free(total.d);
int64_t lo = 0;
int64_t hi = 100000000000;
while (lo < hi) {
int64_t mid = FLOW_CHECKED_DIV((((lo + hi) + 1)), (2));
Big temp = bn_copy_Big(den);
bn_mul_small_ptr_Big_i64((&(temp)), mid);
if (bn_cmp_Big_Big(temp, scaled) <= 0) {
lo = mid;
} else {
hi = (mid - 1);
}
free(temp.d);
}
int64_t q = lo;
Big qden = bn_copy_Big(den);
bn_mul_small_ptr_Big_i64((&(qden)), q);
Big r = bn_copy_Big(scaled);
bn_sub_ptr_Big_Big((&(r)), qden);
free(qden.d);
free(scaled.d);
bn_mul_small_ptr_Big_i64((&(r)), 2);
int64_t qv = q;
if (bn_cmp_Big_Big(r, den) >= 0) {
qv = (q + 1);
}
int64_t int_part = FLOW_CHECKED_DIV((qv), (10000000000));
int64_t frac_part = FLOW_CHECKED_MOD((qv), (10000000000));
printf("%lld.%010lld\n", int_part, frac_part);
free(r.d);
free(den.d);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld.%010lld\n\00") {addr_space = 0 : i32} : !llvm.array<14 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
// Constant: BASE
llvm.mlir.global internal constant @BASE(1000000000 : i64) : i64
// Constant: CAP
llvm.mlir.global internal constant @CAP(60 : i64) : i64
// Struct: Big
// Fields:
// d: !llvm.ptr
// len: i64
func.func @bn_alloc(%arg0: i64) -> !llvm.struct<(!llvm.ptr, i64)> {
%1 = arith.constant 8 : i32
%2 = arith.extsi %1 : i32 to i64
%0 = func.call @calloc(%arg0, %2) : (i64, i64) -> !llvm.ptr
%3 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%4 = llvm.insertvalue %0, %3[0] : !llvm.struct<(!llvm.ptr, i64)>
%5 = arith.constant 0 : i32
%6 = arith.extsi %5 : i32 to i64
%7 = llvm.insertvalue %6, %4[1] : !llvm.struct<(!llvm.ptr, i64)>
%8 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%9 = llvm.extractvalue %7[0] : !llvm.struct<(!llvm.ptr, i64)>
%10 = llvm.insertvalue %9, %8[0] : !llvm.struct<(!llvm.ptr, i64)>
%11 = llvm.extractvalue %7[1] : !llvm.struct<(!llvm.ptr, i64)>
%12 = llvm.insertvalue %11, %10[1] : !llvm.struct<(!llvm.ptr, i64)>
%13 = llvm.mlir.constant(1 : i64) : i64
%14 = llvm.alloca %13 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %12, %14 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%15 = llvm.load %14 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %15 : !llvm.struct<(!llvm.ptr, i64)>
}
func.func @bn_from_i64(%arg0: i64) -> !llvm.struct<(!llvm.ptr, i64)> {
%17 = llvm.mlir.addressof @CAP : !llvm.ptr
%18 = llvm.load %17 : !llvm.ptr -> i64
%16 = func.call @bn_alloc(%18) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%19 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%20 = llvm.extractvalue %16[0] : !llvm.struct<(!llvm.ptr, i64)>
%21 = llvm.insertvalue %20, %19[0] : !llvm.struct<(!llvm.ptr, i64)>
%22 = llvm.extractvalue %16[1] : !llvm.struct<(!llvm.ptr, i64)>
%23 = llvm.insertvalue %22, %21[1] : !llvm.struct<(!llvm.ptr, i64)>
%24 = llvm.mlir.constant(1 : i64) : i64
%25 = llvm.alloca %24 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %23, %25 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%26 = llvm.load %25 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%27 = llvm.mlir.constant(1 : i64) : i64
%28 = llvm.alloca %27 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %26, %28 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%29 = arith.constant 0 : i32
%31 = arith.extsi %29 : i32 to i64
%30 = arith.cmpi eq, %arg0, %31 : i64
cf.cond_br %30, ^bb0, ^bb1
^bb0:
%32 = llvm.load %28 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%33 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%34 = llvm.extractvalue %32[0] : !llvm.struct<(!llvm.ptr, i64)>
%35 = llvm.insertvalue %34, %33[0] : !llvm.struct<(!llvm.ptr, i64)>
%36 = llvm.extractvalue %32[1] : !llvm.struct<(!llvm.ptr, i64)>
%37 = llvm.insertvalue %36, %35[1] : !llvm.struct<(!llvm.ptr, i64)>
%38 = llvm.mlir.constant(1 : i64) : i64
%39 = llvm.alloca %38 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %37, %39 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%40 = llvm.load %39 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %40 : !llvm.struct<(!llvm.ptr, i64)>
^bb1:
cf.br ^bb2
^bb2:
%41 = llvm.mlir.constant(1 : i64) : i64
%42 = llvm.alloca %41 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %42 : i64, !llvm.ptr
%43 = arith.constant 0 : i32
%44 = arith.extsi %43 : i32 to i64
%45 = llvm.mlir.constant(1 : i64) : i64
%46 = llvm.alloca %45 x i64 : (i64) -> !llvm.ptr
llvm.store %44, %46 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%47 = llvm.load %42 : !llvm.ptr -> i64
%48 = arith.constant 0 : i32
%50 = arith.extsi %48 : i32 to i64
%49 = arith.cmpi sgt, %47, %50 : i64
cf.cond_br %49, ^bb4, ^bb5
^bb4:
%51 = llvm.load %42 : !llvm.ptr -> i64
%52 = llvm.mlir.addressof @BASE : !llvm.ptr
%53 = llvm.load %52 : !llvm.ptr -> i64
%54 = arith.remsi %51, %53 : i64
%55 = llvm.load %28 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%56 = llvm.getelementptr %28[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%57 = llvm.load %56 : !llvm.ptr -> !llvm.ptr
%58 = llvm.load %46 : !llvm.ptr -> i64
%59 = llvm.getelementptr %57[%58] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %54, %59 : i64, !llvm.ptr
%60 = llvm.load %42 : !llvm.ptr -> i64
%61 = llvm.mlir.addressof @BASE : !llvm.ptr
%62 = llvm.load %61 : !llvm.ptr -> i64
%63 = arith.divsi %60, %62 : i64
llvm.store %63, %42 : i64, !llvm.ptr
%64 = llvm.load %46 : !llvm.ptr -> i64
%65 = arith.constant 1 : i32
%67 = arith.extsi %65 : i32 to i64
%66 = arith.addi %64, %67 : i64
llvm.store %66, %46 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
%68 = llvm.load %46 : !llvm.ptr -> i64
%69 = llvm.getelementptr %28[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %68, %69 : i64, !llvm.ptr
%70 = llvm.load %28 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%71 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%72 = llvm.extractvalue %70[0] : !llvm.struct<(!llvm.ptr, i64)>
%73 = llvm.insertvalue %72, %71[0] : !llvm.struct<(!llvm.ptr, i64)>
%74 = llvm.extractvalue %70[1] : !llvm.struct<(!llvm.ptr, i64)>
%75 = llvm.insertvalue %74, %73[1] : !llvm.struct<(!llvm.ptr, i64)>
%76 = llvm.mlir.constant(1 : i64) : i64
%77 = llvm.alloca %76 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %75, %77 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%78 = llvm.load %77 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %78 : !llvm.struct<(!llvm.ptr, i64)>
}
func.func @bn_copy(%arg0: !llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)> {
%79 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%80 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64)>
%81 = llvm.insertvalue %80, %79[0] : !llvm.struct<(!llvm.ptr, i64)>
%82 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64)>
%83 = llvm.insertvalue %82, %81[1] : !llvm.struct<(!llvm.ptr, i64)>
%84 = llvm.mlir.constant(1 : i64) : i64
%85 = llvm.alloca %84 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %83, %85 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%87 = llvm.mlir.addressof @CAP : !llvm.ptr
%88 = llvm.load %87 : !llvm.ptr -> i64
%86 = func.call @bn_alloc(%88) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%89 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%90 = llvm.extractvalue %86[0] : !llvm.struct<(!llvm.ptr, i64)>
%91 = llvm.insertvalue %90, %89[0] : !llvm.struct<(!llvm.ptr, i64)>
%92 = llvm.extractvalue %86[1] : !llvm.struct<(!llvm.ptr, i64)>
%93 = llvm.insertvalue %92, %91[1] : !llvm.struct<(!llvm.ptr, i64)>
%94 = llvm.mlir.constant(1 : i64) : i64
%95 = llvm.alloca %94 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %93, %95 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%96 = llvm.load %95 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%97 = llvm.mlir.constant(1 : i64) : i64
%98 = llvm.alloca %97 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %96, %98 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%99 = arith.constant 0 : i32
%100 = arith.extsi %99 : i32 to i64
%101 = llvm.mlir.constant(1 : i64) : i64
%102 = llvm.alloca %101 x i64 : (i64) -> !llvm.ptr
llvm.store %100, %102 : i64, !llvm.ptr
cf.br ^bb6
^bb6:
%103 = llvm.load %102 : !llvm.ptr -> i64
%104 = llvm.load %85 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%105 = llvm.getelementptr %85[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%106 = llvm.load %105 : !llvm.ptr -> i64
%107 = arith.cmpi slt, %103, %106 : i64
cf.cond_br %107, ^bb7, ^bb8
^bb7:
%109 = llvm.load %85 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%110 = llvm.getelementptr %85[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%111 = llvm.load %110 : !llvm.ptr -> !llvm.ptr
%112 = llvm.load %102 : !llvm.ptr -> i64
%113 = llvm.getelementptr %111[%112] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%108 = llvm.load %113 : !llvm.ptr -> i64
%114 = llvm.load %98 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%115 = llvm.getelementptr %98[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%116 = llvm.load %115 : !llvm.ptr -> !llvm.ptr
%117 = llvm.load %102 : !llvm.ptr -> i64
%118 = llvm.getelementptr %116[%117] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %108, %118 : i64, !llvm.ptr
%119 = llvm.load %102 : !llvm.ptr -> i64
%120 = arith.constant 1 : i32
%122 = arith.extsi %120 : i32 to i64
%121 = arith.addi %119, %122 : i64
llvm.store %121, %102 : i64, !llvm.ptr
cf.br ^bb6
^bb8:
%123 = llvm.load %85 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%124 = llvm.getelementptr %85[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%125 = llvm.load %124 : !llvm.ptr -> i64
%126 = llvm.getelementptr %98[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %125, %126 : i64, !llvm.ptr
%127 = llvm.load %98 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%128 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%129 = llvm.extractvalue %127[0] : !llvm.struct<(!llvm.ptr, i64)>
%130 = llvm.insertvalue %129, %128[0] : !llvm.struct<(!llvm.ptr, i64)>
%131 = llvm.extractvalue %127[1] : !llvm.struct<(!llvm.ptr, i64)>
%132 = llvm.insertvalue %131, %130[1] : !llvm.struct<(!llvm.ptr, i64)>
%133 = llvm.mlir.constant(1 : i64) : i64
%134 = llvm.alloca %133 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %132, %134 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%135 = llvm.load %134 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %135 : !llvm.struct<(!llvm.ptr, i64)>
}
func.func @bn_cmp(%arg0: !llvm.struct<(!llvm.ptr, i64)>, %arg1: !llvm.struct<(!llvm.ptr, i64)>) -> i32 {
%136 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%137 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64)>
%138 = llvm.insertvalue %137, %136[0] : !llvm.struct<(!llvm.ptr, i64)>
%139 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64)>
%140 = llvm.insertvalue %139, %138[1] : !llvm.struct<(!llvm.ptr, i64)>
%141 = llvm.mlir.constant(1 : i64) : i64
%142 = llvm.alloca %141 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %140, %142 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%143 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%144 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i64)>
%145 = llvm.insertvalue %144, %143[0] : !llvm.struct<(!llvm.ptr, i64)>
%146 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i64)>
%147 = llvm.insertvalue %146, %145[1] : !llvm.struct<(!llvm.ptr, i64)>
%148 = llvm.mlir.constant(1 : i64) : i64
%149 = llvm.alloca %148 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %147, %149 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%150 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%151 = llvm.getelementptr %142[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%152 = llvm.load %151 : !llvm.ptr -> i64
%153 = llvm.load %149 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%154 = llvm.getelementptr %149[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%155 = llvm.load %154 : !llvm.ptr -> i64
%156 = arith.cmpi slt, %152, %155 : i64
cf.cond_br %156, ^bb9, ^bb10
^bb9:
%157 = arith.constant 1 : i32
%159 = arith.constant 0 : i32
%158 = arith.subi %159, %157 : i32
func.return %158 : i32
^bb10:
cf.br ^bb11
^bb11:
%160 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%161 = llvm.getelementptr %142[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%162 = llvm.load %161 : !llvm.ptr -> i64
%163 = llvm.load %149 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%164 = llvm.getelementptr %149[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%165 = llvm.load %164 : !llvm.ptr -> i64
%166 = arith.cmpi sgt, %162, %165 : i64
cf.cond_br %166, ^bb12, ^bb13
^bb12:
%167 = arith.constant 1 : i32
func.return %167 : i32
^bb13:
cf.br ^bb14
^bb14:
%168 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%169 = llvm.getelementptr %142[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%170 = llvm.load %169 : !llvm.ptr -> i64
%171 = arith.constant 0 : i32
%173 = arith.extsi %171 : i32 to i64
%172 = arith.cmpi eq, %170, %173 : i64
cf.cond_br %172, ^bb15, ^bb16
^bb15:
%174 = arith.constant 0 : i32
func.return %174 : i32
^bb16:
cf.br ^bb17
^bb17:
%175 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%176 = llvm.getelementptr %142[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%177 = llvm.load %176 : !llvm.ptr -> i64
%178 = arith.constant 1 : i32
%180 = arith.extsi %178 : i32 to i64
%179 = arith.subi %177, %180 : i64
%181 = llvm.mlir.constant(1 : i64) : i64
%182 = llvm.alloca %181 x i64 : (i64) -> !llvm.ptr
llvm.store %179, %182 : i64, !llvm.ptr
cf.br ^bb18
^bb18:
%183 = llvm.load %182 : !llvm.ptr -> i64
%184 = arith.constant 0 : i32
%186 = arith.extsi %184 : i32 to i64
%185 = arith.cmpi sge, %183, %186 : i64
cf.cond_br %185, ^bb19, ^bb20
^bb19:
%188 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%189 = llvm.getelementptr %142[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%190 = llvm.load %189 : !llvm.ptr -> !llvm.ptr
%191 = llvm.load %182 : !llvm.ptr -> i64
%192 = llvm.getelementptr %190[%191] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%187 = llvm.load %192 : !llvm.ptr -> i64
%194 = llvm.load %149 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%195 = llvm.getelementptr %149[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%196 = llvm.load %195 : !llvm.ptr -> !llvm.ptr
%197 = llvm.load %182 : !llvm.ptr -> i64
%198 = llvm.getelementptr %196[%197] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%193 = llvm.load %198 : !llvm.ptr -> i64
%199 = arith.cmpi slt, %187, %193 : i64
cf.cond_br %199, ^bb21, ^bb22
^bb21:
%200 = arith.constant 1 : i32
%202 = arith.constant 0 : i32
%201 = arith.subi %202, %200 : i32
func.return %201 : i32
^bb22:
cf.br ^bb23
^bb23:
%204 = llvm.load %142 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%205 = llvm.getelementptr %142[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%206 = llvm.load %205 : !llvm.ptr -> !llvm.ptr
%207 = llvm.load %182 : !llvm.ptr -> i64
%208 = llvm.getelementptr %206[%207] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%203 = llvm.load %208 : !llvm.ptr -> i64
%210 = llvm.load %149 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%211 = llvm.getelementptr %149[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%212 = llvm.load %211 : !llvm.ptr -> !llvm.ptr
%213 = llvm.load %182 : !llvm.ptr -> i64
%214 = llvm.getelementptr %212[%213] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%209 = llvm.load %214 : !llvm.ptr -> i64
%215 = arith.cmpi sgt, %203, %209 : i64
cf.cond_br %215, ^bb24, ^bb25
^bb24:
%216 = arith.constant 1 : i32
func.return %216 : i32
^bb25:
cf.br ^bb26
^bb26:
%217 = llvm.load %182 : !llvm.ptr -> i64
%218 = arith.constant 1 : i32
%220 = arith.extsi %218 : i32 to i64
%219 = arith.subi %217, %220 : i64
llvm.store %219, %182 : i64, !llvm.ptr
cf.br ^bb18
^bb20:
%221 = arith.constant 0 : i32
func.return %221 : i32
}
func.func @bn_add(%arg0: !llvm.ptr, %arg1: !llvm.struct<(!llvm.ptr, i64)>) -> () {
%222 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%223 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i64)>
%224 = llvm.insertvalue %223, %222[0] : !llvm.struct<(!llvm.ptr, i64)>
%225 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i64)>
%226 = llvm.insertvalue %225, %224[1] : !llvm.struct<(!llvm.ptr, i64)>
%227 = llvm.mlir.constant(1 : i64) : i64
%228 = llvm.alloca %227 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %226, %228 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%229 = arith.constant 0 : i32
%230 = arith.extsi %229 : i32 to i64
%231 = llvm.mlir.constant(1 : i64) : i64
%232 = llvm.alloca %231 x i64 : (i64) -> !llvm.ptr
llvm.store %230, %232 : i64, !llvm.ptr
%233 = arith.constant 0 : i32
%234 = arith.extsi %233 : i32 to i64
%235 = llvm.mlir.constant(1 : i64) : i64
%236 = llvm.alloca %235 x i64 : (i64) -> !llvm.ptr
llvm.store %234, %236 : i64, !llvm.ptr
cf.br ^bb27
^bb27:
%237 = llvm.load %232 : !llvm.ptr -> i64
%239 = arith.constant 0 : i32
%240 = arith.extsi %239 : i32 to i64
%241 = llvm.getelementptr %arg0[%240] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%238 = llvm.load %241 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%242 = arith.constant 0 : i32
%243 = arith.extsi %242 : i32 to i64
%244 = llvm.getelementptr %arg0[%243] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%245 = llvm.getelementptr %244[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%246 = llvm.load %245 : !llvm.ptr -> i64
%247 = arith.cmpi slt, %237, %246 : i64
%248 = scf.if %247 -> (i1) {
%249 = arith.constant true
scf.yield %249 : i1
} else {
%250 = llvm.load %232 : !llvm.ptr -> i64
%251 = llvm.load %228 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%252 = llvm.getelementptr %228[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%253 = llvm.load %252 : !llvm.ptr -> i64
%254 = arith.cmpi slt, %250, %253 : i64
scf.yield %254 : i1
}
%255 = scf.if %248 -> (i1) {
%256 = arith.constant true
scf.yield %256 : i1
} else {
%257 = llvm.load %236 : !llvm.ptr -> i64
%258 = arith.constant 0 : i32
%260 = arith.extsi %258 : i32 to i64
%259 = arith.cmpi sgt, %257, %260 : i64
scf.yield %259 : i1
}
cf.cond_br %255, ^bb28, ^bb29
^bb28:
%261 = llvm.load %236 : !llvm.ptr -> i64
%262 = llvm.mlir.constant(1 : i64) : i64
%263 = llvm.alloca %262 x i64 : (i64) -> !llvm.ptr
llvm.store %261, %263 : i64, !llvm.ptr
%264 = llvm.load %232 : !llvm.ptr -> i64
%266 = arith.constant 0 : i32
%267 = arith.extsi %266 : i32 to i64
%268 = llvm.getelementptr %arg0[%267] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%265 = llvm.load %268 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%269 = arith.constant 0 : i32
%270 = arith.extsi %269 : i32 to i64
%271 = llvm.getelementptr %arg0[%270] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%272 = llvm.getelementptr %271[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%273 = llvm.load %272 : !llvm.ptr -> i64
%274 = arith.cmpi slt, %264, %273 : i64
cf.cond_br %274, ^bb30, ^bb31
^bb30:
%275 = llvm.load %263 : !llvm.ptr -> i64
%278 = arith.constant 0 : i32
%279 = arith.extsi %278 : i32 to i64
%280 = llvm.getelementptr %arg0[%279] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%277 = llvm.load %280 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%281 = arith.constant 0 : i32
%282 = arith.extsi %281 : i32 to i64
%283 = llvm.getelementptr %arg0[%282] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%284 = llvm.getelementptr %283[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%285 = llvm.load %284 : !llvm.ptr -> !llvm.ptr
%286 = llvm.load %232 : !llvm.ptr -> i64
%287 = llvm.getelementptr %285[%286] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%276 = llvm.load %287 : !llvm.ptr -> i64
%288 = arith.addi %275, %276 : i64
llvm.store %288, %263 : i64, !llvm.ptr
cf.br ^bb32
^bb31:
cf.br ^bb32
^bb32:
%289 = llvm.load %232 : !llvm.ptr -> i64
%290 = llvm.load %228 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%291 = llvm.getelementptr %228[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%292 = llvm.load %291 : !llvm.ptr -> i64
%293 = arith.cmpi slt, %289, %292 : i64
cf.cond_br %293, ^bb33, ^bb34
^bb33:
%294 = llvm.load %263 : !llvm.ptr -> i64
%296 = llvm.load %228 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%297 = llvm.getelementptr %228[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%298 = llvm.load %297 : !llvm.ptr -> !llvm.ptr
%299 = llvm.load %232 : !llvm.ptr -> i64
%300 = llvm.getelementptr %298[%299] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%295 = llvm.load %300 : !llvm.ptr -> i64
%301 = arith.addi %294, %295 : i64
llvm.store %301, %263 : i64, !llvm.ptr
cf.br ^bb35
^bb34:
cf.br ^bb35
^bb35:
%302 = llvm.load %263 : !llvm.ptr -> i64
%303 = llvm.mlir.addressof @BASE : !llvm.ptr
%304 = llvm.load %303 : !llvm.ptr -> i64
%305 = arith.remsi %302, %304 : i64
%307 = arith.constant 0 : i32
%308 = arith.extsi %307 : i32 to i64
%309 = llvm.getelementptr %arg0[%308] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%306 = llvm.load %309 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%310 = arith.constant 0 : i32
%311 = arith.extsi %310 : i32 to i64
%312 = llvm.getelementptr %arg0[%311] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%313 = llvm.getelementptr %312[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%314 = llvm.load %313 : !llvm.ptr -> !llvm.ptr
%315 = llvm.load %232 : !llvm.ptr -> i64
%316 = llvm.getelementptr %314[%315] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %305, %316 : i64, !llvm.ptr
%317 = llvm.load %263 : !llvm.ptr -> i64
%318 = llvm.mlir.addressof @BASE : !llvm.ptr
%319 = llvm.load %318 : !llvm.ptr -> i64
%320 = arith.divsi %317, %319 : i64
llvm.store %320, %236 : i64, !llvm.ptr
%321 = llvm.load %232 : !llvm.ptr -> i64
%322 = arith.constant 1 : i32
%324 = arith.extsi %322 : i32 to i64
%323 = arith.addi %321, %324 : i64
llvm.store %323, %232 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
%325 = llvm.load %232 : !llvm.ptr -> i64
%326 = arith.constant 0 : i32
%327 = arith.extsi %326 : i32 to i64
%328 = llvm.getelementptr %arg0[%327] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%329 = llvm.getelementptr %328[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %325, %329 : i64, !llvm.ptr
cf.br ^bb36
^bb36:
%331 = arith.constant 0 : i32
%332 = arith.extsi %331 : i32 to i64
%333 = llvm.getelementptr %arg0[%332] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%330 = llvm.load %333 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%334 = arith.constant 0 : i32
%335 = arith.extsi %334 : i32 to i64
%336 = llvm.getelementptr %arg0[%335] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%337 = llvm.getelementptr %336[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%338 = llvm.load %337 : !llvm.ptr -> i64
%339 = arith.constant 0 : i32
%341 = arith.extsi %339 : i32 to i64
%340 = arith.cmpi sgt, %338, %341 : i64
%342 = scf.if %340 -> (i1) {
%345 = arith.constant 0 : i32
%346 = arith.extsi %345 : i32 to i64
%347 = llvm.getelementptr %arg0[%346] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%344 = llvm.load %347 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%348 = arith.constant 0 : i32
%349 = arith.extsi %348 : i32 to i64
%350 = llvm.getelementptr %arg0[%349] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%351 = llvm.getelementptr %350[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%352 = llvm.load %351 : !llvm.ptr -> !llvm.ptr
%354 = arith.constant 0 : i32
%355 = arith.extsi %354 : i32 to i64
%356 = llvm.getelementptr %arg0[%355] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%353 = llvm.load %356 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%357 = arith.constant 0 : i32
%358 = arith.extsi %357 : i32 to i64
%359 = llvm.getelementptr %arg0[%358] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%360 = llvm.getelementptr %359[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%361 = llvm.load %360 : !llvm.ptr -> i64
%362 = arith.constant 1 : i32
%364 = arith.extsi %362 : i32 to i64
%363 = arith.subi %361, %364 : i64
%365 = llvm.getelementptr %352[%363] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%343 = llvm.load %365 : !llvm.ptr -> i64
%366 = arith.constant 0 : i32
%368 = arith.extsi %366 : i32 to i64
%367 = arith.cmpi eq, %343, %368 : i64
scf.yield %367 : i1
} else {
%369 = arith.constant false
scf.yield %369 : i1
}
cf.cond_br %342, ^bb37, ^bb38
^bb37:
%371 = arith.constant 0 : i32
%372 = arith.extsi %371 : i32 to i64
%373 = llvm.getelementptr %arg0[%372] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%370 = llvm.load %373 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%374 = arith.constant 0 : i32
%375 = arith.extsi %374 : i32 to i64
%376 = llvm.getelementptr %arg0[%375] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%377 = llvm.getelementptr %376[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%378 = llvm.load %377 : !llvm.ptr -> i64
%379 = arith.constant 1 : i32
%381 = arith.extsi %379 : i32 to i64
%380 = arith.subi %378, %381 : i64
%382 = arith.constant 0 : i32
%383 = arith.extsi %382 : i32 to i64
%384 = llvm.getelementptr %arg0[%383] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%385 = llvm.getelementptr %384[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %380, %385 : i64, !llvm.ptr
cf.br ^bb36
^bb38:
func.return
}
func.func @bn_sub(%arg0: !llvm.ptr, %arg1: !llvm.struct<(!llvm.ptr, i64)>) -> () {
%386 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%387 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i64)>
%388 = llvm.insertvalue %387, %386[0] : !llvm.struct<(!llvm.ptr, i64)>
%389 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i64)>
%390 = llvm.insertvalue %389, %388[1] : !llvm.struct<(!llvm.ptr, i64)>
%391 = llvm.mlir.constant(1 : i64) : i64
%392 = llvm.alloca %391 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %390, %392 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%393 = arith.constant 0 : i32
%394 = arith.extsi %393 : i32 to i64
%395 = llvm.mlir.constant(1 : i64) : i64
%396 = llvm.alloca %395 x i64 : (i64) -> !llvm.ptr
llvm.store %394, %396 : i64, !llvm.ptr
%397 = arith.constant 0 : i32
%398 = arith.extsi %397 : i32 to i64
%399 = llvm.mlir.constant(1 : i64) : i64
%400 = llvm.alloca %399 x i64 : (i64) -> !llvm.ptr
llvm.store %398, %400 : i64, !llvm.ptr
cf.br ^bb39
^bb39:
%401 = llvm.load %396 : !llvm.ptr -> i64
%403 = arith.constant 0 : i32
%404 = arith.extsi %403 : i32 to i64
%405 = llvm.getelementptr %arg0[%404] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%402 = llvm.load %405 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%406 = arith.constant 0 : i32
%407 = arith.extsi %406 : i32 to i64
%408 = llvm.getelementptr %arg0[%407] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%409 = llvm.getelementptr %408[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%410 = llvm.load %409 : !llvm.ptr -> i64
%411 = arith.cmpi slt, %401, %410 : i64
cf.cond_br %411, ^bb40, ^bb41
^bb40:
%414 = arith.constant 0 : i32
%415 = arith.extsi %414 : i32 to i64
%416 = llvm.getelementptr %arg0[%415] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%413 = llvm.load %416 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%417 = arith.constant 0 : i32
%418 = arith.extsi %417 : i32 to i64
%419 = llvm.getelementptr %arg0[%418] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%420 = llvm.getelementptr %419[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%421 = llvm.load %420 : !llvm.ptr -> !llvm.ptr
%422 = llvm.load %396 : !llvm.ptr -> i64
%423 = llvm.getelementptr %421[%422] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%412 = llvm.load %423 : !llvm.ptr -> i64
%424 = llvm.load %400 : !llvm.ptr -> i64
%425 = arith.subi %412, %424 : i64
%426 = llvm.mlir.constant(1 : i64) : i64
%427 = llvm.alloca %426 x i64 : (i64) -> !llvm.ptr
llvm.store %425, %427 : i64, !llvm.ptr
%428 = llvm.load %396 : !llvm.ptr -> i64
%429 = llvm.load %392 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%430 = llvm.getelementptr %392[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%431 = llvm.load %430 : !llvm.ptr -> i64
%432 = arith.cmpi slt, %428, %431 : i64
cf.cond_br %432, ^bb42, ^bb43
^bb42:
%433 = llvm.load %427 : !llvm.ptr -> i64
%435 = llvm.load %392 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%436 = llvm.getelementptr %392[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%437 = llvm.load %436 : !llvm.ptr -> !llvm.ptr
%438 = llvm.load %396 : !llvm.ptr -> i64
%439 = llvm.getelementptr %437[%438] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%434 = llvm.load %439 : !llvm.ptr -> i64
%440 = arith.subi %433, %434 : i64
llvm.store %440, %427 : i64, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%441 = llvm.load %427 : !llvm.ptr -> i64
%442 = arith.constant 0 : i32
%444 = arith.extsi %442 : i32 to i64
%443 = arith.cmpi slt, %441, %444 : i64
cf.cond_br %443, ^bb45, ^bb46
^bb45:
%445 = llvm.load %427 : !llvm.ptr -> i64
%446 = llvm.mlir.addressof @BASE : !llvm.ptr
%447 = llvm.load %446 : !llvm.ptr -> i64
%448 = arith.addi %445, %447 : i64
llvm.store %448, %427 : i64, !llvm.ptr
%449 = arith.constant 1 : i32
%450 = arith.extsi %449 : i32 to i64
llvm.store %450, %400 : i64, !llvm.ptr
cf.br ^bb47
^bb46:
%451 = arith.constant 0 : i32
%452 = arith.extsi %451 : i32 to i64
llvm.store %452, %400 : i64, !llvm.ptr
cf.br ^bb47
^bb47:
%453 = llvm.load %427 : !llvm.ptr -> i64
%455 = arith.constant 0 : i32
%456 = arith.extsi %455 : i32 to i64
%457 = llvm.getelementptr %arg0[%456] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%454 = llvm.load %457 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%458 = arith.constant 0 : i32
%459 = arith.extsi %458 : i32 to i64
%460 = llvm.getelementptr %arg0[%459] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%461 = llvm.getelementptr %460[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%462 = llvm.load %461 : !llvm.ptr -> !llvm.ptr
%463 = llvm.load %396 : !llvm.ptr -> i64
%464 = llvm.getelementptr %462[%463] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %453, %464 : i64, !llvm.ptr
%465 = llvm.load %396 : !llvm.ptr -> i64
%466 = arith.constant 1 : i32
%468 = arith.extsi %466 : i32 to i64
%467 = arith.addi %465, %468 : i64
llvm.store %467, %396 : i64, !llvm.ptr
cf.br ^bb39
^bb41:
cf.br ^bb48
^bb48:
%470 = arith.constant 0 : i32
%471 = arith.extsi %470 : i32 to i64
%472 = llvm.getelementptr %arg0[%471] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%469 = llvm.load %472 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%473 = arith.constant 0 : i32
%474 = arith.extsi %473 : i32 to i64
%475 = llvm.getelementptr %arg0[%474] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%476 = llvm.getelementptr %475[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%477 = llvm.load %476 : !llvm.ptr -> i64
%478 = arith.constant 0 : i32
%480 = arith.extsi %478 : i32 to i64
%479 = arith.cmpi sgt, %477, %480 : i64
%481 = scf.if %479 -> (i1) {
%484 = arith.constant 0 : i32
%485 = arith.extsi %484 : i32 to i64
%486 = llvm.getelementptr %arg0[%485] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%483 = llvm.load %486 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%487 = arith.constant 0 : i32
%488 = arith.extsi %487 : i32 to i64
%489 = llvm.getelementptr %arg0[%488] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%490 = llvm.getelementptr %489[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%491 = llvm.load %490 : !llvm.ptr -> !llvm.ptr
%493 = arith.constant 0 : i32
%494 = arith.extsi %493 : i32 to i64
%495 = llvm.getelementptr %arg0[%494] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%492 = llvm.load %495 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%496 = arith.constant 0 : i32
%497 = arith.extsi %496 : i32 to i64
%498 = llvm.getelementptr %arg0[%497] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%499 = llvm.getelementptr %498[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%500 = llvm.load %499 : !llvm.ptr -> i64
%501 = arith.constant 1 : i32
%503 = arith.extsi %501 : i32 to i64
%502 = arith.subi %500, %503 : i64
%504 = llvm.getelementptr %491[%502] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%482 = llvm.load %504 : !llvm.ptr -> i64
%505 = arith.constant 0 : i32
%507 = arith.extsi %505 : i32 to i64
%506 = arith.cmpi eq, %482, %507 : i64
scf.yield %506 : i1
} else {
%508 = arith.constant false
scf.yield %508 : i1
}
cf.cond_br %481, ^bb49, ^bb50
^bb49:
%510 = arith.constant 0 : i32
%511 = arith.extsi %510 : i32 to i64
%512 = llvm.getelementptr %arg0[%511] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%509 = llvm.load %512 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%513 = arith.constant 0 : i32
%514 = arith.extsi %513 : i32 to i64
%515 = llvm.getelementptr %arg0[%514] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%516 = llvm.getelementptr %515[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%517 = llvm.load %516 : !llvm.ptr -> i64
%518 = arith.constant 1 : i32
%520 = arith.extsi %518 : i32 to i64
%519 = arith.subi %517, %520 : i64
%521 = arith.constant 0 : i32
%522 = arith.extsi %521 : i32 to i64
%523 = llvm.getelementptr %arg0[%522] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%524 = llvm.getelementptr %523[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %519, %524 : i64, !llvm.ptr
cf.br ^bb48
^bb50:
func.return
}
func.func @bn_mul_small(%arg0: !llvm.ptr, %arg1: i64) -> () {
%525 = arith.constant 0 : i32
%527 = arith.extsi %525 : i32 to i64
%526 = arith.cmpi eq, %arg1, %527 : i64
cf.cond_br %526, ^bb51, ^bb52
^bb51:
%528 = arith.constant 0 : i32
%529 = arith.constant 0 : i32
%530 = arith.extsi %529 : i32 to i64
%531 = llvm.getelementptr %arg0[%530] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%532 = arith.extsi %528 : i32 to i64
%533 = llvm.getelementptr %531[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %532, %533 : i64, !llvm.ptr
func.return
^bb52:
cf.br ^bb53
^bb53:
%534 = arith.constant 0 : i32
%535 = arith.extsi %534 : i32 to i64
%536 = llvm.mlir.constant(1 : i64) : i64
%537 = llvm.alloca %536 x i64 : (i64) -> !llvm.ptr
llvm.store %535, %537 : i64, !llvm.ptr
%538 = arith.constant 0 : i32
%539 = arith.extsi %538 : i32 to i64
%540 = llvm.mlir.constant(1 : i64) : i64
%541 = llvm.alloca %540 x i64 : (i64) -> !llvm.ptr
llvm.store %539, %541 : i64, !llvm.ptr
cf.br ^bb54
^bb54:
%542 = llvm.load %541 : !llvm.ptr -> i64
%544 = arith.constant 0 : i32
%545 = arith.extsi %544 : i32 to i64
%546 = llvm.getelementptr %arg0[%545] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%543 = llvm.load %546 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%547 = arith.constant 0 : i32
%548 = arith.extsi %547 : i32 to i64
%549 = llvm.getelementptr %arg0[%548] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%550 = llvm.getelementptr %549[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%551 = llvm.load %550 : !llvm.ptr -> i64
%552 = arith.cmpi slt, %542, %551 : i64
cf.cond_br %552, ^bb55, ^bb56
^bb55:
%555 = arith.constant 0 : i32
%556 = arith.extsi %555 : i32 to i64
%557 = llvm.getelementptr %arg0[%556] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%554 = llvm.load %557 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%558 = arith.constant 0 : i32
%559 = arith.extsi %558 : i32 to i64
%560 = llvm.getelementptr %arg0[%559] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%561 = llvm.getelementptr %560[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%562 = llvm.load %561 : !llvm.ptr -> !llvm.ptr
%563 = llvm.load %541 : !llvm.ptr -> i64
%564 = llvm.getelementptr %562[%563] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%553 = llvm.load %564 : !llvm.ptr -> i64
%565 = arith.extsi %553 : i64 to i128
%566 = arith.extsi %arg1 : i64 to i128
%568 = arith.trunci %565 : i128 to i64
%569 = arith.trunci %566 : i128 to i64
%567 = arith.muli %568, %569 : i64
%570 = llvm.load %537 : !llvm.ptr -> i64
%571 = arith.extsi %570 : i64 to i128
%573 = arith.trunci %571 : i128 to i64
%572 = arith.addi %567, %573 : i64
%574 = arith.extsi %572 : i64 to i128
%575 = llvm.mlir.addressof @BASE : !llvm.ptr
%576 = llvm.load %575 : !llvm.ptr -> i64
%577 = arith.extsi %576 : i64 to i128
%579 = arith.trunci %574 : i128 to i64
%580 = arith.trunci %577 : i128 to i64
%578 = arith.remsi %579, %580 : i64
%582 = arith.constant 0 : i32
%583 = arith.extsi %582 : i32 to i64
%584 = llvm.getelementptr %arg0[%583] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%581 = llvm.load %584 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%585 = arith.constant 0 : i32
%586 = arith.extsi %585 : i32 to i64
%587 = llvm.getelementptr %arg0[%586] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%588 = llvm.getelementptr %587[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%589 = llvm.load %588 : !llvm.ptr -> !llvm.ptr
%590 = llvm.load %541 : !llvm.ptr -> i64
%591 = llvm.getelementptr %589[%590] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %578, %591 : i64, !llvm.ptr
%592 = llvm.mlir.addressof @BASE : !llvm.ptr
%593 = llvm.load %592 : !llvm.ptr -> i64
%594 = arith.extsi %593 : i64 to i128
%596 = arith.trunci %574 : i128 to i64
%597 = arith.trunci %594 : i128 to i64
%595 = arith.divsi %596, %597 : i64
llvm.store %595, %537 : i64, !llvm.ptr
%598 = llvm.load %541 : !llvm.ptr -> i64
%599 = arith.constant 1 : i32
%601 = arith.extsi %599 : i32 to i64
%600 = arith.addi %598, %601 : i64
llvm.store %600, %541 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
cf.br ^bb57
^bb57:
%602 = llvm.load %537 : !llvm.ptr -> i64
%603 = arith.constant 0 : i32
%605 = arith.extsi %603 : i32 to i64
%604 = arith.cmpi sgt, %602, %605 : i64
cf.cond_br %604, ^bb58, ^bb59
^bb58:
%606 = llvm.load %537 : !llvm.ptr -> i64
%607 = llvm.mlir.addressof @BASE : !llvm.ptr
%608 = llvm.load %607 : !llvm.ptr -> i64
%609 = arith.remsi %606, %608 : i64
%611 = arith.constant 0 : i32
%612 = arith.extsi %611 : i32 to i64
%613 = llvm.getelementptr %arg0[%612] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%610 = llvm.load %613 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%614 = arith.constant 0 : i32
%615 = arith.extsi %614 : i32 to i64
%616 = llvm.getelementptr %arg0[%615] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%617 = llvm.getelementptr %616[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%618 = llvm.load %617 : !llvm.ptr -> !llvm.ptr
%620 = arith.constant 0 : i32
%621 = arith.extsi %620 : i32 to i64
%622 = llvm.getelementptr %arg0[%621] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%619 = llvm.load %622 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%623 = arith.constant 0 : i32
%624 = arith.extsi %623 : i32 to i64
%625 = llvm.getelementptr %arg0[%624] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%626 = llvm.getelementptr %625[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%627 = llvm.load %626 : !llvm.ptr -> i64
%628 = llvm.getelementptr %618[%627] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %609, %628 : i64, !llvm.ptr
%629 = llvm.load %537 : !llvm.ptr -> i64
%630 = llvm.mlir.addressof @BASE : !llvm.ptr
%631 = llvm.load %630 : !llvm.ptr -> i64
%632 = arith.divsi %629, %631 : i64
llvm.store %632, %537 : i64, !llvm.ptr
%634 = arith.constant 0 : i32
%635 = arith.extsi %634 : i32 to i64
%636 = llvm.getelementptr %arg0[%635] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%633 = llvm.load %636 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%637 = arith.constant 0 : i32
%638 = arith.extsi %637 : i32 to i64
%639 = llvm.getelementptr %arg0[%638] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%640 = llvm.getelementptr %639[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%641 = llvm.load %640 : !llvm.ptr -> i64
%642 = arith.constant 1 : i32
%644 = arith.extsi %642 : i32 to i64
%643 = arith.addi %641, %644 : i64
%645 = arith.constant 0 : i32
%646 = arith.extsi %645 : i32 to i64
%647 = llvm.getelementptr %arg0[%646] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%648 = llvm.getelementptr %647[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %643, %648 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
func.return
}
func.func @bn_div_small(%arg0: !llvm.ptr, %arg1: i64) -> i64 {
%649 = arith.constant 0 : i32
%650 = arith.extsi %649 : i32 to i64
%651 = llvm.mlir.constant(1 : i64) : i64
%652 = llvm.alloca %651 x i64 : (i64) -> !llvm.ptr
llvm.store %650, %652 : i64, !llvm.ptr
%654 = arith.constant 0 : i32
%655 = arith.extsi %654 : i32 to i64
%656 = llvm.getelementptr %arg0[%655] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%653 = llvm.load %656 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%657 = arith.constant 0 : i32
%658 = arith.extsi %657 : i32 to i64
%659 = llvm.getelementptr %arg0[%658] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%660 = llvm.getelementptr %659[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%661 = llvm.load %660 : !llvm.ptr -> i64
%662 = arith.constant 1 : i32
%664 = arith.extsi %662 : i32 to i64
%663 = arith.subi %661, %664 : i64
%665 = llvm.mlir.constant(1 : i64) : i64
%666 = llvm.alloca %665 x i64 : (i64) -> !llvm.ptr
llvm.store %663, %666 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%667 = llvm.load %666 : !llvm.ptr -> i64
%668 = arith.constant 0 : i32
%670 = arith.extsi %668 : i32 to i64
%669 = arith.cmpi sge, %667, %670 : i64
cf.cond_br %669, ^bb61, ^bb62
^bb61:
%671 = llvm.load %652 : !llvm.ptr -> i64
%672 = llvm.mlir.addressof @BASE : !llvm.ptr
%673 = llvm.load %672 : !llvm.ptr -> i64
%674 = arith.muli %671, %673 : i64
%677 = arith.constant 0 : i32
%678 = arith.extsi %677 : i32 to i64
%679 = llvm.getelementptr %arg0[%678] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%676 = llvm.load %679 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%680 = arith.constant 0 : i32
%681 = arith.extsi %680 : i32 to i64
%682 = llvm.getelementptr %arg0[%681] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%683 = llvm.getelementptr %682[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%684 = llvm.load %683 : !llvm.ptr -> !llvm.ptr
%685 = llvm.load %666 : !llvm.ptr -> i64
%686 = llvm.getelementptr %684[%685] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%675 = llvm.load %686 : !llvm.ptr -> i64
%687 = arith.addi %674, %675 : i64
%688 = arith.divsi %687, %arg1 : i64
%690 = arith.constant 0 : i32
%691 = arith.extsi %690 : i32 to i64
%692 = llvm.getelementptr %arg0[%691] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%689 = llvm.load %692 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%693 = arith.constant 0 : i32
%694 = arith.extsi %693 : i32 to i64
%695 = llvm.getelementptr %arg0[%694] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%696 = llvm.getelementptr %695[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%697 = llvm.load %696 : !llvm.ptr -> !llvm.ptr
%698 = llvm.load %666 : !llvm.ptr -> i64
%699 = llvm.getelementptr %697[%698] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %688, %699 : i64, !llvm.ptr
%700 = arith.remsi %687, %arg1 : i64
llvm.store %700, %652 : i64, !llvm.ptr
%701 = llvm.load %666 : !llvm.ptr -> i64
%702 = arith.constant 1 : i32
%704 = arith.extsi %702 : i32 to i64
%703 = arith.subi %701, %704 : i64
llvm.store %703, %666 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
cf.br ^bb63
^bb63:
%706 = arith.constant 0 : i32
%707 = arith.extsi %706 : i32 to i64
%708 = llvm.getelementptr %arg0[%707] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%705 = llvm.load %708 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%709 = arith.constant 0 : i32
%710 = arith.extsi %709 : i32 to i64
%711 = llvm.getelementptr %arg0[%710] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%712 = llvm.getelementptr %711[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%713 = llvm.load %712 : !llvm.ptr -> i64
%714 = arith.constant 0 : i32
%716 = arith.extsi %714 : i32 to i64
%715 = arith.cmpi sgt, %713, %716 : i64
%717 = scf.if %715 -> (i1) {
%720 = arith.constant 0 : i32
%721 = arith.extsi %720 : i32 to i64
%722 = llvm.getelementptr %arg0[%721] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%719 = llvm.load %722 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%723 = arith.constant 0 : i32
%724 = arith.extsi %723 : i32 to i64
%725 = llvm.getelementptr %arg0[%724] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%726 = llvm.getelementptr %725[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%727 = llvm.load %726 : !llvm.ptr -> !llvm.ptr
%729 = arith.constant 0 : i32
%730 = arith.extsi %729 : i32 to i64
%731 = llvm.getelementptr %arg0[%730] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%728 = llvm.load %731 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%732 = arith.constant 0 : i32
%733 = arith.extsi %732 : i32 to i64
%734 = llvm.getelementptr %arg0[%733] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%735 = llvm.getelementptr %734[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%736 = llvm.load %735 : !llvm.ptr -> i64
%737 = arith.constant 1 : i32
%739 = arith.extsi %737 : i32 to i64
%738 = arith.subi %736, %739 : i64
%740 = llvm.getelementptr %727[%738] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%718 = llvm.load %740 : !llvm.ptr -> i64
%741 = arith.constant 0 : i32
%743 = arith.extsi %741 : i32 to i64
%742 = arith.cmpi eq, %718, %743 : i64
scf.yield %742 : i1
} else {
%744 = arith.constant false
scf.yield %744 : i1
}
cf.cond_br %717, ^bb64, ^bb65
^bb64:
%746 = arith.constant 0 : i32
%747 = arith.extsi %746 : i32 to i64
%748 = llvm.getelementptr %arg0[%747] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%745 = llvm.load %748 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%749 = arith.constant 0 : i32
%750 = arith.extsi %749 : i32 to i64
%751 = llvm.getelementptr %arg0[%750] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%752 = llvm.getelementptr %751[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%753 = llvm.load %752 : !llvm.ptr -> i64
%754 = arith.constant 1 : i32
%756 = arith.extsi %754 : i32 to i64
%755 = arith.subi %753, %756 : i64
%757 = arith.constant 0 : i32
%758 = arith.extsi %757 : i32 to i64
%759 = llvm.getelementptr %arg0[%758] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%760 = llvm.getelementptr %759[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %755, %760 : i64, !llvm.ptr
cf.br ^bb63
^bb65:
%761 = llvm.load %652 : !llvm.ptr -> i64
func.return %761 : i64
}
func.func @bn_mul(%arg0: !llvm.struct<(!llvm.ptr, i64)>, %arg1: !llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)> {
%762 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%763 = llvm.extractvalue %arg0[0] : !llvm.struct<(!llvm.ptr, i64)>
%764 = llvm.insertvalue %763, %762[0] : !llvm.struct<(!llvm.ptr, i64)>
%765 = llvm.extractvalue %arg0[1] : !llvm.struct<(!llvm.ptr, i64)>
%766 = llvm.insertvalue %765, %764[1] : !llvm.struct<(!llvm.ptr, i64)>
%767 = llvm.mlir.constant(1 : i64) : i64
%768 = llvm.alloca %767 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %766, %768 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%769 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%770 = llvm.extractvalue %arg1[0] : !llvm.struct<(!llvm.ptr, i64)>
%771 = llvm.insertvalue %770, %769[0] : !llvm.struct<(!llvm.ptr, i64)>
%772 = llvm.extractvalue %arg1[1] : !llvm.struct<(!llvm.ptr, i64)>
%773 = llvm.insertvalue %772, %771[1] : !llvm.struct<(!llvm.ptr, i64)>
%774 = llvm.mlir.constant(1 : i64) : i64
%775 = llvm.alloca %774 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %773, %775 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%777 = llvm.mlir.addressof @CAP : !llvm.ptr
%778 = llvm.load %777 : !llvm.ptr -> i64
%776 = func.call @bn_alloc(%778) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%779 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%780 = llvm.extractvalue %776[0] : !llvm.struct<(!llvm.ptr, i64)>
%781 = llvm.insertvalue %780, %779[0] : !llvm.struct<(!llvm.ptr, i64)>
%782 = llvm.extractvalue %776[1] : !llvm.struct<(!llvm.ptr, i64)>
%783 = llvm.insertvalue %782, %781[1] : !llvm.struct<(!llvm.ptr, i64)>
%784 = llvm.mlir.constant(1 : i64) : i64
%785 = llvm.alloca %784 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %783, %785 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%786 = llvm.load %785 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%787 = llvm.mlir.constant(1 : i64) : i64
%788 = llvm.alloca %787 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %786, %788 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%789 = arith.constant 0 : i32
%790 = arith.extsi %789 : i32 to i64
%791 = llvm.mlir.constant(1 : i64) : i64
%792 = llvm.alloca %791 x i64 : (i64) -> !llvm.ptr
llvm.store %790, %792 : i64, !llvm.ptr
cf.br ^bb66
^bb66:
%793 = llvm.load %792 : !llvm.ptr -> i64
%794 = llvm.load %768 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%795 = llvm.getelementptr %768[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%796 = llvm.load %795 : !llvm.ptr -> i64
%797 = arith.cmpi slt, %793, %796 : i64
cf.cond_br %797, ^bb67, ^bb68
^bb67:
%798 = arith.constant 0 : i32
%799 = arith.extsi %798 : i32 to i64
%800 = llvm.mlir.constant(1 : i64) : i64
%801 = llvm.alloca %800 x i64 : (i64) -> !llvm.ptr
llvm.store %799, %801 : i64, !llvm.ptr
%802 = arith.constant 0 : i32
%803 = arith.extsi %802 : i32 to i64
%804 = llvm.mlir.constant(1 : i64) : i64
%805 = llvm.alloca %804 x i64 : (i64) -> !llvm.ptr
llvm.store %803, %805 : i64, !llvm.ptr
cf.br ^bb69
^bb69:
%806 = llvm.load %805 : !llvm.ptr -> i64
%807 = llvm.load %775 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%808 = llvm.getelementptr %775[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%809 = llvm.load %808 : !llvm.ptr -> i64
%810 = arith.cmpi slt, %806, %809 : i64
cf.cond_br %810, ^bb70, ^bb71
^bb70:
%811 = llvm.load %792 : !llvm.ptr -> i64
%812 = llvm.load %805 : !llvm.ptr -> i64
%813 = arith.addi %811, %812 : i64
%815 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%816 = llvm.getelementptr %788[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%817 = llvm.load %816 : !llvm.ptr -> !llvm.ptr
%818 = llvm.getelementptr %817[%813] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%814 = llvm.load %818 : !llvm.ptr -> i64
%820 = llvm.load %768 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%821 = llvm.getelementptr %768[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%822 = llvm.load %821 : !llvm.ptr -> !llvm.ptr
%823 = llvm.load %792 : !llvm.ptr -> i64
%824 = llvm.getelementptr %822[%823] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%819 = llvm.load %824 : !llvm.ptr -> i64
%826 = llvm.load %775 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%827 = llvm.getelementptr %775[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%828 = llvm.load %827 : !llvm.ptr -> !llvm.ptr
%829 = llvm.load %805 : !llvm.ptr -> i64
%830 = llvm.getelementptr %828[%829] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%825 = llvm.load %830 : !llvm.ptr -> i64
%831 = arith.muli %819, %825 : i64
%832 = arith.addi %814, %831 : i64
%833 = llvm.load %801 : !llvm.ptr -> i64
%834 = arith.addi %832, %833 : i64
%835 = llvm.mlir.addressof @BASE : !llvm.ptr
%836 = llvm.load %835 : !llvm.ptr -> i64
%837 = arith.remsi %834, %836 : i64
%838 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%839 = llvm.getelementptr %788[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%840 = llvm.load %839 : !llvm.ptr -> !llvm.ptr
%841 = llvm.getelementptr %840[%813] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %837, %841 : i64, !llvm.ptr
%842 = llvm.mlir.addressof @BASE : !llvm.ptr
%843 = llvm.load %842 : !llvm.ptr -> i64
%844 = arith.divsi %834, %843 : i64
llvm.store %844, %801 : i64, !llvm.ptr
%845 = llvm.load %805 : !llvm.ptr -> i64
%846 = arith.constant 1 : i32
%848 = arith.extsi %846 : i32 to i64
%847 = arith.addi %845, %848 : i64
llvm.store %847, %805 : i64, !llvm.ptr
cf.br ^bb69
^bb71:
%849 = llvm.load %792 : !llvm.ptr -> i64
%850 = llvm.load %775 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%851 = llvm.getelementptr %775[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%852 = llvm.load %851 : !llvm.ptr -> i64
%853 = arith.addi %849, %852 : i64
%854 = llvm.mlir.constant(1 : i64) : i64
%855 = llvm.alloca %854 x i64 : (i64) -> !llvm.ptr
llvm.store %853, %855 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%856 = llvm.load %801 : !llvm.ptr -> i64
%857 = arith.constant 0 : i32
%859 = arith.extsi %857 : i32 to i64
%858 = arith.cmpi sgt, %856, %859 : i64
cf.cond_br %858, ^bb73, ^bb74
^bb73:
%861 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%862 = llvm.getelementptr %788[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%863 = llvm.load %862 : !llvm.ptr -> !llvm.ptr
%864 = llvm.load %855 : !llvm.ptr -> i64
%865 = llvm.getelementptr %863[%864] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%860 = llvm.load %865 : !llvm.ptr -> i64
%866 = llvm.load %801 : !llvm.ptr -> i64
%867 = arith.addi %860, %866 : i64
%868 = llvm.mlir.addressof @BASE : !llvm.ptr
%869 = llvm.load %868 : !llvm.ptr -> i64
%870 = arith.remsi %867, %869 : i64
%871 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%872 = llvm.getelementptr %788[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%873 = llvm.load %872 : !llvm.ptr -> !llvm.ptr
%874 = llvm.load %855 : !llvm.ptr -> i64
%875 = llvm.getelementptr %873[%874] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %870, %875 : i64, !llvm.ptr
%876 = llvm.mlir.addressof @BASE : !llvm.ptr
%877 = llvm.load %876 : !llvm.ptr -> i64
%878 = arith.divsi %867, %877 : i64
llvm.store %878, %801 : i64, !llvm.ptr
%879 = llvm.load %855 : !llvm.ptr -> i64
%880 = arith.constant 1 : i32
%882 = arith.extsi %880 : i32 to i64
%881 = arith.addi %879, %882 : i64
llvm.store %881, %855 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
%883 = llvm.load %792 : !llvm.ptr -> i64
%884 = arith.constant 1 : i32
%886 = arith.extsi %884 : i32 to i64
%885 = arith.addi %883, %886 : i64
llvm.store %885, %792 : i64, !llvm.ptr
cf.br ^bb66
^bb68:
%887 = llvm.load %768 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%888 = llvm.getelementptr %768[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%889 = llvm.load %888 : !llvm.ptr -> i64
%890 = llvm.load %775 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%891 = llvm.getelementptr %775[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%892 = llvm.load %891 : !llvm.ptr -> i64
%893 = arith.addi %889, %892 : i64
%894 = llvm.getelementptr %788[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %893, %894 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%895 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%896 = llvm.getelementptr %788[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%897 = llvm.load %896 : !llvm.ptr -> i64
%898 = arith.constant 0 : i32
%900 = arith.extsi %898 : i32 to i64
%899 = arith.cmpi sgt, %897, %900 : i64
%901 = scf.if %899 -> (i1) {
%903 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%904 = llvm.getelementptr %788[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%905 = llvm.load %904 : !llvm.ptr -> !llvm.ptr
%906 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%907 = llvm.getelementptr %788[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%908 = llvm.load %907 : !llvm.ptr -> i64
%909 = arith.constant 1 : i32
%911 = arith.extsi %909 : i32 to i64
%910 = arith.subi %908, %911 : i64
%912 = llvm.getelementptr %905[%910] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%902 = llvm.load %912 : !llvm.ptr -> i64
%913 = arith.constant 0 : i32
%915 = arith.extsi %913 : i32 to i64
%914 = arith.cmpi eq, %902, %915 : i64
scf.yield %914 : i1
} else {
%916 = arith.constant false
scf.yield %916 : i1
}
cf.cond_br %901, ^bb76, ^bb77
^bb76:
%917 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%918 = llvm.getelementptr %788[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%919 = llvm.load %918 : !llvm.ptr -> i64
%920 = arith.constant 1 : i32
%922 = arith.extsi %920 : i32 to i64
%921 = arith.subi %919, %922 : i64
%923 = llvm.getelementptr %788[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
llvm.store %921, %923 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
%924 = llvm.load %788 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%925 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%926 = llvm.extractvalue %924[0] : !llvm.struct<(!llvm.ptr, i64)>
%927 = llvm.insertvalue %926, %925[0] : !llvm.struct<(!llvm.ptr, i64)>
%928 = llvm.extractvalue %924[1] : !llvm.struct<(!llvm.ptr, i64)>
%929 = llvm.insertvalue %928, %927[1] : !llvm.struct<(!llvm.ptr, i64)>
%930 = llvm.mlir.constant(1 : i64) : i64
%931 = llvm.alloca %930 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %929, %931 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%932 = llvm.load %931 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %932 : !llvm.struct<(!llvm.ptr, i64)>
}
func.func @bn_pow_small(%arg0: i64, %arg1: i64) -> !llvm.struct<(!llvm.ptr, i64)> {
%934 = arith.constant 1 : i32
%935 = arith.extsi %934 : i32 to i64
%933 = func.call @bn_from_i64(%935) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%936 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%937 = llvm.extractvalue %933[0] : !llvm.struct<(!llvm.ptr, i64)>
%938 = llvm.insertvalue %937, %936[0] : !llvm.struct<(!llvm.ptr, i64)>
%939 = llvm.extractvalue %933[1] : !llvm.struct<(!llvm.ptr, i64)>
%940 = llvm.insertvalue %939, %938[1] : !llvm.struct<(!llvm.ptr, i64)>
%941 = llvm.mlir.constant(1 : i64) : i64
%942 = llvm.alloca %941 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %940, %942 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%943 = llvm.load %942 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%944 = llvm.mlir.constant(1 : i64) : i64
%945 = llvm.alloca %944 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %943, %945 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%946 = arith.constant 0 : i32
%947 = arith.extsi %946 : i32 to i64
%948 = llvm.mlir.constant(1 : i64) : i64
%949 = llvm.alloca %948 x i64 : (i64) -> !llvm.ptr
llvm.store %947, %949 : i64, !llvm.ptr
cf.br ^bb78
^bb78:
%950 = llvm.load %949 : !llvm.ptr -> i64
%951 = arith.cmpi slt, %950, %arg1 : i64
cf.cond_br %951, ^bb79, ^bb80
^bb79:
func.call @bn_mul_small(%945, %arg0) : (!llvm.ptr, i64) -> ()
%953 = llvm.load %949 : !llvm.ptr -> i64
%954 = arith.constant 1 : i32
%956 = arith.extsi %954 : i32 to i64
%955 = arith.addi %953, %956 : i64
llvm.store %955, %949 : i64, !llvm.ptr
cf.br ^bb78
^bb80:
%957 = llvm.load %945 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%958 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%959 = llvm.extractvalue %957[0] : !llvm.struct<(!llvm.ptr, i64)>
%960 = llvm.insertvalue %959, %958[0] : !llvm.struct<(!llvm.ptr, i64)>
%961 = llvm.extractvalue %957[1] : !llvm.struct<(!llvm.ptr, i64)>
%962 = llvm.insertvalue %961, %960[1] : !llvm.struct<(!llvm.ptr, i64)>
%963 = llvm.mlir.constant(1 : i64) : i64
%964 = llvm.alloca %963 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %962, %964 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%965 = llvm.load %964 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.return %965 : !llvm.struct<(!llvm.ptr, i64)>
}
func.func @main() -> i32 {
%966 = arith.constant 80 : i32
%967 = arith.extsi %966 : i32 to i64
%968 = arith.constant 2 : i32
%970 = arith.extsi %968 : i32 to i64
%969 = arith.muli %970, %967 : i64
%971 = arith.constant 1 : i32
%973 = arith.extsi %971 : i32 to i64
%972 = arith.subi %969, %973 : i64
%975 = arith.constant 0 : i32
%976 = arith.extsi %975 : i32 to i64
%974 = func.call @bn_from_i64(%976) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%977 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%978 = llvm.extractvalue %974[0] : !llvm.struct<(!llvm.ptr, i64)>
%979 = llvm.insertvalue %978, %977[0] : !llvm.struct<(!llvm.ptr, i64)>
%980 = llvm.extractvalue %974[1] : !llvm.struct<(!llvm.ptr, i64)>
%981 = llvm.insertvalue %980, %979[1] : !llvm.struct<(!llvm.ptr, i64)>
%982 = llvm.mlir.constant(1 : i64) : i64
%983 = llvm.alloca %982 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %981, %983 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%984 = llvm.load %983 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%985 = llvm.mlir.constant(1 : i64) : i64
%986 = llvm.alloca %985 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %984, %986 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%988 = arith.constant 0 : i32
%989 = arith.extsi %988 : i32 to i64
%987 = func.call @bn_from_i64(%989) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%990 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%991 = llvm.extractvalue %987[0] : !llvm.struct<(!llvm.ptr, i64)>
%992 = llvm.insertvalue %991, %990[0] : !llvm.struct<(!llvm.ptr, i64)>
%993 = llvm.extractvalue %987[1] : !llvm.struct<(!llvm.ptr, i64)>
%994 = llvm.insertvalue %993, %992[1] : !llvm.struct<(!llvm.ptr, i64)>
%995 = llvm.mlir.constant(1 : i64) : i64
%996 = llvm.alloca %995 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %994, %996 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%997 = llvm.load %996 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%998 = llvm.mlir.constant(1 : i64) : i64
%999 = llvm.alloca %998 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %997, %999 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1001 = arith.constant 1 : i32
%1002 = arith.extsi %1001 : i32 to i64
%1000 = func.call @bn_from_i64(%1002) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%1003 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1004 = llvm.extractvalue %1000[0] : !llvm.struct<(!llvm.ptr, i64)>
%1005 = llvm.insertvalue %1004, %1003[0] : !llvm.struct<(!llvm.ptr, i64)>
%1006 = llvm.extractvalue %1000[1] : !llvm.struct<(!llvm.ptr, i64)>
%1007 = llvm.insertvalue %1006, %1005[1] : !llvm.struct<(!llvm.ptr, i64)>
%1008 = llvm.mlir.constant(1 : i64) : i64
%1009 = llvm.alloca %1008 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1007, %1009 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1010 = llvm.load %1009 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1011 = llvm.mlir.constant(1 : i64) : i64
%1012 = llvm.alloca %1011 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1010, %1012 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1013 = arith.constant 0 : i32
%1014 = arith.extsi %1013 : i32 to i64
%1015 = llvm.mlir.constant(1 : i64) : i64
%1016 = llvm.alloca %1015 x i64 : (i64) -> !llvm.ptr
llvm.store %1014, %1016 : i64, !llvm.ptr
cf.br ^bb81
^bb81:
%1017 = llvm.load %1016 : !llvm.ptr -> i64
%1018 = arith.cmpi slt, %1017, %967 : i64
cf.cond_br %1018, ^bb82, ^bb83
^bb82:
%1020 = llvm.load %1016 : !llvm.ptr -> i64
%1021 = arith.subi %967, %1020 : i64
%1019 = func.call @bn_pow_small(%1021, %972) : (i64, i64) -> !llvm.struct<(!llvm.ptr, i64)>
%1022 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1023 = llvm.extractvalue %1019[0] : !llvm.struct<(!llvm.ptr, i64)>
%1024 = llvm.insertvalue %1023, %1022[0] : !llvm.struct<(!llvm.ptr, i64)>
%1025 = llvm.extractvalue %1019[1] : !llvm.struct<(!llvm.ptr, i64)>
%1026 = llvm.insertvalue %1025, %1024[1] : !llvm.struct<(!llvm.ptr, i64)>
%1027 = llvm.mlir.constant(1 : i64) : i64
%1028 = llvm.alloca %1027 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1026, %1028 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1029 = llvm.load %1028 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1030 = llvm.mlir.constant(1 : i64) : i64
%1031 = llvm.alloca %1030 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1029, %1031 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1033 = llvm.load %1031 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1034 = llvm.load %1012 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1035 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1036 = llvm.extractvalue %1034[0] : !llvm.struct<(!llvm.ptr, i64)>
%1037 = llvm.insertvalue %1036, %1035[0] : !llvm.struct<(!llvm.ptr, i64)>
%1038 = llvm.extractvalue %1034[1] : !llvm.struct<(!llvm.ptr, i64)>
%1039 = llvm.insertvalue %1038, %1037[1] : !llvm.struct<(!llvm.ptr, i64)>
%1040 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1041 = llvm.extractvalue %1033[0] : !llvm.struct<(!llvm.ptr, i64)>
%1042 = llvm.insertvalue %1041, %1040[0] : !llvm.struct<(!llvm.ptr, i64)>
%1043 = llvm.extractvalue %1033[1] : !llvm.struct<(!llvm.ptr, i64)>
%1044 = llvm.insertvalue %1043, %1042[1] : !llvm.struct<(!llvm.ptr, i64)>
%1032 = func.call @bn_mul(%1039, %1044) : (!llvm.struct<(!llvm.ptr, i64)>, !llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1045 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1046 = llvm.extractvalue %1032[0] : !llvm.struct<(!llvm.ptr, i64)>
%1047 = llvm.insertvalue %1046, %1045[0] : !llvm.struct<(!llvm.ptr, i64)>
%1048 = llvm.extractvalue %1032[1] : !llvm.struct<(!llvm.ptr, i64)>
%1049 = llvm.insertvalue %1048, %1047[1] : !llvm.struct<(!llvm.ptr, i64)>
%1050 = llvm.mlir.constant(1 : i64) : i64
%1051 = llvm.alloca %1050 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1049, %1051 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1052 = llvm.load %1051 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1053 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1054 = llvm.extractvalue %1039[0] : !llvm.struct<(!llvm.ptr, i64)>
%1055 = llvm.insertvalue %1054, %1053[0] : !llvm.struct<(!llvm.ptr, i64)>
%1056 = llvm.extractvalue %1039[1] : !llvm.struct<(!llvm.ptr, i64)>
%1057 = llvm.insertvalue %1056, %1055[1] : !llvm.struct<(!llvm.ptr, i64)>
%1058 = llvm.mlir.constant(1 : i64) : i64
%1059 = llvm.alloca %1058 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1057, %1059 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1060 = llvm.load %1059 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1060, %1012 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1061 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1062 = llvm.extractvalue %1044[0] : !llvm.struct<(!llvm.ptr, i64)>
%1063 = llvm.insertvalue %1062, %1061[0] : !llvm.struct<(!llvm.ptr, i64)>
%1064 = llvm.extractvalue %1044[1] : !llvm.struct<(!llvm.ptr, i64)>
%1065 = llvm.insertvalue %1064, %1063[1] : !llvm.struct<(!llvm.ptr, i64)>
%1066 = llvm.mlir.constant(1 : i64) : i64
%1067 = llvm.alloca %1066 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1065, %1067 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1068 = llvm.load %1067 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1068, %1031 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1069 = llvm.mlir.constant(1 : i64) : i64
%1070 = llvm.alloca %1069 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1052, %1070 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1072 = llvm.load %1031 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1073 = llvm.getelementptr %1031[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1074 = llvm.load %1073 : !llvm.ptr -> !llvm.ptr
func.call @free(%1074) : (!llvm.ptr) -> ()
%1075 = llvm.load %1016 : !llvm.ptr -> i64
%1076 = arith.constant 2 : i32
%1078 = arith.extsi %1076 : i32 to i64
%1077 = arith.remsi %1075, %1078 : i64
%1079 = arith.constant 0 : i32
%1081 = arith.extsi %1079 : i32 to i64
%1080 = arith.cmpi eq, %1077, %1081 : i64
cf.cond_br %1080, ^bb84, ^bb85
^bb84:
%1083 = llvm.load %1070 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.call @bn_add(%986, %1083) : (!llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>) -> ()
cf.br ^bb86
^bb85:
%1085 = llvm.load %1070 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.call @bn_add(%999, %1085) : (!llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>) -> ()
cf.br ^bb86
^bb86:
%1087 = llvm.load %1070 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1088 = llvm.getelementptr %1070[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1089 = llvm.load %1088 : !llvm.ptr -> !llvm.ptr
func.call @free(%1089) : (!llvm.ptr) -> ()
%1090 = llvm.load %1016 : !llvm.ptr -> i64
%1091 = arith.constant 1 : i32
%1093 = arith.extsi %1091 : i32 to i64
%1092 = arith.addi %1090, %1093 : i64
%1094 = arith.cmpi slt, %1092, %967 : i64
cf.cond_br %1094, ^bb87, ^bb88
^bb87:
%1096 = arith.constant 2 : i32
%1098 = arith.extsi %1096 : i32 to i64
%1097 = arith.muli %1098, %967 : i64
%1099 = llvm.load %1016 : !llvm.ptr -> i64
%1100 = arith.subi %1097, %1099 : i64
func.call @bn_mul_small(%1012, %1100) : (!llvm.ptr, i64) -> ()
%1102 = llvm.load %1016 : !llvm.ptr -> i64
%1103 = arith.constant 1 : i32
%1105 = arith.extsi %1103 : i32 to i64
%1104 = arith.addi %1102, %1105 : i64
%1101 = func.call @bn_div_small(%1012, %1104) : (!llvm.ptr, i64) -> i64
cf.br ^bb89
^bb88:
cf.br ^bb89
^bb89:
%1106 = llvm.load %1016 : !llvm.ptr -> i64
%1107 = arith.constant 1 : i32
%1109 = arith.extsi %1107 : i32 to i64
%1108 = arith.addi %1106, %1109 : i64
llvm.store %1108, %1016 : i64, !llvm.ptr
cf.br ^bb81
^bb83:
%1111 = llvm.load %986 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1112 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1113 = llvm.extractvalue %1111[0] : !llvm.struct<(!llvm.ptr, i64)>
%1114 = llvm.insertvalue %1113, %1112[0] : !llvm.struct<(!llvm.ptr, i64)>
%1115 = llvm.extractvalue %1111[1] : !llvm.struct<(!llvm.ptr, i64)>
%1116 = llvm.insertvalue %1115, %1114[1] : !llvm.struct<(!llvm.ptr, i64)>
%1110 = func.call @bn_copy(%1116) : (!llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1117 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1118 = llvm.extractvalue %1110[0] : !llvm.struct<(!llvm.ptr, i64)>
%1119 = llvm.insertvalue %1118, %1117[0] : !llvm.struct<(!llvm.ptr, i64)>
%1120 = llvm.extractvalue %1110[1] : !llvm.struct<(!llvm.ptr, i64)>
%1121 = llvm.insertvalue %1120, %1119[1] : !llvm.struct<(!llvm.ptr, i64)>
%1122 = llvm.mlir.constant(1 : i64) : i64
%1123 = llvm.alloca %1122 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1121, %1123 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1124 = llvm.load %1123 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1125 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1126 = llvm.extractvalue %1116[0] : !llvm.struct<(!llvm.ptr, i64)>
%1127 = llvm.insertvalue %1126, %1125[0] : !llvm.struct<(!llvm.ptr, i64)>
%1128 = llvm.extractvalue %1116[1] : !llvm.struct<(!llvm.ptr, i64)>
%1129 = llvm.insertvalue %1128, %1127[1] : !llvm.struct<(!llvm.ptr, i64)>
%1130 = llvm.mlir.constant(1 : i64) : i64
%1131 = llvm.alloca %1130 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1129, %1131 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1132 = llvm.load %1131 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1132, %986 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1133 = llvm.mlir.constant(1 : i64) : i64
%1134 = llvm.alloca %1133 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1124, %1134 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1136 = llvm.load %999 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.call @bn_sub(%1134, %1136) : (!llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>) -> ()
%1138 = llvm.load %986 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1139 = llvm.getelementptr %986[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1140 = llvm.load %1139 : !llvm.ptr -> !llvm.ptr
func.call @free(%1140) : (!llvm.ptr) -> ()
%1142 = llvm.load %999 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1143 = llvm.getelementptr %999[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1144 = llvm.load %1143 : !llvm.ptr -> !llvm.ptr
func.call @free(%1144) : (!llvm.ptr) -> ()
%1146 = llvm.load %1012 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1147 = llvm.getelementptr %1012[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1148 = llvm.load %1147 : !llvm.ptr -> !llvm.ptr
func.call @free(%1148) : (!llvm.ptr) -> ()
%1150 = arith.constant 1 : i32
%1151 = arith.extsi %1150 : i32 to i64
%1149 = func.call @bn_from_i64(%1151) : (i64) -> !llvm.struct<(!llvm.ptr, i64)>
%1152 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1153 = llvm.extractvalue %1149[0] : !llvm.struct<(!llvm.ptr, i64)>
%1154 = llvm.insertvalue %1153, %1152[0] : !llvm.struct<(!llvm.ptr, i64)>
%1155 = llvm.extractvalue %1149[1] : !llvm.struct<(!llvm.ptr, i64)>
%1156 = llvm.insertvalue %1155, %1154[1] : !llvm.struct<(!llvm.ptr, i64)>
%1157 = llvm.mlir.constant(1 : i64) : i64
%1158 = llvm.alloca %1157 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1156, %1158 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1159 = llvm.load %1158 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1160 = llvm.mlir.constant(1 : i64) : i64
%1161 = llvm.alloca %1160 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1159, %1161 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1162 = arith.constant 2 : i32
%1163 = arith.extsi %1162 : i32 to i64
%1164 = llvm.mlir.constant(1 : i64) : i64
%1165 = llvm.alloca %1164 x i64 : (i64) -> !llvm.ptr
llvm.store %1163, %1165 : i64, !llvm.ptr
cf.br ^bb90
^bb90:
%1166 = llvm.load %1165 : !llvm.ptr -> i64
%1167 = arith.cmpi sle, %1166, %972 : i64
cf.cond_br %1167, ^bb91, ^bb92
^bb91:
%1169 = llvm.load %1165 : !llvm.ptr -> i64
func.call @bn_mul_small(%1161, %1169) : (!llvm.ptr, i64) -> ()
%1170 = llvm.load %1165 : !llvm.ptr -> i64
%1171 = arith.constant 1 : i32
%1173 = arith.extsi %1171 : i32 to i64
%1172 = arith.addi %1170, %1173 : i64
llvm.store %1172, %1165 : i64, !llvm.ptr
cf.br ^bb90
^bb92:
%1175 = llvm.load %1134 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1176 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1177 = llvm.extractvalue %1175[0] : !llvm.struct<(!llvm.ptr, i64)>
%1178 = llvm.insertvalue %1177, %1176[0] : !llvm.struct<(!llvm.ptr, i64)>
%1179 = llvm.extractvalue %1175[1] : !llvm.struct<(!llvm.ptr, i64)>
%1180 = llvm.insertvalue %1179, %1178[1] : !llvm.struct<(!llvm.ptr, i64)>
%1174 = func.call @bn_copy(%1180) : (!llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1181 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1182 = llvm.extractvalue %1174[0] : !llvm.struct<(!llvm.ptr, i64)>
%1183 = llvm.insertvalue %1182, %1181[0] : !llvm.struct<(!llvm.ptr, i64)>
%1184 = llvm.extractvalue %1174[1] : !llvm.struct<(!llvm.ptr, i64)>
%1185 = llvm.insertvalue %1184, %1183[1] : !llvm.struct<(!llvm.ptr, i64)>
%1186 = llvm.mlir.constant(1 : i64) : i64
%1187 = llvm.alloca %1186 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1185, %1187 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1188 = llvm.load %1187 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1189 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1190 = llvm.extractvalue %1180[0] : !llvm.struct<(!llvm.ptr, i64)>
%1191 = llvm.insertvalue %1190, %1189[0] : !llvm.struct<(!llvm.ptr, i64)>
%1192 = llvm.extractvalue %1180[1] : !llvm.struct<(!llvm.ptr, i64)>
%1193 = llvm.insertvalue %1192, %1191[1] : !llvm.struct<(!llvm.ptr, i64)>
%1194 = llvm.mlir.constant(1 : i64) : i64
%1195 = llvm.alloca %1194 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1193, %1195 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1196 = llvm.load %1195 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1196, %1134 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1197 = llvm.mlir.constant(1 : i64) : i64
%1198 = llvm.alloca %1197 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1188, %1198 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1200 = arith.constant 5705032704 : i32
%1201 = arith.extsi %1200 : i32 to i64
func.call @bn_mul_small(%1198, %1201) : (!llvm.ptr, i64) -> ()
%1203 = llvm.load %1134 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1204 = llvm.getelementptr %1134[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1205 = llvm.load %1204 : !llvm.ptr -> !llvm.ptr
func.call @free(%1205) : (!llvm.ptr) -> ()
%1206 = arith.constant 0 : i32
%1207 = arith.extsi %1206 : i32 to i64
%1208 = llvm.mlir.constant(1 : i64) : i64
%1209 = llvm.alloca %1208 x i64 : (i64) -> !llvm.ptr
llvm.store %1207, %1209 : i64, !llvm.ptr
%1210 = arith.constant 95705032704 : i32
%1211 = arith.extsi %1210 : i32 to i64
%1212 = llvm.mlir.constant(1 : i64) : i64
%1213 = llvm.alloca %1212 x i64 : (i64) -> !llvm.ptr
llvm.store %1211, %1213 : i64, !llvm.ptr
cf.br ^bb93
^bb93:
%1214 = llvm.load %1209 : !llvm.ptr -> i64
%1215 = llvm.load %1213 : !llvm.ptr -> i64
%1216 = arith.cmpi slt, %1214, %1215 : i64
cf.cond_br %1216, ^bb94, ^bb95
^bb94:
%1217 = llvm.load %1209 : !llvm.ptr -> i64
%1218 = llvm.load %1213 : !llvm.ptr -> i64
%1219 = arith.addi %1217, %1218 : i64
%1220 = arith.constant 1 : i32
%1222 = arith.extsi %1220 : i32 to i64
%1221 = arith.addi %1219, %1222 : i64
%1223 = arith.constant 2 : i32
%1225 = arith.extsi %1223 : i32 to i64
%1224 = arith.divsi %1221, %1225 : i64
%1227 = llvm.load %1161 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1228 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1229 = llvm.extractvalue %1227[0] : !llvm.struct<(!llvm.ptr, i64)>
%1230 = llvm.insertvalue %1229, %1228[0] : !llvm.struct<(!llvm.ptr, i64)>
%1231 = llvm.extractvalue %1227[1] : !llvm.struct<(!llvm.ptr, i64)>
%1232 = llvm.insertvalue %1231, %1230[1] : !llvm.struct<(!llvm.ptr, i64)>
%1226 = func.call @bn_copy(%1232) : (!llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1233 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1234 = llvm.extractvalue %1226[0] : !llvm.struct<(!llvm.ptr, i64)>
%1235 = llvm.insertvalue %1234, %1233[0] : !llvm.struct<(!llvm.ptr, i64)>
%1236 = llvm.extractvalue %1226[1] : !llvm.struct<(!llvm.ptr, i64)>
%1237 = llvm.insertvalue %1236, %1235[1] : !llvm.struct<(!llvm.ptr, i64)>
%1238 = llvm.mlir.constant(1 : i64) : i64
%1239 = llvm.alloca %1238 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1237, %1239 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1240 = llvm.load %1239 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1241 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1242 = llvm.extractvalue %1232[0] : !llvm.struct<(!llvm.ptr, i64)>
%1243 = llvm.insertvalue %1242, %1241[0] : !llvm.struct<(!llvm.ptr, i64)>
%1244 = llvm.extractvalue %1232[1] : !llvm.struct<(!llvm.ptr, i64)>
%1245 = llvm.insertvalue %1244, %1243[1] : !llvm.struct<(!llvm.ptr, i64)>
%1246 = llvm.mlir.constant(1 : i64) : i64
%1247 = llvm.alloca %1246 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1245, %1247 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1248 = llvm.load %1247 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1248, %1161 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1249 = llvm.mlir.constant(1 : i64) : i64
%1250 = llvm.alloca %1249 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1240, %1250 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
func.call @bn_mul_small(%1250, %1224) : (!llvm.ptr, i64) -> ()
%1253 = llvm.load %1250 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1254 = llvm.load %1198 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1252 = func.call @bn_cmp(%1253, %1254) : (!llvm.struct<(!llvm.ptr, i64)>, !llvm.struct<(!llvm.ptr, i64)>) -> i32
%1255 = arith.constant 0 : i32
%1256 = arith.cmpi sle, %1252, %1255 : i32
cf.cond_br %1256, ^bb96, ^bb97
^bb96:
llvm.store %1224, %1209 : i64, !llvm.ptr
cf.br ^bb98
^bb97:
%1257 = arith.constant 1 : i32
%1259 = arith.extsi %1257 : i32 to i64
%1258 = arith.subi %1224, %1259 : i64
llvm.store %1258, %1213 : i64, !llvm.ptr
cf.br ^bb98
^bb98:
%1261 = llvm.load %1250 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1262 = llvm.getelementptr %1250[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1263 = llvm.load %1262 : !llvm.ptr -> !llvm.ptr
func.call @free(%1263) : (!llvm.ptr) -> ()
cf.br ^bb93
^bb95:
%1264 = llvm.load %1209 : !llvm.ptr -> i64
%1266 = llvm.load %1161 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1267 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1268 = llvm.extractvalue %1266[0] : !llvm.struct<(!llvm.ptr, i64)>
%1269 = llvm.insertvalue %1268, %1267[0] : !llvm.struct<(!llvm.ptr, i64)>
%1270 = llvm.extractvalue %1266[1] : !llvm.struct<(!llvm.ptr, i64)>
%1271 = llvm.insertvalue %1270, %1269[1] : !llvm.struct<(!llvm.ptr, i64)>
%1265 = func.call @bn_copy(%1271) : (!llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1272 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1273 = llvm.extractvalue %1265[0] : !llvm.struct<(!llvm.ptr, i64)>
%1274 = llvm.insertvalue %1273, %1272[0] : !llvm.struct<(!llvm.ptr, i64)>
%1275 = llvm.extractvalue %1265[1] : !llvm.struct<(!llvm.ptr, i64)>
%1276 = llvm.insertvalue %1275, %1274[1] : !llvm.struct<(!llvm.ptr, i64)>
%1277 = llvm.mlir.constant(1 : i64) : i64
%1278 = llvm.alloca %1277 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1276, %1278 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1279 = llvm.load %1278 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1280 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1281 = llvm.extractvalue %1271[0] : !llvm.struct<(!llvm.ptr, i64)>
%1282 = llvm.insertvalue %1281, %1280[0] : !llvm.struct<(!llvm.ptr, i64)>
%1283 = llvm.extractvalue %1271[1] : !llvm.struct<(!llvm.ptr, i64)>
%1284 = llvm.insertvalue %1283, %1282[1] : !llvm.struct<(!llvm.ptr, i64)>
%1285 = llvm.mlir.constant(1 : i64) : i64
%1286 = llvm.alloca %1285 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1284, %1286 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1287 = llvm.load %1286 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1287, %1161 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1288 = llvm.mlir.constant(1 : i64) : i64
%1289 = llvm.alloca %1288 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1279, %1289 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
func.call @bn_mul_small(%1289, %1264) : (!llvm.ptr, i64) -> ()
%1292 = llvm.load %1198 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1293 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1294 = llvm.extractvalue %1292[0] : !llvm.struct<(!llvm.ptr, i64)>
%1295 = llvm.insertvalue %1294, %1293[0] : !llvm.struct<(!llvm.ptr, i64)>
%1296 = llvm.extractvalue %1292[1] : !llvm.struct<(!llvm.ptr, i64)>
%1297 = llvm.insertvalue %1296, %1295[1] : !llvm.struct<(!llvm.ptr, i64)>
%1291 = func.call @bn_copy(%1297) : (!llvm.struct<(!llvm.ptr, i64)>) -> !llvm.struct<(!llvm.ptr, i64)>
%1298 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1299 = llvm.extractvalue %1291[0] : !llvm.struct<(!llvm.ptr, i64)>
%1300 = llvm.insertvalue %1299, %1298[0] : !llvm.struct<(!llvm.ptr, i64)>
%1301 = llvm.extractvalue %1291[1] : !llvm.struct<(!llvm.ptr, i64)>
%1302 = llvm.insertvalue %1301, %1300[1] : !llvm.struct<(!llvm.ptr, i64)>
%1303 = llvm.mlir.constant(1 : i64) : i64
%1304 = llvm.alloca %1303 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1302, %1304 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1305 = llvm.load %1304 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1306 = llvm.mlir.undef : !llvm.struct<(!llvm.ptr, i64)>
%1307 = llvm.extractvalue %1297[0] : !llvm.struct<(!llvm.ptr, i64)>
%1308 = llvm.insertvalue %1307, %1306[0] : !llvm.struct<(!llvm.ptr, i64)>
%1309 = llvm.extractvalue %1297[1] : !llvm.struct<(!llvm.ptr, i64)>
%1310 = llvm.insertvalue %1309, %1308[1] : !llvm.struct<(!llvm.ptr, i64)>
%1311 = llvm.mlir.constant(1 : i64) : i64
%1312 = llvm.alloca %1311 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1310, %1312 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1313 = llvm.load %1312 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
llvm.store %1313, %1198 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1314 = llvm.mlir.constant(1 : i64) : i64
%1315 = llvm.alloca %1314 x !llvm.struct<(!llvm.ptr, i64)> : (i64) -> !llvm.ptr
llvm.store %1305, %1315 : !llvm.struct<(!llvm.ptr, i64)>, !llvm.ptr
%1317 = llvm.load %1289 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
func.call @bn_sub(%1315, %1317) : (!llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>) -> ()
%1319 = llvm.load %1289 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1320 = llvm.getelementptr %1289[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1321 = llvm.load %1320 : !llvm.ptr -> !llvm.ptr
func.call @free(%1321) : (!llvm.ptr) -> ()
%1323 = llvm.load %1198 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1324 = llvm.getelementptr %1198[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1325 = llvm.load %1324 : !llvm.ptr -> !llvm.ptr
func.call @free(%1325) : (!llvm.ptr) -> ()
%1327 = arith.constant 2 : i32
%1328 = arith.extsi %1327 : i32 to i64
func.call @bn_mul_small(%1315, %1328) : (!llvm.ptr, i64) -> ()
%1329 = llvm.mlir.constant(1 : i64) : i64
%1330 = llvm.alloca %1329 x i64 : (i64) -> !llvm.ptr
llvm.store %1264, %1330 : i64, !llvm.ptr
%1332 = llvm.load %1315 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1333 = llvm.load %1161 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1331 = func.call @bn_cmp(%1332, %1333) : (!llvm.struct<(!llvm.ptr, i64)>, !llvm.struct<(!llvm.ptr, i64)>) -> i32
%1334 = arith.constant 0 : i32
%1335 = arith.cmpi sge, %1331, %1334 : i32
cf.cond_br %1335, ^bb99, ^bb100
^bb99:
%1336 = arith.constant 1 : i32
%1338 = arith.extsi %1336 : i32 to i64
%1337 = arith.addi %1264, %1338 : i64
llvm.store %1337, %1330 : i64, !llvm.ptr
cf.br ^bb101
^bb100:
cf.br ^bb101
^bb101:
%1339 = llvm.load %1330 : !llvm.ptr -> i64
%1340 = arith.constant 5705032704 : i32
%1342 = arith.extsi %1340 : i32 to i64
%1341 = arith.divsi %1339, %1342 : i64
%1343 = llvm.load %1330 : !llvm.ptr -> i64
%1344 = arith.constant 5705032704 : i32
%1346 = arith.extsi %1344 : i32 to i64
%1345 = arith.remsi %1343, %1346 : i64
%1347 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1348 = llvm.call @printf(%1347, %1341, %1345) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64, i64) -> i32
%1350 = llvm.load %1315 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1351 = llvm.getelementptr %1315[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1352 = llvm.load %1351 : !llvm.ptr -> !llvm.ptr
func.call @free(%1352) : (!llvm.ptr) -> ()
%1354 = llvm.load %1161 : !llvm.ptr -> !llvm.struct<(!llvm.ptr, i64)>
%1355 = llvm.getelementptr %1161[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(!llvm.ptr, i64)>
%1356 = llvm.load %1355 : !llvm.ptr -> !llvm.ptr
func.call @free(%1356) : (!llvm.ptr) -> ()
%1357 = arith.constant 0 : i32
func.return %1357 : i32
}
}