int explode(int cnt, char *flat[]) {
  int ctr = 0;
  int swt = 0;
  int temp = 0;
  int t2 = 0;
  for (ctr = 1; ctr < cnt; ctr++) {
    if (strcmp(flat[ctr], "MF$") == 0) {
      ctr++;
      while (!strcmp(flat[ctr], "MF!") == 0) {
        for (t2 = 0; t2 < strlen(flat[ctr]); t2++) {
          swt += *(flat[ctr] + t2);
        }
        switch (swt) {
        case 217:
          ctr++;
          printf("%d\n", atoi(flat[ctr]));
          temp = atoi(flat[ctr]);
          break;
        case 201:
          ctr++;
          printf("%d -> ", atoi(flat[ctr]));
          temp += atoi(flat[ctr]);
          printf("%d\n", temp);
          break;
        case 234:
          ctr++;
          printf("%d -> ", atoi(flat[ctr]));
          temp -= atoi(flat[ctr]);
          printf("%d\n", temp);
          break;
        case 238:
          ctr++;
          printf("%d -> ", atoi(flat[ctr]));
          temp = temp * atoi(flat[ctr]);
          printf("%d\n", temp);
          break;
        case 227:
          ctr++;
          printf("%d -> ", atoi(flat[ctr]));
          temp = temp / atoi(flat[ctr]);
          printf("%d\n", temp);
          break;
        default:
          printf("Invalid instruction %s\n", flat[ctr]);
          ctr++;
          break;
        }
        swt = 0;
        ctr++;
      }
    } else {
      printf("\n%s\n", flat[ctr]);
    }
  }
  return ctr;
}


