← All problems Problem 816
Closest pair of points via O(n log n) divide and conquer. 2*10^6 points generated by s_{k+1} = s_k^2 mod 50515093, s_0 = 290797. Pure Flow port of native/p816.c. Uses parallel arrays (SoA) instead of Point struct.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(2^n)?Space complexity O(1)?Approach Flow solution Not curated Verdict Unknown
Flow source
# Project Euler 816 - Shortest distance between points.
# Closest pair of points via O(n log n) divide and conquer.
# 2*10^6 points generated by s_{k+1} = s_k^2 mod 50515093, s_0 = 290797.
# Pure Flow port of native/p816.c.
# Uses parallel arrays (SoA) instead of Point struct.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function malloc(n: i64) -> ptr<void>
function memcpy(dst: ptr<void>, src: ptr<void>, n: i64) -> ptr<void>
function sqrt(x: f64) -> f64
}
const N: i64 = 2000000
const M: i64 = 50515093
# Global temp buffers for closest_rec (parallel arrays)
let mut temp_x: ptr<i32> = null
let mut temp_y: ptr<i32> = null
let mut temp_id: ptr<i32> = null
function dist2(ax: i32, ay: i32, bx: i32, by: i32) -> i64 {
let dx: i64 = (ax as i64) - (bx as i64)
let dy: i64 = (ay as i64) - (by as i64)
return dx * dx + dy * dy
}
# Brute force closest pair among X[lo..hi] (using X arrays).
function brute(Xx: ptr<i32>, Xy: ptr<i32>, lo: i64, n: i64) -> i64 {
let mut best: i64 = -1
let mut i: i64 = 0
while i < n {
let mut j: i64 = i + 1
while j < n {
let d: i64 = dist2(Xx[lo + i], Xy[lo + i], Xx[lo + j], Xy[lo + j])
if best < 0 || d < best {
best = d
}
j = j + 1
}
i = i + 1
}
return best
}
# Sort Y arrays by y-coordinate using insertion sort (small n <= 3).
function sort_y_small(Yx: ptr<i32>, Yy: ptr<i32>, Yid: ptr<i32>, n: i64) -> void {
let mut i: i64 = 1
while i < n {
let key_y: i32 = Yy[i]
let key_x: i32 = Yx[i]
let key_id: i32 = Yid[i]
let mut j: i64 = i
while j > 0 && Yy[j - 1] > key_y {
Yy[j] = Yy[j - 1]
Yx[j] = Yx[j - 1]
Yid[j] = Yid[j - 1]
j = j - 1
}
Yy[j] = key_y
Yx[j] = key_x
Yid[j] = key_id
i = i + 1
}
}
# Merge two sorted halves of Y (by y) back into y-order using temp buffer.
# Y[0..nl-1] and Y[nl..yn-1] are both y-sorted.
function merge_y(Yx: ptr<i32>, Yy: ptr<i32>, Yid: ptr<i32>, nl: i64, nr: i64) -> void {
let yn: i64 = nl + nr
let mut i: i64 = 0
let mut j: i64 = 0
let mut k: i64 = 0
while i < nl && j < nr {
if Yy[i] <= Yy[nl + j] {
temp_x[k] = Yx[i]
temp_y[k] = Yy[i]
temp_id[k] = Yid[i]
k = k + 1
i = i + 1
} else {
temp_x[k] = Yx[nl + j]
temp_y[k] = Yy[nl + j]
temp_id[k] = Yid[nl + j]
k = k + 1
j = j + 1
}
}
while i < nl {
temp_x[k] = Yx[i]
temp_y[k] = Yy[i]
temp_id[k] = Yid[i]
k = k + 1
i = i + 1
}
while j < nr {
temp_x[k] = Yx[nl + j]
temp_y[k] = Yy[nl + j]
temp_id[k] = Yid[nl + j]
k = k + 1
j = j + 1
}
let mut idx: i64 = 0
while idx < yn {
Yx[idx] = temp_x[idx]
Yy[idx] = temp_y[idx]
Yid[idx] = temp_id[idx]
idx = idx + 1
}
}
# Recursive closest pair.
# X arrays are sorted by x. Y arrays are sorted by y.
# lo, hi are inclusive indices into X.
function closest_rec(Xx: ptr<i32>, Xy: ptr<i32>, Xid: ptr<i32>, lo: i64, hi: i64,
Yx: ptr<i32>, Yy: ptr<i32>, Yid: ptr<i32>, yn: i64) -> i64 {
let n: i64 = hi - lo + 1
if n <= 3 {
# Sort X[lo..hi] by y into Y (insertion sort).
let mut i: i64 = 0
while i < n {
Yx[i] = Xx[lo + i]
Yy[i] = Xy[lo + i]
Yid[i] = Xid[lo + i]
i = i + 1
}
sort_y_small(Yx, Yy, Yid, n)
return brute(Xx, Xy, lo, n)
}
let mid: i64 = lo + n / 2
let midx: i32 = Xx[mid - 1]
# Split Y (y-sorted) into YL [id < mid] and YR [id >= mid], both y-sorted.
let mut nl: i64 = 0
let mut nr: i64 = 0
let mut i: i64 = 0
while i < yn {
if Yid[i] < mid {
temp_x[nl] = Yx[i]
temp_y[nl] = Yy[i]
temp_id[nl] = Yid[i]
nl = nl + 1
}
i = i + 1
}
i = 0
while i < yn {
if Yid[i] >= mid {
temp_x[nl + nr] = Yx[i]
temp_y[nl + nr] = Yy[i]
temp_id[nl + nr] = Yid[i]
nr = nr + 1
}
i = i + 1
}
# Copy temp back into Y (first nl left, then nr right)
i = 0
while i < yn {
Yx[i] = temp_x[i]
Yy[i] = temp_y[i]
Yid[i] = temp_id[i]
i = i + 1
}
let dl: i64 = closest_rec(Xx, Xy, Xid, lo, mid - 1, Yx, Yy, Yid, nl)
let dr: i64 = closest_rec(Xx, Xy, Xid, mid, hi, Yx + nl, Yy + nl, Yid + nl, nr)
let mut d: i64 = dl
if dr < d { d = dr }
# Merge Y[0..nl-1] and Y[nl..yn-1] (both y-sorted) back into y-order.
merge_y(Yx, Yy, Yid, nl, nr)
# Build strip from Y (y-sorted): points within sqrt(d) of midx.
let mut sc: i64 = 0
i = 0
while i < yn {
let dx: i64 = (Yx[i] as i64) - (midx as i64)
if dx * dx < d {
temp_x[sc] = Yx[i]
temp_y[sc] = Yy[i]
temp_id[sc] = Yid[i]
sc = sc + 1
}
i = i + 1
}
i = 0
while i < sc {
let mut j: i64 = i + 1
while j < sc {
let dy: i64 = (temp_y[j] as i64) - (temp_y[i] as i64)
if dy * dy >= d { break }
let dd: i64 = dist2(temp_x[i], temp_y[i], temp_x[j], temp_y[j])
if dd < d { d = dd }
j = j + 1
}
i = i + 1
}
return d
}
# Heapsort X arrays by x (then y) using parallel arrays.
# Also sorts id array alongside.
function heapsort_x(Xx: ptr<i32>, Xy: ptr<i32>, Xid: ptr<i32>, n: i64) -> void {
# Build max heap
let mut start: i64 = n / 2 - 1
while start >= 0 {
let mut root: i64 = start
while root * 2 + 1 < n {
let child: i64 = root * 2 + 1
let mut swap: i64 = root
# Compare by x, then y
let mut swap_needed: bool = false
if Xx[child] > Xx[swap] {
swap_needed = true
} else {
if Xx[child] == Xx[swap] && Xy[child] > Xy[swap] {
swap_needed = true
}
}
if swap_needed {
swap = child
}
let child2: i64 = child + 1
if child2 < n {
let mut needed2: bool = false
if Xx[child2] > Xx[swap] {
needed2 = true
} else {
if Xx[child2] == Xx[swap] && Xy[child2] > Xy[swap] {
needed2 = true
}
}
if needed2 {
swap = child2
}
}
if swap == root {
break
}
# Swap
let tx: i32 = Xx[root]
let ty: i32 = Xy[root]
let tid: i32 = Xid[root]
Xx[root] = Xx[swap]
Xy[root] = Xy[swap]
Xid[root] = Xid[swap]
Xx[swap] = tx
Xy[swap] = ty
Xid[swap] = tid
root = swap
}
if start == 0 { break }
start = start - 1
}
# Sort down
let mut end: i64 = n - 1
while end > 0 {
# Swap root and end
let tx: i32 = Xx[0]
let ty: i32 = Xy[0]
let tid: i32 = Xid[0]
Xx[0] = Xx[end]
Xy[0] = Xy[end]
Xid[0] = Xid[end]
Xx[end] = tx
Xy[end] = ty
Xid[end] = tid
let mut root: i64 = 0
while root * 2 + 1 < end {
let child: i64 = root * 2 + 1
let mut swap: i64 = root
let mut sn: bool = false
if Xx[child] > Xx[swap] {
sn = true
} else {
if Xx[child] == Xx[swap] && Xy[child] > Xy[swap] {
sn = true
}
}
if sn { swap = child }
let child2: i64 = child + 1
if child2 < end {
let mut sn2: bool = false
if Xx[child2] > Xx[swap] {
sn2 = true
} else {
if Xx[child2] == Xx[swap] && Xy[child2] > Xy[swap] {
sn2 = true
}
}
if sn2 { swap = child2 }
}
if swap == root { break }
let tx2: i32 = Xx[root]
let ty2: i32 = Xy[root]
let tid2: i32 = Xid[root]
Xx[root] = Xx[swap]
Xy[root] = Xy[swap]
Xid[root] = Xid[swap]
Xx[swap] = tx2
Xy[swap] = ty2
Xid[swap] = tid2
root = swap
}
end = end - 1
}
}
# Heapsort Y arrays by y (then x).
function heapsort_y(Yx: ptr<i32>, Yy: ptr<i32>, Yid: ptr<i32>, n: i64) -> void {
# Build max heap
let mut start: i64 = n / 2 - 1
while start >= 0 {
let mut root: i64 = start
while root * 2 + 1 < n {
let child: i64 = root * 2 + 1
let mut swap: i64 = root
let mut sn: bool = false
if Yy[child] > Yy[swap] {
sn = true
} else {
if Yy[child] == Yy[swap] && Yx[child] > Yx[swap] {
sn = true
}
}
if sn { swap = child }
let child2: i64 = child + 1
if child2 < n {
let mut sn2: bool = false
if Yy[child2] > Yy[swap] {
sn2 = true
} else {
if Yy[child2] == Yy[swap] && Yx[child2] > Yx[swap] {
sn2 = true
}
}
if sn2 { swap = child2 }
}
if swap == root { break }
let tx: i32 = Yx[root]
let ty: i32 = Yy[root]
let tid: i32 = Yid[root]
Yx[root] = Yx[swap]
Yy[root] = Yy[swap]
Yid[root] = Yid[swap]
Yx[swap] = tx
Yy[swap] = ty
Yid[swap] = tid
root = swap
}
if start == 0 { break }
start = start - 1
}
let mut end: i64 = n - 1
while end > 0 {
let tx: i32 = Yx[0]
let ty: i32 = Yy[0]
let tid: i32 = Yid[0]
Yx[0] = Yx[end]
Yy[0] = Yy[end]
Yid[0] = Yid[end]
Yx[end] = tx
Yy[end] = ty
Yid[end] = tid
let mut root: i64 = 0
while root * 2 + 1 < end {
let child: i64 = root * 2 + 1
let mut swap: i64 = root
let mut sn: bool = false
if Yy[child] > Yy[swap] {
sn = true
} else {
if Yy[child] == Yy[swap] && Yx[child] > Yx[swap] {
sn = true
}
}
if sn { swap = child }
let child2: i64 = child + 1
if child2 < end {
let mut sn2: bool = false
if Yy[child2] > Yy[swap] {
sn2 = true
} else {
if Yy[child2] == Yy[swap] && Yx[child2] > Yx[swap] {
sn2 = true
}
}
if sn2 { swap = child2 }
}
if swap == root { break }
let tx2: i32 = Yx[root]
let ty2: i32 = Yy[root]
let tid2: i32 = Yid[root]
Yx[root] = Yx[swap]
Yy[root] = Yy[swap]
Yid[root] = Yid[swap]
Yx[swap] = tx2
Yy[swap] = ty2
Yid[swap] = tid2
root = swap
}
end = end - 1
}
}
function main() -> i32 {
let Xx: ptr<i32> = malloc(N * 4)
let Xy: ptr<i32> = malloc(N * 4)
let Xid: ptr<i32> = malloc(N * 4)
let Yx: ptr<i32> = malloc(N * 4)
let Yy: ptr<i32> = malloc(N * 4)
let Yid: ptr<i32> = malloc(N * 4)
temp_x = malloc(N * 4)
temp_y = malloc(N * 4)
temp_id = malloc(N * 4)
# Generate points (s_{2i}, s_{2i+1}) where s_0=290797, s_{k+1}=s_k^2 mod 50515093.
let mut s: i64 = 290797
let mut i: i64 = 0
while i < N {
let s0: i64 = s
let s1: i64 = (s0 * s0) % M
Xx[i] = s0 as i32
Xy[i] = s1 as i32
s = (s1 * s1) % M
i = i + 1
}
# Sort X by (x, y)
i = 0
while i < N {
Xid[i] = i as i32
i = i + 1
}
heapsort_x(Xx, Xy, Xid, N)
# Copy X to Y, then sort Y by (y, x)
i = 0
while i < N {
Yx[i] = Xx[i]
Yy[i] = Xy[i]
Yid[i] = Xid[i]
i = i + 1
}
heapsort_y(Yx, Yy, Yid, N)
let d2: i64 = closest_rec(Xx, Xy, Xid, 0, N - 1, Yx, Yy, Yid, N)
let ans: f64 = sqrt(d2 as f64)
printf("%.9f\n", ans)
free(Xx)
free(Xy)
free(Xid)
free(Yx)
free(Yy)
free(Yid)
free(temp_x)
free(temp_y)
free(temp_id)
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 dist2_i32_i32_i32_i32(int32_t ax, int32_t ay, int32_t bx, int32_t by);
int64_t brute_ptr_i32_ptr_i32_i64_i64(int32_t* Xx, int32_t* Xy, int64_t lo, int64_t n);
void sort_y_small_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t n);
void merge_y_ptr_i32_ptr_i32_ptr_i32_i64_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t nl, int64_t nr);
int64_t closest_rec_ptr_i32_ptr_i32_ptr_i32_i64_i64_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Xx, int32_t* Xy, int32_t* Xid, int64_t lo, int64_t hi, int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t yn);
void heapsort_x_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Xx, int32_t* Xy, int32_t* Xid, int64_t n);
void heapsort_y_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t n);
int32_t main(void);
static const int64_t N = 2000000;
static const int64_t M = 50515093;
/* Module statics */
static int32_t* temp_x = NULL;
static int32_t* temp_y = NULL;
static int32_t* temp_id = NULL;
int64_t dist2_i32_i32_i32_i32(int32_t ax, int32_t ay, int32_t bx, int32_t by) {
int64_t dx = (((int64_t)(ax)) - ((int64_t)(bx)));
int64_t dy = (((int64_t)(ay)) - ((int64_t)(by)));
return ((dx * dx) + (dy * dy));
}
int64_t brute_ptr_i32_ptr_i32_i64_i64(int32_t* Xx, int32_t* Xy, int64_t lo, int64_t n) {
int64_t best = (-1);
int64_t i = 0;
while (i < n) {
int64_t j = (i + 1);
while (j < n) {
int64_t d = dist2_i32_i32_i32_i32(Xx[(lo + i)], Xy[(lo + i)], Xx[(lo + j)], Xy[(lo + j)]);
if ((best < 0 || d < best)) {
best = d;
}
j = (j + 1);
}
i = (i + 1);
}
return best;
}
void sort_y_small_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t n) {
int64_t i = 1;
while (i < n) {
int32_t key_y = Yy[i];
int32_t key_x = Yx[i];
int32_t key_id = Yid[i];
int64_t j = i;
while ((j > 0 && Yy[(j - 1)] > key_y)) {
Yy[j] = Yy[(j - 1)];
Yx[j] = Yx[(j - 1)];
Yid[j] = Yid[(j - 1)];
j = (j - 1);
}
Yy[j] = key_y;
Yx[j] = key_x;
Yid[j] = key_id;
i = (i + 1);
}
}
void merge_y_ptr_i32_ptr_i32_ptr_i32_i64_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t nl, int64_t nr) {
int64_t yn = (nl + nr);
int64_t i = 0;
int64_t j = 0;
int64_t k = 0;
while ((i < nl && j < nr)) {
if (Yy[i] <= Yy[(nl + j)]) {
temp_x[k] = Yx[i];
temp_y[k] = Yy[i];
temp_id[k] = Yid[i];
k = (k + 1);
i = (i + 1);
} else {
temp_x[k] = Yx[(nl + j)];
temp_y[k] = Yy[(nl + j)];
temp_id[k] = Yid[(nl + j)];
k = (k + 1);
j = (j + 1);
}
}
while (i < nl) {
temp_x[k] = Yx[i];
temp_y[k] = Yy[i];
temp_id[k] = Yid[i];
k = (k + 1);
i = (i + 1);
}
while (j < nr) {
temp_x[k] = Yx[(nl + j)];
temp_y[k] = Yy[(nl + j)];
temp_id[k] = Yid[(nl + j)];
k = (k + 1);
j = (j + 1);
}
int64_t idx = 0;
while (idx < yn) {
Yx[idx] = temp_x[idx];
Yy[idx] = temp_y[idx];
Yid[idx] = temp_id[idx];
idx = (idx + 1);
}
}
int64_t closest_rec_ptr_i32_ptr_i32_ptr_i32_i64_i64_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Xx, int32_t* Xy, int32_t* Xid, int64_t lo, int64_t hi, int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t yn) {
int64_t n = ((hi - lo) + 1);
if (n <= 3) {
int64_t i = 0;
while (i < n) {
Yx[i] = Xx[(lo + i)];
Yy[i] = Xy[(lo + i)];
Yid[i] = Xid[(lo + i)];
i = (i + 1);
}
sort_y_small_ptr_i32_ptr_i32_ptr_i32_i64(Yx, Yy, Yid, n);
return brute_ptr_i32_ptr_i32_i64_i64(Xx, Xy, lo, n);
}
int64_t mid = (lo + FLOW_CHECKED_DIV((n), (2)));
int32_t midx = Xx[(mid - 1)];
int64_t nl = 0;
int64_t nr = 0;
int64_t i = 0;
while (i < yn) {
if (Yid[i] < mid) {
temp_x[nl] = Yx[i];
temp_y[nl] = Yy[i];
temp_id[nl] = Yid[i];
nl = (nl + 1);
}
i = (i + 1);
}
i = 0;
while (i < yn) {
if (Yid[i] >= mid) {
temp_x[(nl + nr)] = Yx[i];
temp_y[(nl + nr)] = Yy[i];
temp_id[(nl + nr)] = Yid[i];
nr = (nr + 1);
}
i = (i + 1);
}
i = 0;
while (i < yn) {
Yx[i] = temp_x[i];
Yy[i] = temp_y[i];
Yid[i] = temp_id[i];
i = (i + 1);
}
int64_t dl = closest_rec_ptr_i32_ptr_i32_ptr_i32_i64_i64_ptr_i32_ptr_i32_ptr_i32_i64(Xx, Xy, Xid, lo, (mid - 1), Yx, Yy, Yid, nl);
int64_t dr = closest_rec_ptr_i32_ptr_i32_ptr_i32_i64_i64_ptr_i32_ptr_i32_ptr_i32_i64(Xx, Xy, Xid, mid, hi, (Yx + nl), (Yy + nl), (Yid + nl), nr);
int64_t d = dl;
if (dr < d) {
d = dr;
}
merge_y_ptr_i32_ptr_i32_ptr_i32_i64_i64(Yx, Yy, Yid, nl, nr);
int64_t sc = 0;
i = 0;
while (i < yn) {
int64_t dx = (((int64_t)(Yx[i])) - ((int64_t)(midx)));
if ((dx * dx) < d) {
temp_x[sc] = Yx[i];
temp_y[sc] = Yy[i];
temp_id[sc] = Yid[i];
sc = (sc + 1);
}
i = (i + 1);
}
i = 0;
while (i < sc) {
int64_t j = (i + 1);
while (j < sc) {
int64_t dy = (((int64_t)(temp_y[j])) - ((int64_t)(temp_y[i])));
if ((dy * dy) >= d) {
break;
}
int64_t dd = dist2_i32_i32_i32_i32(temp_x[i], temp_y[i], temp_x[j], temp_y[j]);
if (dd < d) {
d = dd;
}
j = (j + 1);
}
i = (i + 1);
}
return d;
}
void heapsort_x_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Xx, int32_t* Xy, int32_t* Xid, int64_t n) {
int64_t start = (FLOW_CHECKED_DIV((n), (2)) - 1);
while (start >= 0) {
int64_t root = start;
while (((root * 2) + 1) < n) {
int64_t child = ((root * 2) + 1);
int64_t swap = root;
bool swap_needed = 0;
if (Xx[child] > Xx[swap]) {
swap_needed = 1;
} else {
if ((Xx[child] == Xx[swap] && Xy[child] > Xy[swap])) {
swap_needed = 1;
}
}
if (swap_needed) {
swap = child;
}
int64_t child2 = (child + 1);
if (child2 < n) {
bool needed2 = 0;
if (Xx[child2] > Xx[swap]) {
needed2 = 1;
} else {
if ((Xx[child2] == Xx[swap] && Xy[child2] > Xy[swap])) {
needed2 = 1;
}
}
if (needed2) {
swap = child2;
}
}
if (swap == root) {
break;
}
int32_t tx = Xx[root];
int32_t ty = Xy[root];
int32_t tid = Xid[root];
Xx[root] = Xx[swap];
Xy[root] = Xy[swap];
Xid[root] = Xid[swap];
Xx[swap] = tx;
Xy[swap] = ty;
Xid[swap] = tid;
root = swap;
}
if (start == 0) {
break;
}
start = (start - 1);
}
int64_t end = (n - 1);
while (end > 0) {
int32_t tx = Xx[0];
int32_t ty = Xy[0];
int32_t tid = Xid[0];
Xx[0] = Xx[end];
Xy[0] = Xy[end];
Xid[0] = Xid[end];
Xx[end] = tx;
Xy[end] = ty;
Xid[end] = tid;
int64_t root = 0;
while (((root * 2) + 1) < end) {
int64_t child = ((root * 2) + 1);
int64_t swap = root;
bool sn = 0;
if (Xx[child] > Xx[swap]) {
sn = 1;
} else {
if ((Xx[child] == Xx[swap] && Xy[child] > Xy[swap])) {
sn = 1;
}
}
if (sn) {
swap = child;
}
int64_t child2 = (child + 1);
if (child2 < end) {
bool sn2 = 0;
if (Xx[child2] > Xx[swap]) {
sn2 = 1;
} else {
if ((Xx[child2] == Xx[swap] && Xy[child2] > Xy[swap])) {
sn2 = 1;
}
}
if (sn2) {
swap = child2;
}
}
if (swap == root) {
break;
}
int32_t tx2 = Xx[root];
int32_t ty2 = Xy[root];
int32_t tid2 = Xid[root];
Xx[root] = Xx[swap];
Xy[root] = Xy[swap];
Xid[root] = Xid[swap];
Xx[swap] = tx2;
Xy[swap] = ty2;
Xid[swap] = tid2;
root = swap;
}
end = (end - 1);
}
}
void heapsort_y_ptr_i32_ptr_i32_ptr_i32_i64(int32_t* Yx, int32_t* Yy, int32_t* Yid, int64_t n) {
int64_t start = (FLOW_CHECKED_DIV((n), (2)) - 1);
while (start >= 0) {
int64_t root = start;
while (((root * 2) + 1) < n) {
int64_t child = ((root * 2) + 1);
int64_t swap = root;
bool sn = 0;
if (Yy[child] > Yy[swap]) {
sn = 1;
} else {
if ((Yy[child] == Yy[swap] && Yx[child] > Yx[swap])) {
sn = 1;
}
}
if (sn) {
swap = child;
}
int64_t child2 = (child + 1);
if (child2 < n) {
bool sn2 = 0;
if (Yy[child2] > Yy[swap]) {
sn2 = 1;
} else {
if ((Yy[child2] == Yy[swap] && Yx[child2] > Yx[swap])) {
sn2 = 1;
}
}
if (sn2) {
swap = child2;
}
}
if (swap == root) {
break;
}
int32_t tx = Yx[root];
int32_t ty = Yy[root];
int32_t tid = Yid[root];
Yx[root] = Yx[swap];
Yy[root] = Yy[swap];
Yid[root] = Yid[swap];
Yx[swap] = tx;
Yy[swap] = ty;
Yid[swap] = tid;
root = swap;
}
if (start == 0) {
break;
}
start = (start - 1);
}
int64_t end = (n - 1);
while (end > 0) {
int32_t tx = Yx[0];
int32_t ty = Yy[0];
int32_t tid = Yid[0];
Yx[0] = Yx[end];
Yy[0] = Yy[end];
Yid[0] = Yid[end];
Yx[end] = tx;
Yy[end] = ty;
Yid[end] = tid;
int64_t root = 0;
while (((root * 2) + 1) < end) {
int64_t child = ((root * 2) + 1);
int64_t swap = root;
bool sn = 0;
if (Yy[child] > Yy[swap]) {
sn = 1;
} else {
if ((Yy[child] == Yy[swap] && Yx[child] > Yx[swap])) {
sn = 1;
}
}
if (sn) {
swap = child;
}
int64_t child2 = (child + 1);
if (child2 < end) {
bool sn2 = 0;
if (Yy[child2] > Yy[swap]) {
sn2 = 1;
} else {
if ((Yy[child2] == Yy[swap] && Yx[child2] > Yx[swap])) {
sn2 = 1;
}
}
if (sn2) {
swap = child2;
}
}
if (swap == root) {
break;
}
int32_t tx2 = Yx[root];
int32_t ty2 = Yy[root];
int32_t tid2 = Yid[root];
Yx[root] = Yx[swap];
Yy[root] = Yy[swap];
Yid[root] = Yid[swap];
Yx[swap] = tx2;
Yy[swap] = ty2;
Yid[swap] = tid2;
root = swap;
}
end = (end - 1);
}
}
int32_t main(void) {
int32_t* Xx = (int32_t*)(malloc((N * 4)));
int32_t* Xy = (int32_t*)(malloc((N * 4)));
int32_t* Xid = (int32_t*)(malloc((N * 4)));
int32_t* Yx = (int32_t*)(malloc((N * 4)));
int32_t* Yy = (int32_t*)(malloc((N * 4)));
int32_t* Yid = (int32_t*)(malloc((N * 4)));
temp_x = malloc((N * 4));
temp_y = malloc((N * 4));
temp_id = malloc((N * 4));
int64_t s = 290797;
int64_t i = 0;
while (i < N) {
int64_t s0 = s;
int64_t s1 = FLOW_CHECKED_MOD(((s0 * s0)), (M));
Xx[i] = ((int32_t)(s0));
Xy[i] = ((int32_t)(s1));
s = FLOW_CHECKED_MOD(((s1 * s1)), (M));
i = (i + 1);
}
i = 0;
while (i < N) {
Xid[i] = ((int32_t)(i));
i = (i + 1);
}
heapsort_x_ptr_i32_ptr_i32_ptr_i32_i64(Xx, Xy, Xid, N);
i = 0;
while (i < N) {
Yx[i] = Xx[i];
Yy[i] = Xy[i];
Yid[i] = Xid[i];
i = (i + 1);
}
heapsort_y_ptr_i32_ptr_i32_ptr_i32_i64(Yx, Yy, Yid, N);
int64_t d2 = closest_rec_ptr_i32_ptr_i32_ptr_i32_i64_i64_ptr_i32_ptr_i32_ptr_i32_i64(Xx, Xy, Xid, 0, (N - 1), Yx, Yy, Yid, N);
double ans = sqrt(((double)(d2)));
printf("%.9f\n", ans);
free(Xx);
free(Xy);
free(Xid);
free(Yx);
free(Yy);
free(Yid);
free(temp_x);
free(temp_y);
free(temp_id);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%.9f\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @malloc(i64) -> !llvm.ptr
func.func private @memcpy(!llvm.ptr, !llvm.ptr, i64) -> !llvm.ptr
func.func private @sqrt(f64) -> f64
// Constant: N
llvm.mlir.global internal constant @N(2000000 : i64) : i64
// Constant: M
llvm.mlir.global internal constant @M(50515093 : i64) : i64
// Module static: temp_x
llvm.mlir.global internal @temp_x() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: temp_y
llvm.mlir.global internal @temp_y() {addr_space = 0 : i32} : !llvm.ptr {
%1 = llvm.mlir.zero : !llvm.ptr
llvm.return %1 : !llvm.ptr
}
// Module static: temp_id
llvm.mlir.global internal @temp_id() {addr_space = 0 : i32} : !llvm.ptr {
%2 = llvm.mlir.zero : !llvm.ptr
llvm.return %2 : !llvm.ptr
}
func.func @dist2(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32) -> i64 {
%3 = arith.extsi %arg0 : i32 to i64
%4 = arith.extsi %arg2 : i32 to i64
%5 = arith.subi %3, %4 : i64
%6 = arith.extsi %arg1 : i32 to i64
%7 = arith.extsi %arg3 : i32 to i64
%8 = arith.subi %6, %7 : i64
%9 = arith.muli %5, %5 : i64
%10 = arith.muli %8, %8 : i64
%11 = arith.addi %9, %10 : i64
func.return %11 : i64
}
func.func @brute(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: i64, %arg3: i64) -> i64 {
%12 = arith.constant 1 : i32
%14 = arith.constant 0 : i32
%13 = arith.subi %14, %12 : i32
%15 = arith.extsi %13 : i32 to i64
%16 = llvm.mlir.constant(1 : i64) : i64
%17 = llvm.alloca %16 x i64 : (i64) -> !llvm.ptr
llvm.store %15, %17 : i64, !llvm.ptr
%18 = arith.constant 0 : i32
%19 = arith.extsi %18 : i32 to i64
%20 = llvm.mlir.constant(1 : i64) : i64
%21 = llvm.alloca %20 x i64 : (i64) -> !llvm.ptr
llvm.store %19, %21 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%22 = llvm.load %21 : !llvm.ptr -> i64
%23 = arith.cmpi slt, %22, %arg3 : i64
cf.cond_br %23, ^bb1, ^bb2
^bb1:
%24 = llvm.load %21 : !llvm.ptr -> i64
%25 = arith.constant 1 : i32
%27 = arith.extsi %25 : i32 to i64
%26 = arith.addi %24, %27 : i64
%28 = llvm.mlir.constant(1 : i64) : i64
%29 = llvm.alloca %28 x i64 : (i64) -> !llvm.ptr
llvm.store %26, %29 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%30 = llvm.load %29 : !llvm.ptr -> i64
%31 = arith.cmpi slt, %30, %arg3 : i64
cf.cond_br %31, ^bb4, ^bb5
^bb4:
%34 = llvm.load %21 : !llvm.ptr -> i64
%35 = arith.addi %arg2, %34 : i64
%36 = llvm.getelementptr %arg0[%35] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%33 = llvm.load %36 : !llvm.ptr -> i32
%38 = llvm.load %21 : !llvm.ptr -> i64
%39 = arith.addi %arg2, %38 : i64
%40 = llvm.getelementptr %arg1[%39] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%37 = llvm.load %40 : !llvm.ptr -> i32
%42 = llvm.load %29 : !llvm.ptr -> i64
%43 = arith.addi %arg2, %42 : i64
%44 = llvm.getelementptr %arg0[%43] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%41 = llvm.load %44 : !llvm.ptr -> i32
%46 = llvm.load %29 : !llvm.ptr -> i64
%47 = arith.addi %arg2, %46 : i64
%48 = llvm.getelementptr %arg1[%47] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%45 = llvm.load %48 : !llvm.ptr -> i32
%32 = func.call @dist2(%33, %37, %41, %45) : (i32, i32, i32, i32) -> i64
%49 = llvm.load %17 : !llvm.ptr -> i64
%50 = arith.constant 0 : i32
%52 = arith.extsi %50 : i32 to i64
%51 = arith.cmpi slt, %49, %52 : i64
%53 = scf.if %51 -> (i1) {
%54 = arith.constant true
scf.yield %54 : i1
} else {
%55 = llvm.load %17 : !llvm.ptr -> i64
%56 = arith.cmpi slt, %32, %55 : i64
scf.yield %56 : i1
}
cf.cond_br %53, ^bb6, ^bb7
^bb6:
llvm.store %32, %17 : i64, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%57 = llvm.load %29 : !llvm.ptr -> i64
%58 = arith.constant 1 : i32
%60 = arith.extsi %58 : i32 to i64
%59 = arith.addi %57, %60 : i64
llvm.store %59, %29 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
%61 = llvm.load %21 : !llvm.ptr -> i64
%62 = arith.constant 1 : i32
%64 = arith.extsi %62 : i32 to i64
%63 = arith.addi %61, %64 : i64
llvm.store %63, %21 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
%65 = llvm.load %17 : !llvm.ptr -> i64
func.return %65 : i64
}
func.func @sort_y_small(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i64) -> () {
%66 = arith.constant 1 : i32
%67 = arith.extsi %66 : i32 to i64
%68 = llvm.mlir.constant(1 : i64) : i64
%69 = llvm.alloca %68 x i64 : (i64) -> !llvm.ptr
llvm.store %67, %69 : i64, !llvm.ptr
cf.br ^bb9
^bb9:
%70 = llvm.load %69 : !llvm.ptr -> i64
%71 = arith.cmpi slt, %70, %arg3 : i64
cf.cond_br %71, ^bb10, ^bb11
^bb10:
%73 = llvm.load %69 : !llvm.ptr -> i64
%74 = llvm.getelementptr %arg1[%73] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%72 = llvm.load %74 : !llvm.ptr -> i32
%76 = llvm.load %69 : !llvm.ptr -> i64
%77 = llvm.getelementptr %arg0[%76] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%75 = llvm.load %77 : !llvm.ptr -> i32
%79 = llvm.load %69 : !llvm.ptr -> i64
%80 = llvm.getelementptr %arg2[%79] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%78 = llvm.load %80 : !llvm.ptr -> i32
%81 = llvm.load %69 : !llvm.ptr -> i64
%82 = llvm.mlir.constant(1 : i64) : i64
%83 = llvm.alloca %82 x i64 : (i64) -> !llvm.ptr
llvm.store %81, %83 : i64, !llvm.ptr
cf.br ^bb12
^bb12:
%84 = llvm.load %83 : !llvm.ptr -> i64
%85 = arith.constant 0 : i32
%87 = arith.extsi %85 : i32 to i64
%86 = arith.cmpi sgt, %84, %87 : i64
%88 = scf.if %86 -> (i1) {
%90 = llvm.load %83 : !llvm.ptr -> i64
%91 = arith.constant 1 : i32
%93 = arith.extsi %91 : i32 to i64
%92 = arith.subi %90, %93 : i64
%94 = llvm.getelementptr %arg1[%92] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%89 = llvm.load %94 : !llvm.ptr -> i32
%95 = arith.cmpi sgt, %89, %72 : i32
scf.yield %95 : i1
} else {
%96 = arith.constant false
scf.yield %96 : i1
}
cf.cond_br %88, ^bb13, ^bb14
^bb13:
%98 = llvm.load %83 : !llvm.ptr -> i64
%99 = arith.constant 1 : i32
%101 = arith.extsi %99 : i32 to i64
%100 = arith.subi %98, %101 : i64
%102 = llvm.getelementptr %arg1[%100] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%97 = llvm.load %102 : !llvm.ptr -> i32
%103 = llvm.load %83 : !llvm.ptr -> i64
%104 = llvm.getelementptr %arg1[%103] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %97, %104 : i32, !llvm.ptr
%106 = llvm.load %83 : !llvm.ptr -> i64
%107 = arith.constant 1 : i32
%109 = arith.extsi %107 : i32 to i64
%108 = arith.subi %106, %109 : i64
%110 = llvm.getelementptr %arg0[%108] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%105 = llvm.load %110 : !llvm.ptr -> i32
%111 = llvm.load %83 : !llvm.ptr -> i64
%112 = llvm.getelementptr %arg0[%111] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %105, %112 : i32, !llvm.ptr
%114 = llvm.load %83 : !llvm.ptr -> i64
%115 = arith.constant 1 : i32
%117 = arith.extsi %115 : i32 to i64
%116 = arith.subi %114, %117 : i64
%118 = llvm.getelementptr %arg2[%116] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%113 = llvm.load %118 : !llvm.ptr -> i32
%119 = llvm.load %83 : !llvm.ptr -> i64
%120 = llvm.getelementptr %arg2[%119] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %113, %120 : i32, !llvm.ptr
%121 = llvm.load %83 : !llvm.ptr -> i64
%122 = arith.constant 1 : i32
%124 = arith.extsi %122 : i32 to i64
%123 = arith.subi %121, %124 : i64
llvm.store %123, %83 : i64, !llvm.ptr
cf.br ^bb12
^bb14:
%125 = llvm.load %83 : !llvm.ptr -> i64
%126 = llvm.getelementptr %arg1[%125] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %72, %126 : i32, !llvm.ptr
%127 = llvm.load %83 : !llvm.ptr -> i64
%128 = llvm.getelementptr %arg0[%127] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %75, %128 : i32, !llvm.ptr
%129 = llvm.load %83 : !llvm.ptr -> i64
%130 = llvm.getelementptr %arg2[%129] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %78, %130 : i32, !llvm.ptr
%131 = llvm.load %69 : !llvm.ptr -> i64
%132 = arith.constant 1 : i32
%134 = arith.extsi %132 : i32 to i64
%133 = arith.addi %131, %134 : i64
llvm.store %133, %69 : i64, !llvm.ptr
cf.br ^bb9
^bb11:
func.return
}
func.func @merge_y(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64) -> () {
%135 = arith.addi %arg3, %arg4 : i64
%136 = arith.constant 0 : i32
%137 = arith.extsi %136 : i32 to i64
%138 = llvm.mlir.constant(1 : i64) : i64
%139 = llvm.alloca %138 x i64 : (i64) -> !llvm.ptr
llvm.store %137, %139 : i64, !llvm.ptr
%140 = arith.constant 0 : i32
%141 = arith.extsi %140 : i32 to i64
%142 = llvm.mlir.constant(1 : i64) : i64
%143 = llvm.alloca %142 x i64 : (i64) -> !llvm.ptr
llvm.store %141, %143 : i64, !llvm.ptr
%144 = arith.constant 0 : i32
%145 = arith.extsi %144 : i32 to i64
%146 = llvm.mlir.constant(1 : i64) : i64
%147 = llvm.alloca %146 x i64 : (i64) -> !llvm.ptr
llvm.store %145, %147 : i64, !llvm.ptr
cf.br ^bb15
^bb15:
%148 = llvm.load %139 : !llvm.ptr -> i64
%149 = arith.cmpi slt, %148, %arg3 : i64
%150 = scf.if %149 -> (i1) {
%151 = llvm.load %143 : !llvm.ptr -> i64
%152 = arith.cmpi slt, %151, %arg4 : i64
scf.yield %152 : i1
} else {
%153 = arith.constant false
scf.yield %153 : i1
}
cf.cond_br %150, ^bb16, ^bb17
^bb16:
%155 = llvm.load %139 : !llvm.ptr -> i64
%156 = llvm.getelementptr %arg1[%155] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%154 = llvm.load %156 : !llvm.ptr -> i32
%158 = llvm.load %143 : !llvm.ptr -> i64
%159 = arith.addi %arg3, %158 : i64
%160 = llvm.getelementptr %arg1[%159] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%157 = llvm.load %160 : !llvm.ptr -> i32
%161 = arith.cmpi sle, %154, %157 : i32
cf.cond_br %161, ^bb18, ^bb19
^bb18:
%163 = llvm.load %139 : !llvm.ptr -> i64
%164 = llvm.getelementptr %arg0[%163] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%162 = llvm.load %164 : !llvm.ptr -> i32
%165 = llvm.mlir.addressof @temp_x : !llvm.ptr
%166 = llvm.load %165 : !llvm.ptr -> !llvm.ptr
%167 = llvm.load %147 : !llvm.ptr -> i64
%168 = llvm.getelementptr %166[%167] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %162, %168 : i32, !llvm.ptr
%170 = llvm.load %139 : !llvm.ptr -> i64
%171 = llvm.getelementptr %arg1[%170] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%169 = llvm.load %171 : !llvm.ptr -> i32
%172 = llvm.mlir.addressof @temp_y : !llvm.ptr
%173 = llvm.load %172 : !llvm.ptr -> !llvm.ptr
%174 = llvm.load %147 : !llvm.ptr -> i64
%175 = llvm.getelementptr %173[%174] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %169, %175 : i32, !llvm.ptr
%177 = llvm.load %139 : !llvm.ptr -> i64
%178 = llvm.getelementptr %arg2[%177] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%176 = llvm.load %178 : !llvm.ptr -> i32
%179 = llvm.mlir.addressof @temp_id : !llvm.ptr
%180 = llvm.load %179 : !llvm.ptr -> !llvm.ptr
%181 = llvm.load %147 : !llvm.ptr -> i64
%182 = llvm.getelementptr %180[%181] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %176, %182 : i32, !llvm.ptr
%183 = llvm.load %147 : !llvm.ptr -> i64
%184 = arith.constant 1 : i32
%186 = arith.extsi %184 : i32 to i64
%185 = arith.addi %183, %186 : i64
llvm.store %185, %147 : i64, !llvm.ptr
%187 = llvm.load %139 : !llvm.ptr -> i64
%188 = arith.constant 1 : i32
%190 = arith.extsi %188 : i32 to i64
%189 = arith.addi %187, %190 : i64
llvm.store %189, %139 : i64, !llvm.ptr
cf.br ^bb20
^bb19:
%192 = llvm.load %143 : !llvm.ptr -> i64
%193 = arith.addi %arg3, %192 : i64
%194 = llvm.getelementptr %arg0[%193] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%191 = llvm.load %194 : !llvm.ptr -> i32
%195 = llvm.mlir.addressof @temp_x : !llvm.ptr
%196 = llvm.load %195 : !llvm.ptr -> !llvm.ptr
%197 = llvm.load %147 : !llvm.ptr -> i64
%198 = llvm.getelementptr %196[%197] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %191, %198 : i32, !llvm.ptr
%200 = llvm.load %143 : !llvm.ptr -> i64
%201 = arith.addi %arg3, %200 : i64
%202 = llvm.getelementptr %arg1[%201] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%199 = llvm.load %202 : !llvm.ptr -> i32
%203 = llvm.mlir.addressof @temp_y : !llvm.ptr
%204 = llvm.load %203 : !llvm.ptr -> !llvm.ptr
%205 = llvm.load %147 : !llvm.ptr -> i64
%206 = llvm.getelementptr %204[%205] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %199, %206 : i32, !llvm.ptr
%208 = llvm.load %143 : !llvm.ptr -> i64
%209 = arith.addi %arg3, %208 : i64
%210 = llvm.getelementptr %arg2[%209] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%207 = llvm.load %210 : !llvm.ptr -> i32
%211 = llvm.mlir.addressof @temp_id : !llvm.ptr
%212 = llvm.load %211 : !llvm.ptr -> !llvm.ptr
%213 = llvm.load %147 : !llvm.ptr -> i64
%214 = llvm.getelementptr %212[%213] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %207, %214 : i32, !llvm.ptr
%215 = llvm.load %147 : !llvm.ptr -> i64
%216 = arith.constant 1 : i32
%218 = arith.extsi %216 : i32 to i64
%217 = arith.addi %215, %218 : i64
llvm.store %217, %147 : i64, !llvm.ptr
%219 = llvm.load %143 : !llvm.ptr -> i64
%220 = arith.constant 1 : i32
%222 = arith.extsi %220 : i32 to i64
%221 = arith.addi %219, %222 : i64
llvm.store %221, %143 : i64, !llvm.ptr
cf.br ^bb20
^bb20:
cf.br ^bb15
^bb17:
cf.br ^bb21
^bb21:
%223 = llvm.load %139 : !llvm.ptr -> i64
%224 = arith.cmpi slt, %223, %arg3 : i64
cf.cond_br %224, ^bb22, ^bb23
^bb22:
%226 = llvm.load %139 : !llvm.ptr -> i64
%227 = llvm.getelementptr %arg0[%226] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%225 = llvm.load %227 : !llvm.ptr -> i32
%228 = llvm.mlir.addressof @temp_x : !llvm.ptr
%229 = llvm.load %228 : !llvm.ptr -> !llvm.ptr
%230 = llvm.load %147 : !llvm.ptr -> i64
%231 = llvm.getelementptr %229[%230] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %225, %231 : i32, !llvm.ptr
%233 = llvm.load %139 : !llvm.ptr -> i64
%234 = llvm.getelementptr %arg1[%233] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%232 = llvm.load %234 : !llvm.ptr -> i32
%235 = llvm.mlir.addressof @temp_y : !llvm.ptr
%236 = llvm.load %235 : !llvm.ptr -> !llvm.ptr
%237 = llvm.load %147 : !llvm.ptr -> i64
%238 = llvm.getelementptr %236[%237] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %232, %238 : i32, !llvm.ptr
%240 = llvm.load %139 : !llvm.ptr -> i64
%241 = llvm.getelementptr %arg2[%240] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%239 = llvm.load %241 : !llvm.ptr -> i32
%242 = llvm.mlir.addressof @temp_id : !llvm.ptr
%243 = llvm.load %242 : !llvm.ptr -> !llvm.ptr
%244 = llvm.load %147 : !llvm.ptr -> i64
%245 = llvm.getelementptr %243[%244] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %239, %245 : i32, !llvm.ptr
%246 = llvm.load %147 : !llvm.ptr -> i64
%247 = arith.constant 1 : i32
%249 = arith.extsi %247 : i32 to i64
%248 = arith.addi %246, %249 : i64
llvm.store %248, %147 : i64, !llvm.ptr
%250 = llvm.load %139 : !llvm.ptr -> i64
%251 = arith.constant 1 : i32
%253 = arith.extsi %251 : i32 to i64
%252 = arith.addi %250, %253 : i64
llvm.store %252, %139 : i64, !llvm.ptr
cf.br ^bb21
^bb23:
cf.br ^bb24
^bb24:
%254 = llvm.load %143 : !llvm.ptr -> i64
%255 = arith.cmpi slt, %254, %arg4 : i64
cf.cond_br %255, ^bb25, ^bb26
^bb25:
%257 = llvm.load %143 : !llvm.ptr -> i64
%258 = arith.addi %arg3, %257 : i64
%259 = llvm.getelementptr %arg0[%258] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%256 = llvm.load %259 : !llvm.ptr -> i32
%260 = llvm.mlir.addressof @temp_x : !llvm.ptr
%261 = llvm.load %260 : !llvm.ptr -> !llvm.ptr
%262 = llvm.load %147 : !llvm.ptr -> i64
%263 = llvm.getelementptr %261[%262] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %256, %263 : i32, !llvm.ptr
%265 = llvm.load %143 : !llvm.ptr -> i64
%266 = arith.addi %arg3, %265 : i64
%267 = llvm.getelementptr %arg1[%266] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%264 = llvm.load %267 : !llvm.ptr -> i32
%268 = llvm.mlir.addressof @temp_y : !llvm.ptr
%269 = llvm.load %268 : !llvm.ptr -> !llvm.ptr
%270 = llvm.load %147 : !llvm.ptr -> i64
%271 = llvm.getelementptr %269[%270] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %264, %271 : i32, !llvm.ptr
%273 = llvm.load %143 : !llvm.ptr -> i64
%274 = arith.addi %arg3, %273 : i64
%275 = llvm.getelementptr %arg2[%274] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%272 = llvm.load %275 : !llvm.ptr -> i32
%276 = llvm.mlir.addressof @temp_id : !llvm.ptr
%277 = llvm.load %276 : !llvm.ptr -> !llvm.ptr
%278 = llvm.load %147 : !llvm.ptr -> i64
%279 = llvm.getelementptr %277[%278] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %272, %279 : i32, !llvm.ptr
%280 = llvm.load %147 : !llvm.ptr -> i64
%281 = arith.constant 1 : i32
%283 = arith.extsi %281 : i32 to i64
%282 = arith.addi %280, %283 : i64
llvm.store %282, %147 : i64, !llvm.ptr
%284 = llvm.load %143 : !llvm.ptr -> i64
%285 = arith.constant 1 : i32
%287 = arith.extsi %285 : i32 to i64
%286 = arith.addi %284, %287 : i64
llvm.store %286, %143 : i64, !llvm.ptr
cf.br ^bb24
^bb26:
%288 = arith.constant 0 : i32
%289 = arith.extsi %288 : i32 to i64
%290 = llvm.mlir.constant(1 : i64) : i64
%291 = llvm.alloca %290 x i64 : (i64) -> !llvm.ptr
llvm.store %289, %291 : i64, !llvm.ptr
cf.br ^bb27
^bb27:
%292 = llvm.load %291 : !llvm.ptr -> i64
%293 = arith.cmpi slt, %292, %135 : i64
cf.cond_br %293, ^bb28, ^bb29
^bb28:
%295 = llvm.mlir.addressof @temp_x : !llvm.ptr
%296 = llvm.load %295 : !llvm.ptr -> !llvm.ptr
%297 = llvm.load %291 : !llvm.ptr -> i64
%298 = llvm.getelementptr %296[%297] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%294 = llvm.load %298 : !llvm.ptr -> i32
%299 = llvm.load %291 : !llvm.ptr -> i64
%300 = llvm.getelementptr %arg0[%299] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %294, %300 : i32, !llvm.ptr
%302 = llvm.mlir.addressof @temp_y : !llvm.ptr
%303 = llvm.load %302 : !llvm.ptr -> !llvm.ptr
%304 = llvm.load %291 : !llvm.ptr -> i64
%305 = llvm.getelementptr %303[%304] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%301 = llvm.load %305 : !llvm.ptr -> i32
%306 = llvm.load %291 : !llvm.ptr -> i64
%307 = llvm.getelementptr %arg1[%306] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %301, %307 : i32, !llvm.ptr
%309 = llvm.mlir.addressof @temp_id : !llvm.ptr
%310 = llvm.load %309 : !llvm.ptr -> !llvm.ptr
%311 = llvm.load %291 : !llvm.ptr -> i64
%312 = llvm.getelementptr %310[%311] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%308 = llvm.load %312 : !llvm.ptr -> i32
%313 = llvm.load %291 : !llvm.ptr -> i64
%314 = llvm.getelementptr %arg2[%313] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %308, %314 : i32, !llvm.ptr
%315 = llvm.load %291 : !llvm.ptr -> i64
%316 = arith.constant 1 : i32
%318 = arith.extsi %316 : i32 to i64
%317 = arith.addi %315, %318 : i64
llvm.store %317, %291 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
func.return
}
func.func @closest_rec(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i64, %arg4: i64, %arg5: !llvm.ptr, %arg6: !llvm.ptr, %arg7: !llvm.ptr, %arg8: i64) -> i64 {
%319 = arith.subi %arg4, %arg3 : i64
%320 = arith.constant 1 : i32
%322 = arith.extsi %320 : i32 to i64
%321 = arith.addi %319, %322 : i64
%323 = arith.constant 3 : i32
%325 = arith.extsi %323 : i32 to i64
%324 = arith.cmpi sle, %321, %325 : i64
cf.cond_br %324, ^bb30, ^bb31
^bb30:
%326 = arith.constant 0 : i32
%327 = arith.extsi %326 : i32 to i64
%328 = llvm.mlir.constant(1 : i64) : i64
%329 = llvm.alloca %328 x i64 : (i64) -> !llvm.ptr
llvm.store %327, %329 : i64, !llvm.ptr
cf.br ^bb33
^bb33:
%330 = llvm.load %329 : !llvm.ptr -> i64
%331 = arith.cmpi slt, %330, %321 : i64
cf.cond_br %331, ^bb34, ^bb35
^bb34:
%333 = llvm.load %329 : !llvm.ptr -> i64
%334 = arith.addi %arg3, %333 : i64
%335 = llvm.getelementptr %arg0[%334] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%332 = llvm.load %335 : !llvm.ptr -> i32
%336 = llvm.load %329 : !llvm.ptr -> i64
%337 = llvm.getelementptr %arg5[%336] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %332, %337 : i32, !llvm.ptr
%339 = llvm.load %329 : !llvm.ptr -> i64
%340 = arith.addi %arg3, %339 : i64
%341 = llvm.getelementptr %arg1[%340] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%338 = llvm.load %341 : !llvm.ptr -> i32
%342 = llvm.load %329 : !llvm.ptr -> i64
%343 = llvm.getelementptr %arg6[%342] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %338, %343 : i32, !llvm.ptr
%345 = llvm.load %329 : !llvm.ptr -> i64
%346 = arith.addi %arg3, %345 : i64
%347 = llvm.getelementptr %arg2[%346] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%344 = llvm.load %347 : !llvm.ptr -> i32
%348 = llvm.load %329 : !llvm.ptr -> i64
%349 = llvm.getelementptr %arg7[%348] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %344, %349 : i32, !llvm.ptr
%350 = llvm.load %329 : !llvm.ptr -> i64
%351 = arith.constant 1 : i32
%353 = arith.extsi %351 : i32 to i64
%352 = arith.addi %350, %353 : i64
llvm.store %352, %329 : i64, !llvm.ptr
cf.br ^bb33
^bb35:
func.call @sort_y_small(%arg5, %arg6, %arg7, %321) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> ()
%355 = func.call @brute(%arg0, %arg1, %arg3, %321) : (!llvm.ptr, !llvm.ptr, i64, i64) -> i64
func.return %355 : i64
^bb31:
cf.br ^bb32
^bb32:
%356 = arith.constant 2 : i32
%358 = arith.extsi %356 : i32 to i64
%357 = arith.divsi %321, %358 : i64
%359 = arith.addi %arg3, %357 : i64
%361 = arith.constant 1 : i32
%363 = arith.extsi %361 : i32 to i64
%362 = arith.subi %359, %363 : i64
%364 = llvm.getelementptr %arg0[%362] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%360 = llvm.load %364 : !llvm.ptr -> i32
%365 = arith.constant 0 : i32
%366 = arith.extsi %365 : i32 to i64
%367 = llvm.mlir.constant(1 : i64) : i64
%368 = llvm.alloca %367 x i64 : (i64) -> !llvm.ptr
llvm.store %366, %368 : i64, !llvm.ptr
%369 = arith.constant 0 : i32
%370 = arith.extsi %369 : i32 to i64
%371 = llvm.mlir.constant(1 : i64) : i64
%372 = llvm.alloca %371 x i64 : (i64) -> !llvm.ptr
llvm.store %370, %372 : i64, !llvm.ptr
%373 = arith.constant 0 : i32
%374 = arith.extsi %373 : i32 to i64
%375 = llvm.mlir.constant(1 : i64) : i64
%376 = llvm.alloca %375 x i64 : (i64) -> !llvm.ptr
llvm.store %374, %376 : i64, !llvm.ptr
cf.br ^bb36
^bb36:
%377 = llvm.load %376 : !llvm.ptr -> i64
%378 = arith.cmpi slt, %377, %arg8 : i64
cf.cond_br %378, ^bb37, ^bb38
^bb37:
%380 = llvm.load %376 : !llvm.ptr -> i64
%381 = llvm.getelementptr %arg7[%380] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%379 = llvm.load %381 : !llvm.ptr -> i32
%383 = arith.extsi %379 : i32 to i64
%382 = arith.cmpi slt, %383, %359 : i64
cf.cond_br %382, ^bb39, ^bb40
^bb39:
%385 = llvm.load %376 : !llvm.ptr -> i64
%386 = llvm.getelementptr %arg5[%385] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%384 = llvm.load %386 : !llvm.ptr -> i32
%387 = llvm.mlir.addressof @temp_x : !llvm.ptr
%388 = llvm.load %387 : !llvm.ptr -> !llvm.ptr
%389 = llvm.load %368 : !llvm.ptr -> i64
%390 = llvm.getelementptr %388[%389] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %384, %390 : i32, !llvm.ptr
%392 = llvm.load %376 : !llvm.ptr -> i64
%393 = llvm.getelementptr %arg6[%392] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%391 = llvm.load %393 : !llvm.ptr -> i32
%394 = llvm.mlir.addressof @temp_y : !llvm.ptr
%395 = llvm.load %394 : !llvm.ptr -> !llvm.ptr
%396 = llvm.load %368 : !llvm.ptr -> i64
%397 = llvm.getelementptr %395[%396] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %391, %397 : i32, !llvm.ptr
%399 = llvm.load %376 : !llvm.ptr -> i64
%400 = llvm.getelementptr %arg7[%399] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%398 = llvm.load %400 : !llvm.ptr -> i32
%401 = llvm.mlir.addressof @temp_id : !llvm.ptr
%402 = llvm.load %401 : !llvm.ptr -> !llvm.ptr
%403 = llvm.load %368 : !llvm.ptr -> i64
%404 = llvm.getelementptr %402[%403] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %398, %404 : i32, !llvm.ptr
%405 = llvm.load %368 : !llvm.ptr -> i64
%406 = arith.constant 1 : i32
%408 = arith.extsi %406 : i32 to i64
%407 = arith.addi %405, %408 : i64
llvm.store %407, %368 : i64, !llvm.ptr
cf.br ^bb41
^bb40:
cf.br ^bb41
^bb41:
%409 = llvm.load %376 : !llvm.ptr -> i64
%410 = arith.constant 1 : i32
%412 = arith.extsi %410 : i32 to i64
%411 = arith.addi %409, %412 : i64
llvm.store %411, %376 : i64, !llvm.ptr
cf.br ^bb36
^bb38:
%413 = arith.constant 0 : i32
%414 = arith.extsi %413 : i32 to i64
llvm.store %414, %376 : i64, !llvm.ptr
cf.br ^bb42
^bb42:
%415 = llvm.load %376 : !llvm.ptr -> i64
%416 = arith.cmpi slt, %415, %arg8 : i64
cf.cond_br %416, ^bb43, ^bb44
^bb43:
%418 = llvm.load %376 : !llvm.ptr -> i64
%419 = llvm.getelementptr %arg7[%418] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%417 = llvm.load %419 : !llvm.ptr -> i32
%421 = arith.extsi %417 : i32 to i64
%420 = arith.cmpi sge, %421, %359 : i64
cf.cond_br %420, ^bb45, ^bb46
^bb45:
%423 = llvm.load %376 : !llvm.ptr -> i64
%424 = llvm.getelementptr %arg5[%423] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%422 = llvm.load %424 : !llvm.ptr -> i32
%425 = llvm.mlir.addressof @temp_x : !llvm.ptr
%426 = llvm.load %425 : !llvm.ptr -> !llvm.ptr
%427 = llvm.load %368 : !llvm.ptr -> i64
%428 = llvm.load %372 : !llvm.ptr -> i64
%429 = arith.addi %427, %428 : i64
%430 = llvm.getelementptr %426[%429] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %422, %430 : i32, !llvm.ptr
%432 = llvm.load %376 : !llvm.ptr -> i64
%433 = llvm.getelementptr %arg6[%432] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%431 = llvm.load %433 : !llvm.ptr -> i32
%434 = llvm.mlir.addressof @temp_y : !llvm.ptr
%435 = llvm.load %434 : !llvm.ptr -> !llvm.ptr
%436 = llvm.load %368 : !llvm.ptr -> i64
%437 = llvm.load %372 : !llvm.ptr -> i64
%438 = arith.addi %436, %437 : i64
%439 = llvm.getelementptr %435[%438] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %431, %439 : i32, !llvm.ptr
%441 = llvm.load %376 : !llvm.ptr -> i64
%442 = llvm.getelementptr %arg7[%441] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%440 = llvm.load %442 : !llvm.ptr -> i32
%443 = llvm.mlir.addressof @temp_id : !llvm.ptr
%444 = llvm.load %443 : !llvm.ptr -> !llvm.ptr
%445 = llvm.load %368 : !llvm.ptr -> i64
%446 = llvm.load %372 : !llvm.ptr -> i64
%447 = arith.addi %445, %446 : i64
%448 = llvm.getelementptr %444[%447] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %440, %448 : i32, !llvm.ptr
%449 = llvm.load %372 : !llvm.ptr -> i64
%450 = arith.constant 1 : i32
%452 = arith.extsi %450 : i32 to i64
%451 = arith.addi %449, %452 : i64
llvm.store %451, %372 : i64, !llvm.ptr
cf.br ^bb47
^bb46:
cf.br ^bb47
^bb47:
%453 = llvm.load %376 : !llvm.ptr -> i64
%454 = arith.constant 1 : i32
%456 = arith.extsi %454 : i32 to i64
%455 = arith.addi %453, %456 : i64
llvm.store %455, %376 : i64, !llvm.ptr
cf.br ^bb42
^bb44:
%457 = arith.constant 0 : i32
%458 = arith.extsi %457 : i32 to i64
llvm.store %458, %376 : i64, !llvm.ptr
cf.br ^bb48
^bb48:
%459 = llvm.load %376 : !llvm.ptr -> i64
%460 = arith.cmpi slt, %459, %arg8 : i64
cf.cond_br %460, ^bb49, ^bb50
^bb49:
%462 = llvm.mlir.addressof @temp_x : !llvm.ptr
%463 = llvm.load %462 : !llvm.ptr -> !llvm.ptr
%464 = llvm.load %376 : !llvm.ptr -> i64
%465 = llvm.getelementptr %463[%464] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%461 = llvm.load %465 : !llvm.ptr -> i32
%466 = llvm.load %376 : !llvm.ptr -> i64
%467 = llvm.getelementptr %arg5[%466] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %461, %467 : i32, !llvm.ptr
%469 = llvm.mlir.addressof @temp_y : !llvm.ptr
%470 = llvm.load %469 : !llvm.ptr -> !llvm.ptr
%471 = llvm.load %376 : !llvm.ptr -> i64
%472 = llvm.getelementptr %470[%471] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%468 = llvm.load %472 : !llvm.ptr -> i32
%473 = llvm.load %376 : !llvm.ptr -> i64
%474 = llvm.getelementptr %arg6[%473] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %468, %474 : i32, !llvm.ptr
%476 = llvm.mlir.addressof @temp_id : !llvm.ptr
%477 = llvm.load %476 : !llvm.ptr -> !llvm.ptr
%478 = llvm.load %376 : !llvm.ptr -> i64
%479 = llvm.getelementptr %477[%478] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%475 = llvm.load %479 : !llvm.ptr -> i32
%480 = llvm.load %376 : !llvm.ptr -> i64
%481 = llvm.getelementptr %arg7[%480] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %475, %481 : i32, !llvm.ptr
%482 = llvm.load %376 : !llvm.ptr -> i64
%483 = arith.constant 1 : i32
%485 = arith.extsi %483 : i32 to i64
%484 = arith.addi %482, %485 : i64
llvm.store %484, %376 : i64, !llvm.ptr
cf.br ^bb48
^bb50:
%487 = arith.constant 1 : i32
%489 = arith.extsi %487 : i32 to i64
%488 = arith.subi %359, %489 : i64
%490 = llvm.load %368 : !llvm.ptr -> i64
%486 = func.call @closest_rec(%arg0, %arg1, %arg2, %arg3, %488, %arg5, %arg6, %arg7, %490) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> i64
# String concatenation: !llvm.ptr + i64
# String concatenation: !llvm.ptr + i64
# String concatenation: !llvm.ptr + i64
%495 = llvm.load %372 : !llvm.ptr -> i64
%491 = func.call @closest_rec(%arg0, %arg1, %arg2, %359, %arg4, %492, %493, %494, %495) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> i64
%496 = llvm.mlir.constant(1 : i64) : i64
%497 = llvm.alloca %496 x i64 : (i64) -> !llvm.ptr
llvm.store %486, %497 : i64, !llvm.ptr
%498 = llvm.load %497 : !llvm.ptr -> i64
%499 = arith.cmpi slt, %491, %498 : i64
cf.cond_br %499, ^bb51, ^bb52
^bb51:
llvm.store %491, %497 : i64, !llvm.ptr
cf.br ^bb53
^bb52:
cf.br ^bb53
^bb53:
%501 = llvm.load %368 : !llvm.ptr -> i64
%502 = llvm.load %372 : !llvm.ptr -> i64
func.call @merge_y(%arg5, %arg6, %arg7, %501, %502) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i64) -> ()
%503 = arith.constant 0 : i32
%504 = arith.extsi %503 : i32 to i64
%505 = llvm.mlir.constant(1 : i64) : i64
%506 = llvm.alloca %505 x i64 : (i64) -> !llvm.ptr
llvm.store %504, %506 : i64, !llvm.ptr
%507 = arith.constant 0 : i32
%508 = arith.extsi %507 : i32 to i64
llvm.store %508, %376 : i64, !llvm.ptr
cf.br ^bb54
^bb54:
%509 = llvm.load %376 : !llvm.ptr -> i64
%510 = arith.cmpi slt, %509, %arg8 : i64
cf.cond_br %510, ^bb55, ^bb56
^bb55:
%512 = llvm.load %376 : !llvm.ptr -> i64
%513 = llvm.getelementptr %arg5[%512] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%511 = llvm.load %513 : !llvm.ptr -> i32
%514 = arith.extsi %511 : i32 to i64
%515 = arith.extsi %360 : i32 to i64
%516 = arith.subi %514, %515 : i64
%517 = arith.muli %516, %516 : i64
%518 = llvm.load %497 : !llvm.ptr -> i64
%519 = arith.cmpi slt, %517, %518 : i64
cf.cond_br %519, ^bb57, ^bb58
^bb57:
%521 = llvm.load %376 : !llvm.ptr -> i64
%522 = llvm.getelementptr %arg5[%521] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%520 = llvm.load %522 : !llvm.ptr -> i32
%523 = llvm.mlir.addressof @temp_x : !llvm.ptr
%524 = llvm.load %523 : !llvm.ptr -> !llvm.ptr
%525 = llvm.load %506 : !llvm.ptr -> i64
%526 = llvm.getelementptr %524[%525] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %520, %526 : i32, !llvm.ptr
%528 = llvm.load %376 : !llvm.ptr -> i64
%529 = llvm.getelementptr %arg6[%528] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%527 = llvm.load %529 : !llvm.ptr -> i32
%530 = llvm.mlir.addressof @temp_y : !llvm.ptr
%531 = llvm.load %530 : !llvm.ptr -> !llvm.ptr
%532 = llvm.load %506 : !llvm.ptr -> i64
%533 = llvm.getelementptr %531[%532] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %527, %533 : i32, !llvm.ptr
%535 = llvm.load %376 : !llvm.ptr -> i64
%536 = llvm.getelementptr %arg7[%535] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%534 = llvm.load %536 : !llvm.ptr -> i32
%537 = llvm.mlir.addressof @temp_id : !llvm.ptr
%538 = llvm.load %537 : !llvm.ptr -> !llvm.ptr
%539 = llvm.load %506 : !llvm.ptr -> i64
%540 = llvm.getelementptr %538[%539] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %534, %540 : i32, !llvm.ptr
%541 = llvm.load %506 : !llvm.ptr -> i64
%542 = arith.constant 1 : i32
%544 = arith.extsi %542 : i32 to i64
%543 = arith.addi %541, %544 : i64
llvm.store %543, %506 : i64, !llvm.ptr
cf.br ^bb59
^bb58:
cf.br ^bb59
^bb59:
%545 = llvm.load %376 : !llvm.ptr -> i64
%546 = arith.constant 1 : i32
%548 = arith.extsi %546 : i32 to i64
%547 = arith.addi %545, %548 : i64
llvm.store %547, %376 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
%549 = arith.constant 0 : i32
%550 = arith.extsi %549 : i32 to i64
llvm.store %550, %376 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%551 = llvm.load %376 : !llvm.ptr -> i64
%552 = llvm.load %506 : !llvm.ptr -> i64
%553 = arith.cmpi slt, %551, %552 : i64
cf.cond_br %553, ^bb61, ^bb62
^bb61:
%554 = llvm.load %376 : !llvm.ptr -> i64
%555 = arith.constant 1 : i32
%557 = arith.extsi %555 : i32 to i64
%556 = arith.addi %554, %557 : i64
%558 = llvm.mlir.constant(1 : i64) : i64
%559 = llvm.alloca %558 x i64 : (i64) -> !llvm.ptr
llvm.store %556, %559 : i64, !llvm.ptr
cf.br ^bb63
^bb63:
%560 = llvm.load %559 : !llvm.ptr -> i64
%561 = llvm.load %506 : !llvm.ptr -> i64
%562 = arith.cmpi slt, %560, %561 : i64
cf.cond_br %562, ^bb64, ^bb65
^bb64:
%564 = llvm.mlir.addressof @temp_y : !llvm.ptr
%565 = llvm.load %564 : !llvm.ptr -> !llvm.ptr
%566 = llvm.load %559 : !llvm.ptr -> i64
%567 = llvm.getelementptr %565[%566] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%563 = llvm.load %567 : !llvm.ptr -> i32
%568 = arith.extsi %563 : i32 to i64
%570 = llvm.mlir.addressof @temp_y : !llvm.ptr
%571 = llvm.load %570 : !llvm.ptr -> !llvm.ptr
%572 = llvm.load %376 : !llvm.ptr -> i64
%573 = llvm.getelementptr %571[%572] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%569 = llvm.load %573 : !llvm.ptr -> i32
%574 = arith.extsi %569 : i32 to i64
%575 = arith.subi %568, %574 : i64
%576 = arith.muli %575, %575 : i64
%577 = llvm.load %497 : !llvm.ptr -> i64
%578 = arith.cmpi sge, %576, %577 : i64
cf.cond_br %578, ^bb66, ^bb67
^bb66:
cf.br ^bb65
^bb67:
cf.br ^bb68
^bb68:
%581 = llvm.mlir.addressof @temp_x : !llvm.ptr
%582 = llvm.load %581 : !llvm.ptr -> !llvm.ptr
%583 = llvm.load %376 : !llvm.ptr -> i64
%584 = llvm.getelementptr %582[%583] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%580 = llvm.load %584 : !llvm.ptr -> i32
%586 = llvm.mlir.addressof @temp_y : !llvm.ptr
%587 = llvm.load %586 : !llvm.ptr -> !llvm.ptr
%588 = llvm.load %376 : !llvm.ptr -> i64
%589 = llvm.getelementptr %587[%588] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%585 = llvm.load %589 : !llvm.ptr -> i32
%591 = llvm.mlir.addressof @temp_x : !llvm.ptr
%592 = llvm.load %591 : !llvm.ptr -> !llvm.ptr
%593 = llvm.load %559 : !llvm.ptr -> i64
%594 = llvm.getelementptr %592[%593] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%590 = llvm.load %594 : !llvm.ptr -> i32
%596 = llvm.mlir.addressof @temp_y : !llvm.ptr
%597 = llvm.load %596 : !llvm.ptr -> !llvm.ptr
%598 = llvm.load %559 : !llvm.ptr -> i64
%599 = llvm.getelementptr %597[%598] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%595 = llvm.load %599 : !llvm.ptr -> i32
%579 = func.call @dist2(%580, %585, %590, %595) : (i32, i32, i32, i32) -> i64
%600 = llvm.load %497 : !llvm.ptr -> i64
%601 = arith.cmpi slt, %579, %600 : i64
cf.cond_br %601, ^bb69, ^bb70
^bb69:
llvm.store %579, %497 : i64, !llvm.ptr
cf.br ^bb71
^bb70:
cf.br ^bb71
^bb71:
%602 = llvm.load %559 : !llvm.ptr -> i64
%603 = arith.constant 1 : i32
%605 = arith.extsi %603 : i32 to i64
%604 = arith.addi %602, %605 : i64
llvm.store %604, %559 : i64, !llvm.ptr
cf.br ^bb63
^bb65:
%606 = llvm.load %376 : !llvm.ptr -> i64
%607 = arith.constant 1 : i32
%609 = arith.extsi %607 : i32 to i64
%608 = arith.addi %606, %609 : i64
llvm.store %608, %376 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%610 = llvm.load %497 : !llvm.ptr -> i64
func.return %610 : i64
}
func.func @heapsort_x(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i64) -> () {
%611 = arith.constant 2 : i32
%613 = arith.extsi %611 : i32 to i64
%612 = arith.divsi %arg3, %613 : i64
%614 = arith.constant 1 : i32
%616 = arith.extsi %614 : i32 to i64
%615 = arith.subi %612, %616 : i64
%617 = llvm.mlir.constant(1 : i64) : i64
%618 = llvm.alloca %617 x i64 : (i64) -> !llvm.ptr
llvm.store %615, %618 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%619 = llvm.load %618 : !llvm.ptr -> i64
%620 = arith.constant 0 : i32
%622 = arith.extsi %620 : i32 to i64
%621 = arith.cmpi sge, %619, %622 : i64
cf.cond_br %621, ^bb73, ^bb74
^bb73:
%623 = llvm.load %618 : !llvm.ptr -> i64
%624 = llvm.mlir.constant(1 : i64) : i64
%625 = llvm.alloca %624 x i64 : (i64) -> !llvm.ptr
llvm.store %623, %625 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%626 = llvm.load %625 : !llvm.ptr -> i64
%627 = arith.constant 2 : i32
%629 = arith.extsi %627 : i32 to i64
%628 = arith.muli %626, %629 : i64
%630 = arith.constant 1 : i32
%632 = arith.extsi %630 : i32 to i64
%631 = arith.addi %628, %632 : i64
%633 = arith.cmpi slt, %631, %arg3 : i64
cf.cond_br %633, ^bb76, ^bb77
^bb76:
%634 = llvm.load %625 : !llvm.ptr -> i64
%635 = arith.constant 2 : i32
%637 = arith.extsi %635 : i32 to i64
%636 = arith.muli %634, %637 : i64
%638 = arith.constant 1 : i32
%640 = arith.extsi %638 : i32 to i64
%639 = arith.addi %636, %640 : i64
%641 = llvm.load %625 : !llvm.ptr -> i64
%642 = llvm.mlir.constant(1 : i64) : i64
%643 = llvm.alloca %642 x i64 : (i64) -> !llvm.ptr
llvm.store %641, %643 : i64, !llvm.ptr
%644 = arith.constant 0 : i1
%645 = llvm.mlir.constant(1 : i64) : i64
%646 = llvm.alloca %645 x i1 : (i64) -> !llvm.ptr
llvm.store %644, %646 : i1, !llvm.ptr
%648 = llvm.getelementptr %arg0[%639] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%647 = llvm.load %648 : !llvm.ptr -> i32
%650 = llvm.load %643 : !llvm.ptr -> i64
%651 = llvm.getelementptr %arg0[%650] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%649 = llvm.load %651 : !llvm.ptr -> i32
%652 = arith.cmpi sgt, %647, %649 : i32
cf.cond_br %652, ^bb78, ^bb79
^bb78:
%653 = arith.constant 1 : i1
llvm.store %653, %646 : i1, !llvm.ptr
cf.br ^bb80
^bb79:
%655 = llvm.getelementptr %arg0[%639] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%654 = llvm.load %655 : !llvm.ptr -> i32
%657 = llvm.load %643 : !llvm.ptr -> i64
%658 = llvm.getelementptr %arg0[%657] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%656 = llvm.load %658 : !llvm.ptr -> i32
%659 = arith.cmpi eq, %654, %656 : i32
%660 = scf.if %659 -> (i1) {
%662 = llvm.getelementptr %arg1[%639] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%661 = llvm.load %662 : !llvm.ptr -> i32
%664 = llvm.load %643 : !llvm.ptr -> i64
%665 = llvm.getelementptr %arg1[%664] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%663 = llvm.load %665 : !llvm.ptr -> i32
%666 = arith.cmpi sgt, %661, %663 : i32
scf.yield %666 : i1
} else {
%667 = arith.constant false
scf.yield %667 : i1
}
cf.cond_br %660, ^bb81, ^bb82
^bb81:
%668 = arith.constant 1 : i1
llvm.store %668, %646 : i1, !llvm.ptr
cf.br ^bb83
^bb82:
cf.br ^bb83
^bb83:
cf.br ^bb80
^bb80:
%669 = llvm.load %646 : !llvm.ptr -> i1
cf.cond_br %669, ^bb84, ^bb85
^bb84:
llvm.store %639, %643 : i64, !llvm.ptr
cf.br ^bb86
^bb85:
cf.br ^bb86
^bb86:
%670 = arith.constant 1 : i32
%672 = arith.extsi %670 : i32 to i64
%671 = arith.addi %639, %672 : i64
%673 = arith.cmpi slt, %671, %arg3 : i64
cf.cond_br %673, ^bb87, ^bb88
^bb87:
%674 = arith.constant 0 : i1
%675 = llvm.mlir.constant(1 : i64) : i64
%676 = llvm.alloca %675 x i1 : (i64) -> !llvm.ptr
llvm.store %674, %676 : i1, !llvm.ptr
%678 = llvm.getelementptr %arg0[%671] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%677 = llvm.load %678 : !llvm.ptr -> i32
%680 = llvm.load %643 : !llvm.ptr -> i64
%681 = llvm.getelementptr %arg0[%680] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%679 = llvm.load %681 : !llvm.ptr -> i32
%682 = arith.cmpi sgt, %677, %679 : i32
cf.cond_br %682, ^bb90, ^bb91
^bb90:
%683 = arith.constant 1 : i1
llvm.store %683, %676 : i1, !llvm.ptr
cf.br ^bb92
^bb91:
%685 = llvm.getelementptr %arg0[%671] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%684 = llvm.load %685 : !llvm.ptr -> i32
%687 = llvm.load %643 : !llvm.ptr -> i64
%688 = llvm.getelementptr %arg0[%687] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%686 = llvm.load %688 : !llvm.ptr -> i32
%689 = arith.cmpi eq, %684, %686 : i32
%690 = scf.if %689 -> (i1) {
%692 = llvm.getelementptr %arg1[%671] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%691 = llvm.load %692 : !llvm.ptr -> i32
%694 = llvm.load %643 : !llvm.ptr -> i64
%695 = llvm.getelementptr %arg1[%694] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%693 = llvm.load %695 : !llvm.ptr -> i32
%696 = arith.cmpi sgt, %691, %693 : i32
scf.yield %696 : i1
} else {
%697 = arith.constant false
scf.yield %697 : i1
}
cf.cond_br %690, ^bb93, ^bb94
^bb93:
%698 = arith.constant 1 : i1
llvm.store %698, %676 : i1, !llvm.ptr
cf.br ^bb95
^bb94:
cf.br ^bb95
^bb95:
cf.br ^bb92
^bb92:
%699 = llvm.load %676 : !llvm.ptr -> i1
cf.cond_br %699, ^bb96, ^bb97
^bb96:
llvm.store %671, %643 : i64, !llvm.ptr
cf.br ^bb98
^bb97:
cf.br ^bb98
^bb98:
cf.br ^bb89
^bb88:
cf.br ^bb89
^bb89:
%700 = llvm.load %643 : !llvm.ptr -> i64
%701 = llvm.load %625 : !llvm.ptr -> i64
%702 = arith.cmpi eq, %700, %701 : i64
cf.cond_br %702, ^bb99, ^bb100
^bb99:
cf.br ^bb77
^bb100:
cf.br ^bb101
^bb101:
%704 = llvm.load %625 : !llvm.ptr -> i64
%705 = llvm.getelementptr %arg0[%704] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%703 = llvm.load %705 : !llvm.ptr -> i32
%707 = llvm.load %625 : !llvm.ptr -> i64
%708 = llvm.getelementptr %arg1[%707] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%706 = llvm.load %708 : !llvm.ptr -> i32
%710 = llvm.load %625 : !llvm.ptr -> i64
%711 = llvm.getelementptr %arg2[%710] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%709 = llvm.load %711 : !llvm.ptr -> i32
%713 = llvm.load %643 : !llvm.ptr -> i64
%714 = llvm.getelementptr %arg0[%713] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%712 = llvm.load %714 : !llvm.ptr -> i32
%715 = llvm.load %625 : !llvm.ptr -> i64
%716 = llvm.getelementptr %arg0[%715] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %712, %716 : i32, !llvm.ptr
%718 = llvm.load %643 : !llvm.ptr -> i64
%719 = llvm.getelementptr %arg1[%718] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%717 = llvm.load %719 : !llvm.ptr -> i32
%720 = llvm.load %625 : !llvm.ptr -> i64
%721 = llvm.getelementptr %arg1[%720] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %717, %721 : i32, !llvm.ptr
%723 = llvm.load %643 : !llvm.ptr -> i64
%724 = llvm.getelementptr %arg2[%723] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%722 = llvm.load %724 : !llvm.ptr -> i32
%725 = llvm.load %625 : !llvm.ptr -> i64
%726 = llvm.getelementptr %arg2[%725] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %722, %726 : i32, !llvm.ptr
%727 = llvm.load %643 : !llvm.ptr -> i64
%728 = llvm.getelementptr %arg0[%727] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %703, %728 : i32, !llvm.ptr
%729 = llvm.load %643 : !llvm.ptr -> i64
%730 = llvm.getelementptr %arg1[%729] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %706, %730 : i32, !llvm.ptr
%731 = llvm.load %643 : !llvm.ptr -> i64
%732 = llvm.getelementptr %arg2[%731] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %709, %732 : i32, !llvm.ptr
%733 = llvm.load %643 : !llvm.ptr -> i64
llvm.store %733, %625 : i64, !llvm.ptr
cf.br ^bb75
^bb77:
%734 = llvm.load %618 : !llvm.ptr -> i64
%735 = arith.constant 0 : i32
%737 = arith.extsi %735 : i32 to i64
%736 = arith.cmpi eq, %734, %737 : i64
cf.cond_br %736, ^bb102, ^bb103
^bb102:
cf.br ^bb74
^bb103:
cf.br ^bb104
^bb104:
%738 = llvm.load %618 : !llvm.ptr -> i64
%739 = arith.constant 1 : i32
%741 = arith.extsi %739 : i32 to i64
%740 = arith.subi %738, %741 : i64
llvm.store %740, %618 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
%742 = arith.constant 1 : i32
%744 = arith.extsi %742 : i32 to i64
%743 = arith.subi %arg3, %744 : i64
%745 = llvm.mlir.constant(1 : i64) : i64
%746 = llvm.alloca %745 x i64 : (i64) -> !llvm.ptr
llvm.store %743, %746 : i64, !llvm.ptr
cf.br ^bb105
^bb105:
%747 = llvm.load %746 : !llvm.ptr -> i64
%748 = arith.constant 0 : i32
%750 = arith.extsi %748 : i32 to i64
%749 = arith.cmpi sgt, %747, %750 : i64
cf.cond_br %749, ^bb106, ^bb107
^bb106:
%752 = arith.constant 0 : i32
%753 = arith.extsi %752 : i32 to i64
%754 = llvm.getelementptr %arg0[%753] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%751 = llvm.load %754 : !llvm.ptr -> i32
%756 = arith.constant 0 : i32
%757 = arith.extsi %756 : i32 to i64
%758 = llvm.getelementptr %arg1[%757] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%755 = llvm.load %758 : !llvm.ptr -> i32
%760 = arith.constant 0 : i32
%761 = arith.extsi %760 : i32 to i64
%762 = llvm.getelementptr %arg2[%761] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%759 = llvm.load %762 : !llvm.ptr -> i32
%764 = llvm.load %746 : !llvm.ptr -> i64
%765 = llvm.getelementptr %arg0[%764] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%763 = llvm.load %765 : !llvm.ptr -> i32
%766 = arith.constant 0 : i32
%767 = arith.extsi %766 : i32 to i64
%768 = llvm.getelementptr %arg0[%767] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %763, %768 : i32, !llvm.ptr
%770 = llvm.load %746 : !llvm.ptr -> i64
%771 = llvm.getelementptr %arg1[%770] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%769 = llvm.load %771 : !llvm.ptr -> i32
%772 = arith.constant 0 : i32
%773 = arith.extsi %772 : i32 to i64
%774 = llvm.getelementptr %arg1[%773] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %769, %774 : i32, !llvm.ptr
%776 = llvm.load %746 : !llvm.ptr -> i64
%777 = llvm.getelementptr %arg2[%776] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%775 = llvm.load %777 : !llvm.ptr -> i32
%778 = arith.constant 0 : i32
%779 = arith.extsi %778 : i32 to i64
%780 = llvm.getelementptr %arg2[%779] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %775, %780 : i32, !llvm.ptr
%781 = llvm.load %746 : !llvm.ptr -> i64
%782 = llvm.getelementptr %arg0[%781] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %751, %782 : i32, !llvm.ptr
%783 = llvm.load %746 : !llvm.ptr -> i64
%784 = llvm.getelementptr %arg1[%783] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %755, %784 : i32, !llvm.ptr
%785 = llvm.load %746 : !llvm.ptr -> i64
%786 = llvm.getelementptr %arg2[%785] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %759, %786 : i32, !llvm.ptr
%787 = arith.constant 0 : i32
%788 = arith.extsi %787 : i32 to i64
%789 = llvm.mlir.constant(1 : i64) : i64
%790 = llvm.alloca %789 x i64 : (i64) -> !llvm.ptr
llvm.store %788, %790 : i64, !llvm.ptr
cf.br ^bb108
^bb108:
%791 = llvm.load %790 : !llvm.ptr -> i64
%792 = arith.constant 2 : i32
%794 = arith.extsi %792 : i32 to i64
%793 = arith.muli %791, %794 : i64
%795 = arith.constant 1 : i32
%797 = arith.extsi %795 : i32 to i64
%796 = arith.addi %793, %797 : i64
%798 = llvm.load %746 : !llvm.ptr -> i64
%799 = arith.cmpi slt, %796, %798 : i64
cf.cond_br %799, ^bb109, ^bb110
^bb109:
%800 = llvm.load %790 : !llvm.ptr -> i64
%801 = arith.constant 2 : i32
%803 = arith.extsi %801 : i32 to i64
%802 = arith.muli %800, %803 : i64
%804 = arith.constant 1 : i32
%806 = arith.extsi %804 : i32 to i64
%805 = arith.addi %802, %806 : i64
%807 = llvm.load %790 : !llvm.ptr -> i64
%808 = llvm.mlir.constant(1 : i64) : i64
%809 = llvm.alloca %808 x i64 : (i64) -> !llvm.ptr
llvm.store %807, %809 : i64, !llvm.ptr
%810 = arith.constant 0 : i1
%811 = llvm.mlir.constant(1 : i64) : i64
%812 = llvm.alloca %811 x i1 : (i64) -> !llvm.ptr
llvm.store %810, %812 : i1, !llvm.ptr
%814 = llvm.getelementptr %arg0[%805] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%813 = llvm.load %814 : !llvm.ptr -> i32
%816 = llvm.load %809 : !llvm.ptr -> i64
%817 = llvm.getelementptr %arg0[%816] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%815 = llvm.load %817 : !llvm.ptr -> i32
%818 = arith.cmpi sgt, %813, %815 : i32
cf.cond_br %818, ^bb111, ^bb112
^bb111:
%819 = arith.constant 1 : i1
llvm.store %819, %812 : i1, !llvm.ptr
cf.br ^bb113
^bb112:
%821 = llvm.getelementptr %arg0[%805] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%820 = llvm.load %821 : !llvm.ptr -> i32
%823 = llvm.load %809 : !llvm.ptr -> i64
%824 = llvm.getelementptr %arg0[%823] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%822 = llvm.load %824 : !llvm.ptr -> i32
%825 = arith.cmpi eq, %820, %822 : i32
%826 = scf.if %825 -> (i1) {
%828 = llvm.getelementptr %arg1[%805] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%827 = llvm.load %828 : !llvm.ptr -> i32
%830 = llvm.load %809 : !llvm.ptr -> i64
%831 = llvm.getelementptr %arg1[%830] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%829 = llvm.load %831 : !llvm.ptr -> i32
%832 = arith.cmpi sgt, %827, %829 : i32
scf.yield %832 : i1
} else {
%833 = arith.constant false
scf.yield %833 : i1
}
cf.cond_br %826, ^bb114, ^bb115
^bb114:
%834 = arith.constant 1 : i1
llvm.store %834, %812 : i1, !llvm.ptr
cf.br ^bb116
^bb115:
cf.br ^bb116
^bb116:
cf.br ^bb113
^bb113:
%835 = llvm.load %812 : !llvm.ptr -> i1
cf.cond_br %835, ^bb117, ^bb118
^bb117:
llvm.store %805, %809 : i64, !llvm.ptr
cf.br ^bb119
^bb118:
cf.br ^bb119
^bb119:
%836 = arith.constant 1 : i32
%838 = arith.extsi %836 : i32 to i64
%837 = arith.addi %805, %838 : i64
%839 = llvm.load %746 : !llvm.ptr -> i64
%840 = arith.cmpi slt, %837, %839 : i64
cf.cond_br %840, ^bb120, ^bb121
^bb120:
%841 = arith.constant 0 : i1
%842 = llvm.mlir.constant(1 : i64) : i64
%843 = llvm.alloca %842 x i1 : (i64) -> !llvm.ptr
llvm.store %841, %843 : i1, !llvm.ptr
%845 = llvm.getelementptr %arg0[%837] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%844 = llvm.load %845 : !llvm.ptr -> i32
%847 = llvm.load %809 : !llvm.ptr -> i64
%848 = llvm.getelementptr %arg0[%847] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%846 = llvm.load %848 : !llvm.ptr -> i32
%849 = arith.cmpi sgt, %844, %846 : i32
cf.cond_br %849, ^bb123, ^bb124
^bb123:
%850 = arith.constant 1 : i1
llvm.store %850, %843 : i1, !llvm.ptr
cf.br ^bb125
^bb124:
%852 = llvm.getelementptr %arg0[%837] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%851 = llvm.load %852 : !llvm.ptr -> i32
%854 = llvm.load %809 : !llvm.ptr -> i64
%855 = llvm.getelementptr %arg0[%854] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%853 = llvm.load %855 : !llvm.ptr -> i32
%856 = arith.cmpi eq, %851, %853 : i32
%857 = scf.if %856 -> (i1) {
%859 = llvm.getelementptr %arg1[%837] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%858 = llvm.load %859 : !llvm.ptr -> i32
%861 = llvm.load %809 : !llvm.ptr -> i64
%862 = llvm.getelementptr %arg1[%861] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%860 = llvm.load %862 : !llvm.ptr -> i32
%863 = arith.cmpi sgt, %858, %860 : i32
scf.yield %863 : i1
} else {
%864 = arith.constant false
scf.yield %864 : i1
}
cf.cond_br %857, ^bb126, ^bb127
^bb126:
%865 = arith.constant 1 : i1
llvm.store %865, %843 : i1, !llvm.ptr
cf.br ^bb128
^bb127:
cf.br ^bb128
^bb128:
cf.br ^bb125
^bb125:
%866 = llvm.load %843 : !llvm.ptr -> i1
cf.cond_br %866, ^bb129, ^bb130
^bb129:
llvm.store %837, %809 : i64, !llvm.ptr
cf.br ^bb131
^bb130:
cf.br ^bb131
^bb131:
cf.br ^bb122
^bb121:
cf.br ^bb122
^bb122:
%867 = llvm.load %809 : !llvm.ptr -> i64
%868 = llvm.load %790 : !llvm.ptr -> i64
%869 = arith.cmpi eq, %867, %868 : i64
cf.cond_br %869, ^bb132, ^bb133
^bb132:
cf.br ^bb110
^bb133:
cf.br ^bb134
^bb134:
%871 = llvm.load %790 : !llvm.ptr -> i64
%872 = llvm.getelementptr %arg0[%871] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%870 = llvm.load %872 : !llvm.ptr -> i32
%874 = llvm.load %790 : !llvm.ptr -> i64
%875 = llvm.getelementptr %arg1[%874] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%873 = llvm.load %875 : !llvm.ptr -> i32
%877 = llvm.load %790 : !llvm.ptr -> i64
%878 = llvm.getelementptr %arg2[%877] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%876 = llvm.load %878 : !llvm.ptr -> i32
%880 = llvm.load %809 : !llvm.ptr -> i64
%881 = llvm.getelementptr %arg0[%880] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%879 = llvm.load %881 : !llvm.ptr -> i32
%882 = llvm.load %790 : !llvm.ptr -> i64
%883 = llvm.getelementptr %arg0[%882] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %879, %883 : i32, !llvm.ptr
%885 = llvm.load %809 : !llvm.ptr -> i64
%886 = llvm.getelementptr %arg1[%885] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%884 = llvm.load %886 : !llvm.ptr -> i32
%887 = llvm.load %790 : !llvm.ptr -> i64
%888 = llvm.getelementptr %arg1[%887] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %884, %888 : i32, !llvm.ptr
%890 = llvm.load %809 : !llvm.ptr -> i64
%891 = llvm.getelementptr %arg2[%890] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%889 = llvm.load %891 : !llvm.ptr -> i32
%892 = llvm.load %790 : !llvm.ptr -> i64
%893 = llvm.getelementptr %arg2[%892] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %889, %893 : i32, !llvm.ptr
%894 = llvm.load %809 : !llvm.ptr -> i64
%895 = llvm.getelementptr %arg0[%894] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %870, %895 : i32, !llvm.ptr
%896 = llvm.load %809 : !llvm.ptr -> i64
%897 = llvm.getelementptr %arg1[%896] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %873, %897 : i32, !llvm.ptr
%898 = llvm.load %809 : !llvm.ptr -> i64
%899 = llvm.getelementptr %arg2[%898] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %876, %899 : i32, !llvm.ptr
%900 = llvm.load %809 : !llvm.ptr -> i64
llvm.store %900, %790 : i64, !llvm.ptr
cf.br ^bb108
^bb110:
%901 = llvm.load %746 : !llvm.ptr -> i64
%902 = arith.constant 1 : i32
%904 = arith.extsi %902 : i32 to i64
%903 = arith.subi %901, %904 : i64
llvm.store %903, %746 : i64, !llvm.ptr
cf.br ^bb105
^bb107:
func.return
}
func.func @heapsort_y(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i64) -> () {
%905 = arith.constant 2 : i32
%907 = arith.extsi %905 : i32 to i64
%906 = arith.divsi %arg3, %907 : i64
%908 = arith.constant 1 : i32
%910 = arith.extsi %908 : i32 to i64
%909 = arith.subi %906, %910 : i64
%911 = llvm.mlir.constant(1 : i64) : i64
%912 = llvm.alloca %911 x i64 : (i64) -> !llvm.ptr
llvm.store %909, %912 : i64, !llvm.ptr
cf.br ^bb135
^bb135:
%913 = llvm.load %912 : !llvm.ptr -> i64
%914 = arith.constant 0 : i32
%916 = arith.extsi %914 : i32 to i64
%915 = arith.cmpi sge, %913, %916 : i64
cf.cond_br %915, ^bb136, ^bb137
^bb136:
%917 = llvm.load %912 : !llvm.ptr -> i64
%918 = llvm.mlir.constant(1 : i64) : i64
%919 = llvm.alloca %918 x i64 : (i64) -> !llvm.ptr
llvm.store %917, %919 : i64, !llvm.ptr
cf.br ^bb138
^bb138:
%920 = llvm.load %919 : !llvm.ptr -> i64
%921 = arith.constant 2 : i32
%923 = arith.extsi %921 : i32 to i64
%922 = arith.muli %920, %923 : i64
%924 = arith.constant 1 : i32
%926 = arith.extsi %924 : i32 to i64
%925 = arith.addi %922, %926 : i64
%927 = arith.cmpi slt, %925, %arg3 : i64
cf.cond_br %927, ^bb139, ^bb140
^bb139:
%928 = llvm.load %919 : !llvm.ptr -> i64
%929 = arith.constant 2 : i32
%931 = arith.extsi %929 : i32 to i64
%930 = arith.muli %928, %931 : i64
%932 = arith.constant 1 : i32
%934 = arith.extsi %932 : i32 to i64
%933 = arith.addi %930, %934 : i64
%935 = llvm.load %919 : !llvm.ptr -> i64
%936 = llvm.mlir.constant(1 : i64) : i64
%937 = llvm.alloca %936 x i64 : (i64) -> !llvm.ptr
llvm.store %935, %937 : i64, !llvm.ptr
%938 = arith.constant 0 : i1
%939 = llvm.mlir.constant(1 : i64) : i64
%940 = llvm.alloca %939 x i1 : (i64) -> !llvm.ptr
llvm.store %938, %940 : i1, !llvm.ptr
%942 = llvm.getelementptr %arg1[%933] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%941 = llvm.load %942 : !llvm.ptr -> i32
%944 = llvm.load %937 : !llvm.ptr -> i64
%945 = llvm.getelementptr %arg1[%944] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%943 = llvm.load %945 : !llvm.ptr -> i32
%946 = arith.cmpi sgt, %941, %943 : i32
cf.cond_br %946, ^bb141, ^bb142
^bb141:
%947 = arith.constant 1 : i1
llvm.store %947, %940 : i1, !llvm.ptr
cf.br ^bb143
^bb142:
%949 = llvm.getelementptr %arg1[%933] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%948 = llvm.load %949 : !llvm.ptr -> i32
%951 = llvm.load %937 : !llvm.ptr -> i64
%952 = llvm.getelementptr %arg1[%951] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%950 = llvm.load %952 : !llvm.ptr -> i32
%953 = arith.cmpi eq, %948, %950 : i32
%954 = scf.if %953 -> (i1) {
%956 = llvm.getelementptr %arg0[%933] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%955 = llvm.load %956 : !llvm.ptr -> i32
%958 = llvm.load %937 : !llvm.ptr -> i64
%959 = llvm.getelementptr %arg0[%958] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%957 = llvm.load %959 : !llvm.ptr -> i32
%960 = arith.cmpi sgt, %955, %957 : i32
scf.yield %960 : i1
} else {
%961 = arith.constant false
scf.yield %961 : i1
}
cf.cond_br %954, ^bb144, ^bb145
^bb144:
%962 = arith.constant 1 : i1
llvm.store %962, %940 : i1, !llvm.ptr
cf.br ^bb146
^bb145:
cf.br ^bb146
^bb146:
cf.br ^bb143
^bb143:
%963 = llvm.load %940 : !llvm.ptr -> i1
cf.cond_br %963, ^bb147, ^bb148
^bb147:
llvm.store %933, %937 : i64, !llvm.ptr
cf.br ^bb149
^bb148:
cf.br ^bb149
^bb149:
%964 = arith.constant 1 : i32
%966 = arith.extsi %964 : i32 to i64
%965 = arith.addi %933, %966 : i64
%967 = arith.cmpi slt, %965, %arg3 : i64
cf.cond_br %967, ^bb150, ^bb151
^bb150:
%968 = arith.constant 0 : i1
%969 = llvm.mlir.constant(1 : i64) : i64
%970 = llvm.alloca %969 x i1 : (i64) -> !llvm.ptr
llvm.store %968, %970 : i1, !llvm.ptr
%972 = llvm.getelementptr %arg1[%965] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%971 = llvm.load %972 : !llvm.ptr -> i32
%974 = llvm.load %937 : !llvm.ptr -> i64
%975 = llvm.getelementptr %arg1[%974] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%973 = llvm.load %975 : !llvm.ptr -> i32
%976 = arith.cmpi sgt, %971, %973 : i32
cf.cond_br %976, ^bb153, ^bb154
^bb153:
%977 = arith.constant 1 : i1
llvm.store %977, %970 : i1, !llvm.ptr
cf.br ^bb155
^bb154:
%979 = llvm.getelementptr %arg1[%965] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%978 = llvm.load %979 : !llvm.ptr -> i32
%981 = llvm.load %937 : !llvm.ptr -> i64
%982 = llvm.getelementptr %arg1[%981] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%980 = llvm.load %982 : !llvm.ptr -> i32
%983 = arith.cmpi eq, %978, %980 : i32
%984 = scf.if %983 -> (i1) {
%986 = llvm.getelementptr %arg0[%965] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%985 = llvm.load %986 : !llvm.ptr -> i32
%988 = llvm.load %937 : !llvm.ptr -> i64
%989 = llvm.getelementptr %arg0[%988] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%987 = llvm.load %989 : !llvm.ptr -> i32
%990 = arith.cmpi sgt, %985, %987 : i32
scf.yield %990 : i1
} else {
%991 = arith.constant false
scf.yield %991 : i1
}
cf.cond_br %984, ^bb156, ^bb157
^bb156:
%992 = arith.constant 1 : i1
llvm.store %992, %970 : i1, !llvm.ptr
cf.br ^bb158
^bb157:
cf.br ^bb158
^bb158:
cf.br ^bb155
^bb155:
%993 = llvm.load %970 : !llvm.ptr -> i1
cf.cond_br %993, ^bb159, ^bb160
^bb159:
llvm.store %965, %937 : i64, !llvm.ptr
cf.br ^bb161
^bb160:
cf.br ^bb161
^bb161:
cf.br ^bb152
^bb151:
cf.br ^bb152
^bb152:
%994 = llvm.load %937 : !llvm.ptr -> i64
%995 = llvm.load %919 : !llvm.ptr -> i64
%996 = arith.cmpi eq, %994, %995 : i64
cf.cond_br %996, ^bb162, ^bb163
^bb162:
cf.br ^bb140
^bb163:
cf.br ^bb164
^bb164:
%998 = llvm.load %919 : !llvm.ptr -> i64
%999 = llvm.getelementptr %arg0[%998] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%997 = llvm.load %999 : !llvm.ptr -> i32
%1001 = llvm.load %919 : !llvm.ptr -> i64
%1002 = llvm.getelementptr %arg1[%1001] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1000 = llvm.load %1002 : !llvm.ptr -> i32
%1004 = llvm.load %919 : !llvm.ptr -> i64
%1005 = llvm.getelementptr %arg2[%1004] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1003 = llvm.load %1005 : !llvm.ptr -> i32
%1007 = llvm.load %937 : !llvm.ptr -> i64
%1008 = llvm.getelementptr %arg0[%1007] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1006 = llvm.load %1008 : !llvm.ptr -> i32
%1009 = llvm.load %919 : !llvm.ptr -> i64
%1010 = llvm.getelementptr %arg0[%1009] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1006, %1010 : i32, !llvm.ptr
%1012 = llvm.load %937 : !llvm.ptr -> i64
%1013 = llvm.getelementptr %arg1[%1012] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1011 = llvm.load %1013 : !llvm.ptr -> i32
%1014 = llvm.load %919 : !llvm.ptr -> i64
%1015 = llvm.getelementptr %arg1[%1014] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1011, %1015 : i32, !llvm.ptr
%1017 = llvm.load %937 : !llvm.ptr -> i64
%1018 = llvm.getelementptr %arg2[%1017] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1016 = llvm.load %1018 : !llvm.ptr -> i32
%1019 = llvm.load %919 : !llvm.ptr -> i64
%1020 = llvm.getelementptr %arg2[%1019] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1016, %1020 : i32, !llvm.ptr
%1021 = llvm.load %937 : !llvm.ptr -> i64
%1022 = llvm.getelementptr %arg0[%1021] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %997, %1022 : i32, !llvm.ptr
%1023 = llvm.load %937 : !llvm.ptr -> i64
%1024 = llvm.getelementptr %arg1[%1023] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1000, %1024 : i32, !llvm.ptr
%1025 = llvm.load %937 : !llvm.ptr -> i64
%1026 = llvm.getelementptr %arg2[%1025] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1003, %1026 : i32, !llvm.ptr
%1027 = llvm.load %937 : !llvm.ptr -> i64
llvm.store %1027, %919 : i64, !llvm.ptr
cf.br ^bb138
^bb140:
%1028 = llvm.load %912 : !llvm.ptr -> i64
%1029 = arith.constant 0 : i32
%1031 = arith.extsi %1029 : i32 to i64
%1030 = arith.cmpi eq, %1028, %1031 : i64
cf.cond_br %1030, ^bb165, ^bb166
^bb165:
cf.br ^bb137
^bb166:
cf.br ^bb167
^bb167:
%1032 = llvm.load %912 : !llvm.ptr -> i64
%1033 = arith.constant 1 : i32
%1035 = arith.extsi %1033 : i32 to i64
%1034 = arith.subi %1032, %1035 : i64
llvm.store %1034, %912 : i64, !llvm.ptr
cf.br ^bb135
^bb137:
%1036 = arith.constant 1 : i32
%1038 = arith.extsi %1036 : i32 to i64
%1037 = arith.subi %arg3, %1038 : i64
%1039 = llvm.mlir.constant(1 : i64) : i64
%1040 = llvm.alloca %1039 x i64 : (i64) -> !llvm.ptr
llvm.store %1037, %1040 : i64, !llvm.ptr
cf.br ^bb168
^bb168:
%1041 = llvm.load %1040 : !llvm.ptr -> i64
%1042 = arith.constant 0 : i32
%1044 = arith.extsi %1042 : i32 to i64
%1043 = arith.cmpi sgt, %1041, %1044 : i64
cf.cond_br %1043, ^bb169, ^bb170
^bb169:
%1046 = arith.constant 0 : i32
%1047 = arith.extsi %1046 : i32 to i64
%1048 = llvm.getelementptr %arg0[%1047] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1045 = llvm.load %1048 : !llvm.ptr -> i32
%1050 = arith.constant 0 : i32
%1051 = arith.extsi %1050 : i32 to i64
%1052 = llvm.getelementptr %arg1[%1051] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1049 = llvm.load %1052 : !llvm.ptr -> i32
%1054 = arith.constant 0 : i32
%1055 = arith.extsi %1054 : i32 to i64
%1056 = llvm.getelementptr %arg2[%1055] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1053 = llvm.load %1056 : !llvm.ptr -> i32
%1058 = llvm.load %1040 : !llvm.ptr -> i64
%1059 = llvm.getelementptr %arg0[%1058] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1057 = llvm.load %1059 : !llvm.ptr -> i32
%1060 = arith.constant 0 : i32
%1061 = arith.extsi %1060 : i32 to i64
%1062 = llvm.getelementptr %arg0[%1061] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1057, %1062 : i32, !llvm.ptr
%1064 = llvm.load %1040 : !llvm.ptr -> i64
%1065 = llvm.getelementptr %arg1[%1064] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1063 = llvm.load %1065 : !llvm.ptr -> i32
%1066 = arith.constant 0 : i32
%1067 = arith.extsi %1066 : i32 to i64
%1068 = llvm.getelementptr %arg1[%1067] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1063, %1068 : i32, !llvm.ptr
%1070 = llvm.load %1040 : !llvm.ptr -> i64
%1071 = llvm.getelementptr %arg2[%1070] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1069 = llvm.load %1071 : !llvm.ptr -> i32
%1072 = arith.constant 0 : i32
%1073 = arith.extsi %1072 : i32 to i64
%1074 = llvm.getelementptr %arg2[%1073] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1069, %1074 : i32, !llvm.ptr
%1075 = llvm.load %1040 : !llvm.ptr -> i64
%1076 = llvm.getelementptr %arg0[%1075] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1045, %1076 : i32, !llvm.ptr
%1077 = llvm.load %1040 : !llvm.ptr -> i64
%1078 = llvm.getelementptr %arg1[%1077] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1049, %1078 : i32, !llvm.ptr
%1079 = llvm.load %1040 : !llvm.ptr -> i64
%1080 = llvm.getelementptr %arg2[%1079] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1053, %1080 : i32, !llvm.ptr
%1081 = arith.constant 0 : i32
%1082 = arith.extsi %1081 : i32 to i64
%1083 = llvm.mlir.constant(1 : i64) : i64
%1084 = llvm.alloca %1083 x i64 : (i64) -> !llvm.ptr
llvm.store %1082, %1084 : i64, !llvm.ptr
cf.br ^bb171
^bb171:
%1085 = llvm.load %1084 : !llvm.ptr -> i64
%1086 = arith.constant 2 : i32
%1088 = arith.extsi %1086 : i32 to i64
%1087 = arith.muli %1085, %1088 : i64
%1089 = arith.constant 1 : i32
%1091 = arith.extsi %1089 : i32 to i64
%1090 = arith.addi %1087, %1091 : i64
%1092 = llvm.load %1040 : !llvm.ptr -> i64
%1093 = arith.cmpi slt, %1090, %1092 : i64
cf.cond_br %1093, ^bb172, ^bb173
^bb172:
%1094 = llvm.load %1084 : !llvm.ptr -> i64
%1095 = arith.constant 2 : i32
%1097 = arith.extsi %1095 : i32 to i64
%1096 = arith.muli %1094, %1097 : i64
%1098 = arith.constant 1 : i32
%1100 = arith.extsi %1098 : i32 to i64
%1099 = arith.addi %1096, %1100 : i64
%1101 = llvm.load %1084 : !llvm.ptr -> i64
%1102 = llvm.mlir.constant(1 : i64) : i64
%1103 = llvm.alloca %1102 x i64 : (i64) -> !llvm.ptr
llvm.store %1101, %1103 : i64, !llvm.ptr
%1104 = arith.constant 0 : i1
%1105 = llvm.mlir.constant(1 : i64) : i64
%1106 = llvm.alloca %1105 x i1 : (i64) -> !llvm.ptr
llvm.store %1104, %1106 : i1, !llvm.ptr
%1108 = llvm.getelementptr %arg1[%1099] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1107 = llvm.load %1108 : !llvm.ptr -> i32
%1110 = llvm.load %1103 : !llvm.ptr -> i64
%1111 = llvm.getelementptr %arg1[%1110] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1109 = llvm.load %1111 : !llvm.ptr -> i32
%1112 = arith.cmpi sgt, %1107, %1109 : i32
cf.cond_br %1112, ^bb174, ^bb175
^bb174:
%1113 = arith.constant 1 : i1
llvm.store %1113, %1106 : i1, !llvm.ptr
cf.br ^bb176
^bb175:
%1115 = llvm.getelementptr %arg1[%1099] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1114 = llvm.load %1115 : !llvm.ptr -> i32
%1117 = llvm.load %1103 : !llvm.ptr -> i64
%1118 = llvm.getelementptr %arg1[%1117] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1116 = llvm.load %1118 : !llvm.ptr -> i32
%1119 = arith.cmpi eq, %1114, %1116 : i32
%1120 = scf.if %1119 -> (i1) {
%1122 = llvm.getelementptr %arg0[%1099] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1121 = llvm.load %1122 : !llvm.ptr -> i32
%1124 = llvm.load %1103 : !llvm.ptr -> i64
%1125 = llvm.getelementptr %arg0[%1124] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1123 = llvm.load %1125 : !llvm.ptr -> i32
%1126 = arith.cmpi sgt, %1121, %1123 : i32
scf.yield %1126 : i1
} else {
%1127 = arith.constant false
scf.yield %1127 : i1
}
cf.cond_br %1120, ^bb177, ^bb178
^bb177:
%1128 = arith.constant 1 : i1
llvm.store %1128, %1106 : i1, !llvm.ptr
cf.br ^bb179
^bb178:
cf.br ^bb179
^bb179:
cf.br ^bb176
^bb176:
%1129 = llvm.load %1106 : !llvm.ptr -> i1
cf.cond_br %1129, ^bb180, ^bb181
^bb180:
llvm.store %1099, %1103 : i64, !llvm.ptr
cf.br ^bb182
^bb181:
cf.br ^bb182
^bb182:
%1130 = arith.constant 1 : i32
%1132 = arith.extsi %1130 : i32 to i64
%1131 = arith.addi %1099, %1132 : i64
%1133 = llvm.load %1040 : !llvm.ptr -> i64
%1134 = arith.cmpi slt, %1131, %1133 : i64
cf.cond_br %1134, ^bb183, ^bb184
^bb183:
%1135 = arith.constant 0 : i1
%1136 = llvm.mlir.constant(1 : i64) : i64
%1137 = llvm.alloca %1136 x i1 : (i64) -> !llvm.ptr
llvm.store %1135, %1137 : i1, !llvm.ptr
%1139 = llvm.getelementptr %arg1[%1131] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1138 = llvm.load %1139 : !llvm.ptr -> i32
%1141 = llvm.load %1103 : !llvm.ptr -> i64
%1142 = llvm.getelementptr %arg1[%1141] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1140 = llvm.load %1142 : !llvm.ptr -> i32
%1143 = arith.cmpi sgt, %1138, %1140 : i32
cf.cond_br %1143, ^bb186, ^bb187
^bb186:
%1144 = arith.constant 1 : i1
llvm.store %1144, %1137 : i1, !llvm.ptr
cf.br ^bb188
^bb187:
%1146 = llvm.getelementptr %arg1[%1131] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1145 = llvm.load %1146 : !llvm.ptr -> i32
%1148 = llvm.load %1103 : !llvm.ptr -> i64
%1149 = llvm.getelementptr %arg1[%1148] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1147 = llvm.load %1149 : !llvm.ptr -> i32
%1150 = arith.cmpi eq, %1145, %1147 : i32
%1151 = scf.if %1150 -> (i1) {
%1153 = llvm.getelementptr %arg0[%1131] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1152 = llvm.load %1153 : !llvm.ptr -> i32
%1155 = llvm.load %1103 : !llvm.ptr -> i64
%1156 = llvm.getelementptr %arg0[%1155] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1154 = llvm.load %1156 : !llvm.ptr -> i32
%1157 = arith.cmpi sgt, %1152, %1154 : i32
scf.yield %1157 : i1
} else {
%1158 = arith.constant false
scf.yield %1158 : i1
}
cf.cond_br %1151, ^bb189, ^bb190
^bb189:
%1159 = arith.constant 1 : i1
llvm.store %1159, %1137 : i1, !llvm.ptr
cf.br ^bb191
^bb190:
cf.br ^bb191
^bb191:
cf.br ^bb188
^bb188:
%1160 = llvm.load %1137 : !llvm.ptr -> i1
cf.cond_br %1160, ^bb192, ^bb193
^bb192:
llvm.store %1131, %1103 : i64, !llvm.ptr
cf.br ^bb194
^bb193:
cf.br ^bb194
^bb194:
cf.br ^bb185
^bb184:
cf.br ^bb185
^bb185:
%1161 = llvm.load %1103 : !llvm.ptr -> i64
%1162 = llvm.load %1084 : !llvm.ptr -> i64
%1163 = arith.cmpi eq, %1161, %1162 : i64
cf.cond_br %1163, ^bb195, ^bb196
^bb195:
cf.br ^bb173
^bb196:
cf.br ^bb197
^bb197:
%1165 = llvm.load %1084 : !llvm.ptr -> i64
%1166 = llvm.getelementptr %arg0[%1165] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1164 = llvm.load %1166 : !llvm.ptr -> i32
%1168 = llvm.load %1084 : !llvm.ptr -> i64
%1169 = llvm.getelementptr %arg1[%1168] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1167 = llvm.load %1169 : !llvm.ptr -> i32
%1171 = llvm.load %1084 : !llvm.ptr -> i64
%1172 = llvm.getelementptr %arg2[%1171] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1170 = llvm.load %1172 : !llvm.ptr -> i32
%1174 = llvm.load %1103 : !llvm.ptr -> i64
%1175 = llvm.getelementptr %arg0[%1174] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1173 = llvm.load %1175 : !llvm.ptr -> i32
%1176 = llvm.load %1084 : !llvm.ptr -> i64
%1177 = llvm.getelementptr %arg0[%1176] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1173, %1177 : i32, !llvm.ptr
%1179 = llvm.load %1103 : !llvm.ptr -> i64
%1180 = llvm.getelementptr %arg1[%1179] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1178 = llvm.load %1180 : !llvm.ptr -> i32
%1181 = llvm.load %1084 : !llvm.ptr -> i64
%1182 = llvm.getelementptr %arg1[%1181] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1178, %1182 : i32, !llvm.ptr
%1184 = llvm.load %1103 : !llvm.ptr -> i64
%1185 = llvm.getelementptr %arg2[%1184] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1183 = llvm.load %1185 : !llvm.ptr -> i32
%1186 = llvm.load %1084 : !llvm.ptr -> i64
%1187 = llvm.getelementptr %arg2[%1186] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1183, %1187 : i32, !llvm.ptr
%1188 = llvm.load %1103 : !llvm.ptr -> i64
%1189 = llvm.getelementptr %arg0[%1188] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1164, %1189 : i32, !llvm.ptr
%1190 = llvm.load %1103 : !llvm.ptr -> i64
%1191 = llvm.getelementptr %arg1[%1190] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1167, %1191 : i32, !llvm.ptr
%1192 = llvm.load %1103 : !llvm.ptr -> i64
%1193 = llvm.getelementptr %arg2[%1192] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1170, %1193 : i32, !llvm.ptr
%1194 = llvm.load %1103 : !llvm.ptr -> i64
llvm.store %1194, %1084 : i64, !llvm.ptr
cf.br ^bb171
^bb173:
%1195 = llvm.load %1040 : !llvm.ptr -> i64
%1196 = arith.constant 1 : i32
%1198 = arith.extsi %1196 : i32 to i64
%1197 = arith.subi %1195, %1198 : i64
llvm.store %1197, %1040 : i64, !llvm.ptr
cf.br ^bb168
^bb170:
func.return
}
func.func @main() -> i32 {
%1200 = llvm.mlir.addressof @N : !llvm.ptr
%1201 = llvm.load %1200 : !llvm.ptr -> i64
%1202 = arith.constant 4 : i32
%1204 = arith.extsi %1202 : i32 to i64
%1203 = arith.muli %1201, %1204 : i64
%1199 = func.call @malloc(%1203) : (i64) -> !llvm.ptr
%1206 = llvm.mlir.addressof @N : !llvm.ptr
%1207 = llvm.load %1206 : !llvm.ptr -> i64
%1208 = arith.constant 4 : i32
%1210 = arith.extsi %1208 : i32 to i64
%1209 = arith.muli %1207, %1210 : i64
%1205 = func.call @malloc(%1209) : (i64) -> !llvm.ptr
%1212 = llvm.mlir.addressof @N : !llvm.ptr
%1213 = llvm.load %1212 : !llvm.ptr -> i64
%1214 = arith.constant 4 : i32
%1216 = arith.extsi %1214 : i32 to i64
%1215 = arith.muli %1213, %1216 : i64
%1211 = func.call @malloc(%1215) : (i64) -> !llvm.ptr
%1218 = llvm.mlir.addressof @N : !llvm.ptr
%1219 = llvm.load %1218 : !llvm.ptr -> i64
%1220 = arith.constant 4 : i32
%1222 = arith.extsi %1220 : i32 to i64
%1221 = arith.muli %1219, %1222 : i64
%1217 = func.call @malloc(%1221) : (i64) -> !llvm.ptr
%1224 = llvm.mlir.addressof @N : !llvm.ptr
%1225 = llvm.load %1224 : !llvm.ptr -> i64
%1226 = arith.constant 4 : i32
%1228 = arith.extsi %1226 : i32 to i64
%1227 = arith.muli %1225, %1228 : i64
%1223 = func.call @malloc(%1227) : (i64) -> !llvm.ptr
%1230 = llvm.mlir.addressof @N : !llvm.ptr
%1231 = llvm.load %1230 : !llvm.ptr -> i64
%1232 = arith.constant 4 : i32
%1234 = arith.extsi %1232 : i32 to i64
%1233 = arith.muli %1231, %1234 : i64
%1229 = func.call @malloc(%1233) : (i64) -> !llvm.ptr
%1236 = llvm.mlir.addressof @N : !llvm.ptr
%1237 = llvm.load %1236 : !llvm.ptr -> i64
%1238 = arith.constant 4 : i32
%1240 = arith.extsi %1238 : i32 to i64
%1239 = arith.muli %1237, %1240 : i64
%1235 = func.call @malloc(%1239) : (i64) -> !llvm.ptr
%1241 = llvm.mlir.addressof @temp_x : !llvm.ptr
llvm.store %1235, %1241 : !llvm.ptr, !llvm.ptr
%1243 = llvm.mlir.addressof @N : !llvm.ptr
%1244 = llvm.load %1243 : !llvm.ptr -> i64
%1245 = arith.constant 4 : i32
%1247 = arith.extsi %1245 : i32 to i64
%1246 = arith.muli %1244, %1247 : i64
%1242 = func.call @malloc(%1246) : (i64) -> !llvm.ptr
%1248 = llvm.mlir.addressof @temp_y : !llvm.ptr
llvm.store %1242, %1248 : !llvm.ptr, !llvm.ptr
%1250 = llvm.mlir.addressof @N : !llvm.ptr
%1251 = llvm.load %1250 : !llvm.ptr -> i64
%1252 = arith.constant 4 : i32
%1254 = arith.extsi %1252 : i32 to i64
%1253 = arith.muli %1251, %1254 : i64
%1249 = func.call @malloc(%1253) : (i64) -> !llvm.ptr
%1255 = llvm.mlir.addressof @temp_id : !llvm.ptr
llvm.store %1249, %1255 : !llvm.ptr, !llvm.ptr
%1256 = arith.constant 290797 : i32
%1257 = arith.extsi %1256 : i32 to i64
%1258 = llvm.mlir.constant(1 : i64) : i64
%1259 = llvm.alloca %1258 x i64 : (i64) -> !llvm.ptr
llvm.store %1257, %1259 : i64, !llvm.ptr
%1260 = arith.constant 0 : i32
%1261 = arith.extsi %1260 : i32 to i64
%1262 = llvm.mlir.constant(1 : i64) : i64
%1263 = llvm.alloca %1262 x i64 : (i64) -> !llvm.ptr
llvm.store %1261, %1263 : i64, !llvm.ptr
cf.br ^bb198
^bb198:
%1264 = llvm.load %1263 : !llvm.ptr -> i64
%1265 = llvm.mlir.addressof @N : !llvm.ptr
%1266 = llvm.load %1265 : !llvm.ptr -> i64
%1267 = arith.cmpi slt, %1264, %1266 : i64
cf.cond_br %1267, ^bb199, ^bb200
^bb199:
%1268 = llvm.load %1259 : !llvm.ptr -> i64
%1269 = arith.muli %1268, %1268 : i64
%1270 = llvm.mlir.addressof @M : !llvm.ptr
%1271 = llvm.load %1270 : !llvm.ptr -> i64
%1272 = arith.remsi %1269, %1271 : i64
%1273 = arith.trunci %1268 : i64 to i32
%1274 = llvm.load %1263 : !llvm.ptr -> i64
%1275 = llvm.getelementptr %1199[%1274] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1273, %1275 : i32, !llvm.ptr
%1276 = arith.trunci %1272 : i64 to i32
%1277 = llvm.load %1263 : !llvm.ptr -> i64
%1278 = llvm.getelementptr %1205[%1277] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1276, %1278 : i32, !llvm.ptr
%1279 = arith.muli %1272, %1272 : i64
%1280 = llvm.mlir.addressof @M : !llvm.ptr
%1281 = llvm.load %1280 : !llvm.ptr -> i64
%1282 = arith.remsi %1279, %1281 : i64
llvm.store %1282, %1259 : i64, !llvm.ptr
%1283 = llvm.load %1263 : !llvm.ptr -> i64
%1284 = arith.constant 1 : i32
%1286 = arith.extsi %1284 : i32 to i64
%1285 = arith.addi %1283, %1286 : i64
llvm.store %1285, %1263 : i64, !llvm.ptr
cf.br ^bb198
^bb200:
%1287 = arith.constant 0 : i32
%1288 = arith.extsi %1287 : i32 to i64
llvm.store %1288, %1263 : i64, !llvm.ptr
cf.br ^bb201
^bb201:
%1289 = llvm.load %1263 : !llvm.ptr -> i64
%1290 = llvm.mlir.addressof @N : !llvm.ptr
%1291 = llvm.load %1290 : !llvm.ptr -> i64
%1292 = arith.cmpi slt, %1289, %1291 : i64
cf.cond_br %1292, ^bb202, ^bb203
^bb202:
%1293 = llvm.load %1263 : !llvm.ptr -> i64
%1294 = arith.trunci %1293 : i64 to i32
%1295 = llvm.load %1263 : !llvm.ptr -> i64
%1296 = llvm.getelementptr %1211[%1295] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1294, %1296 : i32, !llvm.ptr
%1297 = llvm.load %1263 : !llvm.ptr -> i64
%1298 = arith.constant 1 : i32
%1300 = arith.extsi %1298 : i32 to i64
%1299 = arith.addi %1297, %1300 : i64
llvm.store %1299, %1263 : i64, !llvm.ptr
cf.br ^bb201
^bb203:
%1302 = llvm.mlir.addressof @N : !llvm.ptr
%1303 = llvm.load %1302 : !llvm.ptr -> i64
func.call @heapsort_x(%1199, %1205, %1211, %1303) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> ()
%1304 = arith.constant 0 : i32
%1305 = arith.extsi %1304 : i32 to i64
llvm.store %1305, %1263 : i64, !llvm.ptr
cf.br ^bb204
^bb204:
%1306 = llvm.load %1263 : !llvm.ptr -> i64
%1307 = llvm.mlir.addressof @N : !llvm.ptr
%1308 = llvm.load %1307 : !llvm.ptr -> i64
%1309 = arith.cmpi slt, %1306, %1308 : i64
cf.cond_br %1309, ^bb205, ^bb206
^bb205:
%1311 = llvm.load %1263 : !llvm.ptr -> i64
%1312 = llvm.getelementptr %1199[%1311] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1310 = llvm.load %1312 : !llvm.ptr -> i32
%1313 = llvm.load %1263 : !llvm.ptr -> i64
%1314 = llvm.getelementptr %1217[%1313] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1310, %1314 : i32, !llvm.ptr
%1316 = llvm.load %1263 : !llvm.ptr -> i64
%1317 = llvm.getelementptr %1205[%1316] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1315 = llvm.load %1317 : !llvm.ptr -> i32
%1318 = llvm.load %1263 : !llvm.ptr -> i64
%1319 = llvm.getelementptr %1223[%1318] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1315, %1319 : i32, !llvm.ptr
%1321 = llvm.load %1263 : !llvm.ptr -> i64
%1322 = llvm.getelementptr %1211[%1321] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1320 = llvm.load %1322 : !llvm.ptr -> i32
%1323 = llvm.load %1263 : !llvm.ptr -> i64
%1324 = llvm.getelementptr %1229[%1323] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1320, %1324 : i32, !llvm.ptr
%1325 = llvm.load %1263 : !llvm.ptr -> i64
%1326 = arith.constant 1 : i32
%1328 = arith.extsi %1326 : i32 to i64
%1327 = arith.addi %1325, %1328 : i64
llvm.store %1327, %1263 : i64, !llvm.ptr
cf.br ^bb204
^bb206:
%1330 = llvm.mlir.addressof @N : !llvm.ptr
%1331 = llvm.load %1330 : !llvm.ptr -> i64
func.call @heapsort_y(%1217, %1223, %1229, %1331) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> ()
%1333 = arith.constant 0 : i32
%1334 = llvm.mlir.addressof @N : !llvm.ptr
%1335 = llvm.load %1334 : !llvm.ptr -> i64
%1336 = arith.constant 1 : i32
%1338 = arith.extsi %1336 : i32 to i64
%1337 = arith.subi %1335, %1338 : i64
%1339 = llvm.mlir.addressof @N : !llvm.ptr
%1340 = llvm.load %1339 : !llvm.ptr -> i64
%1341 = arith.extsi %1333 : i32 to i64
%1332 = func.call @closest_rec(%1199, %1205, %1211, %1341, %1337, %1217, %1223, %1229, %1340) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i64, i64, !llvm.ptr, !llvm.ptr, !llvm.ptr, i64) -> i64
%1342 = arith.sitofp %1332 : i64 to f64
%1343 = math.sqrt %1342 : f64
%1344 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1345 = llvm.call @printf(%1344, %1343) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, f64) -> i32
func.call @free(%1199) : (!llvm.ptr) -> ()
func.call @free(%1205) : (!llvm.ptr) -> ()
func.call @free(%1211) : (!llvm.ptr) -> ()
func.call @free(%1217) : (!llvm.ptr) -> ()
func.call @free(%1223) : (!llvm.ptr) -> ()
func.call @free(%1229) : (!llvm.ptr) -> ()
%1353 = llvm.mlir.addressof @temp_x : !llvm.ptr
%1354 = llvm.load %1353 : !llvm.ptr -> !llvm.ptr
func.call @free(%1354) : (!llvm.ptr) -> ()
%1356 = llvm.mlir.addressof @temp_y : !llvm.ptr
%1357 = llvm.load %1356 : !llvm.ptr -> !llvm.ptr
func.call @free(%1357) : (!llvm.ptr) -> ()
%1359 = llvm.mlir.addressof @temp_id : !llvm.ptr
%1360 = llvm.load %1359 : !llvm.ptr -> !llvm.ptr
func.call @free(%1360) : (!llvm.ptr) -> ()
%1361 = arith.constant 0 : i32
func.return %1361 : i32
}
}