Problem 507
Shortest Lattice Vector — sum S(n) for n=1..20_000_000.
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n) | O(n^2) |
|---|
| Space complexity | O(1) | O(n^2) |
|---|
| Approach | Flow solution | Combinatorial or DP counting |
|---|
| Verdict | Optimal |
|---|
Flow source
# Project Euler 507
# Shortest Lattice Vector — sum S(n) for n=1..20_000_000.
const MOD: i64 = 10000000
const LIMIT: i64 = 20000000
function abs64(x: i64) -> i64 {
if x < 0 { return -x }
return x
}
function floordiv(a: i64, b: i64) -> i64 {
if b == 0 { return 0 }
let q: i64 = a / b
let r: i64 = a - q * b
if r != 0 && ((r > 0) != (b > 0)) { q = q - 1 }
return q
}
function best_reduction(a1: i64, a2: i64, a3: i64, b1: i64, b2: i64, b3: i64, nb: i64) -> i64 {
let mut best_m: i64 = 0
let mut best_v: i64 = nb
if a1 != 0 {
let mut q: i64 = floordiv(b1, a1)
let mut v: i64 = abs64(b1 - q * a1) + abs64(b2 - q * a2) + abs64(b3 - q * a3)
if v < best_v {
best_v = v
best_m = q
}
q = q + 1
v = abs64(b1 - q * a1) + abs64(b2 - q * a2) + abs64(b3 - q * a3)
if v < best_v {
best_v = v
best_m = q
}
}
if a2 != 0 {
let mut q2: i64 = floordiv(b2, a2)
let mut v2: i64 = abs64(b1 - q2 * a1) + abs64(b2 - q2 * a2) + abs64(b3 - q2 * a3)
if v2 < best_v {
best_v = v2
best_m = q2
}
q2 = q2 + 1
v2 = abs64(b1 - q2 * a1) + abs64(b2 - q2 * a2) + abs64(b3 - q2 * a3)
if v2 < best_v {
best_v = v2
best_m = q2
}
}
if a3 != 0 {
let mut q3: i64 = floordiv(b3, a3)
let mut v3: i64 = abs64(b1 - q3 * a1) + abs64(b2 - q3 * a2) + abs64(b3 - q3 * a3)
if v3 < best_v {
best_v = v3
best_m = q3
}
q3 = q3 + 1
v3 = abs64(b1 - q3 * a1) + abs64(b2 - q3 * a2) + abs64(b3 - q3 * a3)
if v3 < best_v {
best_v = v3
best_m = q3
}
}
return best_m
}
function shortest_l1(v1: i64, v2: i64, v3: i64, w1: i64, w2: i64, w3: i64) -> i64 {
let mut a1: i64 = v1
let mut a2: i64 = v2
let mut a3: i64 = v3
let mut b1: i64 = w1
let mut b2: i64 = w2
let mut b3: i64 = w3
if (a1 | a2 | a3) == 0 {
return abs64(b1) + abs64(b2) + abs64(b3)
}
if (b1 | b2 | b3) == 0 {
return abs64(a1) + abs64(a2) + abs64(a3)
}
while true {
let na: i64 = abs64(a1) + abs64(a2) + abs64(a3)
let nb: i64 = abs64(b1) + abs64(b2) + abs64(b3)
if nb < na {
let ta1: i64 = a1
a1 = b1
b1 = ta1
let ta2: i64 = a2
a2 = b2
b2 = ta2
let ta3: i64 = a3
a3 = b3
b3 = ta3
}
let m: i64 = best_reduction(a1, a2, a3, b1, b2, b3, nb)
let reduced: i64 = abs64(b1 - m * a1) + abs64(b2 - m * a2) + abs64(b3 - m * a3)
if reduced >= nb { break }
b1 = b1 - m * a1
b2 = b2 - m * a2
b3 = b3 - m * a3
}
let s: i64 = abs64(a1) + abs64(a2) + abs64(a3)
let t: i64 = abs64(b1) + abs64(b2) + abs64(b3)
if t != 0 && t < s { return t }
return s
}
function main() -> i32 {
let mut prev2: i64 = 1
let mut prev1: i64 = 0
let mut cur: i64 = 0
let mut pos: i64 = 0
let mut total: i128 = 0
let b0: ptr<i64> = calloc(12, 8)
if b0 == null { return 1 }
let mut step: i64 = 0
let max_step: i64 = LIMIT * 12
while step < max_step {
b0[pos] = cur
pos = pos + 1
if pos == 12 {
let s: i64 = shortest_l1(
b0[0] - b0[1], b0[2] + b0[3], b0[4] * b0[5],
b0[6] - b0[7], b0[8] + b0[9], b0[10] * b0[11]
)
total = total + (s as i128)
pos = 0
}
let mut nxt: i64 = prev2 + prev1 + cur
if nxt >= MOD {
nxt = nxt - MOD
if nxt >= MOD { nxt = nxt - MOD }
}
prev2 = prev1
prev1 = cur
cur = nxt
step = step + 1
}
printf("%lld\n", total as i64)
free(b0)
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; }
int64_t abs64_i64(int64_t x);
int64_t floordiv_i64_i64(int64_t a, int64_t b);
int64_t best_reduction_i64_i64_i64_i64_i64_i64_i64(int64_t a1, int64_t a2, int64_t a3, int64_t b1, int64_t b2, int64_t b3, int64_t nb);
int64_t shortest_l1_i64_i64_i64_i64_i64_i64(int64_t v1, int64_t v2, int64_t v3, int64_t w1, int64_t w2, int64_t w3);
int32_t main(void);
static const int64_t MOD = 10000000;
static const int64_t LIMIT = 20000000;
int64_t abs64_i64(int64_t x) {
if (x < 0) {
return (-x);
}
return x;
}
int64_t floordiv_i64_i64(int64_t a, int64_t b) {
if (b == 0) {
return 0;
}
int64_t q = FLOW_CHECKED_DIV((a), (b));
int64_t r = (a - (q * b));
if ((r != 0 && r > 0 != b > 0)) {
q = (q - 1);
}
return q;
}
int64_t best_reduction_i64_i64_i64_i64_i64_i64_i64(int64_t a1, int64_t a2, int64_t a3, int64_t b1, int64_t b2, int64_t b3, int64_t nb) {
int64_t best_m = 0;
int64_t best_v = nb;
if (a1 != 0) {
int64_t q = floordiv_i64_i64(b1, a1);
int64_t v = ((abs64_i64((b1 - (q * a1))) + abs64_i64((b2 - (q * a2)))) + abs64_i64((b3 - (q * a3))));
if (v < best_v) {
best_v = v;
best_m = q;
}
q = (q + 1);
v = ((abs64_i64((b1 - (q * a1))) + abs64_i64((b2 - (q * a2)))) + abs64_i64((b3 - (q * a3))));
if (v < best_v) {
best_v = v;
best_m = q;
}
}
if (a2 != 0) {
int64_t q2 = floordiv_i64_i64(b2, a2);
int64_t v2 = ((abs64_i64((b1 - (q2 * a1))) + abs64_i64((b2 - (q2 * a2)))) + abs64_i64((b3 - (q2 * a3))));
if (v2 < best_v) {
best_v = v2;
best_m = q2;
}
q2 = (q2 + 1);
v2 = ((abs64_i64((b1 - (q2 * a1))) + abs64_i64((b2 - (q2 * a2)))) + abs64_i64((b3 - (q2 * a3))));
if (v2 < best_v) {
best_v = v2;
best_m = q2;
}
}
if (a3 != 0) {
int64_t q3 = floordiv_i64_i64(b3, a3);
int64_t v3 = ((abs64_i64((b1 - (q3 * a1))) + abs64_i64((b2 - (q3 * a2)))) + abs64_i64((b3 - (q3 * a3))));
if (v3 < best_v) {
best_v = v3;
best_m = q3;
}
q3 = (q3 + 1);
v3 = ((abs64_i64((b1 - (q3 * a1))) + abs64_i64((b2 - (q3 * a2)))) + abs64_i64((b3 - (q3 * a3))));
if (v3 < best_v) {
best_v = v3;
best_m = q3;
}
}
return best_m;
}
int64_t shortest_l1_i64_i64_i64_i64_i64_i64(int64_t v1, int64_t v2, int64_t v3, int64_t w1, int64_t w2, int64_t w3) {
int64_t a1 = v1;
int64_t a2 = v2;
int64_t a3 = v3;
int64_t b1 = w1;
int64_t b2 = w2;
int64_t b3 = w3;
if (((a1 | a2) | a3) == 0) {
return ((abs64_i64(b1) + abs64_i64(b2)) + abs64_i64(b3));
}
if (((b1 | b2) | b3) == 0) {
return ((abs64_i64(a1) + abs64_i64(a2)) + abs64_i64(a3));
}
while (1) {
int64_t na = ((abs64_i64(a1) + abs64_i64(a2)) + abs64_i64(a3));
int64_t nb = ((abs64_i64(b1) + abs64_i64(b2)) + abs64_i64(b3));
if (nb < na) {
int64_t ta1 = a1;
a1 = b1;
b1 = ta1;
int64_t ta2 = a2;
a2 = b2;
b2 = ta2;
int64_t ta3 = a3;
a3 = b3;
b3 = ta3;
}
int64_t m = best_reduction_i64_i64_i64_i64_i64_i64_i64(a1, a2, a3, b1, b2, b3, nb);
int64_t reduced = ((abs64_i64((b1 - (m * a1))) + abs64_i64((b2 - (m * a2)))) + abs64_i64((b3 - (m * a3))));
if (reduced >= nb) {
break;
}
b1 = (b1 - (m * a1));
b2 = (b2 - (m * a2));
b3 = (b3 - (m * a3));
}
int64_t s = ((abs64_i64(a1) + abs64_i64(a2)) + abs64_i64(a3));
int64_t t = ((abs64_i64(b1) + abs64_i64(b2)) + abs64_i64(b3));
if ((t != 0 && t < s)) {
return t;
}
return s;
}
int32_t main(void) {
int64_t prev2 = 1;
int64_t prev1 = 0;
int64_t cur = 0;
int64_t pos = 0;
__int128 total = 0;
int64_t* b0 = (int64_t*)(calloc(12, 8));
if (b0 == NULL) {
return 1;
}
int64_t step = 0;
int64_t max_step = (LIMIT * 12);
while (step < max_step) {
b0[pos] = cur;
pos = (pos + 1);
if (pos == 12) {
int64_t s = shortest_l1_i64_i64_i64_i64_i64_i64((b0[0] - b0[1]), (b0[2] + b0[3]), (b0[4] * b0[5]), (b0[6] - b0[7]), (b0[8] + b0[9]), (b0[10] * b0[11]));
total = (total + ((__int128)(s)));
pos = 0;
}
int64_t nxt = ((prev2 + prev1) + cur);
if (nxt >= MOD) {
nxt = (nxt - MOD);
if (nxt >= MOD) {
nxt = (nxt - MOD);
}
}
prev2 = prev1;
prev1 = cur;
cur = nxt;
step = (step + 1);
}
printf("%lld\n", ((int64_t)(total)));
free(b0);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
// Constant: MOD
llvm.mlir.global internal constant @MOD(10000000 : i64) : i64
// Constant: LIMIT
llvm.mlir.global internal constant @LIMIT(20000000 : i64) : i64
func.func @abs64(%arg0: i64) -> i64 {
%0 = arith.constant 0 : i32
%2 = arith.extsi %0 : i32 to i64
%1 = arith.cmpi slt, %arg0, %2 : i64
cf.cond_br %1, ^bb0, ^bb1
^bb0:
%4 = arith.constant 0 : i64
%3 = arith.subi %4, %arg0 : i64
func.return %3 : i64
^bb1:
cf.br ^bb2
^bb2:
func.return %arg0 : i64
}
func.func @floordiv(%arg0: i64, %arg1: i64) -> i64 {
%5 = arith.constant 0 : i32
%7 = arith.extsi %5 : i32 to i64
%6 = arith.cmpi eq, %arg1, %7 : i64
cf.cond_br %6, ^bb3, ^bb4
^bb3:
%8 = arith.constant 0 : i32
%9 = arith.extsi %8 : i32 to i64
func.return %9 : i64
^bb4:
cf.br ^bb5
^bb5:
%10 = arith.divsi %arg0, %arg1 : i64
%11 = arith.muli %10, %arg1 : i64
%12 = arith.subi %arg0, %11 : i64
%13 = arith.constant 0 : i32
%15 = arith.extsi %13 : i32 to i64
%14 = arith.cmpi ne, %12, %15 : i64
%16 = scf.if %14 -> (i1) {
%17 = arith.constant 0 : i32
%19 = arith.extsi %17 : i32 to i64
%18 = arith.cmpi sgt, %12, %19 : i64
%20 = arith.constant 0 : i32
%22 = arith.extsi %20 : i32 to i64
%21 = arith.cmpi sgt, %arg1, %22 : i64
%23 = arith.cmpi ne, %18, %21 : i1
scf.yield %23 : i1
} else {
%24 = arith.constant false
scf.yield %24 : i1
}
%25 = scf.if %16 -> (i64) {
%26 = arith.constant 1 : i32
%28 = arith.extsi %26 : i32 to i64
%27 = arith.subi %10, %28 : i64
scf.yield %27 : i64
} else {
scf.yield %10 : i64
}
func.return %25 : i64
}
func.func @best_reduction(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64) -> i64 {
%29 = arith.constant 0 : i32
%30 = arith.extsi %29 : i32 to i64
%31 = llvm.mlir.constant(1 : i64) : i64
%32 = llvm.alloca %31 x i64 : (i64) -> !llvm.ptr
llvm.store %30, %32 : i64, !llvm.ptr
%33 = llvm.mlir.constant(1 : i64) : i64
%34 = llvm.alloca %33 x i64 : (i64) -> !llvm.ptr
llvm.store %arg6, %34 : i64, !llvm.ptr
%35 = arith.constant 0 : i32
%37 = arith.extsi %35 : i32 to i64
%36 = arith.cmpi ne, %arg0, %37 : i64
cf.cond_br %36, ^bb6, ^bb7
^bb6:
%38 = func.call @floordiv(%arg3, %arg0) : (i64, i64) -> i64
%39 = llvm.mlir.constant(1 : i64) : i64
%40 = llvm.alloca %39 x i64 : (i64) -> !llvm.ptr
llvm.store %38, %40 : i64, !llvm.ptr
%42 = llvm.load %40 : !llvm.ptr -> i64
%43 = arith.muli %42, %arg0 : i64
%44 = arith.subi %arg3, %43 : i64
%41 = func.call @abs64(%44) : (i64) -> i64
%46 = llvm.load %40 : !llvm.ptr -> i64
%47 = arith.muli %46, %arg1 : i64
%48 = arith.subi %arg4, %47 : i64
%45 = func.call @abs64(%48) : (i64) -> i64
%49 = arith.addi %41, %45 : i64
%51 = llvm.load %40 : !llvm.ptr -> i64
%52 = arith.muli %51, %arg2 : i64
%53 = arith.subi %arg5, %52 : i64
%50 = func.call @abs64(%53) : (i64) -> i64
%54 = arith.addi %49, %50 : i64
%55 = llvm.mlir.constant(1 : i64) : i64
%56 = llvm.alloca %55 x i64 : (i64) -> !llvm.ptr
llvm.store %54, %56 : i64, !llvm.ptr
%57 = llvm.load %56 : !llvm.ptr -> i64
%58 = llvm.load %34 : !llvm.ptr -> i64
%59 = arith.cmpi slt, %57, %58 : i64
cf.cond_br %59, ^bb9, ^bb10
^bb9:
%60 = llvm.load %56 : !llvm.ptr -> i64
llvm.store %60, %34 : i64, !llvm.ptr
%61 = llvm.load %40 : !llvm.ptr -> i64
llvm.store %61, %32 : i64, !llvm.ptr
cf.br ^bb11
^bb10:
cf.br ^bb11
^bb11:
%62 = llvm.load %40 : !llvm.ptr -> i64
%63 = arith.constant 1 : i32
%65 = arith.extsi %63 : i32 to i64
%64 = arith.addi %62, %65 : i64
llvm.store %64, %40 : i64, !llvm.ptr
%67 = llvm.load %40 : !llvm.ptr -> i64
%68 = arith.muli %67, %arg0 : i64
%69 = arith.subi %arg3, %68 : i64
%66 = func.call @abs64(%69) : (i64) -> i64
%71 = llvm.load %40 : !llvm.ptr -> i64
%72 = arith.muli %71, %arg1 : i64
%73 = arith.subi %arg4, %72 : i64
%70 = func.call @abs64(%73) : (i64) -> i64
%74 = arith.addi %66, %70 : i64
%76 = llvm.load %40 : !llvm.ptr -> i64
%77 = arith.muli %76, %arg2 : i64
%78 = arith.subi %arg5, %77 : i64
%75 = func.call @abs64(%78) : (i64) -> i64
%79 = arith.addi %74, %75 : i64
llvm.store %79, %56 : i64, !llvm.ptr
%80 = llvm.load %56 : !llvm.ptr -> i64
%81 = llvm.load %34 : !llvm.ptr -> i64
%82 = arith.cmpi slt, %80, %81 : i64
cf.cond_br %82, ^bb12, ^bb13
^bb12:
%83 = llvm.load %56 : !llvm.ptr -> i64
llvm.store %83, %34 : i64, !llvm.ptr
%84 = llvm.load %40 : !llvm.ptr -> i64
llvm.store %84, %32 : i64, !llvm.ptr
cf.br ^bb14
^bb13:
cf.br ^bb14
^bb14:
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%85 = arith.constant 0 : i32
%87 = arith.extsi %85 : i32 to i64
%86 = arith.cmpi ne, %arg1, %87 : i64
cf.cond_br %86, ^bb15, ^bb16
^bb15:
%88 = func.call @floordiv(%arg4, %arg1) : (i64, i64) -> i64
%89 = llvm.mlir.constant(1 : i64) : i64
%90 = llvm.alloca %89 x i64 : (i64) -> !llvm.ptr
llvm.store %88, %90 : i64, !llvm.ptr
%92 = llvm.load %90 : !llvm.ptr -> i64
%93 = arith.muli %92, %arg0 : i64
%94 = arith.subi %arg3, %93 : i64
%91 = func.call @abs64(%94) : (i64) -> i64
%96 = llvm.load %90 : !llvm.ptr -> i64
%97 = arith.muli %96, %arg1 : i64
%98 = arith.subi %arg4, %97 : i64
%95 = func.call @abs64(%98) : (i64) -> i64
%99 = arith.addi %91, %95 : i64
%101 = llvm.load %90 : !llvm.ptr -> i64
%102 = arith.muli %101, %arg2 : i64
%103 = arith.subi %arg5, %102 : i64
%100 = func.call @abs64(%103) : (i64) -> i64
%104 = arith.addi %99, %100 : i64
%105 = llvm.mlir.constant(1 : i64) : i64
%106 = llvm.alloca %105 x i64 : (i64) -> !llvm.ptr
llvm.store %104, %106 : i64, !llvm.ptr
%107 = llvm.load %106 : !llvm.ptr -> i64
%108 = llvm.load %34 : !llvm.ptr -> i64
%109 = arith.cmpi slt, %107, %108 : i64
cf.cond_br %109, ^bb18, ^bb19
^bb18:
%110 = llvm.load %106 : !llvm.ptr -> i64
llvm.store %110, %34 : i64, !llvm.ptr
%111 = llvm.load %90 : !llvm.ptr -> i64
llvm.store %111, %32 : i64, !llvm.ptr
cf.br ^bb20
^bb19:
cf.br ^bb20
^bb20:
%112 = llvm.load %90 : !llvm.ptr -> i64
%113 = arith.constant 1 : i32
%115 = arith.extsi %113 : i32 to i64
%114 = arith.addi %112, %115 : i64
llvm.store %114, %90 : i64, !llvm.ptr
%117 = llvm.load %90 : !llvm.ptr -> i64
%118 = arith.muli %117, %arg0 : i64
%119 = arith.subi %arg3, %118 : i64
%116 = func.call @abs64(%119) : (i64) -> i64
%121 = llvm.load %90 : !llvm.ptr -> i64
%122 = arith.muli %121, %arg1 : i64
%123 = arith.subi %arg4, %122 : i64
%120 = func.call @abs64(%123) : (i64) -> i64
%124 = arith.addi %116, %120 : i64
%126 = llvm.load %90 : !llvm.ptr -> i64
%127 = arith.muli %126, %arg2 : i64
%128 = arith.subi %arg5, %127 : i64
%125 = func.call @abs64(%128) : (i64) -> i64
%129 = arith.addi %124, %125 : i64
llvm.store %129, %106 : i64, !llvm.ptr
%130 = llvm.load %106 : !llvm.ptr -> i64
%131 = llvm.load %34 : !llvm.ptr -> i64
%132 = arith.cmpi slt, %130, %131 : i64
cf.cond_br %132, ^bb21, ^bb22
^bb21:
%133 = llvm.load %106 : !llvm.ptr -> i64
llvm.store %133, %34 : i64, !llvm.ptr
%134 = llvm.load %90 : !llvm.ptr -> i64
llvm.store %134, %32 : i64, !llvm.ptr
cf.br ^bb23
^bb22:
cf.br ^bb23
^bb23:
cf.br ^bb17
^bb16:
cf.br ^bb17
^bb17:
%135 = arith.constant 0 : i32
%137 = arith.extsi %135 : i32 to i64
%136 = arith.cmpi ne, %arg2, %137 : i64
cf.cond_br %136, ^bb24, ^bb25
^bb24:
%138 = func.call @floordiv(%arg5, %arg2) : (i64, i64) -> i64
%139 = llvm.mlir.constant(1 : i64) : i64
%140 = llvm.alloca %139 x i64 : (i64) -> !llvm.ptr
llvm.store %138, %140 : i64, !llvm.ptr
%142 = llvm.load %140 : !llvm.ptr -> i64
%143 = arith.muli %142, %arg0 : i64
%144 = arith.subi %arg3, %143 : i64
%141 = func.call @abs64(%144) : (i64) -> i64
%146 = llvm.load %140 : !llvm.ptr -> i64
%147 = arith.muli %146, %arg1 : i64
%148 = arith.subi %arg4, %147 : i64
%145 = func.call @abs64(%148) : (i64) -> i64
%149 = arith.addi %141, %145 : i64
%151 = llvm.load %140 : !llvm.ptr -> i64
%152 = arith.muli %151, %arg2 : i64
%153 = arith.subi %arg5, %152 : i64
%150 = func.call @abs64(%153) : (i64) -> i64
%154 = arith.addi %149, %150 : i64
%155 = llvm.mlir.constant(1 : i64) : i64
%156 = llvm.alloca %155 x i64 : (i64) -> !llvm.ptr
llvm.store %154, %156 : i64, !llvm.ptr
%157 = llvm.load %156 : !llvm.ptr -> i64
%158 = llvm.load %34 : !llvm.ptr -> i64
%159 = arith.cmpi slt, %157, %158 : i64
cf.cond_br %159, ^bb27, ^bb28
^bb27:
%160 = llvm.load %156 : !llvm.ptr -> i64
llvm.store %160, %34 : i64, !llvm.ptr
%161 = llvm.load %140 : !llvm.ptr -> i64
llvm.store %161, %32 : i64, !llvm.ptr
cf.br ^bb29
^bb28:
cf.br ^bb29
^bb29:
%162 = llvm.load %140 : !llvm.ptr -> i64
%163 = arith.constant 1 : i32
%165 = arith.extsi %163 : i32 to i64
%164 = arith.addi %162, %165 : i64
llvm.store %164, %140 : i64, !llvm.ptr
%167 = llvm.load %140 : !llvm.ptr -> i64
%168 = arith.muli %167, %arg0 : i64
%169 = arith.subi %arg3, %168 : i64
%166 = func.call @abs64(%169) : (i64) -> i64
%171 = llvm.load %140 : !llvm.ptr -> i64
%172 = arith.muli %171, %arg1 : i64
%173 = arith.subi %arg4, %172 : i64
%170 = func.call @abs64(%173) : (i64) -> i64
%174 = arith.addi %166, %170 : i64
%176 = llvm.load %140 : !llvm.ptr -> i64
%177 = arith.muli %176, %arg2 : i64
%178 = arith.subi %arg5, %177 : i64
%175 = func.call @abs64(%178) : (i64) -> i64
%179 = arith.addi %174, %175 : i64
llvm.store %179, %156 : i64, !llvm.ptr
%180 = llvm.load %156 : !llvm.ptr -> i64
%181 = llvm.load %34 : !llvm.ptr -> i64
%182 = arith.cmpi slt, %180, %181 : i64
cf.cond_br %182, ^bb30, ^bb31
^bb30:
%183 = llvm.load %156 : !llvm.ptr -> i64
llvm.store %183, %34 : i64, !llvm.ptr
%184 = llvm.load %140 : !llvm.ptr -> i64
llvm.store %184, %32 : i64, !llvm.ptr
cf.br ^bb32
^bb31:
cf.br ^bb32
^bb32:
cf.br ^bb26
^bb25:
cf.br ^bb26
^bb26:
%185 = llvm.load %32 : !llvm.ptr -> i64
func.return %185 : i64
}
func.func @shortest_l1(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: i64) -> i64 {
%186 = llvm.mlir.constant(1 : i64) : i64
%187 = llvm.alloca %186 x i64 : (i64) -> !llvm.ptr
llvm.store %arg0, %187 : i64, !llvm.ptr
%188 = llvm.mlir.constant(1 : i64) : i64
%189 = llvm.alloca %188 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %189 : i64, !llvm.ptr
%190 = llvm.mlir.constant(1 : i64) : i64
%191 = llvm.alloca %190 x i64 : (i64) -> !llvm.ptr
llvm.store %arg2, %191 : i64, !llvm.ptr
%192 = llvm.mlir.constant(1 : i64) : i64
%193 = llvm.alloca %192 x i64 : (i64) -> !llvm.ptr
llvm.store %arg3, %193 : i64, !llvm.ptr
%194 = llvm.mlir.constant(1 : i64) : i64
%195 = llvm.alloca %194 x i64 : (i64) -> !llvm.ptr
llvm.store %arg4, %195 : i64, !llvm.ptr
%196 = llvm.mlir.constant(1 : i64) : i64
%197 = llvm.alloca %196 x i64 : (i64) -> !llvm.ptr
llvm.store %arg5, %197 : i64, !llvm.ptr
%198 = llvm.load %187 : !llvm.ptr -> i64
%199 = llvm.load %189 : !llvm.ptr -> i64
%200 = arith.ori %198, %199 : i64
%201 = llvm.load %191 : !llvm.ptr -> i64
%202 = arith.ori %200, %201 : i64
%203 = arith.constant 0 : i32
%205 = arith.extsi %203 : i32 to i64
%204 = arith.cmpi eq, %202, %205 : i64
cf.cond_br %204, ^bb33, ^bb34
^bb33:
%207 = llvm.load %193 : !llvm.ptr -> i64
%206 = func.call @abs64(%207) : (i64) -> i64
%209 = llvm.load %195 : !llvm.ptr -> i64
%208 = func.call @abs64(%209) : (i64) -> i64
%210 = arith.addi %206, %208 : i64
%212 = llvm.load %197 : !llvm.ptr -> i64
%211 = func.call @abs64(%212) : (i64) -> i64
%213 = arith.addi %210, %211 : i64
func.return %213 : i64
^bb34:
cf.br ^bb35
^bb35:
%214 = llvm.load %193 : !llvm.ptr -> i64
%215 = llvm.load %195 : !llvm.ptr -> i64
%216 = arith.ori %214, %215 : i64
%217 = llvm.load %197 : !llvm.ptr -> i64
%218 = arith.ori %216, %217 : i64
%219 = arith.constant 0 : i32
%221 = arith.extsi %219 : i32 to i64
%220 = arith.cmpi eq, %218, %221 : i64
cf.cond_br %220, ^bb36, ^bb37
^bb36:
%223 = llvm.load %187 : !llvm.ptr -> i64
%222 = func.call @abs64(%223) : (i64) -> i64
%225 = llvm.load %189 : !llvm.ptr -> i64
%224 = func.call @abs64(%225) : (i64) -> i64
%226 = arith.addi %222, %224 : i64
%228 = llvm.load %191 : !llvm.ptr -> i64
%227 = func.call @abs64(%228) : (i64) -> i64
%229 = arith.addi %226, %227 : i64
func.return %229 : i64
^bb37:
cf.br ^bb38
^bb38:
cf.br ^bb39
^bb39:
%230 = arith.constant 1 : i1
cf.cond_br %230, ^bb40, ^bb41
^bb40:
%232 = llvm.load %187 : !llvm.ptr -> i64
%231 = func.call @abs64(%232) : (i64) -> i64
%234 = llvm.load %189 : !llvm.ptr -> i64
%233 = func.call @abs64(%234) : (i64) -> i64
%235 = arith.addi %231, %233 : i64
%237 = llvm.load %191 : !llvm.ptr -> i64
%236 = func.call @abs64(%237) : (i64) -> i64
%238 = arith.addi %235, %236 : i64
%240 = llvm.load %193 : !llvm.ptr -> i64
%239 = func.call @abs64(%240) : (i64) -> i64
%242 = llvm.load %195 : !llvm.ptr -> i64
%241 = func.call @abs64(%242) : (i64) -> i64
%243 = arith.addi %239, %241 : i64
%245 = llvm.load %197 : !llvm.ptr -> i64
%244 = func.call @abs64(%245) : (i64) -> i64
%246 = arith.addi %243, %244 : i64
%247 = arith.cmpi slt, %246, %238 : i64
cf.cond_br %247, ^bb42, ^bb43
^bb42:
%248 = llvm.load %187 : !llvm.ptr -> i64
%249 = llvm.load %193 : !llvm.ptr -> i64
llvm.store %249, %187 : i64, !llvm.ptr
llvm.store %248, %193 : i64, !llvm.ptr
%250 = llvm.load %189 : !llvm.ptr -> i64
%251 = llvm.load %195 : !llvm.ptr -> i64
llvm.store %251, %189 : i64, !llvm.ptr
llvm.store %250, %195 : i64, !llvm.ptr
%252 = llvm.load %191 : !llvm.ptr -> i64
%253 = llvm.load %197 : !llvm.ptr -> i64
llvm.store %253, %191 : i64, !llvm.ptr
llvm.store %252, %197 : i64, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%255 = llvm.load %187 : !llvm.ptr -> i64
%256 = llvm.load %189 : !llvm.ptr -> i64
%257 = llvm.load %191 : !llvm.ptr -> i64
%258 = llvm.load %193 : !llvm.ptr -> i64
%259 = llvm.load %195 : !llvm.ptr -> i64
%260 = llvm.load %197 : !llvm.ptr -> i64
%254 = func.call @best_reduction(%255, %256, %257, %258, %259, %260, %246) : (i64, i64, i64, i64, i64, i64, i64) -> i64
%262 = llvm.load %193 : !llvm.ptr -> i64
%263 = llvm.load %187 : !llvm.ptr -> i64
%264 = arith.muli %254, %263 : i64
%265 = arith.subi %262, %264 : i64
%261 = func.call @abs64(%265) : (i64) -> i64
%267 = llvm.load %195 : !llvm.ptr -> i64
%268 = llvm.load %189 : !llvm.ptr -> i64
%269 = arith.muli %254, %268 : i64
%270 = arith.subi %267, %269 : i64
%266 = func.call @abs64(%270) : (i64) -> i64
%271 = arith.addi %261, %266 : i64
%273 = llvm.load %197 : !llvm.ptr -> i64
%274 = llvm.load %191 : !llvm.ptr -> i64
%275 = arith.muli %254, %274 : i64
%276 = arith.subi %273, %275 : i64
%272 = func.call @abs64(%276) : (i64) -> i64
%277 = arith.addi %271, %272 : i64
%278 = arith.cmpi sge, %277, %246 : i64
cf.cond_br %278, ^bb45, ^bb46
^bb45:
cf.br ^bb41
^bb46:
cf.br ^bb47
^bb47:
%279 = llvm.load %193 : !llvm.ptr -> i64
%280 = llvm.load %187 : !llvm.ptr -> i64
%281 = arith.muli %254, %280 : i64
%282 = arith.subi %279, %281 : i64
llvm.store %282, %193 : i64, !llvm.ptr
%283 = llvm.load %195 : !llvm.ptr -> i64
%284 = llvm.load %189 : !llvm.ptr -> i64
%285 = arith.muli %254, %284 : i64
%286 = arith.subi %283, %285 : i64
llvm.store %286, %195 : i64, !llvm.ptr
%287 = llvm.load %197 : !llvm.ptr -> i64
%288 = llvm.load %191 : !llvm.ptr -> i64
%289 = arith.muli %254, %288 : i64
%290 = arith.subi %287, %289 : i64
llvm.store %290, %197 : i64, !llvm.ptr
cf.br ^bb39
^bb41:
%292 = llvm.load %187 : !llvm.ptr -> i64
%291 = func.call @abs64(%292) : (i64) -> i64
%294 = llvm.load %189 : !llvm.ptr -> i64
%293 = func.call @abs64(%294) : (i64) -> i64
%295 = arith.addi %291, %293 : i64
%297 = llvm.load %191 : !llvm.ptr -> i64
%296 = func.call @abs64(%297) : (i64) -> i64
%298 = arith.addi %295, %296 : i64
%300 = llvm.load %193 : !llvm.ptr -> i64
%299 = func.call @abs64(%300) : (i64) -> i64
%302 = llvm.load %195 : !llvm.ptr -> i64
%301 = func.call @abs64(%302) : (i64) -> i64
%303 = arith.addi %299, %301 : i64
%305 = llvm.load %197 : !llvm.ptr -> i64
%304 = func.call @abs64(%305) : (i64) -> i64
%306 = arith.addi %303, %304 : i64
%307 = arith.constant 0 : i32
%309 = arith.extsi %307 : i32 to i64
%308 = arith.cmpi ne, %306, %309 : i64
%310 = scf.if %308 -> (i1) {
%311 = arith.cmpi slt, %306, %298 : i64
scf.yield %311 : i1
} else {
%312 = arith.constant false
scf.yield %312 : i1
}
cf.cond_br %310, ^bb48, ^bb49
^bb48:
func.return %306 : i64
^bb49:
cf.br ^bb50
^bb50:
func.return %298 : i64
}
func.func @main() -> i32 {
%313 = arith.constant 1 : i32
%314 = arith.extsi %313 : i32 to i64
%315 = llvm.mlir.constant(1 : i64) : i64
%316 = llvm.alloca %315 x i64 : (i64) -> !llvm.ptr
llvm.store %314, %316 : i64, !llvm.ptr
%317 = arith.constant 0 : i32
%318 = arith.extsi %317 : i32 to i64
%319 = llvm.mlir.constant(1 : i64) : i64
%320 = llvm.alloca %319 x i64 : (i64) -> !llvm.ptr
llvm.store %318, %320 : i64, !llvm.ptr
%321 = arith.constant 0 : i32
%322 = arith.extsi %321 : i32 to i64
%323 = llvm.mlir.constant(1 : i64) : i64
%324 = llvm.alloca %323 x i64 : (i64) -> !llvm.ptr
llvm.store %322, %324 : i64, !llvm.ptr
%325 = arith.constant 0 : i32
%326 = arith.extsi %325 : i32 to i64
%327 = llvm.mlir.constant(1 : i64) : i64
%328 = llvm.alloca %327 x i64 : (i64) -> !llvm.ptr
llvm.store %326, %328 : i64, !llvm.ptr
%329 = arith.constant 0 : i32
%330 = arith.extsi %329 : i32 to i128
%331 = llvm.mlir.constant(1 : i64) : i64
%332 = llvm.alloca %331 x i128 : (i64) -> !llvm.ptr
llvm.store %330, %332 : i128, !llvm.ptr
%334 = arith.constant 12 : i32
%335 = arith.constant 8 : i32
%333 = func.call @calloc(%334, %335) : (i32, i32) -> i32
%336 = llvm.inttoptr %333 : i32 to !llvm.ptr
%337 = llvm.mlir.zero : !llvm.ptr
%338 = llvm.icmp "eq" %336, %337 : !llvm.ptr
cf.cond_br %338, ^bb51, ^bb52
^bb51:
%339 = arith.constant 1 : i32
func.return %339 : i32
^bb52:
cf.br ^bb53
^bb53:
%340 = arith.constant 0 : i32
%341 = arith.extsi %340 : i32 to i64
%342 = llvm.mlir.constant(1 : i64) : i64
%343 = llvm.alloca %342 x i64 : (i64) -> !llvm.ptr
llvm.store %341, %343 : i64, !llvm.ptr
%344 = llvm.mlir.addressof @LIMIT : !llvm.ptr
%345 = llvm.load %344 : !llvm.ptr -> i64
%346 = arith.constant 12 : i32
%348 = arith.extsi %346 : i32 to i64
%347 = arith.muli %345, %348 : i64
cf.br ^bb54
^bb54:
%349 = llvm.load %343 : !llvm.ptr -> i64
%350 = arith.cmpi slt, %349, %347 : i64
cf.cond_br %350, ^bb55, ^bb56
^bb55:
%351 = llvm.load %324 : !llvm.ptr -> i64
%352 = llvm.load %328 : !llvm.ptr -> i64
%353 = llvm.getelementptr %336[%352] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %351, %353 : i64, !llvm.ptr
%354 = llvm.load %328 : !llvm.ptr -> i64
%355 = arith.constant 1 : i32
%357 = arith.extsi %355 : i32 to i64
%356 = arith.addi %354, %357 : i64
llvm.store %356, %328 : i64, !llvm.ptr
%358 = llvm.load %328 : !llvm.ptr -> i64
%359 = arith.constant 12 : i32
%361 = arith.extsi %359 : i32 to i64
%360 = arith.cmpi eq, %358, %361 : i64
cf.cond_br %360, ^bb57, ^bb58
^bb57:
%364 = arith.constant 0 : i32
%365 = arith.extsi %364 : i32 to i64
%366 = llvm.getelementptr %336[%365] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%363 = llvm.load %366 : !llvm.ptr -> i64
%368 = arith.constant 1 : i32
%369 = arith.extsi %368 : i32 to i64
%370 = llvm.getelementptr %336[%369] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%367 = llvm.load %370 : !llvm.ptr -> i64
%371 = arith.subi %363, %367 : i64
%373 = arith.constant 2 : i32
%374 = arith.extsi %373 : i32 to i64
%375 = llvm.getelementptr %336[%374] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%372 = llvm.load %375 : !llvm.ptr -> i64
%377 = arith.constant 3 : i32
%378 = arith.extsi %377 : i32 to i64
%379 = llvm.getelementptr %336[%378] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%376 = llvm.load %379 : !llvm.ptr -> i64
%380 = arith.addi %372, %376 : i64
%382 = arith.constant 4 : i32
%383 = arith.extsi %382 : i32 to i64
%384 = llvm.getelementptr %336[%383] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%381 = llvm.load %384 : !llvm.ptr -> i64
%386 = arith.constant 5 : i32
%387 = arith.extsi %386 : i32 to i64
%388 = llvm.getelementptr %336[%387] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%385 = llvm.load %388 : !llvm.ptr -> i64
%389 = arith.muli %381, %385 : i64
%391 = arith.constant 6 : i32
%392 = arith.extsi %391 : i32 to i64
%393 = llvm.getelementptr %336[%392] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%390 = llvm.load %393 : !llvm.ptr -> i64
%395 = arith.constant 7 : i32
%396 = arith.extsi %395 : i32 to i64
%397 = llvm.getelementptr %336[%396] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%394 = llvm.load %397 : !llvm.ptr -> i64
%398 = arith.subi %390, %394 : i64
%400 = arith.constant 8 : i32
%401 = arith.extsi %400 : i32 to i64
%402 = llvm.getelementptr %336[%401] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%399 = llvm.load %402 : !llvm.ptr -> i64
%404 = arith.constant 9 : i32
%405 = arith.extsi %404 : i32 to i64
%406 = llvm.getelementptr %336[%405] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%403 = llvm.load %406 : !llvm.ptr -> i64
%407 = arith.addi %399, %403 : i64
%409 = arith.constant 10 : i32
%410 = arith.extsi %409 : i32 to i64
%411 = llvm.getelementptr %336[%410] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%408 = llvm.load %411 : !llvm.ptr -> i64
%413 = arith.constant 11 : i32
%414 = arith.extsi %413 : i32 to i64
%415 = llvm.getelementptr %336[%414] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%412 = llvm.load %415 : !llvm.ptr -> i64
%416 = arith.muli %408, %412 : i64
%362 = func.call @shortest_l1(%371, %380, %389, %398, %407, %416) : (i64, i64, i64, i64, i64, i64) -> i64
%417 = llvm.load %332 : !llvm.ptr -> i128
%418 = arith.extsi %362 : i64 to i128
%420 = arith.trunci %417 : i128 to i64
%421 = arith.trunci %418 : i128 to i64
%419 = arith.addi %420, %421 : i64
%422 = arith.extsi %419 : i64 to i128
llvm.store %422, %332 : i128, !llvm.ptr
%423 = arith.constant 0 : i32
%424 = arith.extsi %423 : i32 to i64
llvm.store %424, %328 : i64, !llvm.ptr
cf.br ^bb59
^bb58:
cf.br ^bb59
^bb59:
%425 = llvm.load %316 : !llvm.ptr -> i64
%426 = llvm.load %320 : !llvm.ptr -> i64
%427 = arith.addi %425, %426 : i64
%428 = llvm.load %324 : !llvm.ptr -> i64
%429 = arith.addi %427, %428 : i64
%430 = llvm.mlir.constant(1 : i64) : i64
%431 = llvm.alloca %430 x i64 : (i64) -> !llvm.ptr
llvm.store %429, %431 : i64, !llvm.ptr
%432 = llvm.load %431 : !llvm.ptr -> i64
%433 = llvm.mlir.addressof @MOD : !llvm.ptr
%434 = llvm.load %433 : !llvm.ptr -> i64
%435 = arith.cmpi sge, %432, %434 : i64
cf.cond_br %435, ^bb60, ^bb61
^bb60:
%436 = llvm.load %431 : !llvm.ptr -> i64
%437 = llvm.mlir.addressof @MOD : !llvm.ptr
%438 = llvm.load %437 : !llvm.ptr -> i64
%439 = arith.subi %436, %438 : i64
llvm.store %439, %431 : i64, !llvm.ptr
%440 = llvm.load %431 : !llvm.ptr -> i64
%441 = llvm.mlir.addressof @MOD : !llvm.ptr
%442 = llvm.load %441 : !llvm.ptr -> i64
%443 = arith.cmpi sge, %440, %442 : i64
cf.cond_br %443, ^bb63, ^bb64
^bb63:
%444 = llvm.load %431 : !llvm.ptr -> i64
%445 = llvm.mlir.addressof @MOD : !llvm.ptr
%446 = llvm.load %445 : !llvm.ptr -> i64
%447 = arith.subi %444, %446 : i64
llvm.store %447, %431 : i64, !llvm.ptr
cf.br ^bb65
^bb64:
cf.br ^bb65
^bb65:
cf.br ^bb62
^bb61:
cf.br ^bb62
^bb62:
%448 = llvm.load %320 : !llvm.ptr -> i64
llvm.store %448, %316 : i64, !llvm.ptr
%449 = llvm.load %324 : !llvm.ptr -> i64
llvm.store %449, %320 : i64, !llvm.ptr
%450 = llvm.load %431 : !llvm.ptr -> i64
llvm.store %450, %324 : i64, !llvm.ptr
%451 = llvm.load %343 : !llvm.ptr -> i64
%452 = arith.constant 1 : i32
%454 = arith.extsi %452 : i32 to i64
%453 = arith.addi %451, %454 : i64
llvm.store %453, %343 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
%455 = llvm.mlir.addressof @str_0 : !llvm.ptr
%456 = llvm.load %332 : !llvm.ptr -> i128
%457 = arith.trunci %456 : i128 to i64
%458 = llvm.call @printf(%455, %457) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%459 = func.call @free(%336) : (!llvm.ptr) -> i32
%460 = arith.constant 0 : i32
func.return %460 : i32
}
}