#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 /*<<< orphan*/ scanf(char *, int *);
int main() {
  int n, c, array[10], i, check = 0, copy;
  printf("Enter number:");
  scanf("%d", &n);
  copy = n;
  for (i = 0; copy > 0; i++)
    copy /= 10;
  for (; i > 0; i--)
    c = c * 10;
  i = c;
  if (n / i == 0)
    printf(
        "Numbers don't start with 0. \nNote: these zeros will be ommited.\n\n");
  for (i = 0; i < 10; i++)
    array[i] = 0;
  while (n != 0) {
    c = n % 10;
    array[c]++;
    n /= 10;
  }
  for (i = 0; i < 10; i++)
    if (array[i] != 0)
      printf("%d: %d\n", i, array[i]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x48(%rbp)
lea    0xec3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xec3(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jle    1187 <main+0x67>
mov    -0x4c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1161 <main+0x41>
jmp    118c <main+0x6c>
cmpl   $0x0,-0x44(%rbp)
jle    11ab <main+0x8b>
imul   $0xa,-0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    118c <main+0x6c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%eax
cltd
idivl  -0x44(%rbp)
cmp    $0x0,%eax
jne    11cf <main+0xaf>
lea    0xe49(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x44(%rbp)
cmpl   $0xa,-0x44(%rbp)
jge    11fa <main+0xda>
movslq -0x44(%rbp),%rax
movl   $0x0,-0x40(%rbp,%rax,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11d6 <main+0xb6>
jmp    11ff <main+0xdf>
cmpl   $0x0,-0x8(%rbp)
je     1239 <main+0x119>
mov    -0x8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0xc(%rbp)
movslq -0xc(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x8(%rbp)
jmp    11ff <main+0xdf>
movl   $0x0,-0x44(%rbp)
cmpl   $0xa,-0x44(%rbp)
jge    1285 <main+0x165>
movslq -0x44(%rbp),%rax
cmpl   $0x0,-0x40(%rbp,%rax,4)
je     1272 <main+0x152>
mov    -0x44(%rbp),%esi
movslq -0x44(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%edx
lea    0xde8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1277 <main+0x157>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1240 <main+0x120>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x40,%rsp
lea    0xf04(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xf02(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1050 <scanf@plt>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    119b <main+0x6b>
mov    $0xcccccccd,%edx
mov    %ecx,%esi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %esi,%edi
imul   %rdx,%rdi
shr    $0x23,%rdi
add    $0x1,%eax
add    $0xffffffff,%ebx
cmp    $0x9,%esi
mov    %edi,%esi
ja     1170 <main+0x40>
mov    %ebx,%r9d
neg    %r9d
mov    %ebx,%esi
not    %esi
cmp    $0x7,%esi
jae    11a0 <main+0x70>
jmp    12c6 <main+0x196>
jmp    12df <main+0x1af>
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%edi
mov    %edi,%esi
shr    $0x3,%esi
add    $0x1,%esi
cmp    $0x38,%edi
jae    11ca <main+0x9a>
movdqa 0xe40(%rip),%xmm0
movdqa 0xe48(%rip),%xmm1
jmp    122b <main+0xfb>
mov    %esi,%edi
and    $0xfffffff8,%edi
movdqa 0xe29(%rip),%xmm0
movdqa 0xe31(%rip),%xmm1
movdqa 0xe39(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
add    $0xfffffff8,%edi
jne    11f0 <main+0xc0>
test   $0x7,%sil
je     128b <main+0x15b>
mov    %r9d,%edx
and    $0x38,%dl
add    $0xf8,%dl
shr    $0x3,%dl
add    $0x1,%dl
movzbl %dl,%esi
and    $0x7,%esi
movdqa 0xde2(%rip),%xmm2
xchg   %ax,%ax
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
add    $0xffffffff,%esi
jne    1250 <main+0x120>
pshufd $0xf5,%xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm2,%xmm3
pmuludq %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xaa,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pmuludq %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %r8d,%r9d
je     12df <main+0x1af>
and    $0xfffffff8,%eax
add    %ebx,%eax
neg    %eax
mov    %eax,%r9d
add    $0x1,%r9d
nopw   0x0(%rax,%rax,1)
add    %edi,%edi
lea    (%rdi,%rdi,4),%edi
add    $0xffffffff,%r9d
cmp    $0x1,%r9d
jg     12d0 <main+0x1a0>
mov    %ecx,%eax
cltd
idiv   %edi
test   %eax,%eax
jne    12f8 <main+0x1c8>
lea    0xd6a(%rip),%rdi
call   1030 <puts@plt>
mov    0xc(%rsp),%ecx
pxor   %xmm0,%xmm0
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x10(%rsp)
movq   $0x0,0x30(%rsp)
test   %ecx,%ecx
je     136d <main+0x23d>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ecx,%rax
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,1),%edx
lea    (%rdx,%rdx,4),%edx
mov    %eax,%esi
sub    %edx,%esi
movslq %esi,%rdx
addl   $0x1,0x10(%rsp,%rdx,4)
add    $0x9,%eax
cmp    $0x13,%eax
jae    1320 <main+0x1f0>
mov    %ecx,0xc(%rsp)
mov    0x10(%rsp),%edx
test   %edx,%edx
je     136d <main+0x23d>
lea    0xced(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%edx
test   %edx,%edx
je     1388 <main+0x258>
lea    0xcd5(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%edx
test   %edx,%edx
je     13a3 <main+0x273>
lea    0xcba(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%edx
test   %edx,%edx
je     13be <main+0x28e>
lea    0xc9f(%rip),%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%edx
test   %edx,%edx
je     13d9 <main+0x2a9>
lea    0xc84(%rip),%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%edx
test   %edx,%edx
je     13f4 <main+0x2c4>
lea    0xc69(%rip),%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%edx
test   %edx,%edx
je     140f <main+0x2df>
lea    0xc4e(%rip),%rdi
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%edx
test   %edx,%edx
je     142a <main+0x2fa>
lea    0xc33(%rip),%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%edx
test   %edx,%edx
je     1445 <main+0x315>
lea    0xc18(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%edx
test   %edx,%edx
je     1460 <main+0x330>
lea    0xbfd(%rip),%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [14 x i8] c"Enter number:\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [66 x i8] c"Numbers don't start with 0. \0ANote: these zeros will be ommited.\0A\0A\00"
@.str.3 = [8 x i8] c"%d: %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [10 x i32]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %6
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
%9 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%10 = load i32, i32* %2
store i32 %10, i32* %7
store i32 0, i32* %5
br label %11
11: ; preds = %17, %0
%12 = load i32, i32* %7
%13 = icmp sgt i32 %12, 0
br i1 %13, label %14, label %20
14: ; preds = %11
%15 = load i32, i32* %7
%16 = sdiv i32 %15, 10
store i32 %16, i32* %7
br label %17
17: ; preds = %14
%18 = load i32, i32* %5
%19 = add nsw i32 %18, 1
store i32 %19, i32* %5
br label %11
20: ; preds = %11
br label %21
21: ; preds = %27, %20
%22 = load i32, i32* %5
%23 = icmp sgt i32 %22, 0
br i1 %23, label %24, label %30
24: ; preds = %21
%25 = load i32, i32* %3
%26 = mul nsw i32 %25, 10
store i32 %26, i32* %3
br label %27
27: ; preds = %24
%28 = load i32, i32* %5
%29 = add nsw i32 %28, -1
store i32 %29, i32* %5
br label %21
30: ; preds = %21
%31 = load i32, i32* %3
store i32 %31, i32* %5
%32 = load i32, i32* %2
%33 = load i32, i32* %5
%34 = sdiv i32 %32, %33
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %38
36: ; preds = %30
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.2, i64 0, i64 0))
br label %38
38: ; preds = %36, %30
store i32 0, i32* %5
br label %39
39: ; preds = %46, %38
%40 = load i32, i32* %5
%41 = icmp slt i32 %40, 10
br i1 %41, label %42, label %49
42: ; preds = %39
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %44
store i32 0, i32* %45
br label %46
46: ; preds = %42
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
br label %39
49: ; preds = %39
br label %50
50: ; preds = %53, %49
%51 = load i32, i32* %2
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %63
53: ; preds = %50
%54 = load i32, i32* %2
%55 = srem i32 %54, 10
store i32 %55, i32* %3
%56 = load i32, i32* %3
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = add nsw i32 %59, 1
store i32 %60, i32* %58
%61 = load i32, i32* %2
%62 = sdiv i32 %61, 10
store i32 %62, i32* %2
br label %50
63: ; preds = %50
store i32 0, i32* %5
br label %64
64: ; preds = %81, %63
%65 = load i32, i32* %5
%66 = icmp slt i32 %65, 10
br i1 %66, label %67, label %84
67: ; preds = %64
%68 = load i32, i32* %5
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = icmp ne i32 %71, 0
br i1 %72, label %73, label %80
73: ; preds = %67
%74 = load i32, i32* %5
%75 = load i32, i32* %5
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 %74, i32 %78)
br label %80
80: ; preds = %73, %67
br label %81
81: ; preds = %80
%82 = load i32, i32* %5
%83 = add nsw i32 %82, 1
store i32 %83, i32* %5
br label %64
84: ; preds = %64
ret i32 0
}

LLVM IR (-O2):
@.str = [14 x i8] c"Enter number:\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.3 = [8 x i8] c"%d: %d\0A\00"
@str = [65 x i8] c"Numbers don't start with 0. \0ANote: these zeros will be ommited.\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10 x i32]
%3 = bitcast [10 x i32]* %2 to i8*
%4 = bitcast i32* %1 to i8*
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0))
%6 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%7 = load i32, i32* %1
%8 = icmp sgt i32 %7, 0
br i1 %8, label %9, label %65
9: ; preds = %0, %9
%10 = phi i32 [ %12, %9 ], [ %7, %0 ]
%11 = phi i32 [ %13, %9 ], [ 0, %0 ]
%12 = udiv i32 %10, 10
%13 = add nuw nsw i32 %11, 1
%14 = icmp ult i32 %10, 10
br i1 %14, label %15, label %9
15: ; preds = %9
%16 = add nuw i32 %11, 1
%17 = icmp ult i32 %11, 7
br i1 %17, label %56, label %18
18: ; preds = %15
%19 = and i32 %16, -8
%20 = sub i32 %13, %19
%21 = add i32 %19, -8
%22 = lshr exact i32 %21, 3
%23 = add nuw nsw i32 %22, 1
%24 = and i32 %23, 7
%25 = icmp ult i32 %21, 56
br i1 %25, label %36, label %26
26: ; preds = %18
%27 = and i32 %23, 1073741816
br label %28
28: ; preds = %28, %26
%29 = phi <4 x i32> [ <i32 undef, i32 1, i32 1, i32 1>, %26 ], [ %32, %28 ]
%30 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %26 ], [ %33, %28 ]
%31 = phi i32 [ 0, %26 ], [ %34, %28 ]
%32 = mul <4 x i32> %29, <i32 100000000, i32 100000000, i32 100000000, i32 100000000>
%33 = mul <4 x i32> %30, <i32 100000000, i32 100000000, i32 100000000, i32 100000000>
%34 = add nuw i32 %31, 8
%35 = icmp eq i32 %34, %27
br i1 %35, label %36, label %28
36: ; preds = %28, %18
%37 = phi <4 x i32> [ undef, %18 ], [ %32, %28 ]
%38 = phi <4 x i32> [ undef, %18 ], [ %33, %28 ]
%39 = phi <4 x i32> [ <i32 undef, i32 1, i32 1, i32 1>, %18 ], [ %32, %28 ]
%40 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %18 ], [ %33, %28 ]
%41 = icmp eq i32 %24, 0
br i1 %41, label %50, label %42
42: ; preds = %36, %42
%43 = phi <4 x i32> [ %46, %42 ], [ %39, %36 ]
%44 = phi <4 x i32> [ %47, %42 ], [ %40, %36 ]
%45 = phi i32 [ %48, %42 ], [ 0, %36 ]
%46 = mul <4 x i32> %43, <i32 10, i32 10, i32 10, i32 10>
%47 = mul <4 x i32> %44, <i32 10, i32 10, i32 10, i32 10>
%48 = add i32 %45, 1
%49 = icmp eq i32 %48, %24
br i1 %49, label %50, label %42
50: ; preds = %42, %36
%51 = phi <4 x i32> [ %37, %36 ], [ %46, %42 ]
%52 = phi <4 x i32> [ %38, %36 ], [ %47, %42 ]
%53 = mul <4 x i32> %52, %51
%54 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %53)
%55 = icmp eq i32 %16, %19
br i1 %55, label %65, label %56
56: ; preds = %15, %50
%57 = phi i32 [ undef, %15 ], [ %54, %50 ]
%58 = phi i32 [ %13, %15 ], [ %20, %50 ]
br label %59
59: ; preds = %56, %59
%60 = phi i32 [ %62, %59 ], [ %57, %56 ]
%61 = phi i32 [ %63, %59 ], [ %58, %56 ]
%62 = mul nsw i32 %60, 10
%63 = add nsw i32 %61, -1
%64 = icmp sgt i32 %61, 1
br i1 %64, label %59, label %65
65: ; preds = %59, %50, %0
%66 = phi i32 [ undef, %0 ], [ %54, %50 ], [ %62, %59 ]
%67 = sdiv i32 %7, %66
%68 = icmp eq i32 %67, 0
br i1 %68, label %69, label %72
69: ; preds = %65
%70 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str, i64 0, i64 0))
%71 = load i32, i32* %1
br label %72
72: ; preds = %69, %65
%73 = phi i32 [ %71, %69 ], [ %7, %65 ]
%74 = icmp eq i32 %73, 0
br i1 %74, label %91, label %79
75: ; preds = %79
store i32 %86, i32* %1
%76 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 0
%77 = load i32, i32* %76
%78 = icmp eq i32 %77, 0
br i1 %78, label %91, label %89
79: ; preds = %72, %79
%80 = phi i32 [ %86, %79 ], [ %73, %72 ]
%81 = srem i32 %80, 10
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = add nsw i32 %84, 1
store i32 %85, i32* %83
%86 = sdiv i32 %80, 10
%87 = add i32 %80, 9
%88 = icmp ult i32 %87, 19
br i1 %88, label %75, label %79
89: ; preds = %75
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 0, i32 %77)
br label %91
91: ; preds = %72, %75, %89
%92 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 1
%93 = load i32, i32* %92
%94 = icmp eq i32 %93, 0
br i1 %94, label %97, label %95
95: ; preds = %91
%96 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 1, i32 %93)
br label %97
97: ; preds = %95, %91
%98 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 2
%99 = load i32, i32* %98
%100 = icmp eq i32 %99, 0
br i1 %100, label %103, label %101
101: ; preds = %97
%102 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 2, i32 %99)
br label %103
103: ; preds = %101, %97
%104 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 3
%105 = load i32, i32* %104
%106 = icmp eq i32 %105, 0
br i1 %106, label %109, label %107
107: ; preds = %103
%108 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 3, i32 %105)
br label %109
109: ; preds = %107, %103
%110 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 4
%111 = load i32, i32* %110
%112 = icmp eq i32 %111, 0
br i1 %112, label %115, label %113
113: ; preds = %109
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 4, i32 %111)
br label %115
115: ; preds = %113, %109
%116 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 5
%117 = load i32, i32* %116
%118 = icmp eq i32 %117, 0
br i1 %118, label %121, label %119
119: ; preds = %115
%120 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 5, i32 %117)
br label %121
121: ; preds = %119, %115
%122 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 6
%123 = load i32, i32* %122
%124 = icmp eq i32 %123, 0
br i1 %124, label %127, label %125
125: ; preds = %121
%126 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 6, i32 %123)
br label %127
127: ; preds = %125, %121
%128 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 7
%129 = load i32, i32* %128
%130 = icmp eq i32 %129, 0
br i1 %130, label %133, label %131
131: ; preds = %127
%132 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 7, i32 %129)
br label %133
133: ; preds = %131, %127
%134 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 8
%135 = load i32, i32* %134
%136 = icmp eq i32 %135, 0
br i1 %136, label %139, label %137
137: ; preds = %133
%138 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 8, i32 %135)
br label %139
139: ; preds = %137, %133
%140 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 9
%141 = load i32, i32* %140
%142 = icmp eq i32 %141, 0
br i1 %142, label %145, label %143
143: ; preds = %139
%144 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 9, i32 %141)
br label %145
145: ; preds = %143, %139
ret i32 0
}