Problem 941
de Bruijn's Combination Lock. RankDB + LSD radix sort. F(10^7) mod 1234567891.
View problem on Project Euler
Performance comparison
| Metric | Our solution | Best known |
|---|
| Time complexity | O(n^2) | ? |
|---|
| Space complexity | O(n^2) | ? |
|---|
| Approach | Flow solution | Not curated |
|---|
| Verdict | Unknown |
|---|
Flow source
# Project Euler 941
# de Bruijn's Combination Lock. RankDB + LSD radix sort.
# F(10^7) mod 1234567891.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function malloc(n: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function memset(s: ptr<void>, c: i32, n: i64) -> ptr<void>
}
const ND: i64 = 12
const KK: i64 = 10
const STRIDE: i64 = 13
const MOD_LCG: i64 = 1000000000000
# Scratch arrays (reused across rank_db / T_func calls)
let mut power_arr: ptr<i64> = null
let mut t_neck: ptr<i32> = null
let mut neck_rep: ptr<i32> = null
let mut prev_arr: ptr<i32> = null
let mut b_arr: ptr<i64> = null
let mut suf_arr: ptr<i32> = null
function init_tables() -> void {
power_arr = calloc(ND + 1, 8)
power_arr[0] = 1
let mut i: i64 = 1
while i <= ND {
power_arr[i] = power_arr[i - 1] * KK
i = i + 1
}
t_neck = calloc(ND + 1, 4)
neck_rep = calloc(ND + 1, 4)
prev_arr = calloc(ND + 1, 4)
b_arr = calloc(STRIDE * STRIDE, 8)
suf_arr = calloc(STRIDE * STRIDE, 4)
}
# Length of the longest Lyndon prefix of w[1..ND].
function lyn(w: ptr<i32>) -> i64 {
let mut p: i64 = 1
let mut i: i64 = 2
while i <= ND {
if w[i] < w[i - p] {
return p
}
if w[i] > w[i - p] {
p = i
}
i = i + 1
}
return p
}
# True iff w[1..ND] is a necklace (lexicographically smallest rotation).
function is_necklace(w: ptr<i32>) -> bool {
let mut p: i64 = 1
let mut i: i64 = 2
while i <= ND {
if w[i] < w[i - p] {
return false
}
if w[i] > w[i - p] {
p = i
}
i = i + 1
}
return (ND % p) == 0
}
# out[1..ND] = largest necklace <= w[1..ND].
function largest_necklace(w: ptr<i32>, out: ptr<i32>) -> void {
let mut i: i64 = 1
while i <= ND {
out[i] = w[i]
i = i + 1
}
while !is_necklace(out) {
let p: i64 = lyn(out)
out[p] = out[p] - 1
let mut j: i64 = p + 1
while j <= ND {
out[j] = KK as i32
j = j + 1
}
}
}
# Number of strings whose necklace is <= w[1..ND].
function t_func(w: ptr<i32>) -> i64 {
largest_necklace(w, t_neck)
b_arr[0] = 1
let mut t: i64 = 1
while t <= ND {
b_arr[t * STRIDE + t] = 0
let mut j: i64 = t - 1
while j >= 0 {
b_arr[t * STRIDE + j] = b_arr[t * STRIDE + j + 1] +
(KK - (t_neck[j + 1] as i64)) * b_arr[(t - j - 1) * STRIDE + 0]
j = j - 1
}
t = t + 1
}
let mut i: i64 = 2
while i <= ND {
let mut sv: i64 = i
let mut j: i64 = i
while j <= ND {
if t_neck[j] > t_neck[j - sv + 1] {
sv = j + 1
}
suf_arr[i * STRIDE + j] = (j - sv + 1) as i32
j = j + 1
}
i = i + 1
}
let mut tot: i64 = lyn(t_neck)
t = 1
while t <= ND {
let b0: i64 = b_arr[(t - 1) * STRIDE + 0]
let mut j: i64 = 0
while j < ND {
if j + t <= ND {
tot = tot + b0 * ((t_neck[j + 1] as i64) - 1) * power_arr[ND - t - j]
} else {
let mut sfx: i64 = 0
if j >= ND - t + 2 {
sfx = suf_arr[(ND - t + 2) * STRIDE + j] as i64
}
if (t_neck[j + 1] as i64) > (t_neck[sfx + 1] as i64) {
tot = tot + b_arr[(ND - j + sfx) * STRIDE + sfx + 1] +
((t_neck[j + 1] as i64) - (t_neck[sfx + 1] as i64) - 1) *
b_arr[(ND - j - 1) * STRIDE + 0]
}
}
j = j + 1
}
t = t + 1
}
return tot
}
# 1-based rank (start position) of w in the lex-smallest de Bruijn sequence.
function rank_db(w: ptr<i32>) -> i64 {
# Wraparound case: w = KK^t 1^(ND-t) for t >= 1
let mut t: i64 = 0
while t < ND && (w[t + 1] as i64) == KK {
t = t + 1
}
let mut j: i64 = t
while j < ND && w[j + 1] == 1 {
j = j + 1
}
if t >= 1 && j == ND {
return power_arr[ND] - t + 1
}
# If w is already a necklace, done
if is_necklace(w) {
return 1 - lyn(w) + t_func(w)
}
# Find the necklace representative by rotation
let mut i: i64 = 1
while i <= ND {
neck_rep[i] = w[i]
i = i + 1
}
let mut s: i64 = 0
while !is_necklace(neck_rep) {
s = s + 1
i = 1
while i <= ND {
let j2: i64 = i + s
if j2 <= ND {
neck_rep[i] = w[j2]
} else {
neck_rep[i] = w[j2 - ND]
}
i = i + 1
}
}
# neck_rep is now a necklace (not a wraparound case)
let lyn_nr: i64 = lyn(neck_rep)
if s != t {
return 1 + t_func(neck_rep) - s
}
if lyn_nr < ND {
return 1 - lyn_nr + t_func(neck_rep) - s
}
# Adjust suffix to 1s, move to previous necklace
i = ND - s + 1
while i <= ND {
neck_rep[i] = 1
i = i + 1
}
largest_necklace(neck_rep, prev_arr)
return 1 + t_func(prev_arr) - s
}
# Convert a 12-digit integer to symbols 1..10 in w[1..12].
function int_to_word12(x: i64, w: ptr<i32>) -> void {
let hi: i64 = x / 100000000
let mid: i64 = (x / 10000) % 10000
let lo: i64 = x % 10000
w[1] = (hi / 1000 + 1) as i32
w[2] = ((hi / 100) % 10 + 1) as i32
w[3] = ((hi / 10) % 10 + 1) as i32
w[4] = (hi % 10 + 1) as i32
w[5] = (mid / 1000 + 1) as i32
w[6] = ((mid / 100) % 10 + 1) as i32
w[7] = ((mid / 10) % 10 + 1) as i32
w[8] = (mid % 10 + 1) as i32
w[9] = (lo / 1000 + 1) as i32
w[10] = ((lo / 100) % 10 + 1) as i32
w[11] = ((lo / 10) % 10 + 1) as i32
w[12] = (lo % 10 + 1) as i32
}
function compute_F_mod(N: i64, mod_val: i64) -> i64 {
let keys: ptr<i64> = malloc(N * 8)
let vals: ptr<i64> = malloc(N * 8)
let tmp_k: ptr<i64> = malloc(N * 8)
let tmp_v: ptr<i64> = malloc(N * 8)
let w: ptr<i32> = calloc(ND + 1, 4)
let mut a: i64 = 0
let mut i: i64 = 0
while i < N {
a = (920461 * a + 800217387569) % MOD_LCG
int_to_word12(a, w)
keys[i] = rank_db(w)
vals[i] = a
i = i + 1
}
# LSD radix sort (3 passes of 16 bits)
let counts: ptr<i32> = calloc(65536, 4)
let mut sk: ptr<i64> = keys
let mut dk: ptr<i64> = tmp_k
let mut svar: ptr<i64> = vals
let mut dvar: ptr<i64> = tmp_v
let mut pass: i64 = 0
while pass < 3 {
let shift: i64 = pass * 16
memset(counts, 0, 65536 * 4)
let mut ii: i64 = 0
while ii < N {
let b: i64 = (sk[ii] >> shift) & 0xFFFF
counts[b] = counts[b] + 1
ii = ii + 1
}
let mut total: i32 = 0
let mut b: i64 = 0
while b < 65536 {
let c: i32 = counts[b]
counts[b] = total
total = total + c
b = b + 1
}
ii = 0
while ii < N {
let b: i64 = (sk[ii] >> shift) & 0xFFFF
let p: i32 = counts[b]
counts[b] = p + 1
dk[p as i64] = sk[ii]
dvar[p as i64] = svar[ii]
ii = ii + 1
}
# swap
let tk: ptr<i64> = sk
sk = dk
dk = tk
let tv: ptr<i64> = svar
svar = dvar
dvar = tv
pass = pass + 1
}
# After 3 passes (odd), sorted data is in sk / svar
let mut acc: i64 = 0
i = 0
while i < N {
acc = (acc + (i + 1) * (svar[i] % mod_val)) % mod_val
i = i + 1
}
free(keys)
free(vals)
free(tmp_k)
free(tmp_v)
free(counts)
free(w)
return acc
}
function main() -> i32 {
init_tables()
printf("%lld\n", compute_F_mod(10000000, 1234567891))
return 0
}
Generated C
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Flow runtime helpers */
typedef struct flow_temp_node { struct flow_temp_node* next; } flow_temp_node;
static flow_temp_node* flow_temp_head = NULL;
static int flow_temp_atexit_set = 0;
__attribute__((unused)) static void flow_temp_free_all(void) {
while (flow_temp_head) {
flow_temp_node* n = flow_temp_head;
flow_temp_head = n->next;
free(n);
}
}
__attribute__((unused)) static void* flow_temp_alloc(size_t nbytes) {
flow_temp_node* node = (flow_temp_node*)malloc(sizeof(flow_temp_node) + nbytes);
if (!node) return NULL;
node->next = flow_temp_head;
flow_temp_head = node;
if (!flow_temp_atexit_set) {
flow_temp_atexit_set = 1;
atexit(flow_temp_free_all);
}
return (void*)(node + 1);
}
#ifndef FLOW_DIAG
#define FLOW_DIAG(msg) fprintf(stderr, "%s", (msg))
#endif
#ifndef FLOW_LOG
#define FLOW_LOG(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
#ifndef FLOW_LOG_EMPTY
#define FLOW_LOG_EMPTY(fmt) printf(fmt)
#endif
static char* flow_strcat(const char* a, const char* b) {
size_t la = strlen(a ? a : ""), lb = strlen(b ? b : "");
char* r = (char*)flow_temp_alloc(la + lb + 1);
if (!r) return NULL;
if (la) memcpy(r, a, la);
if (lb) memcpy(r + la, b, lb);
r[la + lb] = '\0';
return r;
}
#define __flow_in_arr(arr, val) __extension__ ({ \
int _found = 0; \
size_t _n = sizeof(arr)/sizeof((arr)[0]); \
for (size_t _i = 0; _i < _n; _i++) { \
if ((arr)[_i] == (val)) { _found = 1; break; } \
} _found; })
/* Unified fault handler (MISRA #279) — override with -DFLOW_FAULT_HANDLER=fn */
#ifndef FLOW_FAULT_HANDLER
__attribute__((unused)) static inline void flow_fault_handler(const char* msg) {
fprintf(stderr, "flow: %s\n", msg ? msg : "fault");
abort();
#if defined(__GNUC__) || defined(__clang__)
__builtin_unreachable();
#endif
}
#else
#define flow_fault_handler FLOW_FAULT_HANDLER
#endif
#define flow_div_by_zero_handler() flow_fault_handler("division by zero")
#define flow_shift_ub_handler() flow_fault_handler("invalid shift (amount out of range or left-shift of negative)")
#ifndef FLOW_CHECKED_DIV
#define FLOW_CHECKED_DIV(L, R) (((R) != 0) ? ((L) / (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_MOD
#define FLOW_CHECKED_MOD(L, R) (((R) != 0) ? ((L) % (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHL
#define FLOW_CHECKED_SHL(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull)) && ((L) >= 0)) ? ((L) << (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHR
#define FLOW_CHECKED_SHR(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull))) ? ((L) >> (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#include <math.h>
void* _ui_state = NULL;
static inline float i32_to_f32(int32_t v) { return (float)v; }
/* Host stub for @gpu kernels (device codegen replaces this). */
static inline int32_t gpu_thread_id(void) { return 0; }
void init_tables(void);
int64_t lyn_ptr_i32(int32_t* w);
bool is_necklace_ptr_i32(int32_t* w);
void largest_necklace_ptr_i32_ptr_i32(int32_t* w, int32_t* out);
int64_t t_func_ptr_i32(int32_t* w);
int64_t rank_db_ptr_i32(int32_t* w);
void int_to_word12_i64_ptr_i32(int64_t x, int32_t* w);
int64_t compute_F_mod_i64_i64(int64_t N, int64_t mod_val);
int32_t main(void);
static const int64_t ND = 12;
static const int64_t KK = 10;
static const int64_t STRIDE = 13;
static const int64_t MOD_LCG = 1000000000000;
/* Module statics */
static int64_t* power_arr = NULL;
static int32_t* t_neck = NULL;
static int32_t* neck_rep = NULL;
static int32_t* prev_arr = NULL;
static int64_t* b_arr = NULL;
static int32_t* suf_arr = NULL;
void init_tables(void) {
power_arr = calloc((ND + 1), 8);
power_arr[0] = 1;
int64_t i = 1;
while (i <= ND) {
power_arr[i] = (power_arr[(i - 1)] * KK);
i = (i + 1);
}
t_neck = calloc((ND + 1), 4);
neck_rep = calloc((ND + 1), 4);
prev_arr = calloc((ND + 1), 4);
b_arr = calloc((STRIDE * STRIDE), 8);
suf_arr = calloc((STRIDE * STRIDE), 4);
}
int64_t lyn_ptr_i32(int32_t* w) {
int64_t p = 1;
int64_t i = 2;
while (i <= ND) {
if (w[i] < w[(i - p)]) {
return p;
}
if (w[i] > w[(i - p)]) {
p = i;
}
i = (i + 1);
}
return p;
}
bool is_necklace_ptr_i32(int32_t* w) {
int64_t p = 1;
int64_t i = 2;
while (i <= ND) {
if (w[i] < w[(i - p)]) {
return 0;
}
if (w[i] > w[(i - p)]) {
p = i;
}
i = (i + 1);
}
return FLOW_CHECKED_MOD((ND), (p)) == 0;
}
void largest_necklace_ptr_i32_ptr_i32(int32_t* w, int32_t* out) {
int64_t i = 1;
while (i <= ND) {
out[i] = w[i];
i = (i + 1);
}
while ((!(is_necklace_ptr_i32(out)))) {
int64_t p = lyn_ptr_i32(out);
out[p] = (out[p] - 1);
int64_t j = (p + 1);
while (j <= ND) {
out[j] = ((int32_t)(KK));
j = (j + 1);
}
}
}
int64_t t_func_ptr_i32(int32_t* w) {
largest_necklace_ptr_i32_ptr_i32(w, t_neck);
b_arr[0] = 1;
int64_t t = 1;
while (t <= ND) {
b_arr[((t * STRIDE) + t)] = 0;
int64_t j = (t - 1);
while (j >= 0) {
b_arr[((t * STRIDE) + j)] = (b_arr[(((t * STRIDE) + j) + 1)] + ((KK - ((int64_t)(t_neck[(j + 1)]))) * b_arr[((((t - j) - 1) * STRIDE) + 0)]));
j = (j - 1);
}
t = (t + 1);
}
int64_t i = 2;
while (i <= ND) {
int64_t sv = i;
int64_t j = i;
while (j <= ND) {
if (t_neck[j] > t_neck[((j - sv) + 1)]) {
sv = (j + 1);
}
suf_arr[((i * STRIDE) + j)] = ((int32_t)(((j - sv) + 1)));
j = (j + 1);
}
i = (i + 1);
}
int64_t tot = lyn_ptr_i32(t_neck);
t = 1;
while (t <= ND) {
int64_t b0 = b_arr[(((t - 1) * STRIDE) + 0)];
int64_t j = 0;
while (j < ND) {
if ((j + t) <= ND) {
tot = (tot + ((b0 * (((int64_t)(t_neck[(j + 1)])) - 1)) * power_arr[((ND - t) - j)]));
} else {
int64_t sfx = 0;
if (j >= ((ND - t) + 2)) {
sfx = ((int64_t)(suf_arr[((((ND - t) + 2) * STRIDE) + j)]));
}
if (((int64_t)(t_neck[(j + 1)])) > ((int64_t)(t_neck[(sfx + 1)]))) {
tot = ((tot + b_arr[(((((ND - j) + sfx) * STRIDE) + sfx) + 1)]) + (((((int64_t)(t_neck[(j + 1)])) - ((int64_t)(t_neck[(sfx + 1)]))) - 1) * b_arr[((((ND - j) - 1) * STRIDE) + 0)]));
}
}
j = (j + 1);
}
t = (t + 1);
}
return tot;
}
int64_t rank_db_ptr_i32(int32_t* w) {
int64_t t = 0;
while ((t < ND && ((int64_t)(w[(t + 1)])) == KK)) {
t = (t + 1);
}
int64_t j = t;
while ((j < ND && w[(j + 1)] == 1)) {
j = (j + 1);
}
if ((t >= 1 && j == ND)) {
return ((power_arr[ND] - t) + 1);
}
if (is_necklace_ptr_i32(w)) {
return ((1 - lyn_ptr_i32(w)) + t_func_ptr_i32(w));
}
int64_t i = 1;
while (i <= ND) {
neck_rep[i] = w[i];
i = (i + 1);
}
int64_t s = 0;
while ((!(is_necklace_ptr_i32(neck_rep)))) {
s = (s + 1);
i = 1;
while (i <= ND) {
int64_t j2 = (i + s);
if (j2 <= ND) {
neck_rep[i] = w[j2];
} else {
neck_rep[i] = w[(j2 - ND)];
}
i = (i + 1);
}
}
int64_t lyn_nr = lyn_ptr_i32(neck_rep);
if (s != t) {
return ((1 + t_func_ptr_i32(neck_rep)) - s);
}
if (lyn_nr < ND) {
return (((1 - lyn_nr) + t_func_ptr_i32(neck_rep)) - s);
}
i = ((ND - s) + 1);
while (i <= ND) {
neck_rep[i] = 1;
i = (i + 1);
}
largest_necklace_ptr_i32_ptr_i32(neck_rep, prev_arr);
return ((1 + t_func_ptr_i32(prev_arr)) - s);
}
void int_to_word12_i64_ptr_i32(int64_t x, int32_t* w) {
int64_t hi = FLOW_CHECKED_DIV((x), (100000000));
int64_t mid = FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((x), (10000))), (10000));
int64_t lo = FLOW_CHECKED_MOD((x), (10000));
w[1] = ((int32_t)((FLOW_CHECKED_DIV((hi), (1000)) + 1)));
w[2] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((hi), (100))), (10)) + 1)));
w[3] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((hi), (10))), (10)) + 1)));
w[4] = ((int32_t)((FLOW_CHECKED_MOD((hi), (10)) + 1)));
w[5] = ((int32_t)((FLOW_CHECKED_DIV((mid), (1000)) + 1)));
w[6] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((mid), (100))), (10)) + 1)));
w[7] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((mid), (10))), (10)) + 1)));
w[8] = ((int32_t)((FLOW_CHECKED_MOD((mid), (10)) + 1)));
w[9] = ((int32_t)((FLOW_CHECKED_DIV((lo), (1000)) + 1)));
w[10] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((lo), (100))), (10)) + 1)));
w[11] = ((int32_t)((FLOW_CHECKED_MOD((FLOW_CHECKED_DIV((lo), (10))), (10)) + 1)));
w[12] = ((int32_t)((FLOW_CHECKED_MOD((lo), (10)) + 1)));
}
int64_t compute_F_mod_i64_i64(int64_t N, int64_t mod_val) {
int64_t* keys = (int64_t*)(malloc((N * 8)));
int64_t* vals = (int64_t*)(malloc((N * 8)));
int64_t* tmp_k = (int64_t*)(malloc((N * 8)));
int64_t* tmp_v = (int64_t*)(malloc((N * 8)));
int32_t* w = (int32_t*)(calloc((ND + 1), 4));
int64_t a = 0;
int64_t i = 0;
while (i < N) {
a = FLOW_CHECKED_MOD((((920461 * a) + 800217387569)), (MOD_LCG));
int_to_word12_i64_ptr_i32(a, w);
keys[i] = rank_db_ptr_i32(w);
vals[i] = a;
i = (i + 1);
}
int32_t* counts = (int32_t*)(calloc(65536, 4));
int64_t* sk = (int64_t*)(keys);
int64_t* dk = (int64_t*)(tmp_k);
int64_t* svar = (int64_t*)(vals);
int64_t* dvar = (int64_t*)(tmp_v);
int64_t pass = 0;
while (pass < 3) {
int64_t shift = (pass * 16);
memset(counts, 0, (65536 * 4));
int64_t ii = 0;
while (ii < N) {
int64_t b = (FLOW_CHECKED_SHR((sk[ii]), (shift)) & 65535);
counts[b] = (counts[b] + 1);
ii = (ii + 1);
}
int32_t total = 0;
int64_t b = 0;
while (b < 65536) {
int32_t c = counts[b];
counts[b] = total;
total = (total + c);
b = (b + 1);
}
ii = 0;
while (ii < N) {
int64_t b = (FLOW_CHECKED_SHR((sk[ii]), (shift)) & 65535);
int32_t p = counts[b];
counts[b] = (p + 1);
dk[((int64_t)(p))] = sk[ii];
dvar[((int64_t)(p))] = svar[ii];
ii = (ii + 1);
}
int64_t* tk = (int64_t*)(sk);
sk = dk;
dk = tk;
int64_t* tv = (int64_t*)(svar);
svar = dvar;
dvar = tv;
pass = (pass + 1);
}
int64_t acc = 0;
i = 0;
while (i < N) {
acc = FLOW_CHECKED_MOD(((acc + ((i + 1) * FLOW_CHECKED_MOD((svar[i]), (mod_val))))), (mod_val));
i = (i + 1);
}
free(keys);
free(vals);
free(tmp_k);
free(tmp_v);
free(counts);
free(w);
return acc;
}
int32_t main(void) {
init_tables();
printf("%lld\n", compute_F_mod_i64_i64(10000000, 1234567891));
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 @malloc(i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @memset(!llvm.ptr, i32, i64) -> !llvm.ptr
// Constant: ND
llvm.mlir.global internal constant @ND(12 : i64) : i64
// Constant: KK
llvm.mlir.global internal constant @KK(10 : i64) : i64
// Constant: STRIDE
llvm.mlir.global internal constant @STRIDE(13 : i64) : i64
// Constant: MOD_LCG
llvm.mlir.global internal constant @MOD_LCG(1000000000000 : i64) : i64
// Module static: power_arr
llvm.mlir.global internal @power_arr() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: t_neck
llvm.mlir.global internal @t_neck() {addr_space = 0 : i32} : !llvm.ptr {
%1 = llvm.mlir.zero : !llvm.ptr
llvm.return %1 : !llvm.ptr
}
// Module static: neck_rep
llvm.mlir.global internal @neck_rep() {addr_space = 0 : i32} : !llvm.ptr {
%2 = llvm.mlir.zero : !llvm.ptr
llvm.return %2 : !llvm.ptr
}
// Module static: prev_arr
llvm.mlir.global internal @prev_arr() {addr_space = 0 : i32} : !llvm.ptr {
%3 = llvm.mlir.zero : !llvm.ptr
llvm.return %3 : !llvm.ptr
}
// Module static: b_arr
llvm.mlir.global internal @b_arr() {addr_space = 0 : i32} : !llvm.ptr {
%4 = llvm.mlir.zero : !llvm.ptr
llvm.return %4 : !llvm.ptr
}
// Module static: suf_arr
llvm.mlir.global internal @suf_arr() {addr_space = 0 : i32} : !llvm.ptr {
%5 = llvm.mlir.zero : !llvm.ptr
llvm.return %5 : !llvm.ptr
}
func.func @init_tables() -> () {
%7 = llvm.mlir.addressof @ND : !llvm.ptr
%8 = llvm.load %7 : !llvm.ptr -> i64
%9 = arith.constant 1 : i32
%11 = arith.extsi %9 : i32 to i64
%10 = arith.addi %8, %11 : i64
%12 = arith.constant 8 : i32
%13 = arith.extsi %12 : i32 to i64
%6 = func.call @calloc(%10, %13) : (i64, i64) -> !llvm.ptr
%14 = llvm.mlir.addressof @power_arr : !llvm.ptr
llvm.store %6, %14 : !llvm.ptr, !llvm.ptr
%15 = arith.constant 1 : i32
%16 = llvm.mlir.addressof @power_arr : !llvm.ptr
%17 = llvm.load %16 : !llvm.ptr -> !llvm.ptr
%18 = arith.constant 0 : i32
%19 = arith.extsi %15 : i32 to i64
%20 = arith.extsi %18 : i32 to i64
%21 = llvm.getelementptr %17[%20] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %19, %21 : i64, !llvm.ptr
%22 = arith.constant 1 : i32
%23 = arith.extsi %22 : i32 to i64
%24 = llvm.mlir.constant(1 : i64) : i64
%25 = llvm.alloca %24 x i64 : (i64) -> !llvm.ptr
llvm.store %23, %25 : i64, !llvm.ptr
cf.br ^bb0
^bb0:
%26 = llvm.load %25 : !llvm.ptr -> i64
%27 = llvm.mlir.addressof @ND : !llvm.ptr
%28 = llvm.load %27 : !llvm.ptr -> i64
%29 = arith.cmpi sle, %26, %28 : i64
cf.cond_br %29, ^bb1, ^bb2
^bb1:
%31 = llvm.mlir.addressof @power_arr : !llvm.ptr
%32 = llvm.load %31 : !llvm.ptr -> !llvm.ptr
%33 = llvm.load %25 : !llvm.ptr -> i64
%34 = arith.constant 1 : i32
%36 = arith.extsi %34 : i32 to i64
%35 = arith.subi %33, %36 : i64
%37 = llvm.getelementptr %32[%35] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%30 = llvm.load %37 : !llvm.ptr -> i64
%38 = llvm.mlir.addressof @KK : !llvm.ptr
%39 = llvm.load %38 : !llvm.ptr -> i64
%40 = arith.muli %30, %39 : i64
%41 = llvm.mlir.addressof @power_arr : !llvm.ptr
%42 = llvm.load %41 : !llvm.ptr -> !llvm.ptr
%43 = llvm.load %25 : !llvm.ptr -> i64
%44 = llvm.getelementptr %42[%43] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %40, %44 : i64, !llvm.ptr
%45 = llvm.load %25 : !llvm.ptr -> i64
%46 = arith.constant 1 : i32
%48 = arith.extsi %46 : i32 to i64
%47 = arith.addi %45, %48 : i64
llvm.store %47, %25 : i64, !llvm.ptr
cf.br ^bb0
^bb2:
%50 = llvm.mlir.addressof @ND : !llvm.ptr
%51 = llvm.load %50 : !llvm.ptr -> i64
%52 = arith.constant 1 : i32
%54 = arith.extsi %52 : i32 to i64
%53 = arith.addi %51, %54 : i64
%55 = arith.constant 4 : i32
%56 = arith.extsi %55 : i32 to i64
%49 = func.call @calloc(%53, %56) : (i64, i64) -> !llvm.ptr
%57 = llvm.mlir.addressof @t_neck : !llvm.ptr
llvm.store %49, %57 : !llvm.ptr, !llvm.ptr
%59 = llvm.mlir.addressof @ND : !llvm.ptr
%60 = llvm.load %59 : !llvm.ptr -> i64
%61 = arith.constant 1 : i32
%63 = arith.extsi %61 : i32 to i64
%62 = arith.addi %60, %63 : i64
%64 = arith.constant 4 : i32
%65 = arith.extsi %64 : i32 to i64
%58 = func.call @calloc(%62, %65) : (i64, i64) -> !llvm.ptr
%66 = llvm.mlir.addressof @neck_rep : !llvm.ptr
llvm.store %58, %66 : !llvm.ptr, !llvm.ptr
%68 = llvm.mlir.addressof @ND : !llvm.ptr
%69 = llvm.load %68 : !llvm.ptr -> i64
%70 = arith.constant 1 : i32
%72 = arith.extsi %70 : i32 to i64
%71 = arith.addi %69, %72 : i64
%73 = arith.constant 4 : i32
%74 = arith.extsi %73 : i32 to i64
%67 = func.call @calloc(%71, %74) : (i64, i64) -> !llvm.ptr
%75 = llvm.mlir.addressof @prev_arr : !llvm.ptr
llvm.store %67, %75 : !llvm.ptr, !llvm.ptr
%77 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%78 = llvm.load %77 : !llvm.ptr -> i64
%79 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%80 = llvm.load %79 : !llvm.ptr -> i64
%81 = arith.muli %78, %80 : i64
%82 = arith.constant 8 : i32
%83 = arith.extsi %82 : i32 to i64
%76 = func.call @calloc(%81, %83) : (i64, i64) -> !llvm.ptr
%84 = llvm.mlir.addressof @b_arr : !llvm.ptr
llvm.store %76, %84 : !llvm.ptr, !llvm.ptr
%86 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%87 = llvm.load %86 : !llvm.ptr -> i64
%88 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%89 = llvm.load %88 : !llvm.ptr -> i64
%90 = arith.muli %87, %89 : i64
%91 = arith.constant 4 : i32
%92 = arith.extsi %91 : i32 to i64
%85 = func.call @calloc(%90, %92) : (i64, i64) -> !llvm.ptr
%93 = llvm.mlir.addressof @suf_arr : !llvm.ptr
llvm.store %85, %93 : !llvm.ptr, !llvm.ptr
func.return
}
func.func @lyn(%arg0: !llvm.ptr) -> i64 {
%94 = arith.constant 1 : i32
%95 = arith.extsi %94 : i32 to i64
%96 = llvm.mlir.constant(1 : i64) : i64
%97 = llvm.alloca %96 x i64 : (i64) -> !llvm.ptr
llvm.store %95, %97 : i64, !llvm.ptr
%98 = arith.constant 2 : i32
%99 = arith.extsi %98 : i32 to i64
%100 = llvm.mlir.constant(1 : i64) : i64
%101 = llvm.alloca %100 x i64 : (i64) -> !llvm.ptr
llvm.store %99, %101 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%102 = llvm.load %101 : !llvm.ptr -> i64
%103 = llvm.mlir.addressof @ND : !llvm.ptr
%104 = llvm.load %103 : !llvm.ptr -> i64
%105 = arith.cmpi sle, %102, %104 : i64
cf.cond_br %105, ^bb4, ^bb5
^bb4:
%107 = llvm.load %101 : !llvm.ptr -> i64
%108 = llvm.getelementptr %arg0[%107] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%106 = llvm.load %108 : !llvm.ptr -> i32
%110 = llvm.load %101 : !llvm.ptr -> i64
%111 = llvm.load %97 : !llvm.ptr -> i64
%112 = arith.subi %110, %111 : i64
%113 = llvm.getelementptr %arg0[%112] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%109 = llvm.load %113 : !llvm.ptr -> i32
%114 = arith.cmpi slt, %106, %109 : i32
cf.cond_br %114, ^bb6, ^bb7
^bb6:
%115 = llvm.load %97 : !llvm.ptr -> i64
func.return %115 : i64
^bb7:
cf.br ^bb8
^bb8:
%117 = llvm.load %101 : !llvm.ptr -> i64
%118 = llvm.getelementptr %arg0[%117] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%116 = llvm.load %118 : !llvm.ptr -> i32
%120 = llvm.load %101 : !llvm.ptr -> i64
%121 = llvm.load %97 : !llvm.ptr -> i64
%122 = arith.subi %120, %121 : i64
%123 = llvm.getelementptr %arg0[%122] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%119 = llvm.load %123 : !llvm.ptr -> i32
%124 = arith.cmpi sgt, %116, %119 : i32
cf.cond_br %124, ^bb9, ^bb10
^bb9:
%125 = llvm.load %101 : !llvm.ptr -> i64
llvm.store %125, %97 : i64, !llvm.ptr
cf.br ^bb11
^bb10:
cf.br ^bb11
^bb11:
%126 = llvm.load %101 : !llvm.ptr -> i64
%127 = arith.constant 1 : i32
%129 = arith.extsi %127 : i32 to i64
%128 = arith.addi %126, %129 : i64
llvm.store %128, %101 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
%130 = llvm.load %97 : !llvm.ptr -> i64
func.return %130 : i64
}
func.func @is_necklace(%arg0: !llvm.ptr) -> i1 {
%131 = arith.constant 1 : i32
%132 = arith.extsi %131 : i32 to i64
%133 = llvm.mlir.constant(1 : i64) : i64
%134 = llvm.alloca %133 x i64 : (i64) -> !llvm.ptr
llvm.store %132, %134 : i64, !llvm.ptr
%135 = arith.constant 2 : i32
%136 = arith.extsi %135 : i32 to i64
%137 = llvm.mlir.constant(1 : i64) : i64
%138 = llvm.alloca %137 x i64 : (i64) -> !llvm.ptr
llvm.store %136, %138 : i64, !llvm.ptr
cf.br ^bb12
^bb12:
%139 = llvm.load %138 : !llvm.ptr -> i64
%140 = llvm.mlir.addressof @ND : !llvm.ptr
%141 = llvm.load %140 : !llvm.ptr -> i64
%142 = arith.cmpi sle, %139, %141 : i64
cf.cond_br %142, ^bb13, ^bb14
^bb13:
%144 = llvm.load %138 : !llvm.ptr -> i64
%145 = llvm.getelementptr %arg0[%144] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%143 = llvm.load %145 : !llvm.ptr -> i32
%147 = llvm.load %138 : !llvm.ptr -> i64
%148 = llvm.load %134 : !llvm.ptr -> i64
%149 = arith.subi %147, %148 : i64
%150 = llvm.getelementptr %arg0[%149] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%146 = llvm.load %150 : !llvm.ptr -> i32
%151 = arith.cmpi slt, %143, %146 : i32
cf.cond_br %151, ^bb15, ^bb16
^bb15:
%152 = arith.constant 0 : i1
func.return %152 : i1
^bb16:
cf.br ^bb17
^bb17:
%154 = llvm.load %138 : !llvm.ptr -> i64
%155 = llvm.getelementptr %arg0[%154] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%153 = llvm.load %155 : !llvm.ptr -> i32
%157 = llvm.load %138 : !llvm.ptr -> i64
%158 = llvm.load %134 : !llvm.ptr -> i64
%159 = arith.subi %157, %158 : i64
%160 = llvm.getelementptr %arg0[%159] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%156 = llvm.load %160 : !llvm.ptr -> i32
%161 = arith.cmpi sgt, %153, %156 : i32
cf.cond_br %161, ^bb18, ^bb19
^bb18:
%162 = llvm.load %138 : !llvm.ptr -> i64
llvm.store %162, %134 : i64, !llvm.ptr
cf.br ^bb20
^bb19:
cf.br ^bb20
^bb20:
%163 = llvm.load %138 : !llvm.ptr -> i64
%164 = arith.constant 1 : i32
%166 = arith.extsi %164 : i32 to i64
%165 = arith.addi %163, %166 : i64
llvm.store %165, %138 : i64, !llvm.ptr
cf.br ^bb12
^bb14:
%167 = llvm.mlir.addressof @ND : !llvm.ptr
%168 = llvm.load %167 : !llvm.ptr -> i64
%169 = llvm.load %134 : !llvm.ptr -> i64
%170 = arith.remsi %168, %169 : i64
%171 = arith.constant 0 : i32
%173 = arith.extsi %171 : i32 to i64
%172 = arith.cmpi eq, %170, %173 : i64
func.return %172 : i1
}
func.func @largest_necklace(%arg0: !llvm.ptr, %arg1: !llvm.ptr) -> () {
%174 = arith.constant 1 : i32
%175 = arith.extsi %174 : i32 to i64
%176 = llvm.mlir.constant(1 : i64) : i64
%177 = llvm.alloca %176 x i64 : (i64) -> !llvm.ptr
llvm.store %175, %177 : i64, !llvm.ptr
cf.br ^bb21
^bb21:
%178 = llvm.load %177 : !llvm.ptr -> i64
%179 = llvm.mlir.addressof @ND : !llvm.ptr
%180 = llvm.load %179 : !llvm.ptr -> i64
%181 = arith.cmpi sle, %178, %180 : i64
cf.cond_br %181, ^bb22, ^bb23
^bb22:
%183 = llvm.load %177 : !llvm.ptr -> i64
%184 = llvm.getelementptr %arg0[%183] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%182 = llvm.load %184 : !llvm.ptr -> i32
%185 = llvm.load %177 : !llvm.ptr -> i64
%186 = llvm.getelementptr %arg1[%185] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %182, %186 : i32, !llvm.ptr
%187 = llvm.load %177 : !llvm.ptr -> i64
%188 = arith.constant 1 : i32
%190 = arith.extsi %188 : i32 to i64
%189 = arith.addi %187, %190 : i64
llvm.store %189, %177 : i64, !llvm.ptr
cf.br ^bb21
^bb23:
cf.br ^bb24
^bb24:
%191 = func.call @is_necklace(%arg1) : (!llvm.ptr) -> i1
%193 = arith.constant 1 : i1
%192 = arith.xori %191, %193 : i1
cf.cond_br %192, ^bb25, ^bb26
^bb25:
%195 = func.call @lyn(%arg1) : (!llvm.ptr) -> i64
%197 = llvm.getelementptr %arg1[%195] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%196 = llvm.load %197 : !llvm.ptr -> i32
%198 = arith.constant 1 : i32
%199 = arith.subi %196, %198 : i32
%200 = llvm.getelementptr %arg1[%195] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %199, %200 : i32, !llvm.ptr
%201 = arith.constant 1 : i32
%203 = arith.extsi %201 : i32 to i64
%202 = arith.addi %195, %203 : i64
%204 = llvm.mlir.constant(1 : i64) : i64
%205 = llvm.alloca %204 x i64 : (i64) -> !llvm.ptr
llvm.store %202, %205 : i64, !llvm.ptr
cf.br ^bb27
^bb27:
%206 = llvm.load %205 : !llvm.ptr -> i64
%207 = llvm.mlir.addressof @ND : !llvm.ptr
%208 = llvm.load %207 : !llvm.ptr -> i64
%209 = arith.cmpi sle, %206, %208 : i64
cf.cond_br %209, ^bb28, ^bb29
^bb28:
%210 = llvm.mlir.addressof @KK : !llvm.ptr
%211 = llvm.load %210 : !llvm.ptr -> i64
%212 = arith.trunci %211 : i64 to i32
%213 = llvm.load %205 : !llvm.ptr -> i64
%214 = llvm.getelementptr %arg1[%213] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %212, %214 : i32, !llvm.ptr
%215 = llvm.load %205 : !llvm.ptr -> i64
%216 = arith.constant 1 : i32
%218 = arith.extsi %216 : i32 to i64
%217 = arith.addi %215, %218 : i64
llvm.store %217, %205 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
cf.br ^bb24
^bb26:
func.return
}
func.func @t_func(%arg0: !llvm.ptr) -> i64 {
%220 = llvm.mlir.addressof @t_neck : !llvm.ptr
%221 = llvm.load %220 : !llvm.ptr -> !llvm.ptr
func.call @largest_necklace(%arg0, %221) : (!llvm.ptr, !llvm.ptr) -> ()
%222 = arith.constant 1 : i32
%223 = llvm.mlir.addressof @b_arr : !llvm.ptr
%224 = llvm.load %223 : !llvm.ptr -> !llvm.ptr
%225 = arith.constant 0 : i32
%226 = arith.extsi %222 : i32 to i64
%227 = arith.extsi %225 : i32 to i64
%228 = llvm.getelementptr %224[%227] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %226, %228 : i64, !llvm.ptr
%229 = arith.constant 1 : i32
%230 = arith.extsi %229 : i32 to i64
%231 = llvm.mlir.constant(1 : i64) : i64
%232 = llvm.alloca %231 x i64 : (i64) -> !llvm.ptr
llvm.store %230, %232 : i64, !llvm.ptr
cf.br ^bb30
^bb30:
%233 = llvm.load %232 : !llvm.ptr -> i64
%234 = llvm.mlir.addressof @ND : !llvm.ptr
%235 = llvm.load %234 : !llvm.ptr -> i64
%236 = arith.cmpi sle, %233, %235 : i64
cf.cond_br %236, ^bb31, ^bb32
^bb31:
%237 = arith.constant 0 : i32
%238 = llvm.mlir.addressof @b_arr : !llvm.ptr
%239 = llvm.load %238 : !llvm.ptr -> !llvm.ptr
%240 = llvm.load %232 : !llvm.ptr -> i64
%241 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%242 = llvm.load %241 : !llvm.ptr -> i64
%243 = arith.muli %240, %242 : i64
%244 = llvm.load %232 : !llvm.ptr -> i64
%245 = arith.addi %243, %244 : i64
%246 = arith.extsi %237 : i32 to i64
%247 = llvm.getelementptr %239[%245] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %246, %247 : i64, !llvm.ptr
%248 = llvm.load %232 : !llvm.ptr -> i64
%249 = arith.constant 1 : i32
%251 = arith.extsi %249 : i32 to i64
%250 = arith.subi %248, %251 : i64
%252 = llvm.mlir.constant(1 : i64) : i64
%253 = llvm.alloca %252 x i64 : (i64) -> !llvm.ptr
llvm.store %250, %253 : i64, !llvm.ptr
cf.br ^bb33
^bb33:
%254 = llvm.load %253 : !llvm.ptr -> i64
%255 = arith.constant 0 : i32
%257 = arith.extsi %255 : i32 to i64
%256 = arith.cmpi sge, %254, %257 : i64
cf.cond_br %256, ^bb34, ^bb35
^bb34:
%259 = llvm.mlir.addressof @b_arr : !llvm.ptr
%260 = llvm.load %259 : !llvm.ptr -> !llvm.ptr
%261 = llvm.load %232 : !llvm.ptr -> i64
%262 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%263 = llvm.load %262 : !llvm.ptr -> i64
%264 = arith.muli %261, %263 : i64
%265 = llvm.load %253 : !llvm.ptr -> i64
%266 = arith.addi %264, %265 : i64
%267 = arith.constant 1 : i32
%269 = arith.extsi %267 : i32 to i64
%268 = arith.addi %266, %269 : i64
%270 = llvm.getelementptr %260[%268] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%258 = llvm.load %270 : !llvm.ptr -> i64
%271 = llvm.mlir.addressof @KK : !llvm.ptr
%272 = llvm.load %271 : !llvm.ptr -> i64
%274 = llvm.mlir.addressof @t_neck : !llvm.ptr
%275 = llvm.load %274 : !llvm.ptr -> !llvm.ptr
%276 = llvm.load %253 : !llvm.ptr -> i64
%277 = arith.constant 1 : i32
%279 = arith.extsi %277 : i32 to i64
%278 = arith.addi %276, %279 : i64
%280 = llvm.getelementptr %275[%278] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%273 = llvm.load %280 : !llvm.ptr -> i32
%281 = arith.extsi %273 : i32 to i64
%282 = arith.subi %272, %281 : i64
%284 = llvm.mlir.addressof @b_arr : !llvm.ptr
%285 = llvm.load %284 : !llvm.ptr -> !llvm.ptr
%286 = llvm.load %232 : !llvm.ptr -> i64
%287 = llvm.load %253 : !llvm.ptr -> i64
%288 = arith.subi %286, %287 : i64
%289 = arith.constant 1 : i32
%291 = arith.extsi %289 : i32 to i64
%290 = arith.subi %288, %291 : i64
%292 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%293 = llvm.load %292 : !llvm.ptr -> i64
%294 = arith.muli %290, %293 : i64
%295 = arith.constant 0 : i32
%297 = arith.extsi %295 : i32 to i64
%296 = arith.addi %294, %297 : i64
%298 = llvm.getelementptr %285[%296] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%283 = llvm.load %298 : !llvm.ptr -> i64
%299 = arith.muli %282, %283 : i64
%300 = arith.addi %258, %299 : i64
%301 = llvm.mlir.addressof @b_arr : !llvm.ptr
%302 = llvm.load %301 : !llvm.ptr -> !llvm.ptr
%303 = llvm.load %232 : !llvm.ptr -> i64
%304 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%305 = llvm.load %304 : !llvm.ptr -> i64
%306 = arith.muli %303, %305 : i64
%307 = llvm.load %253 : !llvm.ptr -> i64
%308 = arith.addi %306, %307 : i64
%309 = llvm.getelementptr %302[%308] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %300, %309 : i64, !llvm.ptr
%310 = llvm.load %253 : !llvm.ptr -> i64
%311 = arith.constant 1 : i32
%313 = arith.extsi %311 : i32 to i64
%312 = arith.subi %310, %313 : i64
llvm.store %312, %253 : i64, !llvm.ptr
cf.br ^bb33
^bb35:
%314 = llvm.load %232 : !llvm.ptr -> i64
%315 = arith.constant 1 : i32
%317 = arith.extsi %315 : i32 to i64
%316 = arith.addi %314, %317 : i64
llvm.store %316, %232 : i64, !llvm.ptr
cf.br ^bb30
^bb32:
%318 = arith.constant 2 : i32
%319 = arith.extsi %318 : i32 to i64
%320 = llvm.mlir.constant(1 : i64) : i64
%321 = llvm.alloca %320 x i64 : (i64) -> !llvm.ptr
llvm.store %319, %321 : i64, !llvm.ptr
cf.br ^bb36
^bb36:
%322 = llvm.load %321 : !llvm.ptr -> i64
%323 = llvm.mlir.addressof @ND : !llvm.ptr
%324 = llvm.load %323 : !llvm.ptr -> i64
%325 = arith.cmpi sle, %322, %324 : i64
cf.cond_br %325, ^bb37, ^bb38
^bb37:
%326 = llvm.load %321 : !llvm.ptr -> i64
%327 = llvm.mlir.constant(1 : i64) : i64
%328 = llvm.alloca %327 x i64 : (i64) -> !llvm.ptr
llvm.store %326, %328 : i64, !llvm.ptr
%329 = llvm.load %321 : !llvm.ptr -> i64
%330 = llvm.mlir.constant(1 : i64) : i64
%331 = llvm.alloca %330 x i64 : (i64) -> !llvm.ptr
llvm.store %329, %331 : i64, !llvm.ptr
cf.br ^bb39
^bb39:
%332 = llvm.load %331 : !llvm.ptr -> i64
%333 = llvm.mlir.addressof @ND : !llvm.ptr
%334 = llvm.load %333 : !llvm.ptr -> i64
%335 = arith.cmpi sle, %332, %334 : i64
cf.cond_br %335, ^bb40, ^bb41
^bb40:
%337 = llvm.mlir.addressof @t_neck : !llvm.ptr
%338 = llvm.load %337 : !llvm.ptr -> !llvm.ptr
%339 = llvm.load %331 : !llvm.ptr -> i64
%340 = llvm.getelementptr %338[%339] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%336 = llvm.load %340 : !llvm.ptr -> i32
%342 = llvm.mlir.addressof @t_neck : !llvm.ptr
%343 = llvm.load %342 : !llvm.ptr -> !llvm.ptr
%344 = llvm.load %331 : !llvm.ptr -> i64
%345 = llvm.load %328 : !llvm.ptr -> i64
%346 = arith.subi %344, %345 : i64
%347 = arith.constant 1 : i32
%349 = arith.extsi %347 : i32 to i64
%348 = arith.addi %346, %349 : i64
%350 = llvm.getelementptr %343[%348] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%341 = llvm.load %350 : !llvm.ptr -> i32
%351 = arith.cmpi sgt, %336, %341 : i32
cf.cond_br %351, ^bb42, ^bb43
^bb42:
%352 = llvm.load %331 : !llvm.ptr -> i64
%353 = arith.constant 1 : i32
%355 = arith.extsi %353 : i32 to i64
%354 = arith.addi %352, %355 : i64
llvm.store %354, %328 : i64, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%356 = llvm.load %331 : !llvm.ptr -> i64
%357 = llvm.load %328 : !llvm.ptr -> i64
%358 = arith.subi %356, %357 : i64
%359 = arith.constant 1 : i32
%361 = arith.extsi %359 : i32 to i64
%360 = arith.addi %358, %361 : i64
%362 = arith.trunci %360 : i64 to i32
%363 = llvm.mlir.addressof @suf_arr : !llvm.ptr
%364 = llvm.load %363 : !llvm.ptr -> !llvm.ptr
%365 = llvm.load %321 : !llvm.ptr -> i64
%366 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%367 = llvm.load %366 : !llvm.ptr -> i64
%368 = arith.muli %365, %367 : i64
%369 = llvm.load %331 : !llvm.ptr -> i64
%370 = arith.addi %368, %369 : i64
%371 = llvm.getelementptr %364[%370] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %362, %371 : i32, !llvm.ptr
%372 = llvm.load %331 : !llvm.ptr -> i64
%373 = arith.constant 1 : i32
%375 = arith.extsi %373 : i32 to i64
%374 = arith.addi %372, %375 : i64
llvm.store %374, %331 : i64, !llvm.ptr
cf.br ^bb39
^bb41:
%376 = llvm.load %321 : !llvm.ptr -> i64
%377 = arith.constant 1 : i32
%379 = arith.extsi %377 : i32 to i64
%378 = arith.addi %376, %379 : i64
llvm.store %378, %321 : i64, !llvm.ptr
cf.br ^bb36
^bb38:
%381 = llvm.mlir.addressof @t_neck : !llvm.ptr
%382 = llvm.load %381 : !llvm.ptr -> !llvm.ptr
%380 = func.call @lyn(%382) : (!llvm.ptr) -> i64
%383 = llvm.mlir.constant(1 : i64) : i64
%384 = llvm.alloca %383 x i64 : (i64) -> !llvm.ptr
llvm.store %380, %384 : i64, !llvm.ptr
%385 = arith.constant 1 : i32
%386 = arith.extsi %385 : i32 to i64
llvm.store %386, %232 : i64, !llvm.ptr
cf.br ^bb45
^bb45:
%387 = llvm.load %232 : !llvm.ptr -> i64
%388 = llvm.mlir.addressof @ND : !llvm.ptr
%389 = llvm.load %388 : !llvm.ptr -> i64
%390 = arith.cmpi sle, %387, %389 : i64
cf.cond_br %390, ^bb46, ^bb47
^bb46:
%392 = llvm.mlir.addressof @b_arr : !llvm.ptr
%393 = llvm.load %392 : !llvm.ptr -> !llvm.ptr
%394 = llvm.load %232 : !llvm.ptr -> i64
%395 = arith.constant 1 : i32
%397 = arith.extsi %395 : i32 to i64
%396 = arith.subi %394, %397 : i64
%398 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%399 = llvm.load %398 : !llvm.ptr -> i64
%400 = arith.muli %396, %399 : i64
%401 = arith.constant 0 : i32
%403 = arith.extsi %401 : i32 to i64
%402 = arith.addi %400, %403 : i64
%404 = llvm.getelementptr %393[%402] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%391 = llvm.load %404 : !llvm.ptr -> i64
%405 = arith.constant 0 : i32
%406 = arith.extsi %405 : i32 to i64
%407 = llvm.mlir.constant(1 : i64) : i64
%408 = llvm.alloca %407 x i64 : (i64) -> !llvm.ptr
llvm.store %406, %408 : i64, !llvm.ptr
cf.br ^bb48
^bb48:
%409 = llvm.load %408 : !llvm.ptr -> i64
%410 = llvm.mlir.addressof @ND : !llvm.ptr
%411 = llvm.load %410 : !llvm.ptr -> i64
%412 = arith.cmpi slt, %409, %411 : i64
cf.cond_br %412, ^bb49, ^bb50
^bb49:
%413 = llvm.load %408 : !llvm.ptr -> i64
%414 = llvm.load %232 : !llvm.ptr -> i64
%415 = arith.addi %413, %414 : i64
%416 = llvm.mlir.addressof @ND : !llvm.ptr
%417 = llvm.load %416 : !llvm.ptr -> i64
%418 = arith.cmpi sle, %415, %417 : i64
cf.cond_br %418, ^bb51, ^bb52
^bb51:
%419 = llvm.load %384 : !llvm.ptr -> i64
%421 = llvm.mlir.addressof @t_neck : !llvm.ptr
%422 = llvm.load %421 : !llvm.ptr -> !llvm.ptr
%423 = llvm.load %408 : !llvm.ptr -> i64
%424 = arith.constant 1 : i32
%426 = arith.extsi %424 : i32 to i64
%425 = arith.addi %423, %426 : i64
%427 = llvm.getelementptr %422[%425] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%420 = llvm.load %427 : !llvm.ptr -> i32
%428 = arith.extsi %420 : i32 to i64
%429 = arith.constant 1 : i32
%431 = arith.extsi %429 : i32 to i64
%430 = arith.subi %428, %431 : i64
%432 = arith.muli %391, %430 : i64
%434 = llvm.mlir.addressof @power_arr : !llvm.ptr
%435 = llvm.load %434 : !llvm.ptr -> !llvm.ptr
%436 = llvm.mlir.addressof @ND : !llvm.ptr
%437 = llvm.load %436 : !llvm.ptr -> i64
%438 = llvm.load %232 : !llvm.ptr -> i64
%439 = arith.subi %437, %438 : i64
%440 = llvm.load %408 : !llvm.ptr -> i64
%441 = arith.subi %439, %440 : i64
%442 = llvm.getelementptr %435[%441] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%433 = llvm.load %442 : !llvm.ptr -> i64
%443 = arith.muli %432, %433 : i64
%444 = arith.addi %419, %443 : i64
llvm.store %444, %384 : i64, !llvm.ptr
cf.br ^bb53
^bb52:
%445 = arith.constant 0 : i32
%446 = arith.extsi %445 : i32 to i64
%447 = llvm.mlir.constant(1 : i64) : i64
%448 = llvm.alloca %447 x i64 : (i64) -> !llvm.ptr
llvm.store %446, %448 : i64, !llvm.ptr
%449 = llvm.load %408 : !llvm.ptr -> i64
%450 = llvm.mlir.addressof @ND : !llvm.ptr
%451 = llvm.load %450 : !llvm.ptr -> i64
%452 = llvm.load %232 : !llvm.ptr -> i64
%453 = arith.subi %451, %452 : i64
%454 = arith.constant 2 : i32
%456 = arith.extsi %454 : i32 to i64
%455 = arith.addi %453, %456 : i64
%457 = arith.cmpi sge, %449, %455 : i64
cf.cond_br %457, ^bb54, ^bb55
^bb54:
%459 = llvm.mlir.addressof @suf_arr : !llvm.ptr
%460 = llvm.load %459 : !llvm.ptr -> !llvm.ptr
%461 = llvm.mlir.addressof @ND : !llvm.ptr
%462 = llvm.load %461 : !llvm.ptr -> i64
%463 = llvm.load %232 : !llvm.ptr -> i64
%464 = arith.subi %462, %463 : i64
%465 = arith.constant 2 : i32
%467 = arith.extsi %465 : i32 to i64
%466 = arith.addi %464, %467 : i64
%468 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%469 = llvm.load %468 : !llvm.ptr -> i64
%470 = arith.muli %466, %469 : i64
%471 = llvm.load %408 : !llvm.ptr -> i64
%472 = arith.addi %470, %471 : i64
%473 = llvm.getelementptr %460[%472] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%458 = llvm.load %473 : !llvm.ptr -> i32
%474 = arith.extsi %458 : i32 to i64
llvm.store %474, %448 : i64, !llvm.ptr
cf.br ^bb56
^bb55:
cf.br ^bb56
^bb56:
%476 = llvm.mlir.addressof @t_neck : !llvm.ptr
%477 = llvm.load %476 : !llvm.ptr -> !llvm.ptr
%478 = llvm.load %408 : !llvm.ptr -> i64
%479 = arith.constant 1 : i32
%481 = arith.extsi %479 : i32 to i64
%480 = arith.addi %478, %481 : i64
%482 = llvm.getelementptr %477[%480] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%475 = llvm.load %482 : !llvm.ptr -> i32
%483 = arith.extsi %475 : i32 to i64
%485 = llvm.mlir.addressof @t_neck : !llvm.ptr
%486 = llvm.load %485 : !llvm.ptr -> !llvm.ptr
%487 = llvm.load %448 : !llvm.ptr -> i64
%488 = arith.constant 1 : i32
%490 = arith.extsi %488 : i32 to i64
%489 = arith.addi %487, %490 : i64
%491 = llvm.getelementptr %486[%489] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%484 = llvm.load %491 : !llvm.ptr -> i32
%492 = arith.extsi %484 : i32 to i64
%493 = arith.cmpi sgt, %483, %492 : i64
cf.cond_br %493, ^bb57, ^bb58
^bb57:
%494 = llvm.load %384 : !llvm.ptr -> i64
%496 = llvm.mlir.addressof @b_arr : !llvm.ptr
%497 = llvm.load %496 : !llvm.ptr -> !llvm.ptr
%498 = llvm.mlir.addressof @ND : !llvm.ptr
%499 = llvm.load %498 : !llvm.ptr -> i64
%500 = llvm.load %408 : !llvm.ptr -> i64
%501 = arith.subi %499, %500 : i64
%502 = llvm.load %448 : !llvm.ptr -> i64
%503 = arith.addi %501, %502 : i64
%504 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%505 = llvm.load %504 : !llvm.ptr -> i64
%506 = arith.muli %503, %505 : i64
%507 = llvm.load %448 : !llvm.ptr -> i64
%508 = arith.addi %506, %507 : i64
%509 = arith.constant 1 : i32
%511 = arith.extsi %509 : i32 to i64
%510 = arith.addi %508, %511 : i64
%512 = llvm.getelementptr %497[%510] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%495 = llvm.load %512 : !llvm.ptr -> i64
%513 = arith.addi %494, %495 : i64
%515 = llvm.mlir.addressof @t_neck : !llvm.ptr
%516 = llvm.load %515 : !llvm.ptr -> !llvm.ptr
%517 = llvm.load %408 : !llvm.ptr -> i64
%518 = arith.constant 1 : i32
%520 = arith.extsi %518 : i32 to i64
%519 = arith.addi %517, %520 : i64
%521 = llvm.getelementptr %516[%519] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%514 = llvm.load %521 : !llvm.ptr -> i32
%522 = arith.extsi %514 : i32 to i64
%524 = llvm.mlir.addressof @t_neck : !llvm.ptr
%525 = llvm.load %524 : !llvm.ptr -> !llvm.ptr
%526 = llvm.load %448 : !llvm.ptr -> i64
%527 = arith.constant 1 : i32
%529 = arith.extsi %527 : i32 to i64
%528 = arith.addi %526, %529 : i64
%530 = llvm.getelementptr %525[%528] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%523 = llvm.load %530 : !llvm.ptr -> i32
%531 = arith.extsi %523 : i32 to i64
%532 = arith.subi %522, %531 : i64
%533 = arith.constant 1 : i32
%535 = arith.extsi %533 : i32 to i64
%534 = arith.subi %532, %535 : i64
%537 = llvm.mlir.addressof @b_arr : !llvm.ptr
%538 = llvm.load %537 : !llvm.ptr -> !llvm.ptr
%539 = llvm.mlir.addressof @ND : !llvm.ptr
%540 = llvm.load %539 : !llvm.ptr -> i64
%541 = llvm.load %408 : !llvm.ptr -> i64
%542 = arith.subi %540, %541 : i64
%543 = arith.constant 1 : i32
%545 = arith.extsi %543 : i32 to i64
%544 = arith.subi %542, %545 : i64
%546 = llvm.mlir.addressof @STRIDE : !llvm.ptr
%547 = llvm.load %546 : !llvm.ptr -> i64
%548 = arith.muli %544, %547 : i64
%549 = arith.constant 0 : i32
%551 = arith.extsi %549 : i32 to i64
%550 = arith.addi %548, %551 : i64
%552 = llvm.getelementptr %538[%550] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%536 = llvm.load %552 : !llvm.ptr -> i64
%553 = arith.muli %534, %536 : i64
%554 = arith.addi %513, %553 : i64
llvm.store %554, %384 : i64, !llvm.ptr
cf.br ^bb59
^bb58:
cf.br ^bb59
^bb59:
cf.br ^bb53
^bb53:
%555 = llvm.load %408 : !llvm.ptr -> i64
%556 = arith.constant 1 : i32
%558 = arith.extsi %556 : i32 to i64
%557 = arith.addi %555, %558 : i64
llvm.store %557, %408 : i64, !llvm.ptr
cf.br ^bb48
^bb50:
%559 = llvm.load %232 : !llvm.ptr -> i64
%560 = arith.constant 1 : i32
%562 = arith.extsi %560 : i32 to i64
%561 = arith.addi %559, %562 : i64
llvm.store %561, %232 : i64, !llvm.ptr
cf.br ^bb45
^bb47:
%563 = llvm.load %384 : !llvm.ptr -> i64
func.return %563 : i64
}
func.func @rank_db(%arg0: !llvm.ptr) -> i64 {
%564 = arith.constant 0 : i32
%565 = arith.extsi %564 : i32 to i64
%566 = llvm.mlir.constant(1 : i64) : i64
%567 = llvm.alloca %566 x i64 : (i64) -> !llvm.ptr
llvm.store %565, %567 : i64, !llvm.ptr
cf.br ^bb60
^bb60:
%568 = llvm.load %567 : !llvm.ptr -> i64
%569 = llvm.mlir.addressof @ND : !llvm.ptr
%570 = llvm.load %569 : !llvm.ptr -> i64
%571 = arith.cmpi slt, %568, %570 : i64
%572 = scf.if %571 -> (i1) {
%574 = llvm.load %567 : !llvm.ptr -> i64
%575 = arith.constant 1 : i32
%577 = arith.extsi %575 : i32 to i64
%576 = arith.addi %574, %577 : i64
%578 = llvm.getelementptr %arg0[%576] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%573 = llvm.load %578 : !llvm.ptr -> i32
%579 = arith.extsi %573 : i32 to i64
%580 = llvm.mlir.addressof @KK : !llvm.ptr
%581 = llvm.load %580 : !llvm.ptr -> i64
%582 = arith.cmpi eq, %579, %581 : i64
scf.yield %582 : i1
} else {
%583 = arith.constant false
scf.yield %583 : i1
}
cf.cond_br %572, ^bb61, ^bb62
^bb61:
%584 = llvm.load %567 : !llvm.ptr -> i64
%585 = arith.constant 1 : i32
%587 = arith.extsi %585 : i32 to i64
%586 = arith.addi %584, %587 : i64
llvm.store %586, %567 : i64, !llvm.ptr
cf.br ^bb60
^bb62:
%588 = llvm.load %567 : !llvm.ptr -> i64
%589 = llvm.mlir.constant(1 : i64) : i64
%590 = llvm.alloca %589 x i64 : (i64) -> !llvm.ptr
llvm.store %588, %590 : i64, !llvm.ptr
cf.br ^bb63
^bb63:
%591 = llvm.load %590 : !llvm.ptr -> i64
%592 = llvm.mlir.addressof @ND : !llvm.ptr
%593 = llvm.load %592 : !llvm.ptr -> i64
%594 = arith.cmpi slt, %591, %593 : i64
%595 = scf.if %594 -> (i1) {
%597 = llvm.load %590 : !llvm.ptr -> i64
%598 = arith.constant 1 : i32
%600 = arith.extsi %598 : i32 to i64
%599 = arith.addi %597, %600 : i64
%601 = llvm.getelementptr %arg0[%599] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%596 = llvm.load %601 : !llvm.ptr -> i32
%602 = arith.constant 1 : i32
%603 = arith.cmpi eq, %596, %602 : i32
scf.yield %603 : i1
} else {
%604 = arith.constant false
scf.yield %604 : i1
}
cf.cond_br %595, ^bb64, ^bb65
^bb64:
%605 = llvm.load %590 : !llvm.ptr -> i64
%606 = arith.constant 1 : i32
%608 = arith.extsi %606 : i32 to i64
%607 = arith.addi %605, %608 : i64
llvm.store %607, %590 : i64, !llvm.ptr
cf.br ^bb63
^bb65:
%609 = llvm.load %567 : !llvm.ptr -> i64
%610 = arith.constant 1 : i32
%612 = arith.extsi %610 : i32 to i64
%611 = arith.cmpi sge, %609, %612 : i64
%613 = scf.if %611 -> (i1) {
%614 = llvm.load %590 : !llvm.ptr -> i64
%615 = llvm.mlir.addressof @ND : !llvm.ptr
%616 = llvm.load %615 : !llvm.ptr -> i64
%617 = arith.cmpi eq, %614, %616 : i64
scf.yield %617 : i1
} else {
%618 = arith.constant false
scf.yield %618 : i1
}
cf.cond_br %613, ^bb66, ^bb67
^bb66:
%620 = llvm.mlir.addressof @power_arr : !llvm.ptr
%621 = llvm.load %620 : !llvm.ptr -> !llvm.ptr
%622 = llvm.mlir.addressof @ND : !llvm.ptr
%623 = llvm.load %622 : !llvm.ptr -> i64
%624 = llvm.getelementptr %621[%623] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%619 = llvm.load %624 : !llvm.ptr -> i64
%625 = llvm.load %567 : !llvm.ptr -> i64
%626 = arith.subi %619, %625 : i64
%627 = arith.constant 1 : i32
%629 = arith.extsi %627 : i32 to i64
%628 = arith.addi %626, %629 : i64
func.return %628 : i64
^bb67:
cf.br ^bb68
^bb68:
%630 = func.call @is_necklace(%arg0) : (!llvm.ptr) -> i1
cf.cond_br %630, ^bb69, ^bb70
^bb69:
%631 = arith.constant 1 : i32
%632 = func.call @lyn(%arg0) : (!llvm.ptr) -> i64
%634 = arith.extsi %631 : i32 to i64
%633 = arith.subi %634, %632 : i64
%635 = func.call @t_func(%arg0) : (!llvm.ptr) -> i64
%636 = arith.addi %633, %635 : i64
func.return %636 : i64
^bb70:
cf.br ^bb71
^bb71:
%637 = arith.constant 1 : i32
%638 = arith.extsi %637 : i32 to i64
%639 = llvm.mlir.constant(1 : i64) : i64
%640 = llvm.alloca %639 x i64 : (i64) -> !llvm.ptr
llvm.store %638, %640 : i64, !llvm.ptr
cf.br ^bb72
^bb72:
%641 = llvm.load %640 : !llvm.ptr -> i64
%642 = llvm.mlir.addressof @ND : !llvm.ptr
%643 = llvm.load %642 : !llvm.ptr -> i64
%644 = arith.cmpi sle, %641, %643 : i64
cf.cond_br %644, ^bb73, ^bb74
^bb73:
%646 = llvm.load %640 : !llvm.ptr -> i64
%647 = llvm.getelementptr %arg0[%646] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%645 = llvm.load %647 : !llvm.ptr -> i32
%648 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%649 = llvm.load %648 : !llvm.ptr -> !llvm.ptr
%650 = llvm.load %640 : !llvm.ptr -> i64
%651 = llvm.getelementptr %649[%650] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %645, %651 : i32, !llvm.ptr
%652 = llvm.load %640 : !llvm.ptr -> i64
%653 = arith.constant 1 : i32
%655 = arith.extsi %653 : i32 to i64
%654 = arith.addi %652, %655 : i64
llvm.store %654, %640 : i64, !llvm.ptr
cf.br ^bb72
^bb74:
%656 = arith.constant 0 : i32
%657 = arith.extsi %656 : i32 to i64
%658 = llvm.mlir.constant(1 : i64) : i64
%659 = llvm.alloca %658 x i64 : (i64) -> !llvm.ptr
llvm.store %657, %659 : i64, !llvm.ptr
cf.br ^bb75
^bb75:
%661 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%662 = llvm.load %661 : !llvm.ptr -> !llvm.ptr
%660 = func.call @is_necklace(%662) : (!llvm.ptr) -> i1
%664 = arith.constant 1 : i1
%663 = arith.xori %660, %664 : i1
cf.cond_br %663, ^bb76, ^bb77
^bb76:
%666 = llvm.load %659 : !llvm.ptr -> i64
%667 = arith.constant 1 : i32
%669 = arith.extsi %667 : i32 to i64
%668 = arith.addi %666, %669 : i64
llvm.store %668, %659 : i64, !llvm.ptr
%670 = arith.constant 1 : i32
%671 = arith.extsi %670 : i32 to i64
llvm.store %671, %640 : i64, !llvm.ptr
cf.br ^bb78
^bb78:
%672 = llvm.load %640 : !llvm.ptr -> i64
%673 = llvm.mlir.addressof @ND : !llvm.ptr
%674 = llvm.load %673 : !llvm.ptr -> i64
%675 = arith.cmpi sle, %672, %674 : i64
cf.cond_br %675, ^bb79, ^bb80
^bb79:
%676 = llvm.load %640 : !llvm.ptr -> i64
%677 = llvm.load %659 : !llvm.ptr -> i64
%678 = arith.addi %676, %677 : i64
%679 = llvm.mlir.addressof @ND : !llvm.ptr
%680 = llvm.load %679 : !llvm.ptr -> i64
%681 = arith.cmpi sle, %678, %680 : i64
cf.cond_br %681, ^bb81, ^bb82
^bb81:
%683 = llvm.getelementptr %arg0[%678] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%682 = llvm.load %683 : !llvm.ptr -> i32
%684 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%685 = llvm.load %684 : !llvm.ptr -> !llvm.ptr
%686 = llvm.load %640 : !llvm.ptr -> i64
%687 = llvm.getelementptr %685[%686] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %682, %687 : i32, !llvm.ptr
cf.br ^bb83
^bb82:
%689 = llvm.mlir.addressof @ND : !llvm.ptr
%690 = llvm.load %689 : !llvm.ptr -> i64
%691 = arith.subi %678, %690 : i64
%692 = llvm.getelementptr %arg0[%691] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%688 = llvm.load %692 : !llvm.ptr -> i32
%693 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%694 = llvm.load %693 : !llvm.ptr -> !llvm.ptr
%695 = llvm.load %640 : !llvm.ptr -> i64
%696 = llvm.getelementptr %694[%695] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %688, %696 : i32, !llvm.ptr
cf.br ^bb83
^bb83:
%697 = llvm.load %640 : !llvm.ptr -> i64
%698 = arith.constant 1 : i32
%700 = arith.extsi %698 : i32 to i64
%699 = arith.addi %697, %700 : i64
llvm.store %699, %640 : i64, !llvm.ptr
cf.br ^bb78
^bb80:
cf.br ^bb75
^bb77:
%702 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%703 = llvm.load %702 : !llvm.ptr -> !llvm.ptr
%701 = func.call @lyn(%703) : (!llvm.ptr) -> i64
%704 = llvm.load %659 : !llvm.ptr -> i64
%705 = llvm.load %567 : !llvm.ptr -> i64
%706 = arith.cmpi ne, %704, %705 : i64
cf.cond_br %706, ^bb84, ^bb85
^bb84:
%707 = arith.constant 1 : i32
%709 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%710 = llvm.load %709 : !llvm.ptr -> !llvm.ptr
%708 = func.call @t_func(%710) : (!llvm.ptr) -> i64
%712 = arith.extsi %707 : i32 to i64
%711 = arith.addi %712, %708 : i64
%713 = llvm.load %659 : !llvm.ptr -> i64
%714 = arith.subi %711, %713 : i64
func.return %714 : i64
^bb85:
cf.br ^bb86
^bb86:
%715 = llvm.mlir.addressof @ND : !llvm.ptr
%716 = llvm.load %715 : !llvm.ptr -> i64
%717 = arith.cmpi slt, %701, %716 : i64
cf.cond_br %717, ^bb87, ^bb88
^bb87:
%718 = arith.constant 1 : i32
%720 = arith.extsi %718 : i32 to i64
%719 = arith.subi %720, %701 : i64
%722 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%723 = llvm.load %722 : !llvm.ptr -> !llvm.ptr
%721 = func.call @t_func(%723) : (!llvm.ptr) -> i64
%724 = arith.addi %719, %721 : i64
%725 = llvm.load %659 : !llvm.ptr -> i64
%726 = arith.subi %724, %725 : i64
func.return %726 : i64
^bb88:
cf.br ^bb89
^bb89:
%727 = llvm.mlir.addressof @ND : !llvm.ptr
%728 = llvm.load %727 : !llvm.ptr -> i64
%729 = llvm.load %659 : !llvm.ptr -> i64
%730 = arith.subi %728, %729 : i64
%731 = arith.constant 1 : i32
%733 = arith.extsi %731 : i32 to i64
%732 = arith.addi %730, %733 : i64
llvm.store %732, %640 : i64, !llvm.ptr
cf.br ^bb90
^bb90:
%734 = llvm.load %640 : !llvm.ptr -> i64
%735 = llvm.mlir.addressof @ND : !llvm.ptr
%736 = llvm.load %735 : !llvm.ptr -> i64
%737 = arith.cmpi sle, %734, %736 : i64
cf.cond_br %737, ^bb91, ^bb92
^bb91:
%738 = arith.constant 1 : i32
%739 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%740 = llvm.load %739 : !llvm.ptr -> !llvm.ptr
%741 = llvm.load %640 : !llvm.ptr -> i64
%742 = llvm.getelementptr %740[%741] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %738, %742 : i32, !llvm.ptr
%743 = llvm.load %640 : !llvm.ptr -> i64
%744 = arith.constant 1 : i32
%746 = arith.extsi %744 : i32 to i64
%745 = arith.addi %743, %746 : i64
llvm.store %745, %640 : i64, !llvm.ptr
cf.br ^bb90
^bb92:
%748 = llvm.mlir.addressof @neck_rep : !llvm.ptr
%749 = llvm.load %748 : !llvm.ptr -> !llvm.ptr
%750 = llvm.mlir.addressof @prev_arr : !llvm.ptr
%751 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
func.call @largest_necklace(%749, %751) : (!llvm.ptr, !llvm.ptr) -> ()
%752 = arith.constant 1 : i32
%754 = llvm.mlir.addressof @prev_arr : !llvm.ptr
%755 = llvm.load %754 : !llvm.ptr -> !llvm.ptr
%753 = func.call @t_func(%755) : (!llvm.ptr) -> i64
%757 = arith.extsi %752 : i32 to i64
%756 = arith.addi %757, %753 : i64
%758 = llvm.load %659 : !llvm.ptr -> i64
%759 = arith.subi %756, %758 : i64
func.return %759 : i64
}
func.func @int_to_word12(%arg0: i64, %arg1: !llvm.ptr) -> () {
%760 = arith.constant 100000000 : i32
%762 = arith.extsi %760 : i32 to i64
%761 = arith.divsi %arg0, %762 : i64
%763 = arith.constant 10000 : i32
%765 = arith.extsi %763 : i32 to i64
%764 = arith.divsi %arg0, %765 : i64
%766 = arith.constant 10000 : i32
%768 = arith.extsi %766 : i32 to i64
%767 = arith.remsi %764, %768 : i64
%769 = arith.constant 10000 : i32
%771 = arith.extsi %769 : i32 to i64
%770 = arith.remsi %arg0, %771 : i64
%772 = arith.constant 1000 : i32
%774 = arith.extsi %772 : i32 to i64
%773 = arith.divsi %761, %774 : i64
%775 = arith.constant 1 : i32
%777 = arith.extsi %775 : i32 to i64
%776 = arith.addi %773, %777 : i64
%778 = arith.trunci %776 : i64 to i32
%779 = arith.constant 1 : i32
%780 = arith.extsi %779 : i32 to i64
%781 = llvm.getelementptr %arg1[%780] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %778, %781 : i32, !llvm.ptr
%782 = arith.constant 100 : i32
%784 = arith.extsi %782 : i32 to i64
%783 = arith.divsi %761, %784 : i64
%785 = arith.constant 10 : i32
%787 = arith.extsi %785 : i32 to i64
%786 = arith.remsi %783, %787 : i64
%788 = arith.constant 1 : i32
%790 = arith.extsi %788 : i32 to i64
%789 = arith.addi %786, %790 : i64
%791 = arith.trunci %789 : i64 to i32
%792 = arith.constant 2 : i32
%793 = arith.extsi %792 : i32 to i64
%794 = llvm.getelementptr %arg1[%793] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %791, %794 : i32, !llvm.ptr
%795 = arith.constant 10 : i32
%797 = arith.extsi %795 : i32 to i64
%796 = arith.divsi %761, %797 : i64
%798 = arith.constant 10 : i32
%800 = arith.extsi %798 : i32 to i64
%799 = arith.remsi %796, %800 : i64
%801 = arith.constant 1 : i32
%803 = arith.extsi %801 : i32 to i64
%802 = arith.addi %799, %803 : i64
%804 = arith.trunci %802 : i64 to i32
%805 = arith.constant 3 : i32
%806 = arith.extsi %805 : i32 to i64
%807 = llvm.getelementptr %arg1[%806] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %804, %807 : i32, !llvm.ptr
%808 = arith.constant 10 : i32
%810 = arith.extsi %808 : i32 to i64
%809 = arith.remsi %761, %810 : i64
%811 = arith.constant 1 : i32
%813 = arith.extsi %811 : i32 to i64
%812 = arith.addi %809, %813 : i64
%814 = arith.trunci %812 : i64 to i32
%815 = arith.constant 4 : i32
%816 = arith.extsi %815 : i32 to i64
%817 = llvm.getelementptr %arg1[%816] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %814, %817 : i32, !llvm.ptr
%818 = arith.constant 1000 : i32
%820 = arith.extsi %818 : i32 to i64
%819 = arith.divsi %767, %820 : i64
%821 = arith.constant 1 : i32
%823 = arith.extsi %821 : i32 to i64
%822 = arith.addi %819, %823 : i64
%824 = arith.trunci %822 : i64 to i32
%825 = arith.constant 5 : i32
%826 = arith.extsi %825 : i32 to i64
%827 = llvm.getelementptr %arg1[%826] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %824, %827 : i32, !llvm.ptr
%828 = arith.constant 100 : i32
%830 = arith.extsi %828 : i32 to i64
%829 = arith.divsi %767, %830 : i64
%831 = arith.constant 10 : i32
%833 = arith.extsi %831 : i32 to i64
%832 = arith.remsi %829, %833 : i64
%834 = arith.constant 1 : i32
%836 = arith.extsi %834 : i32 to i64
%835 = arith.addi %832, %836 : i64
%837 = arith.trunci %835 : i64 to i32
%838 = arith.constant 6 : i32
%839 = arith.extsi %838 : i32 to i64
%840 = llvm.getelementptr %arg1[%839] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %837, %840 : i32, !llvm.ptr
%841 = arith.constant 10 : i32
%843 = arith.extsi %841 : i32 to i64
%842 = arith.divsi %767, %843 : i64
%844 = arith.constant 10 : i32
%846 = arith.extsi %844 : i32 to i64
%845 = arith.remsi %842, %846 : i64
%847 = arith.constant 1 : i32
%849 = arith.extsi %847 : i32 to i64
%848 = arith.addi %845, %849 : i64
%850 = arith.trunci %848 : i64 to i32
%851 = arith.constant 7 : i32
%852 = arith.extsi %851 : i32 to i64
%853 = llvm.getelementptr %arg1[%852] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %850, %853 : i32, !llvm.ptr
%854 = arith.constant 10 : i32
%856 = arith.extsi %854 : i32 to i64
%855 = arith.remsi %767, %856 : i64
%857 = arith.constant 1 : i32
%859 = arith.extsi %857 : i32 to i64
%858 = arith.addi %855, %859 : i64
%860 = arith.trunci %858 : i64 to i32
%861 = arith.constant 8 : i32
%862 = arith.extsi %861 : i32 to i64
%863 = llvm.getelementptr %arg1[%862] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %860, %863 : i32, !llvm.ptr
%864 = arith.constant 1000 : i32
%866 = arith.extsi %864 : i32 to i64
%865 = arith.divsi %770, %866 : i64
%867 = arith.constant 1 : i32
%869 = arith.extsi %867 : i32 to i64
%868 = arith.addi %865, %869 : i64
%870 = arith.trunci %868 : i64 to i32
%871 = arith.constant 9 : i32
%872 = arith.extsi %871 : i32 to i64
%873 = llvm.getelementptr %arg1[%872] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %870, %873 : i32, !llvm.ptr
%874 = arith.constant 100 : i32
%876 = arith.extsi %874 : i32 to i64
%875 = arith.divsi %770, %876 : i64
%877 = arith.constant 10 : i32
%879 = arith.extsi %877 : i32 to i64
%878 = arith.remsi %875, %879 : i64
%880 = arith.constant 1 : i32
%882 = arith.extsi %880 : i32 to i64
%881 = arith.addi %878, %882 : i64
%883 = arith.trunci %881 : i64 to i32
%884 = arith.constant 10 : i32
%885 = arith.extsi %884 : i32 to i64
%886 = llvm.getelementptr %arg1[%885] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %883, %886 : i32, !llvm.ptr
%887 = arith.constant 10 : i32
%889 = arith.extsi %887 : i32 to i64
%888 = arith.divsi %770, %889 : i64
%890 = arith.constant 10 : i32
%892 = arith.extsi %890 : i32 to i64
%891 = arith.remsi %888, %892 : i64
%893 = arith.constant 1 : i32
%895 = arith.extsi %893 : i32 to i64
%894 = arith.addi %891, %895 : i64
%896 = arith.trunci %894 : i64 to i32
%897 = arith.constant 11 : i32
%898 = arith.extsi %897 : i32 to i64
%899 = llvm.getelementptr %arg1[%898] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %896, %899 : i32, !llvm.ptr
%900 = arith.constant 10 : i32
%902 = arith.extsi %900 : i32 to i64
%901 = arith.remsi %770, %902 : i64
%903 = arith.constant 1 : i32
%905 = arith.extsi %903 : i32 to i64
%904 = arith.addi %901, %905 : i64
%906 = arith.trunci %904 : i64 to i32
%907 = arith.constant 12 : i32
%908 = arith.extsi %907 : i32 to i64
%909 = llvm.getelementptr %arg1[%908] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %906, %909 : i32, !llvm.ptr
func.return
}
func.func @compute_F_mod(%arg0: i64, %arg1: i64) -> i64 {
%911 = arith.constant 8 : i32
%913 = arith.extsi %911 : i32 to i64
%912 = arith.muli %arg0, %913 : i64
%910 = func.call @malloc(%912) : (i64) -> !llvm.ptr
%915 = arith.constant 8 : i32
%917 = arith.extsi %915 : i32 to i64
%916 = arith.muli %arg0, %917 : i64
%914 = func.call @malloc(%916) : (i64) -> !llvm.ptr
%919 = arith.constant 8 : i32
%921 = arith.extsi %919 : i32 to i64
%920 = arith.muli %arg0, %921 : i64
%918 = func.call @malloc(%920) : (i64) -> !llvm.ptr
%923 = arith.constant 8 : i32
%925 = arith.extsi %923 : i32 to i64
%924 = arith.muli %arg0, %925 : i64
%922 = func.call @malloc(%924) : (i64) -> !llvm.ptr
%927 = llvm.mlir.addressof @ND : !llvm.ptr
%928 = llvm.load %927 : !llvm.ptr -> i64
%929 = arith.constant 1 : i32
%931 = arith.extsi %929 : i32 to i64
%930 = arith.addi %928, %931 : i64
%932 = arith.constant 4 : i32
%933 = arith.extsi %932 : i32 to i64
%926 = func.call @calloc(%930, %933) : (i64, i64) -> !llvm.ptr
%934 = arith.constant 0 : i32
%935 = arith.extsi %934 : i32 to i64
%936 = llvm.mlir.constant(1 : i64) : i64
%937 = llvm.alloca %936 x i64 : (i64) -> !llvm.ptr
llvm.store %935, %937 : i64, !llvm.ptr
%938 = arith.constant 0 : i32
%939 = arith.extsi %938 : i32 to i64
%940 = llvm.mlir.constant(1 : i64) : i64
%941 = llvm.alloca %940 x i64 : (i64) -> !llvm.ptr
llvm.store %939, %941 : i64, !llvm.ptr
cf.br ^bb93
^bb93:
%942 = llvm.load %941 : !llvm.ptr -> i64
%943 = arith.cmpi slt, %942, %arg0 : i64
cf.cond_br %943, ^bb94, ^bb95
^bb94:
%944 = arith.constant 920461 : i32
%945 = llvm.load %937 : !llvm.ptr -> i64
%947 = arith.extsi %944 : i32 to i64
%946 = arith.muli %947, %945 : i64
%948 = arith.constant 795922420273 : i32
%950 = arith.extsi %948 : i32 to i64
%949 = arith.addi %946, %950 : i64
%951 = llvm.mlir.addressof @MOD_LCG : !llvm.ptr
%952 = llvm.load %951 : !llvm.ptr -> i64
%953 = arith.remsi %949, %952 : i64
llvm.store %953, %937 : i64, !llvm.ptr
%955 = llvm.load %937 : !llvm.ptr -> i64
func.call @int_to_word12(%955, %926) : (i64, !llvm.ptr) -> ()
%956 = func.call @rank_db(%926) : (!llvm.ptr) -> i64
%957 = llvm.load %941 : !llvm.ptr -> i64
%958 = llvm.getelementptr %910[%957] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %956, %958 : i64, !llvm.ptr
%959 = llvm.load %937 : !llvm.ptr -> i64
%960 = llvm.load %941 : !llvm.ptr -> i64
%961 = llvm.getelementptr %914[%960] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %959, %961 : i64, !llvm.ptr
%962 = llvm.load %941 : !llvm.ptr -> i64
%963 = arith.constant 1 : i32
%965 = arith.extsi %963 : i32 to i64
%964 = arith.addi %962, %965 : i64
llvm.store %964, %941 : i64, !llvm.ptr
cf.br ^bb93
^bb95:
%967 = arith.constant 65536 : i32
%968 = arith.constant 4 : i32
%969 = arith.extsi %967 : i32 to i64
%970 = arith.extsi %968 : i32 to i64
%966 = func.call @calloc(%969, %970) : (i64, i64) -> !llvm.ptr
%971 = llvm.mlir.constant(1 : i64) : i64
%972 = llvm.alloca %971 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %910, %972 : !llvm.ptr, !llvm.ptr
%973 = llvm.mlir.constant(1 : i64) : i64
%974 = llvm.alloca %973 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %918, %974 : !llvm.ptr, !llvm.ptr
%975 = llvm.mlir.constant(1 : i64) : i64
%976 = llvm.alloca %975 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %914, %976 : !llvm.ptr, !llvm.ptr
%977 = llvm.mlir.constant(1 : i64) : i64
%978 = llvm.alloca %977 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %922, %978 : !llvm.ptr, !llvm.ptr
%979 = arith.constant 0 : i32
%980 = arith.extsi %979 : i32 to i64
%981 = llvm.mlir.constant(1 : i64) : i64
%982 = llvm.alloca %981 x i64 : (i64) -> !llvm.ptr
llvm.store %980, %982 : i64, !llvm.ptr
cf.br ^bb96
^bb96:
%983 = llvm.load %982 : !llvm.ptr -> i64
%984 = arith.constant 3 : i32
%986 = arith.extsi %984 : i32 to i64
%985 = arith.cmpi slt, %983, %986 : i64
cf.cond_br %985, ^bb97, ^bb98
^bb97:
%987 = llvm.load %982 : !llvm.ptr -> i64
%988 = arith.constant 16 : i32
%990 = arith.extsi %988 : i32 to i64
%989 = arith.muli %987, %990 : i64
%992 = arith.constant 0 : i32
%993 = arith.constant 65536 : i32
%994 = arith.constant 4 : i32
%995 = arith.muli %993, %994 : i32
%996 = arith.extsi %995 : i32 to i64
%991 = func.call @memset(%966, %992, %996) : (!llvm.ptr, i32, i64) -> !llvm.ptr
%997 = arith.constant 0 : i32
%998 = arith.extsi %997 : i32 to i64
%999 = llvm.mlir.constant(1 : i64) : i64
%1000 = llvm.alloca %999 x i64 : (i64) -> !llvm.ptr
llvm.store %998, %1000 : i64, !llvm.ptr
cf.br ^bb99
^bb99:
%1001 = llvm.load %1000 : !llvm.ptr -> i64
%1002 = arith.cmpi slt, %1001, %arg0 : i64
cf.cond_br %1002, ^bb100, ^bb101
^bb100:
%1004 = llvm.load %972 : !llvm.ptr -> !llvm.ptr
%1005 = llvm.load %1000 : !llvm.ptr -> i64
%1006 = llvm.getelementptr %1004[%1005] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1003 = llvm.load %1006 : !llvm.ptr -> i64
%1007 = arith.shrsi %1003, %989 : i64
%1008 = arith.constant 65535 : i32
%1010 = arith.extsi %1008 : i32 to i64
%1009 = arith.andi %1007, %1010 : i64
%1012 = llvm.getelementptr %966[%1009] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1011 = llvm.load %1012 : !llvm.ptr -> i32
%1013 = arith.constant 1 : i32
%1014 = arith.addi %1011, %1013 : i32
%1015 = llvm.getelementptr %966[%1009] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1014, %1015 : i32, !llvm.ptr
%1016 = llvm.load %1000 : !llvm.ptr -> i64
%1017 = arith.constant 1 : i32
%1019 = arith.extsi %1017 : i32 to i64
%1018 = arith.addi %1016, %1019 : i64
llvm.store %1018, %1000 : i64, !llvm.ptr
cf.br ^bb99
^bb101:
%1020 = arith.constant 0 : i32
%1021 = llvm.mlir.constant(1 : i64) : i64
%1022 = llvm.alloca %1021 x i32 : (i64) -> !llvm.ptr
llvm.store %1020, %1022 : i32, !llvm.ptr
%1023 = arith.constant 0 : i32
%1024 = arith.extsi %1023 : i32 to i64
%1025 = llvm.mlir.constant(1 : i64) : i64
%1026 = llvm.alloca %1025 x i64 : (i64) -> !llvm.ptr
llvm.store %1024, %1026 : i64, !llvm.ptr
cf.br ^bb102
^bb102:
%1027 = llvm.load %1026 : !llvm.ptr -> i64
%1028 = arith.constant 65536 : i32
%1030 = arith.extsi %1028 : i32 to i64
%1029 = arith.cmpi slt, %1027, %1030 : i64
cf.cond_br %1029, ^bb103, ^bb104
^bb103:
%1032 = llvm.load %1026 : !llvm.ptr -> i64
%1033 = llvm.getelementptr %966[%1032] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1031 = llvm.load %1033 : !llvm.ptr -> i32
%1034 = llvm.load %1022 : !llvm.ptr -> i32
%1035 = llvm.load %1026 : !llvm.ptr -> i64
%1036 = llvm.getelementptr %966[%1035] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1034, %1036 : i32, !llvm.ptr
%1037 = llvm.load %1022 : !llvm.ptr -> i32
%1038 = arith.addi %1037, %1031 : i32
llvm.store %1038, %1022 : i32, !llvm.ptr
%1039 = llvm.load %1026 : !llvm.ptr -> i64
%1040 = arith.constant 1 : i32
%1042 = arith.extsi %1040 : i32 to i64
%1041 = arith.addi %1039, %1042 : i64
llvm.store %1041, %1026 : i64, !llvm.ptr
cf.br ^bb102
^bb104:
%1043 = arith.constant 0 : i32
%1044 = arith.extsi %1043 : i32 to i64
llvm.store %1044, %1000 : i64, !llvm.ptr
cf.br ^bb105
^bb105:
%1045 = llvm.load %1000 : !llvm.ptr -> i64
%1046 = arith.cmpi slt, %1045, %arg0 : i64
cf.cond_br %1046, ^bb106, ^bb107
^bb106:
%1048 = llvm.load %972 : !llvm.ptr -> !llvm.ptr
%1049 = llvm.load %1000 : !llvm.ptr -> i64
%1050 = llvm.getelementptr %1048[%1049] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1047 = llvm.load %1050 : !llvm.ptr -> i64
%1051 = arith.shrsi %1047, %989 : i64
%1052 = arith.constant 65535 : i32
%1054 = arith.extsi %1052 : i32 to i64
%1053 = arith.andi %1051, %1054 : i64
%1056 = llvm.getelementptr %966[%1053] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1055 = llvm.load %1056 : !llvm.ptr -> i32
%1057 = arith.constant 1 : i32
%1058 = arith.addi %1055, %1057 : i32
%1059 = llvm.getelementptr %966[%1053] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1058, %1059 : i32, !llvm.ptr
%1061 = llvm.load %972 : !llvm.ptr -> !llvm.ptr
%1062 = llvm.load %1000 : !llvm.ptr -> i64
%1063 = llvm.getelementptr %1061[%1062] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1060 = llvm.load %1063 : !llvm.ptr -> i64
%1064 = llvm.load %974 : !llvm.ptr -> !llvm.ptr
%1065 = arith.extsi %1055 : i32 to i64
%1066 = llvm.getelementptr %1064[%1065] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1060, %1066 : i64, !llvm.ptr
%1068 = llvm.load %976 : !llvm.ptr -> !llvm.ptr
%1069 = llvm.load %1000 : !llvm.ptr -> i64
%1070 = llvm.getelementptr %1068[%1069] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1067 = llvm.load %1070 : !llvm.ptr -> i64
%1071 = llvm.load %978 : !llvm.ptr -> !llvm.ptr
%1072 = arith.extsi %1055 : i32 to i64
%1073 = llvm.getelementptr %1071[%1072] : (!llvm.ptr, i64) -> !llvm.ptr, i64
llvm.store %1067, %1073 : i64, !llvm.ptr
%1074 = llvm.load %1000 : !llvm.ptr -> i64
%1075 = arith.constant 1 : i32
%1077 = arith.extsi %1075 : i32 to i64
%1076 = arith.addi %1074, %1077 : i64
llvm.store %1076, %1000 : i64, !llvm.ptr
cf.br ^bb105
^bb107:
%1078 = llvm.load %972 : !llvm.ptr -> !llvm.ptr
%1079 = llvm.load %974 : !llvm.ptr -> !llvm.ptr
llvm.store %1079, %972 : !llvm.ptr, !llvm.ptr
llvm.store %1078, %974 : !llvm.ptr, !llvm.ptr
%1080 = llvm.load %976 : !llvm.ptr -> !llvm.ptr
%1081 = llvm.load %978 : !llvm.ptr -> !llvm.ptr
llvm.store %1081, %976 : !llvm.ptr, !llvm.ptr
llvm.store %1080, %978 : !llvm.ptr, !llvm.ptr
%1082 = llvm.load %982 : !llvm.ptr -> i64
%1083 = arith.constant 1 : i32
%1085 = arith.extsi %1083 : i32 to i64
%1084 = arith.addi %1082, %1085 : i64
llvm.store %1084, %982 : i64, !llvm.ptr
cf.br ^bb96
^bb98:
%1086 = arith.constant 0 : i32
%1087 = arith.extsi %1086 : i32 to i64
%1088 = llvm.mlir.constant(1 : i64) : i64
%1089 = llvm.alloca %1088 x i64 : (i64) -> !llvm.ptr
llvm.store %1087, %1089 : i64, !llvm.ptr
%1090 = arith.constant 0 : i32
%1091 = arith.extsi %1090 : i32 to i64
llvm.store %1091, %941 : i64, !llvm.ptr
cf.br ^bb108
^bb108:
%1092 = llvm.load %941 : !llvm.ptr -> i64
%1093 = arith.cmpi slt, %1092, %arg0 : i64
cf.cond_br %1093, ^bb109, ^bb110
^bb109:
%1094 = llvm.load %1089 : !llvm.ptr -> i64
%1095 = llvm.load %941 : !llvm.ptr -> i64
%1096 = arith.constant 1 : i32
%1098 = arith.extsi %1096 : i32 to i64
%1097 = arith.addi %1095, %1098 : i64
%1100 = llvm.load %976 : !llvm.ptr -> !llvm.ptr
%1101 = llvm.load %941 : !llvm.ptr -> i64
%1102 = llvm.getelementptr %1100[%1101] : (!llvm.ptr, i64) -> !llvm.ptr, i64
%1099 = llvm.load %1102 : !llvm.ptr -> i64
%1103 = arith.remsi %1099, %arg1 : i64
%1104 = arith.muli %1097, %1103 : i64
%1105 = arith.addi %1094, %1104 : i64
%1106 = arith.remsi %1105, %arg1 : i64
llvm.store %1106, %1089 : i64, !llvm.ptr
%1107 = llvm.load %941 : !llvm.ptr -> i64
%1108 = arith.constant 1 : i32
%1110 = arith.extsi %1108 : i32 to i64
%1109 = arith.addi %1107, %1110 : i64
llvm.store %1109, %941 : i64, !llvm.ptr
cf.br ^bb108
^bb110:
func.call @free(%910) : (!llvm.ptr) -> ()
func.call @free(%914) : (!llvm.ptr) -> ()
func.call @free(%918) : (!llvm.ptr) -> ()
func.call @free(%922) : (!llvm.ptr) -> ()
func.call @free(%966) : (!llvm.ptr) -> ()
func.call @free(%926) : (!llvm.ptr) -> ()
%1117 = llvm.load %1089 : !llvm.ptr -> i64
func.return %1117 : i64
}
func.func @main() -> i32 {
func.call @init_tables() : () -> ()
%1119 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1121 = arith.constant 10000000 : i32
%1122 = arith.constant 1234567891 : i32
%1123 = arith.extsi %1121 : i32 to i64
%1124 = arith.extsi %1122 : i32 to i64
%1120 = func.call @compute_F_mod(%1123, %1124) : (i64, i64) -> i64
%1125 = llvm.call @printf(%1119, %1120) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%1126 = arith.constant 0 : i32
func.return %1126 : i32
}
}