#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*/ iexit();
int /*<<< orphan*/ ireads(char *, int);
int /*<<< orphan*/ iwrites(char *);
int mdiv(int, int);
int /*<<< orphan*/ scompare(char *, char *);
int /*<<< orphan*/ sformati(char *, int);
int slength(char *);
int main() {
  char op[4];
  char num1[7];
  int num11 = 0;
  char num2[7];
  int num22 = 0;
  int len1;
  int len2;
  int i;
  int ans;
  char str[7];
  iwrites("add, sub, div, or mul?\n");
  ireads(op, 4);
  iwrites("\nfirst number?\n");
  ireads(num1, 7);
  iwrites("\nsecond number?\n");
  ireads(num2, 7);
  iwrites("\n");
  len1 = slength(num1);
  len2 = slength(num2);
  for (i = 0; i < len1; i++) {
    num11 = num11 * 10 + (num1[i] - '0');
  }
  for (i = 0; i < len2; i++) {
    num22 = num22 * 10 + (num2[i] - '0');
  }
  if (len1 == 0) {
    num11 = 0;
  }
  if (len2 == 0) {
    num22 = 0;
  }
  if (!scompare(op, "add")) {
    ans = num11 + num22;
  } else if (!scompare(op, "sub")) {
    ans = num11 - num22;
  } else if (!scompare(op, "mul")) {
    ans = num11 * num22;
  } else if (!scompare(op, "div")) {
    ans = mdiv(num11, num22);
  } else {
    iwrites("try again\n");
    iexit();
  }
  sformati(str, ans);
  iwrites(str);
  iwrites("\n");
  iexit();
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
lea    0xe6c(%rip),%rdi
call   1050 <iwrites@plt>
lea    -0x8(%rbp),%rdi
mov    $0x4,%esi
call   1030 <ireads@plt>
lea    0xe6a(%rip),%rdi
call   1050 <iwrites@plt>
lea    -0xf(%rbp),%rdi
mov    $0x7,%esi
call   1030 <ireads@plt>
lea    0xe60(%rip),%rdi
call   1050 <iwrites@plt>
lea    -0x1b(%rbp),%rdi
mov    $0x7,%esi
call   1030 <ireads@plt>
lea    0xe34(%rip),%rdi
call   1050 <iwrites@plt>
lea    -0xf(%rbp),%rdi
call   1080 <slength@plt>
mov    %eax,-0x24(%rbp)
lea    -0x1b(%rbp),%rdi
call   1080 <slength@plt>
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1235 <main+0xc5>
imul   $0xa,-0x14(%rbp),%eax
movslq -0x2c(%rbp),%rcx
movsbl -0xf(%rbp,%rcx,1),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1206 <main+0x96>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    126b <main+0xfb>
imul   $0xa,-0x20(%rbp),%eax
movslq -0x2c(%rbp),%rcx
movsbl -0x1b(%rbp,%rcx,1),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123c <main+0xcc>
cmpl   $0x0,-0x24(%rbp)
jne    127c <main+0x10c>
movl   $0x0,-0x14(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    128d <main+0x11d>
movl   $0x0,-0x20(%rbp)
lea    -0x8(%rbp),%rdi
lea    0xda1(%rip),%rsi
call   1040 <scompare@plt>
cmp    $0x0,%eax
jne    12b4 <main+0x144>
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1351 <main+0x1e1>
lea    -0x8(%rbp),%rdi
lea    0xd7e(%rip),%rsi
call   1040 <scompare@plt>
cmp    $0x0,%eax
jne    12db <main+0x16b>
mov    -0x14(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    134c <main+0x1dc>
lea    -0x8(%rbp),%rdi
lea    0xd5b(%rip),%rsi
call   1040 <scompare@plt>
cmp    $0x0,%eax
jne    1303 <main+0x193>
mov    -0x14(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1347 <main+0x1d7>
lea    -0x8(%rbp),%rdi
lea    0xd37(%rip),%rsi
call   1040 <scompare@plt>
cmp    $0x0,%eax
jne    132f <main+0x1bf>
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%esi
call   1090 <mdiv@plt>
mov    %eax,-0x30(%rbp)
jmp    1342 <main+0x1d2>
lea    0xd13(%rip),%rdi
call   1050 <iwrites@plt>
mov    $0x0,%al
call   1060 <iexit@plt>
jmp    1347 <main+0x1d7>
jmp    134c <main+0x1dc>
jmp    1351 <main+0x1e1>
lea    -0x37(%rbp),%rdi
mov    -0x30(%rbp),%esi
call   1070 <sformati@plt>
lea    -0x37(%rbp),%rdi
call   1050 <iwrites@plt>
lea    0xca9(%rip),%rdi
call   1050 <iwrites@plt>
mov    $0x0,%al
call   1060 <iexit@plt>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x28,%rsp
lea    0xe7f(%rip),%rdi
call   1050 <iwrites@plt>
lea    0xf(%rsp),%rdi
mov    $0x4,%esi
call   1030 <ireads@plt>
lea    0xe7c(%rip),%rdi
call   1050 <iwrites@plt>
lea    0x1a(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x7,%esi
call   1030 <ireads@plt>
lea    0xe6e(%rip),%rdi
call   1050 <iwrites@plt>
lea    0x13(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x7,%esi
call   1030 <ireads@plt>
lea    0xe3e(%rip),%rdi
call   1050 <iwrites@plt>
mov    %rbx,%rdi
call   1080 <slength@plt>
mov    %eax,%r15d
mov    %rbp,%rdi
call   1080 <slength@plt>
xor    %r14d,%r14d
mov    $0x0,%ebx
test   %r15d,%r15d
jle    1284 <main+0x114>
mov    %r15d,%esi
lea    -0x1(%rsi),%rdx
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1219 <main+0xa9>
xor    %edx,%edx
xor    %ebx,%ebx
jmp    125c <main+0xec>
and    $0xfffffffc,%esi
xor    %edx,%edx
xor    %ebx,%ebx
lea    (%rbx,%rbx,4),%edi
movsbl 0x1a(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x1b(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x1c(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x1d(%rsp,%rdx,1),%ebp
lea    -0xd050(%rbp,%rdi,2),%ebx
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1220 <main+0xb0>
test   %rcx,%rcx
je     1284 <main+0x114>
add    %rsp,%rdx
add    $0x1a,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%rbx,4),%edi
movsbl (%rdx,%rsi,1),%ebp
lea    -0x30(%rbp,%rdi,2),%ebx
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1270 <main+0x100>
test   %eax,%eax
jle    1316 <main+0x1a6>
mov    %eax,%esi
lea    -0x1(%rsi),%rdx
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    12a4 <main+0x134>
xor    %edx,%edx
xor    %r14d,%r14d
jmp    12ee <main+0x17e>
and    $0xfffffffc,%esi
xor    %edx,%edx
xor    %r14d,%r14d
nopl   0x0(%rax)
lea    (%r14,%r14,4),%edi
movsbl 0x13(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x14(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x15(%rsp,%rdx,1),%ebp
lea    0x0(%rbp,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x16(%rsp,%rdx,1),%ebp
lea    -0xd050(%rbp,%rdi,2),%r14d
ff
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    12b0 <main+0x140>
test   %rcx,%rcx
je     1316 <main+0x1a6>
add    %rsp,%rdx
add    $0x13,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
lea    (%r14,%r14,4),%edi
movsbl (%rdx,%rsi,1),%ebp
lea    -0x30(%rbp,%rdi,2),%r14d
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1300 <main+0x190>
test   %r15d,%r15d
cmove  %r15d,%ebx
test   %eax,%eax
cmove  %eax,%r14d
lea    0xd0f(%rip),%rsi
lea    0xf(%rsp),%rdi
call   1040 <scompare@plt>
test   %eax,%eax
je     1386 <main+0x216>
lea    0xcfe(%rip),%rsi
lea    0xf(%rsp),%rdi
call   1040 <scompare@plt>
test   %eax,%eax
je     138b <main+0x21b>
lea    0xced(%rip),%rsi
lea    0xf(%rsp),%rdi
call   1040 <scompare@plt>
test   %eax,%eax
je     1393 <main+0x223>
lea    0xcdc(%rip),%rsi
lea    0xf(%rsp),%rdi
call   1040 <scompare@plt>
test   %eax,%eax
jne    13cf <main+0x25f>
mov    %ebx,%edi
mov    %r14d,%esi
call   1090 <mdiv@plt>
mov    %eax,%r14d
jmp    1397 <main+0x227>
add    %ebx,%r14d
jmp    1397 <main+0x227>
sub    %r14d,%ebx
mov    %ebx,%r14d
jmp    1397 <main+0x227>
imul   %ebx,%r14d
lea    0x21(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14d,%esi
call   1070 <sformati@plt>
mov    %rbx,%rdi
call   1050 <iwrites@plt>
lea    0xc60(%rip),%rdi
call   1050 <iwrites@plt>
xor    %eax,%eax
call   1060 <iexit@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc73(%rip),%rdi
call   1050 <iwrites@plt>
xor    %eax,%eax
call   1060 <iexit@plt>

LLVM IR (-O0):
@.str = [24 x i8] c"add, sub, div, or mul?\0A\00"
@.str.1 = [16 x i8] c"\0Afirst number?\0A\00"
@.str.2 = [17 x i8] c"\0Asecond number?\0A\00"
@.str.3 = [2 x i8] c"\0A\00"
@.str.4 = [4 x i8] c"add\00"
@.str.5 = [4 x i8] c"sub\00"
@.str.6 = [4 x i8] c"mul\00"
@.str.7 = [4 x i8] c"div\00"
@.str.8 = [11 x i8] c"try again\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [4 x i8]
%3 = alloca [7 x i8]
%4 = alloca i32
%5 = alloca [7 x i8]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [7 x i8]
store i32 0, i32* %1
store i32 0, i32* %4
store i32 0, i32* %6
%12 = call i32 @iwrites(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0))
%13 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%14 = call i32 @ireads(i8* %13, i32 4)
%15 = call i32 @iwrites(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0))
%16 = getelementptr inbounds [7 x i8], [7 x i8]* %3, i64 0, i64 0
%17 = call i32 @ireads(i8* %16, i32 7)
%18 = call i32 @iwrites(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0))
%19 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 0
%20 = call i32 @ireads(i8* %19, i32 7)
%21 = call i32 @iwrites(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%22 = getelementptr inbounds [7 x i8], [7 x i8]* %3, i64 0, i64 0
%23 = call i32 @slength(i8* %22)
store i32 %23, i32* %7
%24 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 0
%25 = call i32 @slength(i8* %24)
store i32 %25, i32* %8
store i32 0, i32* %9
br label %26
26: ; preds = %40, %0
%27 = load i32, i32* %9
%28 = load i32, i32* %7
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %43
30: ; preds = %26
%31 = load i32, i32* %4
%32 = mul nsw i32 %31, 10
%33 = load i32, i32* %9
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [7 x i8], [7 x i8]* %3, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = sub nsw i32 %37, 48
%39 = add nsw i32 %32, %38
store i32 %39, i32* %4
br label %40
40: ; preds = %30
%41 = load i32, i32* %9
%42 = add nsw i32 %41, 1
store i32 %42, i32* %9
br label %26
43: ; preds = %26
store i32 0, i32* %9
br label %44
44: ; preds = %58, %43
%45 = load i32, i32* %9
%46 = load i32, i32* %8
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %61
48: ; preds = %44
%49 = load i32, i32* %6
%50 = mul nsw i32 %49, 10
%51 = load i32, i32* %9
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = sub nsw i32 %55, 48
%57 = add nsw i32 %50, %56
store i32 %57, i32* %6
br label %58
58: ; preds = %48
%59 = load i32, i32* %9
%60 = add nsw i32 %59, 1
store i32 %60, i32* %9
br label %44
61: ; preds = %44
%62 = load i32, i32* %7
%63 = icmp eq i32 %62, 0
br i1 %63, label %64, label %65
64: ; preds = %61
store i32 0, i32* %4
br label %65
65: ; preds = %64, %61
%66 = load i32, i32* %8
%67 = icmp eq i32 %66, 0
br i1 %67, label %68, label %69
68: ; preds = %65
store i32 0, i32* %6
br label %69
69: ; preds = %68, %65
%70 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%71 = call i32 @scompare(i8* %70, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
%72 = icmp ne i32 %71, 0
br i1 %72, label %77, label %73
73: ; preds = %69
%74 = load i32, i32* %4
%75 = load i32, i32* %6
%76 = add nsw i32 %74, %75
store i32 %76, i32* %10
br label %107
77: ; preds = %69
%78 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%79 = call i32 @scompare(i8* %78, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%80 = icmp ne i32 %79, 0
br i1 %80, label %85, label %81
81: ; preds = %77
%82 = load i32, i32* %4
%83 = load i32, i32* %6
%84 = sub nsw i32 %82, %83
store i32 %84, i32* %10
br label %106
85: ; preds = %77
%86 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%87 = call i32 @scompare(i8* %86, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%88 = icmp ne i32 %87, 0
br i1 %88, label %93, label %89
89: ; preds = %85
%90 = load i32, i32* %4
%91 = load i32, i32* %6
%92 = mul nsw i32 %90, %91
store i32 %92, i32* %10
br label %105
93: ; preds = %85
%94 = getelementptr inbounds [4 x i8], [4 x i8]* %2, i64 0, i64 0
%95 = call i32 @scompare(i8* %94, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%96 = icmp ne i32 %95, 0
br i1 %96, label %101, label %97
97: ; preds = %93
%98 = load i32, i32* %4
%99 = load i32, i32* %6
%100 = call i32 @mdiv(i32 %98, i32 %99)
store i32 %100, i32* %10
br label %104
101: ; preds = %93
%102 = call i32 @iwrites(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0))
%103 = call i32 (...) @iexit()
br label %104
104: ; preds = %101, %97
br label %105
105: ; preds = %104, %89
br label %106
106: ; preds = %105, %81
br label %107
107: ; preds = %106, %73
%108 = getelementptr inbounds [7 x i8], [7 x i8]* %11, i64 0, i64 0
%109 = load i32, i32* %10
%110 = call i32 @sformati(i8* %108, i32 %109)
%111 = getelementptr inbounds [7 x i8], [7 x i8]* %11, i64 0, i64 0
%112 = call i32 @iwrites(i8* %111)
%113 = call i32 @iwrites(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%114 = call i32 (...) @iexit()
%115 = load i32, i32* %1
ret i32 %115
}

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