#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
size_t strlen(char *);
int romanToInt(char *s) {
  int retval = 0;
  size_t index = 0;
  size_t sl = strlen(s);
  if (s == NULL || s[0] == '\0') {
    return 0;
  }
  while (index < sl) {
    if (s[index] == 'I') {
      index++;
      if (index >= sl) {
        retval += 1;
        break;
      } else if (s[index] == 'V') {
        retval += 4;
        index++;
      } else if (s[index] == 'X') {
        retval += 9;
        index++;
      } else {
        retval += 1;
      }
      continue;
    } else if (s[index] == 'V') {
      retval += 5;
      index++;
      continue;
    } else if (s[index] == 'X') {
      index++;
      if (index >= sl) {
        retval += 10;
        break;
      } else if (s[index] == 'L') {
        retval += 40;
        index++;
      } else if (s[index] == 'C') {
        retval += 90;
        index++;
      } else {
        retval += 10;
      }
      continue;
    } else if (s[index] == 'L') {
      retval += 50;
      index++;
      continue;
    } else if (s[index] == 'C') {
      index++;
      if (index >= sl) {
        retval += 100;
        break;
      } else if (s[index] == 'D') {
        retval += 400;
        index++;
      } else if (s[index] == 'M') {
        retval += 900;
        index++;
      } else {
        retval += 100;
      }
      continue;
    } else if (s[index] == 'D') {
      retval += 500;
      index++;
      continue;
    } else if (s[index] == 'M') {
      retval += 1000;
      index++;
      continue;
    } else {
      assert(0);
    }
  }
  assert(retval >= 0 && retval < 4000);
  return retval;
}


