#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 */
char getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main(void) {
  int numbers[3];
  char operator;
  int operation;
  do {
    operator= '\n';
    printf("Add(+), Subtract(-), Multiply(*), Divide(/), or Quit(q):");
    do {
      operator= getchar();
    } while (operator== '\n');
    if (operator== '\n')
      printf("warning: char c contains a newline\n");
    if (operator== '+')
      printf("\nyou said you would like to add:\n");
    if (operator== '-')
      printf("\nyou said you would like to subtract:\n");
    if (operator== '*')
      printf("\nyou said you would like to multiply:\n");
    if (operator== '/')
      printf("\nyou said you would like to divide:\n");
    if ((operator== '+') || (operator== '-') || (operator== '*') ||
        (operator== '/')) {
      printf("enter first number:");
      scanf("%9d", &numbers[1]);
      printf("enter second number:");
      scanf("%9d", &numbers[2]);
    }
    if (operator== '+') {
      operation = (numbers[1] + numbers[2]);
      printf("%d\n+\n%d\n=\n%d\n\n", numbers[1], numbers[2], operation);
    } else if (operator== '-') {
      operation = (numbers[1] - numbers[2]);
      printf("%d\n-\n%d\n=\n%d\n\n", numbers[1], numbers[2], operation);
    } else if (operator== '*') {
      operation = (numbers[1] * numbers[2]);
      printf("%d\n*\n%d\n=\n%d\n\n", numbers[1], numbers[2], operation);
    } else if (operator== '/') {
      while (numbers[2] == 0) {
        printf("Cannot divide by 0. Please enter new number to divide by:");
        scanf("%9d", &numbers[2]);
      }
      operation = (numbers[1] / numbers[2]);
      printf("%d\n/\n%d\n=\n%d\n\n", numbers[1], numbers[2], operation);
    }
  } while (operator!= 'q');
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
movb   $0xa,-0x11(%rbp)
lea    0xeb6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <getchar@plt>
mov    %al,-0x11(%rbp)
movsbl -0x11(%rbp),%eax
cmp    $0xa,%eax
je     1151 <main+0x21>
movsbl -0x11(%rbp),%eax
cmp    $0xa,%eax
jne    1183 <main+0x53>
lea    0xebd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2b,%eax
jne    119e <main+0x6e>
lea    0xec6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2d,%eax
jne    11b9 <main+0x89>
lea    0xecd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2a,%eax
jne    11d4 <main+0xa4>
lea    0xed9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2f,%eax
jne    11ef <main+0xbf>
lea    0xee5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2b,%eax
je     1223 <main+0xf3>
movsbl -0x11(%rbp),%eax
cmp    $0x2d,%eax
je     1223 <main+0xf3>
movsbl -0x11(%rbp),%eax
cmp    $0x2a,%eax
je     1223 <main+0xf3>
movsbl -0x11(%rbp),%eax
cmp    $0x2f,%eax
jne    1267 <main+0x137>
lea    0xec8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x10(%rbp),%rsi
add    $0x4,%rsi
lea    0xec6(%rip),%rdi
call   1050 <scanf@plt>
lea    0xebe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x10(%rbp),%rsi
add    $0x8,%rsi
lea    0xea4(%rip),%rdi
call   1050 <scanf@plt>
movsbl -0x11(%rbp),%eax
cmp    $0x2b,%eax
jne    1299 <main+0x169>
mov    -0xc(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x18(%rbp),%ecx
lea    0xe92(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1371 <main+0x241>
movsbl -0x11(%rbp),%eax
cmp    $0x2d,%eax
jne    12cb <main+0x19b>
mov    -0xc(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x18(%rbp),%ecx
lea    0xe6f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    136c <main+0x23c>
movsbl -0x11(%rbp),%eax
cmp    $0x2a,%eax
jne    12fe <main+0x1ce>
mov    -0xc(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x18(%rbp),%ecx
lea    0xe4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1367 <main+0x237>
movsbl -0x11(%rbp),%eax
cmp    $0x2f,%eax
jne    1362 <main+0x232>
jmp    1310 <main+0x1e0>
cmpl   $0x0,-0x8(%rbp)
jne    1341 <main+0x211>
lea    0xe2b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x10(%rbp),%rsi
add    $0x8,%rsi
lea    0xdcf(%rip),%rdi
call   1050 <scanf@plt>
jmp    1310 <main+0x1e0>
mov    -0xc(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x18(%rbp),%ecx
lea    0xe2b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1367 <main+0x237>
jmp    136c <main+0x23c>
jmp    1371 <main+0x241>
jmp    1376 <main+0x246>
movsbl -0x11(%rbp),%eax
cmp    $0x71,%eax
jne    113f <main+0xf>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
jmp    1173 <main+0x33>
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%edx
lea    (%rdx,%rsi,1),%ecx
lea    0xf1c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmp    $0x71,%r14b
je     130a <main+0x1ca>
lea    0xe9e(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1050 <getchar@plt>
cmp    $0xa,%al
je     1190 <main+0x50>
mov    %eax,%r14d
cmp    $0x2b,%al
jne    1230 <main+0xf0>
xor    %ebx,%ebx
lea    0xfb5(%rip),%rdi
xor    %r15d,%r15d
xor    %r12d,%r12d
call   1030 <puts@plt>
mov    %r15d,%r13d
mov    %r12d,%ecx
mov    %ecx,%r12d
mov    %ebx,%r15d
lea    0xe84(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe8a(%rip),%rbx
mov    %rbx,%rdi
lea    0x10(%rsp),%rsi
call   1060 <scanf@plt>
lea    0xe7a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    0x14(%rsp),%rbp
mov    %rbp,%rsi
call   1060 <scanf@plt>
cmp    $0x2b,%r14b
je     1150 <main+0x10>
test   %r13b,%r13b
je     1280 <main+0x140>
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%edx
mov    %esi,%ecx
sub    %edx,%ecx
lea    0xe65(%rip),%rdi
jmp    1162 <main+0x22>
nopl   (%rax)
lea    -0x2a(%r14),%eax
cmp    $0x5,%al
ja     1169 <main+0x29>
mov    $0x1,%r15b
xor    %ebx,%ebx
movzbl %al,%eax
lea    0xdb5(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
lea    0xee5(%rip),%rdi
xor    %r12d,%r12d
xor    %r13d,%r13d
xor    %ecx,%ecx
jmp    *%rax
mov    $0x1,%bl
xor    %r15d,%r15d
lea    0xea9(%rip),%rdi
jmp    11b2 <main+0x72>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r15b,%r15b
je     129e <main+0x15e>
mov    0x10(%rsp),%esi
mov    0x14(%rsp),%edx
mov    %edx,%ecx
imul   %esi,%ecx
lea    0xe03(%rip),%rdi
jmp    1162 <main+0x22>
test   %r12b,%r12b
je     1169 <main+0x29>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
lea    0xdf7(%rip),%r15
jne    12dd <main+0x19d>
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1060 <scanf@plt>
mov    0x14(%rsp),%ecx
test   %ecx,%ecx
je     12c0 <main+0x180>
mov    0x10(%rsp),%esi
mov    %esi,%eax
cltd
idiv   %ecx
lea    0xdf8(%rip),%rdi
mov    %ecx,%edx
mov    %eax,%ecx
jmp    1162 <main+0x22>
mov    $0x1,%r12b
xor    %ebx,%ebx
lea    0xdf2(%rip),%rdi
xor    %r15d,%r15d
jmp    11b5 <main+0x75>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [57 x i8] c"Add(+), Subtract(-), Multiply(*), Divide(/), or Quit(q):\00"
@.str.1 = [36 x i8] c"warning: char c contains a newline\0A\00"
@.str.2 = [34 x i8] c"\0Ayou said you would like to add:\0A\00"
@.str.3 = [39 x i8] c"\0Ayou said you would like to subtract:\0A\00"
@.str.4 = [39 x i8] c"\0Ayou said you would like to multiply:\0A\00"
@.str.5 = [37 x i8] c"\0Ayou said you would like to divide:\0A\00"
@.str.6 = [20 x i8] c"enter first number:\00"
@.str.7 = [4 x i8] c"%9d\00"
@.str.8 = [21 x i8] c"enter second number:\00"
@.str.9 = [15 x i8] c"%d\0A+\0A%d\0A=\0A%d\0A\0A\00"
@.str.10 = [15 x i8] c"%d\0A-\0A%d\0A=\0A%d\0A\0A\00"
@.str.11 = [15 x i8] c"%d\0A*\0A%d\0A=\0A%d\0A\0A\00"
@.str.12 = [58 x i8] c"Cannot divide by 0. Please enter new number to divide by:\00"
@.str.13 = [15 x i8] c"%d\0A/\0A%d\0A=\0A%d\0A\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [3 x i32]
%3 = alloca i8
%4 = alloca i32
store i32 0, i32* %1
br label %5
5: ; preds = %143, %0
store i8 10, i8* %3
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
br label %7
7: ; preds = %9, %5
%8 = call signext i8 (...) @getchar()
store i8 %8, i8* %3
br label %9
9: ; preds = %7
%10 = load i8, i8* %3
%11 = sext i8 %10 to i32
%12 = icmp eq i32 %11, 10
br i1 %12, label %7, label %13
13: ; preds = %9
%14 = load i8, i8* %3
%15 = sext i8 %14 to i32
%16 = icmp eq i32 %15, 10
br i1 %16, label %17, label %19
17: ; preds = %13
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
br label %19
19: ; preds = %17, %13
%20 = load i8, i8* %3
%21 = sext i8 %20 to i32
%22 = icmp eq i32 %21, 43
br i1 %22, label %23, label %25
23: ; preds = %19
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.2, i64 0, i64 0))
br label %25
25: ; preds = %23, %19
%26 = load i8, i8* %3
%27 = sext i8 %26 to i32
%28 = icmp eq i32 %27, 45
br i1 %28, label %29, label %31
29: ; preds = %25
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.3, i64 0, i64 0))
br label %31
31: ; preds = %29, %25
%32 = load i8, i8* %3
%33 = sext i8 %32 to i32
%34 = icmp eq i32 %33, 42
br i1 %34, label %35, label %37
35: ; preds = %31
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0))
br label %37
37: ; preds = %35, %31
%38 = load i8, i8* %3
%39 = sext i8 %38 to i32
%40 = icmp eq i32 %39, 47
br i1 %40, label %41, label %43
41: ; preds = %37
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.5, i64 0, i64 0))
br label %43
43: ; preds = %41, %37
%44 = load i8, i8* %3
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 43
br i1 %46, label %59, label %47
47: ; preds = %43
%48 = load i8, i8* %3
%49 = sext i8 %48 to i32
%50 = icmp eq i32 %49, 45
br i1 %50, label %59, label %51
51: ; preds = %47
%52 = load i8, i8* %3
%53 = sext i8 %52 to i32
%54 = icmp eq i32 %53, 42
br i1 %54, label %59, label %55
55: ; preds = %51
%56 = load i8, i8* %3
%57 = sext i8 %56 to i32
%58 = icmp eq i32 %57, 47
br i1 %58, label %59, label %66
59: ; preds = %55, %51, %47, %43
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.6, i64 0, i64 0))
%61 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%62 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %61)
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0))
%64 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%65 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %64)
br label %66
66: ; preds = %59, %55
%67 = load i8, i8* %3
%68 = sext i8 %67 to i32
%69 = icmp eq i32 %68, 43
br i1 %69, label %70, label %82
70: ; preds = %66
%71 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%72 = load i32, i32* %71
%73 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%74 = load i32, i32* %73
%75 = add nsw i32 %72, %74
store i32 %75, i32* %4
%76 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%77 = load i32, i32* %76
%78 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%79 = load i32, i32* %78
%80 = load i32, i32* %4
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), i32 %77, i32 %79, i32 %80)
br label %142
82: ; preds = %66
%83 = load i8, i8* %3
%84 = sext i8 %83 to i32
%85 = icmp eq i32 %84, 45
br i1 %85, label %86, label %98
86: ; preds = %82
%87 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%88 = load i32, i32* %87
%89 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%90 = load i32, i32* %89
%91 = sub nsw i32 %88, %90
store i32 %91, i32* %4
%92 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%93 = load i32, i32* %92
%94 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%95 = load i32, i32* %94
%96 = load i32, i32* %4
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), i32 %93, i32 %95, i32 %96)
br label %141
98: ; preds = %82
%99 = load i8, i8* %3
%100 = sext i8 %99 to i32
%101 = icmp eq i32 %100, 42
br i1 %101, label %102, label %114
102: ; preds = %98
%103 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%104 = load i32, i32* %103
%105 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%106 = load i32, i32* %105
%107 = mul nsw i32 %104, %106
store i32 %107, i32* %4
%108 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%109 = load i32, i32* %108
%110 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%111 = load i32, i32* %110
%112 = load i32, i32* %4
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.11, i64 0, i64 0), i32 %109, i32 %111, i32 %112)
br label %140
114: ; preds = %98
%115 = load i8, i8* %3
%116 = sext i8 %115 to i32
%117 = icmp eq i32 %116, 47
br i1 %117, label %118, label %139
118: ; preds = %114
br label %119
119: ; preds = %123, %118
%120 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%121 = load i32, i32* %120
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %127
123: ; preds = %119
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
%125 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%126 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %125)
br label %119
127: ; preds = %119
%128 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%129 = load i32, i32* %128
%130 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%131 = load i32, i32* %130
%132 = sdiv i32 %129, %131
store i32 %132, i32* %4
%133 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 1
%134 = load i32, i32* %133
%135 = getelementptr inbounds [3 x i32], [3 x i32]* %2, i64 0, i64 2
%136 = load i32, i32* %135
%137 = load i32, i32* %4
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.13, i64 0, i64 0), i32 %134, i32 %136, i32 %137)
br label %139
139: ; preds = %127, %114
br label %140
140: ; preds = %139, %102
br label %141
141: ; preds = %140, %86
br label %142
142: ; preds = %141, %70
br label %143
143: ; preds = %142
%144 = load i8, i8* %3
%145 = sext i8 %144 to i32
%146 = icmp ne i32 %145, 113
br i1 %146, label %5, label %147
147: ; preds = %143
ret i32 0
}

