#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
scalar_t__ EOF;
int /*<<< orphan*/ *fopen(char *, char *);
scalar_t__ fscanf(int /*<<< orphan*/ *, char *, int *, long long *);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char *argv[]) {
  FILE *fp;
  const int stats[32] = {2, 4, 8, 6, 3, 9, 7, 1, 4, 6, 4, 6, 5, 5, 5, 5,
                         6, 6, 6, 6, 7, 9, 3, 1, 8, 4, 2, 6, 9, 1, 9, 1};
  int a;
  long long int n;
  if (argc != 2) {
    printf("Usage: %s [FILE]\n", argv[0]);
    return 1;
  }
  fp = fopen(*++argv, "r");
  while (fscanf(fp, "%d %lld", &a, &n) != EOF) {
    int i;
    long long int m = n / 4;
    long long int res[10] = {0};
    a -= 2;
    for (i = 0; i < 4; i++) {
      res[stats[a * 4 + i]] += m;
    }
    for (i = 0; i < n % 4; i++) {
      res[stats[a * 4 + i]]++;
    }
    for (i = 0; i <= 9; i++) {
      if (i > 0) {
        printf(", ");
      }
      printf("%d: %lld", i, res[i]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0xa0(%rbp),%rdi
lea    0xe89(%rip),%rsi
mov    $0x80,%edx
call   1060 <memcpy@plt>
cmpl   $0x2,-0x8(%rbp)
je     11ac <main+0x5c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xee7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    138f <main+0x23f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x8(%rax),%rdi
lea    0xecc(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xeba(%rip),%rsi
lea    -0xa4(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
call   1050 <fscanf@plt>
mov    0x2df4(%rip),%rcx
cmp    (%rcx),%rax
je     1388 <main+0x238>
mov    -0xb0(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %rax,-0xc0(%rbp)
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x50,%edx
call   1040 <memset@plt>
mov    -0xa4(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xa4(%rbp)
movl   $0x0,-0xb4(%rbp)
cmpl   $0x4,-0xb4(%rbp)
jge    1292 <main+0x142>
mov    -0xc0(%rbp),%rcx
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    -0xb4(%rbp),%eax
cltq
movslq -0xa0(%rbp,%rax,4),%rax
ff
add    -0x110(%rbp,%rax,8),%rcx
ff
mov    %rcx,-0x110(%rbp,%rax,8)
ff
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1241 <main+0xf1>
movl   $0x0,-0xb4(%rbp)
movslq -0xb4(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0xb0(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    -0x118(%rbp),%rax
cmp    %rdx,%rax
jge    130c <main+0x1bc>
mov    -0xa4(%rbp),%eax
shl    $0x2,%eax
add    -0xb4(%rbp),%eax
cltq
movslq -0xa0(%rbp,%rax,4),%rax
ff
mov    -0x110(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x110(%rbp,%rax,8)
ff
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    129c <main+0x14c>
movl   $0x0,-0xb4(%rbp)
cmpl   $0x9,-0xb4(%rbp)
jg     1375 <main+0x225>
cmpl   $0x0,-0xb4(%rbp)
jle    133e <main+0x1ee>
lea    0xd65(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb4(%rbp),%esi
movslq -0xb4(%rbp),%rax
mov    -0x110(%rbp,%rax,8),%rdx
ff
lea    0xd45(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1316 <main+0x1c6>
lea    0xd14(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    11cf <main+0x7f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
cmp    $0x2,%edi
jne    13dc <main+0x29c>
mov    0x8(%rsi),%rdi
lea    0xf30(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,%r14
lea    0xf23(%rip),%rsi
lea    0x4(%rsp),%rdx
lea    0x8(%rsp),%rcx
mov    %rax,%rdi
call   1050 <fscanf@plt>
mov    0x2e5e(%rip),%rcx
xor    %r12d,%r12d
cmp    (%rcx),%rax
je     13f3 <main+0x2b3>
lea    0xe63(%rip),%r13
lea    0xefb(%rip),%rbx
lea    0xef1(%rip),%r15
xor    %r12d,%r12d
jmp    1312 <main+0x1d2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x50(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%rdx
mov    %rbx,%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
lea    0xda1(%rip),%rsi
lea    0x4(%rsp),%rdx
lea    0x8(%rsp),%rcx
call   1050 <fscanf@plt>
mov    0x2cdf(%rip),%rcx
cmp    (%rcx),%rax
je     13f3 <main+0x2b3>
mov    0x8(%rsp),%rax
xorps  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movslq 0x4(%rsp),%rcx
lea    -0x2(%rcx),%rdx
mov    %edx,0x4(%rsp)
shl    $0x4,%rdx
movslq (%rdx,%r13,1),%rsi
lea    0x3(%rax),%rbp
test   %rax,%rax
cmovns %rax,%rbp
mov    %rbp,%rdi
sar    $0x2,%rdi
add    %rdi,0x10(%rsp,%rsi,8)
movslq 0x4(%rdx,%r13,1),%rsi
add    %rdi,0x10(%rsp,%rsi,8)
movslq 0x8(%rdx,%r13,1),%rsi
add    %rdi,0x10(%rsp,%rsi,8)
movslq 0xc(%rdx,%r13,1),%rdx
add    %rdi,0x10(%rsp,%rdx,8)
and    $0xfffffffffffffffc,%rbp
sub    %rbp,%rax
test   %rax,%rax
jle    11c0 <main+0x80>
lea    -0x8(,%rcx,4),%rcx
ff
movslq 0x0(%r13,%rcx,4),%rdx
addq   $0x1,0x10(%rsp,%rdx,8)
cmp    $0x1,%rax
je     11c0 <main+0x80>
shl    $0x2,%rcx
mov    %rcx,%rdx
or     $0x4,%rdx
movslq (%rdx,%r13,1),%rdx
addq   $0x1,0x10(%rsp,%rdx,8)
cmp    $0x2,%rax
je     11c0 <main+0x80>
or     $0x8,%rcx
movslq (%rcx,%r13,1),%rax
addq   $0x1,0x10(%rsp,%rax,8)
jmp    11c0 <main+0x80>
mov    (%rsi),%rsi
lea    0xc9a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0x1,%r12d
mov    %r12d,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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