← All problems Problem 857
Beautiful Graphs: G(10^7) mod (10^9+7). Ported from native C to pure Flow.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n)O(e log v)Space complexity O(1)O(v)Approach Flow solution Kruskal or Prim algorithm Verdict Unknown
Flow source
# Project Euler 857
# Beautiful Graphs: G(10^7) mod (10^9+7).
# Ported from native C to pure Flow.
const MOD: i64 = 1000000007
const TARGET_N: i64 = 10000000
function mod_pow(a0: i64, e0: i64, mod: i64) -> i64 {
let mut r: i64 = 1 % mod
let mut a: i64 = a0 % mod
if a < 0 { a = a + mod }
let mut e: i64 = e0
while e > 0 {
if (e & 1) == 1 {
r = (((r as i128) * (a as i128)) % (mod as i128)) as i64
}
a = (((a as i128) * (a as i128)) % (mod as i128)) as i64
e = e >> 1
}
return r
}
function mod_inv(a: i64, mod: i64) -> i64 {
return mod_pow(a, mod - 2, mod)
}
# Count 2-colourings of edges of K_k with no monochromatic triangle.
function count_no_mono_triangle(k: i32) -> i64 {
if k <= 1 { return 1 }
# edge index: (i,j) -> idx, i < j. Flat 6*6 array.
let mut edge: array<i32, 36> = [
-1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1
]
let mut m: i32 = 0
let mut i: i32 = 0
while i < k {
let mut j: i32 = i + 1
while j < k {
edge[i * 6 + j] = m
m = m + 1
j = j + 1
}
i = i + 1
}
# collect triangles as triples of edge indices. Flat 20*3 array.
let tris: array<i32, 60> = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
let mut nt: i32 = 0
i = 0
while i < k {
let mut j: i32 = i + 1
while j < k {
let mut l: i32 = j + 1
while l < k {
tris[nt * 3] = edge[i * 6 + j]
tris[nt * 3 + 1] = edge[i * 6 + l]
tris[nt * 3 + 2] = edge[j * 6 + l]
nt = nt + 1
l = l + 1
}
j = j + 1
}
i = i + 1
}
let mut good: i64 = 0
let total: i64 = 1 << m
let mut mask: i64 = 0
while mask < total {
let mut ok: bool = true
let mut t: i32 = 0
while t < nt {
if ok {
let x: i32 = ((mask >> tris[t * 3]) & 1) as i32
let y: i32 = ((mask >> tris[t * 3 + 1]) & 1) as i32
let z: i32 = ((mask >> tris[t * 3 + 2]) & 1) as i32
if x == y {
if x == z {
ok = false
}
}
}
t = t + 1
}
if ok {
good = good + 1
}
mask = mask + 1
}
return good
}
function G_mod(n: i64) -> i64 {
if n == 0 { return 1 }
# a[s] for s=1..5
let a: array<i64, 6> = [0, 0, 0, 0, 0, 0]
let mut s: i32 = 1
while s <= 5 {
a[s] = count_no_mono_triangle(s)
s = s + 1
}
# coeff[s] = a[s] / s! (mod MOD)
let coeff: array<i64, 6> = [0, 0, 0, 0, 0, 0]
let mut fact_small: i64 = 1
s = 1
while s <= 5 {
fact_small = (((fact_small as i128) * (s as i128)) % (MOD as i128)) as i64
coeff[s] = (((a[s] as i128) * (mod_inv(fact_small, MOD) as i128)) % (MOD as i128)) as i64
s = s + 1
}
let c1: i64 = coeff[1]
let c2: i64 = coeff[2]
let c3: i64 = coeff[3]
let c4: i64 = coeff[4]
let c5: i64 = coeff[5]
# rolling recurrence: f1 = f_0 = 1, f2..f5 = 0 (lagged)
let mut f1: i64 = 1
let mut f2: i64 = 0
let mut f3: i64 = 0
let mut f4: i64 = 0
let mut f5: i64 = 0
let mut fact: i64 = 1
let mut i: i64 = 1
while i <= n {
let fn: i64 = ((((c1 as i128) * (f1 as i128) % (MOD as i128)
+ (c2 as i128) * (f2 as i128) % (MOD as i128)
+ (c3 as i128) * (f3 as i128) % (MOD as i128)
+ (c4 as i128) * (f4 as i128) % (MOD as i128)
+ (c5 as i128) * (f5 as i128) % (MOD as i128)) % (MOD as i128))) as i64
f5 = f4
f4 = f3
f3 = f2
f2 = f1
f1 = fn
fact = (((fact as i128) * (i as i128)) % (MOD as i128)) as i64
i = i + 1
}
return (((fact as i128) * (f1 as i128)) % (MOD as i128)) as i64
}
function main() -> i32 {
printf("%lld\n", G_mod(TARGET_N))
return 0
}
Generated C
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Flow runtime helpers */
typedef struct flow_temp_node { struct flow_temp_node* next; } flow_temp_node;
static flow_temp_node* flow_temp_head = NULL;
static int flow_temp_atexit_set = 0;
__attribute__((unused)) static void flow_temp_free_all(void) {
while (flow_temp_head) {
flow_temp_node* n = flow_temp_head;
flow_temp_head = n->next;
free(n);
}
}
__attribute__((unused)) static void* flow_temp_alloc(size_t nbytes) {
flow_temp_node* node = (flow_temp_node*)malloc(sizeof(flow_temp_node) + nbytes);
if (!node) return NULL;
node->next = flow_temp_head;
flow_temp_head = node;
if (!flow_temp_atexit_set) {
flow_temp_atexit_set = 1;
atexit(flow_temp_free_all);
}
return (void*)(node + 1);
}
#ifndef FLOW_DIAG
#define FLOW_DIAG(msg) fprintf(stderr, "%s", (msg))
#endif
#ifndef FLOW_LOG
#define FLOW_LOG(fmt, ...) printf(fmt, __VA_ARGS__)
#endif
#ifndef FLOW_LOG_EMPTY
#define FLOW_LOG_EMPTY(fmt) printf(fmt)
#endif
static char* flow_strcat(const char* a, const char* b) {
size_t la = strlen(a ? a : ""), lb = strlen(b ? b : "");
char* r = (char*)flow_temp_alloc(la + lb + 1);
if (!r) return NULL;
if (la) memcpy(r, a, la);
if (lb) memcpy(r + la, b, lb);
r[la + lb] = '\0';
return r;
}
#define __flow_in_arr(arr, val) __extension__ ({ \
int _found = 0; \
size_t _n = sizeof(arr)/sizeof((arr)[0]); \
for (size_t _i = 0; _i < _n; _i++) { \
if ((arr)[_i] == (val)) { _found = 1; break; } \
} _found; })
/* Unified fault handler (MISRA #279) — override with -DFLOW_FAULT_HANDLER=fn */
#ifndef FLOW_FAULT_HANDLER
__attribute__((unused)) static inline void flow_fault_handler(const char* msg) {
fprintf(stderr, "flow: %s\n", msg ? msg : "fault");
abort();
#if defined(__GNUC__) || defined(__clang__)
__builtin_unreachable();
#endif
}
#else
#define flow_fault_handler FLOW_FAULT_HANDLER
#endif
#define flow_div_by_zero_handler() flow_fault_handler("division by zero")
#define flow_shift_ub_handler() flow_fault_handler("invalid shift (amount out of range or left-shift of negative)")
#ifndef FLOW_CHECKED_DIV
#define FLOW_CHECKED_DIV(L, R) (((R) != 0) ? ((L) / (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_MOD
#define FLOW_CHECKED_MOD(L, R) (((R) != 0) ? ((L) % (R)) : (flow_div_by_zero_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHL
#define FLOW_CHECKED_SHL(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull)) && ((L) >= 0)) ? ((L) << (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#ifndef FLOW_CHECKED_SHR
#define FLOW_CHECKED_SHR(L, R) ((((R) >= 0) && ((unsigned long long)(R) < (sizeof(L) * 8ull))) ? ((L) >> (R)) : (flow_shift_ub_handler(), (L) * 0))
#endif
#include <math.h>
void* _ui_state = NULL;
static inline float i32_to_f32(int32_t v) { return (float)v; }
/* Host stub for @gpu kernels (device codegen replaces this). */
static inline int32_t gpu_thread_id(void) { return 0; }
int64_t mod_pow_i64_i64_i64(int64_t a0, int64_t e0, int64_t mod);
int64_t mod_inv_i64_i64(int64_t a, int64_t mod);
int64_t count_no_mono_triangle_i32(int32_t k);
int64_t G_mod_i64(int64_t n);
int32_t main(void);
static const int64_t MOD = 1000000007;
static const int64_t TARGET_N = 10000000;
int64_t mod_pow_i64_i64_i64(int64_t a0, int64_t e0, int64_t mod) {
int64_t r = FLOW_CHECKED_MOD((1), (mod));
int64_t a = FLOW_CHECKED_MOD((a0), (mod));
if (a < 0) {
a = (a + mod);
}
int64_t e = e0;
while (e > 0) {
if ((e & 1) == 1) {
r = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(r)) * ((__int128)(a)))), (((__int128)(mod))))));
}
a = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(a)) * ((__int128)(a)))), (((__int128)(mod))))));
e = FLOW_CHECKED_SHR((e), (1));
}
return r;
}
int64_t mod_inv_i64_i64(int64_t a, int64_t mod) {
return mod_pow_i64_i64_i64(a, (mod - 2), mod);
}
int64_t count_no_mono_triangle_i32(int32_t k) {
if (k <= 1) {
return 1;
}
int32_t edge[36] = { (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1) };
int32_t m = 0;
int32_t i = 0;
while (i < k) {
int32_t j = (i + 1);
while (j < k) {
edge[((i * 6) + j)] = m;
m = (m + 1);
j = (j + 1);
}
i = (i + 1);
}
int32_t tris[60] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int32_t nt = 0;
i = 0;
while (i < k) {
int32_t j = (i + 1);
while (j < k) {
int32_t l = (j + 1);
while (l < k) {
tris[(nt * 3)] = (((unsigned)(((i * 6) + j)) < 36) ? edge[((i * 6) + j)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(((i * 6) + j)), 36), flow_fault_handler("array index out of bounds"), edge[0]));
tris[((nt * 3) + 1)] = (((unsigned)(((i * 6) + l)) < 36) ? edge[((i * 6) + l)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(((i * 6) + l)), 36), flow_fault_handler("array index out of bounds"), edge[0]));
tris[((nt * 3) + 2)] = (((unsigned)(((j * 6) + l)) < 36) ? edge[((j * 6) + l)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(((j * 6) + l)), 36), flow_fault_handler("array index out of bounds"), edge[0]));
nt = (nt + 1);
l = (l + 1);
}
j = (j + 1);
}
i = (i + 1);
}
int64_t good = 0;
int64_t total = FLOW_CHECKED_SHL((1), (m));
int64_t mask = 0;
while (mask < total) {
bool ok = 1;
int32_t t = 0;
while (t < nt) {
if (ok) {
int32_t x = ((int32_t)((FLOW_CHECKED_SHR((mask), ((((unsigned)((t * 3)) < 60) ? tris[(t * 3)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)((t * 3)), 60), flow_fault_handler("array index out of bounds"), tris[0])))) & 1)));
int32_t y = ((int32_t)((FLOW_CHECKED_SHR((mask), ((((unsigned)(((t * 3) + 1)) < 60) ? tris[((t * 3) + 1)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(((t * 3) + 1)), 60), flow_fault_handler("array index out of bounds"), tris[0])))) & 1)));
int32_t z = ((int32_t)((FLOW_CHECKED_SHR((mask), ((((unsigned)(((t * 3) + 2)) < 60) ? tris[((t * 3) + 2)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(((t * 3) + 2)), 60), flow_fault_handler("array index out of bounds"), tris[0])))) & 1)));
if (x == y) {
if (x == z) {
ok = 0;
}
}
}
t = (t + 1);
}
if (ok) {
good = (good + 1);
}
mask = (mask + 1);
}
return good;
}
int64_t G_mod_i64(int64_t n) {
if (n == 0) {
return 1;
}
int64_t a[6] = { 0, 0, 0, 0, 0, 0 };
int32_t s = 1;
while (s <= 5) {
a[s] = count_no_mono_triangle_i32(s);
s = (s + 1);
}
int64_t coeff[6] = { 0, 0, 0, 0, 0, 0 };
int64_t fact_small = 1;
s = 1;
while (s <= 5) {
fact_small = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(fact_small)) * ((__int128)(s)))), (((__int128)(MOD))))));
coeff[s] = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)((((unsigned)(s) < 6) ? a[s] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(s), 6), flow_fault_handler("array index out of bounds"), a[0])))) * ((__int128)(mod_inv_i64_i64(fact_small, MOD))))), (((__int128)(MOD))))));
s = (s + 1);
}
int64_t c1 = (((unsigned)(1) < 6) ? coeff[1] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(1), 6), flow_fault_handler("array index out of bounds"), coeff[0]));
int64_t c2 = (((unsigned)(2) < 6) ? coeff[2] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(2), 6), flow_fault_handler("array index out of bounds"), coeff[0]));
int64_t c3 = (((unsigned)(3) < 6) ? coeff[3] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(3), 6), flow_fault_handler("array index out of bounds"), coeff[0]));
int64_t c4 = (((unsigned)(4) < 6) ? coeff[4] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(4), 6), flow_fault_handler("array index out of bounds"), coeff[0]));
int64_t c5 = (((unsigned)(5) < 6) ? coeff[5] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(5), 6), flow_fault_handler("array index out of bounds"), coeff[0]));
int64_t f1 = 1;
int64_t f2 = 0;
int64_t f3 = 0;
int64_t f4 = 0;
int64_t f5 = 0;
int64_t fact = 1;
int64_t i = 1;
while (i <= n) {
int64_t fn = ((int64_t)(FLOW_CHECKED_MOD((((((FLOW_CHECKED_MOD(((((__int128)(c1)) * ((__int128)(f1)))), (((__int128)(MOD)))) + FLOW_CHECKED_MOD(((((__int128)(c2)) * ((__int128)(f2)))), (((__int128)(MOD))))) + FLOW_CHECKED_MOD(((((__int128)(c3)) * ((__int128)(f3)))), (((__int128)(MOD))))) + FLOW_CHECKED_MOD(((((__int128)(c4)) * ((__int128)(f4)))), (((__int128)(MOD))))) + FLOW_CHECKED_MOD(((((__int128)(c5)) * ((__int128)(f5)))), (((__int128)(MOD)))))), (((__int128)(MOD))))));
f5 = f4;
f4 = f3;
f3 = f2;
f2 = f1;
f1 = fn;
fact = ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(fact)) * ((__int128)(i)))), (((__int128)(MOD))))));
i = (i + 1);
}
return ((int64_t)(FLOW_CHECKED_MOD(((((__int128)(fact)) * ((__int128)(f1)))), (((__int128)(MOD))))));
}
int32_t main(void) {
printf("%lld\n", G_mod_i64(TARGET_N));
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
// Constant: MOD
llvm.mlir.global internal constant @MOD(1000000007 : i64) : i64
// Constant: TARGET_N
llvm.mlir.global internal constant @TARGET_N(10000000 : i64) : i64
func.func @mod_pow(%arg0: i64, %arg1: i64, %arg2: i64) -> i64 {
%0 = arith.constant 1 : i32
%2 = arith.extsi %0 : i32 to i64
%1 = arith.remsi %2, %arg2 : i64
%3 = llvm.mlir.constant(1 : i64) : i64
%4 = llvm.alloca %3 x i64 : (i64) -> !llvm.ptr
llvm.store %1, %4 : i64, !llvm.ptr
%5 = arith.remsi %arg0, %arg2 : i64
%6 = llvm.mlir.constant(1 : i64) : i64
%7 = llvm.alloca %6 x i64 : (i64) -> !llvm.ptr
llvm.store %5, %7 : i64, !llvm.ptr
%8 = llvm.load %7 : !llvm.ptr -> i64
%9 = arith.constant 0 : i32
%11 = arith.extsi %9 : i32 to i64
%10 = arith.cmpi slt, %8, %11 : i64
cf.cond_br %10, ^bb0, ^bb1
^bb0:
%12 = llvm.load %7 : !llvm.ptr -> i64
%13 = arith.addi %12, %arg2 : i64
llvm.store %13, %7 : i64, !llvm.ptr
cf.br ^bb2
^bb1:
cf.br ^bb2
^bb2:
%14 = llvm.mlir.constant(1 : i64) : i64
%15 = llvm.alloca %14 x i64 : (i64) -> !llvm.ptr
llvm.store %arg1, %15 : i64, !llvm.ptr
cf.br ^bb3
^bb3:
%16 = llvm.load %15 : !llvm.ptr -> i64
%17 = arith.constant 0 : i32
%19 = arith.extsi %17 : i32 to i64
%18 = arith.cmpi sgt, %16, %19 : i64
cf.cond_br %18, ^bb4, ^bb5
^bb4:
%20 = llvm.load %15 : !llvm.ptr -> i64
%21 = arith.constant 1 : i32
%23 = arith.extsi %21 : i32 to i64
%22 = arith.andi %20, %23 : i64
%24 = arith.constant 1 : i32
%26 = arith.extsi %24 : i32 to i64
%25 = arith.cmpi eq, %22, %26 : i64
cf.cond_br %25, ^bb6, ^bb7
^bb6:
%27 = llvm.load %4 : !llvm.ptr -> i64
%28 = arith.extsi %27 : i64 to i128
%29 = llvm.load %7 : !llvm.ptr -> i64
%30 = arith.extsi %29 : i64 to i128
%32 = arith.trunci %28 : i128 to i64
%33 = arith.trunci %30 : i128 to i64
%31 = arith.muli %32, %33 : i64
%34 = arith.extsi %arg2 : i64 to i128
%36 = arith.trunci %34 : i128 to i64
%35 = arith.remsi %31, %36 : i64
llvm.store %35, %4 : i64, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%37 = llvm.load %7 : !llvm.ptr -> i64
%38 = arith.extsi %37 : i64 to i128
%39 = llvm.load %7 : !llvm.ptr -> i64
%40 = arith.extsi %39 : i64 to i128
%42 = arith.trunci %38 : i128 to i64
%43 = arith.trunci %40 : i128 to i64
%41 = arith.muli %42, %43 : i64
%44 = arith.extsi %arg2 : i64 to i128
%46 = arith.trunci %44 : i128 to i64
%45 = arith.remsi %41, %46 : i64
llvm.store %45, %7 : i64, !llvm.ptr
%47 = llvm.load %15 : !llvm.ptr -> i64
%48 = arith.constant 1 : i32
%50 = arith.extsi %48 : i32 to i64
%49 = arith.shrsi %47, %50 : i64
llvm.store %49, %15 : i64, !llvm.ptr
cf.br ^bb3
^bb5:
%51 = llvm.load %4 : !llvm.ptr -> i64
func.return %51 : i64
}
func.func @mod_inv(%arg0: i64, %arg1: i64) -> i64 {
%53 = arith.constant 2 : i32
%55 = arith.extsi %53 : i32 to i64
%54 = arith.subi %arg1, %55 : i64
%52 = func.call @mod_pow(%arg0, %54, %arg1) : (i64, i64, i64) -> i64
func.return %52 : i64
}
func.func @count_no_mono_triangle(%arg0: i32) -> i64 {
%56 = arith.constant 1 : i32
%57 = arith.cmpi sle, %arg0, %56 : i32
cf.cond_br %57, ^bb9, ^bb10
^bb9:
%58 = arith.constant 1 : i32
%59 = arith.extsi %58 : i32 to i64
func.return %59 : i64
^bb10:
cf.br ^bb11
^bb11:
%61 = arith.constant 1 : i32
%63 = arith.constant 0 : i32
%62 = arith.subi %63, %61 : i32
%64 = arith.constant 1 : i32
%66 = arith.constant 0 : i32
%65 = arith.subi %66, %64 : i32
%67 = arith.constant 1 : i32
%69 = arith.constant 0 : i32
%68 = arith.subi %69, %67 : i32
%70 = arith.constant 1 : i32
%72 = arith.constant 0 : i32
%71 = arith.subi %72, %70 : i32
%73 = arith.constant 1 : i32
%75 = arith.constant 0 : i32
%74 = arith.subi %75, %73 : i32
%76 = arith.constant 1 : i32
%78 = arith.constant 0 : i32
%77 = arith.subi %78, %76 : i32
%79 = arith.constant 1 : i32
%81 = arith.constant 0 : i32
%80 = arith.subi %81, %79 : i32
%82 = arith.constant 1 : i32
%84 = arith.constant 0 : i32
%83 = arith.subi %84, %82 : i32
%85 = arith.constant 1 : i32
%87 = arith.constant 0 : i32
%86 = arith.subi %87, %85 : i32
%88 = arith.constant 1 : i32
%90 = arith.constant 0 : i32
%89 = arith.subi %90, %88 : i32
%91 = arith.constant 1 : i32
%93 = arith.constant 0 : i32
%92 = arith.subi %93, %91 : i32
%94 = arith.constant 1 : i32
%96 = arith.constant 0 : i32
%95 = arith.subi %96, %94 : i32
%97 = arith.constant 1 : i32
%99 = arith.constant 0 : i32
%98 = arith.subi %99, %97 : i32
%100 = arith.constant 1 : i32
%102 = arith.constant 0 : i32
%101 = arith.subi %102, %100 : i32
%103 = arith.constant 1 : i32
%105 = arith.constant 0 : i32
%104 = arith.subi %105, %103 : i32
%106 = arith.constant 1 : i32
%108 = arith.constant 0 : i32
%107 = arith.subi %108, %106 : i32
%109 = arith.constant 1 : i32
%111 = arith.constant 0 : i32
%110 = arith.subi %111, %109 : i32
%112 = arith.constant 1 : i32
%114 = arith.constant 0 : i32
%113 = arith.subi %114, %112 : i32
%115 = arith.constant 1 : i32
%117 = arith.constant 0 : i32
%116 = arith.subi %117, %115 : i32
%118 = arith.constant 1 : i32
%120 = arith.constant 0 : i32
%119 = arith.subi %120, %118 : i32
%121 = arith.constant 1 : i32
%123 = arith.constant 0 : i32
%122 = arith.subi %123, %121 : i32
%124 = arith.constant 1 : i32
%126 = arith.constant 0 : i32
%125 = arith.subi %126, %124 : i32
%127 = arith.constant 1 : i32
%129 = arith.constant 0 : i32
%128 = arith.subi %129, %127 : i32
%130 = arith.constant 1 : i32
%132 = arith.constant 0 : i32
%131 = arith.subi %132, %130 : i32
%133 = arith.constant 1 : i32
%135 = arith.constant 0 : i32
%134 = arith.subi %135, %133 : i32
%136 = arith.constant 1 : i32
%138 = arith.constant 0 : i32
%137 = arith.subi %138, %136 : i32
%139 = arith.constant 1 : i32
%141 = arith.constant 0 : i32
%140 = arith.subi %141, %139 : i32
%142 = arith.constant 1 : i32
%144 = arith.constant 0 : i32
%143 = arith.subi %144, %142 : i32
%145 = arith.constant 1 : i32
%147 = arith.constant 0 : i32
%146 = arith.subi %147, %145 : i32
%148 = arith.constant 1 : i32
%150 = arith.constant 0 : i32
%149 = arith.subi %150, %148 : i32
%151 = arith.constant 1 : i32
%153 = arith.constant 0 : i32
%152 = arith.subi %153, %151 : i32
%154 = arith.constant 1 : i32
%156 = arith.constant 0 : i32
%155 = arith.subi %156, %154 : i32
%157 = arith.constant 1 : i32
%159 = arith.constant 0 : i32
%158 = arith.subi %159, %157 : i32
%160 = arith.constant 1 : i32
%162 = arith.constant 0 : i32
%161 = arith.subi %162, %160 : i32
%163 = arith.constant 1 : i32
%165 = arith.constant 0 : i32
%164 = arith.subi %165, %163 : i32
%166 = arith.constant 1 : i32
%168 = arith.constant 0 : i32
%167 = arith.subi %168, %166 : i32
%169 = llvm.mlir.constant(1 : i64) : i64
%170 = llvm.alloca %169 x !llvm.array<36 x i32> : (i64) -> !llvm.ptr
%171 = llvm.mlir.zero : !llvm.array<36 x i32>
llvm.store %171, %170 : !llvm.array<36 x i32>, !llvm.ptr
%172 = llvm.mlir.constant(0 : i64) : i64
%173 = llvm.getelementptr %170[0, %172] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %62, %173 : i32, !llvm.ptr
%174 = llvm.mlir.constant(1 : i64) : i64
%175 = llvm.getelementptr %170[0, %174] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %65, %175 : i32, !llvm.ptr
%176 = llvm.mlir.constant(2 : i64) : i64
%177 = llvm.getelementptr %170[0, %176] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %68, %177 : i32, !llvm.ptr
%178 = llvm.mlir.constant(3 : i64) : i64
%179 = llvm.getelementptr %170[0, %178] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %71, %179 : i32, !llvm.ptr
%180 = llvm.mlir.constant(4 : i64) : i64
%181 = llvm.getelementptr %170[0, %180] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %74, %181 : i32, !llvm.ptr
%182 = llvm.mlir.constant(5 : i64) : i64
%183 = llvm.getelementptr %170[0, %182] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %77, %183 : i32, !llvm.ptr
%184 = llvm.mlir.constant(6 : i64) : i64
%185 = llvm.getelementptr %170[0, %184] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %80, %185 : i32, !llvm.ptr
%186 = llvm.mlir.constant(7 : i64) : i64
%187 = llvm.getelementptr %170[0, %186] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %83, %187 : i32, !llvm.ptr
%188 = llvm.mlir.constant(8 : i64) : i64
%189 = llvm.getelementptr %170[0, %188] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %86, %189 : i32, !llvm.ptr
%190 = llvm.mlir.constant(9 : i64) : i64
%191 = llvm.getelementptr %170[0, %190] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %89, %191 : i32, !llvm.ptr
%192 = llvm.mlir.constant(10 : i64) : i64
%193 = llvm.getelementptr %170[0, %192] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %92, %193 : i32, !llvm.ptr
%194 = llvm.mlir.constant(11 : i64) : i64
%195 = llvm.getelementptr %170[0, %194] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %95, %195 : i32, !llvm.ptr
%196 = llvm.mlir.constant(12 : i64) : i64
%197 = llvm.getelementptr %170[0, %196] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %98, %197 : i32, !llvm.ptr
%198 = llvm.mlir.constant(13 : i64) : i64
%199 = llvm.getelementptr %170[0, %198] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %101, %199 : i32, !llvm.ptr
%200 = llvm.mlir.constant(14 : i64) : i64
%201 = llvm.getelementptr %170[0, %200] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %104, %201 : i32, !llvm.ptr
%202 = llvm.mlir.constant(15 : i64) : i64
%203 = llvm.getelementptr %170[0, %202] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %107, %203 : i32, !llvm.ptr
%204 = llvm.mlir.constant(16 : i64) : i64
%205 = llvm.getelementptr %170[0, %204] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %110, %205 : i32, !llvm.ptr
%206 = llvm.mlir.constant(17 : i64) : i64
%207 = llvm.getelementptr %170[0, %206] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %113, %207 : i32, !llvm.ptr
%208 = llvm.mlir.constant(18 : i64) : i64
%209 = llvm.getelementptr %170[0, %208] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %116, %209 : i32, !llvm.ptr
%210 = llvm.mlir.constant(19 : i64) : i64
%211 = llvm.getelementptr %170[0, %210] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %119, %211 : i32, !llvm.ptr
%212 = llvm.mlir.constant(20 : i64) : i64
%213 = llvm.getelementptr %170[0, %212] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %122, %213 : i32, !llvm.ptr
%214 = llvm.mlir.constant(21 : i64) : i64
%215 = llvm.getelementptr %170[0, %214] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %125, %215 : i32, !llvm.ptr
%216 = llvm.mlir.constant(22 : i64) : i64
%217 = llvm.getelementptr %170[0, %216] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %128, %217 : i32, !llvm.ptr
%218 = llvm.mlir.constant(23 : i64) : i64
%219 = llvm.getelementptr %170[0, %218] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %131, %219 : i32, !llvm.ptr
%220 = llvm.mlir.constant(24 : i64) : i64
%221 = llvm.getelementptr %170[0, %220] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %134, %221 : i32, !llvm.ptr
%222 = llvm.mlir.constant(25 : i64) : i64
%223 = llvm.getelementptr %170[0, %222] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %137, %223 : i32, !llvm.ptr
%224 = llvm.mlir.constant(26 : i64) : i64
%225 = llvm.getelementptr %170[0, %224] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %140, %225 : i32, !llvm.ptr
%226 = llvm.mlir.constant(27 : i64) : i64
%227 = llvm.getelementptr %170[0, %226] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %143, %227 : i32, !llvm.ptr
%228 = llvm.mlir.constant(28 : i64) : i64
%229 = llvm.getelementptr %170[0, %228] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %146, %229 : i32, !llvm.ptr
%230 = llvm.mlir.constant(29 : i64) : i64
%231 = llvm.getelementptr %170[0, %230] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %149, %231 : i32, !llvm.ptr
%232 = llvm.mlir.constant(30 : i64) : i64
%233 = llvm.getelementptr %170[0, %232] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %152, %233 : i32, !llvm.ptr
%234 = llvm.mlir.constant(31 : i64) : i64
%235 = llvm.getelementptr %170[0, %234] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %155, %235 : i32, !llvm.ptr
%236 = llvm.mlir.constant(32 : i64) : i64
%237 = llvm.getelementptr %170[0, %236] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %158, %237 : i32, !llvm.ptr
%238 = llvm.mlir.constant(33 : i64) : i64
%239 = llvm.getelementptr %170[0, %238] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %161, %239 : i32, !llvm.ptr
%240 = llvm.mlir.constant(34 : i64) : i64
%241 = llvm.getelementptr %170[0, %240] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %164, %241 : i32, !llvm.ptr
%242 = llvm.mlir.constant(35 : i64) : i64
%243 = llvm.getelementptr %170[0, %242] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %167, %243 : i32, !llvm.ptr
%244 = arith.constant 0 : i32
%245 = llvm.mlir.constant(1 : i64) : i64
%246 = llvm.alloca %245 x i32 : (i64) -> !llvm.ptr
llvm.store %244, %246 : i32, !llvm.ptr
%247 = arith.constant 0 : i32
%248 = llvm.mlir.constant(1 : i64) : i64
%249 = llvm.alloca %248 x i32 : (i64) -> !llvm.ptr
llvm.store %247, %249 : i32, !llvm.ptr
cf.br ^bb12
^bb12:
%250 = llvm.load %249 : !llvm.ptr -> i32
%251 = arith.cmpi slt, %250, %arg0 : i32
cf.cond_br %251, ^bb13, ^bb14
^bb13:
%252 = llvm.load %249 : !llvm.ptr -> i32
%253 = arith.constant 1 : i32
%254 = arith.addi %252, %253 : i32
%255 = llvm.mlir.constant(1 : i64) : i64
%256 = llvm.alloca %255 x i32 : (i64) -> !llvm.ptr
llvm.store %254, %256 : i32, !llvm.ptr
cf.br ^bb15
^bb15:
%257 = llvm.load %256 : !llvm.ptr -> i32
%258 = arith.cmpi slt, %257, %arg0 : i32
cf.cond_br %258, ^bb16, ^bb17
^bb16:
%259 = llvm.load %246 : !llvm.ptr -> i32
%260 = llvm.load %249 : !llvm.ptr -> i32
%261 = arith.constant 6 : i32
%262 = arith.muli %260, %261 : i32
%263 = llvm.load %256 : !llvm.ptr -> i32
%264 = arith.addi %262, %263 : i32
%265 = arith.extsi %264 : i32 to i64
%266 = llvm.getelementptr %170[0, %265] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
llvm.store %259, %266 : i32, !llvm.ptr
%267 = llvm.load %246 : !llvm.ptr -> i32
%268 = arith.constant 1 : i32
%269 = arith.addi %267, %268 : i32
llvm.store %269, %246 : i32, !llvm.ptr
%270 = llvm.load %256 : !llvm.ptr -> i32
%271 = arith.constant 1 : i32
%272 = arith.addi %270, %271 : i32
llvm.store %272, %256 : i32, !llvm.ptr
cf.br ^bb15
^bb17:
%273 = llvm.load %249 : !llvm.ptr -> i32
%274 = arith.constant 1 : i32
%275 = arith.addi %273, %274 : i32
llvm.store %275, %249 : i32, !llvm.ptr
cf.br ^bb12
^bb14:
%277 = arith.constant 0 : i32
%278 = arith.constant 0 : i32
%279 = arith.constant 0 : i32
%280 = arith.constant 0 : i32
%281 = arith.constant 0 : i32
%282 = arith.constant 0 : i32
%283 = arith.constant 0 : i32
%284 = arith.constant 0 : i32
%285 = arith.constant 0 : i32
%286 = arith.constant 0 : i32
%287 = arith.constant 0 : i32
%288 = arith.constant 0 : i32
%289 = arith.constant 0 : i32
%290 = arith.constant 0 : i32
%291 = arith.constant 0 : i32
%292 = arith.constant 0 : i32
%293 = arith.constant 0 : i32
%294 = arith.constant 0 : i32
%295 = arith.constant 0 : i32
%296 = arith.constant 0 : i32
%297 = arith.constant 0 : i32
%298 = arith.constant 0 : i32
%299 = arith.constant 0 : i32
%300 = arith.constant 0 : i32
%301 = arith.constant 0 : i32
%302 = arith.constant 0 : i32
%303 = arith.constant 0 : i32
%304 = arith.constant 0 : i32
%305 = arith.constant 0 : i32
%306 = arith.constant 0 : i32
%307 = arith.constant 0 : i32
%308 = arith.constant 0 : i32
%309 = arith.constant 0 : i32
%310 = arith.constant 0 : i32
%311 = arith.constant 0 : i32
%312 = arith.constant 0 : i32
%313 = arith.constant 0 : i32
%314 = arith.constant 0 : i32
%315 = arith.constant 0 : i32
%316 = arith.constant 0 : i32
%317 = arith.constant 0 : i32
%318 = arith.constant 0 : i32
%319 = arith.constant 0 : i32
%320 = arith.constant 0 : i32
%321 = arith.constant 0 : i32
%322 = arith.constant 0 : i32
%323 = arith.constant 0 : i32
%324 = arith.constant 0 : i32
%325 = arith.constant 0 : i32
%326 = arith.constant 0 : i32
%327 = arith.constant 0 : i32
%328 = arith.constant 0 : i32
%329 = arith.constant 0 : i32
%330 = arith.constant 0 : i32
%331 = arith.constant 0 : i32
%332 = arith.constant 0 : i32
%333 = arith.constant 0 : i32
%334 = arith.constant 0 : i32
%335 = arith.constant 0 : i32
%336 = arith.constant 0 : i32
%337 = llvm.mlir.constant(1 : i64) : i64
%338 = llvm.alloca %337 x !llvm.array<60 x i32> : (i64) -> !llvm.ptr
%339 = llvm.mlir.zero : !llvm.array<60 x i32>
llvm.store %339, %338 : !llvm.array<60 x i32>, !llvm.ptr
%340 = llvm.mlir.constant(0 : i64) : i64
%341 = llvm.getelementptr %338[0, %340] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %277, %341 : i32, !llvm.ptr
%342 = llvm.mlir.constant(1 : i64) : i64
%343 = llvm.getelementptr %338[0, %342] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %278, %343 : i32, !llvm.ptr
%344 = llvm.mlir.constant(2 : i64) : i64
%345 = llvm.getelementptr %338[0, %344] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %279, %345 : i32, !llvm.ptr
%346 = llvm.mlir.constant(3 : i64) : i64
%347 = llvm.getelementptr %338[0, %346] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %280, %347 : i32, !llvm.ptr
%348 = llvm.mlir.constant(4 : i64) : i64
%349 = llvm.getelementptr %338[0, %348] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %281, %349 : i32, !llvm.ptr
%350 = llvm.mlir.constant(5 : i64) : i64
%351 = llvm.getelementptr %338[0, %350] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %282, %351 : i32, !llvm.ptr
%352 = llvm.mlir.constant(6 : i64) : i64
%353 = llvm.getelementptr %338[0, %352] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %283, %353 : i32, !llvm.ptr
%354 = llvm.mlir.constant(7 : i64) : i64
%355 = llvm.getelementptr %338[0, %354] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %284, %355 : i32, !llvm.ptr
%356 = llvm.mlir.constant(8 : i64) : i64
%357 = llvm.getelementptr %338[0, %356] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %285, %357 : i32, !llvm.ptr
%358 = llvm.mlir.constant(9 : i64) : i64
%359 = llvm.getelementptr %338[0, %358] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %286, %359 : i32, !llvm.ptr
%360 = llvm.mlir.constant(10 : i64) : i64
%361 = llvm.getelementptr %338[0, %360] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %287, %361 : i32, !llvm.ptr
%362 = llvm.mlir.constant(11 : i64) : i64
%363 = llvm.getelementptr %338[0, %362] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %288, %363 : i32, !llvm.ptr
%364 = llvm.mlir.constant(12 : i64) : i64
%365 = llvm.getelementptr %338[0, %364] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %289, %365 : i32, !llvm.ptr
%366 = llvm.mlir.constant(13 : i64) : i64
%367 = llvm.getelementptr %338[0, %366] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %290, %367 : i32, !llvm.ptr
%368 = llvm.mlir.constant(14 : i64) : i64
%369 = llvm.getelementptr %338[0, %368] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %291, %369 : i32, !llvm.ptr
%370 = llvm.mlir.constant(15 : i64) : i64
%371 = llvm.getelementptr %338[0, %370] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %292, %371 : i32, !llvm.ptr
%372 = llvm.mlir.constant(16 : i64) : i64
%373 = llvm.getelementptr %338[0, %372] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %293, %373 : i32, !llvm.ptr
%374 = llvm.mlir.constant(17 : i64) : i64
%375 = llvm.getelementptr %338[0, %374] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %294, %375 : i32, !llvm.ptr
%376 = llvm.mlir.constant(18 : i64) : i64
%377 = llvm.getelementptr %338[0, %376] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %295, %377 : i32, !llvm.ptr
%378 = llvm.mlir.constant(19 : i64) : i64
%379 = llvm.getelementptr %338[0, %378] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %296, %379 : i32, !llvm.ptr
%380 = llvm.mlir.constant(20 : i64) : i64
%381 = llvm.getelementptr %338[0, %380] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %297, %381 : i32, !llvm.ptr
%382 = llvm.mlir.constant(21 : i64) : i64
%383 = llvm.getelementptr %338[0, %382] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %298, %383 : i32, !llvm.ptr
%384 = llvm.mlir.constant(22 : i64) : i64
%385 = llvm.getelementptr %338[0, %384] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %299, %385 : i32, !llvm.ptr
%386 = llvm.mlir.constant(23 : i64) : i64
%387 = llvm.getelementptr %338[0, %386] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %300, %387 : i32, !llvm.ptr
%388 = llvm.mlir.constant(24 : i64) : i64
%389 = llvm.getelementptr %338[0, %388] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %301, %389 : i32, !llvm.ptr
%390 = llvm.mlir.constant(25 : i64) : i64
%391 = llvm.getelementptr %338[0, %390] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %302, %391 : i32, !llvm.ptr
%392 = llvm.mlir.constant(26 : i64) : i64
%393 = llvm.getelementptr %338[0, %392] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %303, %393 : i32, !llvm.ptr
%394 = llvm.mlir.constant(27 : i64) : i64
%395 = llvm.getelementptr %338[0, %394] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %304, %395 : i32, !llvm.ptr
%396 = llvm.mlir.constant(28 : i64) : i64
%397 = llvm.getelementptr %338[0, %396] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %305, %397 : i32, !llvm.ptr
%398 = llvm.mlir.constant(29 : i64) : i64
%399 = llvm.getelementptr %338[0, %398] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %306, %399 : i32, !llvm.ptr
%400 = llvm.mlir.constant(30 : i64) : i64
%401 = llvm.getelementptr %338[0, %400] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %307, %401 : i32, !llvm.ptr
%402 = llvm.mlir.constant(31 : i64) : i64
%403 = llvm.getelementptr %338[0, %402] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %308, %403 : i32, !llvm.ptr
%404 = llvm.mlir.constant(32 : i64) : i64
%405 = llvm.getelementptr %338[0, %404] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %309, %405 : i32, !llvm.ptr
%406 = llvm.mlir.constant(33 : i64) : i64
%407 = llvm.getelementptr %338[0, %406] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %310, %407 : i32, !llvm.ptr
%408 = llvm.mlir.constant(34 : i64) : i64
%409 = llvm.getelementptr %338[0, %408] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %311, %409 : i32, !llvm.ptr
%410 = llvm.mlir.constant(35 : i64) : i64
%411 = llvm.getelementptr %338[0, %410] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %312, %411 : i32, !llvm.ptr
%412 = llvm.mlir.constant(36 : i64) : i64
%413 = llvm.getelementptr %338[0, %412] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %313, %413 : i32, !llvm.ptr
%414 = llvm.mlir.constant(37 : i64) : i64
%415 = llvm.getelementptr %338[0, %414] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %314, %415 : i32, !llvm.ptr
%416 = llvm.mlir.constant(38 : i64) : i64
%417 = llvm.getelementptr %338[0, %416] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %315, %417 : i32, !llvm.ptr
%418 = llvm.mlir.constant(39 : i64) : i64
%419 = llvm.getelementptr %338[0, %418] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %316, %419 : i32, !llvm.ptr
%420 = llvm.mlir.constant(40 : i64) : i64
%421 = llvm.getelementptr %338[0, %420] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %317, %421 : i32, !llvm.ptr
%422 = llvm.mlir.constant(41 : i64) : i64
%423 = llvm.getelementptr %338[0, %422] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %318, %423 : i32, !llvm.ptr
%424 = llvm.mlir.constant(42 : i64) : i64
%425 = llvm.getelementptr %338[0, %424] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %319, %425 : i32, !llvm.ptr
%426 = llvm.mlir.constant(43 : i64) : i64
%427 = llvm.getelementptr %338[0, %426] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %320, %427 : i32, !llvm.ptr
%428 = llvm.mlir.constant(44 : i64) : i64
%429 = llvm.getelementptr %338[0, %428] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %321, %429 : i32, !llvm.ptr
%430 = llvm.mlir.constant(45 : i64) : i64
%431 = llvm.getelementptr %338[0, %430] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %322, %431 : i32, !llvm.ptr
%432 = llvm.mlir.constant(46 : i64) : i64
%433 = llvm.getelementptr %338[0, %432] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %323, %433 : i32, !llvm.ptr
%434 = llvm.mlir.constant(47 : i64) : i64
%435 = llvm.getelementptr %338[0, %434] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %324, %435 : i32, !llvm.ptr
%436 = llvm.mlir.constant(48 : i64) : i64
%437 = llvm.getelementptr %338[0, %436] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %325, %437 : i32, !llvm.ptr
%438 = llvm.mlir.constant(49 : i64) : i64
%439 = llvm.getelementptr %338[0, %438] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %326, %439 : i32, !llvm.ptr
%440 = llvm.mlir.constant(50 : i64) : i64
%441 = llvm.getelementptr %338[0, %440] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %327, %441 : i32, !llvm.ptr
%442 = llvm.mlir.constant(51 : i64) : i64
%443 = llvm.getelementptr %338[0, %442] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %328, %443 : i32, !llvm.ptr
%444 = llvm.mlir.constant(52 : i64) : i64
%445 = llvm.getelementptr %338[0, %444] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %329, %445 : i32, !llvm.ptr
%446 = llvm.mlir.constant(53 : i64) : i64
%447 = llvm.getelementptr %338[0, %446] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %330, %447 : i32, !llvm.ptr
%448 = llvm.mlir.constant(54 : i64) : i64
%449 = llvm.getelementptr %338[0, %448] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %331, %449 : i32, !llvm.ptr
%450 = llvm.mlir.constant(55 : i64) : i64
%451 = llvm.getelementptr %338[0, %450] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %332, %451 : i32, !llvm.ptr
%452 = llvm.mlir.constant(56 : i64) : i64
%453 = llvm.getelementptr %338[0, %452] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %333, %453 : i32, !llvm.ptr
%454 = llvm.mlir.constant(57 : i64) : i64
%455 = llvm.getelementptr %338[0, %454] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %334, %455 : i32, !llvm.ptr
%456 = llvm.mlir.constant(58 : i64) : i64
%457 = llvm.getelementptr %338[0, %456] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %335, %457 : i32, !llvm.ptr
%458 = llvm.mlir.constant(59 : i64) : i64
%459 = llvm.getelementptr %338[0, %458] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %336, %459 : i32, !llvm.ptr
%460 = arith.constant 0 : i32
%461 = llvm.mlir.constant(1 : i64) : i64
%462 = llvm.alloca %461 x i32 : (i64) -> !llvm.ptr
llvm.store %460, %462 : i32, !llvm.ptr
%463 = arith.constant 0 : i32
llvm.store %463, %249 : i32, !llvm.ptr
cf.br ^bb18
^bb18:
%464 = llvm.load %249 : !llvm.ptr -> i32
%465 = arith.cmpi slt, %464, %arg0 : i32
cf.cond_br %465, ^bb19, ^bb20
^bb19:
%466 = llvm.load %249 : !llvm.ptr -> i32
%467 = arith.constant 1 : i32
%468 = arith.addi %466, %467 : i32
%469 = llvm.mlir.constant(1 : i64) : i64
%470 = llvm.alloca %469 x i32 : (i64) -> !llvm.ptr
llvm.store %468, %470 : i32, !llvm.ptr
cf.br ^bb21
^bb21:
%471 = llvm.load %470 : !llvm.ptr -> i32
%472 = arith.cmpi slt, %471, %arg0 : i32
cf.cond_br %472, ^bb22, ^bb23
^bb22:
%473 = llvm.load %470 : !llvm.ptr -> i32
%474 = arith.constant 1 : i32
%475 = arith.addi %473, %474 : i32
%476 = llvm.mlir.constant(1 : i64) : i64
%477 = llvm.alloca %476 x i32 : (i64) -> !llvm.ptr
llvm.store %475, %477 : i32, !llvm.ptr
cf.br ^bb24
^bb24:
%478 = llvm.load %477 : !llvm.ptr -> i32
%479 = arith.cmpi slt, %478, %arg0 : i32
cf.cond_br %479, ^bb25, ^bb26
^bb25:
%481 = llvm.load %249 : !llvm.ptr -> i32
%482 = arith.constant 6 : i32
%483 = arith.muli %481, %482 : i32
%484 = llvm.load %470 : !llvm.ptr -> i32
%485 = arith.addi %483, %484 : i32
%486 = arith.extsi %485 : i32 to i64
%487 = llvm.getelementptr %170[0, %486] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
%480 = llvm.load %487 : !llvm.ptr -> i32
%488 = llvm.load %462 : !llvm.ptr -> i32
%489 = arith.constant 3 : i32
%490 = arith.muli %488, %489 : i32
%491 = arith.extsi %490 : i32 to i64
%492 = llvm.getelementptr %338[0, %491] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %480, %492 : i32, !llvm.ptr
%494 = llvm.load %249 : !llvm.ptr -> i32
%495 = arith.constant 6 : i32
%496 = arith.muli %494, %495 : i32
%497 = llvm.load %477 : !llvm.ptr -> i32
%498 = arith.addi %496, %497 : i32
%499 = arith.extsi %498 : i32 to i64
%500 = llvm.getelementptr %170[0, %499] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
%493 = llvm.load %500 : !llvm.ptr -> i32
%501 = llvm.load %462 : !llvm.ptr -> i32
%502 = arith.constant 3 : i32
%503 = arith.muli %501, %502 : i32
%504 = arith.constant 1 : i32
%505 = arith.addi %503, %504 : i32
%506 = arith.extsi %505 : i32 to i64
%507 = llvm.getelementptr %338[0, %506] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %493, %507 : i32, !llvm.ptr
%509 = llvm.load %470 : !llvm.ptr -> i32
%510 = arith.constant 6 : i32
%511 = arith.muli %509, %510 : i32
%512 = llvm.load %477 : !llvm.ptr -> i32
%513 = arith.addi %511, %512 : i32
%514 = arith.extsi %513 : i32 to i64
%515 = llvm.getelementptr %170[0, %514] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<36 x i32>
%508 = llvm.load %515 : !llvm.ptr -> i32
%516 = llvm.load %462 : !llvm.ptr -> i32
%517 = arith.constant 3 : i32
%518 = arith.muli %516, %517 : i32
%519 = arith.constant 2 : i32
%520 = arith.addi %518, %519 : i32
%521 = arith.extsi %520 : i32 to i64
%522 = llvm.getelementptr %338[0, %521] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
llvm.store %508, %522 : i32, !llvm.ptr
%523 = llvm.load %462 : !llvm.ptr -> i32
%524 = arith.constant 1 : i32
%525 = arith.addi %523, %524 : i32
llvm.store %525, %462 : i32, !llvm.ptr
%526 = llvm.load %477 : !llvm.ptr -> i32
%527 = arith.constant 1 : i32
%528 = arith.addi %526, %527 : i32
llvm.store %528, %477 : i32, !llvm.ptr
cf.br ^bb24
^bb26:
%529 = llvm.load %470 : !llvm.ptr -> i32
%530 = arith.constant 1 : i32
%531 = arith.addi %529, %530 : i32
llvm.store %531, %470 : i32, !llvm.ptr
cf.br ^bb21
^bb23:
%532 = llvm.load %249 : !llvm.ptr -> i32
%533 = arith.constant 1 : i32
%534 = arith.addi %532, %533 : i32
llvm.store %534, %249 : i32, !llvm.ptr
cf.br ^bb18
^bb20:
%535 = arith.constant 0 : i32
%536 = arith.extsi %535 : i32 to i64
%537 = llvm.mlir.constant(1 : i64) : i64
%538 = llvm.alloca %537 x i64 : (i64) -> !llvm.ptr
llvm.store %536, %538 : i64, !llvm.ptr
%539 = arith.constant 1 : i32
%540 = llvm.load %246 : !llvm.ptr -> i32
%541 = arith.shli %539, %540 : i32
%542 = arith.extsi %541 : i32 to i64
%543 = arith.constant 0 : i32
%544 = arith.extsi %543 : i32 to i64
%545 = llvm.mlir.constant(1 : i64) : i64
%546 = llvm.alloca %545 x i64 : (i64) -> !llvm.ptr
llvm.store %544, %546 : i64, !llvm.ptr
cf.br ^bb27
^bb27:
%547 = llvm.load %546 : !llvm.ptr -> i64
%548 = arith.cmpi slt, %547, %542 : i64
cf.cond_br %548, ^bb28, ^bb29
^bb28:
%549 = arith.constant 1 : i1
%550 = llvm.mlir.constant(1 : i64) : i64
%551 = llvm.alloca %550 x i1 : (i64) -> !llvm.ptr
llvm.store %549, %551 : i1, !llvm.ptr
%552 = arith.constant 0 : i32
%553 = llvm.mlir.constant(1 : i64) : i64
%554 = llvm.alloca %553 x i32 : (i64) -> !llvm.ptr
llvm.store %552, %554 : i32, !llvm.ptr
cf.br ^bb30
^bb30:
%555 = llvm.load %554 : !llvm.ptr -> i32
%556 = llvm.load %462 : !llvm.ptr -> i32
%557 = arith.cmpi slt, %555, %556 : i32
cf.cond_br %557, ^bb31, ^bb32
^bb31:
%558 = llvm.load %551 : !llvm.ptr -> i1
cf.cond_br %558, ^bb33, ^bb34
^bb33:
%559 = llvm.load %546 : !llvm.ptr -> i64
%561 = llvm.load %554 : !llvm.ptr -> i32
%562 = arith.constant 3 : i32
%563 = arith.muli %561, %562 : i32
%564 = arith.extsi %563 : i32 to i64
%565 = llvm.getelementptr %338[0, %564] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
%560 = llvm.load %565 : !llvm.ptr -> i32
%567 = arith.extsi %560 : i32 to i64
%566 = arith.shrsi %559, %567 : i64
%568 = arith.constant 1 : i32
%570 = arith.extsi %568 : i32 to i64
%569 = arith.andi %566, %570 : i64
%571 = arith.trunci %569 : i64 to i32
%572 = llvm.load %546 : !llvm.ptr -> i64
%574 = llvm.load %554 : !llvm.ptr -> i32
%575 = arith.constant 3 : i32
%576 = arith.muli %574, %575 : i32
%577 = arith.constant 1 : i32
%578 = arith.addi %576, %577 : i32
%579 = arith.extsi %578 : i32 to i64
%580 = llvm.getelementptr %338[0, %579] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
%573 = llvm.load %580 : !llvm.ptr -> i32
%582 = arith.extsi %573 : i32 to i64
%581 = arith.shrsi %572, %582 : i64
%583 = arith.constant 1 : i32
%585 = arith.extsi %583 : i32 to i64
%584 = arith.andi %581, %585 : i64
%586 = arith.trunci %584 : i64 to i32
%587 = llvm.load %546 : !llvm.ptr -> i64
%589 = llvm.load %554 : !llvm.ptr -> i32
%590 = arith.constant 3 : i32
%591 = arith.muli %589, %590 : i32
%592 = arith.constant 2 : i32
%593 = arith.addi %591, %592 : i32
%594 = arith.extsi %593 : i32 to i64
%595 = llvm.getelementptr %338[0, %594] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<60 x i32>
%588 = llvm.load %595 : !llvm.ptr -> i32
%597 = arith.extsi %588 : i32 to i64
%596 = arith.shrsi %587, %597 : i64
%598 = arith.constant 1 : i32
%600 = arith.extsi %598 : i32 to i64
%599 = arith.andi %596, %600 : i64
%601 = arith.trunci %599 : i64 to i32
%602 = arith.cmpi eq, %571, %586 : i32
cf.cond_br %602, ^bb36, ^bb37
^bb36:
%603 = arith.cmpi eq, %571, %601 : i32
cf.cond_br %603, ^bb39, ^bb40
^bb39:
%604 = arith.constant 0 : i1
llvm.store %604, %551 : i1, !llvm.ptr
cf.br ^bb41
^bb40:
cf.br ^bb41
^bb41:
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
cf.br ^bb35
^bb34:
cf.br ^bb35
^bb35:
%605 = llvm.load %554 : !llvm.ptr -> i32
%606 = arith.constant 1 : i32
%607 = arith.addi %605, %606 : i32
llvm.store %607, %554 : i32, !llvm.ptr
cf.br ^bb30
^bb32:
%608 = llvm.load %551 : !llvm.ptr -> i1
cf.cond_br %608, ^bb42, ^bb43
^bb42:
%609 = llvm.load %538 : !llvm.ptr -> i64
%610 = arith.constant 1 : i32
%612 = arith.extsi %610 : i32 to i64
%611 = arith.addi %609, %612 : i64
llvm.store %611, %538 : i64, !llvm.ptr
cf.br ^bb44
^bb43:
cf.br ^bb44
^bb44:
%613 = llvm.load %546 : !llvm.ptr -> i64
%614 = arith.constant 1 : i32
%616 = arith.extsi %614 : i32 to i64
%615 = arith.addi %613, %616 : i64
llvm.store %615, %546 : i64, !llvm.ptr
cf.br ^bb27
^bb29:
%617 = llvm.load %538 : !llvm.ptr -> i64
func.return %617 : i64
}
func.func @G_mod(%arg0: i64) -> i64 {
%618 = arith.constant 0 : i32
%620 = arith.extsi %618 : i32 to i64
%619 = arith.cmpi eq, %arg0, %620 : i64
cf.cond_br %619, ^bb45, ^bb46
^bb45:
%621 = arith.constant 1 : i32
%622 = arith.extsi %621 : i32 to i64
func.return %622 : i64
^bb46:
cf.br ^bb47
^bb47:
%624 = arith.constant 0 : i32
%625 = arith.constant 0 : i32
%626 = arith.constant 0 : i32
%627 = arith.constant 0 : i32
%628 = arith.constant 0 : i32
%629 = arith.constant 0 : i32
%630 = llvm.mlir.constant(1 : i64) : i64
%631 = llvm.alloca %630 x !llvm.array<6 x i64> : (i64) -> !llvm.ptr
%632 = llvm.mlir.zero : !llvm.array<6 x i64>
llvm.store %632, %631 : !llvm.array<6 x i64>, !llvm.ptr
%633 = arith.extsi %624 : i32 to i64
%634 = arith.extsi %625 : i32 to i64
%635 = arith.extsi %626 : i32 to i64
%636 = arith.extsi %627 : i32 to i64
%637 = arith.extsi %628 : i32 to i64
%638 = arith.extsi %629 : i32 to i64
%639 = llvm.mlir.constant(0 : i64) : i64
%640 = llvm.getelementptr %631[0, %639] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %633, %640 : i64, !llvm.ptr
%641 = llvm.mlir.constant(1 : i64) : i64
%642 = llvm.getelementptr %631[0, %641] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %634, %642 : i64, !llvm.ptr
%643 = llvm.mlir.constant(2 : i64) : i64
%644 = llvm.getelementptr %631[0, %643] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %635, %644 : i64, !llvm.ptr
%645 = llvm.mlir.constant(3 : i64) : i64
%646 = llvm.getelementptr %631[0, %645] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %636, %646 : i64, !llvm.ptr
%647 = llvm.mlir.constant(4 : i64) : i64
%648 = llvm.getelementptr %631[0, %647] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %637, %648 : i64, !llvm.ptr
%649 = llvm.mlir.constant(5 : i64) : i64
%650 = llvm.getelementptr %631[0, %649] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %638, %650 : i64, !llvm.ptr
%651 = arith.constant 1 : i32
%652 = llvm.mlir.constant(1 : i64) : i64
%653 = llvm.alloca %652 x i32 : (i64) -> !llvm.ptr
llvm.store %651, %653 : i32, !llvm.ptr
cf.br ^bb48
^bb48:
%654 = llvm.load %653 : !llvm.ptr -> i32
%655 = arith.constant 5 : i32
%656 = arith.cmpi sle, %654, %655 : i32
cf.cond_br %656, ^bb49, ^bb50
^bb49:
%658 = llvm.load %653 : !llvm.ptr -> i32
%657 = func.call @count_no_mono_triangle(%658) : (i32) -> i64
%659 = llvm.load %653 : !llvm.ptr -> i32
%660 = arith.extsi %659 : i32 to i64
%661 = llvm.getelementptr %631[0, %660] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %657, %661 : i64, !llvm.ptr
%662 = llvm.load %653 : !llvm.ptr -> i32
%663 = arith.constant 1 : i32
%664 = arith.addi %662, %663 : i32
llvm.store %664, %653 : i32, !llvm.ptr
cf.br ^bb48
^bb50:
%666 = arith.constant 0 : i32
%667 = arith.constant 0 : i32
%668 = arith.constant 0 : i32
%669 = arith.constant 0 : i32
%670 = arith.constant 0 : i32
%671 = arith.constant 0 : i32
%672 = llvm.mlir.constant(1 : i64) : i64
%673 = llvm.alloca %672 x !llvm.array<6 x i64> : (i64) -> !llvm.ptr
%674 = llvm.mlir.zero : !llvm.array<6 x i64>
llvm.store %674, %673 : !llvm.array<6 x i64>, !llvm.ptr
%675 = arith.extsi %666 : i32 to i64
%676 = arith.extsi %667 : i32 to i64
%677 = arith.extsi %668 : i32 to i64
%678 = arith.extsi %669 : i32 to i64
%679 = arith.extsi %670 : i32 to i64
%680 = arith.extsi %671 : i32 to i64
%681 = llvm.mlir.constant(0 : i64) : i64
%682 = llvm.getelementptr %673[0, %681] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %675, %682 : i64, !llvm.ptr
%683 = llvm.mlir.constant(1 : i64) : i64
%684 = llvm.getelementptr %673[0, %683] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %676, %684 : i64, !llvm.ptr
%685 = llvm.mlir.constant(2 : i64) : i64
%686 = llvm.getelementptr %673[0, %685] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %677, %686 : i64, !llvm.ptr
%687 = llvm.mlir.constant(3 : i64) : i64
%688 = llvm.getelementptr %673[0, %687] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %678, %688 : i64, !llvm.ptr
%689 = llvm.mlir.constant(4 : i64) : i64
%690 = llvm.getelementptr %673[0, %689] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %679, %690 : i64, !llvm.ptr
%691 = llvm.mlir.constant(5 : i64) : i64
%692 = llvm.getelementptr %673[0, %691] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %680, %692 : i64, !llvm.ptr
%693 = arith.constant 1 : i32
%694 = arith.extsi %693 : i32 to i64
%695 = llvm.mlir.constant(1 : i64) : i64
%696 = llvm.alloca %695 x i64 : (i64) -> !llvm.ptr
llvm.store %694, %696 : i64, !llvm.ptr
%697 = arith.constant 1 : i32
llvm.store %697, %653 : i32, !llvm.ptr
cf.br ^bb51
^bb51:
%698 = llvm.load %653 : !llvm.ptr -> i32
%699 = arith.constant 5 : i32
%700 = arith.cmpi sle, %698, %699 : i32
cf.cond_br %700, ^bb52, ^bb53
^bb52:
%701 = llvm.load %696 : !llvm.ptr -> i64
%702 = arith.extsi %701 : i64 to i128
%703 = llvm.load %653 : !llvm.ptr -> i32
%704 = arith.extsi %703 : i32 to i128
%706 = arith.trunci %702 : i128 to i64
%707 = arith.trunci %704 : i128 to i64
%705 = arith.muli %706, %707 : i64
%708 = llvm.mlir.addressof @MOD : !llvm.ptr
%709 = llvm.load %708 : !llvm.ptr -> i64
%710 = arith.extsi %709 : i64 to i128
%712 = arith.trunci %710 : i128 to i64
%711 = arith.remsi %705, %712 : i64
llvm.store %711, %696 : i64, !llvm.ptr
%714 = llvm.load %653 : !llvm.ptr -> i32
%715 = arith.extsi %714 : i32 to i64
%716 = llvm.getelementptr %631[0, %715] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%713 = llvm.load %716 : !llvm.ptr -> i64
%717 = arith.extsi %713 : i64 to i128
%719 = llvm.load %696 : !llvm.ptr -> i64
%720 = llvm.mlir.addressof @MOD : !llvm.ptr
%721 = llvm.load %720 : !llvm.ptr -> i64
%718 = func.call @mod_inv(%719, %721) : (i64, i64) -> i64
%722 = arith.extsi %718 : i64 to i128
%724 = arith.trunci %717 : i128 to i64
%725 = arith.trunci %722 : i128 to i64
%723 = arith.muli %724, %725 : i64
%726 = llvm.mlir.addressof @MOD : !llvm.ptr
%727 = llvm.load %726 : !llvm.ptr -> i64
%728 = arith.extsi %727 : i64 to i128
%730 = arith.trunci %728 : i128 to i64
%729 = arith.remsi %723, %730 : i64
%731 = llvm.load %653 : !llvm.ptr -> i32
%732 = arith.extsi %731 : i32 to i64
%733 = llvm.getelementptr %673[0, %732] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
llvm.store %729, %733 : i64, !llvm.ptr
%734 = llvm.load %653 : !llvm.ptr -> i32
%735 = arith.constant 1 : i32
%736 = arith.addi %734, %735 : i32
llvm.store %736, %653 : i32, !llvm.ptr
cf.br ^bb51
^bb53:
%738 = arith.constant 1 : i32
%739 = arith.extsi %738 : i32 to i64
%740 = llvm.getelementptr %673[0, %739] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%737 = llvm.load %740 : !llvm.ptr -> i64
%742 = arith.constant 2 : i32
%743 = arith.extsi %742 : i32 to i64
%744 = llvm.getelementptr %673[0, %743] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%741 = llvm.load %744 : !llvm.ptr -> i64
%746 = arith.constant 3 : i32
%747 = arith.extsi %746 : i32 to i64
%748 = llvm.getelementptr %673[0, %747] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%745 = llvm.load %748 : !llvm.ptr -> i64
%750 = arith.constant 4 : i32
%751 = arith.extsi %750 : i32 to i64
%752 = llvm.getelementptr %673[0, %751] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%749 = llvm.load %752 : !llvm.ptr -> i64
%754 = arith.constant 5 : i32
%755 = arith.extsi %754 : i32 to i64
%756 = llvm.getelementptr %673[0, %755] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<6 x i64>
%753 = llvm.load %756 : !llvm.ptr -> i64
%757 = arith.constant 1 : i32
%758 = arith.extsi %757 : i32 to i64
%759 = llvm.mlir.constant(1 : i64) : i64
%760 = llvm.alloca %759 x i64 : (i64) -> !llvm.ptr
llvm.store %758, %760 : i64, !llvm.ptr
%761 = arith.constant 0 : i32
%762 = arith.extsi %761 : i32 to i64
%763 = llvm.mlir.constant(1 : i64) : i64
%764 = llvm.alloca %763 x i64 : (i64) -> !llvm.ptr
llvm.store %762, %764 : i64, !llvm.ptr
%765 = arith.constant 0 : i32
%766 = arith.extsi %765 : i32 to i64
%767 = llvm.mlir.constant(1 : i64) : i64
%768 = llvm.alloca %767 x i64 : (i64) -> !llvm.ptr
llvm.store %766, %768 : i64, !llvm.ptr
%769 = arith.constant 0 : i32
%770 = arith.extsi %769 : i32 to i64
%771 = llvm.mlir.constant(1 : i64) : i64
%772 = llvm.alloca %771 x i64 : (i64) -> !llvm.ptr
llvm.store %770, %772 : i64, !llvm.ptr
%773 = arith.constant 0 : i32
%774 = arith.extsi %773 : i32 to i64
%775 = llvm.mlir.constant(1 : i64) : i64
%776 = llvm.alloca %775 x i64 : (i64) -> !llvm.ptr
llvm.store %774, %776 : i64, !llvm.ptr
%777 = arith.constant 1 : i32
%778 = arith.extsi %777 : i32 to i64
%779 = llvm.mlir.constant(1 : i64) : i64
%780 = llvm.alloca %779 x i64 : (i64) -> !llvm.ptr
llvm.store %778, %780 : i64, !llvm.ptr
%781 = arith.constant 1 : i32
%782 = arith.extsi %781 : i32 to i64
%783 = llvm.mlir.constant(1 : i64) : i64
%784 = llvm.alloca %783 x i64 : (i64) -> !llvm.ptr
llvm.store %782, %784 : i64, !llvm.ptr
cf.br ^bb54
^bb54:
%785 = llvm.load %784 : !llvm.ptr -> i64
%786 = arith.cmpi sle, %785, %arg0 : i64
cf.cond_br %786, ^bb55, ^bb56
^bb55:
%787 = arith.extsi %737 : i64 to i128
%788 = llvm.load %760 : !llvm.ptr -> i64
%789 = arith.extsi %788 : i64 to i128
%791 = arith.trunci %787 : i128 to i64
%792 = arith.trunci %789 : i128 to i64
%790 = arith.muli %791, %792 : i64
%793 = llvm.mlir.addressof @MOD : !llvm.ptr
%794 = llvm.load %793 : !llvm.ptr -> i64
%795 = arith.extsi %794 : i64 to i128
%797 = arith.trunci %795 : i128 to i64
%796 = arith.remsi %790, %797 : i64
%798 = arith.extsi %741 : i64 to i128
%799 = llvm.load %764 : !llvm.ptr -> i64
%800 = arith.extsi %799 : i64 to i128
%802 = arith.trunci %798 : i128 to i64
%803 = arith.trunci %800 : i128 to i64
%801 = arith.muli %802, %803 : i64
%804 = llvm.mlir.addressof @MOD : !llvm.ptr
%805 = llvm.load %804 : !llvm.ptr -> i64
%806 = arith.extsi %805 : i64 to i128
%808 = arith.trunci %806 : i128 to i64
%807 = arith.remsi %801, %808 : i64
%809 = arith.addi %796, %807 : i64
%810 = arith.extsi %745 : i64 to i128
%811 = llvm.load %768 : !llvm.ptr -> i64
%812 = arith.extsi %811 : i64 to i128
%814 = arith.trunci %810 : i128 to i64
%815 = arith.trunci %812 : i128 to i64
%813 = arith.muli %814, %815 : i64
%816 = llvm.mlir.addressof @MOD : !llvm.ptr
%817 = llvm.load %816 : !llvm.ptr -> i64
%818 = arith.extsi %817 : i64 to i128
%820 = arith.trunci %818 : i128 to i64
%819 = arith.remsi %813, %820 : i64
%821 = arith.addi %809, %819 : i64
%822 = arith.extsi %749 : i64 to i128
%823 = llvm.load %772 : !llvm.ptr -> i64
%824 = arith.extsi %823 : i64 to i128
%826 = arith.trunci %822 : i128 to i64
%827 = arith.trunci %824 : i128 to i64
%825 = arith.muli %826, %827 : i64
%828 = llvm.mlir.addressof @MOD : !llvm.ptr
%829 = llvm.load %828 : !llvm.ptr -> i64
%830 = arith.extsi %829 : i64 to i128
%832 = arith.trunci %830 : i128 to i64
%831 = arith.remsi %825, %832 : i64
%833 = arith.addi %821, %831 : i64
%834 = arith.extsi %753 : i64 to i128
%835 = llvm.load %776 : !llvm.ptr -> i64
%836 = arith.extsi %835 : i64 to i128
%838 = arith.trunci %834 : i128 to i64
%839 = arith.trunci %836 : i128 to i64
%837 = arith.muli %838, %839 : i64
%840 = llvm.mlir.addressof @MOD : !llvm.ptr
%841 = llvm.load %840 : !llvm.ptr -> i64
%842 = arith.extsi %841 : i64 to i128
%844 = arith.trunci %842 : i128 to i64
%843 = arith.remsi %837, %844 : i64
%845 = arith.addi %833, %843 : i64
%846 = llvm.mlir.addressof @MOD : !llvm.ptr
%847 = llvm.load %846 : !llvm.ptr -> i64
%848 = arith.extsi %847 : i64 to i128
%850 = arith.trunci %848 : i128 to i64
%849 = arith.remsi %845, %850 : i64
%851 = llvm.load %772 : !llvm.ptr -> i64
llvm.store %851, %776 : i64, !llvm.ptr
%852 = llvm.load %768 : !llvm.ptr -> i64
llvm.store %852, %772 : i64, !llvm.ptr
%853 = llvm.load %764 : !llvm.ptr -> i64
llvm.store %853, %768 : i64, !llvm.ptr
%854 = llvm.load %760 : !llvm.ptr -> i64
llvm.store %854, %764 : i64, !llvm.ptr
llvm.store %849, %760 : i64, !llvm.ptr
%855 = llvm.load %780 : !llvm.ptr -> i64
%856 = arith.extsi %855 : i64 to i128
%857 = llvm.load %784 : !llvm.ptr -> i64
%858 = arith.extsi %857 : i64 to i128
%860 = arith.trunci %856 : i128 to i64
%861 = arith.trunci %858 : i128 to i64
%859 = arith.muli %860, %861 : i64
%862 = llvm.mlir.addressof @MOD : !llvm.ptr
%863 = llvm.load %862 : !llvm.ptr -> i64
%864 = arith.extsi %863 : i64 to i128
%866 = arith.trunci %864 : i128 to i64
%865 = arith.remsi %859, %866 : i64
llvm.store %865, %780 : i64, !llvm.ptr
%867 = llvm.load %784 : !llvm.ptr -> i64
%868 = arith.constant 1 : i32
%870 = arith.extsi %868 : i32 to i64
%869 = arith.addi %867, %870 : i64
llvm.store %869, %784 : i64, !llvm.ptr
cf.br ^bb54
^bb56:
%871 = llvm.load %780 : !llvm.ptr -> i64
%872 = arith.extsi %871 : i64 to i128
%873 = llvm.load %760 : !llvm.ptr -> i64
%874 = arith.extsi %873 : i64 to i128
%876 = arith.trunci %872 : i128 to i64
%877 = arith.trunci %874 : i128 to i64
%875 = arith.muli %876, %877 : i64
%878 = llvm.mlir.addressof @MOD : !llvm.ptr
%879 = llvm.load %878 : !llvm.ptr -> i64
%880 = arith.extsi %879 : i64 to i128
%882 = arith.trunci %880 : i128 to i64
%881 = arith.remsi %875, %882 : i64
func.return %881 : i64
}
func.func @main() -> i32 {
%883 = llvm.mlir.addressof @str_0 : !llvm.ptr
%885 = llvm.mlir.addressof @TARGET_N : !llvm.ptr
%886 = llvm.load %885 : !llvm.ptr -> i64
%884 = func.call @G_mod(%886) : (i64) -> i64
%887 = llvm.call @printf(%883, %884) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%888 = arith.constant 0 : i32
func.return %888 : i32
}
}