#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 */
scalar_t__ EOF;
int /*<<< orphan*/ printf(char *, int, char *);
scalar_t__ scanf(char *, ...);
int main(void) {
  int n, d, i;
  char num[11];
  scanf("%*d");
  while (scanf("%s", num) != EOF) {
    n = 0;
    for (d = 0; num[d]; d++)
      num[d] -= '0';
    d--;
    while (1) {
      for (i = 0; i <= d / 2; i++)
        num[i] = num[d - i] += num[i];
      for (i = 0; i <= d; i++) {
        num[i + 1] += num[i] / 10;
        num[i] %= 10;
      }
      if (num[i]) {
        d++;
        num[i + 1] = 0;
      }
      n++;
      for (i = 0; i <= d / 2; i++)
        if (num[i] != num[d - i])
          break;
      if (i == d / 2 + 1)
        break;
    }
    for (i = 0; i <= d; i++)
      num[i] += '0';
    num[i] = 0;
    printf("%d %s\n", n, num);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeca(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    -0x1b(%rbp),%rsi
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    0x2e92(%rip),%rcx
cmp    (%rcx),%rax
je     1367 <main+0x247>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movslq -0xc(%rbp),%rax
cmpb   $0x0,-0x1b(%rbp,%rax,1)
je     119a <main+0x7a>
movslq -0xc(%rbp),%rax
movsbl -0x1b(%rbp,%rax,1),%ecx
sub    $0x30,%ecx
mov    %cl,-0x1b(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    116d <main+0x4d>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x20(%rbp),%eax
cmp    %ecx,%eax
jg     11fa <main+0xda>
movslq -0x10(%rbp),%rax
movsbl -0x1b(%rbp,%rax,1),%edx
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
movsbl -0x1b(%rbp,%rax,1),%ecx
add    %edx,%ecx
mov    %cl,-0x1b(%rbp,%rax,1)
movslq -0x10(%rbp),%rax
mov    %cl,-0x1b(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11aa <main+0x8a>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1260 <main+0x140>
movslq -0x10(%rbp),%rax
movsbl -0x1b(%rbp,%rax,1),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x1b(%rbp,%rax,1),%ecx
add    %edx,%ecx
mov    %cl,-0x1b(%rbp,%rax,1)
movslq -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movsbl -0x1b(%rbp,%rax,1),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x28(%rbp),%rax
mov    %dl,%cl
mov    %cl,-0x1b(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1201 <main+0xe1>
movslq -0x10(%rbp),%rax
cmpb   $0x0,-0x1b(%rbp,%rax,1)
je     1285 <main+0x165>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
movb   $0x0,-0x1b(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2c(%rbp),%eax
cmp    %ecx,%eax
jg     12ea <main+0x1ca>
movslq -0x10(%rbp),%rax
movsbl -0x1b(%rbp,%rax,1),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movsbl -0x1b(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     12d7 <main+0x1b7>
jmp    12ea <main+0x1ca>
jmp    12dc <main+0x1bc>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1295 <main+0x175>
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1310 <main+0x1f0>
jmp    1315 <main+0x1f5>
jmp    11a3 <main+0x83>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1346 <main+0x226>
movslq -0x10(%rbp),%rax
movsbl -0x1b(%rbp,%rax,1),%ecx
add    $0x30,%ecx
mov    %cl,-0x1b(%rbp,%rax,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    131c <main+0x1fc>
movslq -0x10(%rbp),%rax
movb   $0x0,-0x1b(%rbp,%rax,1)
mov    -0x8(%rbp),%esi
lea    -0x1b(%rbp),%rdx
lea    0xcaa(%rip),%rdi
call   1030 <printf@plt>
jmp    113d <main+0x1d>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
lea    0xeeb(%rip),%rdi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0xee1(%rip),%rdi
lea    0xd(%rsp),%r13
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x2e8f(%rip),%r12
cmp    (%r12),%rax
jne    1170 <main+0x50>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xeb0(%rip),%r14
lea    0xea6(%rip),%r15
movdqa 0xe8a(%rip),%xmm4
movdqa 0xe72(%rip),%xmm5
jmp    11c7 <main+0xa7>
xor    %ecx,%ecx
mov    %ecx,%eax
movb   $0x0,0xd(%rsp,%rax,1)
mov    %r14,%rdi
mov    %r13,%rdx
call   1030 <printf@plt>
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
cmp    (%r12),%rax
movdqa 0xe53(%rip),%xmm4
movdqa 0xe3b(%rip),%xmm5
je     115f <main+0x3f>
mov    0xd(%rsp),%cl
mov    $0x0,%eax
test   %cl,%cl
je     11f4 <main+0xd4>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
add    $0xd0,%cl
mov    %cl,0xd(%rsp,%rax,1)
movzbl 0xe(%rsp,%rax,1),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    11e0 <main+0xc0>
add    $0xffffffff,%eax
xor    %esi,%esi
mov    %eax,%r11d
shr    $0x1f,%r11d
add    %eax,%r11d
sar    %r11d
mov    $0x0,%edx
cmp    $0xffffffff,%eax
jl     12eb <main+0x1cb>
movslq %eax,%r9
lea    0x1(%r11),%r8d
lea    0x1(%rax),%r10d
cmp    $0x3,%r10d
jae    1230 <main+0x110>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    1280 <main+0x160>
jmp    1295 <main+0x175>
nop
lea    (%rsp,%r9,1),%rbx
add    $0xd,%rbx
mov    %r8d,%edi
and    $0xfffffffe,%edi
neg    %rdi
xor    %ebp,%ebp
lea    0xe(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rbp,1),%ecx
add    -0x1(%rdx),%cl
mov    %cl,(%rbx,%rbp,1)
mov    %cl,-0x1(%rdx)
movzbl -0x1(%rbx,%rbp,1),%ecx
add    (%rdx),%cl
mov    %cl,-0x1(%rbx,%rbp,1)
mov    %cl,(%rdx)
add    $0x2,%rdx
add    $0xfffffffffffffffe,%rbp
cmp    %rbp,%rdi
jne    1250 <main+0x130>
neg    %rbp
test   $0x1,%r8b
je     1295 <main+0x175>
sub    %rbp,%r9
mov    0xd(%rsp,%r9,1),%dl
add    0xd(%rsp,%rbp,1),%dl
mov    %dl,0xd(%rsp,%r9,1)
mov    %dl,0xd(%rsp,%rbp,1)
mov    $0x0,%edx
test   %eax,%eax
js     12eb <main+0x1cb>
mov    0xd(%rsp),%bpl
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsbl %bpl,%ecx
imul   $0x67,%ecx,%edx
movzwl %dx,%ebp
shr    $0xa,%edx
shr    $0xf,%ebp
add    %dl,%bpl
movzbl %bpl,%edx
add    0xe(%rsp,%rdi,1),%bpl
mov    %bpl,0xe(%rsp,%rdi,1)
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
mov    %cl,0xd(%rsp,%rdi,1)
lea    0x1(%rdi),%rcx
mov    %rcx,%rdi
cmp    %rcx,%r10
jne    12b0 <main+0x190>
mov    %r10d,%edx
mov    %edx,%edx
cmpb   $0x0,0xd(%rsp,%rdx,1)
je     1311 <main+0x1f1>
movb   $0x0,0x1(%rdx,%r13,1)
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
lea    (%rax,%rdx,1),%r11d
add    $0x1,%r11d
sar    %r11d
mov    %ecx,%eax
add    $0x1,%esi
cmp    $0xfffffffe,%eax
jg     1330 <main+0x210>
add    $0x1,%r11d
xor    %edx,%edx
cmp    %r11d,%edx
jne    11f9 <main+0xd9>
jmp    1366 <main+0x246>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rcx
add    $0x1,%r11d
lea    (%rsp,%rcx,1),%rdi
add    $0xd,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0xd(%rsp,%rdx,1),%ecx
cmp    (%rdi),%cl
jne    131f <main+0x1ff>
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
cmp    %rdx,%r11
jne    1350 <main+0x230>
test   %eax,%eax
js     1190 <main+0x70>
lea    0x1(%rax),%ecx
cmp    $0x7,%eax
jae    1380 <main+0x260>
xor    %edx,%edx
jmp    1480 <main+0x360>
nopl   (%rax)
cmp    $0x1f,%eax
jae    138c <main+0x26c>
xor    %edx,%edx
jmp    143e <main+0x31e>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    -0x20(%rdx),%rdi
mov    %rdi,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     1493 <main+0x373>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu 0xd(%rsp,%rbx,1),%xmm0
movdqu 0x1d(%rsp,%rbx,1),%xmm1
movdqu 0x2d(%rsp,%rbx,1),%xmm2
movdqu 0x3d(%rsp,%rbx,1),%xmm3
paddb  %xmm5,%xmm0
paddb  %xmm5,%xmm1
movdqu %xmm0,0xd(%rsp,%rbx,1)
movdqu %xmm1,0x1d(%rsp,%rbx,1)
paddb  %xmm5,%xmm2
paddb  %xmm5,%xmm3
movdqu %xmm2,0x2d(%rsp,%rbx,1)
movdqu %xmm3,0x3d(%rsp,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rdi
jne    13c0 <main+0x2a0>
test   $0x1,%bpl
je     1430 <main+0x310>
movdqu 0xd(%rsp,%rbx,1),%xmm0
movdqu 0x1d(%rsp,%rbx,1),%xmm1
paddb  %xmm5,%xmm0
paddb  %xmm5,%xmm1
movdqu %xmm0,0xd(%rsp,%rbx,1)
movdqu %xmm1,0x1d(%rsp,%rbx,1)
cmp    %rcx,%rdx
je     1192 <main+0x72>
test   $0x18,%cl
je     1480 <main+0x360>
mov    %rdx,%rdi
add    $0x1,%eax
mov    %eax,%edx
and    $0xfffffff8,%edx
nopl   0x0(%rax)
movq   0xd(%rsp,%rdi,1),%xmm0
paddb  %xmm4,%xmm0
movq   %xmm0,0xd(%rsp,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1450 <main+0x330>
cmp    %rax,%rdx
je     1192 <main+0x72>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addb   $0x30,0xd(%rsp,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1480 <main+0x360>
jmp    1192 <main+0x72>
xor    %ebx,%ebx
test   $0x1,%bpl
jne    1410 <main+0x2f0>
jmp    1430 <main+0x310>

LLVM IR (-O0):
@.str = [4 x i8] c"%*d\00"
@.str.1 = [3 x i8] c"%s\00"
@EOF = global i64 0
@.str.2 = [7 x i8] c"%d %s\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [11 x i8]
store i32 0, i32* %1
%6 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
br label %7
7: ; preds = %154, %0
%8 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 0
%9 = call i64 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %8)
%10 = load i64, i64* @EOF
%11 = icmp ne i64 %9, %10
br i1 %11, label %12, label %161
12: ; preds = %7
store i32 0, i32* %2
store i32 0, i32* %3
br label %13
13: ; preds = %27, %12
%14 = load i32, i32* %3
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %15
%17 = load i8, i8* %16
%18 = icmp ne i8 %17, 0
br i1 %18, label %19, label %30
19: ; preds = %13
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %21
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = sub nsw i32 %24, 48
%26 = trunc i32 %25 to i8
store i8 %26, i8* %22
br label %27
27: ; preds = %19
%28 = load i32, i32* %3
%29 = add nsw i32 %28, 1
store i32 %29, i32* %3
br label %13
30: ; preds = %13
%31 = load i32, i32* %3
%32 = add nsw i32 %31, -1
store i32 %32, i32* %3
br label %33
33: ; preds = %30, %137
store i32 0, i32* %4
br label %34
34: ; preds = %57, %33
%35 = load i32, i32* %4
%36 = load i32, i32* %3
%37 = sdiv i32 %36, 2
%38 = icmp sle i32 %35, %37
br i1 %38, label %39, label %60
39: ; preds = %34
%40 = load i32, i32* %4
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %41
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = load i32, i32* %3
%46 = load i32, i32* %4
%47 = sub nsw i32 %45, %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %48
%50 = load i8, i8* %49
%51 = sext i8 %50 to i32
%52 = add nsw i32 %51, %44
%53 = trunc i32 %52 to i8
store i8 %53, i8* %49
%54 = load i32, i32* %4
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %55
store i8 %53, i8* %56
br label %57
57: ; preds = %39
%58 = load i32, i32* %4
%59 = add nsw i32 %58, 1
store i32 %59, i32* %4
br label %34
60: ; preds = %34
store i32 0, i32* %4
br label %61
61: ; preds = %87, %60
%62 = load i32, i32* %4
%63 = load i32, i32* %3
%64 = icmp sle i32 %62, %63
br i1 %64, label %65, label %90
65: ; preds = %61
%66 = load i32, i32* %4
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %67
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
%71 = sdiv i32 %70, 10
%72 = load i32, i32* %4
%73 = add nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = add nsw i32 %77, %71
%79 = trunc i32 %78 to i8
store i8 %79, i8* %75
%80 = load i32, i32* %4
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %81
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = srem i32 %84, 10
%86 = trunc i32 %85 to i8
store i8 %86, i8* %82
br label %87
87: ; preds = %65
%88 = load i32, i32* %4
%89 = add nsw i32 %88, 1
store i32 %89, i32* %4
br label %61
90: ; preds = %61
%91 = load i32, i32* %4
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %92
%94 = load i8, i8* %93
%95 = icmp ne i8 %94, 0
br i1 %95, label %96, label %103
96: ; preds = %90
%97 = load i32, i32* %3
%98 = add nsw i32 %97, 1
store i32 %98, i32* %3
%99 = load i32, i32* %4
%100 = add nsw i32 %99, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %101
store i8 0, i8* %102
br label %103
103: ; preds = %96, %90
%104 = load i32, i32* %2
%105 = add nsw i32 %104, 1
store i32 %105, i32* %2
store i32 0, i32* %4
br label %106
106: ; preds = %127, %103
%107 = load i32, i32* %4
%108 = load i32, i32* %3
%109 = sdiv i32 %108, 2
%110 = icmp sle i32 %107, %109
br i1 %110, label %111, label %130
111: ; preds = %106
%112 = load i32, i32* %4
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %113
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = load i32, i32* %3
%118 = load i32, i32* %4
%119 = sub nsw i32 %117, %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %120
%122 = load i8, i8* %121
%123 = sext i8 %122 to i32
%124 = icmp ne i32 %116, %123
br i1 %124, label %125, label %126
125: ; preds = %111
br label %130
126: ; preds = %111
br label %127
127: ; preds = %126
%128 = load i32, i32* %4
%129 = add nsw i32 %128, 1
store i32 %129, i32* %4
br label %106
130: ; preds = %125, %106
%131 = load i32, i32* %4
%132 = load i32, i32* %3
%133 = sdiv i32 %132, 2
%134 = add nsw i32 %133, 1
%135 = icmp eq i32 %131, %134
br i1 %135, label %136, label %137
136: ; preds = %130
br label %138
137: ; preds = %130
br label %33
138: ; preds = %136
store i32 0, i32* %4
br label %139
139: ; preds = %151, %138
%140 = load i32, i32* %4
%141 = load i32, i32* %3
%142 = icmp sle i32 %140, %141
br i1 %142, label %143, label %154
143: ; preds = %139
%144 = load i32, i32* %4
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %145
%147 = load i8, i8* %146
%148 = sext i8 %147 to i32
%149 = add nsw i32 %148, 48
%150 = trunc i32 %149 to i8
store i8 %150, i8* %146
br label %151
151: ; preds = %143
%152 = load i32, i32* %4
%153 = add nsw i32 %152, 1
store i32 %153, i32* %4
br label %139
154: ; preds = %139
%155 = load i32, i32* %4
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 %156
store i8 0, i8* %157
%158 = load i32, i32* %2
%159 = getelementptr inbounds [11 x i8], [11 x i8]* %5, i64 0, i64 0
%160 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0), i32 %158, i8* %159)
br label %7
161: ; preds = %7
ret i32 0
}

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