x86 assembly (clang, -O0):
<romanToInt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1163 <romanToInt+0x43>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    116f <romanToInt+0x4f>
movl   $0x0,-0x4(%rbp)
jmp    14b8 <romanToInt+0x398>
jmp    1174 <romanToInt+0x54>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1489 <romanToInt+0x369>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x49,%eax
jne    1235 <romanToInt+0x115>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     11bf <romanToInt+0x9f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1489 <romanToInt+0x369>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x56,%eax
jne    11ee <romanToInt+0xce>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    122b <romanToInt+0x10b>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x58,%eax
jne    121d <romanToInt+0xfd>
mov    -0x14(%rbp),%eax
add    $0x9,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1226 <romanToInt+0x106>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122b <romanToInt+0x10b>
jmp    1230 <romanToInt+0x110>
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x56,%eax
jne    1264 <romanToInt+0x144>
mov    -0x14(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x58,%eax
jne    1317 <romanToInt+0x1f7>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     12a1 <romanToInt+0x181>
mov    -0x14(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x14(%rbp)
jmp    1489 <romanToInt+0x369>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4c,%eax
jne    12d0 <romanToInt+0x1b0>
mov    -0x14(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    130d <romanToInt+0x1ed>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
jne    12ff <romanToInt+0x1df>
mov    -0x14(%rbp),%eax
add    $0x5a,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1308 <romanToInt+0x1e8>
mov    -0x14(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x14(%rbp)
jmp    130d <romanToInt+0x1ed>
jmp    1312 <romanToInt+0x1f2>
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4c,%eax
jne    1346 <romanToInt+0x226>
mov    -0x14(%rbp),%eax
add    $0x32,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
jne    13fd <romanToInt+0x2dd>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     1383 <romanToInt+0x263>
mov    -0x14(%rbp),%eax
add    $0x64,%eax
mov    %eax,-0x14(%rbp)
jmp    1489 <romanToInt+0x369>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x44,%eax
jne    13b4 <romanToInt+0x294>
mov    -0x14(%rbp),%eax
add    $0x190,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    13f3 <romanToInt+0x2d3>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    13e5 <romanToInt+0x2c5>
mov    -0x14(%rbp),%eax
add    $0x384,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    13ee <romanToInt+0x2ce>
mov    -0x14(%rbp),%eax
add    $0x64,%eax
mov    %eax,-0x14(%rbp)
jmp    13f3 <romanToInt+0x2d3>
jmp    13f8 <romanToInt+0x2d8>
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x44,%eax
jne    142e <romanToInt+0x30e>
mov    -0x14(%rbp),%eax
add    $0x1f4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1174 <romanToInt+0x54>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4d,%eax
jne    145f <romanToInt+0x33f>
mov    -0x14(%rbp),%eax
add    $0x3e8,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1174 <romanToInt+0x54>
xor    %edi,%edi
call   1040 <assert@plt>
jmp    146b <romanToInt+0x34b>
jmp    1470 <romanToInt+0x350>
jmp    1475 <romanToInt+0x355>
jmp    147a <romanToInt+0x35a>
jmp    147f <romanToInt+0x35f>
jmp    1484 <romanToInt+0x364>
jmp    1174 <romanToInt+0x54>
xor    %eax,%eax
cmpl   $0x0,-0x14(%rbp)
mov    %al,-0x29(%rbp)
jl     14a5 <romanToInt+0x385>
cmpl   $0xfa0,-0x14(%rbp)
setl   %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<romanToInt>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%r14
call   1030 <strlen@plt>
xor    %ebp,%ebp
test   %r14,%r14
je     1282 <romanToInt+0x162>
mov    %rax,%r15
mov    (%r14),%al
test   %al,%al
je     1282 <romanToInt+0x162>
test   %r15,%r15
je     126f <romanToInt+0x14f>
xor    %ebx,%ebx
lea    0xea5(%rip),%r12
xor    %ebp,%ebp
nopl   (%rax)
add    $0xbd,%al
cmp    $0x15,%al
ja     11b4 <romanToInt+0x94>
movzbl %al,%eax
movslq (%r12,%rax,4),%rax
add    %r12,%rax
jmp    *%rax
lea    0x1(%rbx),%rax
cmp    %r15,%rax
jae    128d <romanToInt+0x16d>
movzbl (%r14,%rax,1),%ecx
cmp    $0x4d,%cl
je     122b <romanToInt+0x10b>
cmp    $0x44,%cl
jne    1237 <romanToInt+0x117>
add    $0x190,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x1f4,%ebp
add    $0x1,%rbx
jmp    1260 <romanToInt+0x140>
xor    %edi,%edi
call   1040 <assert@plt>
jmp    1260 <romanToInt+0x140>
add    $0x5,%ebp
add    $0x1,%rbx
jmp    1260 <romanToInt+0x140>
lea    0x1(%rbx),%rax
cmp    %r15,%rax
jae    1292 <romanToInt+0x172>
movzbl (%r14,%rax,1),%ecx
cmp    $0x43,%cl
je     123c <romanToInt+0x11c>
cmp    $0x4c,%cl
jne    1245 <romanToInt+0x125>
add    $0x28,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
lea    0x1(%rbx),%rax
cmp    %r15,%rax
jae    1297 <romanToInt+0x177>
movzbl (%r14,%rax,1),%ecx
cmp    $0x58,%cl
je     124a <romanToInt+0x12a>
cmp    $0x56,%cl
jne    1253 <romanToInt+0x133>
add    $0x4,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x32,%ebp
add    $0x1,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x3e8,%ebp
add    $0x1,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x384,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x64,%ebp
jmp    1256 <romanToInt+0x136>
add    $0x5a,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
add    $0xa,%ebp
jmp    1256 <romanToInt+0x136>
add    $0x9,%ebp
add    $0x2,%rbx
jmp    1260 <romanToInt+0x140>
add    $0x1,%ebp
mov    %rax,%rbx
nopl   0x0(%rax)
cmp    %r15,%rbx
jae    1271 <romanToInt+0x151>
movzbl (%r14,%rbx,1),%eax
jmp    1160 <romanToInt+0x40>
xor    %ebp,%ebp
xor    %edi,%edi
cmp    $0xfa0,%ebp
setb   %dil
call   1040 <assert@plt>
mov    %ebp,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x64,%ebp
jmp    1271 <romanToInt+0x151>
add    $0xa,%ebp
jmp    1271 <romanToInt+0x151>
add    $0x1,%ebp
jmp    1271 <romanToInt+0x151>

LLVM IR (-O0):
define i32 @romanToInt(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i64
%6 = alloca i64
store i8* %0, i8** %3
store i32 0, i32* %4
store i64 0, i64* %5
%7 = load i8*, i8** %3
%8 = call i64 @strlen(i8* %7)
store i64 %8, i64* %6
%9 = load i8*, i8** %3
%10 = icmp eq i8* %9, null
br i1 %10, label %17, label %11
11: ; preds = %1
%12 = load i8*, i8** %3
%13 = getelementptr inbounds i8, i8* %12, i64 0
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %18
17: ; preds = %11, %1
store i32 0, i32* %2
br label %229
18: ; preds = %11
br label %19
19: ; preds = %217, %204, %192, %184, %134, %126, %76, %68, %18
%20 = load i64, i64* %5
%21 = load i64, i64* %6
%22 = icmp ult i64 %20, %21
br i1 %22, label %23, label %218
23: ; preds = %19
%24 = load i8*, i8** %3
%25 = load i64, i64* %5
%26 = getelementptr inbounds i8, i8* %24, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 73
br i1 %29, label %30, label %69
30: ; preds = %23
%31 = load i64, i64* %5
%32 = add i64 %31, 1
store i64 %32, i64* %5
%33 = load i64, i64* %5
%34 = load i64, i64* %6
%35 = icmp uge i64 %33, %34
br i1 %35, label %36, label %39
36: ; preds = %30
%37 = load i32, i32* %4
%38 = add nsw i32 %37, 1
store i32 %38, i32* %4
br label %218
39: ; preds = %30
%40 = load i8*, i8** %3
%41 = load i64, i64* %5
%42 = getelementptr inbounds i8, i8* %40, i64 %41
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = icmp eq i32 %44, 86
br i1 %45, label %46, label %51
46: ; preds = %39
%47 = load i32, i32* %4
%48 = add nsw i32 %47, 4
store i32 %48, i32* %4
%49 = load i64, i64* %5
%50 = add i64 %49, 1
store i64 %50, i64* %5
br label %67
51: ; preds = %39
%52 = load i8*, i8** %3
%53 = load i64, i64* %5
%54 = getelementptr inbounds i8, i8* %52, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 88
br i1 %57, label %58, label %63
58: ; preds = %51
%59 = load i32, i32* %4
%60 = add nsw i32 %59, 9
store i32 %60, i32* %4
%61 = load i64, i64* %5
%62 = add i64 %61, 1
store i64 %62, i64* %5
br label %66
63: ; preds = %51
%64 = load i32, i32* %4
%65 = add nsw i32 %64, 1
store i32 %65, i32* %4
br label %66
66: ; preds = %63, %58
br label %67
67: ; preds = %66, %46
br label %68
68: ; preds = %67
br label %19
69: ; preds = %23
%70 = load i8*, i8** %3
%71 = load i64, i64* %5
%72 = getelementptr inbounds i8, i8* %70, i64 %71
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 86
br i1 %75, label %76, label %81
76: ; preds = %69
%77 = load i32, i32* %4
%78 = add nsw i32 %77, 5
store i32 %78, i32* %4
%79 = load i64, i64* %5
%80 = add i64 %79, 1
store i64 %80, i64* %5
br label %19
81: ; preds = %69
%82 = load i8*, i8** %3
%83 = load i64, i64* %5
%84 = getelementptr inbounds i8, i8* %82, i64 %83
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = icmp eq i32 %86, 88
br i1 %87, label %88, label %127
88: ; preds = %81
%89 = load i64, i64* %5
%90 = add i64 %89, 1
store i64 %90, i64* %5
%91 = load i64, i64* %5
%92 = load i64, i64* %6
%93 = icmp uge i64 %91, %92
br i1 %93, label %94, label %97
94: ; preds = %88
%95 = load i32, i32* %4
%96 = add nsw i32 %95, 10
store i32 %96, i32* %4
br label %218
97: ; preds = %88
%98 = load i8*, i8** %3
%99 = load i64, i64* %5
%100 = getelementptr inbounds i8, i8* %98, i64 %99
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = icmp eq i32 %102, 76
br i1 %103, label %104, label %109
104: ; preds = %97
%105 = load i32, i32* %4
%106 = add nsw i32 %105, 40
store i32 %106, i32* %4
%107 = load i64, i64* %5
%108 = add i64 %107, 1
store i64 %108, i64* %5
br label %125
109: ; preds = %97
%110 = load i8*, i8** %3
%111 = load i64, i64* %5
%112 = getelementptr inbounds i8, i8* %110, i64 %111
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = icmp eq i32 %114, 67
br i1 %115, label %116, label %121
116: ; preds = %109
%117 = load i32, i32* %4
%118 = add nsw i32 %117, 90
store i32 %118, i32* %4
%119 = load i64, i64* %5
%120 = add i64 %119, 1
store i64 %120, i64* %5
br label %124
121: ; preds = %109
%122 = load i32, i32* %4
%123 = add nsw i32 %122, 10
store i32 %123, i32* %4
br label %124
124: ; preds = %121, %116
br label %125
125: ; preds = %124, %104
br label %126
126: ; preds = %125
br label %19
127: ; preds = %81
%128 = load i8*, i8** %3
%129 = load i64, i64* %5
%130 = getelementptr inbounds i8, i8* %128, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = icmp eq i32 %132, 76
br i1 %133, label %134, label %139
134: ; preds = %127
%135 = load i32, i32* %4
%136 = add nsw i32 %135, 50
store i32 %136, i32* %4
%137 = load i64, i64* %5
%138 = add i64 %137, 1
store i64 %138, i64* %5
br label %19
139: ; preds = %127
%140 = load i8*, i8** %3
%141 = load i64, i64* %5
%142 = getelementptr inbounds i8, i8* %140, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = icmp eq i32 %144, 67
br i1 %145, label %146, label %185
146: ; preds = %139
%147 = load i64, i64* %5
%148 = add i64 %147, 1
store i64 %148, i64* %5
%149 = load i64, i64* %5
%150 = load i64, i64* %6
%151 = icmp uge i64 %149, %150
br i1 %151, label %152, label %155
152: ; preds = %146
%153 = load i32, i32* %4
%154 = add nsw i32 %153, 100
store i32 %154, i32* %4
br label %218
155: ; preds = %146
%156 = load i8*, i8** %3
%157 = load i64, i64* %5
%158 = getelementptr inbounds i8, i8* %156, i64 %157
%159 = load i8, i8* %158
%160 = sext i8 %159 to i32
%161 = icmp eq i32 %160, 68
br i1 %161, label %162, label %167
162: ; preds = %155
%163 = load i32, i32* %4
%164 = add nsw i32 %163, 400
store i32 %164, i32* %4
%165 = load i64, i64* %5
%166 = add i64 %165, 1
store i64 %166, i64* %5
br label %183
167: ; preds = %155
%168 = load i8*, i8** %3
%169 = load i64, i64* %5
%170 = getelementptr inbounds i8, i8* %168, i64 %169
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp eq i32 %172, 77
br i1 %173, label %174, label %179
174: ; preds = %167
%175 = load i32, i32* %4
%176 = add nsw i32 %175, 900
store i32 %176, i32* %4
%177 = load i64, i64* %5
%178 = add i64 %177, 1
store i64 %178, i64* %5
br label %182
179: ; preds = %167
%180 = load i32, i32* %4
%181 = add nsw i32 %180, 100
store i32 %181, i32* %4
br label %182
182: ; preds = %179, %174
br label %183
183: ; preds = %182, %162
br label %184
184: ; preds = %183
br label %19
185: ; preds = %139
%186 = load i8*, i8** %3
%187 = load i64, i64* %5
%188 = getelementptr inbounds i8, i8* %186, i64 %187
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = icmp eq i32 %190, 68
br i1 %191, label %192, label %197
192: ; preds = %185
%193 = load i32, i32* %4
%194 = add nsw i32 %193, 500
store i32 %194, i32* %4
%195 = load i64, i64* %5
%196 = add i64 %195, 1
store i64 %196, i64* %5
br label %19
197: ; preds = %185
%198 = load i8*, i8** %3
%199 = load i64, i64* %5
%200 = getelementptr inbounds i8, i8* %198, i64 %199
%201 = load i8, i8* %200
%202 = sext i8 %201 to i32
%203 = icmp eq i32 %202, 77
br i1 %203, label %204, label %209
204: ; preds = %197
%205 = load i32, i32* %4
%206 = add nsw i32 %205, 1000
store i32 %206, i32* %4
%207 = load i64, i64* %5
%208 = add i64 %207, 1
store i64 %208, i64* %5
br label %19
209: ; preds = %197
%210 = call i32 @assert(i32 0)
br label %211
211: ; preds = %209
br label %212
212: ; preds = %211
br label %213
213: ; preds = %212
br label %214
214: ; preds = %213
br label %215
215: ; preds = %214
br label %216
216: ; preds = %215
br label %217
217: ; preds = %216
br label %19
218: ; preds = %152, %94, %36, %19
%219 = load i32, i32* %4
%220 = icmp sge i32 %219, 0
br i1 %220, label %221, label %224
221: ; preds = %218
%222 = load i32, i32* %4
%223 = icmp slt i32 %222, 4000
br label %224
224: ; preds = %221, %218
%225 = phi i1 [ false, %218 ], [ %223, %221 ]
%226 = zext i1 %225 to i32
%227 = call i32 @assert(i32 %226)
%228 = load i32, i32* %4
store i32 %228, i32* %2
br label %229
229: ; preds = %224, %17
%230 = load i32, i32* %2
ret i32 %230
}

LLVM IR (-O2):
define i32 @romanToInt(i8* %0) {
%2 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%3 = icmp eq i8* %0, null
br i1 %3, label %87, label %4
4: ; preds = %1
%5 = load i8, i8* %0
%6 = icmp eq i8 %5, 0
br i1 %6, label %87, label %7
7: ; preds = %4
%8 = icmp eq i64 %2, 0
br i1 %8, label %82, label %9
9: ; preds = %7, %33
%10 = phi i8 [ %35, %33 ], [ %5, %7 ]
%11 = phi i64 [ %31, %33 ], [ 0, %7 ]
%12 = phi i32 [ %30, %33 ], [ 0, %7 ]
switch i8 %10, label %80 [
i8 73, label %13
i8 86, label %36
i8 88, label %39
i8 76, label %55
i8 67, label %58
i8 68, label %74
i8 77, label %77
]
13: ; preds = %9
%14 = add nuw i64 %11, 1
%15 = icmp ult i64 %14, %2
br i1 %15, label %18, label %16
16: ; preds = %13
%17 = add nsw i32 %12, 1
br label %82
18: ; preds = %13
%19 = getelementptr inbounds i8, i8* %0, i64 %14
%20 = load i8, i8* %19
switch i8 %20, label %27 [
i8 86, label %21
i8 88, label %24
]
21: ; preds = %18
%22 = add nsw i32 %12, 4
%23 = add nuw i64 %11, 2
br label %29
24: ; preds = %18
%25 = add nsw i32 %12, 9
%26 = add nuw i64 %11, 2
br label %29
27: ; preds = %18
%28 = add nsw i32 %12, 1
br label %29
29: ; preds = %69, %72, %66, %50, %53, %47, %24, %27, %21, %36, %55, %74, %77, %80
%30 = phi i32 [ %37, %36 ], [ %56, %55 ], [ %75, %74 ], [ %78, %77 ], [ %12, %80 ], [ %22, %21 ], [ %25, %24 ], [ %28, %27 ], [ %48, %47 ], [ %51, %50 ], [ %54, %53 ], [ %67, %66 ], [ %70, %69 ], [ %73, %72 ]
%31 = phi i64 [ %38, %36 ], [ %57, %55 ], [ %76, %74 ], [ %79, %77 ], [ %11, %80 ], [ %23, %21 ], [ %26, %24 ], [ %14, %27 ], [ %49, %47 ], [ %52, %50 ], [ %40, %53 ], [ %68, %66 ], [ %71, %69 ], [ %59, %72 ]
%32 = icmp ult i64 %31, %2
br i1 %32, label %33, label %82
33: ; preds = %29
%34 = getelementptr inbounds i8, i8* %0, i64 %31
%35 = load i8, i8* %34
br label %9
36: ; preds = %9
%37 = add nsw i32 %12, 5
%38 = add nuw i64 %11, 1
br label %29
39: ; preds = %9
%40 = add nuw i64 %11, 1
%41 = icmp ult i64 %40, %2
br i1 %41, label %44, label %42
42: ; preds = %39
%43 = add nsw i32 %12, 10
br label %82
44: ; preds = %39
%45 = getelementptr inbounds i8, i8* %0, i64 %40
%46 = load i8, i8* %45
switch i8 %46, label %53 [
i8 76, label %47
i8 67, label %50
]
47: ; preds = %44
%48 = add nsw i32 %12, 40
%49 = add nuw i64 %11, 2
br label %29
50: ; preds = %44
%51 = add nsw i32 %12, 90
%52 = add nuw i64 %11, 2
br label %29
53: ; preds = %44
%54 = add nsw i32 %12, 10
br label %29
55: ; preds = %9
%56 = add nsw i32 %12, 50
%57 = add nuw i64 %11, 1
br label %29
58: ; preds = %9
%59 = add nuw i64 %11, 1
%60 = icmp ult i64 %59, %2
br i1 %60, label %63, label %61
61: ; preds = %58
%62 = add nsw i32 %12, 100
br label %82
63: ; preds = %58
%64 = getelementptr inbounds i8, i8* %0, i64 %59
%65 = load i8, i8* %64
switch i8 %65, label %72 [
i8 68, label %66
i8 77, label %69
]
66: ; preds = %63
%67 = add nsw i32 %12, 400
%68 = add nuw i64 %11, 2
br label %29
69: ; preds = %63
%70 = add nsw i32 %12, 900
%71 = add nuw i64 %11, 2
br label %29
72: ; preds = %63
%73 = add nsw i32 %12, 100
br label %29
74: ; preds = %9
%75 = add nsw i32 %12, 500
%76 = add nuw i64 %11, 1
br label %29
77: ; preds = %9
%78 = add nsw i32 %12, 1000
%79 = add nuw i64 %11, 1
br label %29
80: ; preds = %9
%81 = tail call i32 @assert(i32 0)
br label %29
82: ; preds = %29, %7, %61, %42, %16
%83 = phi i32 [ %17, %16 ], [ %43, %42 ], [ %62, %61 ], [ 0, %7 ], [ %30, %29 ]
%84 = icmp ult i32 %83, 4000
%85 = zext i1 %84 to i32
%86 = tail call i32 @assert(i32 %85)
br label %87
87: ; preds = %1, %4, %82
%88 = phi i32 [ %83, %82 ], [ 0, %4 ], [ 0, %1 ]
ret i32 %88
}