← All problems Problem 089
Characters saved by writing Roman numerals in minimal form.
View problem on Project Euler
Performance comparison
Metric Our solution Best known
Time complexity O(n^2)O(n)Space complexity O(1)O(1)Approach Flow solution Direct numeral conversion Verdict Suboptimal
Flow source
# Project Euler 089
# Characters saved by writing Roman numerals in minimal form.
extern {
function fopen(path: string, mode: string) -> ptr<void>
function fgetc(f: ptr<void>) -> i32
function fclose(f: ptr<void>) -> i32
}
function roman_value(c: i32) -> i32 {
if c == 73 { return 1 } # I
if c == 86 { return 5 } # V
if c == 88 { return 10 } # X
if c == 76 { return 50 } # L
if c == 67 { return 100 } # C
if c == 68 { return 500 } # D
if c == 77 { return 1000 } # M
return 0
}
function minimal_len(n: i32) -> i32 {
# standard Roman length for 1..3999
let vals: array<i32, 13> = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
let lens: array<i32, 13> = [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
let mut len: i32 = 0
let mut x: i32 = n
for i in 0..13 {
while x >= vals[i] {
x = x - vals[i]
len = len + lens[i]
}
}
return len
}
function main() -> i32 {
let f: ptr<void> = fopen("data/p089.txt", "r")
if f == null {
printf("failed to read data/p089.txt\n")
return 1
}
let mut saved: i64 = 0
let mut buf: array<i32, 32> = [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 c: i32 = fgetc(f)
while c >= 0 {
let mut len: i32 = 0
while c >= 0 && c != 10 {
if roman_value(c) > 0 {
buf[len] = c
len = len + 1
}
c = fgetc(f)
}
if len > 0 {
# parse value (subtractive)
let mut val: i32 = 0
let mut i: i32 = 0
while i < len {
let v: i32 = roman_value(buf[i])
if i + 1 < len {
let w: i32 = roman_value(buf[i + 1])
if v < w {
val = val + (w - v)
i = i + 2
} else {
val = val + v
i = i + 1
}
} else {
val = val + v
i = i + 1
}
}
saved = saved + ((len - minimal_len(val)) as i64)
}
if c == 10 {
c = fgetc(f)
}
}
fclose(f)
printf("%lld\n", saved)
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; }
int32_t roman_value_i32(int32_t c);
int32_t minimal_len_i32(int32_t n);
int32_t main(void);
int32_t roman_value_i32(int32_t c) {
if (c == 73) {
return 1;
}
if (c == 86) {
return 5;
}
if (c == 88) {
return 10;
}
if (c == 76) {
return 50;
}
if (c == 67) {
return 100;
}
if (c == 68) {
return 500;
}
if (c == 77) {
return 1000;
}
return 0;
}
int32_t minimal_len_i32(int32_t n) {
int32_t vals[13] = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };
int32_t lens[13] = { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1 };
int32_t len = 0;
int32_t x = n;
int32_t __flow_step_1 = 1;
for (int32_t i = 0; (0 <= 13) ? i < 13 : i > 13; i += (0 <= 13) ? 1 : -1) {
while (x >= (((unsigned)(i) < 13) ? vals[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 13), flow_fault_handler("array index out of bounds"), vals[0]))) {
x = (x - (((unsigned)(i) < 13) ? vals[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 13), flow_fault_handler("array index out of bounds"), vals[0])));
len = (len + (((unsigned)(i) < 13) ? lens[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 13), flow_fault_handler("array index out of bounds"), lens[0])));
}
}
return len;
}
int32_t main(void) {
void* f = (void*)(fopen("data/p089.txt", "r"));
if (f == NULL) {
printf("failed to read data/p089.txt\n");
return 1;
}
int64_t saved = 0;
int32_t buf[32] = { 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 c = fgetc(f);
while (c >= 0) {
int32_t len = 0;
while ((c >= 0 && c != 10)) {
if (roman_value_i32(c) > 0) {
buf[len] = c;
len = (len + 1);
}
c = fgetc(f);
}
if (len > 0) {
int32_t val = 0;
int32_t i = 0;
while (i < len) {
int32_t v = roman_value_i32((((unsigned)(i) < 32) ? buf[i] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)(i), 32), flow_fault_handler("array index out of bounds"), buf[0])));
if ((i + 1) < len) {
int32_t w = roman_value_i32((((unsigned)((i + 1)) < 32) ? buf[(i + 1)] : (fprintf(stderr, "array index %d out of bounds (size %d)\n", (int)((i + 1)), 32), flow_fault_handler("array index out of bounds"), buf[0])));
if (v < w) {
val = (val + (w - v));
i = (i + 2);
} else {
val = (val + v);
i = (i + 1);
}
} else {
val = (val + v);
i = (i + 1);
}
}
saved = (saved + ((int64_t)((len - minimal_len_i32(val)))));
}
if (c == 10) {
c = fgetc(f);
}
}
fclose(f);
printf("%lld\n", saved);
return 0;
}
Generated MLIR
module {
llvm.func @printf(!llvm.ptr, ...) -> i32
llvm.mlir.global internal constant @str_0("data/p089.txt\00") {addr_space = 0 : i32} : !llvm.array<14 x i8>
llvm.mlir.global internal constant @str_1("r\00") {addr_space = 0 : i32} : !llvm.array<2 x i8>
llvm.mlir.global internal constant @str_2("failed to read data/p089.txt\n\00") {addr_space = 0 : i32} : !llvm.array<30 x i8>
llvm.mlir.global internal constant @str_3("%lld\n\00") {addr_space = 0 : i32} : !llvm.array<6 x i8>
func.func private @fopen(!llvm.ptr, !llvm.ptr) -> !llvm.ptr
func.func private @fgetc(!llvm.ptr) -> i32
func.func private @fclose(!llvm.ptr) -> i32
func.func @roman_value(%arg0: i32) -> i32 {
%0 = arith.constant 73 : i32
%1 = arith.cmpi eq, %arg0, %0 : i32
cf.cond_br %1, ^bb0, ^bb1
^bb0:
%2 = arith.constant 1 : i32
func.return %2 : i32
^bb1:
cf.br ^bb2
^bb2:
%3 = arith.constant 86 : i32
%4 = arith.cmpi eq, %arg0, %3 : i32
cf.cond_br %4, ^bb3, ^bb4
^bb3:
%5 = arith.constant 5 : i32
func.return %5 : i32
^bb4:
cf.br ^bb5
^bb5:
%6 = arith.constant 88 : i32
%7 = arith.cmpi eq, %arg0, %6 : i32
cf.cond_br %7, ^bb6, ^bb7
^bb6:
%8 = arith.constant 10 : i32
func.return %8 : i32
^bb7:
cf.br ^bb8
^bb8:
%9 = arith.constant 76 : i32
%10 = arith.cmpi eq, %arg0, %9 : i32
cf.cond_br %10, ^bb9, ^bb10
^bb9:
%11 = arith.constant 50 : i32
func.return %11 : i32
^bb10:
cf.br ^bb11
^bb11:
%12 = arith.constant 67 : i32
%13 = arith.cmpi eq, %arg0, %12 : i32
cf.cond_br %13, ^bb12, ^bb13
^bb12:
%14 = arith.constant 100 : i32
func.return %14 : i32
^bb13:
cf.br ^bb14
^bb14:
%15 = arith.constant 68 : i32
%16 = arith.cmpi eq, %arg0, %15 : i32
cf.cond_br %16, ^bb15, ^bb16
^bb15:
%17 = arith.constant 500 : i32
func.return %17 : i32
^bb16:
cf.br ^bb17
^bb17:
%18 = arith.constant 77 : i32
%19 = arith.cmpi eq, %arg0, %18 : i32
cf.cond_br %19, ^bb18, ^bb19
^bb18:
%20 = arith.constant 1000 : i32
func.return %20 : i32
^bb19:
cf.br ^bb20
^bb20:
%21 = arith.constant 0 : i32
func.return %21 : i32
}
func.func @minimal_len(%arg0: i32) -> i32 {
%23 = arith.constant 1000 : i32
%24 = arith.constant 900 : i32
%25 = arith.constant 500 : i32
%26 = arith.constant 400 : i32
%27 = arith.constant 100 : i32
%28 = arith.constant 90 : i32
%29 = arith.constant 50 : i32
%30 = arith.constant 40 : i32
%31 = arith.constant 10 : i32
%32 = arith.constant 9 : i32
%33 = arith.constant 5 : i32
%34 = arith.constant 4 : i32
%35 = arith.constant 1 : i32
%36 = llvm.mlir.constant(1 : i64) : i64
%37 = llvm.alloca %36 x !llvm.array<13 x i32> : (i64) -> !llvm.ptr
%38 = llvm.mlir.zero : !llvm.array<13 x i32>
llvm.store %38, %37 : !llvm.array<13 x i32>, !llvm.ptr
%39 = llvm.mlir.constant(0 : i64) : i64
%40 = llvm.getelementptr %37[0, %39] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %23, %40 : i32, !llvm.ptr
%41 = llvm.mlir.constant(1 : i64) : i64
%42 = llvm.getelementptr %37[0, %41] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %24, %42 : i32, !llvm.ptr
%43 = llvm.mlir.constant(2 : i64) : i64
%44 = llvm.getelementptr %37[0, %43] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %25, %44 : i32, !llvm.ptr
%45 = llvm.mlir.constant(3 : i64) : i64
%46 = llvm.getelementptr %37[0, %45] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %26, %46 : i32, !llvm.ptr
%47 = llvm.mlir.constant(4 : i64) : i64
%48 = llvm.getelementptr %37[0, %47] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %27, %48 : i32, !llvm.ptr
%49 = llvm.mlir.constant(5 : i64) : i64
%50 = llvm.getelementptr %37[0, %49] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %28, %50 : i32, !llvm.ptr
%51 = llvm.mlir.constant(6 : i64) : i64
%52 = llvm.getelementptr %37[0, %51] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %29, %52 : i32, !llvm.ptr
%53 = llvm.mlir.constant(7 : i64) : i64
%54 = llvm.getelementptr %37[0, %53] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %30, %54 : i32, !llvm.ptr
%55 = llvm.mlir.constant(8 : i64) : i64
%56 = llvm.getelementptr %37[0, %55] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %31, %56 : i32, !llvm.ptr
%57 = llvm.mlir.constant(9 : i64) : i64
%58 = llvm.getelementptr %37[0, %57] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %32, %58 : i32, !llvm.ptr
%59 = llvm.mlir.constant(10 : i64) : i64
%60 = llvm.getelementptr %37[0, %59] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %33, %60 : i32, !llvm.ptr
%61 = llvm.mlir.constant(11 : i64) : i64
%62 = llvm.getelementptr %37[0, %61] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %34, %62 : i32, !llvm.ptr
%63 = llvm.mlir.constant(12 : i64) : i64
%64 = llvm.getelementptr %37[0, %63] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %35, %64 : i32, !llvm.ptr
%66 = arith.constant 1 : i32
%67 = arith.constant 2 : i32
%68 = arith.constant 1 : i32
%69 = arith.constant 2 : i32
%70 = arith.constant 1 : i32
%71 = arith.constant 2 : i32
%72 = arith.constant 1 : i32
%73 = arith.constant 2 : i32
%74 = arith.constant 1 : i32
%75 = arith.constant 2 : i32
%76 = arith.constant 1 : i32
%77 = arith.constant 2 : i32
%78 = arith.constant 1 : i32
%79 = llvm.mlir.constant(1 : i64) : i64
%80 = llvm.alloca %79 x !llvm.array<13 x i32> : (i64) -> !llvm.ptr
%81 = llvm.mlir.zero : !llvm.array<13 x i32>
llvm.store %81, %80 : !llvm.array<13 x i32>, !llvm.ptr
%82 = llvm.mlir.constant(0 : i64) : i64
%83 = llvm.getelementptr %80[0, %82] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %66, %83 : i32, !llvm.ptr
%84 = llvm.mlir.constant(1 : i64) : i64
%85 = llvm.getelementptr %80[0, %84] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %67, %85 : i32, !llvm.ptr
%86 = llvm.mlir.constant(2 : i64) : i64
%87 = llvm.getelementptr %80[0, %86] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %68, %87 : i32, !llvm.ptr
%88 = llvm.mlir.constant(3 : i64) : i64
%89 = llvm.getelementptr %80[0, %88] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %69, %89 : i32, !llvm.ptr
%90 = llvm.mlir.constant(4 : i64) : i64
%91 = llvm.getelementptr %80[0, %90] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %70, %91 : i32, !llvm.ptr
%92 = llvm.mlir.constant(5 : i64) : i64
%93 = llvm.getelementptr %80[0, %92] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %71, %93 : i32, !llvm.ptr
%94 = llvm.mlir.constant(6 : i64) : i64
%95 = llvm.getelementptr %80[0, %94] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %72, %95 : i32, !llvm.ptr
%96 = llvm.mlir.constant(7 : i64) : i64
%97 = llvm.getelementptr %80[0, %96] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %73, %97 : i32, !llvm.ptr
%98 = llvm.mlir.constant(8 : i64) : i64
%99 = llvm.getelementptr %80[0, %98] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %74, %99 : i32, !llvm.ptr
%100 = llvm.mlir.constant(9 : i64) : i64
%101 = llvm.getelementptr %80[0, %100] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %75, %101 : i32, !llvm.ptr
%102 = llvm.mlir.constant(10 : i64) : i64
%103 = llvm.getelementptr %80[0, %102] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %76, %103 : i32, !llvm.ptr
%104 = llvm.mlir.constant(11 : i64) : i64
%105 = llvm.getelementptr %80[0, %104] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %77, %105 : i32, !llvm.ptr
%106 = llvm.mlir.constant(12 : i64) : i64
%107 = llvm.getelementptr %80[0, %106] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
llvm.store %78, %107 : i32, !llvm.ptr
%108 = arith.constant 0 : i32
%109 = llvm.mlir.constant(1 : i64) : i64
%110 = llvm.alloca %109 x i32 : (i64) -> !llvm.ptr
llvm.store %108, %110 : i32, !llvm.ptr
%111 = llvm.mlir.constant(1 : i64) : i64
%112 = llvm.alloca %111 x i32 : (i64) -> !llvm.ptr
llvm.store %arg0, %112 : i32, !llvm.ptr
%113 = arith.constant 0 : i32
%114 = arith.constant 13 : i32
%115 = arith.index_cast %113 : i32 to index
%116 = arith.index_cast %114 : i32 to index
%118 = arith.constant 1 : index
%119 = arith.constant -1 : index
%120 = arith.cmpi sle, %115, %116 : index
%117 = arith.select %120, %118, %119 : index
cf.br ^bb21(%115 : index)
^bb21(%121: index):
%122 = arith.cmpi slt, %121, %116 : index
%123 = arith.cmpi sgt, %121, %116 : index
%124 = arith.select %120, %122, %123 : i1
cf.cond_br %124, ^bb22(%121 : index), ^bb23(%121 : index)
^bb22(%125: index):
cf.br ^bb24
^bb24:
%126 = llvm.load %112 : !llvm.ptr -> i32
%128 = arith.index_cast %125 : index to i64
%129 = llvm.getelementptr %37[0, %128] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
%127 = llvm.load %129 : !llvm.ptr -> i32
%130 = arith.cmpi sge, %126, %127 : i32
cf.cond_br %130, ^bb25, ^bb26
^bb25:
%131 = llvm.load %112 : !llvm.ptr -> i32
%133 = arith.index_cast %125 : index to i64
%134 = llvm.getelementptr %37[0, %133] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
%132 = llvm.load %134 : !llvm.ptr -> i32
%135 = arith.subi %131, %132 : i32
llvm.store %135, %112 : i32, !llvm.ptr
%136 = llvm.load %110 : !llvm.ptr -> i32
%138 = arith.index_cast %125 : index to i64
%139 = llvm.getelementptr %80[0, %138] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<13 x i32>
%137 = llvm.load %139 : !llvm.ptr -> i32
%140 = arith.addi %136, %137 : i32
llvm.store %140, %110 : i32, !llvm.ptr
cf.br ^bb24
^bb26:
%141 = arith.addi %125, %117 : index
cf.br ^bb21(%141 : index)
^bb23(%142: index):
%143 = llvm.load %110 : !llvm.ptr -> i32
func.return %143 : i32
}
func.func @main() -> i32 {
%145 = llvm.mlir.addressof @str_0 : !llvm.ptr
%146 = llvm.mlir.addressof @str_1 : !llvm.ptr
%144 = func.call @fopen(%145, %146) : (!llvm.ptr, !llvm.ptr) -> !llvm.ptr
%147 = llvm.mlir.zero : !llvm.ptr
%148 = llvm.icmp "eq" %144, %147 : !llvm.ptr
cf.cond_br %148, ^bb27, ^bb28
^bb27:
%149 = llvm.mlir.addressof @str_2 : !llvm.ptr
%150 = llvm.call @printf(%149) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr) -> i32
%151 = arith.constant 1 : i32
func.return %151 : i32
^bb28:
cf.br ^bb29
^bb29:
%152 = arith.constant 0 : i32
%153 = arith.extsi %152 : i32 to i64
%154 = llvm.mlir.constant(1 : i64) : i64
%155 = llvm.alloca %154 x i64 : (i64) -> !llvm.ptr
llvm.store %153, %155 : i64, !llvm.ptr
%157 = arith.constant 0 : i32
%158 = arith.constant 0 : i32
%159 = arith.constant 0 : i32
%160 = arith.constant 0 : i32
%161 = arith.constant 0 : i32
%162 = arith.constant 0 : i32
%163 = arith.constant 0 : i32
%164 = arith.constant 0 : i32
%165 = arith.constant 0 : i32
%166 = arith.constant 0 : i32
%167 = arith.constant 0 : i32
%168 = arith.constant 0 : i32
%169 = arith.constant 0 : i32
%170 = arith.constant 0 : i32
%171 = arith.constant 0 : i32
%172 = arith.constant 0 : i32
%173 = arith.constant 0 : i32
%174 = arith.constant 0 : i32
%175 = arith.constant 0 : i32
%176 = arith.constant 0 : i32
%177 = arith.constant 0 : i32
%178 = arith.constant 0 : i32
%179 = arith.constant 0 : i32
%180 = arith.constant 0 : i32
%181 = arith.constant 0 : i32
%182 = arith.constant 0 : i32
%183 = arith.constant 0 : i32
%184 = arith.constant 0 : i32
%185 = arith.constant 0 : i32
%186 = arith.constant 0 : i32
%187 = arith.constant 0 : i32
%188 = arith.constant 0 : i32
%189 = llvm.mlir.constant(1 : i64) : i64
%190 = llvm.alloca %189 x !llvm.array<32 x i32> : (i64) -> !llvm.ptr
%191 = llvm.mlir.zero : !llvm.array<32 x i32>
llvm.store %191, %190 : !llvm.array<32 x i32>, !llvm.ptr
%192 = llvm.mlir.constant(0 : i64) : i64
%193 = llvm.getelementptr %190[0, %192] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %157, %193 : i32, !llvm.ptr
%194 = llvm.mlir.constant(1 : i64) : i64
%195 = llvm.getelementptr %190[0, %194] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %158, %195 : i32, !llvm.ptr
%196 = llvm.mlir.constant(2 : i64) : i64
%197 = llvm.getelementptr %190[0, %196] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %159, %197 : i32, !llvm.ptr
%198 = llvm.mlir.constant(3 : i64) : i64
%199 = llvm.getelementptr %190[0, %198] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %160, %199 : i32, !llvm.ptr
%200 = llvm.mlir.constant(4 : i64) : i64
%201 = llvm.getelementptr %190[0, %200] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %161, %201 : i32, !llvm.ptr
%202 = llvm.mlir.constant(5 : i64) : i64
%203 = llvm.getelementptr %190[0, %202] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %162, %203 : i32, !llvm.ptr
%204 = llvm.mlir.constant(6 : i64) : i64
%205 = llvm.getelementptr %190[0, %204] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %163, %205 : i32, !llvm.ptr
%206 = llvm.mlir.constant(7 : i64) : i64
%207 = llvm.getelementptr %190[0, %206] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %164, %207 : i32, !llvm.ptr
%208 = llvm.mlir.constant(8 : i64) : i64
%209 = llvm.getelementptr %190[0, %208] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %165, %209 : i32, !llvm.ptr
%210 = llvm.mlir.constant(9 : i64) : i64
%211 = llvm.getelementptr %190[0, %210] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %166, %211 : i32, !llvm.ptr
%212 = llvm.mlir.constant(10 : i64) : i64
%213 = llvm.getelementptr %190[0, %212] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %167, %213 : i32, !llvm.ptr
%214 = llvm.mlir.constant(11 : i64) : i64
%215 = llvm.getelementptr %190[0, %214] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %168, %215 : i32, !llvm.ptr
%216 = llvm.mlir.constant(12 : i64) : i64
%217 = llvm.getelementptr %190[0, %216] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %169, %217 : i32, !llvm.ptr
%218 = llvm.mlir.constant(13 : i64) : i64
%219 = llvm.getelementptr %190[0, %218] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %170, %219 : i32, !llvm.ptr
%220 = llvm.mlir.constant(14 : i64) : i64
%221 = llvm.getelementptr %190[0, %220] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %171, %221 : i32, !llvm.ptr
%222 = llvm.mlir.constant(15 : i64) : i64
%223 = llvm.getelementptr %190[0, %222] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %172, %223 : i32, !llvm.ptr
%224 = llvm.mlir.constant(16 : i64) : i64
%225 = llvm.getelementptr %190[0, %224] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %173, %225 : i32, !llvm.ptr
%226 = llvm.mlir.constant(17 : i64) : i64
%227 = llvm.getelementptr %190[0, %226] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %174, %227 : i32, !llvm.ptr
%228 = llvm.mlir.constant(18 : i64) : i64
%229 = llvm.getelementptr %190[0, %228] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %175, %229 : i32, !llvm.ptr
%230 = llvm.mlir.constant(19 : i64) : i64
%231 = llvm.getelementptr %190[0, %230] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %176, %231 : i32, !llvm.ptr
%232 = llvm.mlir.constant(20 : i64) : i64
%233 = llvm.getelementptr %190[0, %232] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %177, %233 : i32, !llvm.ptr
%234 = llvm.mlir.constant(21 : i64) : i64
%235 = llvm.getelementptr %190[0, %234] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %178, %235 : i32, !llvm.ptr
%236 = llvm.mlir.constant(22 : i64) : i64
%237 = llvm.getelementptr %190[0, %236] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %179, %237 : i32, !llvm.ptr
%238 = llvm.mlir.constant(23 : i64) : i64
%239 = llvm.getelementptr %190[0, %238] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %180, %239 : i32, !llvm.ptr
%240 = llvm.mlir.constant(24 : i64) : i64
%241 = llvm.getelementptr %190[0, %240] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %181, %241 : i32, !llvm.ptr
%242 = llvm.mlir.constant(25 : i64) : i64
%243 = llvm.getelementptr %190[0, %242] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %182, %243 : i32, !llvm.ptr
%244 = llvm.mlir.constant(26 : i64) : i64
%245 = llvm.getelementptr %190[0, %244] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %183, %245 : i32, !llvm.ptr
%246 = llvm.mlir.constant(27 : i64) : i64
%247 = llvm.getelementptr %190[0, %246] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %184, %247 : i32, !llvm.ptr
%248 = llvm.mlir.constant(28 : i64) : i64
%249 = llvm.getelementptr %190[0, %248] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %185, %249 : i32, !llvm.ptr
%250 = llvm.mlir.constant(29 : i64) : i64
%251 = llvm.getelementptr %190[0, %250] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %186, %251 : i32, !llvm.ptr
%252 = llvm.mlir.constant(30 : i64) : i64
%253 = llvm.getelementptr %190[0, %252] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %187, %253 : i32, !llvm.ptr
%254 = llvm.mlir.constant(31 : i64) : i64
%255 = llvm.getelementptr %190[0, %254] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %188, %255 : i32, !llvm.ptr
%256 = func.call @fgetc(%144) : (!llvm.ptr) -> i32
%257 = llvm.mlir.constant(1 : i64) : i64
%258 = llvm.alloca %257 x i32 : (i64) -> !llvm.ptr
llvm.store %256, %258 : i32, !llvm.ptr
cf.br ^bb30
^bb30:
%259 = llvm.load %258 : !llvm.ptr -> i32
%260 = arith.constant 0 : i32
%261 = arith.cmpi sge, %259, %260 : i32
cf.cond_br %261, ^bb31, ^bb32
^bb31:
%262 = arith.constant 0 : i32
%263 = llvm.mlir.constant(1 : i64) : i64
%264 = llvm.alloca %263 x i32 : (i64) -> !llvm.ptr
llvm.store %262, %264 : i32, !llvm.ptr
cf.br ^bb33
^bb33:
%265 = llvm.load %258 : !llvm.ptr -> i32
%266 = arith.constant 0 : i32
%267 = arith.cmpi sge, %265, %266 : i32
%268 = scf.if %267 -> (i1) {
%269 = llvm.load %258 : !llvm.ptr -> i32
%270 = arith.constant 10 : i32
%271 = arith.cmpi ne, %269, %270 : i32
scf.yield %271 : i1
} else {
%272 = arith.constant false
scf.yield %272 : i1
}
cf.cond_br %268, ^bb34, ^bb35
^bb34:
%274 = llvm.load %258 : !llvm.ptr -> i32
%273 = func.call @roman_value(%274) : (i32) -> i32
%275 = arith.constant 0 : i32
%276 = arith.cmpi sgt, %273, %275 : i32
cf.cond_br %276, ^bb36, ^bb37
^bb36:
%277 = llvm.load %258 : !llvm.ptr -> i32
%278 = llvm.load %264 : !llvm.ptr -> i32
%279 = arith.extsi %278 : i32 to i64
%280 = llvm.getelementptr %190[0, %279] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
llvm.store %277, %280 : i32, !llvm.ptr
%281 = llvm.load %264 : !llvm.ptr -> i32
%282 = arith.constant 1 : i32
%283 = arith.addi %281, %282 : i32
llvm.store %283, %264 : i32, !llvm.ptr
cf.br ^bb38
^bb37:
cf.br ^bb38
^bb38:
%284 = func.call @fgetc(%144) : (!llvm.ptr) -> i32
llvm.store %284, %258 : i32, !llvm.ptr
cf.br ^bb33
^bb35:
%285 = llvm.load %264 : !llvm.ptr -> i32
%286 = arith.constant 0 : i32
%287 = arith.cmpi sgt, %285, %286 : i32
cf.cond_br %287, ^bb39, ^bb40
^bb39:
%288 = arith.constant 0 : i32
%289 = llvm.mlir.constant(1 : i64) : i64
%290 = llvm.alloca %289 x i32 : (i64) -> !llvm.ptr
llvm.store %288, %290 : i32, !llvm.ptr
%291 = arith.constant 0 : i32
%292 = llvm.mlir.constant(1 : i64) : i64
%293 = llvm.alloca %292 x i32 : (i64) -> !llvm.ptr
llvm.store %291, %293 : i32, !llvm.ptr
cf.br ^bb42
^bb42:
%294 = llvm.load %293 : !llvm.ptr -> i32
%295 = llvm.load %264 : !llvm.ptr -> i32
%296 = arith.cmpi slt, %294, %295 : i32
cf.cond_br %296, ^bb43, ^bb44
^bb43:
%299 = llvm.load %293 : !llvm.ptr -> i32
%300 = arith.extsi %299 : i32 to i64
%301 = llvm.getelementptr %190[0, %300] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%298 = llvm.load %301 : !llvm.ptr -> i32
%297 = func.call @roman_value(%298) : (i32) -> i32
%302 = llvm.load %293 : !llvm.ptr -> i32
%303 = arith.constant 1 : i32
%304 = arith.addi %302, %303 : i32
%305 = llvm.load %264 : !llvm.ptr -> i32
%306 = arith.cmpi slt, %304, %305 : i32
cf.cond_br %306, ^bb45, ^bb46
^bb45:
%309 = llvm.load %293 : !llvm.ptr -> i32
%310 = arith.constant 1 : i32
%311 = arith.addi %309, %310 : i32
%312 = arith.extsi %311 : i32 to i64
%313 = llvm.getelementptr %190[0, %312] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.array<32 x i32>
%308 = llvm.load %313 : !llvm.ptr -> i32
%307 = func.call @roman_value(%308) : (i32) -> i32
%314 = arith.cmpi slt, %297, %307 : i32
cf.cond_br %314, ^bb48, ^bb49
^bb48:
%315 = llvm.load %290 : !llvm.ptr -> i32
%316 = arith.subi %307, %297 : i32
%317 = arith.addi %315, %316 : i32
llvm.store %317, %290 : i32, !llvm.ptr
%318 = llvm.load %293 : !llvm.ptr -> i32
%319 = arith.constant 2 : i32
%320 = arith.addi %318, %319 : i32
llvm.store %320, %293 : i32, !llvm.ptr
cf.br ^bb50
^bb49:
%321 = llvm.load %290 : !llvm.ptr -> i32
%322 = arith.addi %321, %297 : i32
llvm.store %322, %290 : i32, !llvm.ptr
%323 = llvm.load %293 : !llvm.ptr -> i32
%324 = arith.constant 1 : i32
%325 = arith.addi %323, %324 : i32
llvm.store %325, %293 : i32, !llvm.ptr
cf.br ^bb50
^bb50:
cf.br ^bb47
^bb46:
%326 = llvm.load %290 : !llvm.ptr -> i32
%327 = arith.addi %326, %297 : i32
llvm.store %327, %290 : i32, !llvm.ptr
%328 = llvm.load %293 : !llvm.ptr -> i32
%329 = arith.constant 1 : i32
%330 = arith.addi %328, %329 : i32
llvm.store %330, %293 : i32, !llvm.ptr
cf.br ^bb47
^bb47:
cf.br ^bb42
^bb44:
%331 = llvm.load %155 : !llvm.ptr -> i64
%332 = llvm.load %264 : !llvm.ptr -> i32
%334 = llvm.load %290 : !llvm.ptr -> i32
%333 = func.call @minimal_len(%334) : (i32) -> i32
%335 = arith.subi %332, %333 : i32
%336 = arith.extsi %335 : i32 to i64
%337 = arith.addi %331, %336 : i64
llvm.store %337, %155 : i64, !llvm.ptr
cf.br ^bb41
^bb40:
cf.br ^bb41
^bb41:
%338 = llvm.load %258 : !llvm.ptr -> i32
%339 = arith.constant 10 : i32
%340 = arith.cmpi eq, %338, %339 : i32
cf.cond_br %340, ^bb51, ^bb52
^bb51:
%341 = func.call @fgetc(%144) : (!llvm.ptr) -> i32
llvm.store %341, %258 : i32, !llvm.ptr
cf.br ^bb53
^bb52:
cf.br ^bb53
^bb53:
cf.br ^bb30
^bb32:
%342 = func.call @fclose(%144) : (!llvm.ptr) -> i32
%343 = llvm.mlir.addressof @str_3 : !llvm.ptr
%344 = llvm.load %155 : !llvm.ptr -> i64
%345 = llvm.call @printf(%343, %344) vararg(!llvm.func<i32 (ptr, ...)>) : (!llvm.ptr, i64) -> i32
%346 = arith.constant 0 : i32
func.return %346 : i32
}
}