← All problems Problem 928
Count non-empty hands (subsets of 52-card deck) where hand_score == cribbage_score. Meet-in-the-middle: left ranks 1..7, right ranks 8..13. Pure Flow port of the native C solver.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^7)O(n * sum)Space complexity O(1)O(sum)Approach Flow solution Subset sum DP Verdict Unknown
Flow source
# Project Euler 928: Cribbage
# Count non-empty hands (subsets of 52-card deck) where
# hand_score == cribbage_score.
# Meet-in-the-middle: left ranks 1..7, right ranks 8..13.
# Pure Flow port of the native C solver.
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 memset(dst: ptr<void>, val: i32, n: i64) -> void
function printf(fmt: ptr<i8>, ...) -> i32
}
struct LeftEntry {
L5: i32
L6: i32
L7: i32
L15: i32
tail_len: i32
tail_prod: i32
A_L: i32
weight: i64
}
struct RightEntry {
c8: i32
c9: i32
n10: i32
head_len: i32
head_prod: i32
A_R: i32
weight: i64
}
struct RightGroup {
c8: i32
c9: i32
n10: i32
head_len: i32
head_prod: i32
start: i32
end: i32
}
struct RightSuperGroup {
c8: i32
c9: i32
n10: i32
start: i32
end: i32
}
let mut COMB4: ptr<i32> = null as ptr<i32>
let mut CHOOSE: ptr<i32> = null as ptr<i32>
let mut g_nd: ptr<i64> = null as ptr<i64>
let mut left_entries: ptr<LeftEntry> = null as ptr<LeftEntry>
let mut n_left: i32 = 0
let mut right_entries: ptr<RightEntry> = null as ptr<RightEntry>
let mut n_right: i32 = 0
function init_choose() -> void {
let mut n: i32 = 0
while n < 5 {
CHOOSE[n * 5 + 0] = 1
let mut k: i32 = 1
while k <= n {
let mut val: i32 = CHOOSE[(n - 1) * 5 + k - 1]
if k <= n - 1 {
val = val + CHOOSE[(n - 1) * 5 + k]
}
CHOOSE[n * 5 + k] = val
k = k + 1
}
n = n + 1
}
}
function dp_update(dp: ptr<i64>, v: i32, c: i32) -> void {
if c == 0 { return }
memset(g_nd as ptr<void>, 0, 128)
let mut s: i32 = 0
while s < 16 {
let mut tot: i64 = 0
let mut maxk: i32 = c
if v > 0 {
if s / v < maxk { maxk = s / v }
}
let mut k: i32 = 0
while k <= maxk {
tot = tot + dp[s - k * v] * (CHOOSE[c * 5 + k] as i64)
k = k + 1
}
g_nd[s] = tot
s = s + 1
}
memcpy(dp as ptr<void>, g_nd as ptr<void>, 128)
}
function run_boundary(tl: i32, tp: i32, hl: i32, hp: i32) -> i32 {
let mut L: i32 = 0
let mut P: i32 = 0
if tl > 0 && hl > 0 {
L = tl + hl
P = tp * hp
} else {
if tl > 0 {
L = tl
P = tp
} else {
if hl > 0 {
L = hl
P = hp
} else {
return 0
}
}
}
if L >= 3 { return L * P }
return 0
}
function cmp_left_at(entries: ptr<LeftEntry>, i: i32, j: i32) -> i32 {
if entries[i].L5 != entries[j].L5 { return entries[i].L5 - entries[j].L5 }
if entries[i].L6 != entries[j].L6 { return entries[i].L6 - entries[j].L6 }
if entries[i].L7 != entries[j].L7 { return entries[i].L7 - entries[j].L7 }
if entries[i].L15 != entries[j].L15 { return entries[i].L15 - entries[j].L15 }
if entries[i].tail_len != entries[j].tail_len { return entries[i].tail_len - entries[j].tail_len }
if entries[i].tail_prod != entries[j].tail_prod { return entries[i].tail_prod - entries[j].tail_prod }
return entries[i].A_L - entries[j].A_L
}
function swap_left(entries: ptr<LeftEntry>, i: i32, j: i32) -> void {
let t: i32 = entries[i].L5
entries[i].L5 = entries[j].L5
entries[j].L5 = t
t = entries[i].L6
entries[i].L6 = entries[j].L6
entries[j].L6 = t
t = entries[i].L7
entries[i].L7 = entries[j].L7
entries[j].L7 = t
t = entries[i].L15
entries[i].L15 = entries[j].L15
entries[j].L15 = t
t = entries[i].tail_len
entries[i].tail_len = entries[j].tail_len
entries[j].tail_len = t
t = entries[i].tail_prod
entries[i].tail_prod = entries[j].tail_prod
entries[j].tail_prod = t
t = entries[i].A_L
entries[i].A_L = entries[j].A_L
entries[j].A_L = t
let tw: i64 = entries[i].weight
entries[i].weight = entries[j].weight
entries[j].weight = tw
}
function sift_down_left(entries: ptr<LeftEntry>, root: i32, size: i32) -> void {
let mut r: i32 = root
while true {
let mut largest: i32 = r
let left: i32 = 2 * r + 1
let right: i32 = 2 * r + 2
if left < size {
if cmp_left_at(entries, left, largest) > 0 {
largest = left
}
}
if right < size {
if cmp_left_at(entries, right, largest) > 0 {
largest = right
}
}
if largest == r { break }
swap_left(entries, r, largest)
r = largest
}
}
function heapsort_left(entries: ptr<LeftEntry>, n: i32) -> void {
if n <= 1 { return }
let mut i: i32 = n / 2 - 1
while i >= 0 {
sift_down_left(entries, i, n)
i = i - 1
}
i = n - 1
while i > 0 {
swap_left(entries, 0, i)
sift_down_left(entries, 0, i)
i = i - 1
}
}
function cmp_right_at(entries: ptr<RightEntry>, i: i32, j: i32) -> i32 {
if entries[i].c8 != entries[j].c8 { return entries[i].c8 - entries[j].c8 }
if entries[i].c9 != entries[j].c9 { return entries[i].c9 - entries[j].c9 }
if entries[i].n10 != entries[j].n10 { return entries[i].n10 - entries[j].n10 }
if entries[i].head_len != entries[j].head_len { return entries[i].head_len - entries[j].head_len }
if entries[i].head_prod != entries[j].head_prod { return entries[i].head_prod - entries[j].head_prod }
return entries[i].A_R - entries[j].A_R
}
function swap_right(entries: ptr<RightEntry>, i: i32, j: i32) -> void {
let t: i32 = entries[i].c8
entries[i].c8 = entries[j].c8
entries[j].c8 = t
t = entries[i].c9
entries[i].c9 = entries[j].c9
entries[j].c9 = t
t = entries[i].n10
entries[i].n10 = entries[j].n10
entries[j].n10 = t
t = entries[i].head_len
entries[i].head_len = entries[j].head_len
entries[j].head_len = t
t = entries[i].head_prod
entries[i].head_prod = entries[j].head_prod
entries[j].head_prod = t
t = entries[i].A_R
entries[i].A_R = entries[j].A_R
entries[j].A_R = t
let tw: i64 = entries[i].weight
entries[i].weight = entries[j].weight
entries[j].weight = tw
}
function sift_down_right(entries: ptr<RightEntry>, root: i32, size: i32) -> void {
let mut r: i32 = root
while true {
let mut largest: i32 = r
let left: i32 = 2 * r + 1
let right: i32 = 2 * r + 2
if left < size {
if cmp_right_at(entries, left, largest) > 0 {
largest = left
}
}
if right < size {
if cmp_right_at(entries, right, largest) > 0 {
largest = right
}
}
if largest == r { break }
swap_right(entries, r, largest)
r = largest
}
}
function heapsort_right(entries: ptr<RightEntry>, n: i32) -> void {
if n <= 1 { return }
let mut i: i32 = n / 2 - 1
while i >= 0 {
sift_down_right(entries, i, n)
i = i - 1
}
i = n - 1
while i > 0 {
swap_right(entries, 0, i)
sift_down_right(entries, 0, i)
i = i - 1
}
}
function enumerate_left() -> void {
let c1: i32 = 0
while c1 < 5 {
let c2: i32 = 0
while c2 < 5 {
let c3: i32 = 0
while c3 < 5 {
let c4: i32 = 0
while c4 < 5 {
let c5: i32 = 0
while c5 < 5 {
let c6: i32 = 0
while c6 < 5 {
let c7: i32 = 0
while c7 < 5 {
let w: i64 = (COMB4[c1] as i64) * (COMB4[c2] as i64) * (COMB4[c3] as i64) * (COMB4[c4] as i64) * (COMB4[c5] as i64) * (COMB4[c6] as i64) * (COMB4[c7] as i64)
if w == 0 {
c7 = c7 + 1
continue
}
let counts: array<i32, 7> = [c1, c2, c3, c4, c5, c6, c7]
let hv: i32 = 1*c1 + 2*c2 + 3*c3 + 4*c4 + 5*c5 + 6*c6 + 7*c7
let pairs: i32 = c1*(c1-1) + c2*(c2-1) + c3*(c3-1) + c4*(c4-1) + c5*(c5-1) + c6*(c6-1) + c7*(c7-1)
let dp: array<i64, 16> = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
dp[0] = 1
dp_update((dp as ptr<i64>), 1, c1)
dp_update((dp as ptr<i64>), 2, c2)
dp_update((dp as ptr<i64>), 3, c3)
dp_update((dp as ptr<i64>), 4, c4)
dp_update((dp as ptr<i64>), 5, c5)
dp_update((dp as ptr<i64>), 6, c6)
dp_update((dp as ptr<i64>), 7, c7)
let L5: i32 = dp[5] as i32
let L6: i32 = dp[6] as i32
let L7: i32 = dp[7] as i32
let L15: i32 = dp[15] as i32
if L15 > 170 {
c7 = c7 + 1
continue
}
# run_internal: exclude trailing segment reaching rank 7
let mut run_internal: i32 = 0
let mut cur_len: i32 = 0
let mut cur_prod: i32 = 1
let mut ii: i32 = 0
while ii < 7 {
if counts[ii] == 0 {
if cur_len >= 3 { run_internal = run_internal + cur_len * cur_prod }
cur_len = 0
cur_prod = 1
} else {
cur_len = cur_len + 1
cur_prod = cur_prod * counts[ii]
}
ii = ii + 1
}
let tail_len: i32 = cur_len
let tail_prod: i32 = 1
if cur_len > 0 { tail_prod = cur_prod }
let A_L: i32 = hv - pairs - run_internal
left_entries[n_left].L5 = L5
left_entries[n_left].L6 = L6
left_entries[n_left].L7 = L7
left_entries[n_left].L15 = L15
left_entries[n_left].tail_len = tail_len
left_entries[n_left].tail_prod = tail_prod
left_entries[n_left].A_L = A_L
left_entries[n_left].weight = w
n_left = n_left + 1
c7 = c7 + 1
}
c6 = c6 + 1
}
c5 = c5 + 1
}
c4 = c4 + 1
}
c3 = c3 + 1
}
c2 = c2 + 1
}
c1 = c1 + 1
}
}
function enumerate_right() -> void {
let c8: i32 = 0
while c8 < 5 {
let c9: i32 = 0
while c9 < 5 {
let c10: i32 = 0
while c10 < 5 {
let c11: i32 = 0
while c11 < 5 {
let c12: i32 = 0
while c12 < 5 {
let c13: i32 = 0
while c13 < 5 {
let w: i64 = (COMB4[c8] as i64) * (COMB4[c9] as i64) * (COMB4[c10] as i64) * (COMB4[c11] as i64) * (COMB4[c12] as i64) * (COMB4[c13] as i64)
if w == 0 {
c13 = c13 + 1
continue
}
let n10: i32 = c10 + c11 + c12 + c13
let hv: i32 = 8*c8 + 9*c9 + 10*n10
let pairs: i32 = c8*(c8-1) + c9*(c9-1) + c10*(c10-1) + c11*(c11-1) + c12*(c12-1) + c13*(c13-1)
let counts: array<i32, 6> = [c8, c9, c10, c11, c12, c13]
# head segment starting at rank 8
let mut head_len: i32 = 0
let mut head_prod: i32 = 1
let mut ii: i32 = 0
while ii < 6 {
if counts[ii] == 0 { break }
head_len = head_len + 1
head_prod = head_prod * counts[ii]
ii = ii + 1
}
if head_len == 0 {
head_len = 0
head_prod = 1
}
# run_internal: all segments length>=3 EXCEPT the one starting at rank 8
let mut run_internal: i32 = 0
let mut cur_len: i32 = 0
let mut cur_prod: i32 = 1
let mut seg_start: i32 = -1
ii = 0
while ii < 6 {
if counts[ii] == 0 {
if cur_len >= 3 && seg_start != 0 {
run_internal = run_internal + cur_len * cur_prod
}
cur_len = 0
cur_prod = 1
seg_start = -1
} else {
if cur_len == 0 { seg_start = ii }
cur_len = cur_len + 1
cur_prod = cur_prod * counts[ii]
}
ii = ii + 1
}
if cur_len >= 3 && seg_start != 0 {
run_internal = run_internal + cur_len * cur_prod
}
let A_R: i32 = hv - pairs - run_internal
right_entries[n_right].c8 = c8
right_entries[n_right].c9 = c9
right_entries[n_right].n10 = n10
right_entries[n_right].head_len = head_len
right_entries[n_right].head_prod = head_prod
right_entries[n_right].A_R = A_R
right_entries[n_right].weight = w
n_right = n_right + 1
c13 = c13 + 1
}
c12 = c12 + 1
}
c11 = c11 + 1
}
c10 = c10 + 1
}
c9 = c9 + 1
}
c8 = c8 + 1
}
}
function binary_search_right(lo0: i32, hi0: i32, target_A_R: i32) -> i64 {
let mut lo: i32 = lo0
let mut hi: i32 = hi0
let orig_hi: i32 = hi0
while lo < hi {
let mid: i32 = lo + (hi - lo) / 2
if right_entries[mid].A_R < target_A_R {
lo = mid + 1
} else {
hi = mid
}
}
if lo < orig_hi && right_entries[lo].A_R == target_A_R {
return right_entries[lo].weight
}
return 0
}
function main() -> i32 {
COMB4 = (malloc(20)) as ptr<i32>
COMB4[0] = 1
COMB4[1] = 4
COMB4[2] = 6
COMB4[3] = 4
COMB4[4] = 1
CHOOSE = (calloc(25, 4)) as ptr<i32>
g_nd = (calloc(16, 8)) as ptr<i64>
init_choose()
left_entries = (calloc(78125, 40)) as ptr<LeftEntry>
n_left = 0
right_entries = (calloc(15625, 48)) as ptr<RightEntry>
n_right = 0
enumerate_left()
enumerate_right()
# Sort both arrays
heapsort_left(left_entries, n_left)
heapsort_right(right_entries, n_right)
# Merge left entries with same key and A_L
let left_group_start: ptr<i32> = (malloc(78125 * 4)) as ptr<i32>
let left_group_end: ptr<i32> = (malloc(78125 * 4)) as ptr<i32>
let mut n_left_groups: i32 = 0
let mut i: i32 = 0
while i < n_left {
let mut j: i32 = i
while j < n_left && cmp_left_at(left_entries, i, j) == 0 {
j = j + 1
}
# Merge weights for same (key, A_L)
let mut total_w: i64 = 0
let mut k: i32 = i
while k < j {
total_w = total_w + left_entries[k].weight
k = k + 1
}
left_entries[i].weight = total_w
left_group_start[n_left_groups] = i
left_group_end[n_left_groups] = j
n_left_groups = n_left_groups + 1
i = j
}
# Build right group index
let right_groups: ptr<RightGroup> = (calloc(15625, 28)) as ptr<RightGroup>
let mut n_right_groups: i32 = 0
i = 0
while i < n_right {
let mut j: i32 = i
while j < n_right &&
right_entries[j].c8 == right_entries[i].c8 &&
right_entries[j].c9 == right_entries[i].c9 &&
right_entries[j].n10 == right_entries[i].n10 &&
right_entries[j].head_len == right_entries[i].head_len &&
right_entries[j].head_prod == right_entries[i].head_prod {
j = j + 1
}
# Merge weights for same A_R within this group
let mut k2: i32 = i
while k2 < j {
let mut l: i32 = k2
while l < j && right_entries[l].A_R == right_entries[k2].A_R {
l = l + 1
}
let mut total_w2: i64 = 0
let mut m: i32 = k2
while m < l {
total_w2 = total_w2 + right_entries[m].weight
m = m + 1
}
right_entries[k2].weight = total_w2
k2 = l
}
right_groups[n_right_groups].c8 = right_entries[i].c8
right_groups[n_right_groups].c9 = right_entries[i].c9
right_groups[n_right_groups].n10 = right_entries[i].n10
right_groups[n_right_groups].head_len = right_entries[i].head_len
right_groups[n_right_groups].head_prod = right_entries[i].head_prod
right_groups[n_right_groups].start = i
right_groups[n_right_groups].end = j
n_right_groups = n_right_groups + 1
i = j
}
# Build right (c8, c9, n10) super-group index
let right_super: ptr<RightSuperGroup> = (calloc(500, 24)) as ptr<RightSuperGroup>
let mut n_right_super: i32 = 0
i = 0
while i < n_right_groups {
let mut j: i32 = i
while j < n_right_groups &&
right_groups[j].c8 == right_groups[i].c8 &&
right_groups[j].c9 == right_groups[i].c9 &&
right_groups[j].n10 == right_groups[i].n10 {
j = j + 1
}
right_super[n_right_super].c8 = right_groups[i].c8
right_super[n_right_super].c9 = right_groups[i].c9
right_super[n_right_super].n10 = right_groups[i].n10
right_super[n_right_super].start = i
right_super[n_right_super].end = j
n_right_super = n_right_super + 1
i = j
}
# Combination step
let mut total: i64 = 0
let mut lg: i32 = 0
while lg < n_left_groups {
let le: ptr<LeftEntry> = (left_entries + left_group_start[lg])
let L5: i32 = le.L5
let L6: i32 = le.L6
let L7: i32 = le.L7
let L15: i32 = le.L15
let tl: i32 = le.tail_len
let tp: i32 = le.tail_prod
let A_L: i32 = le.A_L
let wL: i64 = le.weight
let mut rs: i32 = 0
while rs < n_right_super {
let c8: i32 = right_super[rs].c8
let c9: i32 = right_super[rs].c9
let n10: i32 = right_super[rs].n10
let dp15: i32 = L15 + L7 * c8 + L6 * c9 + L5 * n10
if dp15 > 170 {
rs = rs + 1
continue
}
let base: i32 = 2 * dp15
let mut rg: i32 = right_super[rs].start
while rg < right_super[rs].end {
let hl: i32 = right_groups[rg].head_len
let hp: i32 = right_groups[rg].head_prod
let req: i32 = base + run_boundary(tl, tp, hl, hp)
let want: i32 = req - A_L
let wR: i64 = binary_search_right(right_groups[rg].start, right_groups[rg].end, want)
if wR != 0 { total = total + wL * wR }
rg = rg + 1
}
rs = rs + 1
}
lg = lg + 1
}
# Exclude empty hand
total = total - 1
printf("%lld\n", total)
return 0
}
Generated C
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Flow runtime helpers */
typedef struct flow_temp_node { struct flow_temp_node* next; } flow_temp_node;
static flow_temp_node* flow_temp_head = NULL;
static int flow_temp_atexit_set = 0;
__attribute__((unused)) static void flow_temp_free_all(void) {
while (flow_temp_head) {
flow_temp_node* n = flow_temp_head;
flow_temp_head = n->next;
free(n);
}
}
__attribute__((unused)) static void* flow_temp_alloc(size_t nbytes) {
flow_temp_node* node = (flow_temp_node*)malloc(sizeof(flow_temp_node) + nbytes);
if (!node) return NULL;
node->next = flow_temp_head;
flow_temp_head = node;
if (!flow_temp_atexit_set) {
flow_temp_atexit_set = 1;
atexit(flow_temp_free_all);
}
return (void*)(node + 1);
}
#ifndef FLOW_DIAG
#define FLOW_DIAG(msg) fprintf(stderr, "%s", (msg))
#endif
#ifndef FLOW_LOG
#define FLOW_LOG(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
#ifndef FLOW_LOG_EMPTY
#define FLOW_LOG_EMPTY(fmt) printf(fmt)
#endif
static char* flow_strcat(const char* a, const char* b) {
size_t la = strlen(a ? a : ""), lb = strlen(b ? b : "");
char* r = (char*)flow_temp_alloc(la + lb + 1);
if (!r) return NULL;
if (la) memcpy(r, a, la);
if (lb) memcpy(r + la, b, lb);
r[la + lb] = '\0';
return r;
}
#define __flow_in_arr(arr, val) __extension__ ({ \
int _found = 0; \
size_t _n = sizeof(arr)/sizeof((arr)[0]); \
for (size_t _i = 0; _i < _n; _i++) { \
if ((arr)[_i] == (val)) { _found = 1; break; } \
} _found; })
/* Unified fault handler (MISRA #279) — override with -DFLOW_FAULT_HANDLER=fn */
#ifndef FLOW_FAULT_HANDLER
__attribute__((unused)) static inline void flow_fault_handler(const char* msg) {
fprintf(stderr, "flow: %s\n", msg ? msg : "fault");
abort();
#if defined(__GNUC__) || defined(__clang__)
__builtin_unreachable();
#endif
}
#else
#define flow_fault_handler FLOW_FAULT_HANDLER
#endif
#define flow_div_by_zero_handler() flow_fault_handler("division by zero")
#define flow_shift_ub_handler() flow_fault_handler("invalid shift (amount out of range or left-shift of negative)")
#ifndef FLOW_CHECKED_DIV
#define FLOW_CHECKED_DIV(L, R) (((R) != 0) ? ((L) / (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_MOD
#define FLOW_CHECKED_MOD(L, R) (((R) != 0) ? ((L) % (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHL
#define FLOW_CHECKED_SHL(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull)) && ((L) >= 0)) ? ((L) << (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHR
#define FLOW_CHECKED_SHR(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull))) ? ((L) >> (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#include <math.h>
void* _ui_state = NULL;
static inline float i32_to_f32(int32_t v) { return (float)v; }
/* Host stub for @gpu kernels (device codegen replaces this). */
static inline int32_t gpu_thread_id(void) { return 0; }
typedef struct LeftEntry LeftEntry;
typedef struct RightEntry RightEntry;
typedef struct RightGroup RightGroup;
typedef struct RightSuperGroup RightSuperGroup;
struct LeftEntry {
int32_t L5;
int32_t L6;
int32_t L7;
int32_t L15;
int32_t tail_len;
int32_t tail_prod;
int32_t A_L;
int64_t weight;
};
struct RightEntry {
int32_t c8;
int32_t c9;
int32_t n10;
int32_t head_len;
int32_t head_prod;
int32_t A_R;
int64_t weight;
};
struct RightGroup {
int32_t c8;
int32_t c9;
int32_t n10;
int32_t head_len;
int32_t head_prod;
int32_t start;
int32_t end;
};
struct RightSuperGroup {
int32_t c8;
int32_t c9;
int32_t n10;
int32_t start;
int32_t end;
};
void init_choose(void);
void dp_update_ptr_i64_i32_i32(int64_t* dp, int32_t v, int32_t c);
int32_t run_boundary_i32_i32_i32_i32(int32_t tl, int32_t tp, int32_t hl, int32_t hp);
int32_t cmp_left_at_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t i, int32_t j);
void swap_left_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t i, int32_t j);
void sift_down_left_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t root, int32_t size);
void heapsort_left_ptr_LeftEntry_i32(LeftEntry* entries, int32_t n);
int32_t cmp_right_at_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t i, int32_t j);
void swap_right_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t i, int32_t j);
void sift_down_right_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t root, int32_t size);
void heapsort_right_ptr_RightEntry_i32(RightEntry* entries, int32_t n);
void enumerate_left(void);
void enumerate_right(void);
int64_t binary_search_right_i32_i32_i32(int32_t lo0, int32_t hi0, int32_t target_A_R);
int32_t main(void);
/* Module statics */
static int32_t* COMB4 = ((int32_t*)(NULL));
static int32_t* CHOOSE = ((int32_t*)(NULL));
static int64_t* g_nd = ((int64_t*)(NULL));
static LeftEntry* left_entries = ((LeftEntry*)(NULL));
static int32_t n_left = 0;
static RightEntry* right_entries = ((RightEntry*)(NULL));
static int32_t n_right = 0;
void init_choose(void) {
int32_t n = 0;
while (n < 5) {
CHOOSE[((n * 5) + 0)] = 1;
int32_t k = 1;
while (k <= n) {
int32_t val = CHOOSE[((((n - 1) * 5) + k) - 1)];
if (k <= (n - 1)) {
val = (val + CHOOSE[(((n - 1) * 5) + k)]);
}
CHOOSE[((n * 5) + k)] = val;
k = (k + 1);
}
n = (n + 1);
}
}
void dp_update_ptr_i64_i32_i32(int64_t* dp, int32_t v, int32_t c) {
if (c == 0) {
return;
}
memset(((void*)(g_nd)), 0, 128);
int32_t s = 0;
while (s < 16) {
int64_t tot = 0;
int32_t maxk = c;
if (v > 0) {
if (FLOW_CHECKED_DIV((s), (v)) < maxk) {
maxk = FLOW_CHECKED_DIV((s), (v));
}
}
int32_t k = 0;
while (k <= maxk) {
tot = (tot + (dp[(s - (k * v))] * ((int64_t)(CHOOSE[((c * 5) + k)]))));
k = (k + 1);
}
g_nd[s] = tot;
s = (s + 1);
}
memcpy(((void*)(dp)), ((void*)(g_nd)), 128);
}
int32_t run_boundary_i32_i32_i32_i32(int32_t tl, int32_t tp, int32_t hl, int32_t hp) {
int32_t L = 0;
int32_t P = 0;
if ((tl > 0 && hl > 0)) {
L = (tl + hl);
P = (tp * hp);
} else {
if (tl > 0) {
L = tl;
P = tp;
} else {
if (hl > 0) {
L = hl;
P = hp;
} else {
return 0;
}
}
}
if (L >= 3) {
return (L * P);
}
return 0;
}
int32_t cmp_left_at_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t i, int32_t j) {
if (entries[i].L5 != entries[j].L5) {
return (entries[i].L5 - entries[j].L5);
}
if (entries[i].L6 != entries[j].L6) {
return (entries[i].L6 - entries[j].L6);
}
if (entries[i].L7 != entries[j].L7) {
return (entries[i].L7 - entries[j].L7);
}
if (entries[i].L15 != entries[j].L15) {
return (entries[i].L15 - entries[j].L15);
}
if (entries[i].tail_len != entries[j].tail_len) {
return (entries[i].tail_len - entries[j].tail_len);
}
if (entries[i].tail_prod != entries[j].tail_prod) {
return (entries[i].tail_prod - entries[j].tail_prod);
}
return (entries[i].A_L - entries[j].A_L);
}
void swap_left_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t i, int32_t j) {
int32_t t = entries[i].L5;
entries[i].L5 = entries[j].L5;
entries[j].L5 = t;
t = entries[i].L6;
entries[i].L6 = entries[j].L6;
entries[j].L6 = t;
t = entries[i].L7;
entries[i].L7 = entries[j].L7;
entries[j].L7 = t;
t = entries[i].L15;
entries[i].L15 = entries[j].L15;
entries[j].L15 = t;
t = entries[i].tail_len;
entries[i].tail_len = entries[j].tail_len;
entries[j].tail_len = t;
t = entries[i].tail_prod;
entries[i].tail_prod = entries[j].tail_prod;
entries[j].tail_prod = t;
t = entries[i].A_L;
entries[i].A_L = entries[j].A_L;
entries[j].A_L = t;
int64_t tw = entries[i].weight;
entries[i].weight = entries[j].weight;
entries[j].weight = tw;
}
void sift_down_left_ptr_LeftEntry_i32_i32(LeftEntry* entries, int32_t root, int32_t size) {
int32_t r = root;
while (1) {
int32_t largest = r;
int32_t left = ((2 * r) + 1);
int32_t right = ((2 * r) + 2);
if (left < size) {
if (cmp_left_at_ptr_LeftEntry_i32_i32(entries, left, largest) > 0) {
largest = left;
}
}
if (right < size) {
if (cmp_left_at_ptr_LeftEntry_i32_i32(entries, right, largest) > 0) {
largest = right;
}
}
if (largest == r) {
break;
}
swap_left_ptr_LeftEntry_i32_i32(entries, r, largest);
r = largest;
}
}
void heapsort_left_ptr_LeftEntry_i32(LeftEntry* entries, int32_t n) {
if (n <= 1) {
return;
}
int32_t i = (FLOW_CHECKED_DIV((n), (2)) - 1);
while (i >= 0) {
sift_down_left_ptr_LeftEntry_i32_i32(entries, i, n);
i = (i - 1);
}
i = (n - 1);
while (i > 0) {
swap_left_ptr_LeftEntry_i32_i32(entries, 0, i);
sift_down_left_ptr_LeftEntry_i32_i32(entries, 0, i);
i = (i - 1);
}
}
int32_t cmp_right_at_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t i, int32_t j) {
if (entries[i].c8 != entries[j].c8) {
return (entries[i].c8 - entries[j].c8);
}
if (entries[i].c9 != entries[j].c9) {
return (entries[i].c9 - entries[j].c9);
}
if (entries[i].n10 != entries[j].n10) {
return (entries[i].n10 - entries[j].n10);
}
if (entries[i].head_len != entries[j].head_len) {
return (entries[i].head_len - entries[j].head_len);
}
if (entries[i].head_prod != entries[j].head_prod) {
return (entries[i].head_prod - entries[j].head_prod);
}
return (entries[i].A_R - entries[j].A_R);
}
void swap_right_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t i, int32_t j) {
int32_t t = entries[i].c8;
entries[i].c8 = entries[j].c8;
entries[j].c8 = t;
t = entries[i].c9;
entries[i].c9 = entries[j].c9;
entries[j].c9 = t;
t = entries[i].n10;
entries[i].n10 = entries[j].n10;
entries[j].n10 = t;
t = entries[i].head_len;
entries[i].head_len = entries[j].head_len;
entries[j].head_len = t;
t = entries[i].head_prod;
entries[i].head_prod = entries[j].head_prod;
entries[j].head_prod = t;
t = entries[i].A_R;
entries[i].A_R = entries[j].A_R;
entries[j].A_R = t;
int64_t tw = entries[i].weight;
entries[i].weight = entries[j].weight;
entries[j].weight = tw;
}
void sift_down_right_ptr_RightEntry_i32_i32(RightEntry* entries, int32_t root, int32_t size) {
int32_t r = root;
while (1) {
int32_t largest = r;
int32_t left = ((2 * r) + 1);
int32_t right = ((2 * r) + 2);
if (left < size) {
if (cmp_right_at_ptr_RightEntry_i32_i32(entries, left, largest) > 0) {
largest = left;
}
}
if (right < size) {
if (cmp_right_at_ptr_RightEntry_i32_i32(entries, right, largest) > 0) {
largest = right;
}
}
if (largest == r) {
break;
}
swap_right_ptr_RightEntry_i32_i32(entries, r, largest);
r = largest;
}
}
void heapsort_right_ptr_RightEntry_i32(RightEntry* entries, int32_t n) {
if (n <= 1) {
return;
}
int32_t i = (FLOW_CHECKED_DIV((n), (2)) - 1);
while (i >= 0) {
sift_down_right_ptr_RightEntry_i32_i32(entries, i, n);
i = (i - 1);
}
i = (n - 1);
while (i > 0) {
swap_right_ptr_RightEntry_i32_i32(entries, 0, i);
sift_down_right_ptr_RightEntry_i32_i32(entries, 0, i);
i = (i - 1);
}
}
void enumerate_left(void) {
int32_t c1 = 0;
while (c1 < 5) {
int32_t c2 = 0;
while (c2 < 5) {
int32_t c3 = 0;
while (c3 < 5) {
int32_t c4 = 0;
while (c4 < 5) {
int32_t c5 = 0;
while (c5 < 5) {
int32_t c6 = 0;
while (c6 < 5) {
int32_t c7 = 0;
while (c7 < 5) {
int64_t w = ((((((((int64_t)(COMB4[c1])) * ((int64_t)(COMB4[c2]))) * ((int64_t)(COMB4[c3]))) * ((int64_t)(COMB4[c4]))) * ((int64_t)(COMB4[c5]))) * ((int64_t)(COMB4[c6]))) * ((int64_t)(COMB4[c7])));
if (w == 0) {
c7 = (c7 + 1);
continue;
}
int32_t counts[7] = { c1, c2, c3, c4, c5, c6, c7 };
int32_t hv = (((((((1 * c1) + (2 * c2)) + (3 * c3)) + (4 * c4)) + (5 * c5)) + (6 * c6)) + (7 * c7));
int32_t pairs = (((((((c1 * (c1 - 1)) + (c2 * (c2 - 1))) + (c3 * (c3 - 1))) + (c4 * (c4 - 1))) + (c5 * (c5 - 1))) + (c6 * (c6 - 1))) + (c7 * (c7 - 1)));
int64_t dp[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
dp[0] = 1;
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 1, c1);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 2, c2);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 3, c3);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 4, c4);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 5, c5);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 6, c6);
dp_update_ptr_i64_i32_i32(((int64_t*)(dp)), 7, c7);
int32_t L5 = ((int32_t)((((unsigned)(5) < 16) ? dp[5] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(5), 16), flow_fault_handler("array index out of bounds"), dp[0]))));
int32_t L6 = ((int32_t)((((unsigned)(6) < 16) ? dp[6] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(6), 16), flow_fault_handler("array index out of bounds"), dp[0]))));
int32_t L7 = ((int32_t)((((unsigned)(7) < 16) ? dp[7] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(7), 16), flow_fault_handler("array index out of bounds"), dp[0]))));
int32_t L15 = ((int32_t)((((unsigned)(15) < 16) ? dp[15] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(15), 16), flow_fault_handler("array index out of bounds"), dp[0]))));
if (L15 > 170) {
c7 = (c7 + 1);
continue;
}
int32_t run_internal = 0;
int32_t cur_len = 0;
int32_t cur_prod = 1;
int32_t ii = 0;
while (ii < 7) {
if ((((unsigned)(ii) < 7) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 7), flow_fault_handler("array index out of bounds"), counts[0])) == 0) {
if (cur_len >= 3) {
run_internal = (run_internal + (cur_len * cur_prod));
}
cur_len = 0;
cur_prod = 1;
} else {
cur_len = (cur_len + 1);
cur_prod = (cur_prod * (((unsigned)(ii) < 7) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 7), flow_fault_handler("array index out of bounds"), counts[0])));
}
ii = (ii + 1);
}
int32_t tail_len = cur_len;
int32_t tail_prod = 1;
if (cur_len > 0) {
tail_prod = cur_prod;
}
int32_t A_L = ((hv - pairs) - run_internal);
left_entries[n_left].L5 = L5;
left_entries[n_left].L6 = L6;
left_entries[n_left].L7 = L7;
left_entries[n_left].L15 = L15;
left_entries[n_left].tail_len = tail_len;
left_entries[n_left].tail_prod = tail_prod;
left_entries[n_left].A_L = A_L;
left_entries[n_left].weight = w;
n_left = (n_left + 1);
c7 = (c7 + 1);
}
c6 = (c6 + 1);
}
c5 = (c5 + 1);
}
c4 = (c4 + 1);
}
c3 = (c3 + 1);
}
c2 = (c2 + 1);
}
c1 = (c1 + 1);
}
}
void enumerate_right(void) {
int32_t c8 = 0;
while (c8 < 5) {
int32_t c9 = 0;
while (c9 < 5) {
int32_t c10 = 0;
while (c10 < 5) {
int32_t c11 = 0;
while (c11 < 5) {
int32_t c12 = 0;
while (c12 < 5) {
int32_t c13 = 0;
while (c13 < 5) {
int64_t w = (((((((int64_t)(COMB4[c8])) * ((int64_t)(COMB4[c9]))) * ((int64_t)(COMB4[c10]))) * ((int64_t)(COMB4[c11]))) * ((int64_t)(COMB4[c12]))) * ((int64_t)(COMB4[c13])));
if (w == 0) {
c13 = (c13 + 1);
continue;
}
int32_t n10 = (((c10 + c11) + c12) + c13);
int32_t hv = (((8 * c8) + (9 * c9)) + (10 * n10));
int32_t pairs = ((((((c8 * (c8 - 1)) + (c9 * (c9 - 1))) + (c10 * (c10 - 1))) + (c11 * (c11 - 1))) + (c12 * (c12 - 1))) + (c13 * (c13 - 1)));
int32_t counts[6] = { c8, c9, c10, c11, c12, c13 };
int32_t head_len = 0;
int32_t head_prod = 1;
int32_t ii = 0;
while (ii < 6) {
if ((((unsigned)(ii) < 6) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 6), flow_fault_handler("array index out of bounds"), counts[0])) == 0) {
break;
}
head_len = (head_len + 1);
head_prod = (head_prod * (((unsigned)(ii) < 6) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 6), flow_fault_handler("array index out of bounds"), counts[0])));
ii = (ii + 1);
}
if (head_len == 0) {
head_len = 0;
head_prod = 1;
}
int32_t run_internal = 0;
int32_t cur_len = 0;
int32_t cur_prod = 1;
int32_t seg_start = (-1);
ii = 0;
while (ii < 6) {
if ((((unsigned)(ii) < 6) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 6), flow_fault_handler("array index out of bounds"), counts[0])) == 0) {
if ((cur_len >= 3 && seg_start != 0)) {
run_internal = (run_internal + (cur_len * cur_prod));
}
cur_len = 0;
cur_prod = 1;
seg_start = (-1);
} else {
if (cur_len == 0) {
seg_start = ii;
}
cur_len = (cur_len + 1);
cur_prod = (cur_prod * (((unsigned)(ii) < 6) ? counts[ii] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(ii), 6), flow_fault_handler("array index out of bounds"), counts[0])));
}
ii = (ii + 1);
}
if ((cur_len >= 3 && seg_start != 0)) {
run_internal = (run_internal + (cur_len * cur_prod));
}
int32_t A_R = ((hv - pairs) - run_internal);
right_entries[n_right].c8 = c8;
right_entries[n_right].c9 = c9;
right_entries[n_right].n10 = n10;
right_entries[n_right].head_len = head_len;
right_entries[n_right].head_prod = head_prod;
right_entries[n_right].A_R = A_R;
right_entries[n_right].weight = w;
n_right = (n_right + 1);
c13 = (c13 + 1);
}
c12 = (c12 + 1);
}
c11 = (c11 + 1);
}
c10 = (c10 + 1);
}
c9 = (c9 + 1);
}
c8 = (c8 + 1);
}
}
int64_t binary_search_right_i32_i32_i32(int32_t lo0, int32_t hi0, int32_t target_A_R) {
int32_t lo = lo0;
int32_t hi = hi0;
int32_t orig_hi = hi0;
while (lo < hi) {
int32_t mid = (lo + FLOW_CHECKED_DIV(((hi - lo)), (2)));
if (right_entries[mid].A_R < target_A_R) {
lo = (mid + 1);
} else {
hi = mid;
}
}
if ((lo < orig_hi && right_entries[lo].A_R == target_A_R)) {
return right_entries[lo].weight;
}
return 0;
}
int32_t main(void) {
COMB4 = ((int32_t*)(malloc(20)));
COMB4[0] = 1;
COMB4[1] = 4;
COMB4[2] = 6;
COMB4[3] = 4;
COMB4[4] = 1;
CHOOSE = ((int32_t*)(calloc(25, 4)));
g_nd = ((int64_t*)(calloc(16, 8)));
init_choose();
left_entries = ((LeftEntry*)(calloc(78125, 40)));
n_left = 0;
right_entries = ((RightEntry*)(calloc(15625, 48)));
n_right = 0;
enumerate_left();
enumerate_right();
heapsort_left_ptr_LeftEntry_i32(left_entries, n_left);
heapsort_right_ptr_RightEntry_i32(right_entries, n_right);
int32_t* left_group_start = (int32_t*)(((int32_t*)(malloc((78125 * 4)))));
int32_t* left_group_end = (int32_t*)(((int32_t*)(malloc((78125 * 4)))));
int32_t n_left_groups = 0;
int32_t i = 0;
while (i < n_left) {
int32_t j = i;
while ((j < n_left && cmp_left_at_ptr_LeftEntry_i32_i32(left_entries, i, j) == 0)) {
j = (j + 1);
}
int64_t total_w = 0;
int32_t k = i;
while (k < j) {
total_w = (total_w + left_entries[k].weight);
k = (k + 1);
}
left_entries[i].weight = total_w;
left_group_start[n_left_groups] = i;
left_group_end[n_left_groups] = j;
n_left_groups = (n_left_groups + 1);
i = j;
}
RightGroup* right_groups = (RightGroup*)(((RightGroup*)(calloc(15625, 28))));
int32_t n_right_groups = 0;
i = 0;
while (i < n_right) {
int32_t j = i;
while ((((((j < n_right && right_entries[j].c8 == right_entries[i].c8) && right_entries[j].c9 == right_entries[i].c9) && right_entries[j].n10 == right_entries[i].n10) && right_entries[j].head_len == right_entries[i].head_len) && right_entries[j].head_prod == right_entries[i].head_prod)) {
j = (j + 1);
}
int32_t k2 = i;
while (k2 < j) {
int32_t l = k2;
while ((l < j && right_entries[l].A_R == right_entries[k2].A_R)) {
l = (l + 1);
}
int64_t total_w2 = 0;
int32_t m = k2;
while (m < l) {
total_w2 = (total_w2 + right_entries[m].weight);
m = (m + 1);
}
right_entries[k2].weight = total_w2;
k2 = l;
}
right_groups[n_right_groups].c8 = right_entries[i].c8;
right_groups[n_right_groups].c9 = right_entries[i].c9;
right_groups[n_right_groups].n10 = right_entries[i].n10;
right_groups[n_right_groups].head_len = right_entries[i].head_len;
right_groups[n_right_groups].head_prod = right_entries[i].head_prod;
right_groups[n_right_groups].start = i;
right_groups[n_right_groups].end = j;
n_right_groups = (n_right_groups + 1);
i = j;
}
RightSuperGroup* right_super = (RightSuperGroup*)(((RightSuperGroup*)(calloc(500, 24))));
int32_t n_right_super = 0;
i = 0;
while (i < n_right_groups) {
int32_t j = i;
while ((((j < n_right_groups && right_groups[j].c8 == right_groups[i].c8) && right_groups[j].c9 == right_groups[i].c9) && right_groups[j].n10 == right_groups[i].n10)) {
j = (j + 1);
}
right_super[n_right_super].c8 = right_groups[i].c8;
right_super[n_right_super].c9 = right_groups[i].c9;
right_super[n_right_super].n10 = right_groups[i].n10;
right_super[n_right_super].start = i;
right_super[n_right_super].end = j;
n_right_super = (n_right_super + 1);
i = j;
}
int64_t total = 0;
int32_t lg = 0;
while (lg < n_left_groups) {
LeftEntry* le = (LeftEntry*)((left_entries + left_group_start[lg]));
int32_t L5 = le->L5;
int32_t L6 = le->L6;
int32_t L7 = le->L7;
int32_t L15 = le->L15;
int32_t tl = le->tail_len;
int32_t tp = le->tail_prod;
int32_t A_L = le->A_L;
int64_t wL = le->weight;
int32_t rs = 0;
while (rs < n_right_super) {
int32_t c8 = right_super[rs].c8;
int32_t c9 = right_super[rs].c9;
int32_t n10 = right_super[rs].n10;
int32_t dp15 = (((L15 + (L7 * c8)) + (L6 * c9)) + (L5 * n10));
if (dp15 > 170) {
rs = (rs + 1);
continue;
}
int32_t base = (2 * dp15);
int32_t rg = right_super[rs].start;
while (rg < right_super[rs].end) {
int32_t hl = right_groups[rg].head_len;
int32_t hp = right_groups[rg].head_prod;
int32_t req = (base + run_boundary_i32_i32_i32_i32(tl, tp, hl, hp));
int32_t want = (req - A_L);
int64_t wR = binary_search_right_i32_i32_i32(right_groups[rg].start, right_groups[rg].end, want);
if (wR != 0) {
total = (total + (wL * wR));
}
rg = (rg + 1);
}
rs = (rs + 1);
}
lg = (lg + 1);
}
total = (total - 1);
printf("%lld\n", total);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @malloc(i64) -> !llvm.ptr
func.func private @memcpy(!llvm.ptr, !llvm.ptr, i64) -> !llvm.ptr
func.func private @memset(!llvm.ptr, i32, i64) -> ()
// Struct: LeftEntry
// Fields:
// L5: i32
// L6: i32
// L7: i32
// L15: i32
// tail_len: i32
// tail_prod: i32
// A_L: i32
// weight: i64
// Struct: RightEntry
// Fields:
// c8: i32
// c9: i32
// n10: i32
// head_len: i32
// head_prod: i32
// A_R: i32
// weight: i64
// Struct: RightGroup
// Fields:
// c8: i32
// c9: i32
// n10: i32
// head_len: i32
// head_prod: i32
// start: i32
// end: i32
// Struct: RightSuperGroup
// Fields:
// c8: i32
// c9: i32
// n10: i32
// start: i32
// end: i32
// Module static: COMB4
llvm.mlir.global internal @COMB4() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: CHOOSE
llvm.mlir.global internal @CHOOSE() {addr_space = 0 : i32} : !llvm.ptr {
%1 = llvm.mlir.zero : !llvm.ptr
llvm.return %1 : !llvm.ptr
}
// Module static: g_nd
llvm.mlir.global internal @g_nd() {addr_space = 0 : i32} : !llvm.ptr {
%2 = llvm.mlir.zero : !llvm.ptr
llvm.return %2 : !llvm.ptr
}
// Module static: left_entries
llvm.mlir.global internal @left_entries() {addr_space = 0 : i32} : !llvm.ptr {
%3 = llvm.mlir.zero : !llvm.ptr
llvm.return %3 : !llvm.ptr
}
// Module static: n_left
llvm.mlir.global internal @n_left(0 : i32) : i32
// Module static: right_entries
llvm.mlir.global internal @right_entries() {addr_space = 0 : i32} : !llvm.ptr {
%4 = llvm.mlir.zero : !llvm.ptr
llvm.return %4 : !llvm.ptr
}
// Module static: n_right
llvm.mlir.global internal @n_right(0 : i32) : i32
func.func @init_choose() -> () {
%5 = arith.constant 0 : i32
%6 = llvm.mlir.constant(1 : i64) : i64
%7 = llvm.alloca %6 x i32 : (i64) -> !llvm.ptr
llvm.store %5, %7 : i32, !llvm.ptr
cf.br ^bb0
^bb0:
%8 = llvm.load %7 : !llvm.ptr -> i32
%9 = arith.constant 5 : i32
%10 = arith.cmpi slt, %8, %9 : i32
cf.cond_br %10, ^bb1, ^bb2
^bb1:
%11 = arith.constant 1 : i32
%12 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
%13 = llvm.load %12 : !llvm.ptr -> !llvm.ptr
%14 = llvm.load %7 : !llvm.ptr -> i32
%15 = arith.constant 5 : i32
%16 = arith.muli %14, %15 : i32
%17 = arith.constant 0 : i32
%18 = arith.addi %16, %17 : i32
%19 = arith.extsi %18 : i32 to i64
%20 = llvm.getelementptr %13[%19] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %11, %20 : i32, !llvm.ptr
%21 = arith.constant 1 : i32
%22 = llvm.mlir.constant(1 : i64) : i64
%23 = llvm.alloca %22 x i32 : (i64) -> !llvm.ptr
llvm.store %21, %23 : i32, !llvm.ptr
cf.br ^bb3
^bb3:
%24 = llvm.load %23 : !llvm.ptr -> i32
%25 = llvm.load %7 : !llvm.ptr -> i32
%26 = arith.cmpi sle, %24, %25 : i32
cf.cond_br %26, ^bb4, ^bb5
^bb4:
%28 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
%29 = llvm.load %28 : !llvm.ptr -> !llvm.ptr
%30 = llvm.load %7 : !llvm.ptr -> i32
%31 = arith.constant 1 : i32
%32 = arith.subi %30, %31 : i32
%33 = arith.constant 5 : i32
%34 = arith.muli %32, %33 : i32
%35 = llvm.load %23 : !llvm.ptr -> i32
%36 = arith.addi %34, %35 : i32
%37 = arith.constant 1 : i32
%38 = arith.subi %36, %37 : i32
%39 = arith.extsi %38 : i32 to i64
%40 = llvm.getelementptr %29[%39] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%27 = llvm.load %40 : !llvm.ptr -> i32
%41 = llvm.mlir.constant(1 : i64) : i64
%42 = llvm.alloca %41 x i32 : (i64) -> !llvm.ptr
llvm.store %27, %42 : i32, !llvm.ptr
%43 = llvm.load %23 : !llvm.ptr -> i32
%44 = llvm.load %7 : !llvm.ptr -> i32
%45 = arith.constant 1 : i32
%46 = arith.subi %44, %45 : i32
%47 = arith.cmpi sle, %43, %46 : i32
cf.cond_br %47, ^bb6, ^bb7
^bb6:
%48 = llvm.load %42 : !llvm.ptr -> i32
%50 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
%51 = llvm.load %50 : !llvm.ptr -> !llvm.ptr
%52 = llvm.load %7 : !llvm.ptr -> i32
%53 = arith.constant 1 : i32
%54 = arith.subi %52, %53 : i32
%55 = arith.constant 5 : i32
%56 = arith.muli %54, %55 : i32
%57 = llvm.load %23 : !llvm.ptr -> i32
%58 = arith.addi %56, %57 : i32
%59 = arith.extsi %58 : i32 to i64
%60 = llvm.getelementptr %51[%59] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%49 = llvm.load %60 : !llvm.ptr -> i32
%61 = arith.addi %48, %49 : i32
llvm.store %61, %42 : i32, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%62 = llvm.load %42 : !llvm.ptr -> i32
%63 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
%64 = llvm.load %63 : !llvm.ptr -> !llvm.ptr
%65 = llvm.load %7 : !llvm.ptr -> i32
%66 = arith.constant 5 : i32
%67 = arith.muli %65, %66 : i32
%68 = llvm.load %23 : !llvm.ptr -> i32
%69 = arith.addi %67, %68 : i32
%70 = arith.extsi %69 : i32 to i64
%71 = llvm.getelementptr %64[%70] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %62, %71 : i32, !llvm.ptr
%72 = llvm.load %23 : !llvm.ptr -> i32
%73 = arith.constant 1 : i32
%74 = arith.addi %72, %73 : i32
llvm.store %74, %23 : i32, !llvm.ptr
cf.br ^bb3
^bb5:
%75 = llvm.load %7 : !llvm.ptr -> i32
%76 = arith.constant 1 : i32
%77 = arith.addi %75, %76 : i32
llvm.store %77, %7 : i32, !llvm.ptr
cf.br ^bb0
^bb2:
func.return
}
func.func @dp_update(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> () {
%78 = arith.constant 0 : i32
%79 = arith.cmpi eq, %arg2, %78 : i32
cf.cond_br %79, ^bb9, ^bb10
^bb9:
func.return
^bb10:
cf.br ^bb11
^bb11:
%81 = llvm.mlir.addressof @g_nd : !llvm.ptr
%82 = llvm.load %81 : !llvm.ptr -> !llvm.ptr
%83 = arith.constant 0 : i32
%84 = arith.constant 128 : i32
%85 = arith.extsi %84 : i32 to i64
func.call @memset(%82, %83, %85) : (!llvm.ptr, i32, i64) -> ()
%86 = arith.constant 0 : i32
%87 = llvm.mlir.constant(1 : i64) : i64
%88 = llvm.alloca %87 x i32 : (i64) -> !llvm.ptr
llvm.store %86, %88 : i32, !llvm.ptr
cf.br ^bb12
^bb12:
%89 = llvm.load %88 : !llvm.ptr -> i32
%90 = arith.constant 16 : i32
%91 = arith.cmpi slt, %89, %90 : i32
cf.cond_br %91, ^bb13, ^bb14
^bb13:
%92 = arith.constant 0 : i32
%93 = arith.extsi %92 : i32 to i64
%94 = llvm.mlir.constant(1 : i64) : i64
%95 = llvm.alloca %94 x i64 : (i64) -> !llvm.ptr
llvm.store %93, %95 : i64, !llvm.ptr
%96 = llvm.mlir.constant(1 : i64) : i64
%97 = llvm.alloca %96 x i32 : (i64) -> !llvm.ptr
llvm.store %arg2, %97 : i32, !llvm.ptr
%98 = arith.constant 0 : i32
%99 = arith.cmpi sgt, %arg1, %98 : i32
cf.cond_br %99, ^bb15, ^bb16
^bb15:
%100 = llvm.load %88 : !llvm.ptr -> i32
%101 = arith.divsi %100, %arg1 : i32
%102 = llvm.load %97 : !llvm.ptr -> i32
%103 = arith.cmpi slt, %101, %102 : i32
cf.cond_br %103, ^bb18, ^bb19
^bb18:
%104 = llvm.load %88 : !llvm.ptr -> i32
%105 = arith.divsi %104, %arg1 : i32
llvm.store %105, %97 : i32, !llvm.ptr
cf.br ^bb20
^bb19:
cf.br ^bb20
^bb20:
cf.br ^bb17
^bb16:
cf.br ^bb17
^bb17:
%106 = arith.constant 0 : i32
%107 = llvm.mlir.constant(1 : i64) : i64
%108 = llvm.alloca %107 x i32 : (i64) -> !llvm.ptr
llvm.store %106, %108 : i32, !llvm.ptr
cf.br ^bb21
^bb21:
%109 = llvm.load %108 : !llvm.ptr -> i32
%110 = llvm.load %97 : !llvm.ptr -> i32
%111 = arith.cmpi sle, %109, %110 : i32
cf.cond_br %111, ^bb22, ^bb23
^bb22:
%112 = llvm.load %95 : !llvm.ptr -> i64
%114 = llvm.load %88 : !llvm.ptr -> i32
%115 = llvm.load %108 : !llvm.ptr -> i32
%116 = arith.muli %115, %arg1 : i32
%117 = arith.subi %114, %116 : i32
%118 = arith.extsi %117 : i32 to i64
%119 = llvm.getelementptr %arg0[%118] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%113 = llvm.load %119 : !llvm.ptr -> i64
%121 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
%122 = llvm.load %121 : !llvm.ptr -> !llvm.ptr
%123 = arith.constant 5 : i32
%124 = arith.muli %arg2, %123 : i32
%125 = llvm.load %108 : !llvm.ptr -> i32
%126 = arith.addi %124, %125 : i32
%127 = arith.extsi %126 : i32 to i64
%128 = llvm.getelementptr %122[%127] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%120 = llvm.load %128 : !llvm.ptr -> i32
%129 = arith.extsi %120 : i32 to i64
%130 = arith.muli %113, %129 : i64
%131 = arith.addi %112, %130 : i64
llvm.store %131, %95 : i64, !llvm.ptr
%132 = llvm.load %108 : !llvm.ptr -> i32
%133 = arith.constant 1 : i32
%134 = arith.addi %132, %133 : i32
llvm.store %134, %108 : i32, !llvm.ptr
cf.br ^bb21
^bb23:
%135 = llvm.load %95 : !llvm.ptr -> i64
%136 = llvm.mlir.addressof @g_nd : !llvm.ptr
%137 = llvm.load %136 : !llvm.ptr -> !llvm.ptr
%138 = llvm.load %88 : !llvm.ptr -> i32
%139 = arith.extsi %138 : i32 to i64
%140 = llvm.getelementptr %137[%139] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %135, %140 : i64, !llvm.ptr
%141 = llvm.load %88 : !llvm.ptr -> i32
%142 = arith.constant 1 : i32
%143 = arith.addi %141, %142 : i32
llvm.store %143, %88 : i32, !llvm.ptr
cf.br ^bb12
^bb14:
%145 = llvm.mlir.addressof @g_nd : !llvm.ptr
%146 = llvm.load %145 : !llvm.ptr -> !llvm.ptr
%147 = arith.constant 128 : i32
%148 = arith.extsi %147 : i32 to i64
%144 = func.call @memcpy(%arg0, %146, %148) : (!llvm.ptr, !llvm.ptr, i64) -> !llvm.ptr
func.return
}
func.func @run_boundary(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: i32) -> i32 {
%149 = arith.constant 0 : i32
%150 = llvm.mlir.constant(1 : i64) : i64
%151 = llvm.alloca %150 x i32 : (i64) -> !llvm.ptr
llvm.store %149, %151 : i32, !llvm.ptr
%152 = arith.constant 0 : i32
%153 = llvm.mlir.constant(1 : i64) : i64
%154 = llvm.alloca %153 x i32 : (i64) -> !llvm.ptr
llvm.store %152, %154 : i32, !llvm.ptr
%155 = arith.constant 0 : i32
%156 = arith.cmpi sgt, %arg0, %155 : i32
%157 = scf.if %156 -> (i1) {
%158 = arith.constant 0 : i32
%159 = arith.cmpi sgt, %arg2, %158 : i32
scf.yield %159 : i1
} else {
%160 = arith.constant false
scf.yield %160 : i1
}
cf.cond_br %157, ^bb24, ^bb25
^bb24:
%161 = arith.addi %arg0, %arg2 : i32
llvm.store %161, %151 : i32, !llvm.ptr
%162 = arith.muli %arg1, %arg3 : i32
llvm.store %162, %154 : i32, !llvm.ptr
cf.br ^bb26
^bb25:
%163 = arith.constant 0 : i32
%164 = arith.cmpi sgt, %arg0, %163 : i32
cf.cond_br %164, ^bb27, ^bb28
^bb27:
llvm.store %arg0, %151 : i32, !llvm.ptr
llvm.store %arg1, %154 : i32, !llvm.ptr
cf.br ^bb29
^bb28:
%165 = arith.constant 0 : i32
%166 = arith.cmpi sgt, %arg2, %165 : i32
cf.cond_br %166, ^bb30, ^bb31
^bb30:
llvm.store %arg2, %151 : i32, !llvm.ptr
llvm.store %arg3, %154 : i32, !llvm.ptr
cf.br ^bb32
^bb31:
%167 = arith.constant 0 : i32
func.return %167 : i32
^bb32:
cf.br ^bb29
^bb29:
cf.br ^bb26
^bb26:
%168 = llvm.load %151 : !llvm.ptr -> i32
%169 = arith.constant 3 : i32
%170 = arith.cmpi sge, %168, %169 : i32
cf.cond_br %170, ^bb33, ^bb34
^bb33:
%171 = llvm.load %151 : !llvm.ptr -> i32
%172 = llvm.load %154 : !llvm.ptr -> i32
%173 = arith.muli %171, %172 : i32
func.return %173 : i32
^bb34:
cf.br ^bb35
^bb35:
%174 = arith.constant 0 : i32
func.return %174 : i32
}
func.func @cmp_left_at(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> i32 {
%176 = arith.extsi %arg1 : i32 to i64
%177 = llvm.getelementptr %arg0[%176] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%175 = llvm.load %177 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%178 = arith.extsi %arg1 : i32 to i64
%179 = llvm.getelementptr %arg0[%178] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%180 = llvm.getelementptr %179[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%181 = llvm.load %180 : !llvm.ptr -> i32
%183 = arith.extsi %arg2 : i32 to i64
%184 = llvm.getelementptr %arg0[%183] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%182 = llvm.load %184 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%185 = arith.extsi %arg2 : i32 to i64
%186 = llvm.getelementptr %arg0[%185] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%187 = llvm.getelementptr %186[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%188 = llvm.load %187 : !llvm.ptr -> i32
%189 = arith.cmpi ne, %181, %188 : i32
cf.cond_br %189, ^bb36, ^bb37
^bb36:
%191 = arith.extsi %arg1 : i32 to i64
%192 = llvm.getelementptr %arg0[%191] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%190 = llvm.load %192 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%193 = arith.extsi %arg1 : i32 to i64
%194 = llvm.getelementptr %arg0[%193] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%195 = llvm.getelementptr %194[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%196 = llvm.load %195 : !llvm.ptr -> i32
%198 = arith.extsi %arg2 : i32 to i64
%199 = llvm.getelementptr %arg0[%198] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%197 = llvm.load %199 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%200 = arith.extsi %arg2 : i32 to i64
%201 = llvm.getelementptr %arg0[%200] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%202 = llvm.getelementptr %201[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%203 = llvm.load %202 : !llvm.ptr -> i32
%204 = arith.subi %196, %203 : i32
func.return %204 : i32
^bb37:
cf.br ^bb38
^bb38:
%206 = arith.extsi %arg1 : i32 to i64
%207 = llvm.getelementptr %arg0[%206] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%205 = llvm.load %207 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%208 = arith.extsi %arg1 : i32 to i64
%209 = llvm.getelementptr %arg0[%208] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%210 = llvm.getelementptr %209[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%211 = llvm.load %210 : !llvm.ptr -> i32
%213 = arith.extsi %arg2 : i32 to i64
%214 = llvm.getelementptr %arg0[%213] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%212 = llvm.load %214 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%215 = arith.extsi %arg2 : i32 to i64
%216 = llvm.getelementptr %arg0[%215] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%217 = llvm.getelementptr %216[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%218 = llvm.load %217 : !llvm.ptr -> i32
%219 = arith.cmpi ne, %211, %218 : i32
cf.cond_br %219, ^bb39, ^bb40
^bb39:
%221 = arith.extsi %arg1 : i32 to i64
%222 = llvm.getelementptr %arg0[%221] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%220 = llvm.load %222 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%223 = arith.extsi %arg1 : i32 to i64
%224 = llvm.getelementptr %arg0[%223] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%225 = llvm.getelementptr %224[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%226 = llvm.load %225 : !llvm.ptr -> i32
%228 = arith.extsi %arg2 : i32 to i64
%229 = llvm.getelementptr %arg0[%228] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%227 = llvm.load %229 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%230 = arith.extsi %arg2 : i32 to i64
%231 = llvm.getelementptr %arg0[%230] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%232 = llvm.getelementptr %231[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%233 = llvm.load %232 : !llvm.ptr -> i32
%234 = arith.subi %226, %233 : i32
func.return %234 : i32
^bb40:
cf.br ^bb41
^bb41:
%236 = arith.extsi %arg1 : i32 to i64
%237 = llvm.getelementptr %arg0[%236] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%235 = llvm.load %237 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%238 = arith.extsi %arg1 : i32 to i64
%239 = llvm.getelementptr %arg0[%238] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%240 = llvm.getelementptr %239[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%241 = llvm.load %240 : !llvm.ptr -> i32
%243 = arith.extsi %arg2 : i32 to i64
%244 = llvm.getelementptr %arg0[%243] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%242 = llvm.load %244 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%245 = arith.extsi %arg2 : i32 to i64
%246 = llvm.getelementptr %arg0[%245] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%247 = llvm.getelementptr %246[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%248 = llvm.load %247 : !llvm.ptr -> i32
%249 = arith.cmpi ne, %241, %248 : i32
cf.cond_br %249, ^bb42, ^bb43
^bb42:
%251 = arith.extsi %arg1 : i32 to i64
%252 = llvm.getelementptr %arg0[%251] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%250 = llvm.load %252 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%253 = arith.extsi %arg1 : i32 to i64
%254 = llvm.getelementptr %arg0[%253] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%255 = llvm.getelementptr %254[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%256 = llvm.load %255 : !llvm.ptr -> i32
%258 = arith.extsi %arg2 : i32 to i64
%259 = llvm.getelementptr %arg0[%258] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%257 = llvm.load %259 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%260 = arith.extsi %arg2 : i32 to i64
%261 = llvm.getelementptr %arg0[%260] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%262 = llvm.getelementptr %261[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%263 = llvm.load %262 : !llvm.ptr -> i32
%264 = arith.subi %256, %263 : i32
func.return %264 : i32
^bb43:
cf.br ^bb44
^bb44:
%266 = arith.extsi %arg1 : i32 to i64
%267 = llvm.getelementptr %arg0[%266] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%265 = llvm.load %267 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%268 = arith.extsi %arg1 : i32 to i64
%269 = llvm.getelementptr %arg0[%268] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%270 = llvm.getelementptr %269[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%271 = llvm.load %270 : !llvm.ptr -> i32
%273 = arith.extsi %arg2 : i32 to i64
%274 = llvm.getelementptr %arg0[%273] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%272 = llvm.load %274 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%275 = arith.extsi %arg2 : i32 to i64
%276 = llvm.getelementptr %arg0[%275] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%277 = llvm.getelementptr %276[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%278 = llvm.load %277 : !llvm.ptr -> i32
%279 = arith.cmpi ne, %271, %278 : i32
cf.cond_br %279, ^bb45, ^bb46
^bb45:
%281 = arith.extsi %arg1 : i32 to i64
%282 = llvm.getelementptr %arg0[%281] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%280 = llvm.load %282 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%283 = arith.extsi %arg1 : i32 to i64
%284 = llvm.getelementptr %arg0[%283] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%285 = llvm.getelementptr %284[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%286 = llvm.load %285 : !llvm.ptr -> i32
%288 = arith.extsi %arg2 : i32 to i64
%289 = llvm.getelementptr %arg0[%288] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%287 = llvm.load %289 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%290 = arith.extsi %arg2 : i32 to i64
%291 = llvm.getelementptr %arg0[%290] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%292 = llvm.getelementptr %291[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%293 = llvm.load %292 : !llvm.ptr -> i32
%294 = arith.subi %286, %293 : i32
func.return %294 : i32
^bb46:
cf.br ^bb47
^bb47:
%296 = arith.extsi %arg1 : i32 to i64
%297 = llvm.getelementptr %arg0[%296] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%295 = llvm.load %297 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%298 = arith.extsi %arg1 : i32 to i64
%299 = llvm.getelementptr %arg0[%298] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%300 = llvm.getelementptr %299[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%301 = llvm.load %300 : !llvm.ptr -> i32
%303 = arith.extsi %arg2 : i32 to i64
%304 = llvm.getelementptr %arg0[%303] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%302 = llvm.load %304 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%305 = arith.extsi %arg2 : i32 to i64
%306 = llvm.getelementptr %arg0[%305] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%307 = llvm.getelementptr %306[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%308 = llvm.load %307 : !llvm.ptr -> i32
%309 = arith.cmpi ne, %301, %308 : i32
cf.cond_br %309, ^bb48, ^bb49
^bb48:
%311 = arith.extsi %arg1 : i32 to i64
%312 = llvm.getelementptr %arg0[%311] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%310 = llvm.load %312 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%313 = arith.extsi %arg1 : i32 to i64
%314 = llvm.getelementptr %arg0[%313] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%315 = llvm.getelementptr %314[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%316 = llvm.load %315 : !llvm.ptr -> i32
%318 = arith.extsi %arg2 : i32 to i64
%319 = llvm.getelementptr %arg0[%318] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%317 = llvm.load %319 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%320 = arith.extsi %arg2 : i32 to i64
%321 = llvm.getelementptr %arg0[%320] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%322 = llvm.getelementptr %321[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%323 = llvm.load %322 : !llvm.ptr -> i32
%324 = arith.subi %316, %323 : i32
func.return %324 : i32
^bb49:
cf.br ^bb50
^bb50:
%326 = arith.extsi %arg1 : i32 to i64
%327 = llvm.getelementptr %arg0[%326] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%325 = llvm.load %327 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%328 = arith.extsi %arg1 : i32 to i64
%329 = llvm.getelementptr %arg0[%328] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%330 = llvm.getelementptr %329[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%331 = llvm.load %330 : !llvm.ptr -> i32
%333 = arith.extsi %arg2 : i32 to i64
%334 = llvm.getelementptr %arg0[%333] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%332 = llvm.load %334 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%335 = arith.extsi %arg2 : i32 to i64
%336 = llvm.getelementptr %arg0[%335] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%337 = llvm.getelementptr %336[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%338 = llvm.load %337 : !llvm.ptr -> i32
%339 = arith.cmpi ne, %331, %338 : i32
cf.cond_br %339, ^bb51, ^bb52
^bb51:
%341 = arith.extsi %arg1 : i32 to i64
%342 = llvm.getelementptr %arg0[%341] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%340 = llvm.load %342 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%343 = arith.extsi %arg1 : i32 to i64
%344 = llvm.getelementptr %arg0[%343] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%345 = llvm.getelementptr %344[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%346 = llvm.load %345 : !llvm.ptr -> i32
%348 = arith.extsi %arg2 : i32 to i64
%349 = llvm.getelementptr %arg0[%348] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%347 = llvm.load %349 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%350 = arith.extsi %arg2 : i32 to i64
%351 = llvm.getelementptr %arg0[%350] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%352 = llvm.getelementptr %351[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%353 = llvm.load %352 : !llvm.ptr -> i32
%354 = arith.subi %346, %353 : i32
func.return %354 : i32
^bb52:
cf.br ^bb53
^bb53:
%356 = arith.extsi %arg1 : i32 to i64
%357 = llvm.getelementptr %arg0[%356] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%355 = llvm.load %357 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%358 = arith.extsi %arg1 : i32 to i64
%359 = llvm.getelementptr %arg0[%358] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%360 = llvm.getelementptr %359[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%361 = llvm.load %360 : !llvm.ptr -> i32
%363 = arith.extsi %arg2 : i32 to i64
%364 = llvm.getelementptr %arg0[%363] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%362 = llvm.load %364 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%365 = arith.extsi %arg2 : i32 to i64
%366 = llvm.getelementptr %arg0[%365] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%367 = llvm.getelementptr %366[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%368 = llvm.load %367 : !llvm.ptr -> i32
%369 = arith.subi %361, %368 : i32
func.return %369 : i32
}
func.func @swap_left(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> () {
%371 = arith.extsi %arg1 : i32 to i64
%372 = llvm.getelementptr %arg0[%371] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%370 = llvm.load %372 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%373 = arith.extsi %arg1 : i32 to i64
%374 = llvm.getelementptr %arg0[%373] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%375 = llvm.getelementptr %374[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%376 = llvm.load %375 : !llvm.ptr -> i32
%378 = arith.extsi %arg2 : i32 to i64
%379 = llvm.getelementptr %arg0[%378] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%377 = llvm.load %379 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%380 = arith.extsi %arg2 : i32 to i64
%381 = llvm.getelementptr %arg0[%380] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%382 = llvm.getelementptr %381[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%383 = llvm.load %382 : !llvm.ptr -> i32
%384 = arith.extsi %arg1 : i32 to i64
%385 = llvm.getelementptr %arg0[%384] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%386 = llvm.getelementptr %385[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %383, %386 : i32, !llvm.ptr
%387 = arith.extsi %arg2 : i32 to i64
%388 = llvm.getelementptr %arg0[%387] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%389 = llvm.getelementptr %388[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %376, %389 : i32, !llvm.ptr
%391 = arith.extsi %arg1 : i32 to i64
%392 = llvm.getelementptr %arg0[%391] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%390 = llvm.load %392 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%393 = arith.extsi %arg1 : i32 to i64
%394 = llvm.getelementptr %arg0[%393] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%395 = llvm.getelementptr %394[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%396 = llvm.load %395 : !llvm.ptr -> i32
%398 = arith.extsi %arg2 : i32 to i64
%399 = llvm.getelementptr %arg0[%398] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%397 = llvm.load %399 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%400 = arith.extsi %arg2 : i32 to i64
%401 = llvm.getelementptr %arg0[%400] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%402 = llvm.getelementptr %401[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%403 = llvm.load %402 : !llvm.ptr -> i32
%404 = arith.extsi %arg1 : i32 to i64
%405 = llvm.getelementptr %arg0[%404] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%406 = llvm.getelementptr %405[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %403, %406 : i32, !llvm.ptr
%407 = arith.extsi %arg2 : i32 to i64
%408 = llvm.getelementptr %arg0[%407] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%409 = llvm.getelementptr %408[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %396, %409 : i32, !llvm.ptr
%411 = arith.extsi %arg1 : i32 to i64
%412 = llvm.getelementptr %arg0[%411] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%410 = llvm.load %412 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%413 = arith.extsi %arg1 : i32 to i64
%414 = llvm.getelementptr %arg0[%413] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%415 = llvm.getelementptr %414[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%416 = llvm.load %415 : !llvm.ptr -> i32
%418 = arith.extsi %arg2 : i32 to i64
%419 = llvm.getelementptr %arg0[%418] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%417 = llvm.load %419 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%420 = arith.extsi %arg2 : i32 to i64
%421 = llvm.getelementptr %arg0[%420] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%422 = llvm.getelementptr %421[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%423 = llvm.load %422 : !llvm.ptr -> i32
%424 = arith.extsi %arg1 : i32 to i64
%425 = llvm.getelementptr %arg0[%424] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%426 = llvm.getelementptr %425[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %423, %426 : i32, !llvm.ptr
%427 = arith.extsi %arg2 : i32 to i64
%428 = llvm.getelementptr %arg0[%427] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%429 = llvm.getelementptr %428[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %416, %429 : i32, !llvm.ptr
%431 = arith.extsi %arg1 : i32 to i64
%432 = llvm.getelementptr %arg0[%431] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%430 = llvm.load %432 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%433 = arith.extsi %arg1 : i32 to i64
%434 = llvm.getelementptr %arg0[%433] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%435 = llvm.getelementptr %434[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%436 = llvm.load %435 : !llvm.ptr -> i32
%438 = arith.extsi %arg2 : i32 to i64
%439 = llvm.getelementptr %arg0[%438] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%437 = llvm.load %439 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%440 = arith.extsi %arg2 : i32 to i64
%441 = llvm.getelementptr %arg0[%440] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%442 = llvm.getelementptr %441[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%443 = llvm.load %442 : !llvm.ptr -> i32
%444 = arith.extsi %arg1 : i32 to i64
%445 = llvm.getelementptr %arg0[%444] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%446 = llvm.getelementptr %445[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %443, %446 : i32, !llvm.ptr
%447 = arith.extsi %arg2 : i32 to i64
%448 = llvm.getelementptr %arg0[%447] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%449 = llvm.getelementptr %448[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %436, %449 : i32, !llvm.ptr
%451 = arith.extsi %arg1 : i32 to i64
%452 = llvm.getelementptr %arg0[%451] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%450 = llvm.load %452 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%453 = arith.extsi %arg1 : i32 to i64
%454 = llvm.getelementptr %arg0[%453] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%455 = llvm.getelementptr %454[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%456 = llvm.load %455 : !llvm.ptr -> i32
%458 = arith.extsi %arg2 : i32 to i64
%459 = llvm.getelementptr %arg0[%458] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%457 = llvm.load %459 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%460 = arith.extsi %arg2 : i32 to i64
%461 = llvm.getelementptr %arg0[%460] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%462 = llvm.getelementptr %461[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%463 = llvm.load %462 : !llvm.ptr -> i32
%464 = arith.extsi %arg1 : i32 to i64
%465 = llvm.getelementptr %arg0[%464] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%466 = llvm.getelementptr %465[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %463, %466 : i32, !llvm.ptr
%467 = arith.extsi %arg2 : i32 to i64
%468 = llvm.getelementptr %arg0[%467] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%469 = llvm.getelementptr %468[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %456, %469 : i32, !llvm.ptr
%471 = arith.extsi %arg1 : i32 to i64
%472 = llvm.getelementptr %arg0[%471] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%470 = llvm.load %472 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%473 = arith.extsi %arg1 : i32 to i64
%474 = llvm.getelementptr %arg0[%473] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%475 = llvm.getelementptr %474[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%476 = llvm.load %475 : !llvm.ptr -> i32
%478 = arith.extsi %arg2 : i32 to i64
%479 = llvm.getelementptr %arg0[%478] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%477 = llvm.load %479 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%480 = arith.extsi %arg2 : i32 to i64
%481 = llvm.getelementptr %arg0[%480] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%482 = llvm.getelementptr %481[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%483 = llvm.load %482 : !llvm.ptr -> i32
%484 = arith.extsi %arg1 : i32 to i64
%485 = llvm.getelementptr %arg0[%484] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%486 = llvm.getelementptr %485[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %483, %486 : i32, !llvm.ptr
%487 = arith.extsi %arg2 : i32 to i64
%488 = llvm.getelementptr %arg0[%487] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%489 = llvm.getelementptr %488[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %476, %489 : i32, !llvm.ptr
%491 = arith.extsi %arg1 : i32 to i64
%492 = llvm.getelementptr %arg0[%491] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%490 = llvm.load %492 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%493 = arith.extsi %arg1 : i32 to i64
%494 = llvm.getelementptr %arg0[%493] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%495 = llvm.getelementptr %494[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%496 = llvm.load %495 : !llvm.ptr -> i32
%498 = arith.extsi %arg2 : i32 to i64
%499 = llvm.getelementptr %arg0[%498] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%497 = llvm.load %499 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%500 = arith.extsi %arg2 : i32 to i64
%501 = llvm.getelementptr %arg0[%500] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%502 = llvm.getelementptr %501[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%503 = llvm.load %502 : !llvm.ptr -> i32
%504 = arith.extsi %arg1 : i32 to i64
%505 = llvm.getelementptr %arg0[%504] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%506 = llvm.getelementptr %505[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %503, %506 : i32, !llvm.ptr
%507 = arith.extsi %arg2 : i32 to i64
%508 = llvm.getelementptr %arg0[%507] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%509 = llvm.getelementptr %508[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %496, %509 : i32, !llvm.ptr
%511 = arith.extsi %arg1 : i32 to i64
%512 = llvm.getelementptr %arg0[%511] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%510 = llvm.load %512 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%513 = arith.extsi %arg1 : i32 to i64
%514 = llvm.getelementptr %arg0[%513] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%515 = llvm.getelementptr %514[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%516 = llvm.load %515 : !llvm.ptr -> i64
%518 = arith.extsi %arg2 : i32 to i64
%519 = llvm.getelementptr %arg0[%518] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%517 = llvm.load %519 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%520 = arith.extsi %arg2 : i32 to i64
%521 = llvm.getelementptr %arg0[%520] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%522 = llvm.getelementptr %521[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%523 = llvm.load %522 : !llvm.ptr -> i64
%524 = arith.extsi %arg1 : i32 to i64
%525 = llvm.getelementptr %arg0[%524] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%526 = llvm.getelementptr %525[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %523, %526 : i64, !llvm.ptr
%527 = arith.extsi %arg2 : i32 to i64
%528 = llvm.getelementptr %arg0[%527] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%529 = llvm.getelementptr %528[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %516, %529 : i64, !llvm.ptr
func.return
}
func.func @sift_down_left(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> () {
%530 = llvm.mlir.constant(1 : i64) : i64
%531 = llvm.alloca %530 x i32 : (i64) -> !llvm.ptr
llvm.store %arg1, %531 : i32, !llvm.ptr
cf.br ^bb54
^bb54:
%532 = arith.constant 1 : i1
cf.cond_br %532, ^bb55, ^bb56
^bb55:
%533 = llvm.load %531 : !llvm.ptr -> i32
%534 = llvm.mlir.constant(1 : i64) : i64
%535 = llvm.alloca %534 x i32 : (i64) -> !llvm.ptr
llvm.store %533, %535 : i32, !llvm.ptr
%536 = arith.constant 2 : i32
%537 = llvm.load %531 : !llvm.ptr -> i32
%538 = arith.muli %536, %537 : i32
%539 = arith.constant 1 : i32
%540 = arith.addi %538, %539 : i32
%541 = arith.constant 2 : i32
%542 = llvm.load %531 : !llvm.ptr -> i32
%543 = arith.muli %541, %542 : i32
%544 = arith.constant 2 : i32
%545 = arith.addi %543, %544 : i32
%546 = arith.cmpi slt, %540, %arg2 : i32
cf.cond_br %546, ^bb57, ^bb58
^bb57:
%548 = llvm.load %535 : !llvm.ptr -> i32
%547 = func.call @cmp_left_at(%arg0, %540, %548) : (!llvm.ptr, i32, i32) -> i32
%549 = arith.constant 0 : i32
%550 = arith.cmpi sgt, %547, %549 : i32
cf.cond_br %550, ^bb60, ^bb61
^bb60:
llvm.store %540, %535 : i32, !llvm.ptr
cf.br ^bb62
^bb61:
cf.br ^bb62
^bb62:
cf.br ^bb59
^bb58:
cf.br ^bb59
^bb59:
%551 = arith.cmpi slt, %545, %arg2 : i32
cf.cond_br %551, ^bb63, ^bb64
^bb63:
%553 = llvm.load %535 : !llvm.ptr -> i32
%552 = func.call @cmp_left_at(%arg0, %545, %553) : (!llvm.ptr, i32, i32) -> i32
%554 = arith.constant 0 : i32
%555 = arith.cmpi sgt, %552, %554 : i32
cf.cond_br %555, ^bb66, ^bb67
^bb66:
llvm.store %545, %535 : i32, !llvm.ptr
cf.br ^bb68
^bb67:
cf.br ^bb68
^bb68:
cf.br ^bb65
^bb64:
cf.br ^bb65
^bb65:
%556 = llvm.load %535 : !llvm.ptr -> i32
%557 = llvm.load %531 : !llvm.ptr -> i32
%558 = arith.cmpi eq, %556, %557 : i32
cf.cond_br %558, ^bb69, ^bb70
^bb69:
cf.br ^bb56
^bb70:
cf.br ^bb71
^bb71:
%560 = llvm.load %531 : !llvm.ptr -> i32
%561 = llvm.load %535 : !llvm.ptr -> i32
func.call @swap_left(%arg0, %560, %561) : (!llvm.ptr, i32, i32) -> ()
%562 = llvm.load %535 : !llvm.ptr -> i32
llvm.store %562, %531 : i32, !llvm.ptr
cf.br ^bb54
^bb56:
func.return
}
func.func @heapsort_left(%arg0: !llvm.ptr, %arg1: i32) -> () {
%563 = arith.constant 1 : i32
%564 = arith.cmpi sle, %arg1, %563 : i32
cf.cond_br %564, ^bb72, ^bb73
^bb72:
func.return
^bb73:
cf.br ^bb74
^bb74:
%565 = arith.constant 2 : i32
%566 = arith.divsi %arg1, %565 : i32
%567 = arith.constant 1 : i32
%568 = arith.subi %566, %567 : i32
%569 = llvm.mlir.constant(1 : i64) : i64
%570 = llvm.alloca %569 x i32 : (i64) -> !llvm.ptr
llvm.store %568, %570 : i32, !llvm.ptr
cf.br ^bb75
^bb75:
%571 = llvm.load %570 : !llvm.ptr -> i32
%572 = arith.constant 0 : i32
%573 = arith.cmpi sge, %571, %572 : i32
cf.cond_br %573, ^bb76, ^bb77
^bb76:
%575 = llvm.load %570 : !llvm.ptr -> i32
func.call @sift_down_left(%arg0, %575, %arg1) : (!llvm.ptr, i32, i32) -> ()
%576 = llvm.load %570 : !llvm.ptr -> i32
%577 = arith.constant 1 : i32
%578 = arith.subi %576, %577 : i32
llvm.store %578, %570 : i32, !llvm.ptr
cf.br ^bb75
^bb77:
%579 = arith.constant 1 : i32
%580 = arith.subi %arg1, %579 : i32
llvm.store %580, %570 : i32, !llvm.ptr
cf.br ^bb78
^bb78:
%581 = llvm.load %570 : !llvm.ptr -> i32
%582 = arith.constant 0 : i32
%583 = arith.cmpi sgt, %581, %582 : i32
cf.cond_br %583, ^bb79, ^bb80
^bb79:
%585 = arith.constant 0 : i32
%586 = llvm.load %570 : !llvm.ptr -> i32
func.call @swap_left(%arg0, %585, %586) : (!llvm.ptr, i32, i32) -> ()
%588 = arith.constant 0 : i32
%589 = llvm.load %570 : !llvm.ptr -> i32
func.call @sift_down_left(%arg0, %588, %589) : (!llvm.ptr, i32, i32) -> ()
%590 = llvm.load %570 : !llvm.ptr -> i32
%591 = arith.constant 1 : i32
%592 = arith.subi %590, %591 : i32
llvm.store %592, %570 : i32, !llvm.ptr
cf.br ^bb78
^bb80:
func.return
}
func.func @cmp_right_at(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> i32 {
%594 = arith.extsi %arg1 : i32 to i64
%595 = llvm.getelementptr %arg0[%594] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%593 = llvm.load %595 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%596 = arith.extsi %arg1 : i32 to i64
%597 = llvm.getelementptr %arg0[%596] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%598 = llvm.getelementptr %597[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%599 = llvm.load %598 : !llvm.ptr -> i32
%601 = arith.extsi %arg2 : i32 to i64
%602 = llvm.getelementptr %arg0[%601] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%600 = llvm.load %602 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%603 = arith.extsi %arg2 : i32 to i64
%604 = llvm.getelementptr %arg0[%603] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%605 = llvm.getelementptr %604[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%606 = llvm.load %605 : !llvm.ptr -> i32
%607 = arith.cmpi ne, %599, %606 : i32
cf.cond_br %607, ^bb81, ^bb82
^bb81:
%609 = arith.extsi %arg1 : i32 to i64
%610 = llvm.getelementptr %arg0[%609] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%608 = llvm.load %610 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%611 = arith.extsi %arg1 : i32 to i64
%612 = llvm.getelementptr %arg0[%611] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%613 = llvm.getelementptr %612[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%614 = llvm.load %613 : !llvm.ptr -> i32
%616 = arith.extsi %arg2 : i32 to i64
%617 = llvm.getelementptr %arg0[%616] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%615 = llvm.load %617 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%618 = arith.extsi %arg2 : i32 to i64
%619 = llvm.getelementptr %arg0[%618] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%620 = llvm.getelementptr %619[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%621 = llvm.load %620 : !llvm.ptr -> i32
%622 = arith.subi %614, %621 : i32
func.return %622 : i32
^bb82:
cf.br ^bb83
^bb83:
%624 = arith.extsi %arg1 : i32 to i64
%625 = llvm.getelementptr %arg0[%624] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%623 = llvm.load %625 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%626 = arith.extsi %arg1 : i32 to i64
%627 = llvm.getelementptr %arg0[%626] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%628 = llvm.getelementptr %627[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%629 = llvm.load %628 : !llvm.ptr -> i32
%631 = arith.extsi %arg2 : i32 to i64
%632 = llvm.getelementptr %arg0[%631] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%630 = llvm.load %632 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%633 = arith.extsi %arg2 : i32 to i64
%634 = llvm.getelementptr %arg0[%633] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%635 = llvm.getelementptr %634[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%636 = llvm.load %635 : !llvm.ptr -> i32
%637 = arith.cmpi ne, %629, %636 : i32
cf.cond_br %637, ^bb84, ^bb85
^bb84:
%639 = arith.extsi %arg1 : i32 to i64
%640 = llvm.getelementptr %arg0[%639] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%638 = llvm.load %640 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%641 = arith.extsi %arg1 : i32 to i64
%642 = llvm.getelementptr %arg0[%641] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%643 = llvm.getelementptr %642[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%644 = llvm.load %643 : !llvm.ptr -> i32
%646 = arith.extsi %arg2 : i32 to i64
%647 = llvm.getelementptr %arg0[%646] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%645 = llvm.load %647 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%648 = arith.extsi %arg2 : i32 to i64
%649 = llvm.getelementptr %arg0[%648] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%650 = llvm.getelementptr %649[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%651 = llvm.load %650 : !llvm.ptr -> i32
%652 = arith.subi %644, %651 : i32
func.return %652 : i32
^bb85:
cf.br ^bb86
^bb86:
%654 = arith.extsi %arg1 : i32 to i64
%655 = llvm.getelementptr %arg0[%654] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%653 = llvm.load %655 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%656 = arith.extsi %arg1 : i32 to i64
%657 = llvm.getelementptr %arg0[%656] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%658 = llvm.getelementptr %657[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%659 = llvm.load %658 : !llvm.ptr -> i32
%661 = arith.extsi %arg2 : i32 to i64
%662 = llvm.getelementptr %arg0[%661] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%660 = llvm.load %662 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%663 = arith.extsi %arg2 : i32 to i64
%664 = llvm.getelementptr %arg0[%663] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%665 = llvm.getelementptr %664[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%666 = llvm.load %665 : !llvm.ptr -> i32
%667 = arith.cmpi ne, %659, %666 : i32
cf.cond_br %667, ^bb87, ^bb88
^bb87:
%669 = arith.extsi %arg1 : i32 to i64
%670 = llvm.getelementptr %arg0[%669] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%668 = llvm.load %670 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%671 = arith.extsi %arg1 : i32 to i64
%672 = llvm.getelementptr %arg0[%671] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%673 = llvm.getelementptr %672[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%674 = llvm.load %673 : !llvm.ptr -> i32
%676 = arith.extsi %arg2 : i32 to i64
%677 = llvm.getelementptr %arg0[%676] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%675 = llvm.load %677 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%678 = arith.extsi %arg2 : i32 to i64
%679 = llvm.getelementptr %arg0[%678] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%680 = llvm.getelementptr %679[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%681 = llvm.load %680 : !llvm.ptr -> i32
%682 = arith.subi %674, %681 : i32
func.return %682 : i32
^bb88:
cf.br ^bb89
^bb89:
%684 = arith.extsi %arg1 : i32 to i64
%685 = llvm.getelementptr %arg0[%684] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%683 = llvm.load %685 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%686 = arith.extsi %arg1 : i32 to i64
%687 = llvm.getelementptr %arg0[%686] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%688 = llvm.getelementptr %687[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%689 = llvm.load %688 : !llvm.ptr -> i32
%691 = arith.extsi %arg2 : i32 to i64
%692 = llvm.getelementptr %arg0[%691] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%690 = llvm.load %692 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%693 = arith.extsi %arg2 : i32 to i64
%694 = llvm.getelementptr %arg0[%693] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%695 = llvm.getelementptr %694[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%696 = llvm.load %695 : !llvm.ptr -> i32
%697 = arith.cmpi ne, %689, %696 : i32
cf.cond_br %697, ^bb90, ^bb91
^bb90:
%699 = arith.extsi %arg1 : i32 to i64
%700 = llvm.getelementptr %arg0[%699] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%698 = llvm.load %700 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%701 = arith.extsi %arg1 : i32 to i64
%702 = llvm.getelementptr %arg0[%701] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%703 = llvm.getelementptr %702[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%704 = llvm.load %703 : !llvm.ptr -> i32
%706 = arith.extsi %arg2 : i32 to i64
%707 = llvm.getelementptr %arg0[%706] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%705 = llvm.load %707 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%708 = arith.extsi %arg2 : i32 to i64
%709 = llvm.getelementptr %arg0[%708] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%710 = llvm.getelementptr %709[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%711 = llvm.load %710 : !llvm.ptr -> i32
%712 = arith.subi %704, %711 : i32
func.return %712 : i32
^bb91:
cf.br ^bb92
^bb92:
%714 = arith.extsi %arg1 : i32 to i64
%715 = llvm.getelementptr %arg0[%714] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%713 = llvm.load %715 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%716 = arith.extsi %arg1 : i32 to i64
%717 = llvm.getelementptr %arg0[%716] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%718 = llvm.getelementptr %717[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%719 = llvm.load %718 : !llvm.ptr -> i32
%721 = arith.extsi %arg2 : i32 to i64
%722 = llvm.getelementptr %arg0[%721] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%720 = llvm.load %722 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%723 = arith.extsi %arg2 : i32 to i64
%724 = llvm.getelementptr %arg0[%723] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%725 = llvm.getelementptr %724[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%726 = llvm.load %725 : !llvm.ptr -> i32
%727 = arith.cmpi ne, %719, %726 : i32
cf.cond_br %727, ^bb93, ^bb94
^bb93:
%729 = arith.extsi %arg1 : i32 to i64
%730 = llvm.getelementptr %arg0[%729] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%728 = llvm.load %730 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%731 = arith.extsi %arg1 : i32 to i64
%732 = llvm.getelementptr %arg0[%731] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%733 = llvm.getelementptr %732[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%734 = llvm.load %733 : !llvm.ptr -> i32
%736 = arith.extsi %arg2 : i32 to i64
%737 = llvm.getelementptr %arg0[%736] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%735 = llvm.load %737 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%738 = arith.extsi %arg2 : i32 to i64
%739 = llvm.getelementptr %arg0[%738] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%740 = llvm.getelementptr %739[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%741 = llvm.load %740 : !llvm.ptr -> i32
%742 = arith.subi %734, %741 : i32
func.return %742 : i32
^bb94:
cf.br ^bb95
^bb95:
%744 = arith.extsi %arg1 : i32 to i64
%745 = llvm.getelementptr %arg0[%744] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%743 = llvm.load %745 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%746 = arith.extsi %arg1 : i32 to i64
%747 = llvm.getelementptr %arg0[%746] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%748 = llvm.getelementptr %747[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%749 = llvm.load %748 : !llvm.ptr -> i32
%751 = arith.extsi %arg2 : i32 to i64
%752 = llvm.getelementptr %arg0[%751] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%750 = llvm.load %752 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%753 = arith.extsi %arg2 : i32 to i64
%754 = llvm.getelementptr %arg0[%753] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%755 = llvm.getelementptr %754[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%756 = llvm.load %755 : !llvm.ptr -> i32
%757 = arith.subi %749, %756 : i32
func.return %757 : i32
}
func.func @swap_right(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> () {
%759 = arith.extsi %arg1 : i32 to i64
%760 = llvm.getelementptr %arg0[%759] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%758 = llvm.load %760 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%761 = arith.extsi %arg1 : i32 to i64
%762 = llvm.getelementptr %arg0[%761] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%763 = llvm.getelementptr %762[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%764 = llvm.load %763 : !llvm.ptr -> i32
%766 = arith.extsi %arg2 : i32 to i64
%767 = llvm.getelementptr %arg0[%766] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%765 = llvm.load %767 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%768 = arith.extsi %arg2 : i32 to i64
%769 = llvm.getelementptr %arg0[%768] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%770 = llvm.getelementptr %769[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%771 = llvm.load %770 : !llvm.ptr -> i32
%772 = arith.extsi %arg1 : i32 to i64
%773 = llvm.getelementptr %arg0[%772] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%774 = llvm.getelementptr %773[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %771, %774 : i32, !llvm.ptr
%775 = arith.extsi %arg2 : i32 to i64
%776 = llvm.getelementptr %arg0[%775] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%777 = llvm.getelementptr %776[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %764, %777 : i32, !llvm.ptr
%779 = arith.extsi %arg1 : i32 to i64
%780 = llvm.getelementptr %arg0[%779] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%778 = llvm.load %780 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%781 = arith.extsi %arg1 : i32 to i64
%782 = llvm.getelementptr %arg0[%781] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%783 = llvm.getelementptr %782[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%784 = llvm.load %783 : !llvm.ptr -> i32
%786 = arith.extsi %arg2 : i32 to i64
%787 = llvm.getelementptr %arg0[%786] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%785 = llvm.load %787 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%788 = arith.extsi %arg2 : i32 to i64
%789 = llvm.getelementptr %arg0[%788] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%790 = llvm.getelementptr %789[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%791 = llvm.load %790 : !llvm.ptr -> i32
%792 = arith.extsi %arg1 : i32 to i64
%793 = llvm.getelementptr %arg0[%792] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%794 = llvm.getelementptr %793[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %791, %794 : i32, !llvm.ptr
%795 = arith.extsi %arg2 : i32 to i64
%796 = llvm.getelementptr %arg0[%795] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%797 = llvm.getelementptr %796[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %784, %797 : i32, !llvm.ptr
%799 = arith.extsi %arg1 : i32 to i64
%800 = llvm.getelementptr %arg0[%799] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%798 = llvm.load %800 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%801 = arith.extsi %arg1 : i32 to i64
%802 = llvm.getelementptr %arg0[%801] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%803 = llvm.getelementptr %802[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%804 = llvm.load %803 : !llvm.ptr -> i32
%806 = arith.extsi %arg2 : i32 to i64
%807 = llvm.getelementptr %arg0[%806] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%805 = llvm.load %807 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%808 = arith.extsi %arg2 : i32 to i64
%809 = llvm.getelementptr %arg0[%808] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%810 = llvm.getelementptr %809[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%811 = llvm.load %810 : !llvm.ptr -> i32
%812 = arith.extsi %arg1 : i32 to i64
%813 = llvm.getelementptr %arg0[%812] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%814 = llvm.getelementptr %813[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %811, %814 : i32, !llvm.ptr
%815 = arith.extsi %arg2 : i32 to i64
%816 = llvm.getelementptr %arg0[%815] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%817 = llvm.getelementptr %816[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %804, %817 : i32, !llvm.ptr
%819 = arith.extsi %arg1 : i32 to i64
%820 = llvm.getelementptr %arg0[%819] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%818 = llvm.load %820 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%821 = arith.extsi %arg1 : i32 to i64
%822 = llvm.getelementptr %arg0[%821] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%823 = llvm.getelementptr %822[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%824 = llvm.load %823 : !llvm.ptr -> i32
%826 = arith.extsi %arg2 : i32 to i64
%827 = llvm.getelementptr %arg0[%826] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%825 = llvm.load %827 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%828 = arith.extsi %arg2 : i32 to i64
%829 = llvm.getelementptr %arg0[%828] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%830 = llvm.getelementptr %829[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%831 = llvm.load %830 : !llvm.ptr -> i32
%832 = arith.extsi %arg1 : i32 to i64
%833 = llvm.getelementptr %arg0[%832] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%834 = llvm.getelementptr %833[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %831, %834 : i32, !llvm.ptr
%835 = arith.extsi %arg2 : i32 to i64
%836 = llvm.getelementptr %arg0[%835] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%837 = llvm.getelementptr %836[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %824, %837 : i32, !llvm.ptr
%839 = arith.extsi %arg1 : i32 to i64
%840 = llvm.getelementptr %arg0[%839] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%838 = llvm.load %840 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%841 = arith.extsi %arg1 : i32 to i64
%842 = llvm.getelementptr %arg0[%841] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%843 = llvm.getelementptr %842[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%844 = llvm.load %843 : !llvm.ptr -> i32
%846 = arith.extsi %arg2 : i32 to i64
%847 = llvm.getelementptr %arg0[%846] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%845 = llvm.load %847 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%848 = arith.extsi %arg2 : i32 to i64
%849 = llvm.getelementptr %arg0[%848] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%850 = llvm.getelementptr %849[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%851 = llvm.load %850 : !llvm.ptr -> i32
%852 = arith.extsi %arg1 : i32 to i64
%853 = llvm.getelementptr %arg0[%852] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%854 = llvm.getelementptr %853[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %851, %854 : i32, !llvm.ptr
%855 = arith.extsi %arg2 : i32 to i64
%856 = llvm.getelementptr %arg0[%855] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%857 = llvm.getelementptr %856[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %844, %857 : i32, !llvm.ptr
%859 = arith.extsi %arg1 : i32 to i64
%860 = llvm.getelementptr %arg0[%859] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%858 = llvm.load %860 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%861 = arith.extsi %arg1 : i32 to i64
%862 = llvm.getelementptr %arg0[%861] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%863 = llvm.getelementptr %862[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%864 = llvm.load %863 : !llvm.ptr -> i32
%866 = arith.extsi %arg2 : i32 to i64
%867 = llvm.getelementptr %arg0[%866] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%865 = llvm.load %867 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%868 = arith.extsi %arg2 : i32 to i64
%869 = llvm.getelementptr %arg0[%868] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%870 = llvm.getelementptr %869[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%871 = llvm.load %870 : !llvm.ptr -> i32
%872 = arith.extsi %arg1 : i32 to i64
%873 = llvm.getelementptr %arg0[%872] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%874 = llvm.getelementptr %873[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %871, %874 : i32, !llvm.ptr
%875 = arith.extsi %arg2 : i32 to i64
%876 = llvm.getelementptr %arg0[%875] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%877 = llvm.getelementptr %876[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %864, %877 : i32, !llvm.ptr
%879 = arith.extsi %arg1 : i32 to i64
%880 = llvm.getelementptr %arg0[%879] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%878 = llvm.load %880 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%881 = arith.extsi %arg1 : i32 to i64
%882 = llvm.getelementptr %arg0[%881] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%883 = llvm.getelementptr %882[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%884 = llvm.load %883 : !llvm.ptr -> i64
%886 = arith.extsi %arg2 : i32 to i64
%887 = llvm.getelementptr %arg0[%886] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%885 = llvm.load %887 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%888 = arith.extsi %arg2 : i32 to i64
%889 = llvm.getelementptr %arg0[%888] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%890 = llvm.getelementptr %889[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%891 = llvm.load %890 : !llvm.ptr -> i64
%892 = arith.extsi %arg1 : i32 to i64
%893 = llvm.getelementptr %arg0[%892] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%894 = llvm.getelementptr %893[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %891, %894 : i64, !llvm.ptr
%895 = arith.extsi %arg2 : i32 to i64
%896 = llvm.getelementptr %arg0[%895] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%897 = llvm.getelementptr %896[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %884, %897 : i64, !llvm.ptr
func.return
}
func.func @sift_down_right(%arg0: !llvm.ptr, %arg1: i32, %arg2: i32) -> () {
%898 = llvm.mlir.constant(1 : i64) : i64
%899 = llvm.alloca %898 x i32 : (i64) -> !llvm.ptr
llvm.store %arg1, %899 : i32, !llvm.ptr
cf.br ^bb96
^bb96:
%900 = arith.constant 1 : i1
cf.cond_br %900, ^bb97, ^bb98
^bb97:
%901 = llvm.load %899 : !llvm.ptr -> i32
%902 = llvm.mlir.constant(1 : i64) : i64
%903 = llvm.alloca %902 x i32 : (i64) -> !llvm.ptr
llvm.store %901, %903 : i32, !llvm.ptr
%904 = arith.constant 2 : i32
%905 = llvm.load %899 : !llvm.ptr -> i32
%906 = arith.muli %904, %905 : i32
%907 = arith.constant 1 : i32
%908 = arith.addi %906, %907 : i32
%909 = arith.constant 2 : i32
%910 = llvm.load %899 : !llvm.ptr -> i32
%911 = arith.muli %909, %910 : i32
%912 = arith.constant 2 : i32
%913 = arith.addi %911, %912 : i32
%914 = arith.cmpi slt, %908, %arg2 : i32
cf.cond_br %914, ^bb99, ^bb100
^bb99:
%916 = llvm.load %903 : !llvm.ptr -> i32
%915 = func.call @cmp_right_at(%arg0, %908, %916) : (!llvm.ptr, i32, i32) -> i32
%917 = arith.constant 0 : i32
%918 = arith.cmpi sgt, %915, %917 : i32
cf.cond_br %918, ^bb102, ^bb103
^bb102:
llvm.store %908, %903 : i32, !llvm.ptr
cf.br ^bb104
^bb103:
cf.br ^bb104
^bb104:
cf.br ^bb101
^bb100:
cf.br ^bb101
^bb101:
%919 = arith.cmpi slt, %913, %arg2 : i32
cf.cond_br %919, ^bb105, ^bb106
^bb105:
%921 = llvm.load %903 : !llvm.ptr -> i32
%920 = func.call @cmp_right_at(%arg0, %913, %921) : (!llvm.ptr, i32, i32) -> i32
%922 = arith.constant 0 : i32
%923 = arith.cmpi sgt, %920, %922 : i32
cf.cond_br %923, ^bb108, ^bb109
^bb108:
llvm.store %913, %903 : i32, !llvm.ptr
cf.br ^bb110
^bb109:
cf.br ^bb110
^bb110:
cf.br ^bb107
^bb106:
cf.br ^bb107
^bb107:
%924 = llvm.load %903 : !llvm.ptr -> i32
%925 = llvm.load %899 : !llvm.ptr -> i32
%926 = arith.cmpi eq, %924, %925 : i32
cf.cond_br %926, ^bb111, ^bb112
^bb111:
cf.br ^bb98
^bb112:
cf.br ^bb113
^bb113:
%928 = llvm.load %899 : !llvm.ptr -> i32
%929 = llvm.load %903 : !llvm.ptr -> i32
func.call @swap_right(%arg0, %928, %929) : (!llvm.ptr, i32, i32) -> ()
%930 = llvm.load %903 : !llvm.ptr -> i32
llvm.store %930, %899 : i32, !llvm.ptr
cf.br ^bb96
^bb98:
func.return
}
func.func @heapsort_right(%arg0: !llvm.ptr, %arg1: i32) -> () {
%931 = arith.constant 1 : i32
%932 = arith.cmpi sle, %arg1, %931 : i32
cf.cond_br %932, ^bb114, ^bb115
^bb114:
func.return
^bb115:
cf.br ^bb116
^bb116:
%933 = arith.constant 2 : i32
%934 = arith.divsi %arg1, %933 : i32
%935 = arith.constant 1 : i32
%936 = arith.subi %934, %935 : i32
%937 = llvm.mlir.constant(1 : i64) : i64
%938 = llvm.alloca %937 x i32 : (i64) -> !llvm.ptr
llvm.store %936, %938 : i32, !llvm.ptr
cf.br ^bb117
^bb117:
%939 = llvm.load %938 : !llvm.ptr -> i32
%940 = arith.constant 0 : i32
%941 = arith.cmpi sge, %939, %940 : i32
cf.cond_br %941, ^bb118, ^bb119
^bb118:
%943 = llvm.load %938 : !llvm.ptr -> i32
func.call @sift_down_right(%arg0, %943, %arg1) : (!llvm.ptr, i32, i32) -> ()
%944 = llvm.load %938 : !llvm.ptr -> i32
%945 = arith.constant 1 : i32
%946 = arith.subi %944, %945 : i32
llvm.store %946, %938 : i32, !llvm.ptr
cf.br ^bb117
^bb119:
%947 = arith.constant 1 : i32
%948 = arith.subi %arg1, %947 : i32
llvm.store %948, %938 : i32, !llvm.ptr
cf.br ^bb120
^bb120:
%949 = llvm.load %938 : !llvm.ptr -> i32
%950 = arith.constant 0 : i32
%951 = arith.cmpi sgt, %949, %950 : i32
cf.cond_br %951, ^bb121, ^bb122
^bb121:
%953 = arith.constant 0 : i32
%954 = llvm.load %938 : !llvm.ptr -> i32
func.call @swap_right(%arg0, %953, %954) : (!llvm.ptr, i32, i32) -> ()
%956 = arith.constant 0 : i32
%957 = llvm.load %938 : !llvm.ptr -> i32
func.call @sift_down_right(%arg0, %956, %957) : (!llvm.ptr, i32, i32) -> ()
%958 = llvm.load %938 : !llvm.ptr -> i32
%959 = arith.constant 1 : i32
%960 = arith.subi %958, %959 : i32
llvm.store %960, %938 : i32, !llvm.ptr
cf.br ^bb120
^bb122:
func.return
}
func.func @enumerate_left() -> () {
%961 = arith.constant 0 : i32
cf.br ^bb123(%961 : i32)
^bb123(%962: i32):
%963 = arith.constant 5 : i32
%964 = arith.cmpi slt, %962, %963 : i32
cf.cond_br %964, ^bb124(%962 : i32), ^bb125(%962 : i32)
^bb124(%965: i32):
%966 = arith.constant 0 : i32
cf.br ^bb126(%966 : i32)
^bb126(%967: i32):
%968 = arith.constant 5 : i32
%969 = arith.cmpi slt, %967, %968 : i32
cf.cond_br %969, ^bb127(%967 : i32), ^bb128(%967 : i32)
^bb127(%970: i32):
%971 = arith.constant 0 : i32
cf.br ^bb129(%971 : i32)
^bb129(%972: i32):
%973 = arith.constant 5 : i32
%974 = arith.cmpi slt, %972, %973 : i32
cf.cond_br %974, ^bb130(%972 : i32), ^bb131(%972 : i32)
^bb130(%975: i32):
%976 = arith.constant 0 : i32
cf.br ^bb132(%976 : i32)
^bb132(%977: i32):
%978 = arith.constant 5 : i32
%979 = arith.cmpi slt, %977, %978 : i32
cf.cond_br %979, ^bb133(%977 : i32), ^bb134(%977 : i32)
^bb133(%980: i32):
%981 = arith.constant 0 : i32
cf.br ^bb135(%981 : i32)
^bb135(%982: i32):
%983 = arith.constant 5 : i32
%984 = arith.cmpi slt, %982, %983 : i32
cf.cond_br %984, ^bb136(%982 : i32), ^bb137(%982 : i32)
^bb136(%985: i32):
%986 = arith.constant 0 : i32
cf.br ^bb138(%986 : i32)
^bb138(%987: i32):
%988 = arith.constant 5 : i32
%989 = arith.cmpi slt, %987, %988 : i32
cf.cond_br %989, ^bb139(%987 : i32), ^bb140(%987 : i32)
^bb139(%990: i32):
%991 = arith.constant 0 : i32
cf.br ^bb141(%991 : i32)
^bb141(%992: i32):
%993 = arith.constant 5 : i32
%994 = arith.cmpi slt, %992, %993 : i32
cf.cond_br %994, ^bb142(%992 : i32), ^bb143(%992 : i32)
^bb142(%995: i32):
%997 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%998 = llvm.load %997 : !llvm.ptr -> !llvm.ptr
%999 = arith.extsi %965 : i32 to i64
%1000 = llvm.getelementptr %998[%999] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%996 = llvm.load %1000 : !llvm.ptr -> i32
%1001 = arith.extsi %996 : i32 to i64
%1003 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1004 = llvm.load %1003 : !llvm.ptr -> !llvm.ptr
%1005 = arith.extsi %970 : i32 to i64
%1006 = llvm.getelementptr %1004[%1005] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1002 = llvm.load %1006 : !llvm.ptr -> i32
%1007 = arith.extsi %1002 : i32 to i64
%1008 = arith.muli %1001, %1007 : i64
%1010 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1011 = llvm.load %1010 : !llvm.ptr -> !llvm.ptr
%1012 = arith.extsi %975 : i32 to i64
%1013 = llvm.getelementptr %1011[%1012] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1009 = llvm.load %1013 : !llvm.ptr -> i32
%1014 = arith.extsi %1009 : i32 to i64
%1015 = arith.muli %1008, %1014 : i64
%1017 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1018 = llvm.load %1017 : !llvm.ptr -> !llvm.ptr
%1019 = arith.extsi %980 : i32 to i64
%1020 = llvm.getelementptr %1018[%1019] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1016 = llvm.load %1020 : !llvm.ptr -> i32
%1021 = arith.extsi %1016 : i32 to i64
%1022 = arith.muli %1015, %1021 : i64
%1024 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1025 = llvm.load %1024 : !llvm.ptr -> !llvm.ptr
%1026 = arith.extsi %985 : i32 to i64
%1027 = llvm.getelementptr %1025[%1026] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1023 = llvm.load %1027 : !llvm.ptr -> i32
%1028 = arith.extsi %1023 : i32 to i64
%1029 = arith.muli %1022, %1028 : i64
%1031 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1032 = llvm.load %1031 : !llvm.ptr -> !llvm.ptr
%1033 = arith.extsi %990 : i32 to i64
%1034 = llvm.getelementptr %1032[%1033] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1030 = llvm.load %1034 : !llvm.ptr -> i32
%1035 = arith.extsi %1030 : i32 to i64
%1036 = arith.muli %1029, %1035 : i64
%1038 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1039 = llvm.load %1038 : !llvm.ptr -> !llvm.ptr
%1040 = arith.extsi %995 : i32 to i64
%1041 = llvm.getelementptr %1039[%1040] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1037 = llvm.load %1041 : !llvm.ptr -> i32
%1042 = arith.extsi %1037 : i32 to i64
%1043 = arith.muli %1036, %1042 : i64
%1044 = arith.constant 0 : i32
%1046 = arith.extsi %1044 : i32 to i64
%1045 = arith.cmpi eq, %1043, %1046 : i64
cf.cond_br %1045, ^bb144, ^bb145
^bb144:
%1047 = arith.constant 1 : i32
%1048 = arith.addi %995, %1047 : i32
cf.br ^bb141(%1048 : i32)
^bb145:
cf.br ^bb146(%995 : i32)
^bb146(%1049: i32):
%1051 = llvm.mlir.constant(1 : i64) : i64
%1052 = llvm.alloca %1051 x !llvm.array<7 x i32> : (i64) -> !llvm.ptr
%1053 = llvm.mlir.zero : !llvm.array<7 x i32>
llvm.store %1053, %1052 : !llvm.array<7 x i32>, !llvm.ptr
%1054 = llvm.mlir.constant(0 : i64) : i64
%1055 = llvm.getelementptr %1052[0, %1054] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %965, %1055 : i32, !llvm.ptr
%1056 = llvm.mlir.constant(1 : i64) : i64
%1057 = llvm.getelementptr %1052[0, %1056] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %970, %1057 : i32, !llvm.ptr
%1058 = llvm.mlir.constant(2 : i64) : i64
%1059 = llvm.getelementptr %1052[0, %1058] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %975, %1059 : i32, !llvm.ptr
%1060 = llvm.mlir.constant(3 : i64) : i64
%1061 = llvm.getelementptr %1052[0, %1060] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %980, %1061 : i32, !llvm.ptr
%1062 = llvm.mlir.constant(4 : i64) : i64
%1063 = llvm.getelementptr %1052[0, %1062] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %985, %1063 : i32, !llvm.ptr
%1064 = llvm.mlir.constant(5 : i64) : i64
%1065 = llvm.getelementptr %1052[0, %1064] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %990, %1065 : i32, !llvm.ptr
%1066 = llvm.mlir.constant(6 : i64) : i64
%1067 = llvm.getelementptr %1052[0, %1066] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
llvm.store %1049, %1067 : i32, !llvm.ptr
%1068 = arith.constant 1 : i32
%1069 = arith.muli %1068, %965 : i32
%1070 = arith.constant 2 : i32
%1071 = arith.muli %1070, %970 : i32
%1072 = arith.addi %1069, %1071 : i32
%1073 = arith.constant 3 : i32
%1074 = arith.muli %1073, %975 : i32
%1075 = arith.addi %1072, %1074 : i32
%1076 = arith.constant 4 : i32
%1077 = arith.muli %1076, %980 : i32
%1078 = arith.addi %1075, %1077 : i32
%1079 = arith.constant 5 : i32
%1080 = arith.muli %1079, %985 : i32
%1081 = arith.addi %1078, %1080 : i32
%1082 = arith.constant 6 : i32
%1083 = arith.muli %1082, %990 : i32
%1084 = arith.addi %1081, %1083 : i32
%1085 = arith.constant 7 : i32
%1086 = arith.muli %1085, %1049 : i32
%1087 = arith.addi %1084, %1086 : i32
%1088 = arith.constant 1 : i32
%1089 = arith.subi %965, %1088 : i32
%1090 = arith.muli %965, %1089 : i32
%1091 = arith.constant 1 : i32
%1092 = arith.subi %970, %1091 : i32
%1093 = arith.muli %970, %1092 : i32
%1094 = arith.addi %1090, %1093 : i32
%1095 = arith.constant 1 : i32
%1096 = arith.subi %975, %1095 : i32
%1097 = arith.muli %975, %1096 : i32
%1098 = arith.addi %1094, %1097 : i32
%1099 = arith.constant 1 : i32
%1100 = arith.subi %980, %1099 : i32
%1101 = arith.muli %980, %1100 : i32
%1102 = arith.addi %1098, %1101 : i32
%1103 = arith.constant 1 : i32
%1104 = arith.subi %985, %1103 : i32
%1105 = arith.muli %985, %1104 : i32
%1106 = arith.addi %1102, %1105 : i32
%1107 = arith.constant 1 : i32
%1108 = arith.subi %990, %1107 : i32
%1109 = arith.muli %990, %1108 : i32
%1110 = arith.addi %1106, %1109 : i32
%1111 = arith.constant 1 : i32
%1112 = arith.subi %1049, %1111 : i32
%1113 = arith.muli %1049, %1112 : i32
%1114 = arith.addi %1110, %1113 : i32
%1116 = arith.constant 0 : i32
%1117 = arith.constant 0 : i32
%1118 = arith.constant 0 : i32
%1119 = arith.constant 0 : i32
%1120 = arith.constant 0 : i32
%1121 = arith.constant 0 : i32
%1122 = arith.constant 0 : i32
%1123 = arith.constant 0 : i32
%1124 = arith.constant 0 : i32
%1125 = arith.constant 0 : i32
%1126 = arith.constant 0 : i32
%1127 = arith.constant 0 : i32
%1128 = arith.constant 0 : i32
%1129 = arith.constant 0 : i32
%1130 = arith.constant 0 : i32
%1131 = arith.constant 0 : i32
%1132 = llvm.mlir.constant(1 : i64) : i64
%1133 = llvm.alloca %1132 x !llvm.array<16 x i64> : (i64) -> !llvm.ptr
%1134 = llvm.mlir.zero : !llvm.array<16 x i64>
llvm.store %1134, %1133 : !llvm.array<16 x i64>, !llvm.ptr
%1135 = arith.extsi %1116 : i32 to i64
%1136 = arith.extsi %1117 : i32 to i64
%1137 = arith.extsi %1118 : i32 to i64
%1138 = arith.extsi %1119 : i32 to i64
%1139 = arith.extsi %1120 : i32 to i64
%1140 = arith.extsi %1121 : i32 to i64
%1141 = arith.extsi %1122 : i32 to i64
%1142 = arith.extsi %1123 : i32 to i64
%1143 = arith.extsi %1124 : i32 to i64
%1144 = arith.extsi %1125 : i32 to i64
%1145 = arith.extsi %1126 : i32 to i64
%1146 = arith.extsi %1127 : i32 to i64
%1147 = arith.extsi %1128 : i32 to i64
%1148 = arith.extsi %1129 : i32 to i64
%1149 = arith.extsi %1130 : i32 to i64
%1150 = arith.extsi %1131 : i32 to i64
%1151 = llvm.mlir.constant(0 : i64) : i64
%1152 = llvm.getelementptr %1133[0, %1151] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1135, %1152 : i64, !llvm.ptr
%1153 = llvm.mlir.constant(1 : i64) : i64
%1154 = llvm.getelementptr %1133[0, %1153] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1136, %1154 : i64, !llvm.ptr
%1155 = llvm.mlir.constant(2 : i64) : i64
%1156 = llvm.getelementptr %1133[0, %1155] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1137, %1156 : i64, !llvm.ptr
%1157 = llvm.mlir.constant(3 : i64) : i64
%1158 = llvm.getelementptr %1133[0, %1157] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1138, %1158 : i64, !llvm.ptr
%1159 = llvm.mlir.constant(4 : i64) : i64
%1160 = llvm.getelementptr %1133[0, %1159] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1139, %1160 : i64, !llvm.ptr
%1161 = llvm.mlir.constant(5 : i64) : i64
%1162 = llvm.getelementptr %1133[0, %1161] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1140, %1162 : i64, !llvm.ptr
%1163 = llvm.mlir.constant(6 : i64) : i64
%1164 = llvm.getelementptr %1133[0, %1163] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1141, %1164 : i64, !llvm.ptr
%1165 = llvm.mlir.constant(7 : i64) : i64
%1166 = llvm.getelementptr %1133[0, %1165] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1142, %1166 : i64, !llvm.ptr
%1167 = llvm.mlir.constant(8 : i64) : i64
%1168 = llvm.getelementptr %1133[0, %1167] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1143, %1168 : i64, !llvm.ptr
%1169 = llvm.mlir.constant(9 : i64) : i64
%1170 = llvm.getelementptr %1133[0, %1169] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1144, %1170 : i64, !llvm.ptr
%1171 = llvm.mlir.constant(10 : i64) : i64
%1172 = llvm.getelementptr %1133[0, %1171] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1145, %1172 : i64, !llvm.ptr
%1173 = llvm.mlir.constant(11 : i64) : i64
%1174 = llvm.getelementptr %1133[0, %1173] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1146, %1174 : i64, !llvm.ptr
%1175 = llvm.mlir.constant(12 : i64) : i64
%1176 = llvm.getelementptr %1133[0, %1175] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1147, %1176 : i64, !llvm.ptr
%1177 = llvm.mlir.constant(13 : i64) : i64
%1178 = llvm.getelementptr %1133[0, %1177] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1148, %1178 : i64, !llvm.ptr
%1179 = llvm.mlir.constant(14 : i64) : i64
%1180 = llvm.getelementptr %1133[0, %1179] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1149, %1180 : i64, !llvm.ptr
%1181 = llvm.mlir.constant(15 : i64) : i64
%1182 = llvm.getelementptr %1133[0, %1181] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1150, %1182 : i64, !llvm.ptr
%1183 = arith.constant 1 : i32
%1184 = arith.constant 0 : i32
%1185 = arith.extsi %1183 : i32 to i64
%1186 = arith.extsi %1184 : i32 to i64
%1187 = llvm.getelementptr %1133[0, %1186] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
llvm.store %1185, %1187 : i64, !llvm.ptr
%1189 = arith.constant 1 : i32
func.call @dp_update(%1133, %1189, %965) : (!llvm.ptr, i32, i32) -> ()
%1191 = arith.constant 2 : i32
func.call @dp_update(%1133, %1191, %970) : (!llvm.ptr, i32, i32) -> ()
%1193 = arith.constant 3 : i32
func.call @dp_update(%1133, %1193, %975) : (!llvm.ptr, i32, i32) -> ()
%1195 = arith.constant 4 : i32
func.call @dp_update(%1133, %1195, %980) : (!llvm.ptr, i32, i32) -> ()
%1197 = arith.constant 5 : i32
func.call @dp_update(%1133, %1197, %985) : (!llvm.ptr, i32, i32) -> ()
%1199 = arith.constant 6 : i32
func.call @dp_update(%1133, %1199, %990) : (!llvm.ptr, i32, i32) -> ()
%1201 = arith.constant 7 : i32
func.call @dp_update(%1133, %1201, %1049) : (!llvm.ptr, i32, i32) -> ()
%1203 = arith.constant 5 : i32
%1204 = arith.extsi %1203 : i32 to i64
%1205 = llvm.getelementptr %1133[0, %1204] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
%1202 = llvm.load %1205 : !llvm.ptr -> i64
%1206 = arith.trunci %1202 : i64 to i32
%1208 = arith.constant 6 : i32
%1209 = arith.extsi %1208 : i32 to i64
%1210 = llvm.getelementptr %1133[0, %1209] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
%1207 = llvm.load %1210 : !llvm.ptr -> i64
%1211 = arith.trunci %1207 : i64 to i32
%1213 = arith.constant 7 : i32
%1214 = arith.extsi %1213 : i32 to i64
%1215 = llvm.getelementptr %1133[0, %1214] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
%1212 = llvm.load %1215 : !llvm.ptr -> i64
%1216 = arith.trunci %1212 : i64 to i32
%1218 = arith.constant 15 : i32
%1219 = arith.extsi %1218 : i32 to i64
%1220 = llvm.getelementptr %1133[0, %1219] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<16 x i64>
%1217 = llvm.load %1220 : !llvm.ptr -> i64
%1221 = arith.trunci %1217 : i64 to i32
%1222 = arith.constant 170 : i32
%1223 = arith.cmpi sgt, %1221, %1222 : i32
cf.cond_br %1223, ^bb147, ^bb148
^bb147:
%1224 = arith.constant 1 : i32
%1225 = arith.addi %1049, %1224 : i32
cf.br ^bb141(%1225 : i32)
^bb148:
cf.br ^bb149(%1049 : i32)
^bb149(%1226: i32):
%1227 = arith.constant 0 : i32
%1228 = llvm.mlir.constant(1 : i64) : i64
%1229 = llvm.alloca %1228 x i32 : (i64) -> !llvm.ptr
llvm.store %1227, %1229 : i32, !llvm.ptr
%1230 = arith.constant 0 : i32
%1231 = llvm.mlir.constant(1 : i64) : i64
%1232 = llvm.alloca %1231 x i32 : (i64) -> !llvm.ptr
llvm.store %1230, %1232 : i32, !llvm.ptr
%1233 = arith.constant 1 : i32
%1234 = llvm.mlir.constant(1 : i64) : i64
%1235 = llvm.alloca %1234 x i32 : (i64) -> !llvm.ptr
llvm.store %1233, %1235 : i32, !llvm.ptr
%1236 = arith.constant 0 : i32
%1237 = llvm.mlir.constant(1 : i64) : i64
%1238 = llvm.alloca %1237 x i32 : (i64) -> !llvm.ptr
llvm.store %1236, %1238 : i32, !llvm.ptr
cf.br ^bb150
^bb150:
%1239 = llvm.load %1238 : !llvm.ptr -> i32
%1240 = arith.constant 7 : i32
%1241 = arith.cmpi slt, %1239, %1240 : i32
cf.cond_br %1241, ^bb151, ^bb152
^bb151:
%1243 = llvm.load %1238 : !llvm.ptr -> i32
%1244 = arith.extsi %1243 : i32 to i64
%1245 = llvm.getelementptr %1052[0, %1244] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
%1242 = llvm.load %1245 : !llvm.ptr -> i32
%1246 = arith.constant 0 : i32
%1247 = arith.cmpi eq, %1242, %1246 : i32
cf.cond_br %1247, ^bb153, ^bb154
^bb153:
%1248 = llvm.load %1232 : !llvm.ptr -> i32
%1249 = arith.constant 3 : i32
%1250 = arith.cmpi sge, %1248, %1249 : i32
cf.cond_br %1250, ^bb156, ^bb157
^bb156:
%1251 = llvm.load %1229 : !llvm.ptr -> i32
%1252 = llvm.load %1232 : !llvm.ptr -> i32
%1253 = llvm.load %1235 : !llvm.ptr -> i32
%1254 = arith.muli %1252, %1253 : i32
%1255 = arith.addi %1251, %1254 : i32
llvm.store %1255, %1229 : i32, !llvm.ptr
cf.br ^bb158
^bb157:
cf.br ^bb158
^bb158:
%1256 = arith.constant 0 : i32
llvm.store %1256, %1232 : i32, !llvm.ptr
%1257 = arith.constant 1 : i32
llvm.store %1257, %1235 : i32, !llvm.ptr
cf.br ^bb155
^bb154:
%1258 = llvm.load %1232 : !llvm.ptr -> i32
%1259 = arith.constant 1 : i32
%1260 = arith.addi %1258, %1259 : i32
llvm.store %1260, %1232 : i32, !llvm.ptr
%1261 = llvm.load %1235 : !llvm.ptr -> i32
%1263 = llvm.load %1238 : !llvm.ptr -> i32
%1264 = arith.extsi %1263 : i32 to i64
%1265 = llvm.getelementptr %1052[0, %1264] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<7 x i32>
%1262 = llvm.load %1265 : !llvm.ptr -> i32
%1266 = arith.muli %1261, %1262 : i32
llvm.store %1266, %1235 : i32, !llvm.ptr
cf.br ^bb155
^bb155:
%1267 = llvm.load %1238 : !llvm.ptr -> i32
%1268 = arith.constant 1 : i32
%1269 = arith.addi %1267, %1268 : i32
llvm.store %1269, %1238 : i32, !llvm.ptr
cf.br ^bb150
^bb152:
%1270 = llvm.load %1232 : !llvm.ptr -> i32
%1271 = arith.constant 1 : i32
%1272 = llvm.load %1232 : !llvm.ptr -> i32
%1273 = arith.constant 0 : i32
%1274 = arith.cmpi sgt, %1272, %1273 : i32
%1275 = scf.if %1274 -> (i32) {
%1276 = llvm.load %1235 : !llvm.ptr -> i32
scf.yield %1276 : i32
} else {
scf.yield %1271 : i32
}
%1277 = arith.subi %1087, %1114 : i32
%1278 = llvm.load %1229 : !llvm.ptr -> i32
%1279 = arith.subi %1277, %1278 : i32
%1280 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1281 = llvm.load %1280 : !llvm.ptr -> !llvm.ptr
%1282 = llvm.mlir.addressof @n_left : !llvm.ptr
%1283 = llvm.load %1282 : !llvm.ptr -> i32
%1284 = arith.extsi %1283 : i32 to i64
%1285 = llvm.getelementptr %1281[%1284] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1286 = llvm.getelementptr %1285[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1206, %1286 : i32, !llvm.ptr
%1287 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1288 = llvm.load %1287 : !llvm.ptr -> !llvm.ptr
%1289 = llvm.mlir.addressof @n_left : !llvm.ptr
%1290 = llvm.load %1289 : !llvm.ptr -> i32
%1291 = arith.extsi %1290 : i32 to i64
%1292 = llvm.getelementptr %1288[%1291] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1293 = llvm.getelementptr %1292[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1211, %1293 : i32, !llvm.ptr
%1294 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1295 = llvm.load %1294 : !llvm.ptr -> !llvm.ptr
%1296 = llvm.mlir.addressof @n_left : !llvm.ptr
%1297 = llvm.load %1296 : !llvm.ptr -> i32
%1298 = arith.extsi %1297 : i32 to i64
%1299 = llvm.getelementptr %1295[%1298] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1300 = llvm.getelementptr %1299[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1216, %1300 : i32, !llvm.ptr
%1301 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1302 = llvm.load %1301 : !llvm.ptr -> !llvm.ptr
%1303 = llvm.mlir.addressof @n_left : !llvm.ptr
%1304 = llvm.load %1303 : !llvm.ptr -> i32
%1305 = arith.extsi %1304 : i32 to i64
%1306 = llvm.getelementptr %1302[%1305] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1307 = llvm.getelementptr %1306[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1221, %1307 : i32, !llvm.ptr
%1308 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1309 = llvm.load %1308 : !llvm.ptr -> !llvm.ptr
%1310 = llvm.mlir.addressof @n_left : !llvm.ptr
%1311 = llvm.load %1310 : !llvm.ptr -> i32
%1312 = arith.extsi %1311 : i32 to i64
%1313 = llvm.getelementptr %1309[%1312] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1314 = llvm.getelementptr %1313[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1270, %1314 : i32, !llvm.ptr
%1315 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1316 = llvm.load %1315 : !llvm.ptr -> !llvm.ptr
%1317 = llvm.mlir.addressof @n_left : !llvm.ptr
%1318 = llvm.load %1317 : !llvm.ptr -> i32
%1319 = arith.extsi %1318 : i32 to i64
%1320 = llvm.getelementptr %1316[%1319] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1321 = llvm.getelementptr %1320[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1275, %1321 : i32, !llvm.ptr
%1322 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1323 = llvm.load %1322 : !llvm.ptr -> !llvm.ptr
%1324 = llvm.mlir.addressof @n_left : !llvm.ptr
%1325 = llvm.load %1324 : !llvm.ptr -> i32
%1326 = arith.extsi %1325 : i32 to i64
%1327 = llvm.getelementptr %1323[%1326] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1328 = llvm.getelementptr %1327[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1279, %1328 : i32, !llvm.ptr
%1329 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1330 = llvm.load %1329 : !llvm.ptr -> !llvm.ptr
%1331 = llvm.mlir.addressof @n_left : !llvm.ptr
%1332 = llvm.load %1331 : !llvm.ptr -> i32
%1333 = arith.extsi %1332 : i32 to i64
%1334 = llvm.getelementptr %1330[%1333] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1335 = llvm.getelementptr %1334[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1043, %1335 : i64, !llvm.ptr
%1336 = llvm.mlir.addressof @n_left : !llvm.ptr
%1337 = llvm.load %1336 : !llvm.ptr -> i32
%1338 = arith.constant 1 : i32
%1339 = arith.addi %1337, %1338 : i32
%1340 = llvm.mlir.addressof @n_left : !llvm.ptr
llvm.store %1339, %1340 : i32, !llvm.ptr
%1341 = arith.constant 1 : i32
%1342 = arith.addi %1226, %1341 : i32
cf.br ^bb141(%1342 : i32)
^bb143(%1343: i32):
%1344 = arith.constant 1 : i32
%1345 = arith.addi %990, %1344 : i32
cf.br ^bb138(%1345 : i32)
^bb140(%1346: i32):
%1347 = arith.constant 1 : i32
%1348 = arith.addi %985, %1347 : i32
cf.br ^bb135(%1348 : i32)
^bb137(%1349: i32):
%1350 = arith.constant 1 : i32
%1351 = arith.addi %980, %1350 : i32
cf.br ^bb132(%1351 : i32)
^bb134(%1352: i32):
%1353 = arith.constant 1 : i32
%1354 = arith.addi %975, %1353 : i32
cf.br ^bb129(%1354 : i32)
^bb131(%1355: i32):
%1356 = arith.constant 1 : i32
%1357 = arith.addi %970, %1356 : i32
cf.br ^bb126(%1357 : i32)
^bb128(%1358: i32):
%1359 = arith.constant 1 : i32
%1360 = arith.addi %965, %1359 : i32
cf.br ^bb123(%1360 : i32)
^bb125(%1361: i32):
func.return
}
func.func @enumerate_right() -> () {
%1362 = arith.constant 0 : i32
cf.br ^bb159(%1362 : i32)
^bb159(%1363: i32):
%1364 = arith.constant 5 : i32
%1365 = arith.cmpi slt, %1363, %1364 : i32
cf.cond_br %1365, ^bb160(%1363 : i32), ^bb161(%1363 : i32)
^bb160(%1366: i32):
%1367 = arith.constant 0 : i32
cf.br ^bb162(%1367 : i32)
^bb162(%1368: i32):
%1369 = arith.constant 5 : i32
%1370 = arith.cmpi slt, %1368, %1369 : i32
cf.cond_br %1370, ^bb163(%1368 : i32), ^bb164(%1368 : i32)
^bb163(%1371: i32):
%1372 = arith.constant 0 : i32
cf.br ^bb165(%1372 : i32)
^bb165(%1373: i32):
%1374 = arith.constant 5 : i32
%1375 = arith.cmpi slt, %1373, %1374 : i32
cf.cond_br %1375, ^bb166(%1373 : i32), ^bb167(%1373 : i32)
^bb166(%1376: i32):
%1377 = arith.constant 0 : i32
cf.br ^bb168(%1377 : i32)
^bb168(%1378: i32):
%1379 = arith.constant 5 : i32
%1380 = arith.cmpi slt, %1378, %1379 : i32
cf.cond_br %1380, ^bb169(%1378 : i32), ^bb170(%1378 : i32)
^bb169(%1381: i32):
%1382 = arith.constant 0 : i32
cf.br ^bb171(%1382 : i32)
^bb171(%1383: i32):
%1384 = arith.constant 5 : i32
%1385 = arith.cmpi slt, %1383, %1384 : i32
cf.cond_br %1385, ^bb172(%1383 : i32), ^bb173(%1383 : i32)
^bb172(%1386: i32):
%1387 = arith.constant 0 : i32
cf.br ^bb174(%1387 : i32)
^bb174(%1388: i32):
%1389 = arith.constant 5 : i32
%1390 = arith.cmpi slt, %1388, %1389 : i32
cf.cond_br %1390, ^bb175(%1388 : i32), ^bb176(%1388 : i32)
^bb175(%1391: i32):
%1393 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1394 = llvm.load %1393 : !llvm.ptr -> !llvm.ptr
%1395 = arith.extsi %1366 : i32 to i64
%1396 = llvm.getelementptr %1394[%1395] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1392 = llvm.load %1396 : !llvm.ptr -> i32
%1397 = arith.extsi %1392 : i32 to i64
%1399 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1400 = llvm.load %1399 : !llvm.ptr -> !llvm.ptr
%1401 = arith.extsi %1371 : i32 to i64
%1402 = llvm.getelementptr %1400[%1401] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1398 = llvm.load %1402 : !llvm.ptr -> i32
%1403 = arith.extsi %1398 : i32 to i64
%1404 = arith.muli %1397, %1403 : i64
%1406 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1407 = llvm.load %1406 : !llvm.ptr -> !llvm.ptr
%1408 = arith.extsi %1376 : i32 to i64
%1409 = llvm.getelementptr %1407[%1408] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1405 = llvm.load %1409 : !llvm.ptr -> i32
%1410 = arith.extsi %1405 : i32 to i64
%1411 = arith.muli %1404, %1410 : i64
%1413 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1414 = llvm.load %1413 : !llvm.ptr -> !llvm.ptr
%1415 = arith.extsi %1381 : i32 to i64
%1416 = llvm.getelementptr %1414[%1415] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1412 = llvm.load %1416 : !llvm.ptr -> i32
%1417 = arith.extsi %1412 : i32 to i64
%1418 = arith.muli %1411, %1417 : i64
%1420 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1421 = llvm.load %1420 : !llvm.ptr -> !llvm.ptr
%1422 = arith.extsi %1386 : i32 to i64
%1423 = llvm.getelementptr %1421[%1422] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1419 = llvm.load %1423 : !llvm.ptr -> i32
%1424 = arith.extsi %1419 : i32 to i64
%1425 = arith.muli %1418, %1424 : i64
%1427 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1428 = llvm.load %1427 : !llvm.ptr -> !llvm.ptr
%1429 = arith.extsi %1391 : i32 to i64
%1430 = llvm.getelementptr %1428[%1429] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1426 = llvm.load %1430 : !llvm.ptr -> i32
%1431 = arith.extsi %1426 : i32 to i64
%1432 = arith.muli %1425, %1431 : i64
%1433 = arith.constant 0 : i32
%1435 = arith.extsi %1433 : i32 to i64
%1434 = arith.cmpi eq, %1432, %1435 : i64
cf.cond_br %1434, ^bb177, ^bb178
^bb177:
%1436 = arith.constant 1 : i32
%1437 = arith.addi %1391, %1436 : i32
cf.br ^bb174(%1437 : i32)
^bb178:
cf.br ^bb179(%1391 : i32)
^bb179(%1438: i32):
%1439 = arith.addi %1376, %1381 : i32
%1440 = arith.addi %1439, %1386 : i32
%1441 = arith.addi %1440, %1438 : i32
%1442 = arith.constant 8 : i32
%1443 = arith.muli %1442, %1366 : i32
%1444 = arith.constant 9 : i32
%1445 = arith.muli %1444, %1371 : i32
%1446 = arith.addi %1443, %1445 : i32
%1447 = arith.constant 10 : i32
%1448 = arith.muli %1447, %1441 : i32
%1449 = arith.addi %1446, %1448 : i32
%1450 = arith.constant 1 : i32
%1451 = arith.subi %1366, %1450 : i32
%1452 = arith.muli %1366, %1451 : i32
%1453 = arith.constant 1 : i32
%1454 = arith.subi %1371, %1453 : i32
%1455 = arith.muli %1371, %1454 : i32
%1456 = arith.addi %1452, %1455 : i32
%1457 = arith.constant 1 : i32
%1458 = arith.subi %1376, %1457 : i32
%1459 = arith.muli %1376, %1458 : i32
%1460 = arith.addi %1456, %1459 : i32
%1461 = arith.constant 1 : i32
%1462 = arith.subi %1381, %1461 : i32
%1463 = arith.muli %1381, %1462 : i32
%1464 = arith.addi %1460, %1463 : i32
%1465 = arith.constant 1 : i32
%1466 = arith.subi %1386, %1465 : i32
%1467 = arith.muli %1386, %1466 : i32
%1468 = arith.addi %1464, %1467 : i32
%1469 = arith.constant 1 : i32
%1470 = arith.subi %1438, %1469 : i32
%1471 = arith.muli %1438, %1470 : i32
%1472 = arith.addi %1468, %1471 : i32
%1474 = llvm.mlir.constant(1 : i64) : i64
%1475 = llvm.alloca %1474 x !llvm.array<6 x i32> : (i64) -> !llvm.ptr
%1476 = llvm.mlir.zero : !llvm.array<6 x i32>
llvm.store %1476, %1475 : !llvm.array<6 x i32>, !llvm.ptr
%1477 = llvm.mlir.constant(0 : i64) : i64
%1478 = llvm.getelementptr %1475[0, %1477] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1366, %1478 : i32, !llvm.ptr
%1479 = llvm.mlir.constant(1 : i64) : i64
%1480 = llvm.getelementptr %1475[0, %1479] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1371, %1480 : i32, !llvm.ptr
%1481 = llvm.mlir.constant(2 : i64) : i64
%1482 = llvm.getelementptr %1475[0, %1481] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1376, %1482 : i32, !llvm.ptr
%1483 = llvm.mlir.constant(3 : i64) : i64
%1484 = llvm.getelementptr %1475[0, %1483] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1381, %1484 : i32, !llvm.ptr
%1485 = llvm.mlir.constant(4 : i64) : i64
%1486 = llvm.getelementptr %1475[0, %1485] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1386, %1486 : i32, !llvm.ptr
%1487 = llvm.mlir.constant(5 : i64) : i64
%1488 = llvm.getelementptr %1475[0, %1487] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
llvm.store %1438, %1488 : i32, !llvm.ptr
%1489 = arith.constant 0 : i32
%1490 = llvm.mlir.constant(1 : i64) : i64
%1491 = llvm.alloca %1490 x i32 : (i64) -> !llvm.ptr
llvm.store %1489, %1491 : i32, !llvm.ptr
%1492 = arith.constant 1 : i32
%1493 = llvm.mlir.constant(1 : i64) : i64
%1494 = llvm.alloca %1493 x i32 : (i64) -> !llvm.ptr
llvm.store %1492, %1494 : i32, !llvm.ptr
%1495 = arith.constant 0 : i32
%1496 = llvm.mlir.constant(1 : i64) : i64
%1497 = llvm.alloca %1496 x i32 : (i64) -> !llvm.ptr
llvm.store %1495, %1497 : i32, !llvm.ptr
cf.br ^bb180
^bb180:
%1498 = llvm.load %1497 : !llvm.ptr -> i32
%1499 = arith.constant 6 : i32
%1500 = arith.cmpi slt, %1498, %1499 : i32
cf.cond_br %1500, ^bb181, ^bb182
^bb181:
%1502 = llvm.load %1497 : !llvm.ptr -> i32
%1503 = arith.extsi %1502 : i32 to i64
%1504 = llvm.getelementptr %1475[0, %1503] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
%1501 = llvm.load %1504 : !llvm.ptr -> i32
%1505 = arith.constant 0 : i32
%1506 = arith.cmpi eq, %1501, %1505 : i32
cf.cond_br %1506, ^bb183, ^bb184
^bb183:
cf.br ^bb182
^bb184:
cf.br ^bb185
^bb185:
%1507 = llvm.load %1491 : !llvm.ptr -> i32
%1508 = arith.constant 1 : i32
%1509 = arith.addi %1507, %1508 : i32
llvm.store %1509, %1491 : i32, !llvm.ptr
%1510 = llvm.load %1494 : !llvm.ptr -> i32
%1512 = llvm.load %1497 : !llvm.ptr -> i32
%1513 = arith.extsi %1512 : i32 to i64
%1514 = llvm.getelementptr %1475[0, %1513] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
%1511 = llvm.load %1514 : !llvm.ptr -> i32
%1515 = arith.muli %1510, %1511 : i32
llvm.store %1515, %1494 : i32, !llvm.ptr
%1516 = llvm.load %1497 : !llvm.ptr -> i32
%1517 = arith.constant 1 : i32
%1518 = arith.addi %1516, %1517 : i32
llvm.store %1518, %1497 : i32, !llvm.ptr
cf.br ^bb180
^bb182:
%1519 = llvm.load %1491 : !llvm.ptr -> i32
%1520 = arith.constant 0 : i32
%1521 = arith.cmpi eq, %1519, %1520 : i32
cf.cond_br %1521, ^bb186, ^bb187
^bb186:
%1522 = arith.constant 0 : i32
llvm.store %1522, %1491 : i32, !llvm.ptr
%1523 = arith.constant 1 : i32
llvm.store %1523, %1494 : i32, !llvm.ptr
cf.br ^bb188
^bb187:
cf.br ^bb188
^bb188:
%1524 = arith.constant 0 : i32
%1525 = llvm.mlir.constant(1 : i64) : i64
%1526 = llvm.alloca %1525 x i32 : (i64) -> !llvm.ptr
llvm.store %1524, %1526 : i32, !llvm.ptr
%1527 = arith.constant 0 : i32
%1528 = llvm.mlir.constant(1 : i64) : i64
%1529 = llvm.alloca %1528 x i32 : (i64) -> !llvm.ptr
llvm.store %1527, %1529 : i32, !llvm.ptr
%1530 = arith.constant 1 : i32
%1531 = llvm.mlir.constant(1 : i64) : i64
%1532 = llvm.alloca %1531 x i32 : (i64) -> !llvm.ptr
llvm.store %1530, %1532 : i32, !llvm.ptr
%1533 = arith.constant 1 : i32
%1535 = arith.constant 0 : i32
%1534 = arith.subi %1535, %1533 : i32
%1536 = llvm.mlir.constant(1 : i64) : i64
%1537 = llvm.alloca %1536 x i32 : (i64) -> !llvm.ptr
llvm.store %1534, %1537 : i32, !llvm.ptr
%1538 = arith.constant 0 : i32
llvm.store %1538, %1497 : i32, !llvm.ptr
cf.br ^bb189
^bb189:
%1539 = llvm.load %1497 : !llvm.ptr -> i32
%1540 = arith.constant 6 : i32
%1541 = arith.cmpi slt, %1539, %1540 : i32
cf.cond_br %1541, ^bb190, ^bb191
^bb190:
%1543 = llvm.load %1497 : !llvm.ptr -> i32
%1544 = arith.extsi %1543 : i32 to i64
%1545 = llvm.getelementptr %1475[0, %1544] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
%1542 = llvm.load %1545 : !llvm.ptr -> i32
%1546 = arith.constant 0 : i32
%1547 = arith.cmpi eq, %1542, %1546 : i32
cf.cond_br %1547, ^bb192, ^bb193
^bb192:
%1548 = llvm.load %1529 : !llvm.ptr -> i32
%1549 = arith.constant 3 : i32
%1550 = arith.cmpi sge, %1548, %1549 : i32
%1551 = scf.if %1550 -> (i1) {
%1552 = llvm.load %1537 : !llvm.ptr -> i32
%1553 = arith.constant 0 : i32
%1554 = arith.cmpi ne, %1552, %1553 : i32
scf.yield %1554 : i1
} else {
%1555 = arith.constant false
scf.yield %1555 : i1
}
cf.cond_br %1551, ^bb195, ^bb196
^bb195:
%1556 = llvm.load %1526 : !llvm.ptr -> i32
%1557 = llvm.load %1529 : !llvm.ptr -> i32
%1558 = llvm.load %1532 : !llvm.ptr -> i32
%1559 = arith.muli %1557, %1558 : i32
%1560 = arith.addi %1556, %1559 : i32
llvm.store %1560, %1526 : i32, !llvm.ptr
cf.br ^bb197
^bb196:
cf.br ^bb197
^bb197:
%1561 = arith.constant 0 : i32
llvm.store %1561, %1529 : i32, !llvm.ptr
%1562 = arith.constant 1 : i32
llvm.store %1562, %1532 : i32, !llvm.ptr
%1563 = arith.constant 1 : i32
%1565 = arith.constant 0 : i32
%1564 = arith.subi %1565, %1563 : i32
llvm.store %1564, %1537 : i32, !llvm.ptr
cf.br ^bb194
^bb193:
%1566 = llvm.load %1529 : !llvm.ptr -> i32
%1567 = arith.constant 0 : i32
%1568 = arith.cmpi eq, %1566, %1567 : i32
cf.cond_br %1568, ^bb198, ^bb199
^bb198:
%1569 = llvm.load %1497 : !llvm.ptr -> i32
llvm.store %1569, %1537 : i32, !llvm.ptr
cf.br ^bb200
^bb199:
cf.br ^bb200
^bb200:
%1570 = llvm.load %1529 : !llvm.ptr -> i32
%1571 = arith.constant 1 : i32
%1572 = arith.addi %1570, %1571 : i32
llvm.store %1572, %1529 : i32, !llvm.ptr
%1573 = llvm.load %1532 : !llvm.ptr -> i32
%1575 = llvm.load %1497 : !llvm.ptr -> i32
%1576 = arith.extsi %1575 : i32 to i64
%1577 = llvm.getelementptr %1475[0, %1576] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i32>
%1574 = llvm.load %1577 : !llvm.ptr -> i32
%1578 = arith.muli %1573, %1574 : i32
llvm.store %1578, %1532 : i32, !llvm.ptr
cf.br ^bb194
^bb194:
%1579 = llvm.load %1497 : !llvm.ptr -> i32
%1580 = arith.constant 1 : i32
%1581 = arith.addi %1579, %1580 : i32
llvm.store %1581, %1497 : i32, !llvm.ptr
cf.br ^bb189
^bb191:
%1582 = llvm.load %1529 : !llvm.ptr -> i32
%1583 = arith.constant 3 : i32
%1584 = arith.cmpi sge, %1582, %1583 : i32
%1585 = scf.if %1584 -> (i1) {
%1586 = llvm.load %1537 : !llvm.ptr -> i32
%1587 = arith.constant 0 : i32
%1588 = arith.cmpi ne, %1586, %1587 : i32
scf.yield %1588 : i1
} else {
%1589 = arith.constant false
scf.yield %1589 : i1
}
cf.cond_br %1585, ^bb201, ^bb202
^bb201:
%1590 = llvm.load %1526 : !llvm.ptr -> i32
%1591 = llvm.load %1529 : !llvm.ptr -> i32
%1592 = llvm.load %1532 : !llvm.ptr -> i32
%1593 = arith.muli %1591, %1592 : i32
%1594 = arith.addi %1590, %1593 : i32
llvm.store %1594, %1526 : i32, !llvm.ptr
cf.br ^bb203
^bb202:
cf.br ^bb203
^bb203:
%1595 = arith.subi %1449, %1472 : i32
%1596 = llvm.load %1526 : !llvm.ptr -> i32
%1597 = arith.subi %1595, %1596 : i32
%1598 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1599 = llvm.load %1598 : !llvm.ptr -> !llvm.ptr
%1600 = llvm.mlir.addressof @n_right : !llvm.ptr
%1601 = llvm.load %1600 : !llvm.ptr -> i32
%1602 = arith.extsi %1601 : i32 to i64
%1603 = llvm.getelementptr %1599[%1602] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1604 = llvm.getelementptr %1603[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1366, %1604 : i32, !llvm.ptr
%1605 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1606 = llvm.load %1605 : !llvm.ptr -> !llvm.ptr
%1607 = llvm.mlir.addressof @n_right : !llvm.ptr
%1608 = llvm.load %1607 : !llvm.ptr -> i32
%1609 = arith.extsi %1608 : i32 to i64
%1610 = llvm.getelementptr %1606[%1609] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1611 = llvm.getelementptr %1610[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1371, %1611 : i32, !llvm.ptr
%1612 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1613 = llvm.load %1612 : !llvm.ptr -> !llvm.ptr
%1614 = llvm.mlir.addressof @n_right : !llvm.ptr
%1615 = llvm.load %1614 : !llvm.ptr -> i32
%1616 = arith.extsi %1615 : i32 to i64
%1617 = llvm.getelementptr %1613[%1616] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1618 = llvm.getelementptr %1617[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1441, %1618 : i32, !llvm.ptr
%1619 = llvm.load %1491 : !llvm.ptr -> i32
%1620 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1621 = llvm.load %1620 : !llvm.ptr -> !llvm.ptr
%1622 = llvm.mlir.addressof @n_right : !llvm.ptr
%1623 = llvm.load %1622 : !llvm.ptr -> i32
%1624 = arith.extsi %1623 : i32 to i64
%1625 = llvm.getelementptr %1621[%1624] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1626 = llvm.getelementptr %1625[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1619, %1626 : i32, !llvm.ptr
%1627 = llvm.load %1494 : !llvm.ptr -> i32
%1628 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1629 = llvm.load %1628 : !llvm.ptr -> !llvm.ptr
%1630 = llvm.mlir.addressof @n_right : !llvm.ptr
%1631 = llvm.load %1630 : !llvm.ptr -> i32
%1632 = arith.extsi %1631 : i32 to i64
%1633 = llvm.getelementptr %1629[%1632] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1634 = llvm.getelementptr %1633[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1627, %1634 : i32, !llvm.ptr
%1635 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1636 = llvm.load %1635 : !llvm.ptr -> !llvm.ptr
%1637 = llvm.mlir.addressof @n_right : !llvm.ptr
%1638 = llvm.load %1637 : !llvm.ptr -> i32
%1639 = arith.extsi %1638 : i32 to i64
%1640 = llvm.getelementptr %1636[%1639] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1641 = llvm.getelementptr %1640[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1597, %1641 : i32, !llvm.ptr
%1642 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1643 = llvm.load %1642 : !llvm.ptr -> !llvm.ptr
%1644 = llvm.mlir.addressof @n_right : !llvm.ptr
%1645 = llvm.load %1644 : !llvm.ptr -> i32
%1646 = arith.extsi %1645 : i32 to i64
%1647 = llvm.getelementptr %1643[%1646] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1648 = llvm.getelementptr %1647[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1432, %1648 : i64, !llvm.ptr
%1649 = llvm.mlir.addressof @n_right : !llvm.ptr
%1650 = llvm.load %1649 : !llvm.ptr -> i32
%1651 = arith.constant 1 : i32
%1652 = arith.addi %1650, %1651 : i32
%1653 = llvm.mlir.addressof @n_right : !llvm.ptr
llvm.store %1652, %1653 : i32, !llvm.ptr
%1654 = arith.constant 1 : i32
%1655 = arith.addi %1438, %1654 : i32
cf.br ^bb174(%1655 : i32)
^bb176(%1656: i32):
%1657 = arith.constant 1 : i32
%1658 = arith.addi %1386, %1657 : i32
cf.br ^bb171(%1658 : i32)
^bb173(%1659: i32):
%1660 = arith.constant 1 : i32
%1661 = arith.addi %1381, %1660 : i32
cf.br ^bb168(%1661 : i32)
^bb170(%1662: i32):
%1663 = arith.constant 1 : i32
%1664 = arith.addi %1376, %1663 : i32
cf.br ^bb165(%1664 : i32)
^bb167(%1665: i32):
%1666 = arith.constant 1 : i32
%1667 = arith.addi %1371, %1666 : i32
cf.br ^bb162(%1667 : i32)
^bb164(%1668: i32):
%1669 = arith.constant 1 : i32
%1670 = arith.addi %1366, %1669 : i32
cf.br ^bb159(%1670 : i32)
^bb161(%1671: i32):
func.return
}
func.func @binary_search_right(%arg0: i32, %arg1: i32, %arg2: i32) -> i64 {
%1672 = llvm.mlir.constant(1 : i64) : i64
%1673 = llvm.alloca %1672 x i32 : (i64) -> !llvm.ptr
llvm.store %arg0, %1673 : i32, !llvm.ptr
%1674 = llvm.mlir.constant(1 : i64) : i64
%1675 = llvm.alloca %1674 x i32 : (i64) -> !llvm.ptr
llvm.store %arg1, %1675 : i32, !llvm.ptr
cf.br ^bb204
^bb204:
%1676 = llvm.load %1673 : !llvm.ptr -> i32
%1677 = llvm.load %1675 : !llvm.ptr -> i32
%1678 = arith.cmpi slt, %1676, %1677 : i32
cf.cond_br %1678, ^bb205, ^bb206
^bb205:
%1679 = llvm.load %1673 : !llvm.ptr -> i32
%1680 = llvm.load %1675 : !llvm.ptr -> i32
%1681 = llvm.load %1673 : !llvm.ptr -> i32
%1682 = arith.subi %1680, %1681 : i32
%1683 = arith.constant 2 : i32
%1684 = arith.divsi %1682, %1683 : i32
%1685 = arith.addi %1679, %1684 : i32
%1687 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1688 = llvm.load %1687 : !llvm.ptr -> !llvm.ptr
%1689 = arith.extsi %1685 : i32 to i64
%1690 = llvm.getelementptr %1688[%1689] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1686 = llvm.load %1690 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1691 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1692 = llvm.load %1691 : !llvm.ptr -> !llvm.ptr
%1693 = arith.extsi %1685 : i32 to i64
%1694 = llvm.getelementptr %1692[%1693] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1695 = llvm.getelementptr %1694[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1696 = llvm.load %1695 : !llvm.ptr -> i32
%1697 = arith.cmpi slt, %1696, %arg2 : i32
cf.cond_br %1697, ^bb207, ^bb208
^bb207:
%1698 = arith.constant 1 : i32
%1699 = arith.addi %1685, %1698 : i32
llvm.store %1699, %1673 : i32, !llvm.ptr
cf.br ^bb209
^bb208:
llvm.store %1685, %1675 : i32, !llvm.ptr
cf.br ^bb209
^bb209:
cf.br ^bb204
^bb206:
%1700 = llvm.load %1673 : !llvm.ptr -> i32
%1701 = arith.cmpi slt, %1700, %arg1 : i32
%1702 = scf.if %1701 -> (i1) {
%1704 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1705 = llvm.load %1704 : !llvm.ptr -> !llvm.ptr
%1706 = llvm.load %1673 : !llvm.ptr -> i32
%1707 = arith.extsi %1706 : i32 to i64
%1708 = llvm.getelementptr %1705[%1707] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1703 = llvm.load %1708 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1709 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1710 = llvm.load %1709 : !llvm.ptr -> !llvm.ptr
%1711 = llvm.load %1673 : !llvm.ptr -> i32
%1712 = arith.extsi %1711 : i32 to i64
%1713 = llvm.getelementptr %1710[%1712] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1714 = llvm.getelementptr %1713[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1715 = llvm.load %1714 : !llvm.ptr -> i32
%1716 = arith.cmpi eq, %1715, %arg2 : i32
scf.yield %1716 : i1
} else {
%1717 = arith.constant false
scf.yield %1717 : i1
}
cf.cond_br %1702, ^bb210, ^bb211
^bb210:
%1719 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1720 = llvm.load %1719 : !llvm.ptr -> !llvm.ptr
%1721 = llvm.load %1673 : !llvm.ptr -> i32
%1722 = arith.extsi %1721 : i32 to i64
%1723 = llvm.getelementptr %1720[%1722] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1718 = llvm.load %1723 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1724 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1725 = llvm.load %1724 : !llvm.ptr -> !llvm.ptr
%1726 = llvm.load %1673 : !llvm.ptr -> i32
%1727 = arith.extsi %1726 : i32 to i64
%1728 = llvm.getelementptr %1725[%1727] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1729 = llvm.getelementptr %1728[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1730 = llvm.load %1729 : !llvm.ptr -> i64
func.return %1730 : i64
^bb211:
cf.br ^bb212
^bb212:
%1731 = arith.constant 0 : i32
%1732 = arith.extsi %1731 : i32 to i64
func.return %1732 : i64
}
func.func @main() -> i32 {
%1734 = arith.constant 20 : i32
%1735 = arith.extsi %1734 : i32 to i64
%1733 = func.call @malloc(%1735) : (i64) -> !llvm.ptr
%1736 = llvm.mlir.addressof @COMB4 : !llvm.ptr
llvm.store %1733, %1736 : !llvm.ptr, !llvm.ptr
%1737 = arith.constant 1 : i32
%1738 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1739 = llvm.load %1738 : !llvm.ptr -> !llvm.ptr
%1740 = arith.constant 0 : i32
%1741 = arith.extsi %1740 : i32 to i64
%1742 = llvm.getelementptr %1739[%1741] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1737, %1742 : i32, !llvm.ptr
%1743 = arith.constant 4 : i32
%1744 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1745 = llvm.load %1744 : !llvm.ptr -> !llvm.ptr
%1746 = arith.constant 1 : i32
%1747 = arith.extsi %1746 : i32 to i64
%1748 = llvm.getelementptr %1745[%1747] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1743, %1748 : i32, !llvm.ptr
%1749 = arith.constant 6 : i32
%1750 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1751 = llvm.load %1750 : !llvm.ptr -> !llvm.ptr
%1752 = arith.constant 2 : i32
%1753 = arith.extsi %1752 : i32 to i64
%1754 = llvm.getelementptr %1751[%1753] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1749, %1754 : i32, !llvm.ptr
%1755 = arith.constant 4 : i32
%1756 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1757 = llvm.load %1756 : !llvm.ptr -> !llvm.ptr
%1758 = arith.constant 3 : i32
%1759 = arith.extsi %1758 : i32 to i64
%1760 = llvm.getelementptr %1757[%1759] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1755, %1760 : i32, !llvm.ptr
%1761 = arith.constant 1 : i32
%1762 = llvm.mlir.addressof @COMB4 : !llvm.ptr
%1763 = llvm.load %1762 : !llvm.ptr -> !llvm.ptr
%1764 = arith.constant 4 : i32
%1765 = arith.extsi %1764 : i32 to i64
%1766 = llvm.getelementptr %1763[%1765] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1761, %1766 : i32, !llvm.ptr
%1768 = arith.constant 25 : i32
%1769 = arith.constant 4 : i32
%1770 = arith.extsi %1768 : i32 to i64
%1771 = arith.extsi %1769 : i32 to i64
%1767 = func.call @calloc(%1770, %1771) : (i64, i64) -> !llvm.ptr
%1772 = llvm.mlir.addressof @CHOOSE : !llvm.ptr
llvm.store %1767, %1772 : !llvm.ptr, !llvm.ptr
%1774 = arith.constant 16 : i32
%1775 = arith.constant 8 : i32
%1776 = arith.extsi %1774 : i32 to i64
%1777 = arith.extsi %1775 : i32 to i64
%1773 = func.call @calloc(%1776, %1777) : (i64, i64) -> !llvm.ptr
%1778 = llvm.mlir.addressof @g_nd : !llvm.ptr
llvm.store %1773, %1778 : !llvm.ptr, !llvm.ptr
func.call @init_choose() : () -> ()
%1781 = arith.constant 78125 : i32
%1782 = arith.constant 40 : i32
%1783 = arith.extsi %1781 : i32 to i64
%1784 = arith.extsi %1782 : i32 to i64
%1780 = func.call @calloc(%1783, %1784) : (i64, i64) -> !llvm.ptr
%1785 = llvm.mlir.addressof @left_entries : !llvm.ptr
llvm.store %1780, %1785 : !llvm.ptr, !llvm.ptr
%1786 = arith.constant 0 : i32
%1787 = llvm.mlir.addressof @n_left : !llvm.ptr
llvm.store %1786, %1787 : i32, !llvm.ptr
%1789 = arith.constant 15625 : i32
%1790 = arith.constant 48 : i32
%1791 = arith.extsi %1789 : i32 to i64
%1792 = arith.extsi %1790 : i32 to i64
%1788 = func.call @calloc(%1791, %1792) : (i64, i64) -> !llvm.ptr
%1793 = llvm.mlir.addressof @right_entries : !llvm.ptr
llvm.store %1788, %1793 : !llvm.ptr, !llvm.ptr
%1794 = arith.constant 0 : i32
%1795 = llvm.mlir.addressof @n_right : !llvm.ptr
llvm.store %1794, %1795 : i32, !llvm.ptr
func.call @enumerate_left() : () -> ()
func.call @enumerate_right() : () -> ()
%1799 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1800 = llvm.load %1799 : !llvm.ptr -> !llvm.ptr
%1801 = llvm.mlir.addressof @n_left : !llvm.ptr
%1802 = llvm.load %1801 : !llvm.ptr -> i32
func.call @heapsort_left(%1800, %1802) : (!llvm.ptr, i32) -> ()
%1804 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1805 = llvm.load %1804 : !llvm.ptr -> !llvm.ptr
%1806 = llvm.mlir.addressof @n_right : !llvm.ptr
%1807 = llvm.load %1806 : !llvm.ptr -> i32
func.call @heapsort_right(%1805, %1807) : (!llvm.ptr, i32) -> ()
%1809 = arith.constant 78125 : i32
%1810 = arith.constant 4 : i32
%1811 = arith.muli %1809, %1810 : i32
%1812 = arith.extsi %1811 : i32 to i64
%1808 = func.call @malloc(%1812) : (i64) -> !llvm.ptr
%1814 = arith.constant 78125 : i32
%1815 = arith.constant 4 : i32
%1816 = arith.muli %1814, %1815 : i32
%1817 = arith.extsi %1816 : i32 to i64
%1813 = func.call @malloc(%1817) : (i64) -> !llvm.ptr
%1818 = arith.constant 0 : i32
%1819 = llvm.mlir.constant(1 : i64) : i64
%1820 = llvm.alloca %1819 x i32 : (i64) -> !llvm.ptr
llvm.store %1818, %1820 : i32, !llvm.ptr
%1821 = arith.constant 0 : i32
%1822 = llvm.mlir.constant(1 : i64) : i64
%1823 = llvm.alloca %1822 x i32 : (i64) -> !llvm.ptr
llvm.store %1821, %1823 : i32, !llvm.ptr
cf.br ^bb213
^bb213:
%1824 = llvm.load %1823 : !llvm.ptr -> i32
%1825 = llvm.mlir.addressof @n_left : !llvm.ptr
%1826 = llvm.load %1825 : !llvm.ptr -> i32
%1827 = arith.cmpi slt, %1824, %1826 : i32
cf.cond_br %1827, ^bb214, ^bb215
^bb214:
%1828 = llvm.load %1823 : !llvm.ptr -> i32
%1829 = llvm.mlir.constant(1 : i64) : i64
%1830 = llvm.alloca %1829 x i32 : (i64) -> !llvm.ptr
llvm.store %1828, %1830 : i32, !llvm.ptr
cf.br ^bb216
^bb216:
%1831 = llvm.load %1830 : !llvm.ptr -> i32
%1832 = llvm.mlir.addressof @n_left : !llvm.ptr
%1833 = llvm.load %1832 : !llvm.ptr -> i32
%1834 = arith.cmpi slt, %1831, %1833 : i32
%1835 = scf.if %1834 -> (i1) {
%1837 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1838 = llvm.load %1837 : !llvm.ptr -> !llvm.ptr
%1839 = llvm.load %1823 : !llvm.ptr -> i32
%1840 = llvm.load %1830 : !llvm.ptr -> i32
%1836 = func.call @cmp_left_at(%1838, %1839, %1840) : (!llvm.ptr, i32, i32) -> i32
%1841 = arith.constant 0 : i32
%1842 = arith.cmpi eq, %1836, %1841 : i32
scf.yield %1842 : i1
} else {
%1843 = arith.constant false
scf.yield %1843 : i1
}
cf.cond_br %1835, ^bb217, ^bb218
^bb217:
%1844 = llvm.load %1830 : !llvm.ptr -> i32
%1845 = arith.constant 1 : i32
%1846 = arith.addi %1844, %1845 : i32
llvm.store %1846, %1830 : i32, !llvm.ptr
cf.br ^bb216
^bb218:
%1847 = arith.constant 0 : i32
%1848 = arith.extsi %1847 : i32 to i64
%1849 = llvm.mlir.constant(1 : i64) : i64
%1850 = llvm.alloca %1849 x i64 : (i64) -> !llvm.ptr
llvm.store %1848, %1850 : i64, !llvm.ptr
%1851 = llvm.load %1823 : !llvm.ptr -> i32
%1852 = llvm.mlir.constant(1 : i64) : i64
%1853 = llvm.alloca %1852 x i32 : (i64) -> !llvm.ptr
llvm.store %1851, %1853 : i32, !llvm.ptr
cf.br ^bb219
^bb219:
%1854 = llvm.load %1853 : !llvm.ptr -> i32
%1855 = llvm.load %1830 : !llvm.ptr -> i32
%1856 = arith.cmpi slt, %1854, %1855 : i32
cf.cond_br %1856, ^bb220, ^bb221
^bb220:
%1857 = llvm.load %1850 : !llvm.ptr -> i64
%1859 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1860 = llvm.load %1859 : !llvm.ptr -> !llvm.ptr
%1861 = llvm.load %1853 : !llvm.ptr -> i32
%1862 = arith.extsi %1861 : i32 to i64
%1863 = llvm.getelementptr %1860[%1862] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1858 = llvm.load %1863 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1864 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1865 = llvm.load %1864 : !llvm.ptr -> !llvm.ptr
%1866 = llvm.load %1853 : !llvm.ptr -> i32
%1867 = arith.extsi %1866 : i32 to i64
%1868 = llvm.getelementptr %1865[%1867] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1869 = llvm.getelementptr %1868[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1870 = llvm.load %1869 : !llvm.ptr -> i64
%1871 = arith.addi %1857, %1870 : i64
llvm.store %1871, %1850 : i64, !llvm.ptr
%1872 = llvm.load %1853 : !llvm.ptr -> i32
%1873 = arith.constant 1 : i32
%1874 = arith.addi %1872, %1873 : i32
llvm.store %1874, %1853 : i32, !llvm.ptr
cf.br ^bb219
^bb221:
%1875 = llvm.load %1850 : !llvm.ptr -> i64
%1876 = llvm.mlir.addressof @left_entries : !llvm.ptr
%1877 = llvm.load %1876 : !llvm.ptr -> !llvm.ptr
%1878 = llvm.load %1823 : !llvm.ptr -> i32
%1879 = arith.extsi %1878 : i32 to i64
%1880 = llvm.getelementptr %1877[%1879] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%1881 = llvm.getelementptr %1880[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
llvm.store %1875, %1881 : i64, !llvm.ptr
%1882 = llvm.load %1823 : !llvm.ptr -> i32
%1883 = llvm.load %1820 : !llvm.ptr -> i32
%1884 = arith.extsi %1883 : i32 to i64
%1885 = llvm.getelementptr %1808[%1884] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1882, %1885 : i32, !llvm.ptr
%1886 = llvm.load %1830 : !llvm.ptr -> i32
%1887 = llvm.load %1820 : !llvm.ptr -> i32
%1888 = arith.extsi %1887 : i32 to i64
%1889 = llvm.getelementptr %1813[%1888] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1886, %1889 : i32, !llvm.ptr
%1890 = llvm.load %1820 : !llvm.ptr -> i32
%1891 = arith.constant 1 : i32
%1892 = arith.addi %1890, %1891 : i32
llvm.store %1892, %1820 : i32, !llvm.ptr
%1893 = llvm.load %1830 : !llvm.ptr -> i32
llvm.store %1893, %1823 : i32, !llvm.ptr
cf.br ^bb213
^bb215:
%1895 = arith.constant 15625 : i32
%1896 = arith.constant 28 : i32
%1897 = arith.extsi %1895 : i32 to i64
%1898 = arith.extsi %1896 : i32 to i64
%1894 = func.call @calloc(%1897, %1898) : (i64, i64) -> !llvm.ptr
%1899 = arith.constant 0 : i32
%1900 = llvm.mlir.constant(1 : i64) : i64
%1901 = llvm.alloca %1900 x i32 : (i64) -> !llvm.ptr
llvm.store %1899, %1901 : i32, !llvm.ptr
%1902 = arith.constant 0 : i32
llvm.store %1902, %1823 : i32, !llvm.ptr
cf.br ^bb222
^bb222:
%1903 = llvm.load %1823 : !llvm.ptr -> i32
%1904 = llvm.mlir.addressof @n_right : !llvm.ptr
%1905 = llvm.load %1904 : !llvm.ptr -> i32
%1906 = arith.cmpi slt, %1903, %1905 : i32
cf.cond_br %1906, ^bb223, ^bb224
^bb223:
%1907 = llvm.load %1823 : !llvm.ptr -> i32
%1908 = llvm.mlir.constant(1 : i64) : i64
%1909 = llvm.alloca %1908 x i32 : (i64) -> !llvm.ptr
llvm.store %1907, %1909 : i32, !llvm.ptr
cf.br ^bb225
^bb225:
%1910 = llvm.load %1909 : !llvm.ptr -> i32
%1911 = llvm.mlir.addressof @n_right : !llvm.ptr
%1912 = llvm.load %1911 : !llvm.ptr -> i32
%1913 = arith.cmpi slt, %1910, %1912 : i32
%1914 = scf.if %1913 -> (i1) {
%1916 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1917 = llvm.load %1916 : !llvm.ptr -> !llvm.ptr
%1918 = llvm.load %1909 : !llvm.ptr -> i32
%1919 = arith.extsi %1918 : i32 to i64
%1920 = llvm.getelementptr %1917[%1919] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1915 = llvm.load %1920 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1921 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1922 = llvm.load %1921 : !llvm.ptr -> !llvm.ptr
%1923 = llvm.load %1909 : !llvm.ptr -> i32
%1924 = arith.extsi %1923 : i32 to i64
%1925 = llvm.getelementptr %1922[%1924] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1926 = llvm.getelementptr %1925[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1927 = llvm.load %1926 : !llvm.ptr -> i32
%1929 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1930 = llvm.load %1929 : !llvm.ptr -> !llvm.ptr
%1931 = llvm.load %1823 : !llvm.ptr -> i32
%1932 = arith.extsi %1931 : i32 to i64
%1933 = llvm.getelementptr %1930[%1932] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1928 = llvm.load %1933 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1934 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1935 = llvm.load %1934 : !llvm.ptr -> !llvm.ptr
%1936 = llvm.load %1823 : !llvm.ptr -> i32
%1937 = arith.extsi %1936 : i32 to i64
%1938 = llvm.getelementptr %1935[%1937] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1939 = llvm.getelementptr %1938[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1940 = llvm.load %1939 : !llvm.ptr -> i32
%1941 = arith.cmpi eq, %1927, %1940 : i32
scf.yield %1941 : i1
} else {
%1942 = arith.constant false
scf.yield %1942 : i1
}
%1943 = scf.if %1914 -> (i1) {
%1945 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1946 = llvm.load %1945 : !llvm.ptr -> !llvm.ptr
%1947 = llvm.load %1909 : !llvm.ptr -> i32
%1948 = arith.extsi %1947 : i32 to i64
%1949 = llvm.getelementptr %1946[%1948] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1944 = llvm.load %1949 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1950 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1951 = llvm.load %1950 : !llvm.ptr -> !llvm.ptr
%1952 = llvm.load %1909 : !llvm.ptr -> i32
%1953 = arith.extsi %1952 : i32 to i64
%1954 = llvm.getelementptr %1951[%1953] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1955 = llvm.getelementptr %1954[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1956 = llvm.load %1955 : !llvm.ptr -> i32
%1958 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1959 = llvm.load %1958 : !llvm.ptr -> !llvm.ptr
%1960 = llvm.load %1823 : !llvm.ptr -> i32
%1961 = arith.extsi %1960 : i32 to i64
%1962 = llvm.getelementptr %1959[%1961] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1957 = llvm.load %1962 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1963 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1964 = llvm.load %1963 : !llvm.ptr -> !llvm.ptr
%1965 = llvm.load %1823 : !llvm.ptr -> i32
%1966 = arith.extsi %1965 : i32 to i64
%1967 = llvm.getelementptr %1964[%1966] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1968 = llvm.getelementptr %1967[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1969 = llvm.load %1968 : !llvm.ptr -> i32
%1970 = arith.cmpi eq, %1956, %1969 : i32
scf.yield %1970 : i1
} else {
%1971 = arith.constant false
scf.yield %1971 : i1
}
%1972 = scf.if %1943 -> (i1) {
%1974 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1975 = llvm.load %1974 : !llvm.ptr -> !llvm.ptr
%1976 = llvm.load %1909 : !llvm.ptr -> i32
%1977 = arith.extsi %1976 : i32 to i64
%1978 = llvm.getelementptr %1975[%1977] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1973 = llvm.load %1978 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1979 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1980 = llvm.load %1979 : !llvm.ptr -> !llvm.ptr
%1981 = llvm.load %1909 : !llvm.ptr -> i32
%1982 = arith.extsi %1981 : i32 to i64
%1983 = llvm.getelementptr %1980[%1982] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1984 = llvm.getelementptr %1983[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1985 = llvm.load %1984 : !llvm.ptr -> i32
%1987 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1988 = llvm.load %1987 : !llvm.ptr -> !llvm.ptr
%1989 = llvm.load %1823 : !llvm.ptr -> i32
%1990 = arith.extsi %1989 : i32 to i64
%1991 = llvm.getelementptr %1988[%1990] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1986 = llvm.load %1991 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1992 = llvm.mlir.addressof @right_entries : !llvm.ptr
%1993 = llvm.load %1992 : !llvm.ptr -> !llvm.ptr
%1994 = llvm.load %1823 : !llvm.ptr -> i32
%1995 = arith.extsi %1994 : i32 to i64
%1996 = llvm.getelementptr %1993[%1995] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1997 = llvm.getelementptr %1996[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%1998 = llvm.load %1997 : !llvm.ptr -> i32
%1999 = arith.cmpi eq, %1985, %1998 : i32
scf.yield %1999 : i1
} else {
%2000 = arith.constant false
scf.yield %2000 : i1
}
%2001 = scf.if %1972 -> (i1) {
%2003 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2004 = llvm.load %2003 : !llvm.ptr -> !llvm.ptr
%2005 = llvm.load %1909 : !llvm.ptr -> i32
%2006 = arith.extsi %2005 : i32 to i64
%2007 = llvm.getelementptr %2004[%2006] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2002 = llvm.load %2007 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2008 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2009 = llvm.load %2008 : !llvm.ptr -> !llvm.ptr
%2010 = llvm.load %1909 : !llvm.ptr -> i32
%2011 = arith.extsi %2010 : i32 to i64
%2012 = llvm.getelementptr %2009[%2011] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2013 = llvm.getelementptr %2012[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2014 = llvm.load %2013 : !llvm.ptr -> i32
%2016 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2017 = llvm.load %2016 : !llvm.ptr -> !llvm.ptr
%2018 = llvm.load %1823 : !llvm.ptr -> i32
%2019 = arith.extsi %2018 : i32 to i64
%2020 = llvm.getelementptr %2017[%2019] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2015 = llvm.load %2020 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2021 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2022 = llvm.load %2021 : !llvm.ptr -> !llvm.ptr
%2023 = llvm.load %1823 : !llvm.ptr -> i32
%2024 = arith.extsi %2023 : i32 to i64
%2025 = llvm.getelementptr %2022[%2024] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2026 = llvm.getelementptr %2025[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2027 = llvm.load %2026 : !llvm.ptr -> i32
%2028 = arith.cmpi eq, %2014, %2027 : i32
scf.yield %2028 : i1
} else {
%2029 = arith.constant false
scf.yield %2029 : i1
}
%2030 = scf.if %2001 -> (i1) {
%2032 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2033 = llvm.load %2032 : !llvm.ptr -> !llvm.ptr
%2034 = llvm.load %1909 : !llvm.ptr -> i32
%2035 = arith.extsi %2034 : i32 to i64
%2036 = llvm.getelementptr %2033[%2035] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2031 = llvm.load %2036 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2037 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2038 = llvm.load %2037 : !llvm.ptr -> !llvm.ptr
%2039 = llvm.load %1909 : !llvm.ptr -> i32
%2040 = arith.extsi %2039 : i32 to i64
%2041 = llvm.getelementptr %2038[%2040] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2042 = llvm.getelementptr %2041[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2043 = llvm.load %2042 : !llvm.ptr -> i32
%2045 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2046 = llvm.load %2045 : !llvm.ptr -> !llvm.ptr
%2047 = llvm.load %1823 : !llvm.ptr -> i32
%2048 = arith.extsi %2047 : i32 to i64
%2049 = llvm.getelementptr %2046[%2048] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2044 = llvm.load %2049 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2050 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2051 = llvm.load %2050 : !llvm.ptr -> !llvm.ptr
%2052 = llvm.load %1823 : !llvm.ptr -> i32
%2053 = arith.extsi %2052 : i32 to i64
%2054 = llvm.getelementptr %2051[%2053] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2055 = llvm.getelementptr %2054[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2056 = llvm.load %2055 : !llvm.ptr -> i32
%2057 = arith.cmpi eq, %2043, %2056 : i32
scf.yield %2057 : i1
} else {
%2058 = arith.constant false
scf.yield %2058 : i1
}
cf.cond_br %2030, ^bb226, ^bb227
^bb226:
%2059 = llvm.load %1909 : !llvm.ptr -> i32
%2060 = arith.constant 1 : i32
%2061 = arith.addi %2059, %2060 : i32
llvm.store %2061, %1909 : i32, !llvm.ptr
cf.br ^bb225
^bb227:
%2062 = llvm.load %1823 : !llvm.ptr -> i32
%2063 = llvm.mlir.constant(1 : i64) : i64
%2064 = llvm.alloca %2063 x i32 : (i64) -> !llvm.ptr
llvm.store %2062, %2064 : i32, !llvm.ptr
cf.br ^bb228
^bb228:
%2065 = llvm.load %2064 : !llvm.ptr -> i32
%2066 = llvm.load %1909 : !llvm.ptr -> i32
%2067 = arith.cmpi slt, %2065, %2066 : i32
cf.cond_br %2067, ^bb229, ^bb230
^bb229:
%2068 = llvm.load %2064 : !llvm.ptr -> i32
%2069 = llvm.mlir.constant(1 : i64) : i64
%2070 = llvm.alloca %2069 x i32 : (i64) -> !llvm.ptr
llvm.store %2068, %2070 : i32, !llvm.ptr
cf.br ^bb231
^bb231:
%2071 = llvm.load %2070 : !llvm.ptr -> i32
%2072 = llvm.load %1909 : !llvm.ptr -> i32
%2073 = arith.cmpi slt, %2071, %2072 : i32
%2074 = scf.if %2073 -> (i1) {
%2076 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2077 = llvm.load %2076 : !llvm.ptr -> !llvm.ptr
%2078 = llvm.load %2070 : !llvm.ptr -> i32
%2079 = arith.extsi %2078 : i32 to i64
%2080 = llvm.getelementptr %2077[%2079] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2075 = llvm.load %2080 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2081 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2082 = llvm.load %2081 : !llvm.ptr -> !llvm.ptr
%2083 = llvm.load %2070 : !llvm.ptr -> i32
%2084 = arith.extsi %2083 : i32 to i64
%2085 = llvm.getelementptr %2082[%2084] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2086 = llvm.getelementptr %2085[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2087 = llvm.load %2086 : !llvm.ptr -> i32
%2089 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2090 = llvm.load %2089 : !llvm.ptr -> !llvm.ptr
%2091 = llvm.load %2064 : !llvm.ptr -> i32
%2092 = arith.extsi %2091 : i32 to i64
%2093 = llvm.getelementptr %2090[%2092] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2088 = llvm.load %2093 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2094 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2095 = llvm.load %2094 : !llvm.ptr -> !llvm.ptr
%2096 = llvm.load %2064 : !llvm.ptr -> i32
%2097 = arith.extsi %2096 : i32 to i64
%2098 = llvm.getelementptr %2095[%2097] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2099 = llvm.getelementptr %2098[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2100 = llvm.load %2099 : !llvm.ptr -> i32
%2101 = arith.cmpi eq, %2087, %2100 : i32
scf.yield %2101 : i1
} else {
%2102 = arith.constant false
scf.yield %2102 : i1
}
cf.cond_br %2074, ^bb232, ^bb233
^bb232:
%2103 = llvm.load %2070 : !llvm.ptr -> i32
%2104 = arith.constant 1 : i32
%2105 = arith.addi %2103, %2104 : i32
llvm.store %2105, %2070 : i32, !llvm.ptr
cf.br ^bb231
^bb233:
%2106 = arith.constant 0 : i32
%2107 = arith.extsi %2106 : i32 to i64
%2108 = llvm.mlir.constant(1 : i64) : i64
%2109 = llvm.alloca %2108 x i64 : (i64) -> !llvm.ptr
llvm.store %2107, %2109 : i64, !llvm.ptr
%2110 = llvm.load %2064 : !llvm.ptr -> i32
%2111 = llvm.mlir.constant(1 : i64) : i64
%2112 = llvm.alloca %2111 x i32 : (i64) -> !llvm.ptr
llvm.store %2110, %2112 : i32, !llvm.ptr
cf.br ^bb234
^bb234:
%2113 = llvm.load %2112 : !llvm.ptr -> i32
%2114 = llvm.load %2070 : !llvm.ptr -> i32
%2115 = arith.cmpi slt, %2113, %2114 : i32
cf.cond_br %2115, ^bb235, ^bb236
^bb235:
%2116 = llvm.load %2109 : !llvm.ptr -> i64
%2118 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2119 = llvm.load %2118 : !llvm.ptr -> !llvm.ptr
%2120 = llvm.load %2112 : !llvm.ptr -> i32
%2121 = arith.extsi %2120 : i32 to i64
%2122 = llvm.getelementptr %2119[%2121] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2117 = llvm.load %2122 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2123 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2124 = llvm.load %2123 : !llvm.ptr -> !llvm.ptr
%2125 = llvm.load %2112 : !llvm.ptr -> i32
%2126 = arith.extsi %2125 : i32 to i64
%2127 = llvm.getelementptr %2124[%2126] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2128 = llvm.getelementptr %2127[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2129 = llvm.load %2128 : !llvm.ptr -> i64
%2130 = arith.addi %2116, %2129 : i64
llvm.store %2130, %2109 : i64, !llvm.ptr
%2131 = llvm.load %2112 : !llvm.ptr -> i32
%2132 = arith.constant 1 : i32
%2133 = arith.addi %2131, %2132 : i32
llvm.store %2133, %2112 : i32, !llvm.ptr
cf.br ^bb234
^bb236:
%2134 = llvm.load %2109 : !llvm.ptr -> i64
%2135 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2136 = llvm.load %2135 : !llvm.ptr -> !llvm.ptr
%2137 = llvm.load %2064 : !llvm.ptr -> i32
%2138 = arith.extsi %2137 : i32 to i64
%2139 = llvm.getelementptr %2136[%2138] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2140 = llvm.getelementptr %2139[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
llvm.store %2134, %2140 : i64, !llvm.ptr
%2141 = llvm.load %2070 : !llvm.ptr -> i32
llvm.store %2141, %2064 : i32, !llvm.ptr
cf.br ^bb228
^bb230:
%2143 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2144 = llvm.load %2143 : !llvm.ptr -> !llvm.ptr
%2145 = llvm.load %1823 : !llvm.ptr -> i32
%2146 = arith.extsi %2145 : i32 to i64
%2147 = llvm.getelementptr %2144[%2146] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2142 = llvm.load %2147 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2148 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2149 = llvm.load %2148 : !llvm.ptr -> !llvm.ptr
%2150 = llvm.load %1823 : !llvm.ptr -> i32
%2151 = arith.extsi %2150 : i32 to i64
%2152 = llvm.getelementptr %2149[%2151] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2153 = llvm.getelementptr %2152[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2154 = llvm.load %2153 : !llvm.ptr -> i32
%2155 = llvm.load %1901 : !llvm.ptr -> i32
%2156 = arith.extsi %2155 : i32 to i64
%2157 = llvm.getelementptr %1894[%2156] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2158 = llvm.getelementptr %2157[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2154, %2158 : i32, !llvm.ptr
%2160 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2161 = llvm.load %2160 : !llvm.ptr -> !llvm.ptr
%2162 = llvm.load %1823 : !llvm.ptr -> i32
%2163 = arith.extsi %2162 : i32 to i64
%2164 = llvm.getelementptr %2161[%2163] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2159 = llvm.load %2164 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2165 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2166 = llvm.load %2165 : !llvm.ptr -> !llvm.ptr
%2167 = llvm.load %1823 : !llvm.ptr -> i32
%2168 = arith.extsi %2167 : i32 to i64
%2169 = llvm.getelementptr %2166[%2168] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2170 = llvm.getelementptr %2169[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2171 = llvm.load %2170 : !llvm.ptr -> i32
%2172 = llvm.load %1901 : !llvm.ptr -> i32
%2173 = arith.extsi %2172 : i32 to i64
%2174 = llvm.getelementptr %1894[%2173] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2175 = llvm.getelementptr %2174[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2171, %2175 : i32, !llvm.ptr
%2177 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2178 = llvm.load %2177 : !llvm.ptr -> !llvm.ptr
%2179 = llvm.load %1823 : !llvm.ptr -> i32
%2180 = arith.extsi %2179 : i32 to i64
%2181 = llvm.getelementptr %2178[%2180] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2176 = llvm.load %2181 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2182 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2183 = llvm.load %2182 : !llvm.ptr -> !llvm.ptr
%2184 = llvm.load %1823 : !llvm.ptr -> i32
%2185 = arith.extsi %2184 : i32 to i64
%2186 = llvm.getelementptr %2183[%2185] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2187 = llvm.getelementptr %2186[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2188 = llvm.load %2187 : !llvm.ptr -> i32
%2189 = llvm.load %1901 : !llvm.ptr -> i32
%2190 = arith.extsi %2189 : i32 to i64
%2191 = llvm.getelementptr %1894[%2190] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2192 = llvm.getelementptr %2191[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2188, %2192 : i32, !llvm.ptr
%2194 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2195 = llvm.load %2194 : !llvm.ptr -> !llvm.ptr
%2196 = llvm.load %1823 : !llvm.ptr -> i32
%2197 = arith.extsi %2196 : i32 to i64
%2198 = llvm.getelementptr %2195[%2197] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2193 = llvm.load %2198 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2199 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2200 = llvm.load %2199 : !llvm.ptr -> !llvm.ptr
%2201 = llvm.load %1823 : !llvm.ptr -> i32
%2202 = arith.extsi %2201 : i32 to i64
%2203 = llvm.getelementptr %2200[%2202] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2204 = llvm.getelementptr %2203[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2205 = llvm.load %2204 : !llvm.ptr -> i32
%2206 = llvm.load %1901 : !llvm.ptr -> i32
%2207 = arith.extsi %2206 : i32 to i64
%2208 = llvm.getelementptr %1894[%2207] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2209 = llvm.getelementptr %2208[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2205, %2209 : i32, !llvm.ptr
%2211 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2212 = llvm.load %2211 : !llvm.ptr -> !llvm.ptr
%2213 = llvm.load %1823 : !llvm.ptr -> i32
%2214 = arith.extsi %2213 : i32 to i64
%2215 = llvm.getelementptr %2212[%2214] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2210 = llvm.load %2215 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2216 = llvm.mlir.addressof @right_entries : !llvm.ptr
%2217 = llvm.load %2216 : !llvm.ptr -> !llvm.ptr
%2218 = llvm.load %1823 : !llvm.ptr -> i32
%2219 = arith.extsi %2218 : i32 to i64
%2220 = llvm.getelementptr %2217[%2219] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2221 = llvm.getelementptr %2220[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i64)>
%2222 = llvm.load %2221 : !llvm.ptr -> i32
%2223 = llvm.load %1901 : !llvm.ptr -> i32
%2224 = arith.extsi %2223 : i32 to i64
%2225 = llvm.getelementptr %1894[%2224] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2226 = llvm.getelementptr %2225[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2222, %2226 : i32, !llvm.ptr
%2227 = llvm.load %1823 : !llvm.ptr -> i32
%2228 = llvm.load %1901 : !llvm.ptr -> i32
%2229 = arith.extsi %2228 : i32 to i64
%2230 = llvm.getelementptr %1894[%2229] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2231 = llvm.getelementptr %2230[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2227, %2231 : i32, !llvm.ptr
%2232 = llvm.load %1909 : !llvm.ptr -> i32
%2233 = llvm.load %1901 : !llvm.ptr -> i32
%2234 = arith.extsi %2233 : i32 to i64
%2235 = llvm.getelementptr %1894[%2234] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2236 = llvm.getelementptr %2235[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
llvm.store %2232, %2236 : i32, !llvm.ptr
%2237 = llvm.load %1901 : !llvm.ptr -> i32
%2238 = arith.constant 1 : i32
%2239 = arith.addi %2237, %2238 : i32
llvm.store %2239, %1901 : i32, !llvm.ptr
%2240 = llvm.load %1909 : !llvm.ptr -> i32
llvm.store %2240, %1823 : i32, !llvm.ptr
cf.br ^bb222
^bb224:
%2242 = arith.constant 500 : i32
%2243 = arith.constant 24 : i32
%2244 = arith.extsi %2242 : i32 to i64
%2245 = arith.extsi %2243 : i32 to i64
%2241 = func.call @calloc(%2244, %2245) : (i64, i64) -> !llvm.ptr
%2246 = arith.constant 0 : i32
%2247 = llvm.mlir.constant(1 : i64) : i64
%2248 = llvm.alloca %2247 x i32 : (i64) -> !llvm.ptr
llvm.store %2246, %2248 : i32, !llvm.ptr
%2249 = arith.constant 0 : i32
llvm.store %2249, %1823 : i32, !llvm.ptr
cf.br ^bb237
^bb237:
%2250 = llvm.load %1823 : !llvm.ptr -> i32
%2251 = llvm.load %1901 : !llvm.ptr -> i32
%2252 = arith.cmpi slt, %2250, %2251 : i32
cf.cond_br %2252, ^bb238, ^bb239
^bb238:
%2253 = llvm.load %1823 : !llvm.ptr -> i32
%2254 = llvm.mlir.constant(1 : i64) : i64
%2255 = llvm.alloca %2254 x i32 : (i64) -> !llvm.ptr
llvm.store %2253, %2255 : i32, !llvm.ptr
cf.br ^bb240
^bb240:
%2256 = llvm.load %2255 : !llvm.ptr -> i32
%2257 = llvm.load %1901 : !llvm.ptr -> i32
%2258 = arith.cmpi slt, %2256, %2257 : i32
%2259 = scf.if %2258 -> (i1) {
%2261 = llvm.load %2255 : !llvm.ptr -> i32
%2262 = arith.extsi %2261 : i32 to i64
%2263 = llvm.getelementptr %1894[%2262] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2260 = llvm.load %2263 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2264 = llvm.load %2255 : !llvm.ptr -> i32
%2265 = arith.extsi %2264 : i32 to i64
%2266 = llvm.getelementptr %1894[%2265] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2267 = llvm.getelementptr %2266[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2268 = llvm.load %2267 : !llvm.ptr -> i32
%2270 = llvm.load %1823 : !llvm.ptr -> i32
%2271 = arith.extsi %2270 : i32 to i64
%2272 = llvm.getelementptr %1894[%2271] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2269 = llvm.load %2272 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2273 = llvm.load %1823 : !llvm.ptr -> i32
%2274 = arith.extsi %2273 : i32 to i64
%2275 = llvm.getelementptr %1894[%2274] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2276 = llvm.getelementptr %2275[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2277 = llvm.load %2276 : !llvm.ptr -> i32
%2278 = arith.cmpi eq, %2268, %2277 : i32
scf.yield %2278 : i1
} else {
%2279 = arith.constant false
scf.yield %2279 : i1
}
%2280 = scf.if %2259 -> (i1) {
%2282 = llvm.load %2255 : !llvm.ptr -> i32
%2283 = arith.extsi %2282 : i32 to i64
%2284 = llvm.getelementptr %1894[%2283] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2281 = llvm.load %2284 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2285 = llvm.load %2255 : !llvm.ptr -> i32
%2286 = arith.extsi %2285 : i32 to i64
%2287 = llvm.getelementptr %1894[%2286] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2288 = llvm.getelementptr %2287[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2289 = llvm.load %2288 : !llvm.ptr -> i32
%2291 = llvm.load %1823 : !llvm.ptr -> i32
%2292 = arith.extsi %2291 : i32 to i64
%2293 = llvm.getelementptr %1894[%2292] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2290 = llvm.load %2293 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2294 = llvm.load %1823 : !llvm.ptr -> i32
%2295 = arith.extsi %2294 : i32 to i64
%2296 = llvm.getelementptr %1894[%2295] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2297 = llvm.getelementptr %2296[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2298 = llvm.load %2297 : !llvm.ptr -> i32
%2299 = arith.cmpi eq, %2289, %2298 : i32
scf.yield %2299 : i1
} else {
%2300 = arith.constant false
scf.yield %2300 : i1
}
%2301 = scf.if %2280 -> (i1) {
%2303 = llvm.load %2255 : !llvm.ptr -> i32
%2304 = arith.extsi %2303 : i32 to i64
%2305 = llvm.getelementptr %1894[%2304] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2302 = llvm.load %2305 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2306 = llvm.load %2255 : !llvm.ptr -> i32
%2307 = arith.extsi %2306 : i32 to i64
%2308 = llvm.getelementptr %1894[%2307] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2309 = llvm.getelementptr %2308[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2310 = llvm.load %2309 : !llvm.ptr -> i32
%2312 = llvm.load %1823 : !llvm.ptr -> i32
%2313 = arith.extsi %2312 : i32 to i64
%2314 = llvm.getelementptr %1894[%2313] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2311 = llvm.load %2314 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2315 = llvm.load %1823 : !llvm.ptr -> i32
%2316 = arith.extsi %2315 : i32 to i64
%2317 = llvm.getelementptr %1894[%2316] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2318 = llvm.getelementptr %2317[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2319 = llvm.load %2318 : !llvm.ptr -> i32
%2320 = arith.cmpi eq, %2310, %2319 : i32
scf.yield %2320 : i1
} else {
%2321 = arith.constant false
scf.yield %2321 : i1
}
cf.cond_br %2301, ^bb241, ^bb242
^bb241:
%2322 = llvm.load %2255 : !llvm.ptr -> i32
%2323 = arith.constant 1 : i32
%2324 = arith.addi %2322, %2323 : i32
llvm.store %2324, %2255 : i32, !llvm.ptr
cf.br ^bb240
^bb242:
%2326 = llvm.load %1823 : !llvm.ptr -> i32
%2327 = arith.extsi %2326 : i32 to i64
%2328 = llvm.getelementptr %1894[%2327] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2325 = llvm.load %2328 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2329 = llvm.load %1823 : !llvm.ptr -> i32
%2330 = arith.extsi %2329 : i32 to i64
%2331 = llvm.getelementptr %1894[%2330] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2332 = llvm.getelementptr %2331[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2333 = llvm.load %2332 : !llvm.ptr -> i32
%2334 = llvm.load %2248 : !llvm.ptr -> i32
%2335 = arith.extsi %2334 : i32 to i64
%2336 = llvm.getelementptr %2241[%2335] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2337 = llvm.getelementptr %2336[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
llvm.store %2333, %2337 : i32, !llvm.ptr
%2339 = llvm.load %1823 : !llvm.ptr -> i32
%2340 = arith.extsi %2339 : i32 to i64
%2341 = llvm.getelementptr %1894[%2340] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2338 = llvm.load %2341 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2342 = llvm.load %1823 : !llvm.ptr -> i32
%2343 = arith.extsi %2342 : i32 to i64
%2344 = llvm.getelementptr %1894[%2343] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2345 = llvm.getelementptr %2344[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2346 = llvm.load %2345 : !llvm.ptr -> i32
%2347 = llvm.load %2248 : !llvm.ptr -> i32
%2348 = arith.extsi %2347 : i32 to i64
%2349 = llvm.getelementptr %2241[%2348] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2350 = llvm.getelementptr %2349[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
llvm.store %2346, %2350 : i32, !llvm.ptr
%2352 = llvm.load %1823 : !llvm.ptr -> i32
%2353 = arith.extsi %2352 : i32 to i64
%2354 = llvm.getelementptr %1894[%2353] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2351 = llvm.load %2354 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2355 = llvm.load %1823 : !llvm.ptr -> i32
%2356 = arith.extsi %2355 : i32 to i64
%2357 = llvm.getelementptr %1894[%2356] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2358 = llvm.getelementptr %2357[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2359 = llvm.load %2358 : !llvm.ptr -> i32
%2360 = llvm.load %2248 : !llvm.ptr -> i32
%2361 = arith.extsi %2360 : i32 to i64
%2362 = llvm.getelementptr %2241[%2361] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2363 = llvm.getelementptr %2362[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
llvm.store %2359, %2363 : i32, !llvm.ptr
%2364 = llvm.load %1823 : !llvm.ptr -> i32
%2365 = llvm.load %2248 : !llvm.ptr -> i32
%2366 = arith.extsi %2365 : i32 to i64
%2367 = llvm.getelementptr %2241[%2366] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2368 = llvm.getelementptr %2367[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
llvm.store %2364, %2368 : i32, !llvm.ptr
%2369 = llvm.load %2255 : !llvm.ptr -> i32
%2370 = llvm.load %2248 : !llvm.ptr -> i32
%2371 = arith.extsi %2370 : i32 to i64
%2372 = llvm.getelementptr %2241[%2371] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2373 = llvm.getelementptr %2372[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
llvm.store %2369, %2373 : i32, !llvm.ptr
%2374 = llvm.load %2248 : !llvm.ptr -> i32
%2375 = arith.constant 1 : i32
%2376 = arith.addi %2374, %2375 : i32
llvm.store %2376, %2248 : i32, !llvm.ptr
%2377 = llvm.load %2255 : !llvm.ptr -> i32
llvm.store %2377, %1823 : i32, !llvm.ptr
cf.br ^bb237
^bb239:
%2378 = arith.constant 0 : i32
%2379 = arith.extsi %2378 : i32 to i64
%2380 = llvm.mlir.constant(1 : i64) : i64
%2381 = llvm.alloca %2380 x i64 : (i64) -> !llvm.ptr
llvm.store %2379, %2381 : i64, !llvm.ptr
%2382 = arith.constant 0 : i32
%2383 = llvm.mlir.constant(1 : i64) : i64
%2384 = llvm.alloca %2383 x i32 : (i64) -> !llvm.ptr
llvm.store %2382, %2384 : i32, !llvm.ptr
cf.br ^bb243
^bb243:
%2385 = llvm.load %2384 : !llvm.ptr -> i32
%2386 = llvm.load %1820 : !llvm.ptr -> i32
%2387 = arith.cmpi slt, %2385, %2386 : i32
cf.cond_br %2387, ^bb244, ^bb245
^bb244:
# String concatenation: !llvm.ptr + i32
%2389 = llvm.getelementptr %2388[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2390 = llvm.load %2389 : !llvm.ptr -> i32
%2391 = llvm.getelementptr %2388[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2392 = llvm.load %2391 : !llvm.ptr -> i32
%2393 = llvm.getelementptr %2388[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2394 = llvm.load %2393 : !llvm.ptr -> i32
%2395 = llvm.getelementptr %2388[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2396 = llvm.load %2395 : !llvm.ptr -> i32
%2397 = llvm.getelementptr %2388[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2398 = llvm.load %2397 : !llvm.ptr -> i32
%2399 = llvm.getelementptr %2388[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2400 = llvm.load %2399 : !llvm.ptr -> i32
%2401 = llvm.getelementptr %2388[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2402 = llvm.load %2401 : !llvm.ptr -> i32
%2403 = llvm.getelementptr %2388[0, 7] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32, i64)>
%2404 = llvm.load %2403 : !llvm.ptr -> i64
%2405 = arith.constant 0 : i32
%2406 = llvm.mlir.constant(1 : i64) : i64
%2407 = llvm.alloca %2406 x i32 : (i64) -> !llvm.ptr
llvm.store %2405, %2407 : i32, !llvm.ptr
cf.br ^bb246
^bb246:
%2408 = llvm.load %2407 : !llvm.ptr -> i32
%2409 = llvm.load %2248 : !llvm.ptr -> i32
%2410 = arith.cmpi slt, %2408, %2409 : i32
cf.cond_br %2410, ^bb247, ^bb248
^bb247:
%2412 = llvm.load %2407 : !llvm.ptr -> i32
%2413 = arith.extsi %2412 : i32 to i64
%2414 = llvm.getelementptr %2241[%2413] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2411 = llvm.load %2414 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32)>
%2415 = llvm.load %2407 : !llvm.ptr -> i32
%2416 = arith.extsi %2415 : i32 to i64
%2417 = llvm.getelementptr %2241[%2416] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2418 = llvm.getelementptr %2417[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2419 = llvm.load %2418 : !llvm.ptr -> i32
%2421 = llvm.load %2407 : !llvm.ptr -> i32
%2422 = arith.extsi %2421 : i32 to i64
%2423 = llvm.getelementptr %2241[%2422] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2420 = llvm.load %2423 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32)>
%2424 = llvm.load %2407 : !llvm.ptr -> i32
%2425 = arith.extsi %2424 : i32 to i64
%2426 = llvm.getelementptr %2241[%2425] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2427 = llvm.getelementptr %2426[0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2428 = llvm.load %2427 : !llvm.ptr -> i32
%2430 = llvm.load %2407 : !llvm.ptr -> i32
%2431 = arith.extsi %2430 : i32 to i64
%2432 = llvm.getelementptr %2241[%2431] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2429 = llvm.load %2432 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32)>
%2433 = llvm.load %2407 : !llvm.ptr -> i32
%2434 = arith.extsi %2433 : i32 to i64
%2435 = llvm.getelementptr %2241[%2434] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2436 = llvm.getelementptr %2435[0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2437 = llvm.load %2436 : !llvm.ptr -> i32
%2438 = arith.muli %2394, %2419 : i32
%2439 = arith.addi %2396, %2438 : i32
%2440 = arith.muli %2392, %2428 : i32
%2441 = arith.addi %2439, %2440 : i32
%2442 = arith.muli %2390, %2437 : i32
%2443 = arith.addi %2441, %2442 : i32
%2444 = arith.constant 170 : i32
%2445 = arith.cmpi sgt, %2443, %2444 : i32
cf.cond_br %2445, ^bb249, ^bb250
^bb249:
%2446 = llvm.load %2407 : !llvm.ptr -> i32
%2447 = arith.constant 1 : i32
%2448 = arith.addi %2446, %2447 : i32
llvm.store %2448, %2407 : i32, !llvm.ptr
cf.br ^bb246
^bb250:
cf.br ^bb251
^bb251:
%2449 = arith.constant 2 : i32
%2450 = arith.muli %2449, %2443 : i32
%2452 = llvm.load %2407 : !llvm.ptr -> i32
%2453 = arith.extsi %2452 : i32 to i64
%2454 = llvm.getelementptr %2241[%2453] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2451 = llvm.load %2454 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32)>
%2455 = llvm.load %2407 : !llvm.ptr -> i32
%2456 = arith.extsi %2455 : i32 to i64
%2457 = llvm.getelementptr %2241[%2456] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2458 = llvm.getelementptr %2457[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2459 = llvm.load %2458 : !llvm.ptr -> i32
%2460 = llvm.mlir.constant(1 : i64) : i64
%2461 = llvm.alloca %2460 x i32 : (i64) -> !llvm.ptr
llvm.store %2459, %2461 : i32, !llvm.ptr
cf.br ^bb252
^bb252:
%2462 = llvm.load %2461 : !llvm.ptr -> i32
%2464 = llvm.load %2407 : !llvm.ptr -> i32
%2465 = arith.extsi %2464 : i32 to i64
%2466 = llvm.getelementptr %2241[%2465] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2463 = llvm.load %2466 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32)>
%2467 = llvm.load %2407 : !llvm.ptr -> i32
%2468 = arith.extsi %2467 : i32 to i64
%2469 = llvm.getelementptr %2241[%2468] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2470 = llvm.getelementptr %2469[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32)>
%2471 = llvm.load %2470 : !llvm.ptr -> i32
%2472 = arith.cmpi slt, %2462, %2471 : i32
cf.cond_br %2472, ^bb253, ^bb254
^bb253:
%2474 = llvm.load %2461 : !llvm.ptr -> i32
%2475 = arith.extsi %2474 : i32 to i64
%2476 = llvm.getelementptr %1894[%2475] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2473 = llvm.load %2476 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2477 = llvm.load %2461 : !llvm.ptr -> i32
%2478 = arith.extsi %2477 : i32 to i64
%2479 = llvm.getelementptr %1894[%2478] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2480 = llvm.getelementptr %2479[0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2481 = llvm.load %2480 : !llvm.ptr -> i32
%2483 = llvm.load %2461 : !llvm.ptr -> i32
%2484 = arith.extsi %2483 : i32 to i64
%2485 = llvm.getelementptr %1894[%2484] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2482 = llvm.load %2485 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2486 = llvm.load %2461 : !llvm.ptr -> i32
%2487 = arith.extsi %2486 : i32 to i64
%2488 = llvm.getelementptr %1894[%2487] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2489 = llvm.getelementptr %2488[0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2490 = llvm.load %2489 : !llvm.ptr -> i32
%2491 = func.call @run_boundary(%2398, %2400, %2481, %2490) : (i32, i32, i32, i32) -> i32
%2492 = arith.addi %2450, %2491 : i32
%2493 = arith.subi %2492, %2402 : i32
%2496 = llvm.load %2461 : !llvm.ptr -> i32
%2497 = arith.extsi %2496 : i32 to i64
%2498 = llvm.getelementptr %1894[%2497] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2495 = llvm.load %2498 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2499 = llvm.load %2461 : !llvm.ptr -> i32
%2500 = arith.extsi %2499 : i32 to i64
%2501 = llvm.getelementptr %1894[%2500] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2502 = llvm.getelementptr %2501[0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2503 = llvm.load %2502 : !llvm.ptr -> i32
%2505 = llvm.load %2461 : !llvm.ptr -> i32
%2506 = arith.extsi %2505 : i32 to i64
%2507 = llvm.getelementptr %1894[%2506] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2504 = llvm.load %2507 : !llvm.ptr -> !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2508 = llvm.load %2461 : !llvm.ptr -> i32
%2509 = arith.extsi %2508 : i32 to i64
%2510 = llvm.getelementptr %1894[%2509] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2511 = llvm.getelementptr %2510[0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i32, i32, i32, i32, i32, i32, i32)>
%2512 = llvm.load %2511 : !llvm.ptr -> i32
%2494 = func.call @binary_search_right(%2503, %2512, %2493) : (i32, i32, i32) -> i64
%2513 = arith.constant 0 : i32
%2515 = arith.extsi %2513 : i32 to i64
%2514 = arith.cmpi ne, %2494, %2515 : i64
cf.cond_br %2514, ^bb255, ^bb256
^bb255:
%2516 = llvm.load %2381 : !llvm.ptr -> i64
%2517 = arith.muli %2404, %2494 : i64
%2518 = arith.addi %2516, %2517 : i64
llvm.store %2518, %2381 : i64, !llvm.ptr
cf.br ^bb257
^bb256:
cf.br ^bb257
^bb257:
%2519 = llvm.load %2461 : !llvm.ptr -> i32
%2520 = arith.constant 1 : i32
%2521 = arith.addi %2519, %2520 : i32
llvm.store %2521, %2461 : i32, !llvm.ptr
cf.br ^bb252
^bb254:
%2522 = llvm.load %2407 : !llvm.ptr -> i32
%2523 = arith.constant 1 : i32
%2524 = arith.addi %2522, %2523 : i32
llvm.store %2524, %2407 : i32, !llvm.ptr
cf.br ^bb246
^bb248:
%2525 = llvm.load %2384 : !llvm.ptr -> i32
%2526 = arith.constant 1 : i32
%2527 = arith.addi %2525, %2526 : i32
llvm.store %2527, %2384 : i32, !llvm.ptr
cf.br ^bb243
^bb245:
%2528 = llvm.load %2381 : !llvm.ptr -> i64
%2529 = arith.constant 1 : i32
%2531 = arith.extsi %2529 : i32 to i64
%2530 = arith.subi %2528, %2531 : i64
llvm.store %2530, %2381 : i64, !llvm.ptr
%2532 = llvm.mlir.addressof @str_0 : !llvm.ptr
%2533 = llvm.load %2381 : !llvm.ptr -> i64
%2534 = llvm.call @printf(%2532, %2533) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%2535 = arith.constant 0 : i32
func.return %2535 : i32
}
}