LLVM IR (-O2):
@.str = [57 x i8] c"Add(+), Subtract(-), Multiply(*), Divide(/), or Quit(q):\00"
@.str.6 = [20 x i8] c"enter first number:\00"
@.str.7 = [4 x i8] c"%9d\00"
@.str.8 = [21 x i8] c"enter second number:\00"
@.str.9 = [15 x i8] c"%d\0A+\0A%d\0A=\0A%d\0A\0A\00"
@.str.10 = [15 x i8] c"%d\0A-\0A%d\0A=\0A%d\0A\0A\00"
@.str.11 = [15 x i8] c"%d\0A*\0A%d\0A=\0A%d\0A\0A\00"
@.str.12 = [58 x i8] c"Cannot divide by 0. Please enter new number to divide by:\00"
@.str.13 = [15 x i8] c"%d\0A/\0A%d\0A=\0A%d\0A\0A\00"
@str = [36 x i8] c"\0Ayou said you would like to divide:\00"
@str.14 = [38 x i8] c"\0Ayou said you would like to multiply:\00"
@str.15 = [38 x i8] c"\0Ayou said you would like to subtract:\00"
@str.16 = [33 x i8] c"\0Ayou said you would like to add:\00"
define i32 @main() {
%1 = alloca [3 x i32]
%2 = bitcast [3 x i32]* %1 to i8*
%3 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i64 0, i64 1
%4 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i64 0, i64 2
br label %5
5: ; preds = %62, %0
%6 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
br label %7
7: ; preds = %7, %5
%8 = call signext i8 (...) @getchar()
%9 = icmp eq i8 %8, 10
br i1 %9, label %7, label %10
10: ; preds = %7
%11 = icmp eq i8 %8, 43
br i1 %11, label %15, label %12
12: ; preds = %10
switch i8 %8, label %62 [
i8 45, label %15
i8 42, label %13
i8 47, label %14
i8 43, label %21
i8 113, label %63
]
13: ; preds = %12
br label %15
14: ; preds = %12
br label %15
15: ; preds = %12, %10, %14, %13
%16 = phi i8* [ getelementptr inbounds ([38 x i8], [38 x i8]* @str.14, i64 0, i64 0), %13 ], [ getelementptr inbounds ([36 x i8], [36 x i8]* @str, i64 0, i64 0), %14 ], [ getelementptr inbounds ([33 x i8], [33 x i8]* @str.16, i64 0, i64 0), %10 ], [ getelementptr inbounds ([38 x i8], [38 x i8]* @str.15, i64 0, i64 0), %12 ]
%17 = phi i1 [ true, %13 ], [ false, %14 ], [ false, %10 ], [ false, %12 ]
%18 = phi i1 [ false, %13 ], [ false, %14 ], [ false, %10 ], [ true, %12 ]
%19 = phi i1 [ false, %13 ], [ true, %14 ], [ false, %10 ], [ false, %12 ]
%20 = call i32 @puts(i8* dereferenceable(1) %16)
br label %21
21: ; preds = %12, %15
%22 = phi i1 [ false, %12 ], [ %17, %15 ]
%23 = phi i1 [ false, %12 ], [ %18, %15 ]
%24 = phi i1 [ false, %12 ], [ %19, %15 ]
%25 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.6, i64 0, i64 0))
%26 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %3)
%27 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.8, i64 0, i64 0))
%28 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %4)
br i1 %11, label %29, label %34
29: ; preds = %21
%30 = load i32, i32* %3
%31 = load i32, i32* %4
%32 = add nsw i32 %31, %30
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0), i32 %30, i32 %31, i32 %32)
br label %60
34: ; preds = %21
br i1 %23, label %35, label %40
35: ; preds = %34
%36 = load i32, i32* %3
%37 = load i32, i32* %4
%38 = sub nsw i32 %36, %37
%39 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), i32 %36, i32 %37, i32 %38)
br label %60
40: ; preds = %34
br i1 %22, label %41, label %46
41: ; preds = %40
%42 = load i32, i32* %3
%43 = load i32, i32* %4
%44 = mul nsw i32 %43, %42
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.11, i64 0, i64 0), i32 %42, i32 %43, i32 %44)
br label %60
46: ; preds = %40
br i1 %24, label %47, label %60
47: ; preds = %46
%48 = load i32, i32* %4
%49 = icmp eq i32 %48, 0
br i1 %49, label %50, label %55
50: ; preds = %47, %50
%51 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @.str.12, i64 0, i64 0))
%52 = call i32 @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32* %4)
%53 = load i32, i32* %4
%54 = icmp eq i32 %53, 0
br i1 %54, label %50, label %55
55: ; preds = %50, %47
%56 = phi i32 [ %48, %47 ], [ %53, %50 ]
%57 = load i32, i32* %3
%58 = sdiv i32 %57, %56
%59 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.13, i64 0, i64 0), i32 %57, i32 %56, i32 %58)
br label %60
60: ; preds = %29, %41, %55, %46, %35
%61 = icmp eq i8 %8, 113
br i1 %61, label %63, label %62
62: ; preds = %60, %12
br label %5
63: ; preds = %12, %60
ret i32 0
}