x86 assembly (clang, -O0):
<explode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1490 <explode+0x350>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xf07(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
jne    1463 <explode+0x323>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xee1(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
cmp    $0x0,%eax
jne    145e <explode+0x31e>
movl   $0x0,-0x20(%rbp)
movslq -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
cmp    %rcx,%rax
jae    122e <explode+0xee>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11dd <explode+0x9d>
mov    -0x18(%rbp),%eax
add    $0xffffff37,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x25,%eax
ja     1426 <explode+0x2e6>
mov    -0x30(%rbp),%rax
lea    0xdb0(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%esi
lea    0xe22(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,-0x1c(%rbp)
jmp    1449 <explode+0x309>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%esi
lea    0xddf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0xdb1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1449 <explode+0x309>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%esi
lea    0xd84(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0xd52(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1449 <explode+0x309>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%esi
lea    0xd25(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0xcec(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1449 <explode+0x309>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%esi
lea    0xcbf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1060 <atoi@plt>
mov    %eax,%ecx
mov    -0x38(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%esi
lea    0xc86(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1449 <explode+0x309>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xc72(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a8 <explode+0x68>
jmp    147d <explode+0x33d>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xc4d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1482 <explode+0x342>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1172 <explode+0x32>
mov    -0x14(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<explode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0x1,%ebp
mov    %edi,0x4(%rsp)
cmp    $0x2,%edi
jl     1487 <explode+0x347>
mov    %rsi,%r14
mov    $0x1,%ebp
lea    0xe94(%rip),%r12
xor    %r15d,%r15d
jmp    119e <explode+0x5e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0xf3c(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%ebp
cmp    0x4(%rsp),%ebp
jge    1487 <explode+0x347>
movslq %ebp,%r13
mov    (%r14,%r13,8),%rbx
mov    %rbx,%rdi
lea    0xee9(%rip),%rsi
call   1050 <strcmp@plt>
test   %eax,%eax
jne    1180 <explode+0x40>
mov    0x8(%r14,%r13,8),%r13
mov    %r13,%rdi
lea    0xed5(%rip),%rsi
call   1050 <strcmp@plt>
test   %eax,%eax
jne    120f <explode+0xcf>
add    $0x1,%ebp
jmp    1191 <explode+0x51>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xec4(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x2,%ebp
movslq %ebp,%rax
mov    0x8(%r14,%rax,8),%r13
mov    %r13,%rdi
lea    0xe96(%rip),%rsi
call   1050 <strcmp@plt>
test   %eax,%eax
je     11d0 <explode+0x90>
mov    %r13,%rdi
call   1030 <strlen@plt>
test   %rax,%rax
je     11e0 <explode+0xa0>
cmp    $0x8,%rax
jae    1230 <explode+0xf0>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1330 <explode+0x1f0>
nopl   0x0(%rax,%rax,1)
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     131b <explode+0x1db>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
movd   0x0(%r13,%rsi,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movd   0x4(%r13,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm2
psrad  $0x18,%xmm3
paddd  %xmm1,%xmm3
movd   0x8(%r13,%rsi,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0xc(%r13,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
paddd  %xmm2,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1260 <explode+0x120>
test   $0x1,%dl
je     12ff <explode+0x1bf>
movd   0x0(%r13,%rsi,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movd   0x4(%r13,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm2
paddd  %xmm2,%xmm0
psrad  $0x18,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
jmp    133c <explode+0x1fc>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    12cf <explode+0x18f>
jmp    12ff <explode+0x1bf>
nopl   0x0(%rax)
movsbl 0x0(%r13,%rcx,1),%esi
add    %esi,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1330 <explode+0x1f0>
add    $0xffffff37,%edx
cmp    $0x25,%edx
ja     11e0 <explode+0xa0>
movslq (%r12,%rdx,4),%rax
add    %r12,%rax
jmp    *%rax
movslq %ebp,%rbx
add    $0x2,%ebp
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    0xd32(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
add    %eax,%r15d
jmp    1471 <explode+0x331>
movslq %ebp,%rbx
add    $0x2,%ebp
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    0xcfc(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
mov    %eax,%ecx
mov    %r15d,%eax
cltd
idiv   %ecx
mov    %eax,%r15d
lea    0xcd1(%rip),%rdi
mov    %eax,%esi
jmp    147b <explode+0x33b>
movslq %ebp,%rbx
add    $0x2,%ebp
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    0xcb1(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
mov    %eax,%r15d
jmp    11f4 <explode+0xb4>
movslq %ebp,%rbx
add    $0x2,%ebp
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    0xc7f(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
sub    %eax,%r15d
jmp    1471 <explode+0x331>
movslq %ebp,%rbx
add    $0x2,%ebp
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
lea    0xc4c(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %eax,%eax
call   1060 <atoi@plt>
imul   %eax,%r15d
lea    0xc28(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    11f4 <explode+0xb4>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"MF$\00"
@.str.1 = [4 x i8] c"MF!\00"
@.str.2 = [4 x i8] c"%d\0A\00"
@.str.3 = [7 x i8] c"%d -> \00"
@.str.4 = [24 x i8] c"Invalid instruction %s\0A\00"
@.str.5 = [5 x i8] c"\0A%s\0A\00"
define i32 @explode(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %3
store i8** %1, i8*** %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 1, i32* %5
br label %9
9: ; preds = %181, %2
%10 = load i32, i32* %5
%11 = load i32, i32* %3
%12 = icmp slt i32 %10, %11
br i1 %12, label %13, label %184
13: ; preds = %9
%14 = load i8**, i8*** %4
%15 = load i32, i32* %5
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8*, i8** %14, i64 %16
%18 = load i8*, i8** %17
%19 = call i32 @strcmp(i8* %18, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%20 = icmp eq i32 %19, 0
br i1 %20, label %21, label %173
21: ; preds = %13
%22 = load i32, i32* %5
%23 = add nsw i32 %22, 1
store i32 %23, i32* %5
br label %24
24: ; preds = %169, %21
%25 = load i8**, i8*** %4
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8*, i8** %25, i64 %27
%29 = load i8*, i8** %28
%30 = call i32 @strcmp(i8* %29, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%31 = icmp ne i32 %30, 0
%32 = xor i1 %31, true
%33 = zext i1 %32 to i32
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %172
35: ; preds = %24
store i32 0, i32* %8
br label %36
36: ; preds = %59, %35
%37 = load i32, i32* %8
%38 = sext i32 %37 to i64
%39 = load i8**, i8*** %4
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8*, i8** %39, i64 %41
%43 = load i8*, i8** %42
%44 = call i64 @strlen(i8* %43)
%45 = icmp ult i64 %38, %44
br i1 %45, label %46, label %62
46: ; preds = %36
%47 = load i8**, i8*** %4
%48 = load i32, i32* %5
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8*, i8** %47, i64 %49
%51 = load i8*, i8** %50
%52 = load i32, i32* %8
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = load i32, i32* %6
%58 = add nsw i32 %57, %56
store i32 %58, i32* %6
br label %59
59: ; preds = %46
%60 = load i32, i32* %8
%61 = add nsw i32 %60, 1
store i32 %61, i32* %8
br label %36
62: ; preds = %36
%63 = load i32, i32* %6
switch i32 %63, label %160 [
i32 217, label %64
i32 201, label %80
i32 234, label %100
i32 238, label %120
i32 227, label %140
]
64: ; preds = %62
%65 = load i32, i32* %5
%66 = add nsw i32 %65, 1
store i32 %66, i32* %5
%67 = load i8**, i8*** %4
%68 = load i32, i32* %5
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8*, i8** %67, i64 %69
%71 = load i8*, i8** %70
%72 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %71)
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %72)
%74 = load i8**, i8*** %4
%75 = load i32, i32* %5
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8*, i8** %74, i64 %76
%78 = load i8*, i8** %77
%79 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %78)
store i32 %79, i32* %7
br label %169
80: ; preds = %62
%81 = load i32, i32* %5
%82 = add nsw i32 %81, 1
store i32 %82, i32* %5
%83 = load i8**, i8*** %4
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8*, i8** %83, i64 %85
%87 = load i8*, i8** %86
%88 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %87)
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %88)
%90 = load i8**, i8*** %4
%91 = load i32, i32* %5
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8*, i8** %90, i64 %92
%94 = load i8*, i8** %93
%95 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %94)
%96 = load i32, i32* %7
%97 = add nsw i32 %96, %95
store i32 %97, i32* %7
%98 = load i32, i32* %7
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %98)
br label %169
100: ; preds = %62
%101 = load i32, i32* %5
%102 = add nsw i32 %101, 1
store i32 %102, i32* %5
%103 = load i8**, i8*** %4
%104 = load i32, i32* %5
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8*, i8** %103, i64 %105
%107 = load i8*, i8** %106
%108 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %107)
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %108)
%110 = load i8**, i8*** %4
%111 = load i32, i32* %5
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8*, i8** %110, i64 %112
%114 = load i8*, i8** %113
%115 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %114)
%116 = load i32, i32* %7
%117 = sub nsw i32 %116, %115
store i32 %117, i32* %7
%118 = load i32, i32* %7
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %118)
br label %169
120: ; preds = %62
%121 = load i32, i32* %5
%122 = add nsw i32 %121, 1
store i32 %122, i32* %5
%123 = load i8**, i8*** %4
%124 = load i32, i32* %5
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8*, i8** %123, i64 %125
%127 = load i8*, i8** %126
%128 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %127)
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %128)
%130 = load i32, i32* %7
%131 = load i8**, i8*** %4
%132 = load i32, i32* %5
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8*, i8** %131, i64 %133
%135 = load i8*, i8** %134
%136 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %135)
%137 = mul nsw i32 %130, %136
store i32 %137, i32* %7
%138 = load i32, i32* %7
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %138)
br label %169
140: ; preds = %62
%141 = load i32, i32* %5
%142 = add nsw i32 %141, 1
store i32 %142, i32* %5
%143 = load i8**, i8*** %4
%144 = load i32, i32* %5
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8*, i8** %143, i64 %145
%147 = load i8*, i8** %146
%148 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %147)
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %148)
%150 = load i32, i32* %7
%151 = load i8**, i8*** %4
%152 = load i32, i32* %5
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8*, i8** %151, i64 %153
%155 = load i8*, i8** %154
%156 = call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %155)
%157 = sdiv i32 %150, %156
store i32 %157, i32* %7
%158 = load i32, i32* %7
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %158)
br label %169
160: ; preds = %62
%161 = load i8**, i8*** %4
%162 = load i32, i32* %5
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8*, i8** %161, i64 %163
%165 = load i8*, i8** %164
%166 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.4, i64 0, i64 0), i8* %165)
%167 = load i32, i32* %5
%168 = add nsw i32 %167, 1
store i32 %168, i32* %5
br label %169
169: ; preds = %160, %140, %120, %100, %80, %64
store i32 0, i32* %6
%170 = load i32, i32* %5
%171 = add nsw i32 %170, 1
store i32 %171, i32* %5
br label %24
172: ; preds = %24
br label %180
173: ; preds = %13
%174 = load i8**, i8*** %4
%175 = load i32, i32* %5
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8*, i8** %174, i64 %176
%178 = load i8*, i8** %177
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* %178)
br label %180
180: ; preds = %173, %172
br label %181
181: ; preds = %180
%182 = load i32, i32* %5
%183 = add nsw i32 %182, 1
store i32 %183, i32* %5
br label %9
184: ; preds = %9
%185 = load i32, i32* %5
ret i32 %185
}

LLVM IR (-O2):
@.str = [4 x i8] c"MF$\00"
@.str.1 = [4 x i8] c"MF!\00"
@.str.2 = [4 x i8] c"%d\0A\00"
@.str.3 = [7 x i8] c"%d -> \00"
@.str.4 = [24 x i8] c"Invalid instruction %s\0A\00"
@.str.5 = [5 x i8] c"\0A%s\0A\00"
define i32 @explode(i32 %0, i8** nocapture %1) {
%3 = icmp sgt i32 %0, 1
br i1 %3, label %4, label %175
4: ; preds = %2, %170
%5 = phi i32 [ %172, %170 ], [ 0, %2 ]
%6 = phi i32 [ %173, %170 ], [ 1, %2 ]
%7 = sext i32 %6 to i64
%8 = getelementptr inbounds i8*, i8** %1, i64 %7
%9 = load i8*, i8** %8
%10 = tail call i32 @strcmp(i8* dereferenceable(1) %9, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%11 = icmp eq i32 %10, 0
br i1 %11, label %12, label %168
12: ; preds = %4
%13 = add nsw i32 %6, 1
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i8*, i8** %1, i64 %14
%16 = load i8*, i8** %15
%17 = tail call i32 @strcmp(i8* dereferenceable(1) %16, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%18 = icmp eq i32 %17, 0
br i1 %18, label %170, label %19
19: ; preds = %12, %159
%20 = phi i8* [ %165, %159 ], [ %16, %12 ]
%21 = phi i32 [ %161, %159 ], [ %5, %12 ]
%22 = phi i32 [ %160, %159 ], [ %6, %12 ]
%23 = tail call i64 @strlen(i8* dereferenceable(1) %20)
%24 = icmp eq i64 %23, 0
br i1 %24, label %156, label %25
25: ; preds = %19
%26 = icmp ult i64 %23, 8
br i1 %26, label %89, label %27
27: ; preds = %25
%28 = and i64 %23, -8
%29 = add i64 %28, -8
%30 = lshr exact i64 %29, 3
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 1
%33 = icmp eq i64 %29, 0
br i1 %33, label %65, label %34
34: ; preds = %27
%35 = and i64 %31, 4611686018427387902
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %62, %36 ]
%38 = phi <4 x i32> [ zeroinitializer, %34 ], [ %60, %36 ]
%39 = phi <4 x i32> [ zeroinitializer, %34 ], [ %61, %36 ]
%40 = phi i64 [ 0, %34 ], [ %63, %36 ]
%41 = getelementptr inbounds i8, i8* %20, i64 %37
%42 = bitcast i8* %41 to <4 x i8>*
%43 = load <4 x i8>, <4 x i8>* %42
%44 = getelementptr inbounds i8, i8* %41, i64 4
%45 = bitcast i8* %44 to <4 x i8>*
%46 = load <4 x i8>, <4 x i8>* %45
%47 = sext <4 x i8> %43 to <4 x i32>
%48 = sext <4 x i8> %46 to <4 x i32>
%49 = add <4 x i32> %38, %47
%50 = add <4 x i32> %39, %48
%51 = or i64 %37, 8
%52 = getelementptr inbounds i8, i8* %20, i64 %51
%53 = bitcast i8* %52 to <4 x i8>*
%54 = load <4 x i8>, <4 x i8>* %53
%55 = getelementptr inbounds i8, i8* %52, i64 4
%56 = bitcast i8* %55 to <4 x i8>*
%57 = load <4 x i8>, <4 x i8>* %56
%58 = sext <4 x i8> %54 to <4 x i32>
%59 = sext <4 x i8> %57 to <4 x i32>
%60 = add <4 x i32> %49, %58
%61 = add <4 x i32> %50, %59
%62 = add nuw i64 %37, 16
%63 = add i64 %40, 2
%64 = icmp eq i64 %63, %35
br i1 %64, label %65, label %36
65: ; preds = %36, %27
%66 = phi <4 x i32> [ undef, %27 ], [ %60, %36 ]
%67 = phi <4 x i32> [ undef, %27 ], [ %61, %36 ]
%68 = phi i64 [ 0, %27 ], [ %62, %36 ]
%69 = phi <4 x i32> [ zeroinitializer, %27 ], [ %60, %36 ]
%70 = phi <4 x i32> [ zeroinitializer, %27 ], [ %61, %36 ]
%71 = icmp eq i64 %32, 0
br i1 %71, label %83, label %72
72: ; preds = %65
%73 = getelementptr inbounds i8, i8* %20, i64 %68
%74 = bitcast i8* %73 to <4 x i8>*
%75 = load <4 x i8>, <4 x i8>* %74
%76 = getelementptr inbounds i8, i8* %73, i64 4
%77 = bitcast i8* %76 to <4 x i8>*
%78 = load <4 x i8>, <4 x i8>* %77
%79 = sext <4 x i8> %75 to <4 x i32>
%80 = sext <4 x i8> %78 to <4 x i32>
%81 = add <4 x i32> %69, %79
%82 = add <4 x i32> %70, %80
br label %83
83: ; preds = %65, %72
%84 = phi <4 x i32> [ %66, %65 ], [ %81, %72 ]
%85 = phi <4 x i32> [ %67, %65 ], [ %82, %72 ]
%86 = add <4 x i32> %85, %84
%87 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %86)
%88 = icmp eq i64 %23, %28
br i1 %88, label %101, label %89
89: ; preds = %25, %83
%90 = phi i64 [ 0, %25 ], [ %28, %83 ]
%91 = phi i32 [ 0, %25 ], [ %87, %83 ]
br label %92
92: ; preds = %89, %92
%93 = phi i64 [ %99, %92 ], [ %90, %89 ]
%94 = phi i32 [ %98, %92 ], [ %91, %89 ]
%95 = getelementptr inbounds i8, i8* %20, i64 %93
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = add nsw i32 %94, %97
%99 = add nuw nsw i64 %93, 1
%100 = icmp eq i64 %99, %23
br i1 %100, label %101, label %92
101: ; preds = %92, %83
%102 = phi i32 [ %87, %83 ], [ %98, %92 ]
switch i32 %102, label %156 [
i32 217, label %103
i32 201, label %112
i32 234, label %123
i32 238, label %134
i32 227, label %145
]
103: ; preds = %101
%104 = add nsw i32 %22, 2
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8*, i8** %1, i64 %105
%107 = load i8*, i8** %106
%108 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %107)
%109 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %108)
%110 = load i8*, i8** %106
%111 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %110)
br label %159
112: ; preds = %101
%113 = add nsw i32 %22, 2
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8*, i8** %1, i64 %114
%116 = load i8*, i8** %115
%117 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %116)
%118 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %117)
%119 = load i8*, i8** %115
%120 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %119)
%121 = add nsw i32 %120, %21
%122 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %121)
br label %159
123: ; preds = %101
%124 = add nsw i32 %22, 2
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8*, i8** %1, i64 %125
%127 = load i8*, i8** %126
%128 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %127)
%129 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %128)
%130 = load i8*, i8** %126
%131 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %130)
%132 = sub nsw i32 %21, %131
%133 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %132)
br label %159
134: ; preds = %101
%135 = add nsw i32 %22, 2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8*, i8** %1, i64 %136
%138 = load i8*, i8** %137
%139 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %138)
%140 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %139)
%141 = load i8*, i8** %137
%142 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %141)
%143 = mul nsw i32 %142, %21
%144 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %143)
br label %159
145: ; preds = %101
%146 = add nsw i32 %22, 2
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i8*, i8** %1, i64 %147
%149 = load i8*, i8** %148
%150 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %149)
%151 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %150)
%152 = load i8*, i8** %148
%153 = tail call i32 (i8*, ...) bitcast (i32 (...)* @atoi to i32 (i8*, ...)*)(i8* %152)
%154 = sdiv i32 %21, %153
%155 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %154)
br label %159
156: ; preds = %19, %101
%157 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.4, i64 0, i64 0), i8* %20)
%158 = add nsw i32 %22, 2
br label %159
159: ; preds = %156, %145, %134, %123, %112, %103
%160 = phi i32 [ %158, %156 ], [ %146, %145 ], [ %135, %134 ], [ %124, %123 ], [ %113, %112 ], [ %104, %103 ]
%161 = phi i32 [ %21, %156 ], [ %154, %145 ], [ %143, %134 ], [ %132, %123 ], [ %121, %112 ], [ %111, %103 ]
%162 = add nsw i32 %160, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8*, i8** %1, i64 %163
%165 = load i8*, i8** %164
%166 = tail call i32 @strcmp(i8* dereferenceable(1) %165, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%167 = icmp eq i32 %166, 0
br i1 %167, label %170, label %19
168: ; preds = %4
%169 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* %9)
br label %170
170: ; preds = %159, %12, %168
%171 = phi i32 [ %6, %168 ], [ %13, %12 ], [ %162, %159 ]
%172 = phi i32 [ %5, %168 ], [ %5, %12 ], [ %161, %159 ]
%173 = add nsw i32 %171, 1
%174 = icmp slt i32 %173, %0
br i1 %174, label %4, label %175
175: ; preds = %170, %2
%176 = phi i32 [ 1, %2 ], [ %173, %170 ]
ret i32 %176
}