← All problems Problem 898
Claire Voyant: optimal probability that Claire guesses the coin toss. Meet-in-the-middle with f64 log2 likelihood ratios and Kahan summation. 51 students with lie probabilities 25%..75%, paired into 25 3-outcome variables.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^3)O(n * m)Space complexity O(n^2)O(n)Approach Flow solution Dynamic programming or generating function Verdict Unknown
Flow source
# Project Euler 898
# Claire Voyant: optimal probability that Claire guesses the coin toss.
# Meet-in-the-middle with f64 log2 likelihood ratios and Kahan summation.
# 51 students with lie probabilities 25%..75%, paired into 25 3-outcome variables.
extern {
function calloc(n: i64, size: i64) -> ptr<void>
function free(p: ptr<void>) -> void
function log2(x: f64) -> f64
}
# Variable parallel arrays (flat: var_idx * 3 + outcome_idx)
let mut var_n_outcomes: ptr<i32> = null
let mut var_mul_n: ptr<i32> = null
let mut var_mul_d: ptr<i32> = null
let mut var_ph: ptr<f64> = null
let mut var_pt: ptr<f64> = null
let mut var_log_n: ptr<f64> = null
let mut var_log_d: ptr<f64> = null
let mut n_vars: i32 = 0
# Right state parallel arrays
let mut r_log_ratio: ptr<f64> = null
let mut r_ph: ptr<f64> = null
let mut r_pt: ptr<f64> = null
let mut n_r: i32 = 0
# Suffix sums
let mut suf_h: ptr<f64> = null
let mut suf_t: ptr<f64> = null
# Kahan summation globals
let mut pHA: f64 = 0.0
let mut cH: f64 = 0.0
let mut pTA: f64 = 0.0
let mut cT: f64 = 0.0
let mut n_left: i32 = 0
function build_variables(ps: ptr<i32>, n_ps: i32) -> void {
let counts: ptr<i32> = calloc(101, 4) as ptr<i32>
let mut i: i32 = 0
while i < n_ps {
counts[ps[i]] = counts[ps[i]] + 1
i = i + 1
}
n_vars = 0
let mut k: i32 = 0
while k < 50 {
let mut m: i32 = counts[k]
if counts[100 - k] < m {
m = counts[100 - k]
}
if m > 0 {
counts[k] = counts[k] - m
counts[100 - k] = counts[100 - k] - m
let a: i32 = 100 - k
let b: i32 = k
let num_plus: i32 = a * a
let den_plus: i32 = b * b
let num_minus: i32 = b * b
let den_minus: i32 = a * a
let p_plus_H: f64 = (a * a) as f64 / 10000.0
let p_zero: f64 = (2 * a * b) as f64 / 10000.0
let p_minus_H: f64 = (b * b) as f64 / 10000.0
let mut r: i32 = 0
while r < m {
let vi: i32 = n_vars
n_vars = n_vars + 1
var_n_outcomes[vi] = 3
var_mul_n[vi * 3 + 0] = num_minus
var_mul_d[vi * 3 + 0] = den_minus
var_ph[vi * 3 + 0] = p_minus_H
var_pt[vi * 3 + 0] = p_plus_H
var_mul_n[vi * 3 + 1] = 1
var_mul_d[vi * 3 + 1] = 1
var_ph[vi * 3 + 1] = p_zero
var_pt[vi * 3 + 1] = p_zero
var_mul_n[vi * 3 + 2] = num_plus
var_mul_d[vi * 3 + 2] = den_plus
var_ph[vi * 3 + 2] = p_plus_H
var_pt[vi * 3 + 2] = p_minus_H
let mut o: i32 = 0
while o < 3 {
var_log_n[vi * 3 + o] = log2(var_mul_n[vi * 3 + o] as f64)
var_log_d[vi * 3 + o] = log2(var_mul_d[vi * 3 + o] as f64)
o = o + 1
}
r = r + 1
}
}
k = k + 1
}
counts[50] = 0
k = 0
while k <= 100 {
let mut r: i32 = 0
while r < counts[k] {
let vi: i32 = n_vars
n_vars = n_vars + 1
let a: i32 = 100 - k
let b: i32 = k
var_n_outcomes[vi] = 2
var_mul_n[vi * 3 + 0] = b
var_mul_d[vi * 3 + 0] = a
var_ph[vi * 3 + 0] = b as f64 / 100.0
var_pt[vi * 3 + 0] = a as f64 / 100.0
var_mul_n[vi * 3 + 1] = a
var_mul_d[vi * 3 + 1] = b
var_ph[vi * 3 + 1] = a as f64 / 100.0
var_pt[vi * 3 + 1] = b as f64 / 100.0
let mut o: i32 = 0
while o < 2 {
var_log_n[vi * 3 + o] = log2(var_mul_n[vi * 3 + o] as f64)
var_log_d[vi * 3 + o] = log2(var_mul_d[vi * 3 + o] as f64)
o = o + 1
}
r = r + 1
}
k = k + 1
}
free(counts as ptr<void>)
}
function merge_r(tmp_lr: ptr<f64>, tmp_ph: ptr<f64>, tmp_pt: ptr<f64>, lo: i32, mid: i32, hi: i32) -> void {
let mut i: i32 = lo
let mut j: i32 = mid
let mut k: i32 = lo
while i < mid && j < hi {
if r_log_ratio[i] <= r_log_ratio[j] {
tmp_lr[k] = r_log_ratio[i]
tmp_ph[k] = r_ph[i]
tmp_pt[k] = r_pt[i]
i = i + 1
} else {
tmp_lr[k] = r_log_ratio[j]
tmp_ph[k] = r_ph[j]
tmp_pt[k] = r_pt[j]
j = j + 1
}
k = k + 1
}
while i < mid {
tmp_lr[k] = r_log_ratio[i]
tmp_ph[k] = r_ph[i]
tmp_pt[k] = r_pt[i]
i = i + 1
k = k + 1
}
while j < hi {
tmp_lr[k] = r_log_ratio[j]
tmp_ph[k] = r_ph[j]
tmp_pt[k] = r_pt[j]
j = j + 1
k = k + 1
}
i = lo
while i < hi {
r_log_ratio[i] = tmp_lr[i]
r_ph[i] = tmp_ph[i]
r_pt[i] = tmp_pt[i]
i = i + 1
}
}
function merge_sort_r(tmp_lr: ptr<f64>, tmp_ph: ptr<f64>, tmp_pt: ptr<f64>, lo: i32, hi: i32) -> void {
if hi - lo <= 1 { return }
let mid: i32 = (lo + hi) / 2
merge_sort_r(tmp_lr, tmp_ph, tmp_pt, lo, mid)
merge_sort_r(tmp_lr, tmp_ph, tmp_pt, mid, hi)
merge_r(tmp_lr, tmp_ph, tmp_pt, lo, mid, hi)
}
function enumerate_right(start: i32, n: i32) -> void {
let mut count: i32 = 1
let mut log_ratios: ptr<f64> = calloc(1, 8) as ptr<f64>
let mut phs: ptr<f64> = calloc(1, 8) as ptr<f64>
let mut pts: ptr<f64> = calloc(1, 8) as ptr<f64>
log_ratios[0] = 0.0
phs[0] = 1.0
pts[0] = 1.0
let mut v: i32 = start
while v < n {
let no: i32 = var_n_outcomes[v]
let new_count: i32 = count * no
let nr: ptr<f64> = calloc(new_count as i64, 8) as ptr<f64>
let nph: ptr<f64> = calloc(new_count as i64, 8) as ptr<f64>
let npt: ptr<f64> = calloc(new_count as i64, 8) as ptr<f64>
let mut idx: i32 = 0
let mut i: i32 = 0
while i < count {
let mut o: i32 = 0
while o < no {
nr[idx] = log_ratios[i] + var_log_n[v * 3 + o] - var_log_d[v * 3 + o]
nph[idx] = phs[i] * var_ph[v * 3 + o]
npt[idx] = pts[i] * var_pt[v * 3 + o]
idx = idx + 1
o = o + 1
}
i = i + 1
}
free(log_ratios as ptr<void>)
free(phs as ptr<void>)
free(pts as ptr<void>)
log_ratios = nr
phs = nph
pts = npt
count = new_count
v = v + 1
}
n_r = count
let mut i2: i32 = 0
while i2 < count {
r_log_ratio[i2] = log_ratios[i2]
r_ph[i2] = phs[i2]
r_pt[i2] = pts[i2]
i2 = i2 + 1
}
free(log_ratios as ptr<void>)
free(phs as ptr<void>)
free(pts as ptr<void>)
let tmp_lr: ptr<f64> = calloc(count as i64, 8) as ptr<f64>
let tmp_ph: ptr<f64> = calloc(count as i64, 8) as ptr<f64>
let tmp_pt: ptr<f64> = calloc(count as i64, 8) as ptr<f64>
merge_sort_r(tmp_lr, tmp_ph, tmp_pt, 0, count)
free(tmp_lr as ptr<void>)
free(tmp_ph as ptr<void>)
free(tmp_pt as ptr<void>)
suf_h[count] = 0.0
suf_t[count] = 0.0
let mut i3: i32 = count - 1
while i3 >= 0 {
suf_h[i3] = suf_h[i3 + 1] + r_ph[i3]
suf_t[i3] = suf_t[i3 + 1] + r_pt[i3]
i3 = i3 - 1
}
}
function enum_left(vi: i32, ph: f64, pt: f64, log_ratio: f64) -> void {
if vi == n_left {
let threshold: f64 = 0.0 - log_ratio
let mut lo: i32 = 0
let mut hi: i32 = n_r
while lo < hi {
let mid: i32 = (lo + hi) / 2
if r_log_ratio[mid] < threshold {
lo = mid + 1
} else {
hi = mid
}
}
let j: i32 = lo
let y_h: f64 = ph * suf_h[j] - cH
let t_h: f64 = pHA + y_h
cH = (t_h - pHA) - y_h
pHA = t_h
let y_t: f64 = pt * suf_t[j] - cT
let t_t: f64 = pTA + y_t
cT = (t_t - pTA) - y_t
pTA = t_t
return
}
let no: i32 = var_n_outcomes[vi]
let mut o: i32 = 0
while o < no {
let new_log_ratio: f64 = log_ratio + var_log_n[vi * 3 + o] - var_log_d[vi * 3 + o]
enum_left(vi + 1, ph * var_ph[vi * 3 + o], pt * var_pt[vi * 3 + o], new_log_ratio)
o = o + 1
}
}
function main() -> i32 {
var_n_outcomes = calloc(60, 4) as ptr<i32>
var_mul_n = calloc(180, 4) as ptr<i32>
var_mul_d = calloc(180, 4) as ptr<i32>
var_ph = calloc(180, 8) as ptr<f64>
var_pt = calloc(180, 8) as ptr<f64>
var_log_n = calloc(180, 8) as ptr<f64>
var_log_d = calloc(180, 8) as ptr<f64>
let ps: ptr<i32> = calloc(51, 4) as ptr<i32>
let mut i: i32 = 0
while i < 51 {
ps[i] = 25 + i
i = i + 1
}
build_variables(ps, 51)
free(ps as ptr<void>)
if n_vars == 0 {
printf("0.5\n")
return 0
}
let mid: i32 = n_vars / 2
n_left = mid
r_log_ratio = calloc(2000000, 8) as ptr<f64>
r_ph = calloc(2000000, 8) as ptr<f64>
r_pt = calloc(2000000, 8) as ptr<f64>
suf_h = calloc(2000001, 8) as ptr<f64>
suf_t = calloc(2000001, 8) as ptr<f64>
enumerate_right(mid, n_vars)
pHA = 0.0
cH = 0.0
pTA = 0.0
cT = 0.0
enum_left(0, 1.0, 1.0, 0.0)
let mut tv: f64 = pHA - pTA
if tv < -1.0 { tv = -1.0 }
if tv > 1.0 { tv = 1.0 }
printf("%.10f\n", 0.5 * (1.0 + tv))
free(var_n_outcomes as ptr<void>)
free(var_mul_n as ptr<void>)
free(var_mul_d as ptr<void>)
free(var_ph as ptr<void>)
free(var_pt as ptr<void>)
free(var_log_n as ptr<void>)
free(var_log_d as ptr<void>)
free(r_log_ratio as ptr<void>)
free(r_ph as ptr<void>)
free(r_pt as ptr<void>)
free(suf_h as ptr<void>)
free(suf_t as ptr<void>)
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 build_variables_ptr_i32_i32(int32_t* ps, int32_t n_ps);
void merge_r_ptr_f64_ptr_f64_ptr_f64_i32_i32_i32(double* tmp_lr, double* tmp_ph, double* tmp_pt, int32_t lo, int32_t mid, int32_t hi);
void merge_sort_r_ptr_f64_ptr_f64_ptr_f64_i32_i32(double* tmp_lr, double* tmp_ph, double* tmp_pt, int32_t lo, int32_t hi);
void enumerate_right_i32_i32(int32_t start, int32_t n);
void enum_left_i32_f64_f64_f64(int32_t vi, double ph, double pt, double log_ratio);
int32_t main(void);
/* Module statics */
static int32_t* var_n_outcomes = NULL;
static int32_t* var_mul_n = NULL;
static int32_t* var_mul_d = NULL;
static double* var_ph = NULL;
static double* var_pt = NULL;
static double* var_log_n = NULL;
static double* var_log_d = NULL;
static int32_t n_vars = 0;
static double* r_log_ratio = NULL;
static double* r_ph = NULL;
static double* r_pt = NULL;
static int32_t n_r = 0;
static double* suf_h = NULL;
static double* suf_t = NULL;
static double pHA = 0.0;
static double cH = 0.0;
static double pTA = 0.0;
static double cT = 0.0;
static int32_t n_left = 0;
void build_variables_ptr_i32_i32(int32_t* ps, int32_t n_ps) {
int32_t* counts = (int32_t*)(((int32_t*)(calloc(101, 4))));
int32_t i = 0;
while (i < n_ps) {
counts[ps[i]] = (counts[ps[i]] + 1);
i = (i + 1);
}
n_vars = 0;
int32_t k = 0;
while (k < 50) {
int32_t m = counts[k];
if (counts[(100 - k)] < m) {
m = counts[(100 - k)];
}
if (m > 0) {
counts[k] = (counts[k] - m);
counts[(100 - k)] = (counts[(100 - k)] - m);
int32_t a = (100 - k);
int32_t b = k;
int32_t num_plus = (a * a);
int32_t den_plus = (b * b);
int32_t num_minus = (b * b);
int32_t den_minus = (a * a);
double p_plus_H = (((double)((a * a))) / 10000.0);
double p_zero = (((double)(((2 * a) * b))) / 10000.0);
double p_minus_H = (((double)((b * b))) / 10000.0);
int32_t r = 0;
while (r < m) {
int32_t vi = n_vars;
n_vars = (n_vars + 1);
var_n_outcomes[vi] = 3;
var_mul_n[((vi * 3) + 0)] = num_minus;
var_mul_d[((vi * 3) + 0)] = den_minus;
var_ph[((vi * 3) + 0)] = p_minus_H;
var_pt[((vi * 3) + 0)] = p_plus_H;
var_mul_n[((vi * 3) + 1)] = 1;
var_mul_d[((vi * 3) + 1)] = 1;
var_ph[((vi * 3) + 1)] = p_zero;
var_pt[((vi * 3) + 1)] = p_zero;
var_mul_n[((vi * 3) + 2)] = num_plus;
var_mul_d[((vi * 3) + 2)] = den_plus;
var_ph[((vi * 3) + 2)] = p_plus_H;
var_pt[((vi * 3) + 2)] = p_minus_H;
int32_t o = 0;
while (o < 3) {
var_log_n[((vi * 3) + o)] = log2(((double)(var_mul_n[((vi * 3) + o)])));
var_log_d[((vi * 3) + o)] = log2(((double)(var_mul_d[((vi * 3) + o)])));
o = (o + 1);
}
r = (r + 1);
}
}
k = (k + 1);
}
counts[50] = 0;
k = 0;
while (k <= 100) {
int32_t r = 0;
while (r < counts[k]) {
int32_t vi = n_vars;
n_vars = (n_vars + 1);
int32_t a = (100 - k);
int32_t b = k;
var_n_outcomes[vi] = 2;
var_mul_n[((vi * 3) + 0)] = b;
var_mul_d[((vi * 3) + 0)] = a;
var_ph[((vi * 3) + 0)] = (((double)(b)) / 100.0);
var_pt[((vi * 3) + 0)] = (((double)(a)) / 100.0);
var_mul_n[((vi * 3) + 1)] = a;
var_mul_d[((vi * 3) + 1)] = b;
var_ph[((vi * 3) + 1)] = (((double)(a)) / 100.0);
var_pt[((vi * 3) + 1)] = (((double)(b)) / 100.0);
int32_t o = 0;
while (o < 2) {
var_log_n[((vi * 3) + o)] = log2(((double)(var_mul_n[((vi * 3) + o)])));
var_log_d[((vi * 3) + o)] = log2(((double)(var_mul_d[((vi * 3) + o)])));
o = (o + 1);
}
r = (r + 1);
}
k = (k + 1);
}
free(((void*)(counts)));
}
void merge_r_ptr_f64_ptr_f64_ptr_f64_i32_i32_i32(double* tmp_lr, double* tmp_ph, double* tmp_pt, int32_t lo, int32_t mid, int32_t hi) {
int32_t i = lo;
int32_t j = mid;
int32_t k = lo;
while ((i < mid && j < hi)) {
if (r_log_ratio[i] <= r_log_ratio[j]) {
tmp_lr[k] = r_log_ratio[i];
tmp_ph[k] = r_ph[i];
tmp_pt[k] = r_pt[i];
i = (i + 1);
} else {
tmp_lr[k] = r_log_ratio[j];
tmp_ph[k] = r_ph[j];
tmp_pt[k] = r_pt[j];
j = (j + 1);
}
k = (k + 1);
}
while (i < mid) {
tmp_lr[k] = r_log_ratio[i];
tmp_ph[k] = r_ph[i];
tmp_pt[k] = r_pt[i];
i = (i + 1);
k = (k + 1);
}
while (j < hi) {
tmp_lr[k] = r_log_ratio[j];
tmp_ph[k] = r_ph[j];
tmp_pt[k] = r_pt[j];
j = (j + 1);
k = (k + 1);
}
i = lo;
while (i < hi) {
r_log_ratio[i] = tmp_lr[i];
r_ph[i] = tmp_ph[i];
r_pt[i] = tmp_pt[i];
i = (i + 1);
}
}
void merge_sort_r_ptr_f64_ptr_f64_ptr_f64_i32_i32(double* tmp_lr, double* tmp_ph, double* tmp_pt, int32_t lo, int32_t hi) {
if ((hi - lo) <= 1) {
return;
}
int32_t mid = FLOW_CHECKED_DIV(((lo + hi)), (2));
merge_sort_r_ptr_f64_ptr_f64_ptr_f64_i32_i32(tmp_lr, tmp_ph, tmp_pt, lo, mid);
merge_sort_r_ptr_f64_ptr_f64_ptr_f64_i32_i32(tmp_lr, tmp_ph, tmp_pt, mid, hi);
merge_r_ptr_f64_ptr_f64_ptr_f64_i32_i32_i32(tmp_lr, tmp_ph, tmp_pt, lo, mid, hi);
}
void enumerate_right_i32_i32(int32_t start, int32_t n) {
int32_t count = 1;
double* log_ratios = (double*)(((double*)(calloc(1, 8))));
double* phs = (double*)(((double*)(calloc(1, 8))));
double* pts = (double*)(((double*)(calloc(1, 8))));
log_ratios[0] = 0.0;
phs[0] = 1.0;
pts[0] = 1.0;
int32_t v = start;
while (v < n) {
int32_t no = var_n_outcomes[v];
int32_t new_count = (count * no);
double* nr = (double*)(((double*)(calloc(((int64_t)(new_count)), 8))));
double* nph = (double*)(((double*)(calloc(((int64_t)(new_count)), 8))));
double* npt = (double*)(((double*)(calloc(((int64_t)(new_count)), 8))));
int32_t idx = 0;
int32_t i = 0;
while (i < count) {
int32_t o = 0;
while (o < no) {
nr[idx] = ((log_ratios[i] + var_log_n[((v * 3) + o)]) - var_log_d[((v * 3) + o)]);
nph[idx] = (phs[i] * var_ph[((v * 3) + o)]);
npt[idx] = (pts[i] * var_pt[((v * 3) + o)]);
idx = (idx + 1);
o = (o + 1);
}
i = (i + 1);
}
free(((void*)(log_ratios)));
free(((void*)(phs)));
free(((void*)(pts)));
log_ratios = nr;
phs = nph;
pts = npt;
count = new_count;
v = (v + 1);
}
n_r = count;
int32_t i2 = 0;
while (i2 < count) {
r_log_ratio[i2] = log_ratios[i2];
r_ph[i2] = phs[i2];
r_pt[i2] = pts[i2];
i2 = (i2 + 1);
}
free(((void*)(log_ratios)));
free(((void*)(phs)));
free(((void*)(pts)));
double* tmp_lr = (double*)(((double*)(calloc(((int64_t)(count)), 8))));
double* tmp_ph = (double*)(((double*)(calloc(((int64_t)(count)), 8))));
double* tmp_pt = (double*)(((double*)(calloc(((int64_t)(count)), 8))));
merge_sort_r_ptr_f64_ptr_f64_ptr_f64_i32_i32(tmp_lr, tmp_ph, tmp_pt, 0, count);
free(((void*)(tmp_lr)));
free(((void*)(tmp_ph)));
free(((void*)(tmp_pt)));
suf_h[count] = 0.0;
suf_t[count] = 0.0;
int32_t i3 = (count - 1);
while (i3 >= 0) {
suf_h[i3] = (suf_h[(i3 + 1)] + r_ph[i3]);
suf_t[i3] = (suf_t[(i3 + 1)] + r_pt[i3]);
i3 = (i3 - 1);
}
}
void enum_left_i32_f64_f64_f64(int32_t vi, double ph, double pt, double log_ratio) {
if (vi == n_left) {
double threshold = (0.0 - log_ratio);
int32_t lo = 0;
int32_t hi = n_r;
while (lo < hi) {
int32_t mid = FLOW_CHECKED_DIV(((lo + hi)), (2));
if (r_log_ratio[mid] < threshold) {
lo = (mid + 1);
} else {
hi = mid;
}
}
int32_t j = lo;
double y_h = ((ph * suf_h[j]) - cH);
double t_h = (pHA + y_h);
cH = ((t_h - pHA) - y_h);
pHA = t_h;
double y_t = ((pt * suf_t[j]) - cT);
double t_t = (pTA + y_t);
cT = ((t_t - pTA) - y_t);
pTA = t_t;
return;
}
int32_t no = var_n_outcomes[vi];
int32_t o = 0;
while (o < no) {
double new_log_ratio = ((log_ratio + var_log_n[((vi * 3) + o)]) - var_log_d[((vi * 3) + o)]);
enum_left_i32_f64_f64_f64((vi + 1), (ph * var_ph[((vi * 3) + o)]), (pt * var_pt[((vi * 3) + o)]), new_log_ratio);
o = (o + 1);
}
}
int32_t main(void) {
var_n_outcomes = ((int32_t*)(calloc(60, 4)));
var_mul_n = ((int32_t*)(calloc(180, 4)));
var_mul_d = ((int32_t*)(calloc(180, 4)));
var_ph = ((double*)(calloc(180, 8)));
var_pt = ((double*)(calloc(180, 8)));
var_log_n = ((double*)(calloc(180, 8)));
var_log_d = ((double*)(calloc(180, 8)));
int32_t* ps = (int32_t*)(((int32_t*)(calloc(51, 4))));
int32_t i = 0;
while (i < 51) {
ps[i] = (25 + i);
i = (i + 1);
}
build_variables_ptr_i32_i32(ps, 51);
free(((void*)(ps)));
if (n_vars == 0) {
printf("0.5\n");
return 0;
}
int32_t mid = FLOW_CHECKED_DIV((n_vars), (2));
n_left = mid;
r_log_ratio = ((double*)(calloc(2000000, 8)));
r_ph = ((double*)(calloc(2000000, 8)));
r_pt = ((double*)(calloc(2000000, 8)));
suf_h = ((double*)(calloc(2000001, 8)));
suf_t = ((double*)(calloc(2000001, 8)));
enumerate_right_i32_i32(mid, n_vars);
pHA = 0.0;
cH = 0.0;
pTA = 0.0;
cT = 0.0;
enum_left_i32_f64_f64_f64(0, 1.0, 1.0, 0.0);
double tv = (pHA - pTA);
if (tv < (-1.0)) {
tv = (-1.0);
}
if (tv > 1.0) {
tv = 1.0;
}
printf("%.10f\n", (0.5 * (1.0 + tv)));
free(((void*)(var_n_outcomes)));
free(((void*)(var_mul_n)));
free(((void*)(var_mul_d)));
free(((void*)(var_ph)));
free(((void*)(var_pt)));
free(((void*)(var_log_n)));
free(((void*)(var_log_d)));
free(((void*)(r_log_ratio)));
free(((void*)(r_ph)));
free(((void*)(r_pt)));
free(((void*)(suf_h)));
free(((void*)(suf_t)));
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("0.5\n\00") {addr_space = 0 : i32} : !llvm.array<5 x i8>
llvm.mlir.global internal constant @str_1("%.10f\n\00") {addr_space = 0 : i32} : !llvm.array<7 x i8>
func.func private @calloc(i64, i64) -> !llvm.ptr
func.func private @free(!llvm.ptr) -> ()
func.func private @log2(f64) -> f64
// Module static: var_n_outcomes
llvm.mlir.global internal @var_n_outcomes() {addr_space = 0 : i32} : !llvm.ptr {
%0 = llvm.mlir.zero : !llvm.ptr
llvm.return %0 : !llvm.ptr
}
// Module static: var_mul_n
llvm.mlir.global internal @var_mul_n() {addr_space = 0 : i32} : !llvm.ptr {
%1 = llvm.mlir.zero : !llvm.ptr
llvm.return %1 : !llvm.ptr
}
// Module static: var_mul_d
llvm.mlir.global internal @var_mul_d() {addr_space = 0 : i32} : !llvm.ptr {
%2 = llvm.mlir.zero : !llvm.ptr
llvm.return %2 : !llvm.ptr
}
// Module static: var_ph
llvm.mlir.global internal @var_ph() {addr_space = 0 : i32} : !llvm.ptr {
%3 = llvm.mlir.zero : !llvm.ptr
llvm.return %3 : !llvm.ptr
}
// Module static: var_pt
llvm.mlir.global internal @var_pt() {addr_space = 0 : i32} : !llvm.ptr {
%4 = llvm.mlir.zero : !llvm.ptr
llvm.return %4 : !llvm.ptr
}
// Module static: var_log_n
llvm.mlir.global internal @var_log_n() {addr_space = 0 : i32} : !llvm.ptr {
%5 = llvm.mlir.zero : !llvm.ptr
llvm.return %5 : !llvm.ptr
}
// Module static: var_log_d
llvm.mlir.global internal @var_log_d() {addr_space = 0 : i32} : !llvm.ptr {
%6 = llvm.mlir.zero : !llvm.ptr
llvm.return %6 : !llvm.ptr
}
// Module static: n_vars
llvm.mlir.global internal @n_vars(0 : i32) : i32
// Module static: r_log_ratio
llvm.mlir.global internal @r_log_ratio() {addr_space = 0 : i32} : !llvm.ptr {
%7 = llvm.mlir.zero : !llvm.ptr
llvm.return %7 : !llvm.ptr
}
// Module static: r_ph
llvm.mlir.global internal @r_ph() {addr_space = 0 : i32} : !llvm.ptr {
%8 = llvm.mlir.zero : !llvm.ptr
llvm.return %8 : !llvm.ptr
}
// Module static: r_pt
llvm.mlir.global internal @r_pt() {addr_space = 0 : i32} : !llvm.ptr {
%9 = llvm.mlir.zero : !llvm.ptr
llvm.return %9 : !llvm.ptr
}
// Module static: n_r
llvm.mlir.global internal @n_r(0 : i32) : i32
// Module static: suf_h
llvm.mlir.global internal @suf_h() {addr_space = 0 : i32} : !llvm.ptr {
%10 = llvm.mlir.zero : !llvm.ptr
llvm.return %10 : !llvm.ptr
}
// Module static: suf_t
llvm.mlir.global internal @suf_t() {addr_space = 0 : i32} : !llvm.ptr {
%11 = llvm.mlir.zero : !llvm.ptr
llvm.return %11 : !llvm.ptr
}
// Module static: pHA
llvm.mlir.global internal @pHA(0.0 : f64) : f64
// Module static: cH
llvm.mlir.global internal @cH(0.0 : f64) : f64
// Module static: pTA
llvm.mlir.global internal @pTA(0.0 : f64) : f64
// Module static: cT
llvm.mlir.global internal @cT(0.0 : f64) : f64
// Module static: n_left
llvm.mlir.global internal @n_left(0 : i32) : i32
func.func @build_variables(%arg0: !llvm.ptr, %arg1: i32) -> () {
%13 = arith.constant 101 : i32
%14 = arith.constant 4 : i32
%15 = arith.extsi %13 : i32 to i64
%16 = arith.extsi %14 : i32 to i64
%12 = func.call @calloc(%15, %16) : (i64, i64) -> !llvm.ptr
%17 = arith.constant 0 : i32
%18 = llvm.mlir.constant(1 : i64) : i64
%19 = llvm.alloca %18 x i32 : (i64) -> !llvm.ptr
llvm.store %17, %19 : i32, !llvm.ptr
cf.br ^bb0
^bb0:
%20 = llvm.load %19 : !llvm.ptr -> i32
%21 = arith.cmpi slt, %20, %arg1 : i32
cf.cond_br %21, ^bb1, ^bb2
^bb1:
%24 = llvm.load %19 : !llvm.ptr -> i32
%25 = arith.extsi %24 : i32 to i64
%26 = llvm.getelementptr %arg0[%25] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%23 = llvm.load %26 : !llvm.ptr -> i32
%27 = arith.extsi %23 : i32 to i64
%28 = llvm.getelementptr %12[%27] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%22 = llvm.load %28 : !llvm.ptr -> i32
%29 = arith.constant 1 : i32
%30 = arith.addi %22, %29 : i32
%32 = llvm.load %19 : !llvm.ptr -> i32
%33 = arith.extsi %32 : i32 to i64
%34 = llvm.getelementptr %arg0[%33] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%31 = llvm.load %34 : !llvm.ptr -> i32
%35 = arith.extsi %31 : i32 to i64
%36 = llvm.getelementptr %12[%35] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %30, %36 : i32, !llvm.ptr
%37 = llvm.load %19 : !llvm.ptr -> i32
%38 = arith.constant 1 : i32
%39 = arith.addi %37, %38 : i32
llvm.store %39, %19 : i32, !llvm.ptr
cf.br ^bb0
^bb2:
%40 = arith.constant 0 : i32
%41 = llvm.mlir.addressof @n_vars : !llvm.ptr
llvm.store %40, %41 : i32, !llvm.ptr
%42 = arith.constant 0 : i32
%43 = llvm.mlir.constant(1 : i64) : i64
%44 = llvm.alloca %43 x i32 : (i64) -> !llvm.ptr
llvm.store %42, %44 : i32, !llvm.ptr
cf.br ^bb3
^bb3:
%45 = llvm.load %44 : !llvm.ptr -> i32
%46 = arith.constant 50 : i32
%47 = arith.cmpi slt, %45, %46 : i32
cf.cond_br %47, ^bb4, ^bb5
^bb4:
%49 = llvm.load %44 : !llvm.ptr -> i32
%50 = arith.extsi %49 : i32 to i64
%51 = llvm.getelementptr %12[%50] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%48 = llvm.load %51 : !llvm.ptr -> i32
%52 = llvm.mlir.constant(1 : i64) : i64
%53 = llvm.alloca %52 x i32 : (i64) -> !llvm.ptr
llvm.store %48, %53 : i32, !llvm.ptr
%55 = arith.constant 100 : i32
%56 = llvm.load %44 : !llvm.ptr -> i32
%57 = arith.subi %55, %56 : i32
%58 = arith.extsi %57 : i32 to i64
%59 = llvm.getelementptr %12[%58] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%54 = llvm.load %59 : !llvm.ptr -> i32
%60 = llvm.load %53 : !llvm.ptr -> i32
%61 = arith.cmpi slt, %54, %60 : i32
cf.cond_br %61, ^bb6, ^bb7
^bb6:
%63 = arith.constant 100 : i32
%64 = llvm.load %44 : !llvm.ptr -> i32
%65 = arith.subi %63, %64 : i32
%66 = arith.extsi %65 : i32 to i64
%67 = llvm.getelementptr %12[%66] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%62 = llvm.load %67 : !llvm.ptr -> i32
llvm.store %62, %53 : i32, !llvm.ptr
cf.br ^bb8
^bb7:
cf.br ^bb8
^bb8:
%68 = llvm.load %53 : !llvm.ptr -> i32
%69 = arith.constant 0 : i32
%70 = arith.cmpi sgt, %68, %69 : i32
cf.cond_br %70, ^bb9, ^bb10
^bb9:
%72 = llvm.load %44 : !llvm.ptr -> i32
%73 = arith.extsi %72 : i32 to i64
%74 = llvm.getelementptr %12[%73] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%71 = llvm.load %74 : !llvm.ptr -> i32
%75 = llvm.load %53 : !llvm.ptr -> i32
%76 = arith.subi %71, %75 : i32
%77 = llvm.load %44 : !llvm.ptr -> i32
%78 = arith.extsi %77 : i32 to i64
%79 = llvm.getelementptr %12[%78] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %76, %79 : i32, !llvm.ptr
%81 = arith.constant 100 : i32
%82 = llvm.load %44 : !llvm.ptr -> i32
%83 = arith.subi %81, %82 : i32
%84 = arith.extsi %83 : i32 to i64
%85 = llvm.getelementptr %12[%84] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%80 = llvm.load %85 : !llvm.ptr -> i32
%86 = llvm.load %53 : !llvm.ptr -> i32
%87 = arith.subi %80, %86 : i32
%88 = arith.constant 100 : i32
%89 = llvm.load %44 : !llvm.ptr -> i32
%90 = arith.subi %88, %89 : i32
%91 = arith.extsi %90 : i32 to i64
%92 = llvm.getelementptr %12[%91] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %87, %92 : i32, !llvm.ptr
%93 = arith.constant 100 : i32
%94 = llvm.load %44 : !llvm.ptr -> i32
%95 = arith.subi %93, %94 : i32
%96 = llvm.load %44 : !llvm.ptr -> i32
%97 = arith.muli %95, %95 : i32
%98 = arith.muli %96, %96 : i32
%99 = arith.muli %96, %96 : i32
%100 = arith.muli %95, %95 : i32
%101 = arith.muli %95, %95 : i32
%102 = arith.sitofp %101 : i32 to f64
%103 = arith.constant 10000.0 : f32
%105 = arith.extf %103 : f32 to f64
%104 = arith.divf %102, %105 : f64
%106 = arith.constant 2 : i32
%107 = arith.muli %106, %95 : i32
%108 = arith.muli %107, %96 : i32
%109 = arith.sitofp %108 : i32 to f64
%110 = arith.constant 10000.0 : f32
%112 = arith.extf %110 : f32 to f64
%111 = arith.divf %109, %112 : f64
%113 = arith.muli %96, %96 : i32
%114 = arith.sitofp %113 : i32 to f64
%115 = arith.constant 10000.0 : f32
%117 = arith.extf %115 : f32 to f64
%116 = arith.divf %114, %117 : f64
%118 = arith.constant 0 : i32
%119 = llvm.mlir.constant(1 : i64) : i64
%120 = llvm.alloca %119 x i32 : (i64) -> !llvm.ptr
llvm.store %118, %120 : i32, !llvm.ptr
cf.br ^bb12
^bb12:
%121 = llvm.load %120 : !llvm.ptr -> i32
%122 = llvm.load %53 : !llvm.ptr -> i32
%123 = arith.cmpi slt, %121, %122 : i32
cf.cond_br %123, ^bb13, ^bb14
^bb13:
%124 = llvm.mlir.addressof @n_vars : !llvm.ptr
%125 = llvm.load %124 : !llvm.ptr -> i32
%126 = llvm.mlir.addressof @n_vars : !llvm.ptr
%127 = llvm.load %126 : !llvm.ptr -> i32
%128 = arith.constant 1 : i32
%129 = arith.addi %127, %128 : i32
%130 = llvm.mlir.addressof @n_vars : !llvm.ptr
llvm.store %129, %130 : i32, !llvm.ptr
%131 = arith.constant 3 : i32
%132 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
%133 = llvm.load %132 : !llvm.ptr -> !llvm.ptr
%134 = arith.extsi %125 : i32 to i64
%135 = llvm.getelementptr %133[%134] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %131, %135 : i32, !llvm.ptr
%136 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%137 = llvm.load %136 : !llvm.ptr -> !llvm.ptr
%138 = arith.constant 3 : i32
%139 = arith.muli %125, %138 : i32
%140 = arith.constant 0 : i32
%141 = arith.addi %139, %140 : i32
%142 = arith.extsi %141 : i32 to i64
%143 = llvm.getelementptr %137[%142] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %99, %143 : i32, !llvm.ptr
%144 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%145 = llvm.load %144 : !llvm.ptr -> !llvm.ptr
%146 = arith.constant 3 : i32
%147 = arith.muli %125, %146 : i32
%148 = arith.constant 0 : i32
%149 = arith.addi %147, %148 : i32
%150 = arith.extsi %149 : i32 to i64
%151 = llvm.getelementptr %145[%150] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %100, %151 : i32, !llvm.ptr
%152 = llvm.mlir.addressof @var_ph : !llvm.ptr
%153 = llvm.load %152 : !llvm.ptr -> !llvm.ptr
%154 = arith.constant 3 : i32
%155 = arith.muli %125, %154 : i32
%156 = arith.constant 0 : i32
%157 = arith.addi %155, %156 : i32
%158 = arith.extsi %157 : i32 to i64
%159 = llvm.getelementptr %153[%158] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %116, %159 : f64, !llvm.ptr
%160 = llvm.mlir.addressof @var_pt : !llvm.ptr
%161 = llvm.load %160 : !llvm.ptr -> !llvm.ptr
%162 = arith.constant 3 : i32
%163 = arith.muli %125, %162 : i32
%164 = arith.constant 0 : i32
%165 = arith.addi %163, %164 : i32
%166 = arith.extsi %165 : i32 to i64
%167 = llvm.getelementptr %161[%166] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %104, %167 : f64, !llvm.ptr
%168 = arith.constant 1 : i32
%169 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%170 = llvm.load %169 : !llvm.ptr -> !llvm.ptr
%171 = arith.constant 3 : i32
%172 = arith.muli %125, %171 : i32
%173 = arith.constant 1 : i32
%174 = arith.addi %172, %173 : i32
%175 = arith.extsi %174 : i32 to i64
%176 = llvm.getelementptr %170[%175] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %168, %176 : i32, !llvm.ptr
%177 = arith.constant 1 : i32
%178 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%179 = llvm.load %178 : !llvm.ptr -> !llvm.ptr
%180 = arith.constant 3 : i32
%181 = arith.muli %125, %180 : i32
%182 = arith.constant 1 : i32
%183 = arith.addi %181, %182 : i32
%184 = arith.extsi %183 : i32 to i64
%185 = llvm.getelementptr %179[%184] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %177, %185 : i32, !llvm.ptr
%186 = llvm.mlir.addressof @var_ph : !llvm.ptr
%187 = llvm.load %186 : !llvm.ptr -> !llvm.ptr
%188 = arith.constant 3 : i32
%189 = arith.muli %125, %188 : i32
%190 = arith.constant 1 : i32
%191 = arith.addi %189, %190 : i32
%192 = arith.extsi %191 : i32 to i64
%193 = llvm.getelementptr %187[%192] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %111, %193 : f64, !llvm.ptr
%194 = llvm.mlir.addressof @var_pt : !llvm.ptr
%195 = llvm.load %194 : !llvm.ptr -> !llvm.ptr
%196 = arith.constant 3 : i32
%197 = arith.muli %125, %196 : i32
%198 = arith.constant 1 : i32
%199 = arith.addi %197, %198 : i32
%200 = arith.extsi %199 : i32 to i64
%201 = llvm.getelementptr %195[%200] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %111, %201 : f64, !llvm.ptr
%202 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%203 = llvm.load %202 : !llvm.ptr -> !llvm.ptr
%204 = arith.constant 3 : i32
%205 = arith.muli %125, %204 : i32
%206 = arith.constant 2 : i32
%207 = arith.addi %205, %206 : i32
%208 = arith.extsi %207 : i32 to i64
%209 = llvm.getelementptr %203[%208] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %97, %209 : i32, !llvm.ptr
%210 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%211 = llvm.load %210 : !llvm.ptr -> !llvm.ptr
%212 = arith.constant 3 : i32
%213 = arith.muli %125, %212 : i32
%214 = arith.constant 2 : i32
%215 = arith.addi %213, %214 : i32
%216 = arith.extsi %215 : i32 to i64
%217 = llvm.getelementptr %211[%216] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %98, %217 : i32, !llvm.ptr
%218 = llvm.mlir.addressof @var_ph : !llvm.ptr
%219 = llvm.load %218 : !llvm.ptr -> !llvm.ptr
%220 = arith.constant 3 : i32
%221 = arith.muli %125, %220 : i32
%222 = arith.constant 2 : i32
%223 = arith.addi %221, %222 : i32
%224 = arith.extsi %223 : i32 to i64
%225 = llvm.getelementptr %219[%224] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %104, %225 : f64, !llvm.ptr
%226 = llvm.mlir.addressof @var_pt : !llvm.ptr
%227 = llvm.load %226 : !llvm.ptr -> !llvm.ptr
%228 = arith.constant 3 : i32
%229 = arith.muli %125, %228 : i32
%230 = arith.constant 2 : i32
%231 = arith.addi %229, %230 : i32
%232 = arith.extsi %231 : i32 to i64
%233 = llvm.getelementptr %227[%232] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %116, %233 : f64, !llvm.ptr
%234 = arith.constant 0 : i32
%235 = llvm.mlir.constant(1 : i64) : i64
%236 = llvm.alloca %235 x i32 : (i64) -> !llvm.ptr
llvm.store %234, %236 : i32, !llvm.ptr
cf.br ^bb15
^bb15:
%237 = llvm.load %236 : !llvm.ptr -> i32
%238 = arith.constant 3 : i32
%239 = arith.cmpi slt, %237, %238 : i32
cf.cond_br %239, ^bb16, ^bb17
^bb16:
%242 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%243 = llvm.load %242 : !llvm.ptr -> !llvm.ptr
%244 = arith.constant 3 : i32
%245 = arith.muli %125, %244 : i32
%246 = llvm.load %236 : !llvm.ptr -> i32
%247 = arith.addi %245, %246 : i32
%248 = arith.extsi %247 : i32 to i64
%249 = llvm.getelementptr %243[%248] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%241 = llvm.load %249 : !llvm.ptr -> i32
%250 = arith.sitofp %241 : i32 to f64
%240 = func.call @log2(%250) : (f64) -> f64
%251 = llvm.mlir.addressof @var_log_n : !llvm.ptr
%252 = llvm.load %251 : !llvm.ptr -> !llvm.ptr
%253 = arith.constant 3 : i32
%254 = arith.muli %125, %253 : i32
%255 = llvm.load %236 : !llvm.ptr -> i32
%256 = arith.addi %254, %255 : i32
%257 = arith.extsi %256 : i32 to i64
%258 = llvm.getelementptr %252[%257] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %240, %258 : f64, !llvm.ptr
%261 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%262 = llvm.load %261 : !llvm.ptr -> !llvm.ptr
%263 = arith.constant 3 : i32
%264 = arith.muli %125, %263 : i32
%265 = llvm.load %236 : !llvm.ptr -> i32
%266 = arith.addi %264, %265 : i32
%267 = arith.extsi %266 : i32 to i64
%268 = llvm.getelementptr %262[%267] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%260 = llvm.load %268 : !llvm.ptr -> i32
%269 = arith.sitofp %260 : i32 to f64
%259 = func.call @log2(%269) : (f64) -> f64
%270 = llvm.mlir.addressof @var_log_d : !llvm.ptr
%271 = llvm.load %270 : !llvm.ptr -> !llvm.ptr
%272 = arith.constant 3 : i32
%273 = arith.muli %125, %272 : i32
%274 = llvm.load %236 : !llvm.ptr -> i32
%275 = arith.addi %273, %274 : i32
%276 = arith.extsi %275 : i32 to i64
%277 = llvm.getelementptr %271[%276] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %259, %277 : f64, !llvm.ptr
%278 = llvm.load %236 : !llvm.ptr -> i32
%279 = arith.constant 1 : i32
%280 = arith.addi %278, %279 : i32
llvm.store %280, %236 : i32, !llvm.ptr
cf.br ^bb15
^bb17:
%281 = llvm.load %120 : !llvm.ptr -> i32
%282 = arith.constant 1 : i32
%283 = arith.addi %281, %282 : i32
llvm.store %283, %120 : i32, !llvm.ptr
cf.br ^bb12
^bb14:
cf.br ^bb11
^bb10:
cf.br ^bb11
^bb11:
%284 = llvm.load %44 : !llvm.ptr -> i32
%285 = arith.constant 1 : i32
%286 = arith.addi %284, %285 : i32
llvm.store %286, %44 : i32, !llvm.ptr
cf.br ^bb3
^bb5:
%287 = arith.constant 0 : i32
%288 = arith.constant 50 : i32
%289 = arith.extsi %288 : i32 to i64
%290 = llvm.getelementptr %12[%289] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %287, %290 : i32, !llvm.ptr
%291 = arith.constant 0 : i32
llvm.store %291, %44 : i32, !llvm.ptr
cf.br ^bb18
^bb18:
%292 = llvm.load %44 : !llvm.ptr -> i32
%293 = arith.constant 100 : i32
%294 = arith.cmpi sle, %292, %293 : i32
cf.cond_br %294, ^bb19, ^bb20
^bb19:
%295 = arith.constant 0 : i32
%296 = llvm.mlir.constant(1 : i64) : i64
%297 = llvm.alloca %296 x i32 : (i64) -> !llvm.ptr
llvm.store %295, %297 : i32, !llvm.ptr
cf.br ^bb21
^bb21:
%298 = llvm.load %297 : !llvm.ptr -> i32
%300 = llvm.load %44 : !llvm.ptr -> i32
%301 = arith.extsi %300 : i32 to i64
%302 = llvm.getelementptr %12[%301] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%299 = llvm.load %302 : !llvm.ptr -> i32
%303 = arith.cmpi slt, %298, %299 : i32
cf.cond_br %303, ^bb22, ^bb23
^bb22:
%304 = llvm.mlir.addressof @n_vars : !llvm.ptr
%305 = llvm.load %304 : !llvm.ptr -> i32
%306 = llvm.mlir.addressof @n_vars : !llvm.ptr
%307 = llvm.load %306 : !llvm.ptr -> i32
%308 = arith.constant 1 : i32
%309 = arith.addi %307, %308 : i32
%310 = llvm.mlir.addressof @n_vars : !llvm.ptr
llvm.store %309, %310 : i32, !llvm.ptr
%311 = arith.constant 100 : i32
%312 = llvm.load %44 : !llvm.ptr -> i32
%313 = arith.subi %311, %312 : i32
%314 = llvm.load %44 : !llvm.ptr -> i32
%315 = arith.constant 2 : i32
%316 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
%317 = llvm.load %316 : !llvm.ptr -> !llvm.ptr
%318 = arith.extsi %305 : i32 to i64
%319 = llvm.getelementptr %317[%318] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %315, %319 : i32, !llvm.ptr
%320 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%321 = llvm.load %320 : !llvm.ptr -> !llvm.ptr
%322 = arith.constant 3 : i32
%323 = arith.muli %305, %322 : i32
%324 = arith.constant 0 : i32
%325 = arith.addi %323, %324 : i32
%326 = arith.extsi %325 : i32 to i64
%327 = llvm.getelementptr %321[%326] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %314, %327 : i32, !llvm.ptr
%328 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%329 = llvm.load %328 : !llvm.ptr -> !llvm.ptr
%330 = arith.constant 3 : i32
%331 = arith.muli %305, %330 : i32
%332 = arith.constant 0 : i32
%333 = arith.addi %331, %332 : i32
%334 = arith.extsi %333 : i32 to i64
%335 = llvm.getelementptr %329[%334] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %313, %335 : i32, !llvm.ptr
%336 = arith.sitofp %314 : i32 to f64
%337 = arith.constant 100.0 : f32
%339 = arith.extf %337 : f32 to f64
%338 = arith.divf %336, %339 : f64
%340 = llvm.mlir.addressof @var_ph : !llvm.ptr
%341 = llvm.load %340 : !llvm.ptr -> !llvm.ptr
%342 = arith.constant 3 : i32
%343 = arith.muli %305, %342 : i32
%344 = arith.constant 0 : i32
%345 = arith.addi %343, %344 : i32
%346 = arith.extsi %345 : i32 to i64
%347 = llvm.getelementptr %341[%346] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %338, %347 : f64, !llvm.ptr
%348 = arith.sitofp %313 : i32 to f64
%349 = arith.constant 100.0 : f32
%351 = arith.extf %349 : f32 to f64
%350 = arith.divf %348, %351 : f64
%352 = llvm.mlir.addressof @var_pt : !llvm.ptr
%353 = llvm.load %352 : !llvm.ptr -> !llvm.ptr
%354 = arith.constant 3 : i32
%355 = arith.muli %305, %354 : i32
%356 = arith.constant 0 : i32
%357 = arith.addi %355, %356 : i32
%358 = arith.extsi %357 : i32 to i64
%359 = llvm.getelementptr %353[%358] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %350, %359 : f64, !llvm.ptr
%360 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%361 = llvm.load %360 : !llvm.ptr -> !llvm.ptr
%362 = arith.constant 3 : i32
%363 = arith.muli %305, %362 : i32
%364 = arith.constant 1 : i32
%365 = arith.addi %363, %364 : i32
%366 = arith.extsi %365 : i32 to i64
%367 = llvm.getelementptr %361[%366] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %313, %367 : i32, !llvm.ptr
%368 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%369 = llvm.load %368 : !llvm.ptr -> !llvm.ptr
%370 = arith.constant 3 : i32
%371 = arith.muli %305, %370 : i32
%372 = arith.constant 1 : i32
%373 = arith.addi %371, %372 : i32
%374 = arith.extsi %373 : i32 to i64
%375 = llvm.getelementptr %369[%374] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %314, %375 : i32, !llvm.ptr
%376 = arith.sitofp %313 : i32 to f64
%377 = arith.constant 100.0 : f32
%379 = arith.extf %377 : f32 to f64
%378 = arith.divf %376, %379 : f64
%380 = llvm.mlir.addressof @var_ph : !llvm.ptr
%381 = llvm.load %380 : !llvm.ptr -> !llvm.ptr
%382 = arith.constant 3 : i32
%383 = arith.muli %305, %382 : i32
%384 = arith.constant 1 : i32
%385 = arith.addi %383, %384 : i32
%386 = arith.extsi %385 : i32 to i64
%387 = llvm.getelementptr %381[%386] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %378, %387 : f64, !llvm.ptr
%388 = arith.sitofp %314 : i32 to f64
%389 = arith.constant 100.0 : f32
%391 = arith.extf %389 : f32 to f64
%390 = arith.divf %388, %391 : f64
%392 = llvm.mlir.addressof @var_pt : !llvm.ptr
%393 = llvm.load %392 : !llvm.ptr -> !llvm.ptr
%394 = arith.constant 3 : i32
%395 = arith.muli %305, %394 : i32
%396 = arith.constant 1 : i32
%397 = arith.addi %395, %396 : i32
%398 = arith.extsi %397 : i32 to i64
%399 = llvm.getelementptr %393[%398] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %390, %399 : f64, !llvm.ptr
%400 = arith.constant 0 : i32
%401 = llvm.mlir.constant(1 : i64) : i64
%402 = llvm.alloca %401 x i32 : (i64) -> !llvm.ptr
llvm.store %400, %402 : i32, !llvm.ptr
cf.br ^bb24
^bb24:
%403 = llvm.load %402 : !llvm.ptr -> i32
%404 = arith.constant 2 : i32
%405 = arith.cmpi slt, %403, %404 : i32
cf.cond_br %405, ^bb25, ^bb26
^bb25:
%408 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%409 = llvm.load %408 : !llvm.ptr -> !llvm.ptr
%410 = arith.constant 3 : i32
%411 = arith.muli %305, %410 : i32
%412 = llvm.load %402 : !llvm.ptr -> i32
%413 = arith.addi %411, %412 : i32
%414 = arith.extsi %413 : i32 to i64
%415 = llvm.getelementptr %409[%414] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%407 = llvm.load %415 : !llvm.ptr -> i32
%416 = arith.sitofp %407 : i32 to f64
%406 = func.call @log2(%416) : (f64) -> f64
%417 = llvm.mlir.addressof @var_log_n : !llvm.ptr
%418 = llvm.load %417 : !llvm.ptr -> !llvm.ptr
%419 = arith.constant 3 : i32
%420 = arith.muli %305, %419 : i32
%421 = llvm.load %402 : !llvm.ptr -> i32
%422 = arith.addi %420, %421 : i32
%423 = arith.extsi %422 : i32 to i64
%424 = llvm.getelementptr %418[%423] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %406, %424 : f64, !llvm.ptr
%427 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%428 = llvm.load %427 : !llvm.ptr -> !llvm.ptr
%429 = arith.constant 3 : i32
%430 = arith.muli %305, %429 : i32
%431 = llvm.load %402 : !llvm.ptr -> i32
%432 = arith.addi %430, %431 : i32
%433 = arith.extsi %432 : i32 to i64
%434 = llvm.getelementptr %428[%433] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%426 = llvm.load %434 : !llvm.ptr -> i32
%435 = arith.sitofp %426 : i32 to f64
%425 = func.call @log2(%435) : (f64) -> f64
%436 = llvm.mlir.addressof @var_log_d : !llvm.ptr
%437 = llvm.load %436 : !llvm.ptr -> !llvm.ptr
%438 = arith.constant 3 : i32
%439 = arith.muli %305, %438 : i32
%440 = llvm.load %402 : !llvm.ptr -> i32
%441 = arith.addi %439, %440 : i32
%442 = arith.extsi %441 : i32 to i64
%443 = llvm.getelementptr %437[%442] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %425, %443 : f64, !llvm.ptr
%444 = llvm.load %402 : !llvm.ptr -> i32
%445 = arith.constant 1 : i32
%446 = arith.addi %444, %445 : i32
llvm.store %446, %402 : i32, !llvm.ptr
cf.br ^bb24
^bb26:
%447 = llvm.load %297 : !llvm.ptr -> i32
%448 = arith.constant 1 : i32
%449 = arith.addi %447, %448 : i32
llvm.store %449, %297 : i32, !llvm.ptr
cf.br ^bb21
^bb23:
%450 = llvm.load %44 : !llvm.ptr -> i32
%451 = arith.constant 1 : i32
%452 = arith.addi %450, %451 : i32
llvm.store %452, %44 : i32, !llvm.ptr
cf.br ^bb18
^bb20:
func.call @free(%12) : (!llvm.ptr) -> ()
func.return
}
func.func @merge_r(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i32, %arg4: i32, %arg5: i32) -> () {
%454 = llvm.mlir.constant(1 : i64) : i64
%455 = llvm.alloca %454 x i32 : (i64) -> !llvm.ptr
llvm.store %arg3, %455 : i32, !llvm.ptr
%456 = llvm.mlir.constant(1 : i64) : i64
%457 = llvm.alloca %456 x i32 : (i64) -> !llvm.ptr
llvm.store %arg4, %457 : i32, !llvm.ptr
%458 = llvm.mlir.constant(1 : i64) : i64
%459 = llvm.alloca %458 x i32 : (i64) -> !llvm.ptr
llvm.store %arg3, %459 : i32, !llvm.ptr
cf.br ^bb27
^bb27:
%460 = llvm.load %455 : !llvm.ptr -> i32
%461 = arith.cmpi slt, %460, %arg4 : i32
%462 = scf.if %461 -> (i1) {
%463 = llvm.load %457 : !llvm.ptr -> i32
%464 = arith.cmpi slt, %463, %arg5 : i32
scf.yield %464 : i1
} else {
%465 = arith.constant false
scf.yield %465 : i1
}
cf.cond_br %462, ^bb28, ^bb29
^bb28:
%467 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%468 = llvm.load %467 : !llvm.ptr -> !llvm.ptr
%469 = llvm.load %455 : !llvm.ptr -> i32
%470 = arith.extsi %469 : i32 to i64
%471 = llvm.getelementptr %468[%470] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%466 = llvm.load %471 : !llvm.ptr -> f64
%473 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%474 = llvm.load %473 : !llvm.ptr -> !llvm.ptr
%475 = llvm.load %457 : !llvm.ptr -> i32
%476 = arith.extsi %475 : i32 to i64
%477 = llvm.getelementptr %474[%476] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%472 = llvm.load %477 : !llvm.ptr -> f64
%478 = arith.cmpf ole, %466, %472 : f64
cf.cond_br %478, ^bb30, ^bb31
^bb30:
%480 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%481 = llvm.load %480 : !llvm.ptr -> !llvm.ptr
%482 = llvm.load %455 : !llvm.ptr -> i32
%483 = arith.extsi %482 : i32 to i64
%484 = llvm.getelementptr %481[%483] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%479 = llvm.load %484 : !llvm.ptr -> f64
%485 = llvm.load %459 : !llvm.ptr -> i32
%486 = arith.extsi %485 : i32 to i64
%487 = llvm.getelementptr %arg0[%486] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %479, %487 : f64, !llvm.ptr
%489 = llvm.mlir.addressof @r_ph : !llvm.ptr
%490 = llvm.load %489 : !llvm.ptr -> !llvm.ptr
%491 = llvm.load %455 : !llvm.ptr -> i32
%492 = arith.extsi %491 : i32 to i64
%493 = llvm.getelementptr %490[%492] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%488 = llvm.load %493 : !llvm.ptr -> f64
%494 = llvm.load %459 : !llvm.ptr -> i32
%495 = arith.extsi %494 : i32 to i64
%496 = llvm.getelementptr %arg1[%495] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %488, %496 : f64, !llvm.ptr
%498 = llvm.mlir.addressof @r_pt : !llvm.ptr
%499 = llvm.load %498 : !llvm.ptr -> !llvm.ptr
%500 = llvm.load %455 : !llvm.ptr -> i32
%501 = arith.extsi %500 : i32 to i64
%502 = llvm.getelementptr %499[%501] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%497 = llvm.load %502 : !llvm.ptr -> f64
%503 = llvm.load %459 : !llvm.ptr -> i32
%504 = arith.extsi %503 : i32 to i64
%505 = llvm.getelementptr %arg2[%504] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %497, %505 : f64, !llvm.ptr
%506 = llvm.load %455 : !llvm.ptr -> i32
%507 = arith.constant 1 : i32
%508 = arith.addi %506, %507 : i32
llvm.store %508, %455 : i32, !llvm.ptr
cf.br ^bb32
^bb31:
%510 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%511 = llvm.load %510 : !llvm.ptr -> !llvm.ptr
%512 = llvm.load %457 : !llvm.ptr -> i32
%513 = arith.extsi %512 : i32 to i64
%514 = llvm.getelementptr %511[%513] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%509 = llvm.load %514 : !llvm.ptr -> f64
%515 = llvm.load %459 : !llvm.ptr -> i32
%516 = arith.extsi %515 : i32 to i64
%517 = llvm.getelementptr %arg0[%516] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %509, %517 : f64, !llvm.ptr
%519 = llvm.mlir.addressof @r_ph : !llvm.ptr
%520 = llvm.load %519 : !llvm.ptr -> !llvm.ptr
%521 = llvm.load %457 : !llvm.ptr -> i32
%522 = arith.extsi %521 : i32 to i64
%523 = llvm.getelementptr %520[%522] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%518 = llvm.load %523 : !llvm.ptr -> f64
%524 = llvm.load %459 : !llvm.ptr -> i32
%525 = arith.extsi %524 : i32 to i64
%526 = llvm.getelementptr %arg1[%525] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %518, %526 : f64, !llvm.ptr
%528 = llvm.mlir.addressof @r_pt : !llvm.ptr
%529 = llvm.load %528 : !llvm.ptr -> !llvm.ptr
%530 = llvm.load %457 : !llvm.ptr -> i32
%531 = arith.extsi %530 : i32 to i64
%532 = llvm.getelementptr %529[%531] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%527 = llvm.load %532 : !llvm.ptr -> f64
%533 = llvm.load %459 : !llvm.ptr -> i32
%534 = arith.extsi %533 : i32 to i64
%535 = llvm.getelementptr %arg2[%534] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %527, %535 : f64, !llvm.ptr
%536 = llvm.load %457 : !llvm.ptr -> i32
%537 = arith.constant 1 : i32
%538 = arith.addi %536, %537 : i32
llvm.store %538, %457 : i32, !llvm.ptr
cf.br ^bb32
^bb32:
%539 = llvm.load %459 : !llvm.ptr -> i32
%540 = arith.constant 1 : i32
%541 = arith.addi %539, %540 : i32
llvm.store %541, %459 : i32, !llvm.ptr
cf.br ^bb27
^bb29:
cf.br ^bb33
^bb33:
%542 = llvm.load %455 : !llvm.ptr -> i32
%543 = arith.cmpi slt, %542, %arg4 : i32
cf.cond_br %543, ^bb34, ^bb35
^bb34:
%545 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%546 = llvm.load %545 : !llvm.ptr -> !llvm.ptr
%547 = llvm.load %455 : !llvm.ptr -> i32
%548 = arith.extsi %547 : i32 to i64
%549 = llvm.getelementptr %546[%548] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%544 = llvm.load %549 : !llvm.ptr -> f64
%550 = llvm.load %459 : !llvm.ptr -> i32
%551 = arith.extsi %550 : i32 to i64
%552 = llvm.getelementptr %arg0[%551] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %544, %552 : f64, !llvm.ptr
%554 = llvm.mlir.addressof @r_ph : !llvm.ptr
%555 = llvm.load %554 : !llvm.ptr -> !llvm.ptr
%556 = llvm.load %455 : !llvm.ptr -> i32
%557 = arith.extsi %556 : i32 to i64
%558 = llvm.getelementptr %555[%557] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%553 = llvm.load %558 : !llvm.ptr -> f64
%559 = llvm.load %459 : !llvm.ptr -> i32
%560 = arith.extsi %559 : i32 to i64
%561 = llvm.getelementptr %arg1[%560] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %553, %561 : f64, !llvm.ptr
%563 = llvm.mlir.addressof @r_pt : !llvm.ptr
%564 = llvm.load %563 : !llvm.ptr -> !llvm.ptr
%565 = llvm.load %455 : !llvm.ptr -> i32
%566 = arith.extsi %565 : i32 to i64
%567 = llvm.getelementptr %564[%566] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%562 = llvm.load %567 : !llvm.ptr -> f64
%568 = llvm.load %459 : !llvm.ptr -> i32
%569 = arith.extsi %568 : i32 to i64
%570 = llvm.getelementptr %arg2[%569] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %562, %570 : f64, !llvm.ptr
%571 = llvm.load %455 : !llvm.ptr -> i32
%572 = arith.constant 1 : i32
%573 = arith.addi %571, %572 : i32
llvm.store %573, %455 : i32, !llvm.ptr
%574 = llvm.load %459 : !llvm.ptr -> i32
%575 = arith.constant 1 : i32
%576 = arith.addi %574, %575 : i32
llvm.store %576, %459 : i32, !llvm.ptr
cf.br ^bb33
^bb35:
cf.br ^bb36
^bb36:
%577 = llvm.load %457 : !llvm.ptr -> i32
%578 = arith.cmpi slt, %577, %arg5 : i32
cf.cond_br %578, ^bb37, ^bb38
^bb37:
%580 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%581 = llvm.load %580 : !llvm.ptr -> !llvm.ptr
%582 = llvm.load %457 : !llvm.ptr -> i32
%583 = arith.extsi %582 : i32 to i64
%584 = llvm.getelementptr %581[%583] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%579 = llvm.load %584 : !llvm.ptr -> f64
%585 = llvm.load %459 : !llvm.ptr -> i32
%586 = arith.extsi %585 : i32 to i64
%587 = llvm.getelementptr %arg0[%586] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %579, %587 : f64, !llvm.ptr
%589 = llvm.mlir.addressof @r_ph : !llvm.ptr
%590 = llvm.load %589 : !llvm.ptr -> !llvm.ptr
%591 = llvm.load %457 : !llvm.ptr -> i32
%592 = arith.extsi %591 : i32 to i64
%593 = llvm.getelementptr %590[%592] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%588 = llvm.load %593 : !llvm.ptr -> f64
%594 = llvm.load %459 : !llvm.ptr -> i32
%595 = arith.extsi %594 : i32 to i64
%596 = llvm.getelementptr %arg1[%595] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %588, %596 : f64, !llvm.ptr
%598 = llvm.mlir.addressof @r_pt : !llvm.ptr
%599 = llvm.load %598 : !llvm.ptr -> !llvm.ptr
%600 = llvm.load %457 : !llvm.ptr -> i32
%601 = arith.extsi %600 : i32 to i64
%602 = llvm.getelementptr %599[%601] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%597 = llvm.load %602 : !llvm.ptr -> f64
%603 = llvm.load %459 : !llvm.ptr -> i32
%604 = arith.extsi %603 : i32 to i64
%605 = llvm.getelementptr %arg2[%604] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %597, %605 : f64, !llvm.ptr
%606 = llvm.load %457 : !llvm.ptr -> i32
%607 = arith.constant 1 : i32
%608 = arith.addi %606, %607 : i32
llvm.store %608, %457 : i32, !llvm.ptr
%609 = llvm.load %459 : !llvm.ptr -> i32
%610 = arith.constant 1 : i32
%611 = arith.addi %609, %610 : i32
llvm.store %611, %459 : i32, !llvm.ptr
cf.br ^bb36
^bb38:
llvm.store %arg3, %455 : i32, !llvm.ptr
cf.br ^bb39
^bb39:
%612 = llvm.load %455 : !llvm.ptr -> i32
%613 = arith.cmpi slt, %612, %arg5 : i32
cf.cond_br %613, ^bb40, ^bb41
^bb40:
%615 = llvm.load %455 : !llvm.ptr -> i32
%616 = arith.extsi %615 : i32 to i64
%617 = llvm.getelementptr %arg0[%616] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%614 = llvm.load %617 : !llvm.ptr -> f64
%618 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%619 = llvm.load %618 : !llvm.ptr -> !llvm.ptr
%620 = llvm.load %455 : !llvm.ptr -> i32
%621 = arith.extsi %620 : i32 to i64
%622 = llvm.getelementptr %619[%621] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %614, %622 : f64, !llvm.ptr
%624 = llvm.load %455 : !llvm.ptr -> i32
%625 = arith.extsi %624 : i32 to i64
%626 = llvm.getelementptr %arg1[%625] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%623 = llvm.load %626 : !llvm.ptr -> f64
%627 = llvm.mlir.addressof @r_ph : !llvm.ptr
%628 = llvm.load %627 : !llvm.ptr -> !llvm.ptr
%629 = llvm.load %455 : !llvm.ptr -> i32
%630 = arith.extsi %629 : i32 to i64
%631 = llvm.getelementptr %628[%630] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %623, %631 : f64, !llvm.ptr
%633 = llvm.load %455 : !llvm.ptr -> i32
%634 = arith.extsi %633 : i32 to i64
%635 = llvm.getelementptr %arg2[%634] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%632 = llvm.load %635 : !llvm.ptr -> f64
%636 = llvm.mlir.addressof @r_pt : !llvm.ptr
%637 = llvm.load %636 : !llvm.ptr -> !llvm.ptr
%638 = llvm.load %455 : !llvm.ptr -> i32
%639 = arith.extsi %638 : i32 to i64
%640 = llvm.getelementptr %637[%639] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %632, %640 : f64, !llvm.ptr
%641 = llvm.load %455 : !llvm.ptr -> i32
%642 = arith.constant 1 : i32
%643 = arith.addi %641, %642 : i32
llvm.store %643, %455 : i32, !llvm.ptr
cf.br ^bb39
^bb41:
func.return
}
func.func @merge_sort_r(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr, %arg3: i32, %arg4: i32) -> () {
%644 = arith.subi %arg4, %arg3 : i32
%645 = arith.constant 1 : i32
%646 = arith.cmpi sle, %644, %645 : i32
cf.cond_br %646, ^bb42, ^bb43
^bb42:
func.return
^bb43:
cf.br ^bb44
^bb44:
%647 = arith.addi %arg3, %arg4 : i32
%648 = arith.constant 2 : i32
%649 = arith.divsi %647, %648 : i32
func.call @merge_sort_r(%arg0, %arg1, %arg2, %arg3, %649) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, i32) -> ()
func.call @merge_sort_r(%arg0, %arg1, %arg2, %649, %arg4) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, i32) -> ()
func.call @merge_r(%arg0, %arg1, %arg2, %arg3, %649, %arg4) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, i32, i32) -> ()
func.return
}
func.func @enumerate_right(%arg0: i32, %arg1: i32) -> () {
%653 = arith.constant 1 : i32
%654 = llvm.mlir.constant(1 : i64) : i64
%655 = llvm.alloca %654 x i32 : (i64) -> !llvm.ptr
llvm.store %653, %655 : i32, !llvm.ptr
%657 = arith.constant 1 : i32
%658 = arith.constant 8 : i32
%659 = arith.extsi %657 : i32 to i64
%660 = arith.extsi %658 : i32 to i64
%656 = func.call @calloc(%659, %660) : (i64, i64) -> !llvm.ptr
%661 = llvm.mlir.constant(1 : i64) : i64
%662 = llvm.alloca %661 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %656, %662 : !llvm.ptr, !llvm.ptr
%664 = arith.constant 1 : i32
%665 = arith.constant 8 : i32
%666 = arith.extsi %664 : i32 to i64
%667 = arith.extsi %665 : i32 to i64
%663 = func.call @calloc(%666, %667) : (i64, i64) -> !llvm.ptr
%668 = llvm.mlir.constant(1 : i64) : i64
%669 = llvm.alloca %668 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %663, %669 : !llvm.ptr, !llvm.ptr
%671 = arith.constant 1 : i32
%672 = arith.constant 8 : i32
%673 = arith.extsi %671 : i32 to i64
%674 = arith.extsi %672 : i32 to i64
%670 = func.call @calloc(%673, %674) : (i64, i64) -> !llvm.ptr
%675 = llvm.mlir.constant(1 : i64) : i64
%676 = llvm.alloca %675 x !llvm.ptr : (i64) -> !llvm.ptr
llvm.store %670, %676 : !llvm.ptr, !llvm.ptr
%677 = arith.constant 0.0 : f32
%678 = llvm.load %662 : !llvm.ptr -> !llvm.ptr
%679 = arith.constant 0 : i32
%680 = arith.extf %677 : f32 to f64
%681 = arith.extsi %679 : i32 to i64
%682 = llvm.getelementptr %678[%681] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %680, %682 : f64, !llvm.ptr
%683 = arith.constant 1.0 : f32
%684 = llvm.load %669 : !llvm.ptr -> !llvm.ptr
%685 = arith.constant 0 : i32
%686 = arith.extf %683 : f32 to f64
%687 = arith.extsi %685 : i32 to i64
%688 = llvm.getelementptr %684[%687] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %686, %688 : f64, !llvm.ptr
%689 = arith.constant 1.0 : f32
%690 = llvm.load %676 : !llvm.ptr -> !llvm.ptr
%691 = arith.constant 0 : i32
%692 = arith.extf %689 : f32 to f64
%693 = arith.extsi %691 : i32 to i64
%694 = llvm.getelementptr %690[%693] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %692, %694 : f64, !llvm.ptr
%695 = llvm.mlir.constant(1 : i64) : i64
%696 = llvm.alloca %695 x i32 : (i64) -> !llvm.ptr
llvm.store %arg0, %696 : i32, !llvm.ptr
cf.br ^bb45
^bb45:
%697 = llvm.load %696 : !llvm.ptr -> i32
%698 = arith.cmpi slt, %697, %arg1 : i32
cf.cond_br %698, ^bb46, ^bb47
^bb46:
%700 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
%701 = llvm.load %700 : !llvm.ptr -> !llvm.ptr
%702 = llvm.load %696 : !llvm.ptr -> i32
%703 = arith.extsi %702 : i32 to i64
%704 = llvm.getelementptr %701[%703] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%699 = llvm.load %704 : !llvm.ptr -> i32
%705 = llvm.load %655 : !llvm.ptr -> i32
%706 = arith.muli %705, %699 : i32
%708 = arith.extsi %706 : i32 to i64
%709 = arith.constant 8 : i32
%710 = arith.extsi %709 : i32 to i64
%707 = func.call @calloc(%708, %710) : (i64, i64) -> !llvm.ptr
%712 = arith.extsi %706 : i32 to i64
%713 = arith.constant 8 : i32
%714 = arith.extsi %713 : i32 to i64
%711 = func.call @calloc(%712, %714) : (i64, i64) -> !llvm.ptr
%716 = arith.extsi %706 : i32 to i64
%717 = arith.constant 8 : i32
%718 = arith.extsi %717 : i32 to i64
%715 = func.call @calloc(%716, %718) : (i64, i64) -> !llvm.ptr
%719 = arith.constant 0 : i32
%720 = llvm.mlir.constant(1 : i64) : i64
%721 = llvm.alloca %720 x i32 : (i64) -> !llvm.ptr
llvm.store %719, %721 : i32, !llvm.ptr
%722 = arith.constant 0 : i32
%723 = llvm.mlir.constant(1 : i64) : i64
%724 = llvm.alloca %723 x i32 : (i64) -> !llvm.ptr
llvm.store %722, %724 : i32, !llvm.ptr
cf.br ^bb48
^bb48:
%725 = llvm.load %724 : !llvm.ptr -> i32
%726 = llvm.load %655 : !llvm.ptr -> i32
%727 = arith.cmpi slt, %725, %726 : i32
cf.cond_br %727, ^bb49, ^bb50
^bb49:
%728 = arith.constant 0 : i32
%729 = llvm.mlir.constant(1 : i64) : i64
%730 = llvm.alloca %729 x i32 : (i64) -> !llvm.ptr
llvm.store %728, %730 : i32, !llvm.ptr
cf.br ^bb51
^bb51:
%731 = llvm.load %730 : !llvm.ptr -> i32
%732 = arith.cmpi slt, %731, %699 : i32
cf.cond_br %732, ^bb52, ^bb53
^bb52:
%734 = llvm.load %662 : !llvm.ptr -> !llvm.ptr
%735 = llvm.load %724 : !llvm.ptr -> i32
%736 = arith.extsi %735 : i32 to i64
%737 = llvm.getelementptr %734[%736] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%733 = llvm.load %737 : !llvm.ptr -> f64
%739 = llvm.mlir.addressof @var_log_n : !llvm.ptr
%740 = llvm.load %739 : !llvm.ptr -> !llvm.ptr
%741 = llvm.load %696 : !llvm.ptr -> i32
%742 = arith.constant 3 : i32
%743 = arith.muli %741, %742 : i32
%744 = llvm.load %730 : !llvm.ptr -> i32
%745 = arith.addi %743, %744 : i32
%746 = arith.extsi %745 : i32 to i64
%747 = llvm.getelementptr %740[%746] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%738 = llvm.load %747 : !llvm.ptr -> f64
%748 = arith.addf %733, %738 : f64
%750 = llvm.mlir.addressof @var_log_d : !llvm.ptr
%751 = llvm.load %750 : !llvm.ptr -> !llvm.ptr
%752 = llvm.load %696 : !llvm.ptr -> i32
%753 = arith.constant 3 : i32
%754 = arith.muli %752, %753 : i32
%755 = llvm.load %730 : !llvm.ptr -> i32
%756 = arith.addi %754, %755 : i32
%757 = arith.extsi %756 : i32 to i64
%758 = llvm.getelementptr %751[%757] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%749 = llvm.load %758 : !llvm.ptr -> f64
%759 = arith.subf %748, %749 : f64
%760 = llvm.load %721 : !llvm.ptr -> i32
%761 = arith.extsi %760 : i32 to i64
%762 = llvm.getelementptr %707[%761] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %759, %762 : f64, !llvm.ptr
%764 = llvm.load %669 : !llvm.ptr -> !llvm.ptr
%765 = llvm.load %724 : !llvm.ptr -> i32
%766 = arith.extsi %765 : i32 to i64
%767 = llvm.getelementptr %764[%766] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%763 = llvm.load %767 : !llvm.ptr -> f64
%769 = llvm.mlir.addressof @var_ph : !llvm.ptr
%770 = llvm.load %769 : !llvm.ptr -> !llvm.ptr
%771 = llvm.load %696 : !llvm.ptr -> i32
%772 = arith.constant 3 : i32
%773 = arith.muli %771, %772 : i32
%774 = llvm.load %730 : !llvm.ptr -> i32
%775 = arith.addi %773, %774 : i32
%776 = arith.extsi %775 : i32 to i64
%777 = llvm.getelementptr %770[%776] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%768 = llvm.load %777 : !llvm.ptr -> f64
%778 = arith.mulf %763, %768 : f64
%779 = llvm.load %721 : !llvm.ptr -> i32
%780 = arith.extsi %779 : i32 to i64
%781 = llvm.getelementptr %711[%780] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %778, %781 : f64, !llvm.ptr
%783 = llvm.load %676 : !llvm.ptr -> !llvm.ptr
%784 = llvm.load %724 : !llvm.ptr -> i32
%785 = arith.extsi %784 : i32 to i64
%786 = llvm.getelementptr %783[%785] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%782 = llvm.load %786 : !llvm.ptr -> f64
%788 = llvm.mlir.addressof @var_pt : !llvm.ptr
%789 = llvm.load %788 : !llvm.ptr -> !llvm.ptr
%790 = llvm.load %696 : !llvm.ptr -> i32
%791 = arith.constant 3 : i32
%792 = arith.muli %790, %791 : i32
%793 = llvm.load %730 : !llvm.ptr -> i32
%794 = arith.addi %792, %793 : i32
%795 = arith.extsi %794 : i32 to i64
%796 = llvm.getelementptr %789[%795] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%787 = llvm.load %796 : !llvm.ptr -> f64
%797 = arith.mulf %782, %787 : f64
%798 = llvm.load %721 : !llvm.ptr -> i32
%799 = arith.extsi %798 : i32 to i64
%800 = llvm.getelementptr %715[%799] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %797, %800 : f64, !llvm.ptr
%801 = llvm.load %721 : !llvm.ptr -> i32
%802 = arith.constant 1 : i32
%803 = arith.addi %801, %802 : i32
llvm.store %803, %721 : i32, !llvm.ptr
%804 = llvm.load %730 : !llvm.ptr -> i32
%805 = arith.constant 1 : i32
%806 = arith.addi %804, %805 : i32
llvm.store %806, %730 : i32, !llvm.ptr
cf.br ^bb51
^bb53:
%807 = llvm.load %724 : !llvm.ptr -> i32
%808 = arith.constant 1 : i32
%809 = arith.addi %807, %808 : i32
llvm.store %809, %724 : i32, !llvm.ptr
cf.br ^bb48
^bb50:
%811 = llvm.load %662 : !llvm.ptr -> !llvm.ptr
func.call @free(%811) : (!llvm.ptr) -> ()
%813 = llvm.load %669 : !llvm.ptr -> !llvm.ptr
func.call @free(%813) : (!llvm.ptr) -> ()
%815 = llvm.load %676 : !llvm.ptr -> !llvm.ptr
func.call @free(%815) : (!llvm.ptr) -> ()
llvm.store %707, %662 : !llvm.ptr, !llvm.ptr
llvm.store %711, %669 : !llvm.ptr, !llvm.ptr
llvm.store %715, %676 : !llvm.ptr, !llvm.ptr
llvm.store %706, %655 : i32, !llvm.ptr
%816 = llvm.load %696 : !llvm.ptr -> i32
%817 = arith.constant 1 : i32
%818 = arith.addi %816, %817 : i32
llvm.store %818, %696 : i32, !llvm.ptr
cf.br ^bb45
^bb47:
%819 = llvm.load %655 : !llvm.ptr -> i32
%820 = llvm.mlir.addressof @n_r : !llvm.ptr
llvm.store %819, %820 : i32, !llvm.ptr
%821 = arith.constant 0 : i32
%822 = llvm.mlir.constant(1 : i64) : i64
%823 = llvm.alloca %822 x i32 : (i64) -> !llvm.ptr
llvm.store %821, %823 : i32, !llvm.ptr
cf.br ^bb54
^bb54:
%824 = llvm.load %823 : !llvm.ptr -> i32
%825 = llvm.load %655 : !llvm.ptr -> i32
%826 = arith.cmpi slt, %824, %825 : i32
cf.cond_br %826, ^bb55, ^bb56
^bb55:
%828 = llvm.load %662 : !llvm.ptr -> !llvm.ptr
%829 = llvm.load %823 : !llvm.ptr -> i32
%830 = arith.extsi %829 : i32 to i64
%831 = llvm.getelementptr %828[%830] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%827 = llvm.load %831 : !llvm.ptr -> f64
%832 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%833 = llvm.load %832 : !llvm.ptr -> !llvm.ptr
%834 = llvm.load %823 : !llvm.ptr -> i32
%835 = arith.extsi %834 : i32 to i64
%836 = llvm.getelementptr %833[%835] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %827, %836 : f64, !llvm.ptr
%838 = llvm.load %669 : !llvm.ptr -> !llvm.ptr
%839 = llvm.load %823 : !llvm.ptr -> i32
%840 = arith.extsi %839 : i32 to i64
%841 = llvm.getelementptr %838[%840] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%837 = llvm.load %841 : !llvm.ptr -> f64
%842 = llvm.mlir.addressof @r_ph : !llvm.ptr
%843 = llvm.load %842 : !llvm.ptr -> !llvm.ptr
%844 = llvm.load %823 : !llvm.ptr -> i32
%845 = arith.extsi %844 : i32 to i64
%846 = llvm.getelementptr %843[%845] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %837, %846 : f64, !llvm.ptr
%848 = llvm.load %676 : !llvm.ptr -> !llvm.ptr
%849 = llvm.load %823 : !llvm.ptr -> i32
%850 = arith.extsi %849 : i32 to i64
%851 = llvm.getelementptr %848[%850] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%847 = llvm.load %851 : !llvm.ptr -> f64
%852 = llvm.mlir.addressof @r_pt : !llvm.ptr
%853 = llvm.load %852 : !llvm.ptr -> !llvm.ptr
%854 = llvm.load %823 : !llvm.ptr -> i32
%855 = arith.extsi %854 : i32 to i64
%856 = llvm.getelementptr %853[%855] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %847, %856 : f64, !llvm.ptr
%857 = llvm.load %823 : !llvm.ptr -> i32
%858 = arith.constant 1 : i32
%859 = arith.addi %857, %858 : i32
llvm.store %859, %823 : i32, !llvm.ptr
cf.br ^bb54
^bb56:
%861 = llvm.load %662 : !llvm.ptr -> !llvm.ptr
func.call @free(%861) : (!llvm.ptr) -> ()
%863 = llvm.load %669 : !llvm.ptr -> !llvm.ptr
func.call @free(%863) : (!llvm.ptr) -> ()
%865 = llvm.load %676 : !llvm.ptr -> !llvm.ptr
func.call @free(%865) : (!llvm.ptr) -> ()
%867 = llvm.load %655 : !llvm.ptr -> i32
%868 = arith.extsi %867 : i32 to i64
%869 = arith.constant 8 : i32
%870 = arith.extsi %869 : i32 to i64
%866 = func.call @calloc(%868, %870) : (i64, i64) -> !llvm.ptr
%872 = llvm.load %655 : !llvm.ptr -> i32
%873 = arith.extsi %872 : i32 to i64
%874 = arith.constant 8 : i32
%875 = arith.extsi %874 : i32 to i64
%871 = func.call @calloc(%873, %875) : (i64, i64) -> !llvm.ptr
%877 = llvm.load %655 : !llvm.ptr -> i32
%878 = arith.extsi %877 : i32 to i64
%879 = arith.constant 8 : i32
%880 = arith.extsi %879 : i32 to i64
%876 = func.call @calloc(%878, %880) : (i64, i64) -> !llvm.ptr
%882 = arith.constant 0 : i32
%883 = llvm.load %655 : !llvm.ptr -> i32
func.call @merge_sort_r(%866, %871, %876, %882, %883) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, i32) -> ()
func.call @free(%866) : (!llvm.ptr) -> ()
func.call @free(%871) : (!llvm.ptr) -> ()
func.call @free(%876) : (!llvm.ptr) -> ()
%887 = arith.constant 0.0 : f32
%888 = llvm.mlir.addressof @suf_h : !llvm.ptr
%889 = llvm.load %888 : !llvm.ptr -> !llvm.ptr
%890 = llvm.load %655 : !llvm.ptr -> i32
%891 = arith.extf %887 : f32 to f64
%892 = arith.extsi %890 : i32 to i64
%893 = llvm.getelementptr %889[%892] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %891, %893 : f64, !llvm.ptr
%894 = arith.constant 0.0 : f32
%895 = llvm.mlir.addressof @suf_t : !llvm.ptr
%896 = llvm.load %895 : !llvm.ptr -> !llvm.ptr
%897 = llvm.load %655 : !llvm.ptr -> i32
%898 = arith.extf %894 : f32 to f64
%899 = arith.extsi %897 : i32 to i64
%900 = llvm.getelementptr %896[%899] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %898, %900 : f64, !llvm.ptr
%901 = llvm.load %655 : !llvm.ptr -> i32
%902 = arith.constant 1 : i32
%903 = arith.subi %901, %902 : i32
%904 = llvm.mlir.constant(1 : i64) : i64
%905 = llvm.alloca %904 x i32 : (i64) -> !llvm.ptr
llvm.store %903, %905 : i32, !llvm.ptr
cf.br ^bb57
^bb57:
%906 = llvm.load %905 : !llvm.ptr -> i32
%907 = arith.constant 0 : i32
%908 = arith.cmpi sge, %906, %907 : i32
cf.cond_br %908, ^bb58, ^bb59
^bb58:
%910 = llvm.mlir.addressof @suf_h : !llvm.ptr
%911 = llvm.load %910 : !llvm.ptr -> !llvm.ptr
%912 = llvm.load %905 : !llvm.ptr -> i32
%913 = arith.constant 1 : i32
%914 = arith.addi %912, %913 : i32
%915 = arith.extsi %914 : i32 to i64
%916 = llvm.getelementptr %911[%915] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%909 = llvm.load %916 : !llvm.ptr -> f64
%918 = llvm.mlir.addressof @r_ph : !llvm.ptr
%919 = llvm.load %918 : !llvm.ptr -> !llvm.ptr
%920 = llvm.load %905 : !llvm.ptr -> i32
%921 = arith.extsi %920 : i32 to i64
%922 = llvm.getelementptr %919[%921] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%917 = llvm.load %922 : !llvm.ptr -> f64
%923 = arith.addf %909, %917 : f64
%924 = llvm.mlir.addressof @suf_h : !llvm.ptr
%925 = llvm.load %924 : !llvm.ptr -> !llvm.ptr
%926 = llvm.load %905 : !llvm.ptr -> i32
%927 = arith.extsi %926 : i32 to i64
%928 = llvm.getelementptr %925[%927] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %923, %928 : f64, !llvm.ptr
%930 = llvm.mlir.addressof @suf_t : !llvm.ptr
%931 = llvm.load %930 : !llvm.ptr -> !llvm.ptr
%932 = llvm.load %905 : !llvm.ptr -> i32
%933 = arith.constant 1 : i32
%934 = arith.addi %932, %933 : i32
%935 = arith.extsi %934 : i32 to i64
%936 = llvm.getelementptr %931[%935] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%929 = llvm.load %936 : !llvm.ptr -> f64
%938 = llvm.mlir.addressof @r_pt : !llvm.ptr
%939 = llvm.load %938 : !llvm.ptr -> !llvm.ptr
%940 = llvm.load %905 : !llvm.ptr -> i32
%941 = arith.extsi %940 : i32 to i64
%942 = llvm.getelementptr %939[%941] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%937 = llvm.load %942 : !llvm.ptr -> f64
%943 = arith.addf %929, %937 : f64
%944 = llvm.mlir.addressof @suf_t : !llvm.ptr
%945 = llvm.load %944 : !llvm.ptr -> !llvm.ptr
%946 = llvm.load %905 : !llvm.ptr -> i32
%947 = arith.extsi %946 : i32 to i64
%948 = llvm.getelementptr %945[%947] : (!llvm.ptr, i64) -> !llvm.ptr, f64
llvm.store %943, %948 : f64, !llvm.ptr
%949 = llvm.load %905 : !llvm.ptr -> i32
%950 = arith.constant 1 : i32
%951 = arith.subi %949, %950 : i32
llvm.store %951, %905 : i32, !llvm.ptr
cf.br ^bb57
^bb59:
func.return
}
func.func @enum_left(%arg0: i32, %arg1: f64, %arg2: f64, %arg3: f64) -> () {
%952 = llvm.mlir.addressof @n_left : !llvm.ptr
%953 = llvm.load %952 : !llvm.ptr -> i32
%954 = arith.cmpi eq, %arg0, %953 : i32
cf.cond_br %954, ^bb60, ^bb61
^bb60:
%955 = arith.constant 0.0 : f32
%957 = arith.extf %955 : f32 to f64
%956 = arith.subf %957, %arg3 : f64
%958 = arith.constant 0 : i32
%959 = llvm.mlir.constant(1 : i64) : i64
%960 = llvm.alloca %959 x i32 : (i64) -> !llvm.ptr
llvm.store %958, %960 : i32, !llvm.ptr
%961 = llvm.mlir.addressof @n_r : !llvm.ptr
%962 = llvm.load %961 : !llvm.ptr -> i32
%963 = llvm.mlir.constant(1 : i64) : i64
%964 = llvm.alloca %963 x i32 : (i64) -> !llvm.ptr
llvm.store %962, %964 : i32, !llvm.ptr
cf.br ^bb63
^bb63:
%965 = llvm.load %960 : !llvm.ptr -> i32
%966 = llvm.load %964 : !llvm.ptr -> i32
%967 = arith.cmpi slt, %965, %966 : i32
cf.cond_br %967, ^bb64, ^bb65
^bb64:
%968 = llvm.load %960 : !llvm.ptr -> i32
%969 = llvm.load %964 : !llvm.ptr -> i32
%970 = arith.addi %968, %969 : i32
%971 = arith.constant 2 : i32
%972 = arith.divsi %970, %971 : i32
%974 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%975 = llvm.load %974 : !llvm.ptr -> !llvm.ptr
%976 = arith.extsi %972 : i32 to i64
%977 = llvm.getelementptr %975[%976] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%973 = llvm.load %977 : !llvm.ptr -> f64
%978 = arith.cmpf olt, %973, %956 : f64
cf.cond_br %978, ^bb66, ^bb67
^bb66:
%979 = arith.constant 1 : i32
%980 = arith.addi %972, %979 : i32
llvm.store %980, %960 : i32, !llvm.ptr
cf.br ^bb68
^bb67:
llvm.store %972, %964 : i32, !llvm.ptr
cf.br ^bb68
^bb68:
cf.br ^bb63
^bb65:
%981 = llvm.load %960 : !llvm.ptr -> i32
%983 = llvm.mlir.addressof @suf_h : !llvm.ptr
%984 = llvm.load %983 : !llvm.ptr -> !llvm.ptr
%985 = arith.extsi %981 : i32 to i64
%986 = llvm.getelementptr %984[%985] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%982 = llvm.load %986 : !llvm.ptr -> f64
%987 = arith.mulf %arg1, %982 : f64
%988 = llvm.mlir.addressof @cH : !llvm.ptr
%989 = llvm.load %988 : !llvm.ptr -> f64
%990 = arith.subf %987, %989 : f64
%991 = llvm.mlir.addressof @pHA : !llvm.ptr
%992 = llvm.load %991 : !llvm.ptr -> f64
%993 = arith.addf %992, %990 : f64
%994 = llvm.mlir.addressof @pHA : !llvm.ptr
%995 = llvm.load %994 : !llvm.ptr -> f64
%996 = arith.subf %993, %995 : f64
%997 = arith.subf %996, %990 : f64
%998 = llvm.mlir.addressof @cH : !llvm.ptr
llvm.store %997, %998 : f64, !llvm.ptr
%999 = llvm.mlir.addressof @pHA : !llvm.ptr
llvm.store %993, %999 : f64, !llvm.ptr
%1001 = llvm.mlir.addressof @suf_t : !llvm.ptr
%1002 = llvm.load %1001 : !llvm.ptr -> !llvm.ptr
%1003 = arith.extsi %981 : i32 to i64
%1004 = llvm.getelementptr %1002[%1003] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%1000 = llvm.load %1004 : !llvm.ptr -> f64
%1005 = arith.mulf %arg2, %1000 : f64
%1006 = llvm.mlir.addressof @cT : !llvm.ptr
%1007 = llvm.load %1006 : !llvm.ptr -> f64
%1008 = arith.subf %1005, %1007 : f64
%1009 = llvm.mlir.addressof @pTA : !llvm.ptr
%1010 = llvm.load %1009 : !llvm.ptr -> f64
%1011 = arith.addf %1010, %1008 : f64
%1012 = llvm.mlir.addressof @pTA : !llvm.ptr
%1013 = llvm.load %1012 : !llvm.ptr -> f64
%1014 = arith.subf %1011, %1013 : f64
%1015 = arith.subf %1014, %1008 : f64
%1016 = llvm.mlir.addressof @cT : !llvm.ptr
llvm.store %1015, %1016 : f64, !llvm.ptr
%1017 = llvm.mlir.addressof @pTA : !llvm.ptr
llvm.store %1011, %1017 : f64, !llvm.ptr
func.return
^bb61:
cf.br ^bb62
^bb62:
%1019 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
%1020 = llvm.load %1019 : !llvm.ptr -> !llvm.ptr
%1021 = arith.extsi %arg0 : i32 to i64
%1022 = llvm.getelementptr %1020[%1021] : (!llvm.ptr, i64) -> !llvm.ptr, i32
%1018 = llvm.load %1022 : !llvm.ptr -> i32
%1023 = arith.constant 0 : i32
%1024 = llvm.mlir.constant(1 : i64) : i64
%1025 = llvm.alloca %1024 x i32 : (i64) -> !llvm.ptr
llvm.store %1023, %1025 : i32, !llvm.ptr
cf.br ^bb69
^bb69:
%1026 = llvm.load %1025 : !llvm.ptr -> i32
%1027 = arith.cmpi slt, %1026, %1018 : i32
cf.cond_br %1027, ^bb70, ^bb71
^bb70:
%1029 = llvm.mlir.addressof @var_log_n : !llvm.ptr
%1030 = llvm.load %1029 : !llvm.ptr -> !llvm.ptr
%1031 = arith.constant 3 : i32
%1032 = arith.muli %arg0, %1031 : i32
%1033 = llvm.load %1025 : !llvm.ptr -> i32
%1034 = arith.addi %1032, %1033 : i32
%1035 = arith.extsi %1034 : i32 to i64
%1036 = llvm.getelementptr %1030[%1035] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%1028 = llvm.load %1036 : !llvm.ptr -> f64
%1037 = arith.addf %arg3, %1028 : f64
%1039 = llvm.mlir.addressof @var_log_d : !llvm.ptr
%1040 = llvm.load %1039 : !llvm.ptr -> !llvm.ptr
%1041 = arith.constant 3 : i32
%1042 = arith.muli %arg0, %1041 : i32
%1043 = llvm.load %1025 : !llvm.ptr -> i32
%1044 = arith.addi %1042, %1043 : i32
%1045 = arith.extsi %1044 : i32 to i64
%1046 = llvm.getelementptr %1040[%1045] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%1038 = llvm.load %1046 : !llvm.ptr -> f64
%1047 = arith.subf %1037, %1038 : f64
%1049 = arith.constant 1 : i32
%1050 = arith.addi %arg0, %1049 : i32
%1052 = llvm.mlir.addressof @var_ph : !llvm.ptr
%1053 = llvm.load %1052 : !llvm.ptr -> !llvm.ptr
%1054 = arith.constant 3 : i32
%1055 = arith.muli %arg0, %1054 : i32
%1056 = llvm.load %1025 : !llvm.ptr -> i32
%1057 = arith.addi %1055, %1056 : i32
%1058 = arith.extsi %1057 : i32 to i64
%1059 = llvm.getelementptr %1053[%1058] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%1051 = llvm.load %1059 : !llvm.ptr -> f64
%1060 = arith.mulf %arg1, %1051 : f64
%1062 = llvm.mlir.addressof @var_pt : !llvm.ptr
%1063 = llvm.load %1062 : !llvm.ptr -> !llvm.ptr
%1064 = arith.constant 3 : i32
%1065 = arith.muli %arg0, %1064 : i32
%1066 = llvm.load %1025 : !llvm.ptr -> i32
%1067 = arith.addi %1065, %1066 : i32
%1068 = arith.extsi %1067 : i32 to i64
%1069 = llvm.getelementptr %1063[%1068] : (!llvm.ptr, i64) -> !llvm.ptr, f64
%1061 = llvm.load %1069 : !llvm.ptr -> f64
%1070 = arith.mulf %arg2, %1061 : f64
func.call @enum_left(%1050, %1060, %1070, %1047) : (i32, f64, f64, f64) -> ()
%1071 = llvm.load %1025 : !llvm.ptr -> i32
%1072 = arith.constant 1 : i32
%1073 = arith.addi %1071, %1072 : i32
llvm.store %1073, %1025 : i32, !llvm.ptr
cf.br ^bb69
^bb71:
func.return
}
func.func @main() -> i32 {
%1075 = arith.constant 60 : i32
%1076 = arith.constant 4 : i32
%1077 = arith.extsi %1075 : i32 to i64
%1078 = arith.extsi %1076 : i32 to i64
%1074 = func.call @calloc(%1077, %1078) : (i64, i64) -> !llvm.ptr
%1079 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
llvm.store %1074, %1079 : !llvm.ptr, !llvm.ptr
%1081 = arith.constant 180 : i32
%1082 = arith.constant 4 : i32
%1083 = arith.extsi %1081 : i32 to i64
%1084 = arith.extsi %1082 : i32 to i64
%1080 = func.call @calloc(%1083, %1084) : (i64, i64) -> !llvm.ptr
%1085 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
llvm.store %1080, %1085 : !llvm.ptr, !llvm.ptr
%1087 = arith.constant 180 : i32
%1088 = arith.constant 4 : i32
%1089 = arith.extsi %1087 : i32 to i64
%1090 = arith.extsi %1088 : i32 to i64
%1086 = func.call @calloc(%1089, %1090) : (i64, i64) -> !llvm.ptr
%1091 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
llvm.store %1086, %1091 : !llvm.ptr, !llvm.ptr
%1093 = arith.constant 180 : i32
%1094 = arith.constant 8 : i32
%1095 = arith.extsi %1093 : i32 to i64
%1096 = arith.extsi %1094 : i32 to i64
%1092 = func.call @calloc(%1095, %1096) : (i64, i64) -> !llvm.ptr
%1097 = llvm.mlir.addressof @var_ph : !llvm.ptr
llvm.store %1092, %1097 : !llvm.ptr, !llvm.ptr
%1099 = arith.constant 180 : i32
%1100 = arith.constant 8 : i32
%1101 = arith.extsi %1099 : i32 to i64
%1102 = arith.extsi %1100 : i32 to i64
%1098 = func.call @calloc(%1101, %1102) : (i64, i64) -> !llvm.ptr
%1103 = llvm.mlir.addressof @var_pt : !llvm.ptr
llvm.store %1098, %1103 : !llvm.ptr, !llvm.ptr
%1105 = arith.constant 180 : i32
%1106 = arith.constant 8 : i32
%1107 = arith.extsi %1105 : i32 to i64
%1108 = arith.extsi %1106 : i32 to i64
%1104 = func.call @calloc(%1107, %1108) : (i64, i64) -> !llvm.ptr
%1109 = llvm.mlir.addressof @var_log_n : !llvm.ptr
llvm.store %1104, %1109 : !llvm.ptr, !llvm.ptr
%1111 = arith.constant 180 : i32
%1112 = arith.constant 8 : i32
%1113 = arith.extsi %1111 : i32 to i64
%1114 = arith.extsi %1112 : i32 to i64
%1110 = func.call @calloc(%1113, %1114) : (i64, i64) -> !llvm.ptr
%1115 = llvm.mlir.addressof @var_log_d : !llvm.ptr
llvm.store %1110, %1115 : !llvm.ptr, !llvm.ptr
%1117 = arith.constant 51 : i32
%1118 = arith.constant 4 : i32
%1119 = arith.extsi %1117 : i32 to i64
%1120 = arith.extsi %1118 : i32 to i64
%1116 = func.call @calloc(%1119, %1120) : (i64, i64) -> !llvm.ptr
%1121 = arith.constant 0 : i32
%1122 = llvm.mlir.constant(1 : i64) : i64
%1123 = llvm.alloca %1122 x i32 : (i64) -> !llvm.ptr
llvm.store %1121, %1123 : i32, !llvm.ptr
cf.br ^bb72
^bb72:
%1124 = llvm.load %1123 : !llvm.ptr -> i32
%1125 = arith.constant 51 : i32
%1126 = arith.cmpi slt, %1124, %1125 : i32
cf.cond_br %1126, ^bb73, ^bb74
^bb73:
%1127 = arith.constant 25 : i32
%1128 = llvm.load %1123 : !llvm.ptr -> i32
%1129 = arith.addi %1127, %1128 : i32
%1130 = llvm.load %1123 : !llvm.ptr -> i32
%1131 = arith.extsi %1130 : i32 to i64
%1132 = llvm.getelementptr %1116[%1131] : (!llvm.ptr, i64) -> !llvm.ptr, i32
llvm.store %1129, %1132 : i32, !llvm.ptr
%1133 = llvm.load %1123 : !llvm.ptr -> i32
%1134 = arith.constant 1 : i32
%1135 = arith.addi %1133, %1134 : i32
llvm.store %1135, %1123 : i32, !llvm.ptr
cf.br ^bb72
^bb74:
%1137 = arith.constant 51 : i32
func.call @build_variables(%1116, %1137) : (!llvm.ptr, i32) -> ()
func.call @free(%1116) : (!llvm.ptr) -> ()
%1139 = llvm.mlir.addressof @n_vars : !llvm.ptr
%1140 = llvm.load %1139 : !llvm.ptr -> i32
%1141 = arith.constant 0 : i32
%1142 = arith.cmpi eq, %1140, %1141 : i32
cf.cond_br %1142, ^bb75, ^bb76
^bb75:
%1143 = llvm.mlir.addressof @str_0 : !llvm.ptr
%1144 = llvm.call @printf(%1143) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr) -> i32
%1145 = arith.constant 0 : i32
func.return %1145 : i32
^bb76:
cf.br ^bb77
^bb77:
%1146 = llvm.mlir.addressof @n_vars : !llvm.ptr
%1147 = llvm.load %1146 : !llvm.ptr -> i32
%1148 = arith.constant 2 : i32
%1149 = arith.divsi %1147, %1148 : i32
%1150 = llvm.mlir.addressof @n_left : !llvm.ptr
llvm.store %1149, %1150 : i32, !llvm.ptr
%1152 = arith.constant 2000000 : i32
%1153 = arith.constant 8 : i32
%1154 = arith.extsi %1152 : i32 to i64
%1155 = arith.extsi %1153 : i32 to i64
%1151 = func.call @calloc(%1154, %1155) : (i64, i64) -> !llvm.ptr
%1156 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
llvm.store %1151, %1156 : !llvm.ptr, !llvm.ptr
%1158 = arith.constant 2000000 : i32
%1159 = arith.constant 8 : i32
%1160 = arith.extsi %1158 : i32 to i64
%1161 = arith.extsi %1159 : i32 to i64
%1157 = func.call @calloc(%1160, %1161) : (i64, i64) -> !llvm.ptr
%1162 = llvm.mlir.addressof @r_ph : !llvm.ptr
llvm.store %1157, %1162 : !llvm.ptr, !llvm.ptr
%1164 = arith.constant 2000000 : i32
%1165 = arith.constant 8 : i32
%1166 = arith.extsi %1164 : i32 to i64
%1167 = arith.extsi %1165 : i32 to i64
%1163 = func.call @calloc(%1166, %1167) : (i64, i64) -> !llvm.ptr
%1168 = llvm.mlir.addressof @r_pt : !llvm.ptr
llvm.store %1163, %1168 : !llvm.ptr, !llvm.ptr
%1170 = arith.constant 2000001 : i32
%1171 = arith.constant 8 : i32
%1172 = arith.extsi %1170 : i32 to i64
%1173 = arith.extsi %1171 : i32 to i64
%1169 = func.call @calloc(%1172, %1173) : (i64, i64) -> !llvm.ptr
%1174 = llvm.mlir.addressof @suf_h : !llvm.ptr
llvm.store %1169, %1174 : !llvm.ptr, !llvm.ptr
%1176 = arith.constant 2000001 : i32
%1177 = arith.constant 8 : i32
%1178 = arith.extsi %1176 : i32 to i64
%1179 = arith.extsi %1177 : i32 to i64
%1175 = func.call @calloc(%1178, %1179) : (i64, i64) -> !llvm.ptr
%1180 = llvm.mlir.addressof @suf_t : !llvm.ptr
llvm.store %1175, %1180 : !llvm.ptr, !llvm.ptr
%1182 = llvm.mlir.addressof @n_vars : !llvm.ptr
%1183 = llvm.load %1182 : !llvm.ptr -> i32
func.call @enumerate_right(%1149, %1183) : (i32, i32) -> ()
%1184 = arith.constant 0.0 : f32
%1185 = arith.extf %1184 : f32 to f64
%1186 = llvm.mlir.addressof @pHA : !llvm.ptr
llvm.store %1185, %1186 : f64, !llvm.ptr
%1187 = arith.constant 0.0 : f32
%1188 = arith.extf %1187 : f32 to f64
%1189 = llvm.mlir.addressof @cH : !llvm.ptr
llvm.store %1188, %1189 : f64, !llvm.ptr
%1190 = arith.constant 0.0 : f32
%1191 = arith.extf %1190 : f32 to f64
%1192 = llvm.mlir.addressof @pTA : !llvm.ptr
llvm.store %1191, %1192 : f64, !llvm.ptr
%1193 = arith.constant 0.0 : f32
%1194 = arith.extf %1193 : f32 to f64
%1195 = llvm.mlir.addressof @cT : !llvm.ptr
llvm.store %1194, %1195 : f64, !llvm.ptr
%1197 = arith.constant 0 : i32
%1198 = arith.constant 1.0 : f32
%1199 = arith.constant 1.0 : f32
%1200 = arith.constant 0.0 : f32
%1201 = arith.extf %1198 : f32 to f64
%1202 = arith.extf %1199 : f32 to f64
%1203 = arith.extf %1200 : f32 to f64
func.call @enum_left(%1197, %1201, %1202, %1203) : (i32, f64, f64, f64) -> ()
%1204 = llvm.mlir.addressof @pHA : !llvm.ptr
%1205 = llvm.load %1204 : !llvm.ptr -> f64
%1206 = llvm.mlir.addressof @pTA : !llvm.ptr
%1207 = llvm.load %1206 : !llvm.ptr -> f64
%1208 = arith.subf %1205, %1207 : f64
%1209 = llvm.mlir.constant(1 : i64) : i64
%1210 = llvm.alloca %1209 x f64 : (i64) -> !llvm.ptr
llvm.store %1208, %1210 : f64, !llvm.ptr
%1211 = llvm.load %1210 : !llvm.ptr -> f64
%1212 = arith.constant 1.0 : f32
%1213 = arith.negf %1212 : f32
%1215 = arith.extf %1213 : f32 to f64
%1214 = arith.cmpf olt, %1211, %1215 : f64
cf.cond_br %1214, ^bb78, ^bb79
^bb78:
%1216 = arith.constant 1.0 : f32
%1217 = arith.negf %1216 : f32
%1218 = arith.extf %1217 : f32 to f64
llvm.store %1218, %1210 : f64, !llvm.ptr
cf.br ^bb80
^bb79:
cf.br ^bb80
^bb80:
%1219 = llvm.load %1210 : !llvm.ptr -> f64
%1220 = arith.constant 1.0 : f32
%1222 = arith.extf %1220 : f32 to f64
%1221 = arith.cmpf ogt, %1219, %1222 : f64
cf.cond_br %1221, ^bb81, ^bb82
^bb81:
%1223 = arith.constant 1.0 : f32
%1224 = arith.extf %1223 : f32 to f64
llvm.store %1224, %1210 : f64, !llvm.ptr
cf.br ^bb83
^bb82:
cf.br ^bb83
^bb83:
%1225 = llvm.mlir.addressof @str_1 : !llvm.ptr
%1226 = arith.constant 0.5 : f32
%1227 = arith.constant 1.0 : f32
%1228 = llvm.load %1210 : !llvm.ptr -> f64
%1230 = arith.extf %1227 : f32 to f64
%1229 = arith.addf %1230, %1228 : f64
%1232 = arith.extf %1226 : f32 to f64
%1231 = arith.mulf %1232, %1229 : f64
%1233 = llvm.call @printf(%1225, %1231) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, f64) -> i32
%1235 = llvm.mlir.addressof @var_n_outcomes : !llvm.ptr
%1236 = llvm.load %1235 : !llvm.ptr -> !llvm.ptr
func.call @free(%1236) : (!llvm.ptr) -> ()
%1238 = llvm.mlir.addressof @var_mul_n : !llvm.ptr
%1239 = llvm.load %1238 : !llvm.ptr -> !llvm.ptr
func.call @free(%1239) : (!llvm.ptr) -> ()
%1241 = llvm.mlir.addressof @var_mul_d : !llvm.ptr
%1242 = llvm.load %1241 : !llvm.ptr -> !llvm.ptr
func.call @free(%1242) : (!llvm.ptr) -> ()
%1244 = llvm.mlir.addressof @var_ph : !llvm.ptr
%1245 = llvm.load %1244 : !llvm.ptr -> !llvm.ptr
func.call @free(%1245) : (!llvm.ptr) -> ()
%1247 = llvm.mlir.addressof @var_pt : !llvm.ptr
%1248 = llvm.load %1247 : !llvm.ptr -> !llvm.ptr
func.call @free(%1248) : (!llvm.ptr) -> ()
%1250 = llvm.mlir.addressof @var_log_n : !llvm.ptr
%1251 = llvm.load %1250 : !llvm.ptr -> !llvm.ptr
func.call @free(%1251) : (!llvm.ptr) -> ()
%1253 = llvm.mlir.addressof @var_log_d : !llvm.ptr
%1254 = llvm.load %1253 : !llvm.ptr -> !llvm.ptr
func.call @free(%1254) : (!llvm.ptr) -> ()
%1256 = llvm.mlir.addressof @r_log_ratio : !llvm.ptr
%1257 = llvm.load %1256 : !llvm.ptr -> !llvm.ptr
func.call @free(%1257) : (!llvm.ptr) -> ()
%1259 = llvm.mlir.addressof @r_ph : !llvm.ptr
%1260 = llvm.load %1259 : !llvm.ptr -> !llvm.ptr
func.call @free(%1260) : (!llvm.ptr) -> ()
%1262 = llvm.mlir.addressof @r_pt : !llvm.ptr
%1263 = llvm.load %1262 : !llvm.ptr -> !llvm.ptr
func.call @free(%1263) : (!llvm.ptr) -> ()
%1265 = llvm.mlir.addressof @suf_h : !llvm.ptr
%1266 = llvm.load %1265 : !llvm.ptr -> !llvm.ptr
func.call @free(%1266) : (!llvm.ptr) -> ()
%1268 = llvm.mlir.addressof @suf_t : !llvm.ptr
%1269 = llvm.load %1268 : !llvm.ptr -> !llvm.ptr
func.call @free(%1269) : (!llvm.ptr) -> ()
%1270 = arith.constant 0 : i32
func.return %1270 : i32
}
}