#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*/ printf(char *, ...);
int main() {
  int i, s, sign[10];
  long n, x;
  for (i = 1; i <= 9; i++)
    sign[i] = -1;
  do {
    x = n = 0;
    s = 1;
    for (i = 1; i <= 9; i++)
      if (sign[i] == 0)
        n = 10 * n + i;
      else {
        x += s * n;
        s = sign[i];
        n = i;
      }
    x += s * n;
    if (x == 100) {
      for (i = 1; i <= 9; i++) {
        if (sign[i] == 1)
          printf(" + ");
        else if (sign[i] == -1)
          printf(" - ");
        printf("%10d", i);
      }
      printf(" = 100\n");
    }
    i = 9;
    s = sign[i] + 1;
    while (s > 1) {
      sign[i] = -1;
      i--;
      s = sign[i] + 1;
    }
    sign[i] = s;
  } while (sign[1] < 1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jg     114a <main+0x3a>
movslq -0x8(%rbp),%rax
movl   $0xffffffff,-0x40(%rbp,%rax,4)
ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1126 <main+0x16>
jmp    114f <main+0x3f>
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movl   $0x1,-0xc(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jg     11d2 <main+0xc2>
movslq -0x8(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
jne    119b <main+0x8b>
imul   $0xa,-0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    11bf <main+0xaf>
movslq -0xc(%rbp),%rax
imul   -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
movslq -0x8(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0xc(%rbp)
movslq -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    11c4 <main+0xb4>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    116d <main+0x5d>
movslq -0xc(%rbp),%rax
imul   -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x64,-0x50(%rbp)
jne    1270 <main+0x160>
movl   $0x1,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jg     1262 <main+0x152>
movslq -0x8(%rbp),%rax
cmpl   $0x1,-0x40(%rbp,%rax,4)
jne    1221 <main+0x111>
lea    0xdeb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1243 <main+0x133>
movslq -0x8(%rbp),%rax
cmpl   $0xffffffff,-0x40(%rbp,%rax,4)
jne    123e <main+0x12e>
lea    0xdcd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1243 <main+0x133>
mov    -0x8(%rbp),%esi
lea    0xdbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11f5 <main+0xe5>
lea    0xda4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x9,-0x8(%rbp)
movslq -0x8(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jle    12b7 <main+0x1a7>
movslq -0x8(%rbp),%rax
movl   $0xffffffff,-0x40(%rbp,%rax,4)
ff
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1285 <main+0x175>
mov    -0xc(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
cmpl   $0x1,-0x3c(%rbp)
jl     114f <main+0x3f>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
pcmpeqd %xmm0,%xmm0
movdqu %xmm0,0x24(%rsp)
movdqu %xmm0,0x14(%rsp)
movl   $0xffffffff,0x34(%rsp)
ff
mov    $0xffffffff,%eax
mov    $0x1,%r8d
mov    $0xc,%r9d
jmp    1177 <main+0x57>
nopl   0x0(%rax)
add    $0x1,%r15d
cltq
mov    %r15d,0x10(%rsp,%rax,4)
mov    0x14(%rsp),%eax
test   %eax,%eax
jg     150b <main+0x3eb>
test   %eax,%eax
mov    %eax,%ecx
cmove  %r8d,%ecx
mov    0x18(%rsp),%r13d
test   %r13d,%r13d
mov    %r13d,%edx
cmove  %ecx,%edx
mov    0x1c(%rsp),%r14d
mov    $0x2,%esi
cmove  %r9,%rsi
cmove  %r13d,%ecx
movslq %ecx,%rcx
test   %r14d,%r14d
je     11c0 <main+0xa0>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x3,%esi
mov    %r14d,%edx
jmp    11cb <main+0xab>
nopl   0x0(%rax,%rax,1)
add    %rsi,%rsi
lea    (%rsi,%rsi,4),%rsi
or     $0x3,%rsi
mov    0x20(%rsp),%r12d
test   %r12d,%r12d
je     11f0 <main+0xd0>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x4,%esi
mov    %r12d,%edx
jmp    11fb <main+0xdb>
nopl   0x0(%rax)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x4,%rsi
mov    0x24(%rsp),%r10d
test   %r10d,%r10d
je     1220 <main+0x100>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x5,%esi
mov    %r10d,%edx
jmp    122b <main+0x10b>
nopl   0x0(%rax)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x5,%rsi
mov    0x28(%rsp),%ebp
test   %ebp,%ebp
je     1250 <main+0x130>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x6,%esi
mov    %ebp,%edx
jmp    125b <main+0x13b>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x6,%rsi
mov    0x2c(%rsp),%ebx
test   %ebx,%ebx
je     1280 <main+0x160>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x7,%esi
mov    %ebx,%edx
jmp    128b <main+0x16b>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x7,%rsi
mov    0x30(%rsp),%edi
test   %edi,%edi
je     12b0 <main+0x190>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x8,%esi
mov    %edi,%edx
jmp    12bb <main+0x19b>
cs nopw 0x0(%rax,%rax,1)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x8,%rsi
mov    0x34(%rsp),%r15d
test   %r15d,%r15d
je     12e0 <main+0x1c0>
movslq %edx,%rdx
imul   %rdx,%rsi
add    %rsi,%rcx
mov    $0x9,%esi
mov    %r15d,%edx
jmp    12eb <main+0x1cb>
nopl   0x0(%rax)
lea    (%rsi,%rsi,4),%rsi
add    %rsi,%rsi
add    $0x9,%rsi
movslq %edx,%rdx
imul   %rsi,%rdx
add    %rcx,%rdx
cmp    $0x64,%rdx
jne    14d5 <main+0x3b5>
mov    %r10d,0x4(%rsp)
mov    %ebp,0x8(%rsp)
mov    %edi,0xc(%rsp)
cmp    $0xffffffff,%eax
jne    131f <main+0x1ff>
lea    0xcec(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xce2(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xccb(%rip),%rdi
cmp    $0xffffffff,%r13d
je     134c <main+0x22c>
cmp    $0x1,%r13d
jne    1353 <main+0x233>
lea    0xcb4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xcae(%rip),%rbp
mov    %rbp,%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc94(%rip),%rdi
cmp    $0xffffffff,%r14d
je     1383 <main+0x263>
cmp    $0x1,%r14d
jne    138a <main+0x26a>
lea    0xc7d(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc64(%rip),%rdi
cmp    $0xffffffff,%r12d
je     13b3 <main+0x293>
cmp    $0x1,%r12d
jne    13ba <main+0x29a>
lea    0xc4d(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc34(%rip),%rdi
mov    0x4(%rsp),%eax
cmp    $0xffffffff,%eax
je     13e5 <main+0x2c5>
cmp    $0x1,%eax
jne    13ec <main+0x2cc>
lea    0xc1b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc02(%rip),%rdi
mov    0x8(%rsp),%eax
cmp    $0xffffffff,%eax
je     1417 <main+0x2f7>
cmp    $0x1,%eax
jne    141e <main+0x2fe>
lea    0xbe9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xbd0(%rip),%rdi
cmp    $0xffffffff,%ebx
je     1445 <main+0x325>
cmp    $0x1,%ebx
jne    144c <main+0x32c>
lea    0xbbb(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xba2(%rip),%rdi
mov    0xc(%rsp),%eax
cmp    $0xffffffff,%eax
je     1477 <main+0x357>
cmp    $0x1,%eax
jne    147e <main+0x35e>
lea    0xb89(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb70(%rip),%rdi
cmp    $0xffffffff,%r15d
je     14a7 <main+0x387>
cmp    $0x1,%r15d
jne    14ae <main+0x38e>
lea    0xb59(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb49(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%r8d
mov    $0xc,%r9d
mov    $0x9,%eax
test   %r15d,%r15d
jle    1160 <main+0x40>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0xffffffff,0x10(%rsp,%rax,4)
ff
mov    0xc(%rsp,%rax,4),%r15d
add    $0xffffffffffffffff,%rax
test   %r15d,%r15d
jg     14f0 <main+0x3d0>
jmp    1160 <main+0x40>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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