#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, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  for (;;) {
    int a[785], x, i;
    for (i = 0; i < 785; i++)
      a[i] = -1;
    scanf("%d", &x);
    if (x < 1 || x > 366)
      break;
    int j;
    i = x;
    for (j = 784; i > 0; j--) {
      a[j] = i % 10;
      i = i / 10;
    }
    int k = 0;
    for (i = x - 1; i > 0; i--) {
      for (j = 784; a[j] >= 0; j--) {
        k = (i * a[j]) + k;
        a[j] = k % 10;
        k = k / 10;
      }
      a[j] = k % 10;
      k = k / 10;
      a[j - 1] = k;
      for (k = 0; a[k] < 1; k++)
        a[k] = -1;
      k = 0;
    }
    int num[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    for (i = 0; i < 10; i++)
      for (j = 0; j < 785; j++)
        if (i == a[j])
          num[i]++;
    printf("%d! --\n", x);
    printf("   (0)%5d    (1)%5d    (2)%5d    (3)%5d    (4)%5d\n", num[0],
           num[1], num[2], num[3], num[4]);
    printf("   (5)%5d    (6)%5d    (7)%5d    (8)%5d    (9)%5d \n", num[5],
           num[6], num[7], num[8], num[9]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc90,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xc58(%rbp)
cmpl   $0x311,-0xc58(%rbp)
jge    1182 <main+0x52>
movslq -0xc58(%rbp),%rax
movl   $0xffffffff,-0xc50(%rbp,%rax,4)
ff ff ff ff
mov    -0xc58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc58(%rbp)
jmp    114c <main+0x1c>
lea    0xe77(%rip),%rdi
lea    -0xc54(%rbp),%rsi
call   1050 <scanf@plt>
cmpl   $0x1,-0xc54(%rbp)
jl     11b2 <main+0x82>
cmpl   $0x16e,-0xc54(%rbp)
jle    11b7 <main+0x87>
jmp    1490 <main+0x360>
mov    -0xc54(%rbp),%eax
mov    %eax,-0xc58(%rbp)
movl   $0x310,-0xc5c(%rbp)
cmpl   $0x0,-0xc58(%rbp)
jle    121e <main+0xee>
mov    -0xc58(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0xc5c(%rbp),%rax
mov    %edx,-0xc50(%rbp,%rax,4)
mov    -0xc58(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc58(%rbp)
mov    -0xc5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc5c(%rbp)
jmp    11cd <main+0x9d>
movl   $0x0,-0xc60(%rbp)
mov    -0xc54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc58(%rbp)
cmpl   $0x0,-0xc58(%rbp)
jle    1373 <main+0x243>
movl   $0x310,-0xc5c(%rbp)
movslq -0xc5c(%rbp),%rax
cmpl   $0x0,-0xc50(%rbp,%rax,4)
jl     12c8 <main+0x198>
mov    -0xc58(%rbp),%eax
movslq -0xc5c(%rbp),%rcx
imul   -0xc50(%rbp,%rcx,4),%eax
ff
add    -0xc60(%rbp),%eax
mov    %eax,-0xc60(%rbp)
mov    -0xc60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0xc5c(%rbp),%rax
mov    %edx,-0xc50(%rbp,%rax,4)
mov    -0xc60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc60(%rbp)
mov    -0xc5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc5c(%rbp)
jmp    124e <main+0x11e>
mov    -0xc60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq -0xc5c(%rbp),%rax
mov    %edx,-0xc50(%rbp,%rax,4)
mov    -0xc60(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc60(%rbp)
mov    -0xc60(%rbp),%ecx
mov    -0xc5c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0xc50(%rbp,%rax,4)
movl   $0x0,-0xc60(%rbp)
movslq -0xc60(%rbp),%rax
cmpl   $0x1,-0xc50(%rbp,%rax,4)
01
jge    1355 <main+0x225>
movslq -0xc60(%rbp),%rax
movl   $0xffffffff,-0xc50(%rbp,%rax,4)
ff ff ff ff
mov    -0xc60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc60(%rbp)
jmp    131a <main+0x1ea>
movl   $0x0,-0xc60(%rbp)
mov    -0xc58(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc58(%rbp)
jmp    1237 <main+0x107>
lea    -0xc90(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1040 <memset@plt>
movl   $0x0,-0xc58(%rbp)
cmpl   $0xa,-0xc58(%rbp)
jge    141b <main+0x2eb>
movl   $0x0,-0xc5c(%rbp)
cmpl   $0x311,-0xc5c(%rbp)
jge    1402 <main+0x2d2>
mov    -0xc58(%rbp),%eax
movslq -0xc5c(%rbp),%rcx
cmp    -0xc50(%rbp,%rcx,4),%eax
jne    13e9 <main+0x2b9>
movslq -0xc58(%rbp),%rax
mov    -0xc90(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xc90(%rbp,%rax,4)
jmp    13ee <main+0x2be>
mov    -0xc5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc5c(%rbp)
jmp    13a7 <main+0x277>
jmp    1407 <main+0x2d7>
mov    -0xc58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc58(%rbp)
jmp    1390 <main+0x260>
mov    -0xc54(%rbp),%esi
lea    0xbdb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc90(%rbp),%esi
mov    -0xc8c(%rbp),%edx
mov    -0xc88(%rbp),%ecx
mov    -0xc84(%rbp),%r8d
mov    -0xc80(%rbp),%r9d
lea    0xbb5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc7c(%rbp),%esi
mov    -0xc78(%rbp),%edx
mov    -0xc74(%rbp),%ecx
mov    -0xc70(%rbp),%r8d
mov    -0xc6c(%rbp),%r9d
lea    0xbba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1142 <main+0x12>
xor    %eax,%eax
add    $0xc90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc68,%rsp
lea    0x20(%rsp),%rdi
mov    $0xc44,%edx
mov    $0xff,%esi
call   1040 <memset@plt>
lea    0xf34(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1050 <scanf@plt>
mov    0x8(%rsp),%esi
lea    -0x16f(%rsi),%eax
cmp    $0xfffffe92,%eax
jae    118b <main+0x5b>
xor    %eax,%eax
add    $0xc68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc60(%rsp),%r9
lea    0xc60(%rsp),%r10
lea    0x24(%rsp),%r11
mov    $0xcccccccd,%ebx
movabs $0xffffffff00000000,%r14
ff ff ff
pxor   %xmm3,%xmm3
movdqa 0xe44(%rip),%xmm8
movdqa 0xe4b(%rip),%xmm9
movdqa 0xe52(%rip),%xmm10
movdqa 0xe59(%rip),%xmm11
movdqa 0xe61(%rip),%xmm4
movdqa 0xe69(%rip),%xmm5
movdqa 0xe71(%rip),%xmm6
movdqa 0xe79(%rip),%xmm7
movdqa 0xe80(%rip),%xmm12
mov    %r10,%rax
mov    %esi,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,%edx
imul   %rbx,%rdx
shr    $0x23,%rdx
lea    (%rdx,%rdx,1),%edi
lea    (%rdi,%rdi,4),%edi
mov    %ebp,%ecx
sub    %edi,%ecx
mov    %ecx,(%rax)
add    $0xfffffffffffffffc,%rax
cmp    $0xa,%ebp
mov    %edx,%ebp
jae    1210 <main+0xe0>
mov    %esi,%eax
cmp    $0x2,%esi
jge    188a <main+0x75a>
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1250 <main+0x120>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
cmpl   $0x1,0xc60(%rsp)
01
adc    $0x0,%eax
mov    %eax,0x1c(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    12d0 <main+0x1a0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %ecx,%ecx
cmpl   $0x1,0xc60(%rsp)
01
sete   %cl
add    %eax,%ecx
mov    %ecx,0x18(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm9,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm9,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm9,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm9,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1360 <main+0x230>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %ecx,%ecx
cmpl   $0x2,0xc60(%rsp)
02
sete   %cl
add    %eax,%ecx
mov    %ecx,0x14(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm10,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm10,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm10,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm10,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    13f0 <main+0x2c0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %ecx,%ecx
cmpl   $0x3,0xc60(%rsp)
03
sete   %cl
add    %eax,%ecx
mov    %ecx,0x10(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm11,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm11,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm11,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm11,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1480 <main+0x350>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %ecx,%ecx
cmpl   $0x4,0xc60(%rsp)
04
sete   %cl
add    %eax,%ecx
mov    %ecx,0xc(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm4,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm4,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm4,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm4,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1510 <main+0x3e0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %ebp,%ebp
cmpl   $0x5,0xc60(%rsp)
05
sete   %bpl
add    %eax,%ebp
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1590 <main+0x460>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %r14d,%r14d
cmpl   $0x6,0xc60(%rsp)
06
sete   %r14b
add    %eax,%r14d
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1610 <main+0x4e0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %r15d,%r15d
cmpl   $0x7,0xc60(%rsp)
07
sete   %r15b
add    %eax,%r15d
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm7,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm7,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm7,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm7,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1690 <main+0x560>
mov    %r9,%rbx
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %r12d,%r12d
cmpl   $0x8,0xc60(%rsp)
08
sete   %r12b
add    %eax,%r12d
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm1,%xmm1
nop
movdqa -0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm12,%xmm2
psubd  %xmm2,%xmm0
movdqa (%rsp,%rax,4),%xmm2
pcmpeqd %xmm12,%xmm2
psubd  %xmm2,%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm2
pcmpeqd %xmm12,%xmm2
psubd  %xmm2,%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm2
pcmpeqd %xmm12,%xmm2
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x31c,%rax
jne    1710 <main+0x5e0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
xor    %r13d,%r13d
cmpl   $0x9,0xc60(%rsp)
09
sete   %r13b
add    %eax,%r13d
lea    0x909(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x903(%rip),%rdi
mov    0x1c(%rsp),%esi
mov    0x18(%rsp),%edx
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0xc(%rsp),%r9d
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x912(%rip),%rdi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %r15d,%ecx
mov    %r12d,%r8d
mov    %r13d,%r9d
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0xc44,%edx
lea    0x20(%rsp),%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
lea    0x8a4(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1050 <scanf@plt>
movdqa 0x881(%rip),%xmm12
mov    0x8(%rsp),%esi
lea    -0x16f(%rsi),%eax
cmp    $0xfffffe91,%eax
mov    %rbx,%r9
lea    0xc60(%rsp),%r10
lea    0x24(%rsp),%r11
mov    $0xcccccccd,%ebx
movabs $0xffffffff00000000,%r14
ff ff ff
pxor   %xmm3,%xmm3
movdqa 0x7c6(%rip),%xmm8
movdqa 0x7cd(%rip),%xmm9
movdqa 0x7d4(%rip),%xmm10
movdqa 0x7db(%rip),%xmm11
movdqa 0x7e3(%rip),%xmm4
movdqa 0x7eb(%rip),%xmm5
movdqa 0x7f3(%rip),%xmm6
movdqa 0x7fb(%rip),%xmm7
ja     1200 <main+0xd0>
jmp    1177 <main+0x47>
cmp    $0x2,%r8d
jle    123c <main+0x10c>
mov    %eax,%r8d
lea    -0x1(%r8),%eax
mov    0xc60(%rsp),%ebx
xor    %ebp,%ebp
mov    $0x310,%edx
test   %ebx,%ebx
js     18f0 <main+0x7c0>
mov    %r10,%rdi
cs nopw 0x0(%rax,%rax,1)
imul   %eax,%ebx
add    %ebp,%ebx
movslq %ebx,%rbx
imul   $0x66666667,%rbx,%rbp
mov    %rbp,%rcx
shr    $0x3f,%rcx
sar    $0x22,%rbp
add    %ecx,%ebp
lea    0x0(%rbp,%rbp,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%ebx
mov    %ebx,(%rdi)
add    $0xffffffffffffffff,%rdx
mov    -0x4(%rdi),%ebx
add    $0xfffffffffffffffc,%rdi
test   %ebx,%ebx
jns    18b0 <main+0x780>
jmp    18f3 <main+0x7c3>
nopl   0x0(%rax,%rax,1)
mov    %r9,%rdi
movslq %ebp,%rcx
imul   $0x66666667,%rcx,%rbp
mov    %rbp,%rbx
shr    $0x3f,%rbx
sar    $0x22,%rbp
add    %ebx,%ebp
lea    0x0(%rbp,%rbp,1),%ebx
lea    (%rbx,%rbx,4),%ebx
sub    %ebx,%ecx
mov    %ecx,(%rdi)
shl    $0x20,%rdx
add    %r14,%rdx
sar    $0x1e,%rdx
mov    %ebp,0x20(%rsp,%rdx,1)
cmpl   $0x0,0x20(%rsp)
jg     1880 <main+0x750>
mov    %r11,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0xffffffff,-0x4(%rdx)
cmpl   $0x0,(%rdx)
lea    0x4(%rdx),%rdx
jle    1940 <main+0x810>
jmp    1880 <main+0x750>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [8 x i8] c"%d! --\0A\00"
@.str.2 = [51 x i8] c" (0)%5d (1)%5d (2)%5d (3)%5d (4)%5d\0A\00"
@.str.3 = [52 x i8] c" (5)%5d (6)%5d (7)%5d (8)%5d (9)%5d \0A\00"
define i32 @main() {
%1 = alloca [785 x i32]
%2 = bitcast [785 x i32]* %1 to i8*
%3 = alloca i32
%4 = bitcast i32* %3 to i8*
%5 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%6 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 0
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %3)
%8 = load i32, i32* %3
%9 = add i32 %8, -367
%10 = icmp ult i32 %9, -366
br i1 %10, label %461, label %11
11: ; preds = %0
%12 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%13 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%14 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%15 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%16 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%17 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%18 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%19 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%20 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
%21 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 784
br label %22
22: ; preds = %11, %447
%23 = phi i32 [ %458, %447 ], [ %8, %11 ]
br label %26
24: ; preds = %26
%25 = icmp sgt i32 %23, 1
br i1 %25, label %37, label %36
26: ; preds = %22, %26
%27 = phi i64 [ %32, %26 ], [ 784, %22 ]
%28 = phi i32 [ %31, %26 ], [ %23, %22 ]
%29 = urem i32 %28, 10
%30 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %27
store i32 %29, i32* %30
%31 = udiv i32 %28, 10
%32 = add i64 %27, -1
%33 = icmp ult i32 %28, 10
br i1 %33, label %24, label %26
34: ; preds = %67, %55
%35 = icmp sgt i32 %38, 2
br i1 %35, label %37, label %36
36: ; preds = %34, %24
br label %74
37: ; preds = %24, %34
%38 = phi i32 [ %39, %34 ], [ %23, %24 ]
%39 = add nsw i32 %38, -1
%40 = load i32, i32* %5
%41 = icmp sgt i32 %40, -1
br i1 %41, label %42, label %55
42: ; preds = %37, %42
%43 = phi i64 [ %51, %42 ], [ 784, %37 ]
%44 = phi i32 [ %53, %42 ], [ %40, %37 ]
%45 = phi i32* [ %52, %42 ], [ %5, %37 ]
%46 = phi i32 [ %50, %42 ], [ 0, %37 ]
%47 = mul nsw i32 %44, %39
%48 = add nsw i32 %47, %46
%49 = srem i32 %48, 10
store i32 %49, i32* %45
%50 = sdiv i32 %48, 10
%51 = add nsw i64 %43, -1
%52 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %51
%53 = load i32, i32* %52
%54 = icmp sgt i32 %53, -1
br i1 %54, label %42, label %55
55: ; preds = %42, %37
%56 = phi i64 [ 784, %37 ], [ %51, %42 ]
%57 = phi i32 [ 0, %37 ], [ %50, %42 ]
%58 = phi i32* [ %5, %37 ], [ %52, %42 ]
%59 = srem i32 %57, 10
store i32 %59, i32* %58
%60 = sdiv i32 %57, 10
%61 = shl i64 %56, 32
%62 = add i64 %61, -4294967296
%63 = ashr exact i64 %62, 32
%64 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %63
store i32 %60, i32* %64
%65 = load i32, i32* %6
%66 = icmp slt i32 %65, 1
br i1 %66, label %67, label %34
67: ; preds = %55, %67
%68 = phi i64 [ %70, %67 ], [ 0, %55 ]
%69 = phi i32* [ %71, %67 ], [ %6, %55 ]
store i32 -1, i32* %69
%70 = add nuw nsw i64 %68, 1
%71 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %70
%72 = load i32, i32* %71
%73 = icmp slt i32 %72, 1
br i1 %73, label %67, label %34
74: ; preds = %74, %36
%75 = phi i64 [ 0, %36 ], [ %103, %74 ]
%76 = phi <4 x i32> [ zeroinitializer, %36 ], [ %101, %74 ]
%77 = phi <4 x i32> [ zeroinitializer, %36 ], [ %102, %74 ]
%78 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %75
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = getelementptr inbounds i32, i32* %78, i64 4
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = icmp eq <4 x i32> %80, zeroinitializer
%85 = icmp eq <4 x i32> %83, zeroinitializer
%86 = zext <4 x i1> %84 to <4 x i32>
%87 = zext <4 x i1> %85 to <4 x i32>
%88 = add <4 x i32> %76, %86
%89 = add <4 x i32> %77, %87
%90 = or i64 %75, 8
%91 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %90
%92 = bitcast i32* %91 to <4 x i32>*
%93 = load <4 x i32>, <4 x i32>* %92
%94 = getelementptr inbounds i32, i32* %91, i64 4
%95 = bitcast i32* %94 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = icmp eq <4 x i32> %93, zeroinitializer
%98 = icmp eq <4 x i32> %96, zeroinitializer
%99 = zext <4 x i1> %97 to <4 x i32>
%100 = zext <4 x i1> %98 to <4 x i32>
%101 = add <4 x i32> %88, %99
%102 = add <4 x i32> %89, %100
%103 = add nuw nsw i64 %75, 16
%104 = icmp eq i64 %103, 784
br i1 %104, label %105, label %74
105: ; preds = %74
%106 = add <4 x i32> %102, %101
%107 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %106)
%108 = load i32, i32* %13
%109 = icmp eq i32 %108, 0
%110 = zext i1 %109 to i32
%111 = add nuw nsw i32 %107, %110
br label %112
112: ; preds = %112, %105
%113 = phi i64 [ 0, %105 ], [ %141, %112 ]
%114 = phi <4 x i32> [ zeroinitializer, %105 ], [ %139, %112 ]
%115 = phi <4 x i32> [ zeroinitializer, %105 ], [ %140, %112 ]
%116 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %113
%117 = bitcast i32* %116 to <4 x i32>*
%118 = load <4 x i32>, <4 x i32>* %117
%119 = getelementptr inbounds i32, i32* %116, i64 4
%120 = bitcast i32* %119 to <4 x i32>*
%121 = load <4 x i32>, <4 x i32>* %120
%122 = icmp eq <4 x i32> %118, <i32 1, i32 1, i32 1, i32 1>
%123 = icmp eq <4 x i32> %121, <i32 1, i32 1, i32 1, i32 1>
%124 = zext <4 x i1> %122 to <4 x i32>
%125 = zext <4 x i1> %123 to <4 x i32>
%126 = add <4 x i32> %114, %124
%127 = add <4 x i32> %115, %125
%128 = or i64 %113, 8
%129 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %128
%130 = bitcast i32* %129 to <4 x i32>*
%131 = load <4 x i32>, <4 x i32>* %130
%132 = getelementptr inbounds i32, i32* %129, i64 4
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = icmp eq <4 x i32> %131, <i32 1, i32 1, i32 1, i32 1>
%136 = icmp eq <4 x i32> %134, <i32 1, i32 1, i32 1, i32 1>
%137 = zext <4 x i1> %135 to <4 x i32>
%138 = zext <4 x i1> %136 to <4 x i32>
%139 = add <4 x i32> %126, %137
%140 = add <4 x i32> %127, %138
%141 = add nuw nsw i64 %113, 16
%142 = icmp eq i64 %141, 784
br i1 %142, label %143, label %112
143: ; preds = %112
%144 = add <4 x i32> %140, %139
%145 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %144)
%146 = load i32, i32* %14
%147 = icmp eq i32 %146, 1
%148 = zext i1 %147 to i32
%149 = add nuw nsw i32 %145, %148
br label %150
150: ; preds = %150, %143
%151 = phi i64 [ 0, %143 ], [ %179, %150 ]
%152 = phi <4 x i32> [ zeroinitializer, %143 ], [ %177, %150 ]
%153 = phi <4 x i32> [ zeroinitializer, %143 ], [ %178, %150 ]
%154 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %151
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds i32, i32* %154, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = icmp eq <4 x i32> %156, <i32 2, i32 2, i32 2, i32 2>
%161 = icmp eq <4 x i32> %159, <i32 2, i32 2, i32 2, i32 2>
%162 = zext <4 x i1> %160 to <4 x i32>
%163 = zext <4 x i1> %161 to <4 x i32>
%164 = add <4 x i32> %152, %162
%165 = add <4 x i32> %153, %163
%166 = or i64 %151, 8
%167 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %166
%168 = bitcast i32* %167 to <4 x i32>*
%169 = load <4 x i32>, <4 x i32>* %168
%170 = getelementptr inbounds i32, i32* %167, i64 4
%171 = bitcast i32* %170 to <4 x i32>*
%172 = load <4 x i32>, <4 x i32>* %171
%173 = icmp eq <4 x i32> %169, <i32 2, i32 2, i32 2, i32 2>
%174 = icmp eq <4 x i32> %172, <i32 2, i32 2, i32 2, i32 2>
%175 = zext <4 x i1> %173 to <4 x i32>
%176 = zext <4 x i1> %174 to <4 x i32>
%177 = add <4 x i32> %164, %175
%178 = add <4 x i32> %165, %176
%179 = add nuw nsw i64 %151, 16
%180 = icmp eq i64 %179, 784
br i1 %180, label %181, label %150
181: ; preds = %150
%182 = add <4 x i32> %178, %177
%183 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %182)
%184 = load i32, i32* %15
%185 = icmp eq i32 %184, 2
%186 = zext i1 %185 to i32
%187 = add nuw nsw i32 %183, %186
br label %188
188: ; preds = %188, %181
%189 = phi i64 [ 0, %181 ], [ %217, %188 ]
%190 = phi <4 x i32> [ zeroinitializer, %181 ], [ %215, %188 ]
%191 = phi <4 x i32> [ zeroinitializer, %181 ], [ %216, %188 ]
%192 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %189
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %192, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = icmp eq <4 x i32> %194, <i32 3, i32 3, i32 3, i32 3>
%199 = icmp eq <4 x i32> %197, <i32 3, i32 3, i32 3, i32 3>
%200 = zext <4 x i1> %198 to <4 x i32>
%201 = zext <4 x i1> %199 to <4 x i32>
%202 = add <4 x i32> %190, %200
%203 = add <4 x i32> %191, %201
%204 = or i64 %189, 8
%205 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %204
%206 = bitcast i32* %205 to <4 x i32>*
%207 = load <4 x i32>, <4 x i32>* %206
%208 = getelementptr inbounds i32, i32* %205, i64 4
%209 = bitcast i32* %208 to <4 x i32>*
%210 = load <4 x i32>, <4 x i32>* %209
%211 = icmp eq <4 x i32> %207, <i32 3, i32 3, i32 3, i32 3>
%212 = icmp eq <4 x i32> %210, <i32 3, i32 3, i32 3, i32 3>
%213 = zext <4 x i1> %211 to <4 x i32>
%214 = zext <4 x i1> %212 to <4 x i32>
%215 = add <4 x i32> %202, %213
%216 = add <4 x i32> %203, %214
%217 = add nuw nsw i64 %189, 16
%218 = icmp eq i64 %217, 784
br i1 %218, label %219, label %188
219: ; preds = %188
%220 = add <4 x i32> %216, %215
%221 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %220)
%222 = load i32, i32* %16
%223 = icmp eq i32 %222, 3
%224 = zext i1 %223 to i32
%225 = add nuw nsw i32 %221, %224
br label %226
226: ; preds = %226, %219
%227 = phi i64 [ 0, %219 ], [ %255, %226 ]
%228 = phi <4 x i32> [ zeroinitializer, %219 ], [ %253, %226 ]
%229 = phi <4 x i32> [ zeroinitializer, %219 ], [ %254, %226 ]
%230 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %227
%231 = bitcast i32* %230 to <4 x i32>*
%232 = load <4 x i32>, <4 x i32>* %231
%233 = getelementptr inbounds i32, i32* %230, i64 4
%234 = bitcast i32* %233 to <4 x i32>*
%235 = load <4 x i32>, <4 x i32>* %234
%236 = icmp eq <4 x i32> %232, <i32 4, i32 4, i32 4, i32 4>
%237 = icmp eq <4 x i32> %235, <i32 4, i32 4, i32 4, i32 4>
%238 = zext <4 x i1> %236 to <4 x i32>
%239 = zext <4 x i1> %237 to <4 x i32>
%240 = add <4 x i32> %228, %238
%241 = add <4 x i32> %229, %239
%242 = or i64 %227, 8
%243 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %242
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = getelementptr inbounds i32, i32* %243, i64 4
%247 = bitcast i32* %246 to <4 x i32>*
%248 = load <4 x i32>, <4 x i32>* %247
%249 = icmp eq <4 x i32> %245, <i32 4, i32 4, i32 4, i32 4>
%250 = icmp eq <4 x i32> %248, <i32 4, i32 4, i32 4, i32 4>
%251 = zext <4 x i1> %249 to <4 x i32>
%252 = zext <4 x i1> %250 to <4 x i32>
%253 = add <4 x i32> %240, %251
%254 = add <4 x i32> %241, %252
%255 = add nuw nsw i64 %227, 16
%256 = icmp eq i64 %255, 784
br i1 %256, label %257, label %226
257: ; preds = %226
%258 = add <4 x i32> %254, %253
%259 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %258)
%260 = load i32, i32* %17
%261 = icmp eq i32 %260, 4
%262 = zext i1 %261 to i32
%263 = add nuw nsw i32 %259, %262
br label %264
264: ; preds = %264, %257
%265 = phi i64 [ 0, %257 ], [ %293, %264 ]
%266 = phi <4 x i32> [ zeroinitializer, %257 ], [ %291, %264 ]
%267 = phi <4 x i32> [ zeroinitializer, %257 ], [ %292, %264 ]
%268 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %265
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds i32, i32* %268, i64 4
%272 = bitcast i32* %271 to <4 x i32>*
%273 = load <4 x i32>, <4 x i32>* %272
%274 = icmp eq <4 x i32> %270, <i32 5, i32 5, i32 5, i32 5>
%275 = icmp eq <4 x i32> %273, <i32 5, i32 5, i32 5, i32 5>
%276 = zext <4 x i1> %274 to <4 x i32>
%277 = zext <4 x i1> %275 to <4 x i32>
%278 = add <4 x i32> %266, %276
%279 = add <4 x i32> %267, %277
%280 = or i64 %265, 8
%281 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %280
%282 = bitcast i32* %281 to <4 x i32>*
%283 = load <4 x i32>, <4 x i32>* %282
%284 = getelementptr inbounds i32, i32* %281, i64 4
%285 = bitcast i32* %284 to <4 x i32>*
%286 = load <4 x i32>, <4 x i32>* %285
%287 = icmp eq <4 x i32> %283, <i32 5, i32 5, i32 5, i32 5>
%288 = icmp eq <4 x i32> %286, <i32 5, i32 5, i32 5, i32 5>
%289 = zext <4 x i1> %287 to <4 x i32>
%290 = zext <4 x i1> %288 to <4 x i32>
%291 = add <4 x i32> %278, %289
%292 = add <4 x i32> %279, %290
%293 = add nuw nsw i64 %265, 16
%294 = icmp eq i64 %293, 784
br i1 %294, label %295, label %264
295: ; preds = %264
%296 = add <4 x i32> %292, %291
%297 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %296)
%298 = load i32, i32* %18
%299 = icmp eq i32 %298, 5
%300 = zext i1 %299 to i32
%301 = add nuw nsw i32 %297, %300
br label %302
302: ; preds = %302, %295
%303 = phi i64 [ 0, %295 ], [ %331, %302 ]
%304 = phi <4 x i32> [ zeroinitializer, %295 ], [ %329, %302 ]
%305 = phi <4 x i32> [ zeroinitializer, %295 ], [ %330, %302 ]
%306 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %303
%307 = bitcast i32* %306 to <4 x i32>*
%308 = load <4 x i32>, <4 x i32>* %307
%309 = getelementptr inbounds i32, i32* %306, i64 4
%310 = bitcast i32* %309 to <4 x i32>*
%311 = load <4 x i32>, <4 x i32>* %310
%312 = icmp eq <4 x i32> %308, <i32 6, i32 6, i32 6, i32 6>
%313 = icmp eq <4 x i32> %311, <i32 6, i32 6, i32 6, i32 6>
%314 = zext <4 x i1> %312 to <4 x i32>
%315 = zext <4 x i1> %313 to <4 x i32>
%316 = add <4 x i32> %304, %314
%317 = add <4 x i32> %305, %315
%318 = or i64 %303, 8
%319 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %318
%320 = bitcast i32* %319 to <4 x i32>*
%321 = load <4 x i32>, <4 x i32>* %320
%322 = getelementptr inbounds i32, i32* %319, i64 4
%323 = bitcast i32* %322 to <4 x i32>*
%324 = load <4 x i32>, <4 x i32>* %323
%325 = icmp eq <4 x i32> %321, <i32 6, i32 6, i32 6, i32 6>
%326 = icmp eq <4 x i32> %324, <i32 6, i32 6, i32 6, i32 6>
%327 = zext <4 x i1> %325 to <4 x i32>
%328 = zext <4 x i1> %326 to <4 x i32>
%329 = add <4 x i32> %316, %327
%330 = add <4 x i32> %317, %328
%331 = add nuw nsw i64 %303, 16
%332 = icmp eq i64 %331, 784
br i1 %332, label %333, label %302
333: ; preds = %302
%334 = add <4 x i32> %330, %329
%335 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %334)
%336 = load i32, i32* %19
%337 = icmp eq i32 %336, 6
%338 = zext i1 %337 to i32
%339 = add nuw nsw i32 %335, %338
br label %340
340: ; preds = %340, %333
%341 = phi i64 [ 0, %333 ], [ %369, %340 ]
%342 = phi <4 x i32> [ zeroinitializer, %333 ], [ %367, %340 ]
%343 = phi <4 x i32> [ zeroinitializer, %333 ], [ %368, %340 ]
%344 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %341
%345 = bitcast i32* %344 to <4 x i32>*
%346 = load <4 x i32>, <4 x i32>* %345
%347 = getelementptr inbounds i32, i32* %344, i64 4
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = icmp eq <4 x i32> %346, <i32 7, i32 7, i32 7, i32 7>
%351 = icmp eq <4 x i32> %349, <i32 7, i32 7, i32 7, i32 7>
%352 = zext <4 x i1> %350 to <4 x i32>
%353 = zext <4 x i1> %351 to <4 x i32>
%354 = add <4 x i32> %342, %352
%355 = add <4 x i32> %343, %353
%356 = or i64 %341, 8
%357 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %356
%358 = bitcast i32* %357 to <4 x i32>*
%359 = load <4 x i32>, <4 x i32>* %358
%360 = getelementptr inbounds i32, i32* %357, i64 4
%361 = bitcast i32* %360 to <4 x i32>*
%362 = load <4 x i32>, <4 x i32>* %361
%363 = icmp eq <4 x i32> %359, <i32 7, i32 7, i32 7, i32 7>
%364 = icmp eq <4 x i32> %362, <i32 7, i32 7, i32 7, i32 7>
%365 = zext <4 x i1> %363 to <4 x i32>
%366 = zext <4 x i1> %364 to <4 x i32>
%367 = add <4 x i32> %354, %365
%368 = add <4 x i32> %355, %366
%369 = add nuw nsw i64 %341, 16
%370 = icmp eq i64 %369, 784
br i1 %370, label %371, label %340
371: ; preds = %340
%372 = add <4 x i32> %368, %367
%373 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %372)
%374 = load i32, i32* %20
%375 = icmp eq i32 %374, 7
%376 = zext i1 %375 to i32
%377 = add nuw nsw i32 %373, %376
br label %378
378: ; preds = %378, %371
%379 = phi i64 [ 0, %371 ], [ %407, %378 ]
%380 = phi <4 x i32> [ zeroinitializer, %371 ], [ %405, %378 ]
%381 = phi <4 x i32> [ zeroinitializer, %371 ], [ %406, %378 ]
%382 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %379
%383 = bitcast i32* %382 to <4 x i32>*
%384 = load <4 x i32>, <4 x i32>* %383
%385 = getelementptr inbounds i32, i32* %382, i64 4
%386 = bitcast i32* %385 to <4 x i32>*
%387 = load <4 x i32>, <4 x i32>* %386
%388 = icmp eq <4 x i32> %384, <i32 8, i32 8, i32 8, i32 8>
%389 = icmp eq <4 x i32> %387, <i32 8, i32 8, i32 8, i32 8>
%390 = zext <4 x i1> %388 to <4 x i32>
%391 = zext <4 x i1> %389 to <4 x i32>
%392 = add <4 x i32> %380, %390
%393 = add <4 x i32> %381, %391
%394 = or i64 %379, 8
%395 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %394
%396 = bitcast i32* %395 to <4 x i32>*
%397 = load <4 x i32>, <4 x i32>* %396
%398 = getelementptr inbounds i32, i32* %395, i64 4
%399 = bitcast i32* %398 to <4 x i32>*
%400 = load <4 x i32>, <4 x i32>* %399
%401 = icmp eq <4 x i32> %397, <i32 8, i32 8, i32 8, i32 8>
%402 = icmp eq <4 x i32> %400, <i32 8, i32 8, i32 8, i32 8>
%403 = zext <4 x i1> %401 to <4 x i32>
%404 = zext <4 x i1> %402 to <4 x i32>
%405 = add <4 x i32> %392, %403
%406 = add <4 x i32> %393, %404
%407 = add nuw nsw i64 %379, 16
%408 = icmp eq i64 %407, 784
br i1 %408, label %409, label %378
409: ; preds = %378
%410 = add <4 x i32> %406, %405
%411 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %410)
%412 = load i32, i32* %21
%413 = icmp eq i32 %412, 8
%414 = zext i1 %413 to i32
%415 = add nuw nsw i32 %411, %414
br label %416
416: ; preds = %416, %409
%417 = phi i64 [ 0, %409 ], [ %445, %416 ]
%418 = phi <4 x i32> [ zeroinitializer, %409 ], [ %443, %416 ]
%419 = phi <4 x i32> [ zeroinitializer, %409 ], [ %444, %416 ]
%420 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %417
%421 = bitcast i32* %420 to <4 x i32>*
%422 = load <4 x i32>, <4 x i32>* %421
%423 = getelementptr inbounds i32, i32* %420, i64 4
%424 = bitcast i32* %423 to <4 x i32>*
%425 = load <4 x i32>, <4 x i32>* %424
%426 = icmp eq <4 x i32> %422, <i32 9, i32 9, i32 9, i32 9>
%427 = icmp eq <4 x i32> %425, <i32 9, i32 9, i32 9, i32 9>
%428 = zext <4 x i1> %426 to <4 x i32>
%429 = zext <4 x i1> %427 to <4 x i32>
%430 = add <4 x i32> %418, %428
%431 = add <4 x i32> %419, %429
%432 = or i64 %417, 8
%433 = getelementptr inbounds [785 x i32], [785 x i32]* %1, i64 0, i64 %432
%434 = bitcast i32* %433 to <4 x i32>*
%435 = load <4 x i32>, <4 x i32>* %434
%436 = getelementptr inbounds i32, i32* %433, i64 4
%437 = bitcast i32* %436 to <4 x i32>*
%438 = load <4 x i32>, <4 x i32>* %437
%439 = icmp eq <4 x i32> %435, <i32 9, i32 9, i32 9, i32 9>
%440 = icmp eq <4 x i32> %438, <i32 9, i32 9, i32 9, i32 9>
%441 = zext <4 x i1> %439 to <4 x i32>
%442 = zext <4 x i1> %440 to <4 x i32>
%443 = add <4 x i32> %430, %441
%444 = add <4 x i32> %431, %442
%445 = add nuw nsw i64 %417, 16
%446 = icmp eq i64 %445, 784
br i1 %446, label %447, label %416
447: ; preds = %416
%448 = add <4 x i32> %444, %443
%449 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %448)
%450 = load i32, i32* %12
%451 = icmp eq i32 %450, 9
%452 = zext i1 %451 to i32
%453 = add nuw nsw i32 %449, %452
%454 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0), i32 %23)
%455 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.2, i64 0, i64 0), i32 %111, i32 %149, i32 %187, i32 %225, i32 %263)
%456 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i64 0, i64 0), i32 %301, i32 %339, i32 %377, i32 %415, i32 %453)
%457 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %3)
%458 = load i32, i32* %3
%459 = add i32 %458, -367
%460 = icmp ult i32 %459, -366
br i1 %460, label %461, label %22
461: ; preds = %447, %0
ret i32 0
}