#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*/ freopen(char *, char *, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, int *, ...);
int /*<<< orphan*/ stdin;
int main() {
  int A[9][9], B[9][9];
  int aa, ab, ba, bb, i, j, flag;
  freopen("sample2.in", "r", stdin);
  scanf("%d%d", &aa, &ab);
  for (i = 0; i < aa; i++)
    for (j = 0; j < ab; j++)
      scanf("%d", &A[i][j]);
  scanf("%d%d", &ba, &bb);
  for (i = 0; i < ba; i++)
    for (j = 0; j < bb; j++)
      scanf("%d", &B[i][j]);
  flag = 1;
  if (aa == ba && ab == bb) {
    for (i = 0; i < ba; i++)
      for (j = 0; j < bb; j++)
        if (A[i][j] != B[i][j])
          flag = 0;
    if (flag == 1) {
      printf("0\n");
      return 0;
    }
  }
  flag = 1;
  if (aa == bb && ab == ba) {
    for (i = 0; i < aa; i++)
      for (j = 0; j < ab; j++)
        if (A[i][j] != B[j][aa - 1 - i])
          flag = 0;
    if (flag == 1) {
      printf("90\n");
      return 0;
    }
  }
  flag = 1;
  if (aa == ba && ab == bb) {
    for (i = 0; i < aa; i++)
      for (j = 0; j < ab; j++)
        if (A[i][j] != B[aa - 1 - i][ab - 1 - j])
          flag = 0;
    if (flag == 1) {
      printf("180\n");
      return 0;
    }
  }
  flag = 1;
  if (aa == bb && ab == ba) {
    for (i = 0; i < aa; i++)
      for (j = 0; j < ab; j++)
        if (A[i][j] != B[ab - 1 - j][i])
          flag = 0;
    if (flag == 1) {
      printf("270\n");
      return 0;
    }
  }
  printf("-1\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c0,%rsp
movl   $0x0,-0x4(%rbp)
mov    0x2e9f(%rip),%rax
mov    (%rax),%edx
lea    0xeae(%rip),%rdi
lea    0xeb2(%rip),%rsi
call   1040 <freopen@plt>
lea    0xea8(%rip),%rdi
lea    -0x2a4(%rbp),%rsi
lea    -0x2a8(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2a4(%rbp),%eax
jge    1210 <main+0xe0>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2a8(%rbp),%eax
jge    11f7 <main+0xc7>
movslq -0x2b4(%rbp),%rax
lea    -0x150(%rbp),%rsi
imul   $0x24,%rax,%rax
add    %rax,%rsi
movslq -0x2b8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe33(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    11a0 <main+0x70>
jmp    11fc <main+0xcc>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    1184 <main+0x54>
lea    0xdf6(%rip),%rdi
lea    -0x2ac(%rbp),%rsi
lea    -0x2b0(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jge    12c2 <main+0x192>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jge    12a9 <main+0x179>
movslq -0x2b4(%rbp),%rax
lea    -0x2a0(%rbp),%rsi
imul   $0x24,%rax,%rax
add    %rax,%rsi
movslq -0x2b8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xd81(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    1252 <main+0x122>
jmp    12ae <main+0x17e>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    1236 <main+0x106>
movl   $0x1,-0x2bc(%rbp)
mov    -0x2a4(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jne    13d2 <main+0x2a2>
mov    -0x2a8(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jne    13d2 <main+0x2a2>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jge    13a8 <main+0x278>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jge    138f <main+0x25f>
movslq -0x2b4(%rbp),%rcx
lea    -0x150(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x2b4(%rbp),%rdx
lea    -0x2a0(%rbp),%rcx
imul   $0x24,%rdx,%rdx
add    %rdx,%rcx
movslq -0x2b8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     1376 <main+0x246>
movl   $0x0,-0x2bc(%rbp)
jmp    137b <main+0x24b>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    1316 <main+0x1e6>
jmp    1394 <main+0x264>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    12fa <main+0x1ca>
cmpl   $0x1,-0x2bc(%rbp)
jne    13cd <main+0x29d>
lea    0xc61(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1741 <main+0x611>
jmp    13d2 <main+0x2a2>
movl   $0x1,-0x2bc(%rbp)
mov    -0x2a4(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jne    14ed <main+0x3bd>
mov    -0x2a8(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jne    14ed <main+0x3bd>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2a4(%rbp),%eax
jge    14c3 <main+0x393>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2a8(%rbp),%eax
jge    14aa <main+0x37a>
movslq -0x2b4(%rbp),%rcx
lea    -0x150(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x2b8(%rbp),%rdx
lea    -0x2a0(%rbp),%rcx
imul   $0x24,%rdx,%rdx
add    %rdx,%rcx
mov    -0x2a4(%rbp),%edx
sub    $0x1,%edx
sub    -0x2b4(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     1491 <main+0x361>
movl   $0x0,-0x2bc(%rbp)
jmp    1496 <main+0x366>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    1426 <main+0x2f6>
jmp    14af <main+0x37f>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    140a <main+0x2da>
cmpl   $0x1,-0x2bc(%rbp)
jne    14e8 <main+0x3b8>
lea    0xb3b(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1741 <main+0x611>
jmp    14ed <main+0x3bd>
movl   $0x1,-0x2bc(%rbp)
mov    -0x2a4(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jne    1613 <main+0x4e3>
mov    -0x2a8(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jne    1613 <main+0x4e3>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2a4(%rbp),%eax
jge    15e9 <main+0x4b9>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2a8(%rbp),%eax
jge    15d0 <main+0x4a0>
movslq -0x2b4(%rbp),%rcx
lea    -0x150(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x2a4(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x2b4(%rbp),%ecx
movslq %ecx,%rdx
lea    -0x2a0(%rbp),%rcx
imul   $0x24,%rdx,%rdx
add    %rdx,%rcx
mov    -0x2a8(%rbp),%edx
sub    $0x1,%edx
sub    -0x2b8(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
je     15b7 <main+0x487>
movl   $0x0,-0x2bc(%rbp)
jmp    15bc <main+0x48c>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    1541 <main+0x411>
jmp    15d5 <main+0x4a5>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    1525 <main+0x3f5>
cmpl   $0x1,-0x2bc(%rbp)
jne    160e <main+0x4de>
lea    0xa19(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1741 <main+0x611>
jmp    1613 <main+0x4e3>
movl   $0x1,-0x2bc(%rbp)
mov    -0x2a4(%rbp),%eax
cmp    -0x2b0(%rbp),%eax
jne    172e <main+0x5fe>
mov    -0x2a8(%rbp),%eax
cmp    -0x2ac(%rbp),%eax
jne    172e <main+0x5fe>
movl   $0x0,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%eax
cmp    -0x2a4(%rbp),%eax
jge    1704 <main+0x5d4>
movl   $0x0,-0x2b8(%rbp)
mov    -0x2b8(%rbp),%eax
cmp    -0x2a8(%rbp),%eax
jge    16eb <main+0x5bb>
movslq -0x2b4(%rbp),%rcx
lea    -0x150(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2b8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x2a8(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x2b8(%rbp),%ecx
movslq %ecx,%rdx
lea    -0x2a0(%rbp),%rcx
imul   $0x24,%rdx,%rdx
add    %rdx,%rcx
movslq -0x2b4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     16d2 <main+0x5a2>
movl   $0x0,-0x2bc(%rbp)
jmp    16d7 <main+0x5a7>
mov    -0x2b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b8(%rbp)
jmp    1667 <main+0x537>
jmp    16f0 <main+0x5c0>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    164b <main+0x51b>
cmpl   $0x1,-0x2bc(%rbp)
jne    1729 <main+0x5f9>
lea    0x903(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1741 <main+0x611>
jmp    172e <main+0x5fe>
lea    0x8eb(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
mov    0x2ea0(%rip),%rax
mov    (%rax),%edx
lea    0xeaf(%rip),%rdi
lea    0xeb3(%rip),%rsi
call   1040 <freopen@plt>
lea    0xea9(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x4(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    11e5 <main+0xb5>
lea    0x1c0(%rsp),%r15
mov    0x4(%rsp),%eax
lea    0xe7f(%rip),%r14
xor    %r12d,%r12d
jmp    11b0 <main+0x80>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
movslq %ecx,%rdx
add    $0x24,%r15
cmp    %rdx,%r12
jge    11e5 <main+0xb5>
test   %eax,%eax
jle    11a0 <main+0x70>
mov    %r15,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     11c0 <main+0x90>
mov    0xc(%rsp),%ecx
jmp    11a0 <main+0x70>
lea    0xe21(%rip),%rdi
lea    0x2c(%rsp),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x2c(%rsp),%r9d
test   %r9d,%r9d
jle    1266 <main+0x136>
lea    0x70(%rsp),%r15
mov    0x8(%rsp),%eax
lea    0xdf8(%rip),%r14
xor    %r12d,%r12d
jmp    1230 <main+0x100>
nopl   0x0(%rax)
add    $0x1,%r12
movslq %r9d,%rcx
add    $0x24,%r15
cmp    %rcx,%r12
jge    1266 <main+0x136>
test   %eax,%eax
jle    1220 <main+0xf0>
mov    %r15,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1240 <main+0x110>
mov    0x2c(%rsp),%r9d
jmp    1220 <main+0xf0>
mov    0xc(%rsp),%r15d
cmp    %r9d,%r15d
mov    %r15,0x38(%rsp)
jne    146c <main+0x33c>
mov    0x4(%rsp),%r11d
mov    0x8(%rsp),%r13d
cmp    %r13d,%r11d
jne    1471 <main+0x341>
lea    0xd84(%rip),%rdi
test   %r9d,%r9d
jle    1a29 <main+0x8f9>
mov    %r9d,%r14d
mov    %r11d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%rax
mov    %rax,0x10(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
lea    0x1f0(%rsp),%rbp
lea    0xa0(%rsp),%rdi
mov    $0x1,%ebx
lea    0x1c0(%rsp),%rcx
lea    0x70(%rsp),%rdx
xor    %r10d,%r10d
xor    %r13d,%r13d
jmp    131d <main+0x1ed>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
add    $0x24,%rbp
add    $0x24,%rdi
add    $0x24,%rcx
add    $0x24,%rdx
cmp    %r14,%r13
je     1a00 <main+0x8d0>
test   %r11d,%r11d
jle    1300 <main+0x1d0>
cmp    $0x8,%r11d
jae    1330 <main+0x200>
xor    %eax,%eax
jmp    1440 <main+0x310>
nop
movd   %ebx,%xmm1
pshufd $0x0,%xmm1,%xmm0
cmpq   $0x0,0x10(%rsp)
je     1458 <main+0x328>
mov    0x18(%rsp),%r12
xor    %r8d,%r8d
movdqa %xmm0,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rbp,%r8,4),%xmm3
movdqu -0x20(%rbp,%r8,4),%xmm4
movdqu -0x10(%rbp,%r8,4),%xmm5
movdqu 0x0(%rbp,%r8,4),%xmm6
movdqu -0x30(%rdi,%r8,4),%xmm7
pcmpeqd %xmm3,%xmm7
movdqu -0x20(%rdi,%r8,4),%xmm3
pcmpeqd %xmm4,%xmm3
movdqu -0x10(%rdi,%r8,4),%xmm4
pcmpeqd %xmm5,%xmm4
pand   %xmm7,%xmm4
pand   %xmm4,%xmm0
movdqu (%rdi,%r8,4),%xmm4
pcmpeqd %xmm6,%xmm4
pand   %xmm3,%xmm4
pand   %xmm4,%xmm2
add    $0x10,%r8
add    $0xfffffffffffffffe,%r12
jne    1360 <main+0x230>
testb  $0x1,0x20(%rsp)
je     140d <main+0x2dd>
lea    0x0(,%r13,4),%rax
lea    (%rax,%rax,8),%r12
lea    (%rsp,%r12,1),%rax
add    $0x1c0,%rax
movdqu (%rax,%r8,4),%xmm3
movdqu 0x10(%rax,%r8,4),%xmm4
lea    0x70(%rsp,%r12,1),%rax
movdqu (%rax,%r8,4),%xmm5
pcmpeqd %xmm3,%xmm5
pand   %xmm5,%xmm0
movdqu 0x10(%rax,%r8,4),%xmm3
pcmpeqd %xmm4,%xmm3
pand   %xmm3,%xmm2
pshufd $0x0,%xmm1,%xmm1
movdqa %xmm0,%xmm3
pcmpeqd %xmm1,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
pcmpeqd %xmm1,%xmm3
movmskps %xmm3,%eax
cmp    $0xf,%eax
cmovne %r10d,%ebx
mov    %r15,%rax
cmp    %r11,%r15
je     1300 <main+0x1d0>
mov    (%rcx,%rax,4),%esi
cmp    (%rdx,%rax,4),%esi
cmovne %r10d,%ebx
add    $0x1,%rax
cmp    %rax,%r11
jne    1440 <main+0x310>
jmp    1300 <main+0x1d0>
xor    %r8d,%r8d
movdqa %xmm0,%xmm2
testb  $0x1,0x20(%rsp)
jne    13c8 <main+0x298>
jmp    140d <main+0x2dd>
mov    0x8(%rsp),%r13d
cmp    %r13d,%r15d
mov    %r13,0x20(%rsp)
jne    1620 <main+0x4f0>
cmp    %r9d,0x4(%rsp)
jne    1620 <main+0x4f0>
lea    0xb8c(%rip),%rdi
test   %r15d,%r15d
jle    1a29 <main+0x8f9>
mov    %r9d,%eax
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x1(%r15),%r10d
lea    0x1d0(%rsp),%rdi
lea    0x0(,%rax,4),%r11
and    $0xffffffffffffffe0,%r11
mov    $0x1,%ebx
lea    0x1c0(%rsp),%rdx
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    14f9 <main+0x3c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0xffffffff,%r10d
add    $0x24,%rdi
add    $0x24,%rdx
cmp    %r15,%r12
je     160b <main+0x4db>
test   %r9d,%r9d
jle    14e0 <main+0x3b0>
movslq %r10d,%r14
cmp    $0x8,%r9d
jae    1510 <main+0x3e0>
xor    %ecx,%ecx
jmp    15d9 <main+0x4a9>
xchg   %ax,%ax
lea    (%rsp,%r14,4),%rsi
add    $0x70,%rsi
movd   %ebx,%xmm2
pshufd $0x0,%xmm2,%xmm0
xor    %ecx,%ecx
movdqa %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rcx,1),%xmm3
movdqu (%rdi,%rcx,1),%xmm4
movd   0x6c(%rsi),%xmm5
movd   0x48(%rsi),%xmm6
punpckldq %xmm5,%xmm6
movd   0x24(%rsi),%xmm5
movd   (%rsi),%xmm7
punpckldq %xmm5,%xmm7
punpcklqdq %xmm6,%xmm7
pcmpeqd %xmm3,%xmm7
pand   %xmm7,%xmm0
movd   0xfc(%rsi),%xmm3
movd   0xd8(%rsi),%xmm5
punpckldq %xmm3,%xmm5
movd   0xb4(%rsi),%xmm3
movd   0x90(%rsi),%xmm6
punpckldq %xmm3,%xmm6
punpcklqdq %xmm5,%xmm6
pcmpeqd %xmm4,%xmm6
pand   %xmm6,%xmm1
add    $0x120,%rsi
add    $0x20,%rcx
cmp    %rcx,%r11
jne    1530 <main+0x400>
pshufd $0x0,%xmm2,%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%ecx
cmp    $0xf,%ecx
cmovne %r13d,%ebx
mov    %r8,%rcx
cmp    %rax,%r8
je     14e0 <main+0x3b0>
lea    (%rcx,%rcx,8),%rsi
lea    (%rsp,%rsi,4),%rsi
add    $0x70,%rsi
lea    (%rsi,%r14,4),%rsi
nopl   0x0(%rax)
mov    (%rdx,%rcx,4),%ebp
cmp    (%rsi),%ebp
cmovne %r13d,%ebx
add    $0x1,%rcx
add    $0x24,%rsi
cmp    %rcx,%rax
jne    15f0 <main+0x4c0>
jmp    14e0 <main+0x3b0>
cmp    $0x1,%ebx
lea    0xa08(%rip),%rdi
mov    0x20(%rsp),%r13
je     1a29 <main+0x8f9>
cmp    %r9d,%r15d
mov    %r9,0x10(%rsp)
jne    18f6 <main+0x7c6>
cmp    %r13d,0x4(%rsp)
jne    18f6 <main+0x7c6>
lea    0x9d9(%rip),%rdi
test   %r9d,%r9d
jle    1a29 <main+0x8f9>
mov    %r9d,%eax
mov    %rax,0x68(%rsp)
mov    %r13d,%edx
lea    -0x1(%rdx),%rax
lea    -0x1(%r13),%esi
mov    %edx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x58(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x50(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %esi,%ecx
sub    %eax,%ecx
mov    %esi,0x34(%rsp)
cmp    %esi,%ecx
setg   %cl
shr    $0x20,%rax
setne  %al
or     %cl,%al
mov    %al,0x3(%rsp)
mov    %rdi,%rax
mov    %rdi,0x48(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x40(%rsp)
mov    %rdx,0x18(%rsp)
neg    %rdx
mov    %rdx,0x60(%rsp)
lea    -0x5(%r13),%eax
mov    %eax,0x30(%rsp)
lea    0x1d0(%rsp),%rbp
lea    0x1c4(%rsp),%r9
mov    $0x1,%r12d
xor    %r14d,%r14d
xor    %r8d,%r8d
jmp    1701 <main+0x5d1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x24,%rbp
add    $0x24,%r9
cmp    0x68(%rsp),%r8
mov    0x38(%rsp),%r15
mov    0x20(%rsp),%r13
je     18e0 <main+0x7b0>
test   %r13d,%r13d
jle    16e0 <main+0x5b0>
cmp    $0x4,%r13d
setb   %al
mov    %r8d,%ecx
not    %ecx
add    0x10(%rsp),%ecx
movslq %ecx,%r10
or     0x3(%rsp),%al
je     1730 <main+0x600>
xor    %ecx,%ecx
jmp    181a <main+0x6ea>
cs nopw 0x0(%rax,%rax,1)
movd   %r12d,%xmm1
pshufd $0x0,%xmm1,%xmm0
cmpq   $0x0,0x50(%rsp)
je     18ce <main+0x79e>
mov    0x40(%rsp),%rcx
mov    0x30(%rsp),%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x4(%rax),%esi
movslq %esi,%rsi
lea    (%r10,%r10,8),%rbx
lea    (%rsp,%rbx,4),%rbx
add    $0x70,%rbx
movdqu -0xc(%rbx,%rsi,4),%xmm2
pshufd $0x1b,%xmm2,%xmm2
movdqu -0x10(%rbp,%rdx,4),%xmm3
pcmpeqd %xmm2,%xmm3
movdqu 0x0(%rbp,%rdx,4),%xmm2
cltq
movdqu -0xc(%rbx,%rax,4),%xmm4
pshufd $0x1b,%xmm4,%xmm4
pcmpeqd %xmm2,%xmm4
pand   %xmm3,%xmm4
pand   %xmm4,%xmm0
add    $0x8,%rdx
add    $0xfffffff8,%eax
add    $0xfffffffffffffffe,%rcx
jne    1760 <main+0x630>
testb  $0x1,0x48(%rsp)
je     17f4 <main+0x6c4>
lea    (%r8,%r8,8),%rax
lea    (%rsp,%rax,4),%rax
add    $0x1c0,%rax
movdqu (%rax,%rdx,4),%xmm2
not    %edx
add    %r13d,%edx
movslq %edx,%rax
lea    (%r10,%r10,8),%rcx
lea    (%rsp,%rcx,4),%rcx
add    $0x70,%rcx
movdqu -0xc(%rcx,%rax,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm0
pshufd $0x0,%xmm1,%xmm1
pcmpeqd %xmm0,%xmm1
movmskps %xmm1,%eax
cmp    $0xf,%eax
cmovne %r14d,%r12d
mov    0x58(%rsp),%rax
mov    %rax,%rcx
cmp    0x18(%rsp),%rax
je     16e0 <main+0x5b0>
testb  $0x1,0x18(%rsp)
jne    1830 <main+0x700>
mov    %rcx,%rdx
jmp    1866 <main+0x736>
cs nopw 0x0(%rax,%rax,1)
lea    (%r8,%r8,8),%rax
lea    (%rsp,%rax,4),%rax
add    $0x1c0,%rax
mov    (%rax,%rcx,4),%eax
mov    %ecx,%edx
not    %edx
add    0x20(%rsp),%edx
movslq %edx,%rdx
lea    (%r10,%r10,8),%rsi
lea    (%rsp,%rsi,4),%rsi
add    $0x70,%rsi
cmp    (%rsi,%rdx,4),%eax
cmovne %r14d,%r12d
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x60(%rsp),%rcx
je     16e0 <main+0x5b0>
mov    0x18(%rsp),%rax
sub    %rdx,%rax
mov    0x34(%rsp),%ecx
sub    %edx,%ecx
lea    (%r9,%rdx,4),%rdx
xor    %r13d,%r13d
nopl   0x0(%rax)
movslq %ecx,%rcx
lea    (%r10,%r10,8),%rsi
lea    (%rsp,%rsi,4),%rsi
add    $0x70,%rsi
mov    -0x4(%rdx,%r13,4),%ebx
mov    (%rdx,%r13,4),%r11d
xor    (%rsi,%rcx,4),%ebx
lea    -0x1(%rcx),%r15d
movslq %r15d,%rdi
xor    (%rsi,%rdi,4),%r11d
or     %ebx,%r11d
cmovne %r14d,%r12d
add    $0x2,%r13
add    $0xfffffffe,%ecx
cmp    %r13,%rax
jne    1890 <main+0x760>
jmp    16e0 <main+0x5b0>
xor    %edx,%edx
testb  $0x1,0x48(%rsp)
jne    17ba <main+0x68a>
jmp    17f4 <main+0x6c4>
cmp    $0x1,%r12d
mov    0x10(%rsp),%r9
lea    0x729(%rip),%rdi
je     1a29 <main+0x8f9>
cmp    %r13d,%r15d
jne    1a22 <main+0x8f2>
cmp    %r9d,0x4(%rsp)
jne    1a22 <main+0x8f2>
lea    0x704(%rip),%rdi
test   %r15d,%r15d
jle    1a29 <main+0x8f9>
mov    %rdi,%r12
mov    %r9d,%r10d
mov    %r10d,%r11d
and    $0xfffffffe,%r11d
lea    0x1c4(%rsp),%r14
lea    -0x2(%r9),%r8d
mov    $0x1,%esi
xor    %r9d,%r9d
xor    %ebx,%ebx
jmp    1951 <main+0x821>
nop
add    $0x1,%rbx
add    $0x24,%r14
cmp    %r15,%rbx
je     1a1a <main+0x8ea>
mov    0x10(%rsp),%rax
test   %eax,%eax
jle    1940 <main+0x810>
cmp    $0x1,%eax
jne    1970 <main+0x840>
xor    %edi,%edi
jmp    19c4 <main+0x894>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r8d,%eax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rax),%ebp
movslq %ebp,%rbp
lea    0x0(%rbp,%rbp,8),%rbp
lea    (%rsp,%rbp,4),%rbp
add    $0x70,%rbp
mov    -0x4(%r14,%rdi,4),%ecx
mov    (%r14,%rdi,4),%edx
xor    0x0(%rbp,%rbx,4),%ecx
cltq
lea    (%rax,%rax,8),%rbp
lea    (%rsp,%rbp,4),%rbp
add    $0x70,%rbp
xor    0x0(%rbp,%rbx,4),%edx
or     %ecx,%edx
cmovne %r9d,%esi
add    $0x2,%rdi
add    $0xfffffffe,%eax
cmp    %rdi,%r11
jne    1980 <main+0x850>
test   $0x1,%r10b
je     1940 <main+0x810>
lea    (%rbx,%rbx,8),%rax
lea    (%rsp,%rax,4),%rax
add    $0x1c0,%rax
mov    (%rax,%rdi,4),%eax
not    %edi
add    0x10(%rsp),%edi
movslq %edi,%rcx
lea    (%rcx,%rcx,8),%rcx
lea    (%rsp,%rcx,4),%rcx
add    $0x70,%rcx
cmp    (%rcx,%rbx,4),%eax
cmovne %r9d,%esi
jmp    1940 <main+0x810>
mov    %r11d,%r13d
cmp    $0x1,%ebx
mov    0x38(%rsp),%r15
lea    0x605(%rip),%rdi
jne    1471 <main+0x341>
jmp    1a29 <main+0x8f9>
cmp    $0x1,%esi
mov    %r12,%rdi
je     1a29 <main+0x8f9>
lea    0x5e9(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [11 x i8] c"sample2.in\00"
@.str.1 = [2 x i8] c"r\00"
@stdin = global i32 0
@.str.2 = [5 x i8] c"%d%d\00"
@.str.3 = [3 x i8] c"%d\00"
@.str.4 = [3 x i8] c"0\0A\00"
@.str.5 = [4 x i8] c"90\0A\00"
@.str.6 = [5 x i8] c"180\0A\00"
@.str.7 = [5 x i8] c"270\0A\00"
@.str.8 = [4 x i8] c"-1\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [9 x [9 x i32]]
%3 = alloca [9 x [9 x i32]]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %1
%11 = load i32, i32* @stdin
%12 = call i32 @freopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %11)
%13 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32* %4, i32* %5)
store i32 0, i32* %8
br label %14
14: ; preds = %35, %0
%15 = load i32, i32* %8
%16 = load i32, i32* %4
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %38
18: ; preds = %14
store i32 0, i32* %9
br label %19
19: ; preds = %31, %18
%20 = load i32, i32* %9
%21 = load i32, i32* %5
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %34
23: ; preds = %19
%24 = load i32, i32* %8
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %2, i64 0, i64 %25
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [9 x i32], [9 x i32]* %26, i64 0, i64 %28
%30 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %29)
br label %31
31: ; preds = %23
%32 = load i32, i32* %9
%33 = add nsw i32 %32, 1
store i32 %33, i32* %9
br label %19
34: ; preds = %19
br label %35
35: ; preds = %34
%36 = load i32, i32* %8
%37 = add nsw i32 %36, 1
store i32 %37, i32* %8
br label %14
38: ; preds = %14
%39 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i32* %6, i32* %7)
store i32 0, i32* %8
br label %40
40: ; preds = %61, %38
%41 = load i32, i32* %8
%42 = load i32, i32* %6
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %64
44: ; preds = %40
store i32 0, i32* %9
br label %45
45: ; preds = %57, %44
%46 = load i32, i32* %9
%47 = load i32, i32* %7
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %60
49: ; preds = %45
%50 = load i32, i32* %8
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %3, i64 0, i64 %51
%53 = load i32, i32* %9
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [9 x i32], [9 x i32]* %52, i64 0, i64 %54
%56 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %55)
br label %57
57: ; preds = %49
%58 = load i32, i32* %9
%59 = add nsw i32 %58, 1
store i32 %59, i32* %9
br label %45
60: ; preds = %45
br label %61
61: ; preds = %60
%62 = load i32, i32* %8
%63 = add nsw i32 %62, 1
store i32 %63, i32* %8
br label %40
64: ; preds = %40
store i32 1, i32* %10
%65 = load i32, i32* %4
%66 = load i32, i32* %6
%67 = icmp eq i32 %65, %66
br i1 %67, label %68, label %113
68: ; preds = %64
%69 = load i32, i32* %5
%70 = load i32, i32* %7
%71 = icmp eq i32 %69, %70
br i1 %71, label %72, label %113
72: ; preds = %68
store i32 0, i32* %8
br label %73
73: ; preds = %104, %72
%74 = load i32, i32* %8
%75 = load i32, i32* %6
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %107
77: ; preds = %73
store i32 0, i32* %9
br label %78
78: ; preds = %100, %77
%79 = load i32, i32* %9
%80 = load i32, i32* %7
%81 = icmp slt i32 %79, %80
br i1 %81, label %82, label %103
82: ; preds = %78
%83 = load i32, i32* %8
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %2, i64 0, i64 %84
%86 = load i32, i32* %9
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [9 x i32], [9 x i32]* %85, i64 0, i64 %87
%89 = load i32, i32* %88
%90 = load i32, i32* %8
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %3, i64 0, i64 %91
%93 = load i32, i32* %9
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [9 x i32], [9 x i32]* %92, i64 0, i64 %94
%96 = load i32, i32* %95
%97 = icmp ne i32 %89, %96
br i1 %97, label %98, label %99
98: ; preds = %82
store i32 0, i32* %10
br label %99
99: ; preds = %98, %82
br label %100
100: ; preds = %99
%101 = load i32, i32* %9
%102 = add nsw i32 %101, 1
store i32 %102, i32* %9
br label %78
103: ; preds = %78
br label %104
104: ; preds = %103
%105 = load i32, i32* %8
%106 = add nsw i32 %105, 1
store i32 %106, i32* %8
br label %73
107: ; preds = %73
%108 = load i32, i32* %10
%109 = icmp eq i32 %108, 1
br i1 %109, label %110, label %112
110: ; preds = %107
%111 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %1
br label %274
112: ; preds = %107
br label %113
113: ; preds = %112, %68, %64
store i32 1, i32* %10
%114 = load i32, i32* %4
%115 = load i32, i32* %7
%116 = icmp eq i32 %114, %115
br i1 %116, label %117, label %165
117: ; preds = %113
%118 = load i32, i32* %5
%119 = load i32, i32* %6
%120 = icmp eq i32 %118, %119
br i1 %120, label %121, label %165
121: ; preds = %117
store i32 0, i32* %8
br label %122
122: ; preds = %156, %121
%123 = load i32, i32* %8
%124 = load i32, i32* %4
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %159
126: ; preds = %122
store i32 0, i32* %9
br label %127
127: ; preds = %152, %126
%128 = load i32, i32* %9
%129 = load i32, i32* %5
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %155
131: ; preds = %127
%132 = load i32, i32* %8
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %2, i64 0, i64 %133
%135 = load i32, i32* %9
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [9 x i32], [9 x i32]* %134, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = load i32, i32* %9
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %3, i64 0, i64 %140
%142 = load i32, i32* %4
%143 = sub nsw i32 %142, 1
%144 = load i32, i32* %8
%145 = sub nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [9 x i32], [9 x i32]* %141, i64 0, i64 %146
%148 = load i32, i32* %147
%149 = icmp ne i32 %138, %148
br i1 %149, label %150, label %151
150: ; preds = %131
store i32 0, i32* %10
br label %151
151: ; preds = %150, %131
br label %152
152: ; preds = %151
%153 = load i32, i32* %9
%154 = add nsw i32 %153, 1
store i32 %154, i32* %9
br label %127
155: ; preds = %127
br label %156
156: ; preds = %155
%157 = load i32, i32* %8
%158 = add nsw i32 %157, 1
store i32 %158, i32* %8
br label %122
159: ; preds = %122
%160 = load i32, i32* %10
%161 = icmp eq i32 %160, 1
br i1 %161, label %162, label %164
162: ; preds = %159
%163 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %1
br label %274
164: ; preds = %159
br label %165
165: ; preds = %164, %117, %113
store i32 1, i32* %10
%166 = load i32, i32* %4
%167 = load i32, i32* %6
%168 = icmp eq i32 %166, %167
br i1 %168, label %169, label %220
169: ; preds = %165
%170 = load i32, i32* %5
%171 = load i32, i32* %7
%172 = icmp eq i32 %170, %171
br i1 %172, label %173, label %220
173: ; preds = %169
store i32 0, i32* %8
br label %174
174: ; preds = %211, %173
%175 = load i32, i32* %8
%176 = load i32, i32* %4
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %214
178: ; preds = %174
store i32 0, i32* %9
br label %179
179: ; preds = %207, %178
%180 = load i32, i32* %9
%181 = load i32, i32* %5
%182 = icmp slt i32 %180, %181
br i1 %182, label %183, label %210
183: ; preds = %179
%184 = load i32, i32* %8
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %2, i64 0, i64 %185
%187 = load i32, i32* %9
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [9 x i32], [9 x i32]* %186, i64 0, i64 %188
%190 = load i32, i32* %189
%191 = load i32, i32* %4
%192 = sub nsw i32 %191, 1
%193 = load i32, i32* %8
%194 = sub nsw i32 %192, %193
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %3, i64 0, i64 %195
%197 = load i32, i32* %5
%198 = sub nsw i32 %197, 1
%199 = load i32, i32* %9
%200 = sub nsw i32 %198, %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [9 x i32], [9 x i32]* %196, i64 0, i64 %201
%203 = load i32, i32* %202
%204 = icmp ne i32 %190, %203
br i1 %204, label %205, label %206
205: ; preds = %183
store i32 0, i32* %10
br label %206
206: ; preds = %205, %183
br label %207
207: ; preds = %206
%208 = load i32, i32* %9
%209 = add nsw i32 %208, 1
store i32 %209, i32* %9
br label %179
210: ; preds = %179
br label %211
211: ; preds = %210
%212 = load i32, i32* %8
%213 = add nsw i32 %212, 1
store i32 %213, i32* %8
br label %174
214: ; preds = %174
%215 = load i32, i32* %10
%216 = icmp eq i32 %215, 1
br i1 %216, label %217, label %219
217: ; preds = %214
%218 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %1
br label %274
219: ; preds = %214
br label %220
220: ; preds = %219, %169, %165
store i32 1, i32* %10
%221 = load i32, i32* %4
%222 = load i32, i32* %7
%223 = icmp eq i32 %221, %222
br i1 %223, label %224, label %272
224: ; preds = %220
%225 = load i32, i32* %5
%226 = load i32, i32* %6
%227 = icmp eq i32 %225, %226
br i1 %227, label %228, label %272
228: ; preds = %224
store i32 0, i32* %8
br label %229
229: ; preds = %263, %228
%230 = load i32, i32* %8
%231 = load i32, i32* %4
%232 = icmp slt i32 %230, %231
br i1 %232, label %233, label %266
233: ; preds = %229
store i32 0, i32* %9
br label %234
234: ; preds = %259, %233
%235 = load i32, i32* %9
%236 = load i32, i32* %5
%237 = icmp slt i32 %235, %236
br i1 %237, label %238, label %262
238: ; preds = %234
%239 = load i32, i32* %8
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %2, i64 0, i64 %240
%242 = load i32, i32* %9
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [9 x i32], [9 x i32]* %241, i64 0, i64 %243
%245 = load i32, i32* %244
%246 = load i32, i32* %5
%247 = sub nsw i32 %246, 1
%248 = load i32, i32* %9
%249 = sub nsw i32 %247, %248
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %3, i64 0, i64 %250
%252 = load i32, i32* %8
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [9 x i32], [9 x i32]* %251, i64 0, i64 %253
%255 = load i32, i32* %254
%256 = icmp ne i32 %245, %255
br i1 %256, label %257, label %258
257: ; preds = %238
store i32 0, i32* %10
br label %258
258: ; preds = %257, %238
br label %259
259: ; preds = %258
%260 = load i32, i32* %9
%261 = add nsw i32 %260, 1
store i32 %261, i32* %9
br label %234
262: ; preds = %234
br label %263
263: ; preds = %262
%264 = load i32, i32* %8
%265 = add nsw i32 %264, 1
store i32 %265, i32* %8
br label %229
266: ; preds = %229
%267 = load i32, i32* %10
%268 = icmp eq i32 %267, 1
br i1 %268, label %269, label %271
269: ; preds = %266
%270 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %1
br label %274
271: ; preds = %266
br label %272
272: ; preds = %271, %224, %220
%273 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %1
br label %274
274: ; preds = %272, %269, %217, %162, %110
%275 = load i32, i32* %1
ret i32 %275
}

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