Problem 473
Phigital number base — sum of palindromic phigitals <= 10^10. Meet-in-the-middle over paired exponents (stbrumme gap of 3).
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n log n) | O(n^2) |
|---|
| Space complexity | O(n^2) | O(1) |
|---|
| Approach | Flow solution | Brute-force or constructive search |
|---|
| Verdict | Optimal |
|---|
Flow source
# Project Euler 473
# Phigital number base — sum of palindromic phigitals <= 10^10.
# Meet-in-the-middle over paired exponents (stbrumme gap of 3).
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
}
let mut PX: ptr<i64> = null
let mut PY: ptr<i64> = null
let mut LX: ptr<i64> = null
let mut LY: ptr<i64> = null
let mut LLAST: ptr<i64> = null
let mut LN: i64 = 0
let mut RX: ptr<i64> = null
let mut RY: ptr<i64> = null
let mut RFIRST: ptr<i64> = null
let mut RN: i64 = 0
function gen_left(x: i64, y: i64, ni: i64, last: i64, hi: i64) -> void {
LX[LN] = x
LY[LN] = y
LLAST[LN] = last
LN = LN + 1
let mut e: i64 = ni
while e <= hi {
gen_left(x + PX[e], y + PY[e], e + 3, e, hi)
e = e + 1
}
}
function gen_right(x: i64, y: i64, ni: i64, first: i64, hi: i64) -> void {
RX[RN] = x
RY[RN] = y
RFIRST[RN] = first
RN = RN + 1
let mut e: i64 = ni
while e <= hi {
gen_right(x + PX[e], y + PY[e], e + 3, first, hi)
e = e + 1
}
}
function sort_right_by_y() -> void {
# quicksort triples (RY, RX, RFIRST) by RY then RFIRST
let lo: ptr<i64> = calloc(64, 8)
let hi: ptr<i64> = calloc(64, 8)
let mut sp: i32 = 0
lo[0] = 0
hi[0] = RN - 1
sp = 1
while sp > 0 {
sp = sp - 1
let l: i64 = lo[sp]
let h: i64 = hi[sp]
if l >= h { continue }
let mid: i64 = (l + h) / 2
let py: i64 = RY[mid]
let pf: i64 = RFIRST[mid]
let mut i: i64 = l
let mut j: i64 = h
while i <= j {
while true {
let mut less: bool = false
if RY[i] < py { less = true }
else {
if RY[i] == py {
if RFIRST[i] < pf { less = true }
}
}
if !less { break }
i = i + 1
}
while true {
let mut greater: bool = false
if RY[j] > py { greater = true }
else {
if RY[j] == py {
if RFIRST[j] > pf { greater = true }
}
}
if !greater { break }
j = j - 1
}
if i <= j {
let tx: i64 = RX[i]; RX[i] = RX[j]; RX[j] = tx
let ty: i64 = RY[i]; RY[i] = RY[j]; RY[j] = ty
let tf: i64 = RFIRST[i]; RFIRST[i] = RFIRST[j]; RFIRST[j] = tf
i = i + 1
j = j - 1
}
}
if l < j {
lo[sp] = l
hi[sp] = j
sp = sp + 1
}
if i < h {
lo[sp] = i
hi[sp] = h
sp = sp + 1
}
}
free(lo)
free(hi)
}
function main() -> i32 {
let LIMIT: i64 = 10000000000
PX = calloc(50, 8)
PY = calloc(50, 8)
let F: ptr<i64> = calloc(60, 8)
if PX == null || PY == null || F == null { return 1 }
F[0] = 0
F[1] = 1
let mut i: i64 = 2
while i < 60 {
F[i] = F[i - 1] + F[i - 2]
i = i + 1
}
PX[0] = 2
PY[0] = 0
i = 1
while i <= 48 {
let Lk: i64 = F[i - 1] + F[i + 1]
let Lk1: i64 = F[i] + F[i + 2]
let mut sign: i64 = 0 - 1
if ((i + 1) & 1) == 0 {
sign = 1
}
PX[i] = Lk + sign * Lk1
PY[i] = F[i] - sign * F[i + 1]
i = i + 1
}
# ~13k states per half
let CAP: i64 = 20000
LX = calloc(CAP, 8)
LY = calloc(CAP, 8)
LLAST = calloc(CAP, 8)
RX = calloc(CAP, 8)
RY = calloc(CAP, 8)
RFIRST = calloc(CAP, 8)
if LX == null || LY == null || LLAST == null || RX == null || RY == null || RFIRST == null {
return 1
}
# empty left
LX[0] = 0
LY[0] = 0
LLAST[0] = 0 - 1000000000
LN = 1
i = 1
while i <= 24 {
gen_left(PX[i], PY[i], i + 3, i, 24)
i = i + 1
}
# empty right
RX[0] = 0
RY[0] = 0
RFIRST[0] = 1000000000
RN = 1
i = 25
while i <= 48 {
gen_right(PX[i], PY[i], i + 3, i, 48)
i = i + 1
}
sort_right_by_y()
let mut ans: i64 = 0
let mut li: i64 = 0
while li < LN {
let need: i64 = 0 - LY[li]
let last: i64 = LLAST[li]
# binary search lower bound on RY == need
let mut lo: i64 = 0
let mut hi: i64 = RN
while lo < hi {
let mid: i64 = (lo + hi) / 2
if RY[mid] < need {
lo = mid + 1
} else {
hi = mid
}
}
let mut ri: i64 = lo
while ri < RN {
if RY[ri] != need { break }
if RFIRST[ri] >= last + 3 {
let xx: i64 = LX[li] + RX[ri]
let v: i64 = xx / 2
if v > 0 {
if v <= LIMIT {
ans = ans + v
}
}
}
ri = ri + 1
}
li = li + 1
}
# Lone phigital "1"
printf("%lld\n", ans + 1)
free(PX)
free(PY)
free(F)
free(LX)
free(LY)
free(LLAST)
free(RX)
free(RY)
free(RFIRST)
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; }
void gen_left_i64_i64_i64_i64_i64(int64_t x, int64_t y, int64_t ni, int64_t last, int64_t hi);
void gen_right_i64_i64_i64_i64_i64(int64_t x, int64_t y, int64_t ni, int64_t first, int64_t hi);
void sort_right_by_y(void);
int32_t main(void);
/* Module statics */
static int64_t* PX = NULL;
static int64_t* PY = NULL;
static int64_t* LX = NULL;
static int64_t* LY = NULL;
static int64_t* LLAST = NULL;
static int64_t LN = 0;
static int64_t* RX = NULL;
static int64_t* RY = NULL;
static int64_t* RFIRST = NULL;
static int64_t RN = 0;
void gen_left_i64_i64_i64_i64_i64(int64_t x, int64_t y, int64_t ni, int64_t last, int64_t hi) {
LX[LN] = x;
LY[LN] = y;
LLAST[LN] = last;
LN = (LN + 1);
int64_t e = ni;
while (e <= hi) {
gen_left_i64_i64_i64_i64_i64((x + PX[e]), (y + PY[e]), (e + 3), e, hi);
e = (e + 1);
}
}
void gen_right_i64_i64_i64_i64_i64(int64_t x, int64_t y, int64_t ni, int64_t first, int64_t hi) {
RX[RN] = x;
RY[RN] = y;
RFIRST[RN] = first;
RN = (RN + 1);
int64_t e = ni;
while (e <= hi) {
gen_right_i64_i64_i64_i64_i64((x + PX[e]), (y + PY[e]), (e + 3), first, hi);
e = (e + 1);
}
}
void sort_right_by_y(void) {
int64_t* lo = (int64_t*)(calloc(64, 8));
int64_t* hi = (int64_t*)(calloc(64, 8));
int32_t sp = 0;
lo[0] = 0;
hi[0] = (RN - 1);
sp = 1;
while (sp > 0) {
sp = (sp - 1);
int64_t l = lo[sp];
int64_t h = hi[sp];
if (l >= h) {
continue;
}
int64_t mid = FLOW_CHECKED_DIV(((l + h)), (2));
int64_t py = RY[mid];
int64_t pf = RFIRST[mid];
int64_t i = l;
int64_t j = h;
while (i <= j) {
while (1) {
bool less = 0;
if (RY[i] < py) {
less = 1;
} else {
if (RY[i] == py) {
if (RFIRST[i] < pf) {
less = 1;
}
}
}
if ((!(less))) {
break;
}
i = (i + 1);
}
while (1) {
bool greater = 0;
if (RY[j] > py) {
greater = 1;
} else {
if (RY[j] == py) {
if (RFIRST[j] > pf) {
greater = 1;
}
}
}
if ((!(greater))) {
break;
}
j = (j - 1);
}
if (i <= j) {
int64_t tx = RX[i];
RX[i] = RX[j];
RX[j] = tx;
int64_t ty = RY[i];
RY[i] = RY[j];
RY[j] = ty;
int64_t tf = RFIRST[i];
RFIRST[i] = RFIRST[j];
RFIRST[j] = tf;
i = (i + 1);
j = (j - 1);
}
}
if (l < j) {
lo[sp] = l;
hi[sp] = j;
sp = (sp + 1);
}
if (i < h) {
lo[sp] = i;
hi[sp] = h;
sp = (sp + 1);
}
}
free(lo);
free(hi);
}
int32_t main(void) {
int64_t LIMIT = 10000000000;
PX = calloc(50, 8);
PY = calloc(50, 8);
int64_t* F = (int64_t*)(calloc(60, 8));
if (((PX == NULL || PY == NULL) || F == NULL)) {
return 1;
}
F[0] = 0;
F[1] = 1;
int64_t i = 2;
while (i < 60) {
F[i] = (F[(i - 1)] + F[(i - 2)]);
i = (i + 1);
}
PX[0] = 2;
PY[0] = 0;
i = 1;
while (i <= 48) {
int64_t Lk = (F[(i - 1)] + F[(i + 1)]);
int64_t Lk1 = (F[i] + F[(i + 2)]);
int64_t sign = (0 - 1);
if (((i + 1) & 1) == 0) {
sign = 1;
}
PX[i] = (Lk + (sign * Lk1));
PY[i] = (F[i] - (sign * F[(i + 1)]));
i = (i + 1);
}
int64_t CAP = 20000;
LX = calloc(CAP, 8);
LY = calloc(CAP, 8);
LLAST = calloc(CAP, 8);
RX = calloc(CAP, 8);
RY = calloc(CAP, 8);
RFIRST = calloc(CAP, 8);
if ((((((LX == NULL || LY == NULL) || LLAST == NULL) || RX == NULL) || RY == NULL) || RFIRST == NULL)) {
return 1;
}
LX[0] = 0;
LY[0] = 0;
LLAST[0] = (0 - 1000000000);
LN = 1;
i = 1;
while (i <= 24) {
gen_left_i64_i64_i64_i64_i64(PX[i], PY[i], (i + 3), i, 24);
i = (i + 1);
}
RX[0] = 0;
RY[0] = 0;
RFIRST[0] = 1000000000;
RN = 1;
i = 25;
while (i <= 48) {
gen_right_i64_i64_i64_i64_i64(PX[i], PY[i], (i + 3), i, 48);
i = (i + 1);
}
sort_right_by_y();
int64_t ans = 0;
int64_t li = 0;
while (li < LN) {
int64_t need = (0 - LY[li]);
int64_t last = LLAST[li];
int64_t lo = 0;
int64_t hi = RN;
while (lo < hi) {
int64_t mid = FLOW_CHECKED_DIV(((lo + hi)), (2));
if (RY[mid] < need) {
lo = (mid + 1);
} else {
hi = mid;
}
}
int64_t ri = lo;
while (ri < RN) {
if (RY[ri] != need) {
break;
}
if (RFIRST[ri] >= (last + 3)) {
int64_t xx = (LX[li] + RX[ri]);
int64_t v = FLOW_CHECKED_DIV((xx), (2));
if (v > 0) {
if (v <= LIMIT) {
ans = (ans + v);
}
}
}
ri = (ri + 1);
}
li = (li + 1);
}
printf("%lld\n", (ans + 1));
free(PX);
free(PY);
free(F);
free(LX);
free(LY);
free(LLAST);
free(RX);
free(RY);
free(RFIRST);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
// Module static: PX
llvm.mlir.global internal @PX() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: PY
llvm.mlir.global internal @PY() {addr_space = 0 : i32} : !llvm.ptr {
%1 = llvm.mlir.zero : !llvm.ptr
llvm.return %1 : !llvm.ptr
}
// Module static: LX
llvm.mlir.global internal @LX() {addr_space = 0 : i32} : !llvm.ptr {
%2 = llvm.mlir.zero : !llvm.ptr
llvm.return %2 : !llvm.ptr
}
// Module static: LY
llvm.mlir.global internal @LY() {addr_space = 0 : i32} : !llvm.ptr {
%3 = llvm.mlir.zero : !llvm.ptr
llvm.return %3 : !llvm.ptr
}
// Module static: LLAST
llvm.mlir.global internal @LLAST() {addr_space = 0 : i32} : !llvm.ptr {
%4 = llvm.mlir.zero : !llvm.ptr
llvm.return %4 : !llvm.ptr
}
// Module static: LN
llvm.mlir.global internal @LN(0 : i64) : i64
// Module static: RX
llvm.mlir.global internal @RX() {addr_space = 0 : i32} : !llvm.ptr {
%5 = llvm.mlir.zero : !llvm.ptr
llvm.return %5 : !llvm.ptr
}
// Module static: RY
llvm.mlir.global internal @RY() {addr_space = 0 : i32} : !llvm.ptr {
%6 = llvm.mlir.zero : !llvm.ptr
llvm.return %6 : !llvm.ptr
}
// Module static: RFIRST
llvm.mlir.global internal @RFIRST() {addr_space = 0 : i32} : !llvm.ptr {
%7 = llvm.mlir.zero : !llvm.ptr
llvm.return %7 : !llvm.ptr
}
// Module static: RN
llvm.mlir.global internal @RN(0 : i64) : i64
func.func @gen_left(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: i64, %arg4: i64) -> () {
%8 = llvm.mlir.addressof @LX : !llvm.ptr
%9 = llvm.load %8 : !llvm.ptr -> !llvm.ptr
%10 = llvm.mlir.addressof @LN : !llvm.ptr
%11 = llvm.load %10 : !llvm.ptr -> i64
%12 = llvm.getelementptr %9[%11] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg0, %12 : i64, !llvm.ptr
%13 = llvm.mlir.addressof @LY : !llvm.ptr
%14 = llvm.load %13 : !llvm.ptr -> !llvm.ptr
%15 = llvm.mlir.addressof @LN : !llvm.ptr
%16 = llvm.load %15 : !llvm.ptr -> i64
%17 = llvm.getelementptr %14[%16] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg1, %17 : i64, !llvm.ptr
%18 = llvm.mlir.addressof @LLAST : !llvm.ptr
%19 = llvm.load %18 : !llvm.ptr -> !llvm.ptr
%20 = llvm.mlir.addressof @LN : !llvm.ptr
%21 = llvm.load %20 : !llvm.ptr -> i64
%22 = llvm.getelementptr %19[%21] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg3, %22 : i64, !llvm.ptr
%23 = llvm.mlir.addressof @LN : !llvm.ptr
%24 = llvm.load %23 : !llvm.ptr -> i64
%25 = arith.constant 1 : i32
%27 = arith.extsi %25 : i32 to i64
%26 = arith.addi %24, %27 : i64
%28 = llvm.mlir.addressof @LN : !llvm.ptr
llvm.store %26, %28 : i64, !llvm.ptr
%29 = llvm.mlir.constant(1 : i64) : i64
%30 = llvm.alloca %29 x i64 : (i64) -> !llvm.ptr
llvm.store %arg2, %30 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%31 = llvm.load %30 : !llvm.ptr -> i64
%32 = arith.cmpi sle, %31, %arg4 : i64
cf.cond_br %32, ^bb1, ^bb2
^bb1:
%35 = llvm.mlir.addressof @PX : !llvm.ptr
%36 = llvm.load %35 : !llvm.ptr -> !llvm.ptr
%37 = llvm.load %30 : !llvm.ptr -> i64
%38 = llvm.getelementptr %36[%37] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%34 = llvm.load %38 : !llvm.ptr -> i64
%39 = arith.addi %arg0, %34 : i64
%41 = llvm.mlir.addressof @PY : !llvm.ptr
%42 = llvm.load %41 : !llvm.ptr -> !llvm.ptr
%43 = llvm.load %30 : !llvm.ptr -> i64
%44 = llvm.getelementptr %42[%43] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%40 = llvm.load %44 : !llvm.ptr -> i64
%45 = arith.addi %arg1, %40 : i64
%46 = llvm.load %30 : !llvm.ptr -> i64
%47 = arith.constant 3 : i32
%49 = arith.extsi %47 : i32 to i64
%48 = arith.addi %46, %49 : i64
%50 = llvm.load %30 : !llvm.ptr -> i64
func.call @gen_left(%39, %45, %48, %50, %arg4) : (i64, i64, i64, i64, i64) -> ()
%51 = llvm.load %30 : !llvm.ptr -> i64
%52 = arith.constant 1 : i32
%54 = arith.extsi %52 : i32 to i64
%53 = arith.addi %51, %54 : i64
llvm.store %53, %30 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
func.return
}
func.func @gen_right(%arg0: i64, %arg1: i64, %arg2: i64, %arg3: i64, %arg4: i64) -> () {
%55 = llvm.mlir.addressof @RX : !llvm.ptr
%56 = llvm.load %55 : !llvm.ptr -> !llvm.ptr
%57 = llvm.mlir.addressof @RN : !llvm.ptr
%58 = llvm.load %57 : !llvm.ptr -> i64
%59 = llvm.getelementptr %56[%58] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg0, %59 : i64, !llvm.ptr
%60 = llvm.mlir.addressof @RY : !llvm.ptr
%61 = llvm.load %60 : !llvm.ptr -> !llvm.ptr
%62 = llvm.mlir.addressof @RN : !llvm.ptr
%63 = llvm.load %62 : !llvm.ptr -> i64
%64 = llvm.getelementptr %61[%63] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg1, %64 : i64, !llvm.ptr
%65 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%66 = llvm.load %65 : !llvm.ptr -> !llvm.ptr
%67 = llvm.mlir.addressof @RN : !llvm.ptr
%68 = llvm.load %67 : !llvm.ptr -> i64
%69 = llvm.getelementptr %66[%68] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %arg3, %69 : i64, !llvm.ptr
%70 = llvm.mlir.addressof @RN : !llvm.ptr
%71 = llvm.load %70 : !llvm.ptr -> i64
%72 = arith.constant 1 : i32
%74 = arith.extsi %72 : i32 to i64
%73 = arith.addi %71, %74 : i64
%75 = llvm.mlir.addressof @RN : !llvm.ptr
llvm.store %73, %75 : i64, !llvm.ptr
%76 = llvm.mlir.constant(1 : i64) : i64
%77 = llvm.alloca %76 x i64 : (i64) -> !llvm.ptr
llvm.store %arg2, %77 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%78 = llvm.load %77 : !llvm.ptr -> i64
%79 = arith.cmpi sle, %78, %arg4 : i64
cf.cond_br %79, ^bb4, ^bb5
^bb4:
%82 = llvm.mlir.addressof @PX : !llvm.ptr
%83 = llvm.load %82 : !llvm.ptr -> !llvm.ptr
%84 = llvm.load %77 : !llvm.ptr -> i64
%85 = llvm.getelementptr %83[%84] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%81 = llvm.load %85 : !llvm.ptr -> i64
%86 = arith.addi %arg0, %81 : i64
%88 = llvm.mlir.addressof @PY : !llvm.ptr
%89 = llvm.load %88 : !llvm.ptr -> !llvm.ptr
%90 = llvm.load %77 : !llvm.ptr -> i64
%91 = llvm.getelementptr %89[%90] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%87 = llvm.load %91 : !llvm.ptr -> i64
%92 = arith.addi %arg1, %87 : i64
%93 = llvm.load %77 : !llvm.ptr -> i64
%94 = arith.constant 3 : i32
%96 = arith.extsi %94 : i32 to i64
%95 = arith.addi %93, %96 : i64
func.call @gen_right(%86, %92, %95, %arg3, %arg4) : (i64, i64, i64, i64, i64) -> ()
%97 = llvm.load %77 : !llvm.ptr -> i64
%98 = arith.constant 1 : i32
%100 = arith.extsi %98 : i32 to i64
%99 = arith.addi %97, %100 : i64
llvm.store %99, %77 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
func.return
}
func.func @sort_right_by_y() -> () {
%102 = arith.constant 64 : i32
%103 = arith.constant 8 : i32
%104 = arith.extsi %102 : i32 to i64
%105 = arith.extsi %103 : i32 to i64
%101 = func.call @calloc(%104, %105) : (i64, i64) -> !llvm.ptr
%107 = arith.constant 64 : i32
%108 = arith.constant 8 : i32
%109 = arith.extsi %107 : i32 to i64
%110 = arith.extsi %108 : i32 to i64
%106 = func.call @calloc(%109, %110) : (i64, i64) -> !llvm.ptr
%111 = arith.constant 0 : i32
%112 = llvm.mlir.constant(1 : i64) : i64
%113 = llvm.alloca %112 x i32 : (i64) -> !llvm.ptr
llvm.store %111, %113 : i32, !llvm.ptr
%114 = arith.constant 0 : i32
%115 = arith.constant 0 : i32
%116 = arith.extsi %114 : i32 to i64
%117 = arith.extsi %115 : i32 to i64
%118 = llvm.getelementptr %101[%117] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %116, %118 : i64, !llvm.ptr
%119 = llvm.mlir.addressof @RN : !llvm.ptr
%120 = llvm.load %119 : !llvm.ptr -> i64
%121 = arith.constant 1 : i32
%123 = arith.extsi %121 : i32 to i64
%122 = arith.subi %120, %123 : i64
%124 = arith.constant 0 : i32
%125 = arith.extsi %124 : i32 to i64
%126 = llvm.getelementptr %106[%125] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %122, %126 : i64, !llvm.ptr
%127 = arith.constant 1 : i32
llvm.store %127, %113 : i32, !llvm.ptr
cf.br ^bb6
^bb6:
%128 = llvm.load %113 : !llvm.ptr -> i32
%129 = arith.constant 0 : i32
%130 = arith.cmpi sgt, %128, %129 : i32
cf.cond_br %130, ^bb7, ^bb8
^bb7:
%131 = llvm.load %113 : !llvm.ptr -> i32
%132 = arith.constant 1 : i32
%133 = arith.subi %131, %132 : i32
llvm.store %133, %113 : i32, !llvm.ptr
%135 = llvm.load %113 : !llvm.ptr -> i32
%136 = arith.extsi %135 : i32 to i64
%137 = llvm.getelementptr %101[%136] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%134 = llvm.load %137 : !llvm.ptr -> i64
%139 = llvm.load %113 : !llvm.ptr -> i32
%140 = arith.extsi %139 : i32 to i64
%141 = llvm.getelementptr %106[%140] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%138 = llvm.load %141 : !llvm.ptr -> i64
%142 = arith.cmpi sge, %134, %138 : i64
cf.cond_br %142, ^bb9, ^bb10
^bb9:
cf.br ^bb6
^bb10:
cf.br ^bb11
^bb11:
%143 = arith.addi %134, %138 : i64
%144 = arith.constant 2 : i32
%146 = arith.extsi %144 : i32 to i64
%145 = arith.divsi %143, %146 : i64
%148 = llvm.mlir.addressof @RY : !llvm.ptr
%149 = llvm.load %148 : !llvm.ptr -> !llvm.ptr
%150 = llvm.getelementptr %149[%145] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%147 = llvm.load %150 : !llvm.ptr -> i64
%152 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%153 = llvm.load %152 : !llvm.ptr -> !llvm.ptr
%154 = llvm.getelementptr %153[%145] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%151 = llvm.load %154 : !llvm.ptr -> i64
%155 = llvm.mlir.constant(1 : i64) : i64
%156 = llvm.alloca %155 x i64 : (i64) -> !llvm.ptr
llvm.store %134, %156 : i64, !llvm.ptr
%157 = llvm.mlir.constant(1 : i64) : i64
%158 = llvm.alloca %157 x i64 : (i64) -> !llvm.ptr
llvm.store %138, %158 : i64, !llvm.ptr
cf.br ^bb12
^bb12:
%159 = llvm.load %156 : !llvm.ptr -> i64
%160 = llvm.load %158 : !llvm.ptr -> i64
%161 = arith.cmpi sle, %159, %160 : i64
cf.cond_br %161, ^bb13, ^bb14
^bb13:
cf.br ^bb15
^bb15:
%162 = arith.constant 1 : i1
cf.cond_br %162, ^bb16, ^bb17
^bb16:
%163 = arith.constant 0 : i1
%164 = llvm.mlir.constant(1 : i64) : i64
%165 = llvm.alloca %164 x i1 : (i64) -> !llvm.ptr
llvm.store %163, %165 : i1, !llvm.ptr
%167 = llvm.mlir.addressof @RY : !llvm.ptr
%168 = llvm.load %167 : !llvm.ptr -> !llvm.ptr
%169 = llvm.load %156 : !llvm.ptr -> i64
%170 = llvm.getelementptr %168[%169] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%166 = llvm.load %170 : !llvm.ptr -> i64
%171 = arith.cmpi slt, %166, %147 : i64
cf.cond_br %171, ^bb18, ^bb19
^bb18:
%172 = arith.constant 1 : i1
llvm.store %172, %165 : i1, !llvm.ptr
cf.br ^bb20
^bb19:
%174 = llvm.mlir.addressof @RY : !llvm.ptr
%175 = llvm.load %174 : !llvm.ptr -> !llvm.ptr
%176 = llvm.load %156 : !llvm.ptr -> i64
%177 = llvm.getelementptr %175[%176] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%173 = llvm.load %177 : !llvm.ptr -> i64
%178 = arith.cmpi eq, %173, %147 : i64
cf.cond_br %178, ^bb21, ^bb22
^bb21:
%180 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%181 = llvm.load %180 : !llvm.ptr -> !llvm.ptr
%182 = llvm.load %156 : !llvm.ptr -> i64
%183 = llvm.getelementptr %181[%182] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%179 = llvm.load %183 : !llvm.ptr -> i64
%184 = arith.cmpi slt, %179, %151 : i64
cf.cond_br %184, ^bb24, ^bb25
^bb24:
%185 = arith.constant 1 : i1
llvm.store %185, %165 : i1, !llvm.ptr
cf.br ^bb26
^bb25:
cf.br ^bb26
^bb26:
cf.br ^bb23
^bb22:
cf.br ^bb23
^bb23:
cf.br ^bb20
^bb20:
%186 = llvm.load %165 : !llvm.ptr -> i1
%188 = arith.constant 1 : i1
%187 = arith.xori %186, %188 : i1
cf.cond_br %187, ^bb27, ^bb28
^bb27:
cf.br ^bb17
^bb28:
cf.br ^bb29
^bb29:
%190 = llvm.load %156 : !llvm.ptr -> i64
%191 = arith.constant 1 : i32
%193 = arith.extsi %191 : i32 to i64
%192 = arith.addi %190, %193 : i64
llvm.store %192, %156 : i64, !llvm.ptr
cf.br ^bb15
^bb17:
cf.br ^bb30
^bb30:
%194 = arith.constant 1 : i1
cf.cond_br %194, ^bb31, ^bb32
^bb31:
%195 = arith.constant 0 : i1
%196 = llvm.mlir.constant(1 : i64) : i64
%197 = llvm.alloca %196 x i1 : (i64) -> !llvm.ptr
llvm.store %195, %197 : i1, !llvm.ptr
%199 = llvm.mlir.addressof @RY : !llvm.ptr
%200 = llvm.load %199 : !llvm.ptr -> !llvm.ptr
%201 = llvm.load %158 : !llvm.ptr -> i64
%202 = llvm.getelementptr %200[%201] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%198 = llvm.load %202 : !llvm.ptr -> i64
%203 = arith.cmpi sgt, %198, %147 : i64
cf.cond_br %203, ^bb33, ^bb34
^bb33:
%204 = arith.constant 1 : i1
llvm.store %204, %197 : i1, !llvm.ptr
cf.br ^bb35
^bb34:
%206 = llvm.mlir.addressof @RY : !llvm.ptr
%207 = llvm.load %206 : !llvm.ptr -> !llvm.ptr
%208 = llvm.load %158 : !llvm.ptr -> i64
%209 = llvm.getelementptr %207[%208] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%205 = llvm.load %209 : !llvm.ptr -> i64
%210 = arith.cmpi eq, %205, %147 : i64
cf.cond_br %210, ^bb36, ^bb37
^bb36:
%212 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%213 = llvm.load %212 : !llvm.ptr -> !llvm.ptr
%214 = llvm.load %158 : !llvm.ptr -> i64
%215 = llvm.getelementptr %213[%214] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%211 = llvm.load %215 : !llvm.ptr -> i64
%216 = arith.cmpi sgt, %211, %151 : i64
cf.cond_br %216, ^bb39, ^bb40
^bb39:
%217 = arith.constant 1 : i1
llvm.store %217, %197 : i1, !llvm.ptr
cf.br ^bb41
^bb40:
cf.br ^bb41
^bb41:
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
cf.br ^bb35
^bb35:
%218 = llvm.load %197 : !llvm.ptr -> i1
%220 = arith.constant 1 : i1
%219 = arith.xori %218, %220 : i1
cf.cond_br %219, ^bb42, ^bb43
^bb42:
cf.br ^bb32
^bb43:
cf.br ^bb44
^bb44:
%222 = llvm.load %158 : !llvm.ptr -> i64
%223 = arith.constant 1 : i32
%225 = arith.extsi %223 : i32 to i64
%224 = arith.subi %222, %225 : i64
llvm.store %224, %158 : i64, !llvm.ptr
cf.br ^bb30
^bb32:
%226 = llvm.load %156 : !llvm.ptr -> i64
%227 = llvm.load %158 : !llvm.ptr -> i64
%228 = arith.cmpi sle, %226, %227 : i64
cf.cond_br %228, ^bb45, ^bb46
^bb45:
%230 = llvm.mlir.addressof @RX : !llvm.ptr
%231 = llvm.load %230 : !llvm.ptr -> !llvm.ptr
%232 = llvm.load %156 : !llvm.ptr -> i64
%233 = llvm.getelementptr %231[%232] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%229 = llvm.load %233 : !llvm.ptr -> i64
%235 = llvm.mlir.addressof @RX : !llvm.ptr
%236 = llvm.load %235 : !llvm.ptr -> !llvm.ptr
%237 = llvm.load %158 : !llvm.ptr -> i64
%238 = llvm.getelementptr %236[%237] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%234 = llvm.load %238 : !llvm.ptr -> i64
%239 = llvm.mlir.addressof @RX : !llvm.ptr
%240 = llvm.load %239 : !llvm.ptr -> !llvm.ptr
%241 = llvm.load %156 : !llvm.ptr -> i64
%242 = llvm.getelementptr %240[%241] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %234, %242 : i64, !llvm.ptr
%243 = llvm.mlir.addressof @RX : !llvm.ptr
%244 = llvm.load %243 : !llvm.ptr -> !llvm.ptr
%245 = llvm.load %158 : !llvm.ptr -> i64
%246 = llvm.getelementptr %244[%245] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %229, %246 : i64, !llvm.ptr
%248 = llvm.mlir.addressof @RY : !llvm.ptr
%249 = llvm.load %248 : !llvm.ptr -> !llvm.ptr
%250 = llvm.load %156 : !llvm.ptr -> i64
%251 = llvm.getelementptr %249[%250] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%247 = llvm.load %251 : !llvm.ptr -> i64
%253 = llvm.mlir.addressof @RY : !llvm.ptr
%254 = llvm.load %253 : !llvm.ptr -> !llvm.ptr
%255 = llvm.load %158 : !llvm.ptr -> i64
%256 = llvm.getelementptr %254[%255] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%252 = llvm.load %256 : !llvm.ptr -> i64
%257 = llvm.mlir.addressof @RY : !llvm.ptr
%258 = llvm.load %257 : !llvm.ptr -> !llvm.ptr
%259 = llvm.load %156 : !llvm.ptr -> i64
%260 = llvm.getelementptr %258[%259] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %252, %260 : i64, !llvm.ptr
%261 = llvm.mlir.addressof @RY : !llvm.ptr
%262 = llvm.load %261 : !llvm.ptr -> !llvm.ptr
%263 = llvm.load %158 : !llvm.ptr -> i64
%264 = llvm.getelementptr %262[%263] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %247, %264 : i64, !llvm.ptr
%266 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%267 = llvm.load %266 : !llvm.ptr -> !llvm.ptr
%268 = llvm.load %156 : !llvm.ptr -> i64
%269 = llvm.getelementptr %267[%268] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%265 = llvm.load %269 : !llvm.ptr -> i64
%271 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%272 = llvm.load %271 : !llvm.ptr -> !llvm.ptr
%273 = llvm.load %158 : !llvm.ptr -> i64
%274 = llvm.getelementptr %272[%273] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%270 = llvm.load %274 : !llvm.ptr -> i64
%275 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%276 = llvm.load %275 : !llvm.ptr -> !llvm.ptr
%277 = llvm.load %156 : !llvm.ptr -> i64
%278 = llvm.getelementptr %276[%277] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %270, %278 : i64, !llvm.ptr
%279 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%280 = llvm.load %279 : !llvm.ptr -> !llvm.ptr
%281 = llvm.load %158 : !llvm.ptr -> i64
%282 = llvm.getelementptr %280[%281] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %265, %282 : i64, !llvm.ptr
%283 = llvm.load %156 : !llvm.ptr -> i64
%284 = arith.constant 1 : i32
%286 = arith.extsi %284 : i32 to i64
%285 = arith.addi %283, %286 : i64
llvm.store %285, %156 : i64, !llvm.ptr
%287 = llvm.load %158 : !llvm.ptr -> i64
%288 = arith.constant 1 : i32
%290 = arith.extsi %288 : i32 to i64
%289 = arith.subi %287, %290 : i64
llvm.store %289, %158 : i64, !llvm.ptr
cf.br ^bb47
^bb46:
cf.br ^bb47
^bb47:
cf.br ^bb12
^bb14:
%291 = llvm.load %158 : !llvm.ptr -> i64
%292 = arith.cmpi slt, %134, %291 : i64
cf.cond_br %292, ^bb48, ^bb49
^bb48:
%293 = llvm.load %113 : !llvm.ptr -> i32
%294 = arith.extsi %293 : i32 to i64
%295 = llvm.getelementptr %101[%294] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %134, %295 : i64, !llvm.ptr
%296 = llvm.load %158 : !llvm.ptr -> i64
%297 = llvm.load %113 : !llvm.ptr -> i32
%298 = arith.extsi %297 : i32 to i64
%299 = llvm.getelementptr %106[%298] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %296, %299 : i64, !llvm.ptr
%300 = llvm.load %113 : !llvm.ptr -> i32
%301 = arith.constant 1 : i32
%302 = arith.addi %300, %301 : i32
llvm.store %302, %113 : i32, !llvm.ptr
cf.br ^bb50
^bb49:
cf.br ^bb50
^bb50:
%303 = llvm.load %156 : !llvm.ptr -> i64
%304 = arith.cmpi slt, %303, %138 : i64
cf.cond_br %304, ^bb51, ^bb52
^bb51:
%305 = llvm.load %156 : !llvm.ptr -> i64
%306 = llvm.load %113 : !llvm.ptr -> i32
%307 = arith.extsi %306 : i32 to i64
%308 = llvm.getelementptr %101[%307] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %305, %308 : i64, !llvm.ptr
%309 = llvm.load %113 : !llvm.ptr -> i32
%310 = arith.extsi %309 : i32 to i64
%311 = llvm.getelementptr %106[%310] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %138, %311 : i64, !llvm.ptr
%312 = llvm.load %113 : !llvm.ptr -> i32
%313 = arith.constant 1 : i32
%314 = arith.addi %312, %313 : i32
llvm.store %314, %113 : i32, !llvm.ptr
cf.br ^bb53
^bb52:
cf.br ^bb53
^bb53:
cf.br ^bb6
^bb8:
func.call @free(%101) : (!llvm.ptr) -> ()
func.call @free(%106) : (!llvm.ptr) -> ()
func.return
}
func.func @main() -> i32 {
%317 = arith.constant 5705032704 : i32
%318 = arith.extsi %317 : i32 to i64
%320 = arith.constant 50 : i32
%321 = arith.constant 8 : i32
%322 = arith.extsi %320 : i32 to i64
%323 = arith.extsi %321 : i32 to i64
%319 = func.call @calloc(%322, %323) : (i64, i64) -> !llvm.ptr
%324 = llvm.mlir.addressof @PX : !llvm.ptr
llvm.store %319, %324 : !llvm.ptr, !llvm.ptr
%326 = arith.constant 50 : i32
%327 = arith.constant 8 : i32
%328 = arith.extsi %326 : i32 to i64
%329 = arith.extsi %327 : i32 to i64
%325 = func.call @calloc(%328, %329) : (i64, i64) -> !llvm.ptr
%330 = llvm.mlir.addressof @PY : !llvm.ptr
llvm.store %325, %330 : !llvm.ptr, !llvm.ptr
%332 = arith.constant 60 : i32
%333 = arith.constant 8 : i32
%334 = arith.extsi %332 : i32 to i64
%335 = arith.extsi %333 : i32 to i64
%331 = func.call @calloc(%334, %335) : (i64, i64) -> !llvm.ptr
%336 = llvm.mlir.addressof @PX : !llvm.ptr
%337 = llvm.load %336 : !llvm.ptr -> !llvm.ptr
%338 = llvm.mlir.zero : !llvm.ptr
%339 = llvm.icmp "eq" %337, %338 : !llvm.ptr
%340 = scf.if %339 -> (i1) {
%341 = arith.constant true
scf.yield %341 : i1
} else {
%342 = llvm.mlir.addressof @PY : !llvm.ptr
%343 = llvm.load %342 : !llvm.ptr -> !llvm.ptr
%344 = llvm.mlir.zero : !llvm.ptr
%345 = llvm.icmp "eq" %343, %344 : !llvm.ptr
scf.yield %345 : i1
}
%346 = scf.if %340 -> (i1) {
%347 = arith.constant true
scf.yield %347 : i1
} else {
%348 = llvm.mlir.zero : !llvm.ptr
%349 = llvm.icmp "eq" %331, %348 : !llvm.ptr
scf.yield %349 : i1
}
cf.cond_br %346, ^bb54, ^bb55
^bb54:
%350 = arith.constant 1 : i32
func.return %350 : i32
^bb55:
cf.br ^bb56
^bb56:
%351 = arith.constant 0 : i32
%352 = arith.constant 0 : i32
%353 = arith.extsi %351 : i32 to i64
%354 = arith.extsi %352 : i32 to i64
%355 = llvm.getelementptr %331[%354] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %353, %355 : i64, !llvm.ptr
%356 = arith.constant 1 : i32
%357 = arith.constant 1 : i32
%358 = arith.extsi %356 : i32 to i64
%359 = arith.extsi %357 : i32 to i64
%360 = llvm.getelementptr %331[%359] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %358, %360 : i64, !llvm.ptr
%361 = arith.constant 2 : i32
%362 = arith.extsi %361 : i32 to i64
%363 = llvm.mlir.constant(1 : i64) : i64
%364 = llvm.alloca %363 x i64 : (i64) -> !llvm.ptr
llvm.store %362, %364 : i64, !llvm.ptr
cf.br ^bb57
^bb57:
%365 = llvm.load %364 : !llvm.ptr -> i64
%366 = arith.constant 60 : i32
%368 = arith.extsi %366 : i32 to i64
%367 = arith.cmpi slt, %365, %368 : i64
cf.cond_br %367, ^bb58, ^bb59
^bb58:
%370 = llvm.load %364 : !llvm.ptr -> i64
%371 = arith.constant 1 : i32
%373 = arith.extsi %371 : i32 to i64
%372 = arith.subi %370, %373 : i64
%374 = llvm.getelementptr %331[%372] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%369 = llvm.load %374 : !llvm.ptr -> i64
%376 = llvm.load %364 : !llvm.ptr -> i64
%377 = arith.constant 2 : i32
%379 = arith.extsi %377 : i32 to i64
%378 = arith.subi %376, %379 : i64
%380 = llvm.getelementptr %331[%378] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%375 = llvm.load %380 : !llvm.ptr -> i64
%381 = arith.addi %369, %375 : i64
%382 = llvm.load %364 : !llvm.ptr -> i64
%383 = llvm.getelementptr %331[%382] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %381, %383 : i64, !llvm.ptr
%384 = llvm.load %364 : !llvm.ptr -> i64
%385 = arith.constant 1 : i32
%387 = arith.extsi %385 : i32 to i64
%386 = arith.addi %384, %387 : i64
llvm.store %386, %364 : i64, !llvm.ptr
cf.br ^bb57
^bb59:
%388 = arith.constant 2 : i32
%389 = llvm.mlir.addressof @PX : !llvm.ptr
%390 = llvm.load %389 : !llvm.ptr -> !llvm.ptr
%391 = arith.constant 0 : i32
%392 = arith.extsi %388 : i32 to i64
%393 = arith.extsi %391 : i32 to i64
%394 = llvm.getelementptr %390[%393] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %392, %394 : i64, !llvm.ptr
%395 = arith.constant 0 : i32
%396 = llvm.mlir.addressof @PY : !llvm.ptr
%397 = llvm.load %396 : !llvm.ptr -> !llvm.ptr
%398 = arith.constant 0 : i32
%399 = arith.extsi %395 : i32 to i64
%400 = arith.extsi %398 : i32 to i64
%401 = llvm.getelementptr %397[%400] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %399, %401 : i64, !llvm.ptr
%402 = arith.constant 1 : i32
%403 = arith.extsi %402 : i32 to i64
llvm.store %403, %364 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%404 = llvm.load %364 : !llvm.ptr -> i64
%405 = arith.constant 48 : i32
%407 = arith.extsi %405 : i32 to i64
%406 = arith.cmpi sle, %404, %407 : i64
cf.cond_br %406, ^bb61, ^bb62
^bb61:
%409 = llvm.load %364 : !llvm.ptr -> i64
%410 = arith.constant 1 : i32
%412 = arith.extsi %410 : i32 to i64
%411 = arith.subi %409, %412 : i64
%413 = llvm.getelementptr %331[%411] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%408 = llvm.load %413 : !llvm.ptr -> i64
%415 = llvm.load %364 : !llvm.ptr -> i64
%416 = arith.constant 1 : i32
%418 = arith.extsi %416 : i32 to i64
%417 = arith.addi %415, %418 : i64
%419 = llvm.getelementptr %331[%417] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%414 = llvm.load %419 : !llvm.ptr -> i64
%420 = arith.addi %408, %414 : i64
%422 = llvm.load %364 : !llvm.ptr -> i64
%423 = llvm.getelementptr %331[%422] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%421 = llvm.load %423 : !llvm.ptr -> i64
%425 = llvm.load %364 : !llvm.ptr -> i64
%426 = arith.constant 2 : i32
%428 = arith.extsi %426 : i32 to i64
%427 = arith.addi %425, %428 : i64
%429 = llvm.getelementptr %331[%427] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%424 = llvm.load %429 : !llvm.ptr -> i64
%430 = arith.addi %421, %424 : i64
%431 = arith.constant 0 : i32
%432 = arith.constant 1 : i32
%433 = arith.subi %431, %432 : i32
%434 = arith.extsi %433 : i32 to i64
%435 = llvm.mlir.constant(1 : i64) : i64
%436 = llvm.alloca %435 x i64 : (i64) -> !llvm.ptr
llvm.store %434, %436 : i64, !llvm.ptr
%437 = llvm.load %364 : !llvm.ptr -> i64
%438 = arith.constant 1 : i32
%440 = arith.extsi %438 : i32 to i64
%439 = arith.addi %437, %440 : i64
%441 = arith.constant 1 : i32
%443 = arith.extsi %441 : i32 to i64
%442 = arith.andi %439, %443 : i64
%444 = arith.constant 0 : i32
%446 = arith.extsi %444 : i32 to i64
%445 = arith.cmpi eq, %442, %446 : i64
cf.cond_br %445, ^bb63, ^bb64
^bb63:
%447 = arith.constant 1 : i32
%448 = arith.extsi %447 : i32 to i64
llvm.store %448, %436 : i64, !llvm.ptr
cf.br ^bb65
^bb64:
cf.br ^bb65
^bb65:
%449 = llvm.load %436 : !llvm.ptr -> i64
%450 = arith.muli %449, %430 : i64
%451 = arith.addi %420, %450 : i64
%452 = llvm.mlir.addressof @PX : !llvm.ptr
%453 = llvm.load %452 : !llvm.ptr -> !llvm.ptr
%454 = llvm.load %364 : !llvm.ptr -> i64
%455 = llvm.getelementptr %453[%454] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %451, %455 : i64, !llvm.ptr
%457 = llvm.load %364 : !llvm.ptr -> i64
%458 = llvm.getelementptr %331[%457] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%456 = llvm.load %458 : !llvm.ptr -> i64
%459 = llvm.load %436 : !llvm.ptr -> i64
%461 = llvm.load %364 : !llvm.ptr -> i64
%462 = arith.constant 1 : i32
%464 = arith.extsi %462 : i32 to i64
%463 = arith.addi %461, %464 : i64
%465 = llvm.getelementptr %331[%463] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%460 = llvm.load %465 : !llvm.ptr -> i64
%466 = arith.muli %459, %460 : i64
%467 = arith.subi %456, %466 : i64
%468 = llvm.mlir.addressof @PY : !llvm.ptr
%469 = llvm.load %468 : !llvm.ptr -> !llvm.ptr
%470 = llvm.load %364 : !llvm.ptr -> i64
%471 = llvm.getelementptr %469[%470] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %467, %471 : i64, !llvm.ptr
%472 = llvm.load %364 : !llvm.ptr -> i64
%473 = arith.constant 1 : i32
%475 = arith.extsi %473 : i32 to i64
%474 = arith.addi %472, %475 : i64
llvm.store %474, %364 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%476 = arith.constant 20000 : i32
%477 = arith.extsi %476 : i32 to i64
%479 = arith.constant 8 : i32
%480 = arith.extsi %479 : i32 to i64
%478 = func.call @calloc(%477, %480) : (i64, i64) -> !llvm.ptr
%481 = llvm.mlir.addressof @LX : !llvm.ptr
llvm.store %478, %481 : !llvm.ptr, !llvm.ptr
%483 = arith.constant 8 : i32
%484 = arith.extsi %483 : i32 to i64
%482 = func.call @calloc(%477, %484) : (i64, i64) -> !llvm.ptr
%485 = llvm.mlir.addressof @LY : !llvm.ptr
llvm.store %482, %485 : !llvm.ptr, !llvm.ptr
%487 = arith.constant 8 : i32
%488 = arith.extsi %487 : i32 to i64
%486 = func.call @calloc(%477, %488) : (i64, i64) -> !llvm.ptr
%489 = llvm.mlir.addressof @LLAST : !llvm.ptr
llvm.store %486, %489 : !llvm.ptr, !llvm.ptr
%491 = arith.constant 8 : i32
%492 = arith.extsi %491 : i32 to i64
%490 = func.call @calloc(%477, %492) : (i64, i64) -> !llvm.ptr
%493 = llvm.mlir.addressof @RX : !llvm.ptr
llvm.store %490, %493 : !llvm.ptr, !llvm.ptr
%495 = arith.constant 8 : i32
%496 = arith.extsi %495 : i32 to i64
%494 = func.call @calloc(%477, %496) : (i64, i64) -> !llvm.ptr
%497 = llvm.mlir.addressof @RY : !llvm.ptr
llvm.store %494, %497 : !llvm.ptr, !llvm.ptr
%499 = arith.constant 8 : i32
%500 = arith.extsi %499 : i32 to i64
%498 = func.call @calloc(%477, %500) : (i64, i64) -> !llvm.ptr
%501 = llvm.mlir.addressof @RFIRST : !llvm.ptr
llvm.store %498, %501 : !llvm.ptr, !llvm.ptr
%502 = llvm.mlir.addressof @LX : !llvm.ptr
%503 = llvm.load %502 : !llvm.ptr -> !llvm.ptr
%504 = llvm.mlir.zero : !llvm.ptr
%505 = llvm.icmp "eq" %503, %504 : !llvm.ptr
%506 = scf.if %505 -> (i1) {
%507 = arith.constant true
scf.yield %507 : i1
} else {
%508 = llvm.mlir.addressof @LY : !llvm.ptr
%509 = llvm.load %508 : !llvm.ptr -> !llvm.ptr
%510 = llvm.mlir.zero : !llvm.ptr
%511 = llvm.icmp "eq" %509, %510 : !llvm.ptr
scf.yield %511 : i1
}
%512 = scf.if %506 -> (i1) {
%513 = arith.constant true
scf.yield %513 : i1
} else {
%514 = llvm.mlir.addressof @LLAST : !llvm.ptr
%515 = llvm.load %514 : !llvm.ptr -> !llvm.ptr
%516 = llvm.mlir.zero : !llvm.ptr
%517 = llvm.icmp "eq" %515, %516 : !llvm.ptr
scf.yield %517 : i1
}
%518 = scf.if %512 -> (i1) {
%519 = arith.constant true
scf.yield %519 : i1
} else {
%520 = llvm.mlir.addressof @RX : !llvm.ptr
%521 = llvm.load %520 : !llvm.ptr -> !llvm.ptr
%522 = llvm.mlir.zero : !llvm.ptr
%523 = llvm.icmp "eq" %521, %522 : !llvm.ptr
scf.yield %523 : i1
}
%524 = scf.if %518 -> (i1) {
%525 = arith.constant true
scf.yield %525 : i1
} else {
%526 = llvm.mlir.addressof @RY : !llvm.ptr
%527 = llvm.load %526 : !llvm.ptr -> !llvm.ptr
%528 = llvm.mlir.zero : !llvm.ptr
%529 = llvm.icmp "eq" %527, %528 : !llvm.ptr
scf.yield %529 : i1
}
%530 = scf.if %524 -> (i1) {
%531 = arith.constant true
scf.yield %531 : i1
} else {
%532 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%533 = llvm.load %532 : !llvm.ptr -> !llvm.ptr
%534 = llvm.mlir.zero : !llvm.ptr
%535 = llvm.icmp "eq" %533, %534 : !llvm.ptr
scf.yield %535 : i1
}
cf.cond_br %530, ^bb66, ^bb67
^bb66:
%536 = arith.constant 1 : i32
func.return %536 : i32
^bb67:
cf.br ^bb68
^bb68:
%537 = arith.constant 0 : i32
%538 = llvm.mlir.addressof @LX : !llvm.ptr
%539 = llvm.load %538 : !llvm.ptr -> !llvm.ptr
%540 = arith.constant 0 : i32
%541 = arith.extsi %537 : i32 to i64
%542 = arith.extsi %540 : i32 to i64
%543 = llvm.getelementptr %539[%542] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %541, %543 : i64, !llvm.ptr
%544 = arith.constant 0 : i32
%545 = llvm.mlir.addressof @LY : !llvm.ptr
%546 = llvm.load %545 : !llvm.ptr -> !llvm.ptr
%547 = arith.constant 0 : i32
%548 = arith.extsi %544 : i32 to i64
%549 = arith.extsi %547 : i32 to i64
%550 = llvm.getelementptr %546[%549] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %548, %550 : i64, !llvm.ptr
%551 = arith.constant 0 : i32
%552 = arith.constant 1000000000 : i32
%553 = arith.subi %551, %552 : i32
%554 = llvm.mlir.addressof @LLAST : !llvm.ptr
%555 = llvm.load %554 : !llvm.ptr -> !llvm.ptr
%556 = arith.constant 0 : i32
%557 = arith.extsi %553 : i32 to i64
%558 = arith.extsi %556 : i32 to i64
%559 = llvm.getelementptr %555[%558] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %557, %559 : i64, !llvm.ptr
%560 = arith.constant 1 : i32
%561 = arith.extsi %560 : i32 to i64
%562 = llvm.mlir.addressof @LN : !llvm.ptr
llvm.store %561, %562 : i64, !llvm.ptr
%563 = arith.constant 1 : i32
%564 = arith.extsi %563 : i32 to i64
llvm.store %564, %364 : i64, !llvm.ptr
cf.br ^bb69
^bb69:
%565 = llvm.load %364 : !llvm.ptr -> i64
%566 = arith.constant 24 : i32
%568 = arith.extsi %566 : i32 to i64
%567 = arith.cmpi sle, %565, %568 : i64
cf.cond_br %567, ^bb70, ^bb71
^bb70:
%571 = llvm.mlir.addressof @PX : !llvm.ptr
%572 = llvm.load %571 : !llvm.ptr -> !llvm.ptr
%573 = llvm.load %364 : !llvm.ptr -> i64
%574 = llvm.getelementptr %572[%573] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%570 = llvm.load %574 : !llvm.ptr -> i64
%576 = llvm.mlir.addressof @PY : !llvm.ptr
%577 = llvm.load %576 : !llvm.ptr -> !llvm.ptr
%578 = llvm.load %364 : !llvm.ptr -> i64
%579 = llvm.getelementptr %577[%578] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%575 = llvm.load %579 : !llvm.ptr -> i64
%580 = llvm.load %364 : !llvm.ptr -> i64
%581 = arith.constant 3 : i32
%583 = arith.extsi %581 : i32 to i64
%582 = arith.addi %580, %583 : i64
%584 = llvm.load %364 : !llvm.ptr -> i64
%585 = arith.constant 24 : i32
%586 = arith.extsi %585 : i32 to i64
func.call @gen_left(%570, %575, %582, %584, %586) : (i64, i64, i64, i64, i64) -> ()
%587 = llvm.load %364 : !llvm.ptr -> i64
%588 = arith.constant 1 : i32
%590 = arith.extsi %588 : i32 to i64
%589 = arith.addi %587, %590 : i64
llvm.store %589, %364 : i64, !llvm.ptr
cf.br ^bb69
^bb71:
%591 = arith.constant 0 : i32
%592 = llvm.mlir.addressof @RX : !llvm.ptr
%593 = llvm.load %592 : !llvm.ptr -> !llvm.ptr
%594 = arith.constant 0 : i32
%595 = arith.extsi %591 : i32 to i64
%596 = arith.extsi %594 : i32 to i64
%597 = llvm.getelementptr %593[%596] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %595, %597 : i64, !llvm.ptr
%598 = arith.constant 0 : i32
%599 = llvm.mlir.addressof @RY : !llvm.ptr
%600 = llvm.load %599 : !llvm.ptr -> !llvm.ptr
%601 = arith.constant 0 : i32
%602 = arith.extsi %598 : i32 to i64
%603 = arith.extsi %601 : i32 to i64
%604 = llvm.getelementptr %600[%603] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %602, %604 : i64, !llvm.ptr
%605 = arith.constant 1000000000 : i32
%606 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%607 = llvm.load %606 : !llvm.ptr -> !llvm.ptr
%608 = arith.constant 0 : i32
%609 = arith.extsi %605 : i32 to i64
%610 = arith.extsi %608 : i32 to i64
%611 = llvm.getelementptr %607[%610] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %609, %611 : i64, !llvm.ptr
%612 = arith.constant 1 : i32
%613 = arith.extsi %612 : i32 to i64
%614 = llvm.mlir.addressof @RN : !llvm.ptr
llvm.store %613, %614 : i64, !llvm.ptr
%615 = arith.constant 25 : i32
%616 = arith.extsi %615 : i32 to i64
llvm.store %616, %364 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%617 = llvm.load %364 : !llvm.ptr -> i64
%618 = arith.constant 48 : i32
%620 = arith.extsi %618 : i32 to i64
%619 = arith.cmpi sle, %617, %620 : i64
cf.cond_br %619, ^bb73, ^bb74
^bb73:
%623 = llvm.mlir.addressof @PX : !llvm.ptr
%624 = llvm.load %623 : !llvm.ptr -> !llvm.ptr
%625 = llvm.load %364 : !llvm.ptr -> i64
%626 = llvm.getelementptr %624[%625] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%622 = llvm.load %626 : !llvm.ptr -> i64
%628 = llvm.mlir.addressof @PY : !llvm.ptr
%629 = llvm.load %628 : !llvm.ptr -> !llvm.ptr
%630 = llvm.load %364 : !llvm.ptr -> i64
%631 = llvm.getelementptr %629[%630] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%627 = llvm.load %631 : !llvm.ptr -> i64
%632 = llvm.load %364 : !llvm.ptr -> i64
%633 = arith.constant 3 : i32
%635 = arith.extsi %633 : i32 to i64
%634 = arith.addi %632, %635 : i64
%636 = llvm.load %364 : !llvm.ptr -> i64
%637 = arith.constant 48 : i32
%638 = arith.extsi %637 : i32 to i64
func.call @gen_right(%622, %627, %634, %636, %638) : (i64, i64, i64, i64, i64) -> ()
%639 = llvm.load %364 : !llvm.ptr -> i64
%640 = arith.constant 1 : i32
%642 = arith.extsi %640 : i32 to i64
%641 = arith.addi %639, %642 : i64
llvm.store %641, %364 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
func.call @sort_right_by_y() : () -> ()
%644 = arith.constant 0 : i32
%645 = arith.extsi %644 : i32 to i64
%646 = llvm.mlir.constant(1 : i64) : i64
%647 = llvm.alloca %646 x i64 : (i64) -> !llvm.ptr
llvm.store %645, %647 : i64, !llvm.ptr
%648 = arith.constant 0 : i32
%649 = arith.extsi %648 : i32 to i64
%650 = llvm.mlir.constant(1 : i64) : i64
%651 = llvm.alloca %650 x i64 : (i64) -> !llvm.ptr
llvm.store %649, %651 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%652 = llvm.load %651 : !llvm.ptr -> i64
%653 = llvm.mlir.addressof @LN : !llvm.ptr
%654 = llvm.load %653 : !llvm.ptr -> i64
%655 = arith.cmpi slt, %652, %654 : i64
cf.cond_br %655, ^bb76, ^bb77
^bb76:
%656 = arith.constant 0 : i32
%658 = llvm.mlir.addressof @LY : !llvm.ptr
%659 = llvm.load %658 : !llvm.ptr -> !llvm.ptr
%660 = llvm.load %651 : !llvm.ptr -> i64
%661 = llvm.getelementptr %659[%660] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%657 = llvm.load %661 : !llvm.ptr -> i64
%663 = arith.extsi %656 : i32 to i64
%662 = arith.subi %663, %657 : i64
%665 = llvm.mlir.addressof @LLAST : !llvm.ptr
%666 = llvm.load %665 : !llvm.ptr -> !llvm.ptr
%667 = llvm.load %651 : !llvm.ptr -> i64
%668 = llvm.getelementptr %666[%667] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%664 = llvm.load %668 : !llvm.ptr -> i64
%669 = arith.constant 0 : i32
%670 = arith.extsi %669 : i32 to i64
%671 = llvm.mlir.constant(1 : i64) : i64
%672 = llvm.alloca %671 x i64 : (i64) -> !llvm.ptr
llvm.store %670, %672 : i64, !llvm.ptr
%673 = llvm.mlir.addressof @RN : !llvm.ptr
%674 = llvm.load %673 : !llvm.ptr -> i64
%675 = llvm.mlir.constant(1 : i64) : i64
%676 = llvm.alloca %675 x i64 : (i64) -> !llvm.ptr
llvm.store %674, %676 : i64, !llvm.ptr
cf.br ^bb78
^bb78:
%677 = llvm.load %672 : !llvm.ptr -> i64
%678 = llvm.load %676 : !llvm.ptr -> i64
%679 = arith.cmpi slt, %677, %678 : i64
cf.cond_br %679, ^bb79, ^bb80
^bb79:
%680 = llvm.load %672 : !llvm.ptr -> i64
%681 = llvm.load %676 : !llvm.ptr -> i64
%682 = arith.addi %680, %681 : i64
%683 = arith.constant 2 : i32
%685 = arith.extsi %683 : i32 to i64
%684 = arith.divsi %682, %685 : i64
%687 = llvm.mlir.addressof @RY : !llvm.ptr
%688 = llvm.load %687 : !llvm.ptr -> !llvm.ptr
%689 = llvm.getelementptr %688[%684] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%686 = llvm.load %689 : !llvm.ptr -> i64
%690 = arith.cmpi slt, %686, %662 : i64
cf.cond_br %690, ^bb81, ^bb82
^bb81:
%691 = arith.constant 1 : i32
%693 = arith.extsi %691 : i32 to i64
%692 = arith.addi %684, %693 : i64
llvm.store %692, %672 : i64, !llvm.ptr
cf.br ^bb83
^bb82:
llvm.store %684, %676 : i64, !llvm.ptr
cf.br ^bb83
^bb83:
cf.br ^bb78
^bb80:
%694 = llvm.load %672 : !llvm.ptr -> i64
%695 = llvm.mlir.constant(1 : i64) : i64
%696 = llvm.alloca %695 x i64 : (i64) -> !llvm.ptr
llvm.store %694, %696 : i64, !llvm.ptr
cf.br ^bb84
^bb84:
%697 = llvm.load %696 : !llvm.ptr -> i64
%698 = llvm.mlir.addressof @RN : !llvm.ptr
%699 = llvm.load %698 : !llvm.ptr -> i64
%700 = arith.cmpi slt, %697, %699 : i64
cf.cond_br %700, ^bb85, ^bb86
^bb85:
%702 = llvm.mlir.addressof @RY : !llvm.ptr
%703 = llvm.load %702 : !llvm.ptr -> !llvm.ptr
%704 = llvm.load %696 : !llvm.ptr -> i64
%705 = llvm.getelementptr %703[%704] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%701 = llvm.load %705 : !llvm.ptr -> i64
%706 = arith.cmpi ne, %701, %662 : i64
cf.cond_br %706, ^bb87, ^bb88
^bb87:
cf.br ^bb86
^bb88:
cf.br ^bb89
^bb89:
%708 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%709 = llvm.load %708 : !llvm.ptr -> !llvm.ptr
%710 = llvm.load %696 : !llvm.ptr -> i64
%711 = llvm.getelementptr %709[%710] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%707 = llvm.load %711 : !llvm.ptr -> i64
%712 = arith.constant 3 : i32
%714 = arith.extsi %712 : i32 to i64
%713 = arith.addi %664, %714 : i64
%715 = arith.cmpi sge, %707, %713 : i64
cf.cond_br %715, ^bb90, ^bb91
^bb90:
%717 = llvm.mlir.addressof @LX : !llvm.ptr
%718 = llvm.load %717 : !llvm.ptr -> !llvm.ptr
%719 = llvm.load %651 : !llvm.ptr -> i64
%720 = llvm.getelementptr %718[%719] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%716 = llvm.load %720 : !llvm.ptr -> i64
%722 = llvm.mlir.addressof @RX : !llvm.ptr
%723 = llvm.load %722 : !llvm.ptr -> !llvm.ptr
%724 = llvm.load %696 : !llvm.ptr -> i64
%725 = llvm.getelementptr %723[%724] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%721 = llvm.load %725 : !llvm.ptr -> i64
%726 = arith.addi %716, %721 : i64
%727 = arith.constant 2 : i32
%729 = arith.extsi %727 : i32 to i64
%728 = arith.divsi %726, %729 : i64
%730 = arith.constant 0 : i32
%732 = arith.extsi %730 : i32 to i64
%731 = arith.cmpi sgt, %728, %732 : i64
cf.cond_br %731, ^bb93, ^bb94
^bb93:
%733 = arith.cmpi sle, %728, %318 : i64
cf.cond_br %733, ^bb96, ^bb97
^bb96:
%734 = llvm.load %647 : !llvm.ptr -> i64
%735 = arith.addi %734, %728 : i64
llvm.store %735, %647 : i64, !llvm.ptr
cf.br ^bb98
^bb97:
cf.br ^bb98
^bb98:
cf.br ^bb95
^bb94:
cf.br ^bb95
^bb95:
cf.br ^bb92
^bb91:
cf.br ^bb92
^bb92:
%736 = llvm.load %696 : !llvm.ptr -> i64
%737 = arith.constant 1 : i32
%739 = arith.extsi %737 : i32 to i64
%738 = arith.addi %736, %739 : i64
llvm.store %738, %696 : i64, !llvm.ptr
cf.br ^bb84
^bb86:
%740 = llvm.load %651 : !llvm.ptr -> i64
%741 = arith.constant 1 : i32
%743 = arith.extsi %741 : i32 to i64
%742 = arith.addi %740, %743 : i64
llvm.store %742, %651 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
%744 = llvm.mlir.addressof @str_0 : !llvm.ptr
%745 = llvm.load %647 : !llvm.ptr -> i64
%746 = arith.constant 1 : i32
%748 = arith.extsi %746 : i32 to i64
%747 = arith.addi %745, %748 : i64
%749 = llvm.call @printf(%744, %747) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%751 = llvm.mlir.addressof @PX : !llvm.ptr
%752 = llvm.load %751 : !llvm.ptr -> !llvm.ptr
func.call @free(%752) : (!llvm.ptr) -> ()
%754 = llvm.mlir.addressof @PY : !llvm.ptr
%755 = llvm.load %754 : !llvm.ptr -> !llvm.ptr
func.call @free(%755) : (!llvm.ptr) -> ()
func.call @free(%331) : (!llvm.ptr) -> ()
%758 = llvm.mlir.addressof @LX : !llvm.ptr
%759 = llvm.load %758 : !llvm.ptr -> !llvm.ptr
func.call @free(%759) : (!llvm.ptr) -> ()
%761 = llvm.mlir.addressof @LY : !llvm.ptr
%762 = llvm.load %761 : !llvm.ptr -> !llvm.ptr
func.call @free(%762) : (!llvm.ptr) -> ()
%764 = llvm.mlir.addressof @LLAST : !llvm.ptr
%765 = llvm.load %764 : !llvm.ptr -> !llvm.ptr
func.call @free(%765) : (!llvm.ptr) -> ()
%767 = llvm.mlir.addressof @RX : !llvm.ptr
%768 = llvm.load %767 : !llvm.ptr -> !llvm.ptr
func.call @free(%768) : (!llvm.ptr) -> ()
%770 = llvm.mlir.addressof @RY : !llvm.ptr
%771 = llvm.load %770 : !llvm.ptr -> !llvm.ptr
func.call @free(%771) : (!llvm.ptr) -> ()
%773 = llvm.mlir.addressof @RFIRST : !llvm.ptr
%774 = llvm.load %773 : !llvm.ptr -> !llvm.ptr
func.call @free(%774) : (!llvm.ptr) -> ()
%775 = arith.constant 0 : i32
func.return %775 : i32
}
}