int main() {
  printf("8\n");
  {
    unsigned char buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  printf("16\n");
  {
    unsigned short buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  printf("32\n");
  {
    unsigned buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  return 1;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x11ab0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0x2ec7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7b,-0x2814(%rbp)
movl   $0x0,-0x2818(%rbp)
cmpl   $0x2800,-0x2818(%rbp)
jge    1197 <main+0x77>
mov    -0x2818(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2818(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2818(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2818(%rbp)
jmp    1154 <main+0x34>
lea    -0x2810(%rbp),%rdi
add    $0x1,%rdi
mov    $0xa5,%esi
mov    $0x1,%edx
call   1040 <memset@plt>
movl   $0x0,-0x281c(%rbp)
movl   $0x0,-0x2820(%rbp)
cmpl   $0x2800,-0x2820(%rbp)
jge    1204 <main+0xe4>
movslq -0x2820(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x281c(%rbp),%eax
mov    %eax,-0x281c(%rbp)
mov    -0x2820(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2820(%rbp)
jmp    11c5 <main+0xa5>
mov    -0x281c(%rbp),%edx
lea    0x2df2(%rip),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2824(%rbp)
cmpl   $0x2800,-0x2824(%rbp)
jge    126a <main+0x14a>
mov    -0x2824(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2824(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2824(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2824(%rbp)
jmp    1227 <main+0x107>
lea    -0x2810(%rbp),%rdi
add    $0x2,%rdi
mov    $0xa5,%esi
mov    $0x2,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2828(%rbp)
movl   $0x0,-0x282c(%rbp)
cmpl   $0x2800,-0x282c(%rbp)
jge    12d7 <main+0x1b7>
movslq -0x282c(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2828(%rbp),%eax
mov    %eax,-0x2828(%rbp)
mov    -0x282c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x282c(%rbp)
jmp    1298 <main+0x178>
mov    -0x2828(%rbp),%edx
lea    0x2d1f(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2830(%rbp)
cmpl   $0x2800,-0x2830(%rbp)
jge    133d <main+0x21d>
mov    -0x2830(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2830(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2830(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2830(%rbp)
jmp    12fa <main+0x1da>
lea    -0x2810(%rbp),%rdi
add    $0x3,%rdi
mov    $0xa5,%esi
mov    $0x3,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2834(%rbp)
movl   $0x0,-0x2838(%rbp)
cmpl   $0x2800,-0x2838(%rbp)
jge    13aa <main+0x28a>
movslq -0x2838(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2834(%rbp),%eax
mov    %eax,-0x2834(%rbp)
mov    -0x2838(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2838(%rbp)
jmp    136b <main+0x24b>
mov    -0x2834(%rbp),%edx
lea    0x2c4c(%rip),%rdi
mov    $0x3,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x283c(%rbp)
cmpl   $0x2800,-0x283c(%rbp)
jge    1410 <main+0x2f0>
mov    -0x283c(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x283c(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x283c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x283c(%rbp)
jmp    13cd <main+0x2ad>
lea    -0x2810(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x4,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2840(%rbp)
movl   $0x0,-0x2844(%rbp)
cmpl   $0x2800,-0x2844(%rbp)
jge    147d <main+0x35d>
movslq -0x2844(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2840(%rbp),%eax
mov    %eax,-0x2840(%rbp)
mov    -0x2844(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2844(%rbp)
jmp    143e <main+0x31e>
mov    -0x2840(%rbp),%edx
lea    0x2b79(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2848(%rbp)
cmpl   $0x2800,-0x2848(%rbp)
jge    14e3 <main+0x3c3>
mov    -0x2848(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2848(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2848(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2848(%rbp)
jmp    14a0 <main+0x380>
lea    -0x2810(%rbp),%rdi
add    $0x5,%rdi
mov    $0xa5,%esi
mov    $0x5,%edx
call   1040 <memset@plt>
movl   $0x0,-0x284c(%rbp)
movl   $0x0,-0x2850(%rbp)
cmpl   $0x2800,-0x2850(%rbp)
jge    1550 <main+0x430>
movslq -0x2850(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x284c(%rbp),%eax
mov    %eax,-0x284c(%rbp)
mov    -0x2850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2850(%rbp)
jmp    1511 <main+0x3f1>
mov    -0x284c(%rbp),%edx
lea    0x2aa6(%rip),%rdi
mov    $0x5,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2854(%rbp)
cmpl   $0x2800,-0x2854(%rbp)
jge    15b6 <main+0x496>
mov    -0x2854(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2854(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2854(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2854(%rbp)
jmp    1573 <main+0x453>
lea    -0x2810(%rbp),%rdi
add    $0x6,%rdi
mov    $0xa5,%esi
mov    $0x6,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2858(%rbp)
movl   $0x0,-0x285c(%rbp)
cmpl   $0x2800,-0x285c(%rbp)
jge    1623 <main+0x503>
movslq -0x285c(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2858(%rbp),%eax
mov    %eax,-0x2858(%rbp)
mov    -0x285c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x285c(%rbp)
jmp    15e4 <main+0x4c4>
mov    -0x2858(%rbp),%edx
lea    0x29d3(%rip),%rdi
mov    $0x6,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2860(%rbp)
cmpl   $0x2800,-0x2860(%rbp)
jge    1689 <main+0x569>
mov    -0x2860(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2860(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2860(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2860(%rbp)
jmp    1646 <main+0x526>
lea    -0x2810(%rbp),%rdi
add    $0x7,%rdi
mov    $0xa5,%esi
mov    $0x7,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2864(%rbp)
movl   $0x0,-0x2868(%rbp)
cmpl   $0x2800,-0x2868(%rbp)
jge    16f6 <main+0x5d6>
movslq -0x2868(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2864(%rbp),%eax
mov    %eax,-0x2864(%rbp)
mov    -0x2868(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2868(%rbp)
jmp    16b7 <main+0x597>
mov    -0x2864(%rbp),%edx
lea    0x2900(%rip),%rdi
mov    $0x7,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x286c(%rbp)
cmpl   $0x2800,-0x286c(%rbp)
jge    175c <main+0x63c>
mov    -0x286c(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x286c(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x286c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x286c(%rbp)
jmp    1719 <main+0x5f9>
lea    -0x2810(%rbp),%rdi
add    $0x8,%rdi
mov    $0xa5,%esi
mov    $0x8,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2870(%rbp)
movl   $0x0,-0x2874(%rbp)
cmpl   $0x2800,-0x2874(%rbp)
jge    17c9 <main+0x6a9>
movslq -0x2874(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2870(%rbp),%eax
mov    %eax,-0x2870(%rbp)
mov    -0x2874(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2874(%rbp)
jmp    178a <main+0x66a>
mov    -0x2870(%rbp),%edx
lea    0x282d(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2878(%rbp)
cmpl   $0x2800,-0x2878(%rbp)
jge    182f <main+0x70f>
mov    -0x2878(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2878(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2878(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2878(%rbp)
jmp    17ec <main+0x6cc>
lea    -0x2810(%rbp),%rdi
add    $0x9,%rdi
mov    $0xa5,%esi
mov    $0x9,%edx
call   1040 <memset@plt>
movl   $0x0,-0x287c(%rbp)
movl   $0x0,-0x2880(%rbp)
cmpl   $0x2800,-0x2880(%rbp)
jge    189c <main+0x77c>
movslq -0x2880(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x287c(%rbp),%eax
mov    %eax,-0x287c(%rbp)
mov    -0x2880(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2880(%rbp)
jmp    185d <main+0x73d>
mov    -0x287c(%rbp),%edx
lea    0x275a(%rip),%rdi
mov    $0x9,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2884(%rbp)
cmpl   $0x2800,-0x2884(%rbp)
jge    1902 <main+0x7e2>
mov    -0x2884(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2884(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2884(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2884(%rbp)
jmp    18bf <main+0x79f>
lea    -0x2810(%rbp),%rdi
add    $0xa,%rdi
mov    $0xa5,%esi
mov    $0xa,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2888(%rbp)
movl   $0x0,-0x288c(%rbp)
cmpl   $0x2800,-0x288c(%rbp)
jge    196f <main+0x84f>
movslq -0x288c(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2888(%rbp),%eax
mov    %eax,-0x2888(%rbp)
mov    -0x288c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x288c(%rbp)
jmp    1930 <main+0x810>
mov    -0x2888(%rbp),%edx
lea    0x2687(%rip),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2890(%rbp)
cmpl   $0x2800,-0x2890(%rbp)
jge    19d5 <main+0x8b5>
mov    -0x2890(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x2890(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x2890(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2890(%rbp)
jmp    1992 <main+0x872>
lea    -0x2810(%rbp),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
movl   $0x0,-0x2894(%rbp)
movl   $0x0,-0x2898(%rbp)
cmpl   $0x2800,-0x2898(%rbp)
jge    1a42 <main+0x922>
movslq -0x2898(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x2894(%rbp),%eax
mov    %eax,-0x2894(%rbp)
mov    -0x2898(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2898(%rbp)
jmp    1a03 <main+0x8e3>
mov    -0x2894(%rbp),%edx
lea    0x25b4(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x289c(%rbp)
cmpl   $0x2800,-0x289c(%rbp)
jge    1aa8 <main+0x988>
mov    -0x289c(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x289c(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x289c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x289c(%rbp)
jmp    1a65 <main+0x945>
lea    -0x2810(%rbp),%rdi
add    $0xf,%rdi
mov    $0xa5,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28a0(%rbp)
movl   $0x0,-0x28a4(%rbp)
cmpl   $0x2800,-0x28a4(%rbp)
jge    1b15 <main+0x9f5>
movslq -0x28a4(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28a0(%rbp),%eax
mov    %eax,-0x28a0(%rbp)
mov    -0x28a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28a4(%rbp)
jmp    1ad6 <main+0x9b6>
mov    -0x28a0(%rbp),%edx
lea    0x24e1(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28a8(%rbp)
cmpl   $0x2800,-0x28a8(%rbp)
jge    1b7b <main+0xa5b>
mov    -0x28a8(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28a8(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28a8(%rbp)
jmp    1b38 <main+0xa18>
lea    -0x2810(%rbp),%rdi
add    $0xd,%rdi
mov    $0xa5,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28ac(%rbp)
movl   $0x0,-0x28b0(%rbp)
cmpl   $0x2800,-0x28b0(%rbp)
jge    1be8 <main+0xac8>
movslq -0x28b0(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28ac(%rbp),%eax
mov    %eax,-0x28ac(%rbp)
mov    -0x28b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b0(%rbp)
jmp    1ba9 <main+0xa89>
mov    -0x28ac(%rbp),%edx
lea    0x240e(%rip),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28b4(%rbp)
cmpl   $0x2800,-0x28b4(%rbp)
jge    1c4e <main+0xb2e>
mov    -0x28b4(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28b4(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b4(%rbp)
jmp    1c0b <main+0xaeb>
lea    -0x2810(%rbp),%rdi
add    $0x9,%rdi
mov    $0xa5,%esi
mov    $0x80,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28b8(%rbp)
movl   $0x0,-0x28bc(%rbp)
cmpl   $0x2800,-0x28bc(%rbp)
jge    1cbb <main+0xb9b>
movslq -0x28bc(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28b8(%rbp),%eax
mov    %eax,-0x28b8(%rbp)
mov    -0x28bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
jmp    1c7c <main+0xb5c>
mov    -0x28b8(%rbp),%edx
lea    0x233b(%rip),%rdi
mov    $0x80,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28c0(%rbp)
cmpl   $0x2800,-0x28c0(%rbp)
jge    1d21 <main+0xc01>
mov    -0x28c0(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28c0(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28c0(%rbp)
jmp    1cde <main+0xbbe>
lea    -0x2810(%rbp),%rdi
add    $0x1,%rdi
mov    $0xa5,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28c4(%rbp)
movl   $0x0,-0x28c8(%rbp)
cmpl   $0x2800,-0x28c8(%rbp)
jge    1d8e <main+0xc6e>
movslq -0x28c8(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28c4(%rbp),%eax
mov    %eax,-0x28c4(%rbp)
mov    -0x28c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28c8(%rbp)
jmp    1d4f <main+0xc2f>
mov    -0x28c4(%rbp),%edx
lea    0x2268(%rip),%rdi
mov    $0x100,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28cc(%rbp)
cmpl   $0x2800,-0x28cc(%rbp)
jge    1df4 <main+0xcd4>
mov    -0x28cc(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28cc(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28cc(%rbp)
jmp    1db1 <main+0xc91>
lea    -0x2810(%rbp),%rdi
add    $0x2,%rdi
mov    $0xa5,%esi
mov    $0x200,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28d0(%rbp)
movl   $0x0,-0x28d4(%rbp)
cmpl   $0x2800,-0x28d4(%rbp)
jge    1e61 <main+0xd41>
movslq -0x28d4(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28d0(%rbp),%eax
mov    %eax,-0x28d0(%rbp)
mov    -0x28d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28d4(%rbp)
jmp    1e22 <main+0xd02>
mov    -0x28d0(%rbp),%edx
lea    0x2195(%rip),%rdi
mov    $0x200,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x28d8(%rbp)
cmpl   $0x2800,-0x28d8(%rbp)
jge    1ec7 <main+0xda7>
mov    -0x28d8(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28d8(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28d8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28d8(%rbp)
jmp    1e84 <main+0xd64>
lea    -0x2810(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
movl   $0x0,-0x28dc(%rbp)
movl   $0x0,-0x28e0(%rbp)
cmpl   $0x2800,-0x28e0(%rbp)
jge    1f34 <main+0xe14>
movslq -0x28e0(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
ff
add    -0x28dc(%rbp),%eax
mov    %eax,-0x28dc(%rbp)
mov    -0x28e0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28e0(%rbp)
jmp    1ef5 <main+0xdd5>
mov    -0x28dc(%rbp),%edx
lea    0x20c2(%rip),%rdi
mov    $0x400,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xa,-0x28e4(%rbp)
cmpl   $0x64,-0x28e4(%rbp)
jge    205e <main+0xf3e>
movl   $0x0,-0x28e8(%rbp)
cmpl   $0x2800,-0x28e8(%rbp)
jge    1fb1 <main+0xe91>
mov    -0x28e8(%rbp),%eax
mov    -0x2814(%rbp),%ecx
imul   %ecx,%eax
mov    %al,%cl
movslq -0x28e8(%rbp),%rax
mov    %cl,-0x2810(%rbp,%rax,1)
mov    -0x28e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28e8(%rbp)
jmp    1f6e <main+0xe4e>
lea    -0x2810(%rbp),%rdi
mov    -0x28e4(%rbp),%eax
mov    $0x11,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
add    %rax,%rdi
movslq -0x28e4(%rbp),%rdx
mov    $0xa5,%esi
call   1040 <memset@plt>
movl   $0x0,-0x28ec(%rbp)
movl   $0x0,-0x28f0(%rbp)
cmpl   $0x2800,-0x28f0(%rbp)
jge    2030 <main+0xf10>
movslq -0x28f0(%rbp),%rax
movzbl -0x2810(%rbp,%rax,1),%eax
add    -0x28ec(%rbp),%eax
mov    %eax,-0x28ec(%rbp)
mov    -0x28f0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28f0(%rbp)
jmp    1ff1 <main+0xed1>
mov    -0x28e4(%rbp),%esi
mov    -0x28ec(%rbp),%edx
lea    0x1fc0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28e4(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x28e4(%rbp)
jmp    1f57 <main+0xe37>
lea    0x1fab(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7b,-0x78f4(%rbp)
movl   $0x0,-0x78f8(%rbp)
cmpl   $0x2800,-0x78f8(%rbp)
jge    20c5 <main+0xfa5>
mov    -0x78f8(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x78f8(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x78f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78f8(%rbp)
jmp    2080 <main+0xf60>
lea    -0x78f0(%rbp),%rdi
add    $0x2,%rdi
mov    $0xa5,%esi
mov    $0x1,%edx
call   1040 <memset@plt>
movl   $0x0,-0x78fc(%rbp)
movl   $0x0,-0x7900(%rbp)
cmpl   $0x2800,-0x7900(%rbp)
jge    2132 <main+0x1012>
movslq -0x7900(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x78fc(%rbp),%eax
mov    %eax,-0x78fc(%rbp)
mov    -0x7900(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7900(%rbp)
jmp    20f3 <main+0xfd3>
mov    -0x78fc(%rbp),%edx
lea    0x1ec4(%rip),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7904(%rbp)
cmpl   $0x2800,-0x7904(%rbp)
jge    219a <main+0x107a>
mov    -0x7904(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7904(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7904(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7904(%rbp)
jmp    2155 <main+0x1035>
lea    -0x78f0(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x2,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7908(%rbp)
movl   $0x0,-0x790c(%rbp)
cmpl   $0x2800,-0x790c(%rbp)
jge    2207 <main+0x10e7>
movslq -0x790c(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7908(%rbp),%eax
mov    %eax,-0x7908(%rbp)
mov    -0x790c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x790c(%rbp)
jmp    21c8 <main+0x10a8>
mov    -0x7908(%rbp),%edx
lea    0x1def(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7910(%rbp)
cmpl   $0x2800,-0x7910(%rbp)
jge    226f <main+0x114f>
mov    -0x7910(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7910(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7910(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7910(%rbp)
jmp    222a <main+0x110a>
lea    -0x78f0(%rbp),%rdi
add    $0x6,%rdi
mov    $0xa5,%esi
mov    $0x3,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7914(%rbp)
movl   $0x0,-0x7918(%rbp)
cmpl   $0x2800,-0x7918(%rbp)
jge    22dc <main+0x11bc>
movslq -0x7918(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7914(%rbp),%eax
mov    %eax,-0x7914(%rbp)
mov    -0x7918(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7918(%rbp)
jmp    229d <main+0x117d>
mov    -0x7914(%rbp),%edx
lea    0x1d1a(%rip),%rdi
mov    $0x3,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x791c(%rbp)
cmpl   $0x2800,-0x791c(%rbp)
jge    2344 <main+0x1224>
mov    -0x791c(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x791c(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x791c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x791c(%rbp)
jmp    22ff <main+0x11df>
lea    -0x78f0(%rbp),%rdi
add    $0x8,%rdi
mov    $0xa5,%esi
mov    $0x4,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7920(%rbp)
movl   $0x0,-0x7924(%rbp)
cmpl   $0x2800,-0x7924(%rbp)
jge    23b1 <main+0x1291>
movslq -0x7924(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7920(%rbp),%eax
mov    %eax,-0x7920(%rbp)
mov    -0x7924(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7924(%rbp)
jmp    2372 <main+0x1252>
mov    -0x7920(%rbp),%edx
lea    0x1c45(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7928(%rbp)
cmpl   $0x2800,-0x7928(%rbp)
jge    2419 <main+0x12f9>
mov    -0x7928(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7928(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7928(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7928(%rbp)
jmp    23d4 <main+0x12b4>
lea    -0x78f0(%rbp),%rdi
add    $0xa,%rdi
mov    $0xa5,%esi
mov    $0x5,%edx
call   1040 <memset@plt>
movl   $0x0,-0x792c(%rbp)
movl   $0x0,-0x7930(%rbp)
cmpl   $0x2800,-0x7930(%rbp)
jge    2486 <main+0x1366>
movslq -0x7930(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x792c(%rbp),%eax
mov    %eax,-0x792c(%rbp)
mov    -0x7930(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7930(%rbp)
jmp    2447 <main+0x1327>
mov    -0x792c(%rbp),%edx
lea    0x1b70(%rip),%rdi
mov    $0x5,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7934(%rbp)
cmpl   $0x2800,-0x7934(%rbp)
jge    24ee <main+0x13ce>
mov    -0x7934(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7934(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7934(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7934(%rbp)
jmp    24a9 <main+0x1389>
lea    -0x78f0(%rbp),%rdi
add    $0xc,%rdi
mov    $0xa5,%esi
mov    $0x6,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7938(%rbp)
movl   $0x0,-0x793c(%rbp)
cmpl   $0x2800,-0x793c(%rbp)
jge    255b <main+0x143b>
movslq -0x793c(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7938(%rbp),%eax
mov    %eax,-0x7938(%rbp)
mov    -0x793c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x793c(%rbp)
jmp    251c <main+0x13fc>
mov    -0x7938(%rbp),%edx
lea    0x1a9b(%rip),%rdi
mov    $0x6,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7940(%rbp)
cmpl   $0x2800,-0x7940(%rbp)
jge    25c3 <main+0x14a3>
mov    -0x7940(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7940(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7940(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7940(%rbp)
jmp    257e <main+0x145e>
lea    -0x78f0(%rbp),%rdi
add    $0xe,%rdi
mov    $0xa5,%esi
mov    $0x7,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7944(%rbp)
movl   $0x0,-0x7948(%rbp)
cmpl   $0x2800,-0x7948(%rbp)
jge    2630 <main+0x1510>
movslq -0x7948(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7944(%rbp),%eax
mov    %eax,-0x7944(%rbp)
mov    -0x7948(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7948(%rbp)
jmp    25f1 <main+0x14d1>
mov    -0x7944(%rbp),%edx
lea    0x19c6(%rip),%rdi
mov    $0x7,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x794c(%rbp)
cmpl   $0x2800,-0x794c(%rbp)
jge    2698 <main+0x1578>
mov    -0x794c(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x794c(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x794c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x794c(%rbp)
jmp    2653 <main+0x1533>
lea    -0x78f0(%rbp),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    $0x8,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7950(%rbp)
movl   $0x0,-0x7954(%rbp)
cmpl   $0x2800,-0x7954(%rbp)
jge    2705 <main+0x15e5>
movslq -0x7954(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7950(%rbp),%eax
mov    %eax,-0x7950(%rbp)
mov    -0x7954(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7954(%rbp)
jmp    26c6 <main+0x15a6>
mov    -0x7950(%rbp),%edx
lea    0x18f1(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7958(%rbp)
cmpl   $0x2800,-0x7958(%rbp)
jge    276d <main+0x164d>
mov    -0x7958(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7958(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7958(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7958(%rbp)
jmp    2728 <main+0x1608>
lea    -0x78f0(%rbp),%rdi
add    $0x12,%rdi
mov    $0xa5,%esi
mov    $0x9,%edx
call   1040 <memset@plt>
movl   $0x0,-0x795c(%rbp)
movl   $0x0,-0x7960(%rbp)
cmpl   $0x2800,-0x7960(%rbp)
jge    27da <main+0x16ba>
movslq -0x7960(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x795c(%rbp),%eax
mov    %eax,-0x795c(%rbp)
mov    -0x7960(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7960(%rbp)
jmp    279b <main+0x167b>
mov    -0x795c(%rbp),%edx
lea    0x181c(%rip),%rdi
mov    $0x9,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7964(%rbp)
cmpl   $0x2800,-0x7964(%rbp)
jge    2842 <main+0x1722>
mov    -0x7964(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7964(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7964(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7964(%rbp)
jmp    27fd <main+0x16dd>
lea    -0x78f0(%rbp),%rdi
add    $0x14,%rdi
mov    $0xa5,%esi
mov    $0xa,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7968(%rbp)
movl   $0x0,-0x796c(%rbp)
cmpl   $0x2800,-0x796c(%rbp)
jge    28af <main+0x178f>
movslq -0x796c(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7968(%rbp),%eax
mov    %eax,-0x7968(%rbp)
mov    -0x796c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x796c(%rbp)
jmp    2870 <main+0x1750>
mov    -0x7968(%rbp),%edx
lea    0x1747(%rip),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7970(%rbp)
cmpl   $0x2800,-0x7970(%rbp)
jge    2917 <main+0x17f7>
mov    -0x7970(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7970(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7970(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7970(%rbp)
jmp    28d2 <main+0x17b2>
lea    -0x78f0(%rbp),%rdi
add    $0x20,%rdi
mov    $0xa5,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7974(%rbp)
movl   $0x0,-0x7978(%rbp)
cmpl   $0x2800,-0x7978(%rbp)
jge    2984 <main+0x1864>
movslq -0x7978(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7974(%rbp),%eax
mov    %eax,-0x7974(%rbp)
mov    -0x7978(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7978(%rbp)
jmp    2945 <main+0x1825>
mov    -0x7974(%rbp),%edx
lea    0x1672(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x797c(%rbp)
cmpl   $0x2800,-0x797c(%rbp)
jge    29ec <main+0x18cc>
mov    -0x797c(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x797c(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x797c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x797c(%rbp)
jmp    29a7 <main+0x1887>
lea    -0x78f0(%rbp),%rdi
add    $0x1e,%rdi
mov    $0xa5,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7980(%rbp)
movl   $0x0,-0x7984(%rbp)
cmpl   $0x2800,-0x7984(%rbp)
jge    2a59 <main+0x1939>
movslq -0x7984(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7980(%rbp),%eax
mov    %eax,-0x7980(%rbp)
mov    -0x7984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7984(%rbp)
jmp    2a1a <main+0x18fa>
mov    -0x7980(%rbp),%edx
lea    0x159d(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7988(%rbp)
cmpl   $0x2800,-0x7988(%rbp)
jge    2ac1 <main+0x19a1>
mov    -0x7988(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7988(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7988(%rbp)
jmp    2a7c <main+0x195c>
lea    -0x78f0(%rbp),%rdi
add    $0x1a,%rdi
mov    $0xa5,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0x0,-0x798c(%rbp)
movl   $0x0,-0x7990(%rbp)
cmpl   $0x2800,-0x7990(%rbp)
jge    2b2e <main+0x1a0e>
movslq -0x7990(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x798c(%rbp),%eax
mov    %eax,-0x798c(%rbp)
mov    -0x7990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7990(%rbp)
jmp    2aef <main+0x19cf>
mov    -0x798c(%rbp),%edx
lea    0x14c8(%rip),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x7994(%rbp)
cmpl   $0x2800,-0x7994(%rbp)
jge    2b96 <main+0x1a76>
mov    -0x7994(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x7994(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x7994(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7994(%rbp)
jmp    2b51 <main+0x1a31>
lea    -0x78f0(%rbp),%rdi
add    $0x12,%rdi
mov    $0xa5,%esi
mov    $0x80,%edx
call   1040 <memset@plt>
movl   $0x0,-0x7998(%rbp)
movl   $0x0,-0x799c(%rbp)
cmpl   $0x2800,-0x799c(%rbp)
jge    2c03 <main+0x1ae3>
movslq -0x799c(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x7998(%rbp),%eax
mov    %eax,-0x7998(%rbp)
mov    -0x799c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x799c(%rbp)
jmp    2bc4 <main+0x1aa4>
mov    -0x7998(%rbp),%edx
lea    0x13f3(%rip),%rdi
mov    $0x80,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x79a0(%rbp)
cmpl   $0x2800,-0x79a0(%rbp)
jge    2c6b <main+0x1b4b>
mov    -0x79a0(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x79a0(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x79a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79a0(%rbp)
jmp    2c26 <main+0x1b06>
lea    -0x78f0(%rbp),%rdi
add    $0x2,%rdi
mov    $0xa5,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
movl   $0x0,-0x79a4(%rbp)
movl   $0x0,-0x79a8(%rbp)
cmpl   $0x2800,-0x79a8(%rbp)
jge    2cd8 <main+0x1bb8>
movslq -0x79a8(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x79a4(%rbp),%eax
mov    %eax,-0x79a4(%rbp)
mov    -0x79a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79a8(%rbp)
jmp    2c99 <main+0x1b79>
mov    -0x79a4(%rbp),%edx
lea    0x131e(%rip),%rdi
mov    $0x100,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x79ac(%rbp)
cmpl   $0x2800,-0x79ac(%rbp)
jge    2d40 <main+0x1c20>
mov    -0x79ac(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x79ac(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x79ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79ac(%rbp)
jmp    2cfb <main+0x1bdb>
lea    -0x78f0(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x200,%edx
call   1040 <memset@plt>
movl   $0x0,-0x79b0(%rbp)
movl   $0x0,-0x79b4(%rbp)
cmpl   $0x2800,-0x79b4(%rbp)
jge    2dad <main+0x1c8d>
movslq -0x79b4(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x79b0(%rbp),%eax
mov    %eax,-0x79b0(%rbp)
mov    -0x79b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79b4(%rbp)
jmp    2d6e <main+0x1c4e>
mov    -0x79b0(%rbp),%edx
lea    0x1249(%rip),%rdi
mov    $0x200,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x79b8(%rbp)
cmpl   $0x2800,-0x79b8(%rbp)
jge    2e15 <main+0x1cf5>
mov    -0x79b8(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x79b8(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
mov    -0x79b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79b8(%rbp)
jmp    2dd0 <main+0x1cb0>
lea    -0x78f0(%rbp),%rdi
add    $0x8,%rdi
mov    $0xa5,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
movl   $0x0,-0x79bc(%rbp)
movl   $0x0,-0x79c0(%rbp)
cmpl   $0x2800,-0x79c0(%rbp)
jge    2e82 <main+0x1d62>
movslq -0x79c0(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x79bc(%rbp),%eax
mov    %eax,-0x79bc(%rbp)
mov    -0x79c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79c0(%rbp)
jmp    2e43 <main+0x1d23>
mov    -0x79bc(%rbp),%edx
lea    0x1174(%rip),%rdi
mov    $0x400,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xa,-0x79c4(%rbp)
cmpl   $0x64,-0x79c4(%rbp)
jge    2fb2 <main+0x1e92>
movl   $0x0,-0x79c8(%rbp)
cmpl   $0x2800,-0x79c8(%rbp)
jge    2f01 <main+0x1de1>
mov    -0x79c8(%rbp),%eax
mov    -0x78f4(%rbp),%ecx
imul   %ecx,%eax
mov    %ax,%cx
movslq -0x79c8(%rbp),%rax
mov    %cx,-0x78f0(%rbp,%rax,2)
ff
mov    -0x79c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79c8(%rbp)
jmp    2ebc <main+0x1d9c>
lea    -0x78f0(%rbp),%rdi
mov    -0x79c4(%rbp),%eax
mov    $0x11,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
shl    $0x1,%rax
add    %rax,%rdi
movslq -0x79c4(%rbp),%rdx
mov    $0xa5,%esi
call   1040 <memset@plt>
movl   $0x0,-0x79cc(%rbp)
movl   $0x0,-0x79d0(%rbp)
cmpl   $0x2800,-0x79d0(%rbp)
jge    2f84 <main+0x1e64>
movslq -0x79d0(%rbp),%rax
movzwl -0x78f0(%rbp,%rax,2),%eax
ff
add    -0x79cc(%rbp),%eax
mov    %eax,-0x79cc(%rbp)
mov    -0x79d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x79d0(%rbp)
jmp    2f45 <main+0x1e25>
mov    -0x79c4(%rbp),%esi
mov    -0x79cc(%rbp),%edx
lea    0x106c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x79c4(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x79c4(%rbp)
jmp    2ea5 <main+0x1d85>
lea    0x105b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x7b,-0x119d4(%rbp)
movl   $0x0,-0x119d8(%rbp)
cmpl   $0x2800,-0x119d8(%rbp)
jge    3015 <main+0x1ef5>
mov    -0x119d8(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x119d8(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x119d8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119d8(%rbp)
jmp    2fd4 <main+0x1eb4>
lea    -0x119d0(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x1,%edx
call   1040 <memset@plt>
movl   $0x0,-0x119dc(%rbp)
movl   $0x0,-0x119e0(%rbp)
cmpl   $0x2800,-0x119e0(%rbp)
jge    3081 <main+0x1f61>
movslq -0x119e0(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x119dc(%rbp),%eax
mov    %eax,-0x119dc(%rbp)
mov    -0x119e0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119e0(%rbp)
jmp    3043 <main+0x1f23>
mov    -0x119dc(%rbp),%edx
lea    0xf75(%rip),%rdi
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x119e4(%rbp)
cmpl   $0x2800,-0x119e4(%rbp)
jge    30e5 <main+0x1fc5>
mov    -0x119e4(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x119e4(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x119e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119e4(%rbp)
jmp    30a4 <main+0x1f84>
lea    -0x119d0(%rbp),%rdi
add    $0x8,%rdi
mov    $0xa5,%esi
mov    $0x2,%edx
call   1040 <memset@plt>
movl   $0x0,-0x119e8(%rbp)
movl   $0x0,-0x119ec(%rbp)
cmpl   $0x2800,-0x119ec(%rbp)
jge    3151 <main+0x2031>
movslq -0x119ec(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x119e8(%rbp),%eax
mov    %eax,-0x119e8(%rbp)
mov    -0x119ec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119ec(%rbp)
jmp    3113 <main+0x1ff3>
mov    -0x119e8(%rbp),%edx
lea    0xea5(%rip),%rdi
mov    $0x2,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x119f0(%rbp)
cmpl   $0x2800,-0x119f0(%rbp)
jge    31b5 <main+0x2095>
mov    -0x119f0(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x119f0(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x119f0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119f0(%rbp)
jmp    3174 <main+0x2054>
lea    -0x119d0(%rbp),%rdi
add    $0xc,%rdi
mov    $0xa5,%esi
mov    $0x3,%edx
call   1040 <memset@plt>
movl   $0x0,-0x119f4(%rbp)
movl   $0x0,-0x119f8(%rbp)
cmpl   $0x2800,-0x119f8(%rbp)
jge    3221 <main+0x2101>
movslq -0x119f8(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x119f4(%rbp),%eax
mov    %eax,-0x119f4(%rbp)
mov    -0x119f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119f8(%rbp)
jmp    31e3 <main+0x20c3>
mov    -0x119f4(%rbp),%edx
lea    0xdd5(%rip),%rdi
mov    $0x3,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x119fc(%rbp)
cmpl   $0x2800,-0x119fc(%rbp)
jge    3285 <main+0x2165>
mov    -0x119fc(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x119fc(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x119fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x119fc(%rbp)
jmp    3244 <main+0x2124>
lea    -0x119d0(%rbp),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    $0x4,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a00(%rbp)
movl   $0x0,-0x11a04(%rbp)
cmpl   $0x2800,-0x11a04(%rbp)
jge    32f1 <main+0x21d1>
movslq -0x11a04(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a00(%rbp),%eax
mov    %eax,-0x11a00(%rbp)
mov    -0x11a04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a04(%rbp)
jmp    32b3 <main+0x2193>
mov    -0x11a00(%rbp),%edx
lea    0xd05(%rip),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a08(%rbp)
cmpl   $0x2800,-0x11a08(%rbp)
jge    3355 <main+0x2235>
mov    -0x11a08(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a08(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a08(%rbp)
jmp    3314 <main+0x21f4>
lea    -0x119d0(%rbp),%rdi
add    $0x14,%rdi
mov    $0xa5,%esi
mov    $0x5,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a0c(%rbp)
movl   $0x0,-0x11a10(%rbp)
cmpl   $0x2800,-0x11a10(%rbp)
jge    33c1 <main+0x22a1>
movslq -0x11a10(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a0c(%rbp),%eax
mov    %eax,-0x11a0c(%rbp)
mov    -0x11a10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a10(%rbp)
jmp    3383 <main+0x2263>
mov    -0x11a0c(%rbp),%edx
lea    0xc35(%rip),%rdi
mov    $0x5,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a14(%rbp)
cmpl   $0x2800,-0x11a14(%rbp)
jge    3425 <main+0x2305>
mov    -0x11a14(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a14(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a14(%rbp)
jmp    33e4 <main+0x22c4>
lea    -0x119d0(%rbp),%rdi
add    $0x18,%rdi
mov    $0xa5,%esi
mov    $0x6,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a18(%rbp)
movl   $0x0,-0x11a1c(%rbp)
cmpl   $0x2800,-0x11a1c(%rbp)
jge    3491 <main+0x2371>
movslq -0x11a1c(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a18(%rbp),%eax
mov    %eax,-0x11a18(%rbp)
mov    -0x11a1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a1c(%rbp)
jmp    3453 <main+0x2333>
mov    -0x11a18(%rbp),%edx
lea    0xb65(%rip),%rdi
mov    $0x6,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a20(%rbp)
cmpl   $0x2800,-0x11a20(%rbp)
jge    34f5 <main+0x23d5>
mov    -0x11a20(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a20(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a20(%rbp)
jmp    34b4 <main+0x2394>
lea    -0x119d0(%rbp),%rdi
add    $0x1c,%rdi
mov    $0xa5,%esi
mov    $0x7,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a24(%rbp)
movl   $0x0,-0x11a28(%rbp)
cmpl   $0x2800,-0x11a28(%rbp)
jge    3561 <main+0x2441>
movslq -0x11a28(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a24(%rbp),%eax
mov    %eax,-0x11a24(%rbp)
mov    -0x11a28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a28(%rbp)
jmp    3523 <main+0x2403>
mov    -0x11a24(%rbp),%edx
lea    0xa95(%rip),%rdi
mov    $0x7,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a2c(%rbp)
cmpl   $0x2800,-0x11a2c(%rbp)
jge    35c5 <main+0x24a5>
mov    -0x11a2c(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a2c(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a2c(%rbp)
jmp    3584 <main+0x2464>
lea    -0x119d0(%rbp),%rdi
add    $0x20,%rdi
mov    $0xa5,%esi
mov    $0x8,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a30(%rbp)
movl   $0x0,-0x11a34(%rbp)
cmpl   $0x2800,-0x11a34(%rbp)
jge    3631 <main+0x2511>
movslq -0x11a34(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a30(%rbp),%eax
mov    %eax,-0x11a30(%rbp)
mov    -0x11a34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a34(%rbp)
jmp    35f3 <main+0x24d3>
mov    -0x11a30(%rbp),%edx
lea    0x9c5(%rip),%rdi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a38(%rbp)
cmpl   $0x2800,-0x11a38(%rbp)
jge    3695 <main+0x2575>
mov    -0x11a38(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a38(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a38(%rbp)
jmp    3654 <main+0x2534>
lea    -0x119d0(%rbp),%rdi
add    $0x24,%rdi
mov    $0xa5,%esi
mov    $0x9,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a3c(%rbp)
movl   $0x0,-0x11a40(%rbp)
cmpl   $0x2800,-0x11a40(%rbp)
jge    3701 <main+0x25e1>
movslq -0x11a40(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a3c(%rbp),%eax
mov    %eax,-0x11a3c(%rbp)
mov    -0x11a40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a40(%rbp)
jmp    36c3 <main+0x25a3>
mov    -0x11a3c(%rbp),%edx
lea    0x8f5(%rip),%rdi
mov    $0x9,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a44(%rbp)
cmpl   $0x2800,-0x11a44(%rbp)
jge    3765 <main+0x2645>
mov    -0x11a44(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a44(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a44(%rbp)
jmp    3724 <main+0x2604>
lea    -0x119d0(%rbp),%rdi
add    $0x28,%rdi
mov    $0xa5,%esi
mov    $0xa,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a48(%rbp)
movl   $0x0,-0x11a4c(%rbp)
cmpl   $0x2800,-0x11a4c(%rbp)
jge    37d1 <main+0x26b1>
movslq -0x11a4c(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a48(%rbp),%eax
mov    %eax,-0x11a48(%rbp)
mov    -0x11a4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a4c(%rbp)
jmp    3793 <main+0x2673>
mov    -0x11a48(%rbp),%edx
lea    0x825(%rip),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a50(%rbp)
cmpl   $0x2800,-0x11a50(%rbp)
jge    3835 <main+0x2715>
mov    -0x11a50(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a50(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a50(%rbp)
jmp    37f4 <main+0x26d4>
lea    -0x119d0(%rbp),%rdi
add    $0x40,%rdi
mov    $0xa5,%esi
mov    $0x10,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a54(%rbp)
movl   $0x0,-0x11a58(%rbp)
cmpl   $0x2800,-0x11a58(%rbp)
jge    38a1 <main+0x2781>
movslq -0x11a58(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a54(%rbp),%eax
mov    %eax,-0x11a54(%rbp)
mov    -0x11a58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a58(%rbp)
jmp    3863 <main+0x2743>
mov    -0x11a54(%rbp),%edx
lea    0x755(%rip),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a5c(%rbp)
cmpl   $0x2800,-0x11a5c(%rbp)
jge    3905 <main+0x27e5>
mov    -0x11a5c(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a5c(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a5c(%rbp)
jmp    38c4 <main+0x27a4>
lea    -0x119d0(%rbp),%rdi
add    $0x3c,%rdi
mov    $0xa5,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a60(%rbp)
movl   $0x0,-0x11a64(%rbp)
cmpl   $0x2800,-0x11a64(%rbp)
jge    3971 <main+0x2851>
movslq -0x11a64(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a60(%rbp),%eax
mov    %eax,-0x11a60(%rbp)
mov    -0x11a64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a64(%rbp)
jmp    3933 <main+0x2813>
mov    -0x11a60(%rbp),%edx
lea    0x685(%rip),%rdi
mov    $0x20,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a68(%rbp)
cmpl   $0x2800,-0x11a68(%rbp)
jge    39d5 <main+0x28b5>
mov    -0x11a68(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a68(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a68(%rbp)
jmp    3994 <main+0x2874>
lea    -0x119d0(%rbp),%rdi
add    $0x34,%rdi
mov    $0xa5,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a6c(%rbp)
movl   $0x0,-0x11a70(%rbp)
cmpl   $0x2800,-0x11a70(%rbp)
jge    3a41 <main+0x2921>
movslq -0x11a70(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a6c(%rbp),%eax
mov    %eax,-0x11a6c(%rbp)
mov    -0x11a70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a70(%rbp)
jmp    3a03 <main+0x28e3>
mov    -0x11a6c(%rbp),%edx
lea    0x5b5(%rip),%rdi
mov    $0x40,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a74(%rbp)
cmpl   $0x2800,-0x11a74(%rbp)
jge    3aa5 <main+0x2985>
mov    -0x11a74(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a74(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a74(%rbp)
jmp    3a64 <main+0x2944>
lea    -0x119d0(%rbp),%rdi
add    $0x24,%rdi
mov    $0xa5,%esi
mov    $0x80,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a78(%rbp)
movl   $0x0,-0x11a7c(%rbp)
cmpl   $0x2800,-0x11a7c(%rbp)
jge    3b11 <main+0x29f1>
movslq -0x11a7c(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a78(%rbp),%eax
mov    %eax,-0x11a78(%rbp)
mov    -0x11a7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a7c(%rbp)
jmp    3ad3 <main+0x29b3>
mov    -0x11a78(%rbp),%edx
lea    0x4e5(%rip),%rdi
mov    $0x80,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a80(%rbp)
cmpl   $0x2800,-0x11a80(%rbp)
jge    3b75 <main+0x2a55>
mov    -0x11a80(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a80(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a80(%rbp)
jmp    3b34 <main+0x2a14>
lea    -0x119d0(%rbp),%rdi
add    $0x4,%rdi
mov    $0xa5,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a84(%rbp)
movl   $0x0,-0x11a88(%rbp)
cmpl   $0x2800,-0x11a88(%rbp)
jge    3be1 <main+0x2ac1>
movslq -0x11a88(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a84(%rbp),%eax
mov    %eax,-0x11a84(%rbp)
mov    -0x11a88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a88(%rbp)
jmp    3ba3 <main+0x2a83>
mov    -0x11a84(%rbp),%edx
lea    0x415(%rip),%rdi
mov    $0x100,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a8c(%rbp)
cmpl   $0x2800,-0x11a8c(%rbp)
jge    3c45 <main+0x2b25>
mov    -0x11a8c(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a8c(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a8c(%rbp)
jmp    3c04 <main+0x2ae4>
lea    -0x119d0(%rbp),%rdi
add    $0x8,%rdi
mov    $0xa5,%esi
mov    $0x200,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a90(%rbp)
movl   $0x0,-0x11a94(%rbp)
cmpl   $0x2800,-0x11a94(%rbp)
jge    3cb1 <main+0x2b91>
movslq -0x11a94(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a90(%rbp),%eax
mov    %eax,-0x11a90(%rbp)
mov    -0x11a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a94(%rbp)
jmp    3c73 <main+0x2b53>
mov    -0x11a90(%rbp),%edx
lea    0x345(%rip),%rdi
mov    $0x200,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x11a98(%rbp)
cmpl   $0x2800,-0x11a98(%rbp)
jge    3d15 <main+0x2bf5>
mov    -0x11a98(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11a98(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11a98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11a98(%rbp)
jmp    3cd4 <main+0x2bb4>
lea    -0x119d0(%rbp),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
movl   $0x0,-0x11a9c(%rbp)
movl   $0x0,-0x11aa0(%rbp)
cmpl   $0x2800,-0x11aa0(%rbp)
jge    3d81 <main+0x2c61>
movslq -0x11aa0(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11a9c(%rbp),%eax
mov    %eax,-0x11a9c(%rbp)
mov    -0x11aa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11aa0(%rbp)
jmp    3d43 <main+0x2c23>
mov    -0x11a9c(%rbp),%edx
lea    0x275(%rip),%rdi
mov    $0x400,%esi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0xa,-0x11aa4(%rbp)
cmpl   $0x64,-0x11aa4(%rbp)
jge    3eac <main+0x2d8c>
movl   $0x0,-0x11aa8(%rbp)
cmpl   $0x2800,-0x11aa8(%rbp)
jge    3dfc <main+0x2cdc>
mov    -0x11aa8(%rbp),%ecx
mov    -0x119d4(%rbp),%eax
imul   %eax,%ecx
movslq -0x11aa8(%rbp),%rax
mov    %ecx,-0x119d0(%rbp,%rax,4)
mov    -0x11aa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11aa8(%rbp)
jmp    3dbb <main+0x2c9b>
lea    -0x119d0(%rbp),%rdi
mov    -0x11aa4(%rbp),%eax
mov    $0x11,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x11aa4(%rbp),%rdx
mov    $0xa5,%esi
call   1040 <memset@plt>
movl   $0x0,-0x11aac(%rbp)
movl   $0x0,-0x11ab0(%rbp)
cmpl   $0x2800,-0x11ab0(%rbp)
jge    3e7e <main+0x2d5e>
movslq -0x11ab0(%rbp),%rax
mov    -0x119d0(%rbp,%rax,4),%eax
add    -0x11aac(%rbp),%eax
mov    %eax,-0x11aac(%rbp)
mov    -0x11ab0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11ab0(%rbp)
jmp    3e40 <main+0x2d20>
mov    -0x11aa4(%rbp),%esi
mov    -0x11aac(%rbp),%edx
lea    0x172(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x11aa4(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x11aa4(%rbp)
jmp    3da4 <main+0x2c84>
mov    $0x1,%eax
add    $0x11ab0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa018,%rsp
lea    0x3ed5(%rip),%rdi
call   1030 <puts@plt>
movl   $0x7b,0xc(%rsp)
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    0xc(%rsp),%ecx
imul   %eax,%ecx
mov    %cl,0x10(%rsp,%rax,1)
lea    0x1(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x11(%rsp,%rax,1)
lea    0x2(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x12(%rsp,%rax,1)
lea    0x3(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x13(%rsp,%rax,1)
lea    0x4(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x14(%rsp,%rax,1)
add    $0x5,%rax
cmp    $0x2800,%rax
jne    1160 <main+0x30>
lea    0x11(%rsp),%r12
movb   $0xa5,0x11(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    11d0 <main+0xa0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x3dcb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1260 <main+0x130>
lea    0x12(%rsp),%r14
movw   $0xa5a5,0x12(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    12d0 <main+0x1a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x3ccb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1360 <main+0x230>
movb   $0xa5,0x15(%rsp)
movw   $0xa5a5,0x13(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    13d0 <main+0x2a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x3bcb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1460 <main+0x330>
lea    0x14(%rsp),%r15
movl   $0xa5a5a5a5,0x14(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    14d0 <main+0x3a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x3acb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1560 <main+0x430>
movb   $0xa5,0x19(%rsp)
movl   $0xa5a5a5a5,0x15(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    15d0 <main+0x4a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x39cb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1660 <main+0x530>
movw   $0xa5a5,0x1a(%rsp)
movl   $0xa5a5a5a5,0x16(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    16d0 <main+0x5a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x38cb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1760 <main+0x630>
movl   $0xa5a5a5a5,0x1a(%rsp)
a5
movl   $0xa5a5a5a5,0x17(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    17d0 <main+0x6a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x37cb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1860 <main+0x730>
movabs $0xa5a5a5a5a5a5a5a5,%r13
a5 a5 a5
mov    %r13,0x18(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    18d0 <main+0x7a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x36cb(%rip),%rdi
xor    %ebx,%ebx
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1960 <main+0x830>
lea    0x19(%rsp),%rbx
mov    %r13,0x19(%rsp)
movb   $0xa5,0x21(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    19d0 <main+0x8a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x35cb(%rip),%rdi
xor    %ebp,%ebp
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebp,%eax
mov    %al,0x10(%rsp,%rbp,1)
lea    0x1(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbp,1)
lea    0x2(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbp,1)
lea    0x3(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbp,1)
lea    0x4(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbp,1)
add    $0x5,%rbp
cmp    $0x2800,%rbp
jne    1a60 <main+0x930>
mov    %r13,0x1a(%rsp)
movw   $0xa5a5,0x22(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    1ad0 <main+0x9a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x34cb(%rip),%rdi
xor    %ebp,%ebp
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebp,%eax
mov    %al,0x10(%rsp,%rbp,1)
lea    0x1(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbp,1)
lea    0x2(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbp,1)
lea    0x3(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbp,1)
lea    0x4(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbp,1)
add    $0x5,%rbp
cmp    $0x2800,%rbp
jne    1b60 <main+0xa30>
movdqa 0x3450(%rip),%xmm0
movdqa %xmm0,0x20(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    1bd0 <main+0xaa0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x33cb(%rip),%rdi
xor    %ebp,%ebp
mov    $0x10,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebp,%eax
mov    %al,0x10(%rsp,%rbp,1)
lea    0x1(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbp,1)
lea    0x2(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbp,1)
lea    0x3(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbp,1)
lea    0x4(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbp,1)
add    $0x5,%rbp
cmp    $0x2800,%rbp
jne    1c60 <main+0xb30>
movdqa 0x3350(%rip),%xmm0
movdqu %xmm0,0x2f(%rsp)
movdqu %xmm0,0x1f(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   (%rax)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    1cd0 <main+0xba0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x32cb(%rip),%rdi
xor    %ebp,%ebp
mov    $0x20,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebp,%eax
mov    %al,0x10(%rsp,%rbp,1)
lea    0x1(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbp,1)
lea    0x2(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbp,1)
lea    0x3(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbp,1)
lea    0x4(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbp,1)
add    $0x5,%rbp
cmp    $0x2800,%rbp
jne    1d60 <main+0xc30>
movdqa 0x3250(%rip),%xmm0
movdqu %xmm0,0x4d(%rsp)
movdqu %xmm0,0x3d(%rsp)
movdqu %xmm0,0x2d(%rsp)
movdqu %xmm0,0x1d(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    1de0 <main+0xcb0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x31bb(%rip),%rdi
xor    %ebp,%ebp
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebp,%eax
mov    %al,0x10(%rsp,%rbp,1)
lea    0x1(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbp,1)
lea    0x2(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbp,1)
lea    0x3(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbp,1)
lea    0x4(%rbp),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbp,1)
add    $0x5,%rbp
cmp    $0x2800,%rbp
jne    1e70 <main+0xd40>
movdqa 0x3140(%rip),%xmm0
movdqu %xmm0,0x70(%rbx)
movdqu %xmm0,0x60(%rbx)
movdqu %xmm0,0x50(%rbx)
movdqu %xmm0,0x40(%rbx)
movdqu %xmm0,0x30(%rbx)
movdqu %xmm0,0x20(%rbx)
movdqu %xmm0,0x10(%rbx)
movdqu %xmm0,(%rbx)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    1f00 <main+0xdd0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x309b(%rip),%rdi
xor    %ebx,%ebx
mov    $0x80,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    1f90 <main+0xe60>
movdqa 0x3020(%rip),%xmm0
movdqu %xmm0,0xf0(%r12)
movdqu %xmm0,0xe0(%r12)
movdqu %xmm0,0xd0(%r12)
movdqu %xmm0,0xc0(%r12)
movdqu %xmm0,0xb0(%r12)
movdqu %xmm0,0xa0(%r12)
movdqu %xmm0,0x90(%r12)
movdqu %xmm0,0x80(%r12)
movdqu %xmm0,0x70(%r12)
movdqu %xmm0,0x60(%r12)
movdqu %xmm0,0x50(%r12)
movdqu %xmm0,0x40(%r12)
movdqu %xmm0,0x30(%r12)
movdqu %xmm0,0x20(%r12)
movdqu %xmm0,0x10(%r12)
movdqu %xmm0,(%r12)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2080 <main+0xf50>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x2f1b(%rip),%rdi
xor    %ebx,%ebx
mov    $0x100,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    2110 <main+0xfe0>
mov    $0x200,%edx
mov    %r14,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2180 <main+0x1050>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x2e1b(%rip),%rdi
xor    %ebx,%ebx
mov    $0x200,%esi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%eax
imul   %ebx,%eax
mov    %al,0x10(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x11(%rsp,%rbx,1)
lea    0x2(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x12(%rsp,%rbx,1)
lea    0x3(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x13(%rsp,%rbx,1)
lea    0x4(%rbx),%eax
imul   0xc(%rsp),%eax
mov    %al,0x14(%rsp,%rbx,1)
add    $0x5,%rbx
cmp    $0x2800,%rbx
jne    2210 <main+0x10e0>
mov    $0x400,%edx
mov    %r15,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa 0x4(%rsp,%rax,1),%xmm3
movd   0x8(%rsp,%rax,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0xc(%rsp,%rax,1),%xmm2
movd   0x10(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2280 <main+0x1150>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x2d1b(%rip),%r15
mov    %r15,%rdi
mov    $0x400,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%ebx
mov    $0xf0f0f0f1,%r12d
nop
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xc(%rsp),%ecx
imul   %eax,%ecx
mov    %cl,0x10(%rsp,%rax,1)
lea    0x1(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x11(%rsp,%rax,1)
lea    0x2(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x12(%rsp,%rax,1)
lea    0x3(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x13(%rsp,%rax,1)
lea    0x4(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cl,0x14(%rsp,%rax,1)
add    $0x5,%rax
cmp    $0x2800,%rax
jne    2320 <main+0x11f0>
mov    %ebx,%eax
imul   %r12,%rax
shr    $0x24,%rax
mov    %eax,%ecx
shl    $0x4,%ecx
add    %eax,%ecx
mov    %ebx,%eax
sub    %ecx,%eax
lea    (%rsp,%rax,1),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
pxor   %xmm1,%xmm1
mov    $0xc,%eax
pxor   %xmm0,%xmm0
pxor   %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa 0x4(%rsp,%rax,1),%xmm2
movd   0x8(%rsp,%rax,1),%xmm3
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm1,%xmm2
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm0,%xmm3
movq   0xc(%rsp,%rax,1),%xmm1
movd   0x10(%rsp,%rax,1),%xmm0
punpcklbw %xmm4,%xmm1
punpcklwd %xmm4,%xmm1
paddd  %xmm2,%xmm1
punpcklbw %xmm4,%xmm0
punpcklwd %xmm4,%xmm0
paddd  %xmm3,%xmm0
add    $0x10,%rax
cmp    $0x280c,%rax
jne    23b0 <main+0x1280>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    %r15,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa(%rbx),%rax
cmp    $0x5a,%rbx
mov    %rax,%rbx
jb     2310 <main+0x11e0>
lea    0x2bdd(%rip),%rdi
call   1030 <puts@plt>
movl   $0x7b,0xc(%rsp)
mov    $0xffffffffffffd800,%rax
cs nopw 0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2460 <main+0x1330>
movb   $0xa5,0x12(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    24e0 <main+0x13b0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x2acc(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2560 <main+0x1430>
lea    0x14(%rsp),%r12
movw   $0xa5a5,0x14(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    25f0 <main+0x14c0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x29bc(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2670 <main+0x1540>
movb   $0xa5,0x18(%rsp)
movw   $0xa5a5,0x16(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2700 <main+0x15d0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x28ac(%rip),%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2780 <main+0x1650>
lea    0x18(%rsp),%r15
movl   $0xa5a5a5a5,0x18(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2810 <main+0x16e0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x279c(%rip),%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2890 <main+0x1760>
movb   $0xa5,0x1e(%rsp)
movl   $0xa5a5a5a5,0x1a(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2920 <main+0x17f0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x268c(%rip),%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    29a0 <main+0x1870>
movw   $0xa5a5,0x20(%rsp)
movl   $0xa5a5a5a5,0x1c(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2a30 <main+0x1900>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x257c(%rip),%rdi
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2ab0 <main+0x1980>
movl   $0xa5a5a5a5,0x21(%rsp)
a5
movl   $0xa5a5a5a5,0x1e(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2b40 <main+0x1a10>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x246c(%rip),%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2bc0 <main+0x1a90>
mov    %r13,0x20(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2c40 <main+0x1b10>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x236c(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2cc0 <main+0x1b90>
lea    0x22(%rsp),%rbx
mov    %r13,0x22(%rsp)
movb   $0xa5,0x2a(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2d50 <main+0x1c20>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x225c(%rip),%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2dd0 <main+0x1ca0>
mov    %r13,0x24(%rsp)
movw   $0xa5a5,0x2c(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2e60 <main+0x1d30>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x214c(%rip),%rdi
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2ee0 <main+0x1db0>
movdqa 0x20b3(%rip),%xmm0
movdqa %xmm0,0x30(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    2f70 <main+0x1e40>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x203c(%rip),%rdi
mov    $0x10,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    2ff0 <main+0x1ec0>
movdqa 0x1fa3(%rip),%xmm0
movdqu %xmm0,0x3e(%rsp)
movdqu %xmm0,0x2e(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    3080 <main+0x1f50>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x1f2c(%rip),%rdi
mov    $0x20,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    3100 <main+0x1fd0>
movdqa 0x1e93(%rip),%xmm0
movdqu %xmm0,0x5a(%rsp)
movdqu %xmm0,0x4a(%rsp)
movdqu %xmm0,0x3a(%rsp)
movdqu %xmm0,0x2a(%rsp)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    31a0 <main+0x2070>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x1e0c(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    3220 <main+0x20f0>
movdqa 0x1d73(%rip),%xmm0
movdqu %xmm0,0x70(%rbx)
movdqu %xmm0,0x60(%rbx)
movdqu %xmm0,0x50(%rbx)
movdqu %xmm0,0x40(%rbx)
movdqu %xmm0,0x30(%rbx)
movdqu %xmm0,0x20(%rbx)
movdqu %xmm0,0x10(%rbx)
movdqu %xmm0,(%rbx)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    32d0 <main+0x21a0>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x1cdc(%rip),%rdi
mov    $0x80,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    3350 <main+0x2220>
movdqa 0x1c43(%rip),%xmm0
movdqu %xmm0,0xf0(%r14)
movdqu %xmm0,0xe0(%r14)
movdqu %xmm0,0xd0(%r14)
movdqu %xmm0,0xc0(%r14)
movdqu %xmm0,0xb0(%r14)
movdqu %xmm0,0xa0(%r14)
movdqu %xmm0,0x90(%r14)
movdqu %xmm0,0x80(%r14)
movdqu %xmm0,0x70(%r14)
movdqu %xmm0,0x60(%r14)
movdqu %xmm0,0x50(%r14)
movdqu %xmm0,0x40(%r14)
movdqu %xmm0,0x30(%r14)
movdqu %xmm0,0x20(%r14)
movdqu %xmm0,0x10(%r14)
movdqu %xmm0,(%r14)
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    3450 <main+0x2320>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x1b5c(%rip),%rdi
mov    $0x100,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    34d0 <main+0x23a0>
mov    $0x200,%edx
mov    %r12,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    3560 <main+0x2430>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x1a4c(%rip),%rdi
mov    $0x200,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    35e0 <main+0x24b0>
mov    $0x400,%edx
mov    %r15,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0xc,%eax
pxor   %xmm2,%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movq   -0x8(%rsp,%rax,2),%xmm3
movq   (%rsp,%rax,2),%xmm4
punpcklwd %xmm0,%xmm3
paddd  %xmm2,%xmm3
punpcklwd %xmm0,%xmm4
paddd  %xmm1,%xmm4
movq   0x8(%rsp,%rax,2),%xmm2
movq   0x10(%rsp,%rax,2),%xmm1
punpcklwd %xmm0,%xmm2
paddd  %xmm3,%xmm2
punpcklwd %xmm0,%xmm1
paddd  %xmm4,%xmm1
add    $0x10,%rax
cmp    $0x280c,%rax
jne    3670 <main+0x2540>
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x193c(%rip),%r14
mov    %r14,%rdi
mov    $0x400,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%ebx
mov    $0xf0f0f0f1,%r15d
xchg   %ax,%ax
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5010(%rsp,%rax,2)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5012(%rsp,%rax,2)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5014(%rsp,%rax,2)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5016(%rsp,%rax,2)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %cx,0x5018(%rsp,%rax,2)
add    $0x5,%rax
jne    3700 <main+0x25d0>
mov    %ebx,%eax
imul   %r15,%rax
shr    $0x24,%rax
mov    %eax,%ecx
shl    $0x4,%ecx
add    %eax,%ecx
mov    %ebx,%eax
sub    %ecx,%eax
lea    (%rsp,%rax,2),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
pxor   %xmm1,%xmm1
mov    $0xc,%eax
pxor   %xmm0,%xmm0
pxor   %xmm4,%xmm4
movq   -0x8(%rsp,%rax,2),%xmm2
movq   (%rsp,%rax,2),%xmm3
punpcklwd %xmm4,%xmm2
paddd  %xmm1,%xmm2
punpcklwd %xmm4,%xmm3
paddd  %xmm0,%xmm3
movq   0x8(%rsp,%rax,2),%xmm1
movq   0x10(%rsp,%rax,2),%xmm0
punpcklwd %xmm4,%xmm1
paddd  %xmm2,%xmm1
punpcklwd %xmm4,%xmm0
paddd  %xmm3,%xmm0
add    $0x10,%rax
cmp    $0x280c,%rax
jne    37a0 <main+0x2670>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa(%rbx),%rax
cmp    $0x5a,%rbx
mov    %rax,%rbx
jb     36f0 <main+0x25c0>
lea    0x1801(%rip),%rdi
call   1030 <puts@plt>
movl   $0x7b,0xc(%rsp)
mov    $0xffffffffffffd800,%rax
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3840 <main+0x2710>
movb   $0xa5,0x14(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    38c0 <main+0x2790>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x16e8(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3940 <main+0x2810>
lea    0x18(%rsp),%r14
movw   $0xa5a5,0x18(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    39c0 <main+0x2890>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x15e8(%rip),%rdi
mov    $0x2,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3a40 <main+0x2910>
movb   $0xa5,0x1e(%rsp)
movw   $0xa5a5,0x1c(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3ac0 <main+0x2990>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x14e8(%rip),%rdi
mov    $0x3,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3b40 <main+0x2a10>
lea    0x20(%rsp),%r15
movl   $0xa5a5a5a5,0x20(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3bc0 <main+0x2a90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x13e8(%rip),%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3c40 <main+0x2b10>
movb   $0xa5,0x28(%rsp)
movl   $0xa5a5a5a5,0x24(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3cc0 <main+0x2b90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x12e8(%rip),%rdi
mov    $0x5,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3d40 <main+0x2c10>
movw   $0xa5a5,0x2c(%rsp)
movl   $0xa5a5a5a5,0x28(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3dc0 <main+0x2c90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x11e8(%rip),%rdi
mov    $0x6,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3e40 <main+0x2d10>
movl   $0xa5a5a5a5,0x2f(%rsp)
a5
movl   $0xa5a5a5a5,0x2c(%rsp)
a5
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   (%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3ec0 <main+0x2d90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x10e8(%rip),%rdi
mov    $0x7,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    3f40 <main+0x2e10>
mov    %r13,0x30(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    3fc0 <main+0x2e90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xfe8(%rip),%rdi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4040 <main+0x2f10>
lea    0x34(%rsp),%rbx
mov    %r13,0x34(%rsp)
movb   $0xa5,0x3c(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    40c0 <main+0x2f90>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xee8(%rip),%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4140 <main+0x3010>
mov    %r13,0x38(%rsp)
movw   $0xa5a5,0x40(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    41c0 <main+0x3090>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xde8(%rip),%rdi
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4240 <main+0x3110>
movdqa 0xd58(%rip),%xmm0
movdqa %xmm0,0x50(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    42c0 <main+0x3190>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xce8(%rip),%rdi
mov    $0x10,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4340 <main+0x3210>
movdqa 0xc58(%rip),%xmm0
movdqu %xmm0,0x5c(%rsp)
movdqu %xmm0,0x4c(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    43d0 <main+0x32a0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xbd8(%rip),%rdi
mov    $0x20,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4450 <main+0x3320>
movdqa 0xb48(%rip),%xmm0
movdqu %xmm0,0x74(%rsp)
movdqu %xmm0,0x64(%rsp)
movdqu %xmm0,0x54(%rsp)
movdqu %xmm0,0x44(%rsp)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   (%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    44e0 <main+0x33b0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0xac8(%rip),%rdi
mov    $0x40,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4560 <main+0x3430>
movdqa 0xa38(%rip),%xmm0
movdqu %xmm0,0x70(%rbx)
movdqu %xmm0,0x60(%rbx)
movdqu %xmm0,0x50(%rbx)
movdqu %xmm0,0x40(%rbx)
movdqu %xmm0,0x30(%rbx)
movdqu %xmm0,0x20(%rbx)
movdqu %xmm0,0x10(%rbx)
movdqu %xmm0,(%rbx)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    4600 <main+0x34d0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x9a8(%rip),%rdi
mov    $0x80,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4680 <main+0x3550>
movdqa 0x918(%rip),%xmm0
movdqu %xmm0,0xf0(%r12)
movdqu %xmm0,0xe0(%r12)
movdqu %xmm0,0xd0(%r12)
movdqu %xmm0,0xc0(%r12)
movdqu %xmm0,0xb0(%r12)
movdqu %xmm0,0xa0(%r12)
movdqu %xmm0,0x90(%r12)
movdqu %xmm0,0x80(%r12)
movdqu %xmm0,0x70(%r12)
movdqu %xmm0,0x60(%r12)
movdqu %xmm0,0x50(%r12)
movdqu %xmm0,0x40(%r12)
movdqu %xmm0,0x30(%r12)
movdqu %xmm0,0x20(%r12)
movdqu %xmm0,0x10(%r12)
movdqu %xmm0,(%r12)
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    4780 <main+0x3650>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x828(%rip),%rdi
mov    $0x100,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4800 <main+0x36d0>
mov    $0x200,%edx
mov    %r14,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nop
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    4880 <main+0x3750>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x728(%rip),%rdi
mov    $0x200,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xffffffffffffd800,%rax
nopl   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4900 <main+0x37d0>
mov    $0x400,%edx
mov    %r15,%rdi
mov    $0xa5,%esi
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nop
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    4980 <main+0x3850>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
lea    0x628(%rip),%r14
mov    %r14,%rdi
mov    $0x400,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%ebx
mov    $0xf0f0f0f1,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xffffffffffffd800,%rax
nopw   0x0(%rax,%rax,1)
lea    0x2800(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa010(%rsp,%rax,4)
lea    0x2801(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa014(%rsp,%rax,4)
lea    0x2802(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa018(%rsp,%rax,4)
lea    0x2803(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa01c(%rsp,%rax,4)
lea    0x2804(%rax),%ecx
imul   0xc(%rsp),%ecx
mov    %ecx,0xa020(%rsp,%rax,4)
add    $0x5,%rax
jne    4a20 <main+0x38f0>
mov    %ebx,%eax
imul   %r15,%rax
shr    $0x24,%rax
mov    %eax,%ecx
shl    $0x4,%ecx
add    %eax,%ecx
mov    %ebx,%eax
sub    %ecx,%eax
lea    (%rsp,%rax,4),%rdi
add    $0x10,%rdi
mov    $0xa5,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
pxor   %xmm0,%xmm0
mov    $0x24,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
paddd  -0x80(%rsp,%rax,4),%xmm0
paddd  -0x70(%rsp,%rax,4),%xmm1
paddd  -0x60(%rsp,%rax,4),%xmm0
paddd  -0x50(%rsp,%rax,4),%xmm1
paddd  -0x40(%rsp,%rax,4),%xmm0
paddd  -0x30(%rsp,%rax,4),%xmm1
paddd  -0x20(%rsp,%rax,4),%xmm0
paddd  -0x10(%rsp,%rax,4),%xmm1
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x2824,%rax
jne    4ac0 <main+0x3990>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa(%rbx),%rax
cmp    $0x5a,%rbx
mov    %rax,%rbx
jb     4a10 <main+0x38e0>
mov    $0x1,%eax
add    $0xa018,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"8\0A\00"
@.str.1 = [13 x i8] c"final %d:%d\0A\00"
@.str.2 = [4 x i8] c"16\0A\00"
@.str.3 = [4 x i8] c"32\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10240 x i8]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca [10240 x i16]
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32
%84 = alloca i32
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca i32
%90 = alloca i32
%91 = alloca i32
%92 = alloca i32
%93 = alloca i32
%94 = alloca i32
%95 = alloca i32
%96 = alloca i32
%97 = alloca i32
%98 = alloca i32
%99 = alloca i32
%100 = alloca i32
%101 = alloca i32
%102 = alloca i32
%103 = alloca i32
%104 = alloca i32
%105 = alloca i32
%106 = alloca i32
%107 = alloca i32
%108 = alloca i32
%109 = alloca i32
%110 = alloca i32
%111 = alloca i32
%112 = alloca i32
%113 = alloca i32
%114 = alloca i32
%115 = alloca i32
%116 = alloca [10240 x i32]
%117 = alloca i32
%118 = alloca i32
%119 = alloca i32
%120 = alloca i32
%121 = alloca i32
%122 = alloca i32
%123 = alloca i32
%124 = alloca i32
%125 = alloca i32
%126 = alloca i32
%127 = alloca i32
%128 = alloca i32
%129 = alloca i32
%130 = alloca i32
%131 = alloca i32
%132 = alloca i32
%133 = alloca i32
%134 = alloca i32
%135 = alloca i32
%136 = alloca i32
%137 = alloca i32
%138 = alloca i32
%139 = alloca i32
%140 = alloca i32
%141 = alloca i32
%142 = alloca i32
%143 = alloca i32
%144 = alloca i32
%145 = alloca i32
%146 = alloca i32
%147 = alloca i32
%148 = alloca i32
%149 = alloca i32
%150 = alloca i32
%151 = alloca i32
%152 = alloca i32
%153 = alloca i32
%154 = alloca i32
%155 = alloca i32
%156 = alloca i32
%157 = alloca i32
%158 = alloca i32
%159 = alloca i32
%160 = alloca i32
%161 = alloca i32
%162 = alloca i32
%163 = alloca i32
%164 = alloca i32
%165 = alloca i32
%166 = alloca i32
%167 = alloca i32
%168 = alloca i32
%169 = alloca i32
%170 = alloca i32
%171 = alloca i32
%172 = alloca i32
store i32 0, i32* %1
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store volatile i32 123, i32* %3
store i32 0, i32* %4
br label %174
174: ; preds = %185, %0
%175 = load i32, i32* %4
%176 = icmp slt i32 %175, 10240
br i1 %176, label %177, label %188
177: ; preds = %174
%178 = load i32, i32* %4
%179 = load volatile i32, i32* %3
%180 = mul nsw i32 %178, %179
%181 = trunc i32 %180 to i8
%182 = load i32, i32* %4
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %183
store i8 %181, i8* %184
br label %185
185: ; preds = %177
%186 = load i32, i32* %4
%187 = add nsw i32 %186, 1
store i32 %187, i32* %4
br label %174
188: ; preds = %174
%189 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%190 = getelementptr inbounds i8, i8* %189, i64 1
store i32 0, i32* %5
store i32 0, i32* %6
br label %191
191: ; preds = %202, %188
%192 = load i32, i32* %6
%193 = icmp slt i32 %192, 10240
br i1 %193, label %194, label %205
194: ; preds = %191
%195 = load i32, i32* %6
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %196
%198 = load i8, i8* %197
%199 = zext i8 %198 to i32
%200 = load i32, i32* %5
%201 = add nsw i32 %200, %199
store i32 %201, i32* %5
br label %202
202: ; preds = %194
%203 = load i32, i32* %6
%204 = add nsw i32 %203, 1
store i32 %204, i32* %6
br label %191
205: ; preds = %191
%206 = load i32, i32* %5
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %206)
store i32 0, i32* %7
br label %208
208: ; preds = %219, %205
%209 = load i32, i32* %7
%210 = icmp slt i32 %209, 10240
br i1 %210, label %211, label %222
211: ; preds = %208
%212 = load i32, i32* %7
%213 = load volatile i32, i32* %3
%214 = mul nsw i32 %212, %213
%215 = trunc i32 %214 to i8
%216 = load i32, i32* %7
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %217
store i8 %215, i8* %218
br label %219
219: ; preds = %211
%220 = load i32, i32* %7
%221 = add nsw i32 %220, 1
store i32 %221, i32* %7
br label %208
222: ; preds = %208
%223 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%224 = getelementptr inbounds i8, i8* %223, i64 2
store i32 0, i32* %8
store i32 0, i32* %9
br label %225
225: ; preds = %236, %222
%226 = load i32, i32* %9
%227 = icmp slt i32 %226, 10240
br i1 %227, label %228, label %239
228: ; preds = %225
%229 = load i32, i32* %9
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %230
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = load i32, i32* %8
%235 = add nsw i32 %234, %233
store i32 %235, i32* %8
br label %236
236: ; preds = %228
%237 = load i32, i32* %9
%238 = add nsw i32 %237, 1
store i32 %238, i32* %9
br label %225
239: ; preds = %225
%240 = load i32, i32* %8
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %240)
store i32 0, i32* %10
br label %242
242: ; preds = %253, %239
%243 = load i32, i32* %10
%244 = icmp slt i32 %243, 10240
br i1 %244, label %245, label %256
245: ; preds = %242
%246 = load i32, i32* %10
%247 = load volatile i32, i32* %3
%248 = mul nsw i32 %246, %247
%249 = trunc i32 %248 to i8
%250 = load i32, i32* %10
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %251
store i8 %249, i8* %252
br label %253
253: ; preds = %245
%254 = load i32, i32* %10
%255 = add nsw i32 %254, 1
store i32 %255, i32* %10
br label %242
256: ; preds = %242
%257 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%258 = getelementptr inbounds i8, i8* %257, i64 3
store i32 0, i32* %11
store i32 0, i32* %12
br label %259
259: ; preds = %270, %256
%260 = load i32, i32* %12
%261 = icmp slt i32 %260, 10240
br i1 %261, label %262, label %273
262: ; preds = %259
%263 = load i32, i32* %12
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %264
%266 = load i8, i8* %265
%267 = zext i8 %266 to i32
%268 = load i32, i32* %11
%269 = add nsw i32 %268, %267
store i32 %269, i32* %11
br label %270
270: ; preds = %262
%271 = load i32, i32* %12
%272 = add nsw i32 %271, 1
store i32 %272, i32* %12
br label %259
273: ; preds = %259
%274 = load i32, i32* %11
%275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %274)
store i32 0, i32* %13
br label %276
276: ; preds = %287, %273
%277 = load i32, i32* %13
%278 = icmp slt i32 %277, 10240
br i1 %278, label %279, label %290
279: ; preds = %276
%280 = load i32, i32* %13
%281 = load volatile i32, i32* %3
%282 = mul nsw i32 %280, %281
%283 = trunc i32 %282 to i8
%284 = load i32, i32* %13
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %285
store i8 %283, i8* %286
br label %287
287: ; preds = %279
%288 = load i32, i32* %13
%289 = add nsw i32 %288, 1
store i32 %289, i32* %13
br label %276
290: ; preds = %276
%291 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%292 = getelementptr inbounds i8, i8* %291, i64 4
store i32 0, i32* %14
store i32 0, i32* %15
br label %293
293: ; preds = %304, %290
%294 = load i32, i32* %15
%295 = icmp slt i32 %294, 10240
br i1 %295, label %296, label %307
296: ; preds = %293
%297 = load i32, i32* %15
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %298
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = load i32, i32* %14
%303 = add nsw i32 %302, %301
store i32 %303, i32* %14
br label %304
304: ; preds = %296
%305 = load i32, i32* %15
%306 = add nsw i32 %305, 1
store i32 %306, i32* %15
br label %293
307: ; preds = %293
%308 = load i32, i32* %14
%309 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %308)
store i32 0, i32* %16
br label %310
310: ; preds = %321, %307
%311 = load i32, i32* %16
%312 = icmp slt i32 %311, 10240
br i1 %312, label %313, label %324
313: ; preds = %310
%314 = load i32, i32* %16
%315 = load volatile i32, i32* %3
%316 = mul nsw i32 %314, %315
%317 = trunc i32 %316 to i8
%318 = load i32, i32* %16
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %319
store i8 %317, i8* %320
br label %321
321: ; preds = %313
%322 = load i32, i32* %16
%323 = add nsw i32 %322, 1
store i32 %323, i32* %16
br label %310
324: ; preds = %310
%325 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%326 = getelementptr inbounds i8, i8* %325, i64 5
store i32 0, i32* %17
store i32 0, i32* %18
br label %327
327: ; preds = %338, %324
%328 = load i32, i32* %18
%329 = icmp slt i32 %328, 10240
br i1 %329, label %330, label %341
330: ; preds = %327
%331 = load i32, i32* %18
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %332
%334 = load i8, i8* %333
%335 = zext i8 %334 to i32
%336 = load i32, i32* %17
%337 = add nsw i32 %336, %335
store i32 %337, i32* %17
br label %338
338: ; preds = %330
%339 = load i32, i32* %18
%340 = add nsw i32 %339, 1
store i32 %340, i32* %18
br label %327
341: ; preds = %327
%342 = load i32, i32* %17
%343 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %342)
store i32 0, i32* %19
br label %344
344: ; preds = %355, %341
%345 = load i32, i32* %19
%346 = icmp slt i32 %345, 10240
br i1 %346, label %347, label %358
347: ; preds = %344
%348 = load i32, i32* %19
%349 = load volatile i32, i32* %3
%350 = mul nsw i32 %348, %349
%351 = trunc i32 %350 to i8
%352 = load i32, i32* %19
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %353
store i8 %351, i8* %354
br label %355
355: ; preds = %347
%356 = load i32, i32* %19
%357 = add nsw i32 %356, 1
store i32 %357, i32* %19
br label %344
358: ; preds = %344
%359 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%360 = getelementptr inbounds i8, i8* %359, i64 6
store i32 0, i32* %20
store i32 0, i32* %21
br label %361
361: ; preds = %372, %358
%362 = load i32, i32* %21
%363 = icmp slt i32 %362, 10240
br i1 %363, label %364, label %375
364: ; preds = %361
%365 = load i32, i32* %21
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %366
%368 = load i8, i8* %367
%369 = zext i8 %368 to i32
%370 = load i32, i32* %20
%371 = add nsw i32 %370, %369
store i32 %371, i32* %20
br label %372
372: ; preds = %364
%373 = load i32, i32* %21
%374 = add nsw i32 %373, 1
store i32 %374, i32* %21
br label %361
375: ; preds = %361
%376 = load i32, i32* %20
%377 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %376)
store i32 0, i32* %22
br label %378
378: ; preds = %389, %375
%379 = load i32, i32* %22
%380 = icmp slt i32 %379, 10240
br i1 %380, label %381, label %392
381: ; preds = %378
%382 = load i32, i32* %22
%383 = load volatile i32, i32* %3
%384 = mul nsw i32 %382, %383
%385 = trunc i32 %384 to i8
%386 = load i32, i32* %22
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %387
store i8 %385, i8* %388
br label %389
389: ; preds = %381
%390 = load i32, i32* %22
%391 = add nsw i32 %390, 1
store i32 %391, i32* %22
br label %378
392: ; preds = %378
%393 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%394 = getelementptr inbounds i8, i8* %393, i64 7
store i32 0, i32* %23
store i32 0, i32* %24
br label %395
395: ; preds = %406, %392
%396 = load i32, i32* %24
%397 = icmp slt i32 %396, 10240
br i1 %397, label %398, label %409
398: ; preds = %395
%399 = load i32, i32* %24
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %400
%402 = load i8, i8* %401
%403 = zext i8 %402 to i32
%404 = load i32, i32* %23
%405 = add nsw i32 %404, %403
store i32 %405, i32* %23
br label %406
406: ; preds = %398
%407 = load i32, i32* %24
%408 = add nsw i32 %407, 1
store i32 %408, i32* %24
br label %395
409: ; preds = %395
%410 = load i32, i32* %23
%411 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %410)
store i32 0, i32* %25
br label %412
412: ; preds = %423, %409
%413 = load i32, i32* %25
%414 = icmp slt i32 %413, 10240
br i1 %414, label %415, label %426
415: ; preds = %412
%416 = load i32, i32* %25
%417 = load volatile i32, i32* %3
%418 = mul nsw i32 %416, %417
%419 = trunc i32 %418 to i8
%420 = load i32, i32* %25
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %421
store i8 %419, i8* %422
br label %423
423: ; preds = %415
%424 = load i32, i32* %25
%425 = add nsw i32 %424, 1
store i32 %425, i32* %25
br label %412
426: ; preds = %412
%427 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%428 = getelementptr inbounds i8, i8* %427, i64 8
store i32 0, i32* %26
store i32 0, i32* %27
br label %429
429: ; preds = %440, %426
%430 = load i32, i32* %27
%431 = icmp slt i32 %430, 10240
br i1 %431, label %432, label %443
432: ; preds = %429
%433 = load i32, i32* %27
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %434
%436 = load i8, i8* %435
%437 = zext i8 %436 to i32
%438 = load i32, i32* %26
%439 = add nsw i32 %438, %437
store i32 %439, i32* %26
br label %440
440: ; preds = %432
%441 = load i32, i32* %27
%442 = add nsw i32 %441, 1
store i32 %442, i32* %27
br label %429
443: ; preds = %429
%444 = load i32, i32* %26
%445 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %444)
store i32 0, i32* %28
br label %446
446: ; preds = %457, %443
%447 = load i32, i32* %28
%448 = icmp slt i32 %447, 10240
br i1 %448, label %449, label %460
449: ; preds = %446
%450 = load i32, i32* %28
%451 = load volatile i32, i32* %3
%452 = mul nsw i32 %450, %451
%453 = trunc i32 %452 to i8
%454 = load i32, i32* %28
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %455
store i8 %453, i8* %456
br label %457
457: ; preds = %449
%458 = load i32, i32* %28
%459 = add nsw i32 %458, 1
store i32 %459, i32* %28
br label %446
460: ; preds = %446
%461 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%462 = getelementptr inbounds i8, i8* %461, i64 9
store i32 0, i32* %29
store i32 0, i32* %30
br label %463
463: ; preds = %474, %460
%464 = load i32, i32* %30
%465 = icmp slt i32 %464, 10240
br i1 %465, label %466, label %477
466: ; preds = %463
%467 = load i32, i32* %30
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %468
%470 = load i8, i8* %469
%471 = zext i8 %470 to i32
%472 = load i32, i32* %29
%473 = add nsw i32 %472, %471
store i32 %473, i32* %29
br label %474
474: ; preds = %466
%475 = load i32, i32* %30
%476 = add nsw i32 %475, 1
store i32 %476, i32* %30
br label %463
477: ; preds = %463
%478 = load i32, i32* %29
%479 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %478)
store i32 0, i32* %31
br label %480
480: ; preds = %491, %477
%481 = load i32, i32* %31
%482 = icmp slt i32 %481, 10240
br i1 %482, label %483, label %494
483: ; preds = %480
%484 = load i32, i32* %31
%485 = load volatile i32, i32* %3
%486 = mul nsw i32 %484, %485
%487 = trunc i32 %486 to i8
%488 = load i32, i32* %31
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %489
store i8 %487, i8* %490
br label %491
491: ; preds = %483
%492 = load i32, i32* %31
%493 = add nsw i32 %492, 1
store i32 %493, i32* %31
br label %480
494: ; preds = %480
%495 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%496 = getelementptr inbounds i8, i8* %495, i64 10
store i32 0, i32* %32
store i32 0, i32* %33
br label %497
497: ; preds = %508, %494
%498 = load i32, i32* %33
%499 = icmp slt i32 %498, 10240
br i1 %499, label %500, label %511
500: ; preds = %497
%501 = load i32, i32* %33
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %502
%504 = load i8, i8* %503
%505 = zext i8 %504 to i32
%506 = load i32, i32* %32
%507 = add nsw i32 %506, %505
store i32 %507, i32* %32
br label %508
508: ; preds = %500
%509 = load i32, i32* %33
%510 = add nsw i32 %509, 1
store i32 %510, i32* %33
br label %497
511: ; preds = %497
%512 = load i32, i32* %32
%513 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %512)
store i32 0, i32* %34
br label %514
514: ; preds = %525, %511
%515 = load i32, i32* %34
%516 = icmp slt i32 %515, 10240
br i1 %516, label %517, label %528
517: ; preds = %514
%518 = load i32, i32* %34
%519 = load volatile i32, i32* %3
%520 = mul nsw i32 %518, %519
%521 = trunc i32 %520 to i8
%522 = load i32, i32* %34
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %523
store i8 %521, i8* %524
br label %525
525: ; preds = %517
%526 = load i32, i32* %34
%527 = add nsw i32 %526, 1
store i32 %527, i32* %34
br label %514
528: ; preds = %514
%529 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%530 = getelementptr inbounds i8, i8* %529, i64 16
store i32 0, i32* %35
store i32 0, i32* %36
br label %531
531: ; preds = %542, %528
%532 = load i32, i32* %36
%533 = icmp slt i32 %532, 10240
br i1 %533, label %534, label %545
534: ; preds = %531
%535 = load i32, i32* %36
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %536
%538 = load i8, i8* %537
%539 = zext i8 %538 to i32
%540 = load i32, i32* %35
%541 = add nsw i32 %540, %539
store i32 %541, i32* %35
br label %542
542: ; preds = %534
%543 = load i32, i32* %36
%544 = add nsw i32 %543, 1
store i32 %544, i32* %36
br label %531
545: ; preds = %531
%546 = load i32, i32* %35
%547 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %546)
store i32 0, i32* %37
br label %548
548: ; preds = %559, %545
%549 = load i32, i32* %37
%550 = icmp slt i32 %549, 10240
br i1 %550, label %551, label %562
551: ; preds = %548
%552 = load i32, i32* %37
%553 = load volatile i32, i32* %3
%554 = mul nsw i32 %552, %553
%555 = trunc i32 %554 to i8
%556 = load i32, i32* %37
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %557
store i8 %555, i8* %558
br label %559
559: ; preds = %551
%560 = load i32, i32* %37
%561 = add nsw i32 %560, 1
store i32 %561, i32* %37
br label %548
562: ; preds = %548
%563 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%564 = getelementptr inbounds i8, i8* %563, i64 15
store i32 0, i32* %38
store i32 0, i32* %39
br label %565
565: ; preds = %576, %562
%566 = load i32, i32* %39
%567 = icmp slt i32 %566, 10240
br i1 %567, label %568, label %579
568: ; preds = %565
%569 = load i32, i32* %39
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %570
%572 = load i8, i8* %571
%573 = zext i8 %572 to i32
%574 = load i32, i32* %38
%575 = add nsw i32 %574, %573
store i32 %575, i32* %38
br label %576
576: ; preds = %568
%577 = load i32, i32* %39
%578 = add nsw i32 %577, 1
store i32 %578, i32* %39
br label %565
579: ; preds = %565
%580 = load i32, i32* %38
%581 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %580)
store i32 0, i32* %40
br label %582
582: ; preds = %593, %579
%583 = load i32, i32* %40
%584 = icmp slt i32 %583, 10240
br i1 %584, label %585, label %596
585: ; preds = %582
%586 = load i32, i32* %40
%587 = load volatile i32, i32* %3
%588 = mul nsw i32 %586, %587
%589 = trunc i32 %588 to i8
%590 = load i32, i32* %40
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %591
store i8 %589, i8* %592
br label %593
593: ; preds = %585
%594 = load i32, i32* %40
%595 = add nsw i32 %594, 1
store i32 %595, i32* %40
br label %582
596: ; preds = %582
%597 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%598 = getelementptr inbounds i8, i8* %597, i64 13
store i32 0, i32* %41
store i32 0, i32* %42
br label %599
599: ; preds = %610, %596
%600 = load i32, i32* %42
%601 = icmp slt i32 %600, 10240
br i1 %601, label %602, label %613
602: ; preds = %599
%603 = load i32, i32* %42
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %604
%606 = load i8, i8* %605
%607 = zext i8 %606 to i32
%608 = load i32, i32* %41
%609 = add nsw i32 %608, %607
store i32 %609, i32* %41
br label %610
610: ; preds = %602
%611 = load i32, i32* %42
%612 = add nsw i32 %611, 1
store i32 %612, i32* %42
br label %599
613: ; preds = %599
%614 = load i32, i32* %41
%615 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %614)
store i32 0, i32* %43
br label %616
616: ; preds = %627, %613
%617 = load i32, i32* %43
%618 = icmp slt i32 %617, 10240
br i1 %618, label %619, label %630
619: ; preds = %616
%620 = load i32, i32* %43
%621 = load volatile i32, i32* %3
%622 = mul nsw i32 %620, %621
%623 = trunc i32 %622 to i8
%624 = load i32, i32* %43
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %625
store i8 %623, i8* %626
br label %627
627: ; preds = %619
%628 = load i32, i32* %43
%629 = add nsw i32 %628, 1
store i32 %629, i32* %43
br label %616
630: ; preds = %616
%631 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%632 = getelementptr inbounds i8, i8* %631, i64 9
store i32 0, i32* %44
store i32 0, i32* %45
br label %633
633: ; preds = %644, %630
%634 = load i32, i32* %45
%635 = icmp slt i32 %634, 10240
br i1 %635, label %636, label %647
636: ; preds = %633
%637 = load i32, i32* %45
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %638
%640 = load i8, i8* %639
%641 = zext i8 %640 to i32
%642 = load i32, i32* %44
%643 = add nsw i32 %642, %641
store i32 %643, i32* %44
br label %644
644: ; preds = %636
%645 = load i32, i32* %45
%646 = add nsw i32 %645, 1
store i32 %646, i32* %45
br label %633
647: ; preds = %633
%648 = load i32, i32* %44
%649 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %648)
store i32 0, i32* %46
br label %650
650: ; preds = %661, %647
%651 = load i32, i32* %46
%652 = icmp slt i32 %651, 10240
br i1 %652, label %653, label %664
653: ; preds = %650
%654 = load i32, i32* %46
%655 = load volatile i32, i32* %3
%656 = mul nsw i32 %654, %655
%657 = trunc i32 %656 to i8
%658 = load i32, i32* %46
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %659
store i8 %657, i8* %660
br label %661
661: ; preds = %653
%662 = load i32, i32* %46
%663 = add nsw i32 %662, 1
store i32 %663, i32* %46
br label %650
664: ; preds = %650
%665 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%666 = getelementptr inbounds i8, i8* %665, i64 1
store i32 0, i32* %47
store i32 0, i32* %48
br label %667
667: ; preds = %678, %664
%668 = load i32, i32* %48
%669 = icmp slt i32 %668, 10240
br i1 %669, label %670, label %681
670: ; preds = %667
%671 = load i32, i32* %48
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %672
%674 = load i8, i8* %673
%675 = zext i8 %674 to i32
%676 = load i32, i32* %47
%677 = add nsw i32 %676, %675
store i32 %677, i32* %47
br label %678
678: ; preds = %670
%679 = load i32, i32* %48
%680 = add nsw i32 %679, 1
store i32 %680, i32* %48
br label %667
681: ; preds = %667
%682 = load i32, i32* %47
%683 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %682)
store i32 0, i32* %49
br label %684
684: ; preds = %695, %681
%685 = load i32, i32* %49
%686 = icmp slt i32 %685, 10240
br i1 %686, label %687, label %698
687: ; preds = %684
%688 = load i32, i32* %49
%689 = load volatile i32, i32* %3
%690 = mul nsw i32 %688, %689
%691 = trunc i32 %690 to i8
%692 = load i32, i32* %49
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %693
store i8 %691, i8* %694
br label %695
695: ; preds = %687
%696 = load i32, i32* %49
%697 = add nsw i32 %696, 1
store i32 %697, i32* %49
br label %684
698: ; preds = %684
%699 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%700 = getelementptr inbounds i8, i8* %699, i64 2
store i32 0, i32* %50
store i32 0, i32* %51
br label %701
701: ; preds = %712, %698
%702 = load i32, i32* %51
%703 = icmp slt i32 %702, 10240
br i1 %703, label %704, label %715
704: ; preds = %701
%705 = load i32, i32* %51
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %706
%708 = load i8, i8* %707
%709 = zext i8 %708 to i32
%710 = load i32, i32* %50
%711 = add nsw i32 %710, %709
store i32 %711, i32* %50
br label %712
712: ; preds = %704
%713 = load i32, i32* %51
%714 = add nsw i32 %713, 1
store i32 %714, i32* %51
br label %701
715: ; preds = %701
%716 = load i32, i32* %50
%717 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %716)
store i32 0, i32* %52
br label %718
718: ; preds = %729, %715
%719 = load i32, i32* %52
%720 = icmp slt i32 %719, 10240
br i1 %720, label %721, label %732
721: ; preds = %718
%722 = load i32, i32* %52
%723 = load volatile i32, i32* %3
%724 = mul nsw i32 %722, %723
%725 = trunc i32 %724 to i8
%726 = load i32, i32* %52
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %727
store i8 %725, i8* %728
br label %729
729: ; preds = %721
%730 = load i32, i32* %52
%731 = add nsw i32 %730, 1
store i32 %731, i32* %52
br label %718
732: ; preds = %718
%733 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%734 = getelementptr inbounds i8, i8* %733, i64 4
store i32 0, i32* %53
store i32 0, i32* %54
br label %735
735: ; preds = %746, %732
%736 = load i32, i32* %54
%737 = icmp slt i32 %736, 10240
br i1 %737, label %738, label %749
738: ; preds = %735
%739 = load i32, i32* %54
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %740
%742 = load i8, i8* %741
%743 = zext i8 %742 to i32
%744 = load i32, i32* %53
%745 = add nsw i32 %744, %743
store i32 %745, i32* %53
br label %746
746: ; preds = %738
%747 = load i32, i32* %54
%748 = add nsw i32 %747, 1
store i32 %748, i32* %54
br label %735
749: ; preds = %735
%750 = load i32, i32* %53
%751 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %750)
store i32 10, i32* %55
br label %752
752: ; preds = %796, %749
%753 = load i32, i32* %55
%754 = icmp slt i32 %753, 100
br i1 %754, label %755, label %799
755: ; preds = %752
store i32 0, i32* %56
br label %756
756: ; preds = %767, %755
%757 = load i32, i32* %56
%758 = icmp slt i32 %757, 10240
br i1 %758, label %759, label %770
759: ; preds = %756
%760 = load i32, i32* %56
%761 = load volatile i32, i32* %3
%762 = mul nsw i32 %760, %761
%763 = trunc i32 %762 to i8
%764 = load i32, i32* %56
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %765
store i8 %763, i8* %766
br label %767
767: ; preds = %759
%768 = load i32, i32* %56
%769 = add nsw i32 %768, 1
store i32 %769, i32* %56
br label %756
770: ; preds = %756
%771 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 0
%772 = load i32, i32* %55
%773 = srem i32 %772, 17
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds i8, i8* %771, i64 %774
%776 = load i32, i32* %55
%777 = sext i32 %776 to i64
store i32 0, i32* %57
store i32 0, i32* %58
br label %778
778: ; preds = %789, %770
%779 = load i32, i32* %58
%780 = icmp slt i32 %779, 10240
br i1 %780, label %781, label %792
781: ; preds = %778
%782 = load i32, i32* %58
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds [10240 x i8], [10240 x i8]* %2, i64 0, i64 %783
%785 = load i8, i8* %784
%786 = zext i8 %785 to i32
%787 = load i32, i32* %57
%788 = add nsw i32 %787, %786
store i32 %788, i32* %57
br label %789
789: ; preds = %781
%790 = load i32, i32* %58
%791 = add nsw i32 %790, 1
store i32 %791, i32* %58
br label %778
792: ; preds = %778
%793 = load i32, i32* %55
%794 = load i32, i32* %57
%795 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %793, i32 %794)
br label %796
796: ; preds = %792
%797 = load i32, i32* %55
%798 = add nsw i32 %797, 10
store i32 %798, i32* %55
br label %752
799: ; preds = %752
%800 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
store volatile i32 123, i32* %60
store i32 0, i32* %61
br label %801
801: ; preds = %812, %799
%802 = load i32, i32* %61
%803 = icmp slt i32 %802, 10240
br i1 %803, label %804, label %815
804: ; preds = %801
%805 = load i32, i32* %61
%806 = load volatile i32, i32* %60
%807 = mul nsw i32 %805, %806
%808 = trunc i32 %807 to i16
%809 = load i32, i32* %61
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %810
store i16 %808, i16* %811
br label %812
812: ; preds = %804
%813 = load i32, i32* %61
%814 = add nsw i32 %813, 1
store i32 %814, i32* %61
br label %801
815: ; preds = %801
%816 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%817 = getelementptr inbounds i16, i16* %816, i64 1
%818 = bitcast i16* %817 to i8*
store i32 0, i32* %62
store i32 0, i32* %63
br label %819
819: ; preds = %830, %815
%820 = load i32, i32* %63
%821 = icmp slt i32 %820, 10240
br i1 %821, label %822, label %833
822: ; preds = %819
%823 = load i32, i32* %63
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %824
%826 = load i16, i16* %825
%827 = zext i16 %826 to i32
%828 = load i32, i32* %62
%829 = add nsw i32 %828, %827
store i32 %829, i32* %62
br label %830
830: ; preds = %822
%831 = load i32, i32* %63
%832 = add nsw i32 %831, 1
store i32 %832, i32* %63
br label %819
833: ; preds = %819
%834 = load i32, i32* %62
%835 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %834)
store i32 0, i32* %64
br label %836
836: ; preds = %847, %833
%837 = load i32, i32* %64
%838 = icmp slt i32 %837, 10240
br i1 %838, label %839, label %850
839: ; preds = %836
%840 = load i32, i32* %64
%841 = load volatile i32, i32* %60
%842 = mul nsw i32 %840, %841
%843 = trunc i32 %842 to i16
%844 = load i32, i32* %64
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %845
store i16 %843, i16* %846
br label %847
847: ; preds = %839
%848 = load i32, i32* %64
%849 = add nsw i32 %848, 1
store i32 %849, i32* %64
br label %836
850: ; preds = %836
%851 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%852 = getelementptr inbounds i16, i16* %851, i64 2
%853 = bitcast i16* %852 to i8*
store i32 0, i32* %65
store i32 0, i32* %66
br label %854
854: ; preds = %865, %850
%855 = load i32, i32* %66
%856 = icmp slt i32 %855, 10240
br i1 %856, label %857, label %868
857: ; preds = %854
%858 = load i32, i32* %66
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %859
%861 = load i16, i16* %860
%862 = zext i16 %861 to i32
%863 = load i32, i32* %65
%864 = add nsw i32 %863, %862
store i32 %864, i32* %65
br label %865
865: ; preds = %857
%866 = load i32, i32* %66
%867 = add nsw i32 %866, 1
store i32 %867, i32* %66
br label %854
868: ; preds = %854
%869 = load i32, i32* %65
%870 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %869)
store i32 0, i32* %67
br label %871
871: ; preds = %882, %868
%872 = load i32, i32* %67
%873 = icmp slt i32 %872, 10240
br i1 %873, label %874, label %885
874: ; preds = %871
%875 = load i32, i32* %67
%876 = load volatile i32, i32* %60
%877 = mul nsw i32 %875, %876
%878 = trunc i32 %877 to i16
%879 = load i32, i32* %67
%880 = sext i32 %879 to i64
%881 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %880
store i16 %878, i16* %881
br label %882
882: ; preds = %874
%883 = load i32, i32* %67
%884 = add nsw i32 %883, 1
store i32 %884, i32* %67
br label %871
885: ; preds = %871
%886 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%887 = getelementptr inbounds i16, i16* %886, i64 3
%888 = bitcast i16* %887 to i8*
store i32 0, i32* %68
store i32 0, i32* %69
br label %889
889: ; preds = %900, %885
%890 = load i32, i32* %69
%891 = icmp slt i32 %890, 10240
br i1 %891, label %892, label %903
892: ; preds = %889
%893 = load i32, i32* %69
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %894
%896 = load i16, i16* %895
%897 = zext i16 %896 to i32
%898 = load i32, i32* %68
%899 = add nsw i32 %898, %897
store i32 %899, i32* %68
br label %900
900: ; preds = %892
%901 = load i32, i32* %69
%902 = add nsw i32 %901, 1
store i32 %902, i32* %69
br label %889
903: ; preds = %889
%904 = load i32, i32* %68
%905 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %904)
store i32 0, i32* %70
br label %906
906: ; preds = %917, %903
%907 = load i32, i32* %70
%908 = icmp slt i32 %907, 10240
br i1 %908, label %909, label %920
909: ; preds = %906
%910 = load i32, i32* %70
%911 = load volatile i32, i32* %60
%912 = mul nsw i32 %910, %911
%913 = trunc i32 %912 to i16
%914 = load i32, i32* %70
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %915
store i16 %913, i16* %916
br label %917
917: ; preds = %909
%918 = load i32, i32* %70
%919 = add nsw i32 %918, 1
store i32 %919, i32* %70
br label %906
920: ; preds = %906
%921 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%922 = getelementptr inbounds i16, i16* %921, i64 4
%923 = bitcast i16* %922 to i8*
store i32 0, i32* %71
store i32 0, i32* %72
br label %924
924: ; preds = %935, %920
%925 = load i32, i32* %72
%926 = icmp slt i32 %925, 10240
br i1 %926, label %927, label %938
927: ; preds = %924
%928 = load i32, i32* %72
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %929
%931 = load i16, i16* %930
%932 = zext i16 %931 to i32
%933 = load i32, i32* %71
%934 = add nsw i32 %933, %932
store i32 %934, i32* %71
br label %935
935: ; preds = %927
%936 = load i32, i32* %72
%937 = add nsw i32 %936, 1
store i32 %937, i32* %72
br label %924
938: ; preds = %924
%939 = load i32, i32* %71
%940 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %939)
store i32 0, i32* %73
br label %941
941: ; preds = %952, %938
%942 = load i32, i32* %73
%943 = icmp slt i32 %942, 10240
br i1 %943, label %944, label %955
944: ; preds = %941
%945 = load i32, i32* %73
%946 = load volatile i32, i32* %60
%947 = mul nsw i32 %945, %946
%948 = trunc i32 %947 to i16
%949 = load i32, i32* %73
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %950
store i16 %948, i16* %951
br label %952
952: ; preds = %944
%953 = load i32, i32* %73
%954 = add nsw i32 %953, 1
store i32 %954, i32* %73
br label %941
955: ; preds = %941
%956 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%957 = getelementptr inbounds i16, i16* %956, i64 5
%958 = bitcast i16* %957 to i8*
store i32 0, i32* %74
store i32 0, i32* %75
br label %959
959: ; preds = %970, %955
%960 = load i32, i32* %75
%961 = icmp slt i32 %960, 10240
br i1 %961, label %962, label %973
962: ; preds = %959
%963 = load i32, i32* %75
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %964
%966 = load i16, i16* %965
%967 = zext i16 %966 to i32
%968 = load i32, i32* %74
%969 = add nsw i32 %968, %967
store i32 %969, i32* %74
br label %970
970: ; preds = %962
%971 = load i32, i32* %75
%972 = add nsw i32 %971, 1
store i32 %972, i32* %75
br label %959
973: ; preds = %959
%974 = load i32, i32* %74
%975 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %974)
store i32 0, i32* %76
br label %976
976: ; preds = %987, %973
%977 = load i32, i32* %76
%978 = icmp slt i32 %977, 10240
br i1 %978, label %979, label %990
979: ; preds = %976
%980 = load i32, i32* %76
%981 = load volatile i32, i32* %60
%982 = mul nsw i32 %980, %981
%983 = trunc i32 %982 to i16
%984 = load i32, i32* %76
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %985
store i16 %983, i16* %986
br label %987
987: ; preds = %979
%988 = load i32, i32* %76
%989 = add nsw i32 %988, 1
store i32 %989, i32* %76
br label %976
990: ; preds = %976
%991 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%992 = getelementptr inbounds i16, i16* %991, i64 6
%993 = bitcast i16* %992 to i8*
store i32 0, i32* %77
store i32 0, i32* %78
br label %994
994: ; preds = %1005, %990
%995 = load i32, i32* %78
%996 = icmp slt i32 %995, 10240
br i1 %996, label %997, label %1008
997: ; preds = %994
%998 = load i32, i32* %78
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %999
%1001 = load i16, i16* %1000
%1002 = zext i16 %1001 to i32
%1003 = load i32, i32* %77
%1004 = add nsw i32 %1003, %1002
store i32 %1004, i32* %77
br label %1005
1005: ; preds = %997
%1006 = load i32, i32* %78
%1007 = add nsw i32 %1006, 1
store i32 %1007, i32* %78
br label %994
1008: ; preds = %994
%1009 = load i32, i32* %77
%1010 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %1009)
store i32 0, i32* %79
br label %1011
1011: ; preds = %1022, %1008
%1012 = load i32, i32* %79
%1013 = icmp slt i32 %1012, 10240
br i1 %1013, label %1014, label %1025
1014: ; preds = %1011
%1015 = load i32, i32* %79
%1016 = load volatile i32, i32* %60
%1017 = mul nsw i32 %1015, %1016
%1018 = trunc i32 %1017 to i16
%1019 = load i32, i32* %79
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1020
store i16 %1018, i16* %1021
br label %1022
1022: ; preds = %1014
%1023 = load i32, i32* %79
%1024 = add nsw i32 %1023, 1
store i32 %1024, i32* %79
br label %1011
1025: ; preds = %1011
%1026 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1027 = getelementptr inbounds i16, i16* %1026, i64 7
%1028 = bitcast i16* %1027 to i8*
store i32 0, i32* %80
store i32 0, i32* %81
br label %1029
1029: ; preds = %1040, %1025
%1030 = load i32, i32* %81
%1031 = icmp slt i32 %1030, 10240
br i1 %1031, label %1032, label %1043
1032: ; preds = %1029
%1033 = load i32, i32* %81
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1034
%1036 = load i16, i16* %1035
%1037 = zext i16 %1036 to i32
%1038 = load i32, i32* %80
%1039 = add nsw i32 %1038, %1037
store i32 %1039, i32* %80
br label %1040
1040: ; preds = %1032
%1041 = load i32, i32* %81
%1042 = add nsw i32 %1041, 1
store i32 %1042, i32* %81
br label %1029
1043: ; preds = %1029
%1044 = load i32, i32* %80
%1045 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %1044)
store i32 0, i32* %82
br label %1046
1046: ; preds = %1057, %1043
%1047 = load i32, i32* %82
%1048 = icmp slt i32 %1047, 10240
br i1 %1048, label %1049, label %1060
1049: ; preds = %1046
%1050 = load i32, i32* %82
%1051 = load volatile i32, i32* %60
%1052 = mul nsw i32 %1050, %1051
%1053 = trunc i32 %1052 to i16
%1054 = load i32, i32* %82
%1055 = sext i32 %1054 to i64
%1056 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1055
store i16 %1053, i16* %1056
br label %1057
1057: ; preds = %1049
%1058 = load i32, i32* %82
%1059 = add nsw i32 %1058, 1
store i32 %1059, i32* %82
br label %1046
1060: ; preds = %1046
%1061 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1062 = getelementptr inbounds i16, i16* %1061, i64 8
%1063 = bitcast i16* %1062 to i8*
store i32 0, i32* %83
store i32 0, i32* %84
br label %1064
1064: ; preds = %1075, %1060
%1065 = load i32, i32* %84
%1066 = icmp slt i32 %1065, 10240
br i1 %1066, label %1067, label %1078
1067: ; preds = %1064
%1068 = load i32, i32* %84
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1069
%1071 = load i16, i16* %1070
%1072 = zext i16 %1071 to i32
%1073 = load i32, i32* %83
%1074 = add nsw i32 %1073, %1072
store i32 %1074, i32* %83
br label %1075
1075: ; preds = %1067
%1076 = load i32, i32* %84
%1077 = add nsw i32 %1076, 1
store i32 %1077, i32* %84
br label %1064
1078: ; preds = %1064
%1079 = load i32, i32* %83
%1080 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %1079)
store i32 0, i32* %85
br label %1081
1081: ; preds = %1092, %1078
%1082 = load i32, i32* %85
%1083 = icmp slt i32 %1082, 10240
br i1 %1083, label %1084, label %1095
1084: ; preds = %1081
%1085 = load i32, i32* %85
%1086 = load volatile i32, i32* %60
%1087 = mul nsw i32 %1085, %1086
%1088 = trunc i32 %1087 to i16
%1089 = load i32, i32* %85
%1090 = sext i32 %1089 to i64
%1091 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1090
store i16 %1088, i16* %1091
br label %1092
1092: ; preds = %1084
%1093 = load i32, i32* %85
%1094 = add nsw i32 %1093, 1
store i32 %1094, i32* %85
br label %1081
1095: ; preds = %1081
%1096 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1097 = getelementptr inbounds i16, i16* %1096, i64 9
%1098 = bitcast i16* %1097 to i8*
store i32 0, i32* %86
store i32 0, i32* %87
br label %1099
1099: ; preds = %1110, %1095
%1100 = load i32, i32* %87
%1101 = icmp slt i32 %1100, 10240
br i1 %1101, label %1102, label %1113
1102: ; preds = %1099
%1103 = load i32, i32* %87
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1104
%1106 = load i16, i16* %1105
%1107 = zext i16 %1106 to i32
%1108 = load i32, i32* %86
%1109 = add nsw i32 %1108, %1107
store i32 %1109, i32* %86
br label %1110
1110: ; preds = %1102
%1111 = load i32, i32* %87
%1112 = add nsw i32 %1111, 1
store i32 %1112, i32* %87
br label %1099
1113: ; preds = %1099
%1114 = load i32, i32* %86
%1115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %1114)
store i32 0, i32* %88
br label %1116
1116: ; preds = %1127, %1113
%1117 = load i32, i32* %88
%1118 = icmp slt i32 %1117, 10240
br i1 %1118, label %1119, label %1130
1119: ; preds = %1116
%1120 = load i32, i32* %88
%1121 = load volatile i32, i32* %60
%1122 = mul nsw i32 %1120, %1121
%1123 = trunc i32 %1122 to i16
%1124 = load i32, i32* %88
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1125
store i16 %1123, i16* %1126
br label %1127
1127: ; preds = %1119
%1128 = load i32, i32* %88
%1129 = add nsw i32 %1128, 1
store i32 %1129, i32* %88
br label %1116
1130: ; preds = %1116
%1131 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1132 = getelementptr inbounds i16, i16* %1131, i64 10
%1133 = bitcast i16* %1132 to i8*
store i32 0, i32* %89
store i32 0, i32* %90
br label %1134
1134: ; preds = %1145, %1130
%1135 = load i32, i32* %90
%1136 = icmp slt i32 %1135, 10240
br i1 %1136, label %1137, label %1148
1137: ; preds = %1134
%1138 = load i32, i32* %90
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1139
%1141 = load i16, i16* %1140
%1142 = zext i16 %1141 to i32
%1143 = load i32, i32* %89
%1144 = add nsw i32 %1143, %1142
store i32 %1144, i32* %89
br label %1145
1145: ; preds = %1137
%1146 = load i32, i32* %90
%1147 = add nsw i32 %1146, 1
store i32 %1147, i32* %90
br label %1134
1148: ; preds = %1134
%1149 = load i32, i32* %89
%1150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %1149)
store i32 0, i32* %91
br label %1151
1151: ; preds = %1162, %1148
%1152 = load i32, i32* %91
%1153 = icmp slt i32 %1152, 10240
br i1 %1153, label %1154, label %1165
1154: ; preds = %1151
%1155 = load i32, i32* %91
%1156 = load volatile i32, i32* %60
%1157 = mul nsw i32 %1155, %1156
%1158 = trunc i32 %1157 to i16
%1159 = load i32, i32* %91
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1160
store i16 %1158, i16* %1161
br label %1162
1162: ; preds = %1154
%1163 = load i32, i32* %91
%1164 = add nsw i32 %1163, 1
store i32 %1164, i32* %91
br label %1151
1165: ; preds = %1151
%1166 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1167 = getelementptr inbounds i16, i16* %1166, i64 16
%1168 = bitcast i16* %1167 to i8*
store i32 0, i32* %92
store i32 0, i32* %93
br label %1169
1169: ; preds = %1180, %1165
%1170 = load i32, i32* %93
%1171 = icmp slt i32 %1170, 10240
br i1 %1171, label %1172, label %1183
1172: ; preds = %1169
%1173 = load i32, i32* %93
%1174 = sext i32 %1173 to i64
%1175 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1174
%1176 = load i16, i16* %1175
%1177 = zext i16 %1176 to i32
%1178 = load i32, i32* %92
%1179 = add nsw i32 %1178, %1177
store i32 %1179, i32* %92
br label %1180
1180: ; preds = %1172
%1181 = load i32, i32* %93
%1182 = add nsw i32 %1181, 1
store i32 %1182, i32* %93
br label %1169
1183: ; preds = %1169
%1184 = load i32, i32* %92
%1185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %1184)
store i32 0, i32* %94
br label %1186
1186: ; preds = %1197, %1183
%1187 = load i32, i32* %94
%1188 = icmp slt i32 %1187, 10240
br i1 %1188, label %1189, label %1200
1189: ; preds = %1186
%1190 = load i32, i32* %94
%1191 = load volatile i32, i32* %60
%1192 = mul nsw i32 %1190, %1191
%1193 = trunc i32 %1192 to i16
%1194 = load i32, i32* %94
%1195 = sext i32 %1194 to i64
%1196 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1195
store i16 %1193, i16* %1196
br label %1197
1197: ; preds = %1189
%1198 = load i32, i32* %94
%1199 = add nsw i32 %1198, 1
store i32 %1199, i32* %94
br label %1186
1200: ; preds = %1186
%1201 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1202 = getelementptr inbounds i16, i16* %1201, i64 15
%1203 = bitcast i16* %1202 to i8*
store i32 0, i32* %95
store i32 0, i32* %96
br label %1204
1204: ; preds = %1215, %1200
%1205 = load i32, i32* %96
%1206 = icmp slt i32 %1205, 10240
br i1 %1206, label %1207, label %1218
1207: ; preds = %1204
%1208 = load i32, i32* %96
%1209 = sext i32 %1208 to i64
%1210 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1209
%1211 = load i16, i16* %1210
%1212 = zext i16 %1211 to i32
%1213 = load i32, i32* %95
%1214 = add nsw i32 %1213, %1212
store i32 %1214, i32* %95
br label %1215
1215: ; preds = %1207
%1216 = load i32, i32* %96
%1217 = add nsw i32 %1216, 1
store i32 %1217, i32* %96
br label %1204
1218: ; preds = %1204
%1219 = load i32, i32* %95
%1220 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %1219)
store i32 0, i32* %97
br label %1221
1221: ; preds = %1232, %1218
%1222 = load i32, i32* %97
%1223 = icmp slt i32 %1222, 10240
br i1 %1223, label %1224, label %1235
1224: ; preds = %1221
%1225 = load i32, i32* %97
%1226 = load volatile i32, i32* %60
%1227 = mul nsw i32 %1225, %1226
%1228 = trunc i32 %1227 to i16
%1229 = load i32, i32* %97
%1230 = sext i32 %1229 to i64
%1231 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1230
store i16 %1228, i16* %1231
br label %1232
1232: ; preds = %1224
%1233 = load i32, i32* %97
%1234 = add nsw i32 %1233, 1
store i32 %1234, i32* %97
br label %1221
1235: ; preds = %1221
%1236 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1237 = getelementptr inbounds i16, i16* %1236, i64 13
%1238 = bitcast i16* %1237 to i8*
store i32 0, i32* %98
store i32 0, i32* %99
br label %1239
1239: ; preds = %1250, %1235
%1240 = load i32, i32* %99
%1241 = icmp slt i32 %1240, 10240
br i1 %1241, label %1242, label %1253
1242: ; preds = %1239
%1243 = load i32, i32* %99
%1244 = sext i32 %1243 to i64
%1245 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1244
%1246 = load i16, i16* %1245
%1247 = zext i16 %1246 to i32
%1248 = load i32, i32* %98
%1249 = add nsw i32 %1248, %1247
store i32 %1249, i32* %98
br label %1250
1250: ; preds = %1242
%1251 = load i32, i32* %99
%1252 = add nsw i32 %1251, 1
store i32 %1252, i32* %99
br label %1239
1253: ; preds = %1239
%1254 = load i32, i32* %98
%1255 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %1254)
store i32 0, i32* %100
br label %1256
1256: ; preds = %1267, %1253
%1257 = load i32, i32* %100
%1258 = icmp slt i32 %1257, 10240
br i1 %1258, label %1259, label %1270
1259: ; preds = %1256
%1260 = load i32, i32* %100
%1261 = load volatile i32, i32* %60
%1262 = mul nsw i32 %1260, %1261
%1263 = trunc i32 %1262 to i16
%1264 = load i32, i32* %100
%1265 = sext i32 %1264 to i64
%1266 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1265
store i16 %1263, i16* %1266
br label %1267
1267: ; preds = %1259
%1268 = load i32, i32* %100
%1269 = add nsw i32 %1268, 1
store i32 %1269, i32* %100
br label %1256
1270: ; preds = %1256
%1271 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1272 = getelementptr inbounds i16, i16* %1271, i64 9
%1273 = bitcast i16* %1272 to i8*
store i32 0, i32* %101
store i32 0, i32* %102
br label %1274
1274: ; preds = %1285, %1270
%1275 = load i32, i32* %102
%1276 = icmp slt i32 %1275, 10240
br i1 %1276, label %1277, label %1288
1277: ; preds = %1274
%1278 = load i32, i32* %102
%1279 = sext i32 %1278 to i64
%1280 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1279
%1281 = load i16, i16* %1280
%1282 = zext i16 %1281 to i32
%1283 = load i32, i32* %101
%1284 = add nsw i32 %1283, %1282
store i32 %1284, i32* %101
br label %1285
1285: ; preds = %1277
%1286 = load i32, i32* %102
%1287 = add nsw i32 %1286, 1
store i32 %1287, i32* %102
br label %1274
1288: ; preds = %1274
%1289 = load i32, i32* %101
%1290 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %1289)
store i32 0, i32* %103
br label %1291
1291: ; preds = %1302, %1288
%1292 = load i32, i32* %103
%1293 = icmp slt i32 %1292, 10240
br i1 %1293, label %1294, label %1305
1294: ; preds = %1291
%1295 = load i32, i32* %103
%1296 = load volatile i32, i32* %60
%1297 = mul nsw i32 %1295, %1296
%1298 = trunc i32 %1297 to i16
%1299 = load i32, i32* %103
%1300 = sext i32 %1299 to i64
%1301 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1300
store i16 %1298, i16* %1301
br label %1302
1302: ; preds = %1294
%1303 = load i32, i32* %103
%1304 = add nsw i32 %1303, 1
store i32 %1304, i32* %103
br label %1291
1305: ; preds = %1291
%1306 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1307 = getelementptr inbounds i16, i16* %1306, i64 1
%1308 = bitcast i16* %1307 to i8*
store i32 0, i32* %104
store i32 0, i32* %105
br label %1309
1309: ; preds = %1320, %1305
%1310 = load i32, i32* %105
%1311 = icmp slt i32 %1310, 10240
br i1 %1311, label %1312, label %1323
1312: ; preds = %1309
%1313 = load i32, i32* %105
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1314
%1316 = load i16, i16* %1315
%1317 = zext i16 %1316 to i32
%1318 = load i32, i32* %104
%1319 = add nsw i32 %1318, %1317
store i32 %1319, i32* %104
br label %1320
1320: ; preds = %1312
%1321 = load i32, i32* %105
%1322 = add nsw i32 %1321, 1
store i32 %1322, i32* %105
br label %1309
1323: ; preds = %1309
%1324 = load i32, i32* %104
%1325 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %1324)
store i32 0, i32* %106
br label %1326
1326: ; preds = %1337, %1323
%1327 = load i32, i32* %106
%1328 = icmp slt i32 %1327, 10240
br i1 %1328, label %1329, label %1340
1329: ; preds = %1326
%1330 = load i32, i32* %106
%1331 = load volatile i32, i32* %60
%1332 = mul nsw i32 %1330, %1331
%1333 = trunc i32 %1332 to i16
%1334 = load i32, i32* %106
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1335
store i16 %1333, i16* %1336
br label %1337
1337: ; preds = %1329
%1338 = load i32, i32* %106
%1339 = add nsw i32 %1338, 1
store i32 %1339, i32* %106
br label %1326
1340: ; preds = %1326
%1341 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1342 = getelementptr inbounds i16, i16* %1341, i64 2
%1343 = bitcast i16* %1342 to i8*
store i32 0, i32* %107
store i32 0, i32* %108
br label %1344
1344: ; preds = %1355, %1340
%1345 = load i32, i32* %108
%1346 = icmp slt i32 %1345, 10240
br i1 %1346, label %1347, label %1358
1347: ; preds = %1344
%1348 = load i32, i32* %108
%1349 = sext i32 %1348 to i64
%1350 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1349
%1351 = load i16, i16* %1350
%1352 = zext i16 %1351 to i32
%1353 = load i32, i32* %107
%1354 = add nsw i32 %1353, %1352
store i32 %1354, i32* %107
br label %1355
1355: ; preds = %1347
%1356 = load i32, i32* %108
%1357 = add nsw i32 %1356, 1
store i32 %1357, i32* %108
br label %1344
1358: ; preds = %1344
%1359 = load i32, i32* %107
%1360 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %1359)
store i32 0, i32* %109
br label %1361
1361: ; preds = %1372, %1358
%1362 = load i32, i32* %109
%1363 = icmp slt i32 %1362, 10240
br i1 %1363, label %1364, label %1375
1364: ; preds = %1361
%1365 = load i32, i32* %109
%1366 = load volatile i32, i32* %60
%1367 = mul nsw i32 %1365, %1366
%1368 = trunc i32 %1367 to i16
%1369 = load i32, i32* %109
%1370 = sext i32 %1369 to i64
%1371 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1370
store i16 %1368, i16* %1371
br label %1372
1372: ; preds = %1364
%1373 = load i32, i32* %109
%1374 = add nsw i32 %1373, 1
store i32 %1374, i32* %109
br label %1361
1375: ; preds = %1361
%1376 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1377 = getelementptr inbounds i16, i16* %1376, i64 4
%1378 = bitcast i16* %1377 to i8*
store i32 0, i32* %110
store i32 0, i32* %111
br label %1379
1379: ; preds = %1390, %1375
%1380 = load i32, i32* %111
%1381 = icmp slt i32 %1380, 10240
br i1 %1381, label %1382, label %1393
1382: ; preds = %1379
%1383 = load i32, i32* %111
%1384 = sext i32 %1383 to i64
%1385 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1384
%1386 = load i16, i16* %1385
%1387 = zext i16 %1386 to i32
%1388 = load i32, i32* %110
%1389 = add nsw i32 %1388, %1387
store i32 %1389, i32* %110
br label %1390
1390: ; preds = %1382
%1391 = load i32, i32* %111
%1392 = add nsw i32 %1391, 1
store i32 %1392, i32* %111
br label %1379
1393: ; preds = %1379
%1394 = load i32, i32* %110
%1395 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %1394)
store i32 10, i32* %112
br label %1396
1396: ; preds = %1441, %1393
%1397 = load i32, i32* %112
%1398 = icmp slt i32 %1397, 100
br i1 %1398, label %1399, label %1444
1399: ; preds = %1396
store i32 0, i32* %113
br label %1400
1400: ; preds = %1411, %1399
%1401 = load i32, i32* %113
%1402 = icmp slt i32 %1401, 10240
br i1 %1402, label %1403, label %1414
1403: ; preds = %1400
%1404 = load i32, i32* %113
%1405 = load volatile i32, i32* %60
%1406 = mul nsw i32 %1404, %1405
%1407 = trunc i32 %1406 to i16
%1408 = load i32, i32* %113
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1409
store i16 %1407, i16* %1410
br label %1411
1411: ; preds = %1403
%1412 = load i32, i32* %113
%1413 = add nsw i32 %1412, 1
store i32 %1413, i32* %113
br label %1400
1414: ; preds = %1400
%1415 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 0
%1416 = load i32, i32* %112
%1417 = srem i32 %1416, 17
%1418 = sext i32 %1417 to i64
%1419 = getelementptr inbounds i16, i16* %1415, i64 %1418
%1420 = bitcast i16* %1419 to i8*
%1421 = load i32, i32* %112
%1422 = sext i32 %1421 to i64
store i32 0, i32* %114
store i32 0, i32* %115
br label %1423
1423: ; preds = %1434, %1414
%1424 = load i32, i32* %115
%1425 = icmp slt i32 %1424, 10240
br i1 %1425, label %1426, label %1437
1426: ; preds = %1423
%1427 = load i32, i32* %115
%1428 = sext i32 %1427 to i64
%1429 = getelementptr inbounds [10240 x i16], [10240 x i16]* %59, i64 0, i64 %1428
%1430 = load i16, i16* %1429
%1431 = zext i16 %1430 to i32
%1432 = load i32, i32* %114
%1433 = add nsw i32 %1432, %1431
store i32 %1433, i32* %114
br label %1434
1434: ; preds = %1426
%1435 = load i32, i32* %115
%1436 = add nsw i32 %1435, 1
store i32 %1436, i32* %115
br label %1423
1437: ; preds = %1423
%1438 = load i32, i32* %112
%1439 = load i32, i32* %114
%1440 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %1438, i32 %1439)
br label %1441
1441: ; preds = %1437
%1442 = load i32, i32* %112
%1443 = add nsw i32 %1442, 10
store i32 %1443, i32* %112
br label %1396
1444: ; preds = %1396
%1445 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
store volatile i32 123, i32* %117
store i32 0, i32* %118
br label %1446
1446: ; preds = %1456, %1444
%1447 = load i32, i32* %118
%1448 = icmp slt i32 %1447, 10240
br i1 %1448, label %1449, label %1459
1449: ; preds = %1446
%1450 = load i32, i32* %118
%1451 = load volatile i32, i32* %117
%1452 = mul nsw i32 %1450, %1451
%1453 = load i32, i32* %118
%1454 = sext i32 %1453 to i64
%1455 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1454
store i32 %1452, i32* %1455
br label %1456
1456: ; preds = %1449
%1457 = load i32, i32* %118
%1458 = add nsw i32 %1457, 1
store i32 %1458, i32* %118
br label %1446
1459: ; preds = %1446
%1460 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1461 = getelementptr inbounds i32, i32* %1460, i64 1
%1462 = bitcast i32* %1461 to i8*
store i32 0, i32* %119
store i32 0, i32* %120
br label %1463
1463: ; preds = %1473, %1459
%1464 = load i32, i32* %120
%1465 = icmp slt i32 %1464, 10240
br i1 %1465, label %1466, label %1476
1466: ; preds = %1463
%1467 = load i32, i32* %120
%1468 = sext i32 %1467 to i64
%1469 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1468
%1470 = load i32, i32* %1469
%1471 = load i32, i32* %119
%1472 = add i32 %1471, %1470
store i32 %1472, i32* %119
br label %1473
1473: ; preds = %1466
%1474 = load i32, i32* %120
%1475 = add nsw i32 %1474, 1
store i32 %1475, i32* %120
br label %1463
1476: ; preds = %1463
%1477 = load i32, i32* %119
%1478 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %1477)
store i32 0, i32* %121
br label %1479
1479: ; preds = %1489, %1476
%1480 = load i32, i32* %121
%1481 = icmp slt i32 %1480, 10240
br i1 %1481, label %1482, label %1492
1482: ; preds = %1479
%1483 = load i32, i32* %121
%1484 = load volatile i32, i32* %117
%1485 = mul nsw i32 %1483, %1484
%1486 = load i32, i32* %121
%1487 = sext i32 %1486 to i64
%1488 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1487
store i32 %1485, i32* %1488
br label %1489
1489: ; preds = %1482
%1490 = load i32, i32* %121
%1491 = add nsw i32 %1490, 1
store i32 %1491, i32* %121
br label %1479
1492: ; preds = %1479
%1493 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1494 = getelementptr inbounds i32, i32* %1493, i64 2
%1495 = bitcast i32* %1494 to i8*
store i32 0, i32* %122
store i32 0, i32* %123
br label %1496
1496: ; preds = %1506, %1492
%1497 = load i32, i32* %123
%1498 = icmp slt i32 %1497, 10240
br i1 %1498, label %1499, label %1509
1499: ; preds = %1496
%1500 = load i32, i32* %123
%1501 = sext i32 %1500 to i64
%1502 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1501
%1503 = load i32, i32* %1502
%1504 = load i32, i32* %122
%1505 = add i32 %1504, %1503
store i32 %1505, i32* %122
br label %1506
1506: ; preds = %1499
%1507 = load i32, i32* %123
%1508 = add nsw i32 %1507, 1
store i32 %1508, i32* %123
br label %1496
1509: ; preds = %1496
%1510 = load i32, i32* %122
%1511 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %1510)
store i32 0, i32* %124
br label %1512
1512: ; preds = %1522, %1509
%1513 = load i32, i32* %124
%1514 = icmp slt i32 %1513, 10240
br i1 %1514, label %1515, label %1525
1515: ; preds = %1512
%1516 = load i32, i32* %124
%1517 = load volatile i32, i32* %117
%1518 = mul nsw i32 %1516, %1517
%1519 = load i32, i32* %124
%1520 = sext i32 %1519 to i64
%1521 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1520
store i32 %1518, i32* %1521
br label %1522
1522: ; preds = %1515
%1523 = load i32, i32* %124
%1524 = add nsw i32 %1523, 1
store i32 %1524, i32* %124
br label %1512
1525: ; preds = %1512
%1526 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1527 = getelementptr inbounds i32, i32* %1526, i64 3
%1528 = bitcast i32* %1527 to i8*
store i32 0, i32* %125
store i32 0, i32* %126
br label %1529
1529: ; preds = %1539, %1525
%1530 = load i32, i32* %126
%1531 = icmp slt i32 %1530, 10240
br i1 %1531, label %1532, label %1542
1532: ; preds = %1529
%1533 = load i32, i32* %126
%1534 = sext i32 %1533 to i64
%1535 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1534
%1536 = load i32, i32* %1535
%1537 = load i32, i32* %125
%1538 = add i32 %1537, %1536
store i32 %1538, i32* %125
br label %1539
1539: ; preds = %1532
%1540 = load i32, i32* %126
%1541 = add nsw i32 %1540, 1
store i32 %1541, i32* %126
br label %1529
1542: ; preds = %1529
%1543 = load i32, i32* %125
%1544 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %1543)
store i32 0, i32* %127
br label %1545
1545: ; preds = %1555, %1542
%1546 = load i32, i32* %127
%1547 = icmp slt i32 %1546, 10240
br i1 %1547, label %1548, label %1558
1548: ; preds = %1545
%1549 = load i32, i32* %127
%1550 = load volatile i32, i32* %117
%1551 = mul nsw i32 %1549, %1550
%1552 = load i32, i32* %127
%1553 = sext i32 %1552 to i64
%1554 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1553
store i32 %1551, i32* %1554
br label %1555
1555: ; preds = %1548
%1556 = load i32, i32* %127
%1557 = add nsw i32 %1556, 1
store i32 %1557, i32* %127
br label %1545
1558: ; preds = %1545
%1559 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1560 = getelementptr inbounds i32, i32* %1559, i64 4
%1561 = bitcast i32* %1560 to i8*
store i32 0, i32* %128
store i32 0, i32* %129
br label %1562
1562: ; preds = %1572, %1558
%1563 = load i32, i32* %129
%1564 = icmp slt i32 %1563, 10240
br i1 %1564, label %1565, label %1575
1565: ; preds = %1562
%1566 = load i32, i32* %129
%1567 = sext i32 %1566 to i64
%1568 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1567
%1569 = load i32, i32* %1568
%1570 = load i32, i32* %128
%1571 = add i32 %1570, %1569
store i32 %1571, i32* %128
br label %1572
1572: ; preds = %1565
%1573 = load i32, i32* %129
%1574 = add nsw i32 %1573, 1
store i32 %1574, i32* %129
br label %1562
1575: ; preds = %1562
%1576 = load i32, i32* %128
%1577 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %1576)
store i32 0, i32* %130
br label %1578
1578: ; preds = %1588, %1575
%1579 = load i32, i32* %130
%1580 = icmp slt i32 %1579, 10240
br i1 %1580, label %1581, label %1591
1581: ; preds = %1578
%1582 = load i32, i32* %130
%1583 = load volatile i32, i32* %117
%1584 = mul nsw i32 %1582, %1583
%1585 = load i32, i32* %130
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1586
store i32 %1584, i32* %1587
br label %1588
1588: ; preds = %1581
%1589 = load i32, i32* %130
%1590 = add nsw i32 %1589, 1
store i32 %1590, i32* %130
br label %1578
1591: ; preds = %1578
%1592 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1593 = getelementptr inbounds i32, i32* %1592, i64 5
%1594 = bitcast i32* %1593 to i8*
store i32 0, i32* %131
store i32 0, i32* %132
br label %1595
1595: ; preds = %1605, %1591
%1596 = load i32, i32* %132
%1597 = icmp slt i32 %1596, 10240
br i1 %1597, label %1598, label %1608
1598: ; preds = %1595
%1599 = load i32, i32* %132
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1600
%1602 = load i32, i32* %1601
%1603 = load i32, i32* %131
%1604 = add i32 %1603, %1602
store i32 %1604, i32* %131
br label %1605
1605: ; preds = %1598
%1606 = load i32, i32* %132
%1607 = add nsw i32 %1606, 1
store i32 %1607, i32* %132
br label %1595
1608: ; preds = %1595
%1609 = load i32, i32* %131
%1610 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %1609)
store i32 0, i32* %133
br label %1611
1611: ; preds = %1621, %1608
%1612 = load i32, i32* %133
%1613 = icmp slt i32 %1612, 10240
br i1 %1613, label %1614, label %1624
1614: ; preds = %1611
%1615 = load i32, i32* %133
%1616 = load volatile i32, i32* %117
%1617 = mul nsw i32 %1615, %1616
%1618 = load i32, i32* %133
%1619 = sext i32 %1618 to i64
%1620 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1619
store i32 %1617, i32* %1620
br label %1621
1621: ; preds = %1614
%1622 = load i32, i32* %133
%1623 = add nsw i32 %1622, 1
store i32 %1623, i32* %133
br label %1611
1624: ; preds = %1611
%1625 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1626 = getelementptr inbounds i32, i32* %1625, i64 6
%1627 = bitcast i32* %1626 to i8*
store i32 0, i32* %134
store i32 0, i32* %135
br label %1628
1628: ; preds = %1638, %1624
%1629 = load i32, i32* %135
%1630 = icmp slt i32 %1629, 10240
br i1 %1630, label %1631, label %1641
1631: ; preds = %1628
%1632 = load i32, i32* %135
%1633 = sext i32 %1632 to i64
%1634 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1633
%1635 = load i32, i32* %1634
%1636 = load i32, i32* %134
%1637 = add i32 %1636, %1635
store i32 %1637, i32* %134
br label %1638
1638: ; preds = %1631
%1639 = load i32, i32* %135
%1640 = add nsw i32 %1639, 1
store i32 %1640, i32* %135
br label %1628
1641: ; preds = %1628
%1642 = load i32, i32* %134
%1643 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %1642)
store i32 0, i32* %136
br label %1644
1644: ; preds = %1654, %1641
%1645 = load i32, i32* %136
%1646 = icmp slt i32 %1645, 10240
br i1 %1646, label %1647, label %1657
1647: ; preds = %1644
%1648 = load i32, i32* %136
%1649 = load volatile i32, i32* %117
%1650 = mul nsw i32 %1648, %1649
%1651 = load i32, i32* %136
%1652 = sext i32 %1651 to i64
%1653 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1652
store i32 %1650, i32* %1653
br label %1654
1654: ; preds = %1647
%1655 = load i32, i32* %136
%1656 = add nsw i32 %1655, 1
store i32 %1656, i32* %136
br label %1644
1657: ; preds = %1644
%1658 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1659 = getelementptr inbounds i32, i32* %1658, i64 7
%1660 = bitcast i32* %1659 to i8*
store i32 0, i32* %137
store i32 0, i32* %138
br label %1661
1661: ; preds = %1671, %1657
%1662 = load i32, i32* %138
%1663 = icmp slt i32 %1662, 10240
br i1 %1663, label %1664, label %1674
1664: ; preds = %1661
%1665 = load i32, i32* %138
%1666 = sext i32 %1665 to i64
%1667 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1666
%1668 = load i32, i32* %1667
%1669 = load i32, i32* %137
%1670 = add i32 %1669, %1668
store i32 %1670, i32* %137
br label %1671
1671: ; preds = %1664
%1672 = load i32, i32* %138
%1673 = add nsw i32 %1672, 1
store i32 %1673, i32* %138
br label %1661
1674: ; preds = %1661
%1675 = load i32, i32* %137
%1676 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %1675)
store i32 0, i32* %139
br label %1677
1677: ; preds = %1687, %1674
%1678 = load i32, i32* %139
%1679 = icmp slt i32 %1678, 10240
br i1 %1679, label %1680, label %1690
1680: ; preds = %1677
%1681 = load i32, i32* %139
%1682 = load volatile i32, i32* %117
%1683 = mul nsw i32 %1681, %1682
%1684 = load i32, i32* %139
%1685 = sext i32 %1684 to i64
%1686 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1685
store i32 %1683, i32* %1686
br label %1687
1687: ; preds = %1680
%1688 = load i32, i32* %139
%1689 = add nsw i32 %1688, 1
store i32 %1689, i32* %139
br label %1677
1690: ; preds = %1677
%1691 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1692 = getelementptr inbounds i32, i32* %1691, i64 8
%1693 = bitcast i32* %1692 to i8*
store i32 0, i32* %140
store i32 0, i32* %141
br label %1694
1694: ; preds = %1704, %1690
%1695 = load i32, i32* %141
%1696 = icmp slt i32 %1695, 10240
br i1 %1696, label %1697, label %1707
1697: ; preds = %1694
%1698 = load i32, i32* %141
%1699 = sext i32 %1698 to i64
%1700 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1699
%1701 = load i32, i32* %1700
%1702 = load i32, i32* %140
%1703 = add i32 %1702, %1701
store i32 %1703, i32* %140
br label %1704
1704: ; preds = %1697
%1705 = load i32, i32* %141
%1706 = add nsw i32 %1705, 1
store i32 %1706, i32* %141
br label %1694
1707: ; preds = %1694
%1708 = load i32, i32* %140
%1709 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %1708)
store i32 0, i32* %142
br label %1710
1710: ; preds = %1720, %1707
%1711 = load i32, i32* %142
%1712 = icmp slt i32 %1711, 10240
br i1 %1712, label %1713, label %1723
1713: ; preds = %1710
%1714 = load i32, i32* %142
%1715 = load volatile i32, i32* %117
%1716 = mul nsw i32 %1714, %1715
%1717 = load i32, i32* %142
%1718 = sext i32 %1717 to i64
%1719 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1718
store i32 %1716, i32* %1719
br label %1720
1720: ; preds = %1713
%1721 = load i32, i32* %142
%1722 = add nsw i32 %1721, 1
store i32 %1722, i32* %142
br label %1710
1723: ; preds = %1710
%1724 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1725 = getelementptr inbounds i32, i32* %1724, i64 9
%1726 = bitcast i32* %1725 to i8*
store i32 0, i32* %143
store i32 0, i32* %144
br label %1727
1727: ; preds = %1737, %1723
%1728 = load i32, i32* %144
%1729 = icmp slt i32 %1728, 10240
br i1 %1729, label %1730, label %1740
1730: ; preds = %1727
%1731 = load i32, i32* %144
%1732 = sext i32 %1731 to i64
%1733 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1732
%1734 = load i32, i32* %1733
%1735 = load i32, i32* %143
%1736 = add i32 %1735, %1734
store i32 %1736, i32* %143
br label %1737
1737: ; preds = %1730
%1738 = load i32, i32* %144
%1739 = add nsw i32 %1738, 1
store i32 %1739, i32* %144
br label %1727
1740: ; preds = %1727
%1741 = load i32, i32* %143
%1742 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %1741)
store i32 0, i32* %145
br label %1743
1743: ; preds = %1753, %1740
%1744 = load i32, i32* %145
%1745 = icmp slt i32 %1744, 10240
br i1 %1745, label %1746, label %1756
1746: ; preds = %1743
%1747 = load i32, i32* %145
%1748 = load volatile i32, i32* %117
%1749 = mul nsw i32 %1747, %1748
%1750 = load i32, i32* %145
%1751 = sext i32 %1750 to i64
%1752 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1751
store i32 %1749, i32* %1752
br label %1753
1753: ; preds = %1746
%1754 = load i32, i32* %145
%1755 = add nsw i32 %1754, 1
store i32 %1755, i32* %145
br label %1743
1756: ; preds = %1743
%1757 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1758 = getelementptr inbounds i32, i32* %1757, i64 10
%1759 = bitcast i32* %1758 to i8*
store i32 0, i32* %146
store i32 0, i32* %147
br label %1760
1760: ; preds = %1770, %1756
%1761 = load i32, i32* %147
%1762 = icmp slt i32 %1761, 10240
br i1 %1762, label %1763, label %1773
1763: ; preds = %1760
%1764 = load i32, i32* %147
%1765 = sext i32 %1764 to i64
%1766 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1765
%1767 = load i32, i32* %1766
%1768 = load i32, i32* %146
%1769 = add i32 %1768, %1767
store i32 %1769, i32* %146
br label %1770
1770: ; preds = %1763
%1771 = load i32, i32* %147
%1772 = add nsw i32 %1771, 1
store i32 %1772, i32* %147
br label %1760
1773: ; preds = %1760
%1774 = load i32, i32* %146
%1775 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %1774)
store i32 0, i32* %148
br label %1776
1776: ; preds = %1786, %1773
%1777 = load i32, i32* %148
%1778 = icmp slt i32 %1777, 10240
br i1 %1778, label %1779, label %1789
1779: ; preds = %1776
%1780 = load i32, i32* %148
%1781 = load volatile i32, i32* %117
%1782 = mul nsw i32 %1780, %1781
%1783 = load i32, i32* %148
%1784 = sext i32 %1783 to i64
%1785 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1784
store i32 %1782, i32* %1785
br label %1786
1786: ; preds = %1779
%1787 = load i32, i32* %148
%1788 = add nsw i32 %1787, 1
store i32 %1788, i32* %148
br label %1776
1789: ; preds = %1776
%1790 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1791 = getelementptr inbounds i32, i32* %1790, i64 16
%1792 = bitcast i32* %1791 to i8*
store i32 0, i32* %149
store i32 0, i32* %150
br label %1793
1793: ; preds = %1803, %1789
%1794 = load i32, i32* %150
%1795 = icmp slt i32 %1794, 10240
br i1 %1795, label %1796, label %1806
1796: ; preds = %1793
%1797 = load i32, i32* %150
%1798 = sext i32 %1797 to i64
%1799 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1798
%1800 = load i32, i32* %1799
%1801 = load i32, i32* %149
%1802 = add i32 %1801, %1800
store i32 %1802, i32* %149
br label %1803
1803: ; preds = %1796
%1804 = load i32, i32* %150
%1805 = add nsw i32 %1804, 1
store i32 %1805, i32* %150
br label %1793
1806: ; preds = %1793
%1807 = load i32, i32* %149
%1808 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %1807)
store i32 0, i32* %151
br label %1809
1809: ; preds = %1819, %1806
%1810 = load i32, i32* %151
%1811 = icmp slt i32 %1810, 10240
br i1 %1811, label %1812, label %1822
1812: ; preds = %1809
%1813 = load i32, i32* %151
%1814 = load volatile i32, i32* %117
%1815 = mul nsw i32 %1813, %1814
%1816 = load i32, i32* %151
%1817 = sext i32 %1816 to i64
%1818 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1817
store i32 %1815, i32* %1818
br label %1819
1819: ; preds = %1812
%1820 = load i32, i32* %151
%1821 = add nsw i32 %1820, 1
store i32 %1821, i32* %151
br label %1809
1822: ; preds = %1809
%1823 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1824 = getelementptr inbounds i32, i32* %1823, i64 15
%1825 = bitcast i32* %1824 to i8*
store i32 0, i32* %152
store i32 0, i32* %153
br label %1826
1826: ; preds = %1836, %1822
%1827 = load i32, i32* %153
%1828 = icmp slt i32 %1827, 10240
br i1 %1828, label %1829, label %1839
1829: ; preds = %1826
%1830 = load i32, i32* %153
%1831 = sext i32 %1830 to i64
%1832 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1831
%1833 = load i32, i32* %1832
%1834 = load i32, i32* %152
%1835 = add i32 %1834, %1833
store i32 %1835, i32* %152
br label %1836
1836: ; preds = %1829
%1837 = load i32, i32* %153
%1838 = add nsw i32 %1837, 1
store i32 %1838, i32* %153
br label %1826
1839: ; preds = %1826
%1840 = load i32, i32* %152
%1841 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %1840)
store i32 0, i32* %154
br label %1842
1842: ; preds = %1852, %1839
%1843 = load i32, i32* %154
%1844 = icmp slt i32 %1843, 10240
br i1 %1844, label %1845, label %1855
1845: ; preds = %1842
%1846 = load i32, i32* %154
%1847 = load volatile i32, i32* %117
%1848 = mul nsw i32 %1846, %1847
%1849 = load i32, i32* %154
%1850 = sext i32 %1849 to i64
%1851 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1850
store i32 %1848, i32* %1851
br label %1852
1852: ; preds = %1845
%1853 = load i32, i32* %154
%1854 = add nsw i32 %1853, 1
store i32 %1854, i32* %154
br label %1842
1855: ; preds = %1842
%1856 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1857 = getelementptr inbounds i32, i32* %1856, i64 13
%1858 = bitcast i32* %1857 to i8*
store i32 0, i32* %155
store i32 0, i32* %156
br label %1859
1859: ; preds = %1869, %1855
%1860 = load i32, i32* %156
%1861 = icmp slt i32 %1860, 10240
br i1 %1861, label %1862, label %1872
1862: ; preds = %1859
%1863 = load i32, i32* %156
%1864 = sext i32 %1863 to i64
%1865 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1864
%1866 = load i32, i32* %1865
%1867 = load i32, i32* %155
%1868 = add i32 %1867, %1866
store i32 %1868, i32* %155
br label %1869
1869: ; preds = %1862
%1870 = load i32, i32* %156
%1871 = add nsw i32 %1870, 1
store i32 %1871, i32* %156
br label %1859
1872: ; preds = %1859
%1873 = load i32, i32* %155
%1874 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %1873)
store i32 0, i32* %157
br label %1875
1875: ; preds = %1885, %1872
%1876 = load i32, i32* %157
%1877 = icmp slt i32 %1876, 10240
br i1 %1877, label %1878, label %1888
1878: ; preds = %1875
%1879 = load i32, i32* %157
%1880 = load volatile i32, i32* %117
%1881 = mul nsw i32 %1879, %1880
%1882 = load i32, i32* %157
%1883 = sext i32 %1882 to i64
%1884 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1883
store i32 %1881, i32* %1884
br label %1885
1885: ; preds = %1878
%1886 = load i32, i32* %157
%1887 = add nsw i32 %1886, 1
store i32 %1887, i32* %157
br label %1875
1888: ; preds = %1875
%1889 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1890 = getelementptr inbounds i32, i32* %1889, i64 9
%1891 = bitcast i32* %1890 to i8*
store i32 0, i32* %158
store i32 0, i32* %159
br label %1892
1892: ; preds = %1902, %1888
%1893 = load i32, i32* %159
%1894 = icmp slt i32 %1893, 10240
br i1 %1894, label %1895, label %1905
1895: ; preds = %1892
%1896 = load i32, i32* %159
%1897 = sext i32 %1896 to i64
%1898 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1897
%1899 = load i32, i32* %1898
%1900 = load i32, i32* %158
%1901 = add i32 %1900, %1899
store i32 %1901, i32* %158
br label %1902
1902: ; preds = %1895
%1903 = load i32, i32* %159
%1904 = add nsw i32 %1903, 1
store i32 %1904, i32* %159
br label %1892
1905: ; preds = %1892
%1906 = load i32, i32* %158
%1907 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %1906)
store i32 0, i32* %160
br label %1908
1908: ; preds = %1918, %1905
%1909 = load i32, i32* %160
%1910 = icmp slt i32 %1909, 10240
br i1 %1910, label %1911, label %1921
1911: ; preds = %1908
%1912 = load i32, i32* %160
%1913 = load volatile i32, i32* %117
%1914 = mul nsw i32 %1912, %1913
%1915 = load i32, i32* %160
%1916 = sext i32 %1915 to i64
%1917 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1916
store i32 %1914, i32* %1917
br label %1918
1918: ; preds = %1911
%1919 = load i32, i32* %160
%1920 = add nsw i32 %1919, 1
store i32 %1920, i32* %160
br label %1908
1921: ; preds = %1908
%1922 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1923 = getelementptr inbounds i32, i32* %1922, i64 1
%1924 = bitcast i32* %1923 to i8*
store i32 0, i32* %161
store i32 0, i32* %162
br label %1925
1925: ; preds = %1935, %1921
%1926 = load i32, i32* %162
%1927 = icmp slt i32 %1926, 10240
br i1 %1927, label %1928, label %1938
1928: ; preds = %1925
%1929 = load i32, i32* %162
%1930 = sext i32 %1929 to i64
%1931 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1930
%1932 = load i32, i32* %1931
%1933 = load i32, i32* %161
%1934 = add i32 %1933, %1932
store i32 %1934, i32* %161
br label %1935
1935: ; preds = %1928
%1936 = load i32, i32* %162
%1937 = add nsw i32 %1936, 1
store i32 %1937, i32* %162
br label %1925
1938: ; preds = %1925
%1939 = load i32, i32* %161
%1940 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %1939)
store i32 0, i32* %163
br label %1941
1941: ; preds = %1951, %1938
%1942 = load i32, i32* %163
%1943 = icmp slt i32 %1942, 10240
br i1 %1943, label %1944, label %1954
1944: ; preds = %1941
%1945 = load i32, i32* %163
%1946 = load volatile i32, i32* %117
%1947 = mul nsw i32 %1945, %1946
%1948 = load i32, i32* %163
%1949 = sext i32 %1948 to i64
%1950 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1949
store i32 %1947, i32* %1950
br label %1951
1951: ; preds = %1944
%1952 = load i32, i32* %163
%1953 = add nsw i32 %1952, 1
store i32 %1953, i32* %163
br label %1941
1954: ; preds = %1941
%1955 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1956 = getelementptr inbounds i32, i32* %1955, i64 2
%1957 = bitcast i32* %1956 to i8*
store i32 0, i32* %164
store i32 0, i32* %165
br label %1958
1958: ; preds = %1968, %1954
%1959 = load i32, i32* %165
%1960 = icmp slt i32 %1959, 10240
br i1 %1960, label %1961, label %1971
1961: ; preds = %1958
%1962 = load i32, i32* %165
%1963 = sext i32 %1962 to i64
%1964 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1963
%1965 = load i32, i32* %1964
%1966 = load i32, i32* %164
%1967 = add i32 %1966, %1965
store i32 %1967, i32* %164
br label %1968
1968: ; preds = %1961
%1969 = load i32, i32* %165
%1970 = add nsw i32 %1969, 1
store i32 %1970, i32* %165
br label %1958
1971: ; preds = %1958
%1972 = load i32, i32* %164
%1973 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %1972)
store i32 0, i32* %166
br label %1974
1974: ; preds = %1984, %1971
%1975 = load i32, i32* %166
%1976 = icmp slt i32 %1975, 10240
br i1 %1976, label %1977, label %1987
1977: ; preds = %1974
%1978 = load i32, i32* %166
%1979 = load volatile i32, i32* %117
%1980 = mul nsw i32 %1978, %1979
%1981 = load i32, i32* %166
%1982 = sext i32 %1981 to i64
%1983 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1982
store i32 %1980, i32* %1983
br label %1984
1984: ; preds = %1977
%1985 = load i32, i32* %166
%1986 = add nsw i32 %1985, 1
store i32 %1986, i32* %166
br label %1974
1987: ; preds = %1974
%1988 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%1989 = getelementptr inbounds i32, i32* %1988, i64 4
%1990 = bitcast i32* %1989 to i8*
store i32 0, i32* %167
store i32 0, i32* %168
br label %1991
1991: ; preds = %2001, %1987
%1992 = load i32, i32* %168
%1993 = icmp slt i32 %1992, 10240
br i1 %1993, label %1994, label %2004
1994: ; preds = %1991
%1995 = load i32, i32* %168
%1996 = sext i32 %1995 to i64
%1997 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %1996
%1998 = load i32, i32* %1997
%1999 = load i32, i32* %167
%2000 = add i32 %1999, %1998
store i32 %2000, i32* %167
br label %2001
2001: ; preds = %1994
%2002 = load i32, i32* %168
%2003 = add nsw i32 %2002, 1
store i32 %2003, i32* %168
br label %1991
2004: ; preds = %1991
%2005 = load i32, i32* %167
%2006 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %2005)
store i32 10, i32* %169
br label %2007
2007: ; preds = %2050, %2004
%2008 = load i32, i32* %169
%2009 = icmp slt i32 %2008, 100
br i1 %2009, label %2010, label %2053
2010: ; preds = %2007
store i32 0, i32* %170
br label %2011
2011: ; preds = %2021, %2010
%2012 = load i32, i32* %170
%2013 = icmp slt i32 %2012, 10240
br i1 %2013, label %2014, label %2024
2014: ; preds = %2011
%2015 = load i32, i32* %170
%2016 = load volatile i32, i32* %117
%2017 = mul nsw i32 %2015, %2016
%2018 = load i32, i32* %170
%2019 = sext i32 %2018 to i64
%2020 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %2019
store i32 %2017, i32* %2020
br label %2021
2021: ; preds = %2014
%2022 = load i32, i32* %170
%2023 = add nsw i32 %2022, 1
store i32 %2023, i32* %170
br label %2011
2024: ; preds = %2011
%2025 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 0
%2026 = load i32, i32* %169
%2027 = srem i32 %2026, 17
%2028 = sext i32 %2027 to i64
%2029 = getelementptr inbounds i32, i32* %2025, i64 %2028
%2030 = bitcast i32* %2029 to i8*
%2031 = load i32, i32* %169
%2032 = sext i32 %2031 to i64
store i32 0, i32* %171
store i32 0, i32* %172
br label %2033
2033: ; preds = %2043, %2024
%2034 = load i32, i32* %172
%2035 = icmp slt i32 %2034, 10240
br i1 %2035, label %2036, label %2046
2036: ; preds = %2033
%2037 = load i32, i32* %172
%2038 = sext i32 %2037 to i64
%2039 = getelementptr inbounds [10240 x i32], [10240 x i32]* %116, i64 0, i64 %2038
%2040 = load i32, i32* %2039
%2041 = load i32, i32* %171
%2042 = add i32 %2041, %2040
store i32 %2042, i32* %171
br label %2043
2043: ; preds = %2036
%2044 = load i32, i32* %172
%2045 = add nsw i32 %2044, 1
store i32 %2045, i32* %172
br label %2033
2046: ; preds = %2033
%2047 = load i32, i32* %169
%2048 = load i32, i32* %171
%2049 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %2047, i32 %2048)
br label %2050
2050: ; preds = %2046
%2051 = load i32, i32* %169
%2052 = add nsw i32 %2051, 10
store i32 %2052, i32* %169
br label %2007
2053: ; preds = %2007
ret i32 1
}

LLVM IR (-O2):
@.str.1 = [13 x i8] c"final %d:%d\0A\00"
@str = [2 x i8] c"8\00"
@str.4 = [3 x i8] c"16\00"
@str.5 = [3 x i8] c"32\00"
define i32 @main() {
%1 = alloca [10240 x i8]
%2 = alloca i32
%3 = alloca [10240 x i16]
%4 = alloca i32
%5 = alloca [10240 x i32]
%6 = alloca i32
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str, i64 0, i64 0))
%8 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 0
%9 = bitcast i32* %2 to i8*
store volatile i32 123, i32* %2
br label %43
10: ; preds = %43
%11 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 1
store i8 -91, i8* %11
br label %12
12: ; preds = %12, %10
%13 = phi i64 [ 0, %10 ], [ %37, %12 ]
%14 = phi <4 x i32> [ zeroinitializer, %10 ], [ %35, %12 ]
%15 = phi <4 x i32> [ zeroinitializer, %10 ], [ %36, %12 ]
%16 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %13
%17 = bitcast i8* %16 to <4 x i8>*
%18 = load <4 x i8>, <4 x i8>* %17
%19 = getelementptr inbounds i8, i8* %16, i64 4
%20 = bitcast i8* %19 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20
%22 = zext <4 x i8> %18 to <4 x i32>
%23 = zext <4 x i8> %21 to <4 x i32>
%24 = add <4 x i32> %14, %22
%25 = add <4 x i32> %15, %23
%26 = or i64 %13, 8
%27 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %26
%28 = bitcast i8* %27 to <4 x i8>*
%29 = load <4 x i8>, <4 x i8>* %28
%30 = getelementptr inbounds i8, i8* %27, i64 4
%31 = bitcast i8* %30 to <4 x i8>*
%32 = load <4 x i8>, <4 x i8>* %31
%33 = zext <4 x i8> %29 to <4 x i32>
%34 = zext <4 x i8> %32 to <4 x i32>
%35 = add <4 x i32> %24, %33
%36 = add <4 x i32> %25, %34
%37 = add nuw nsw i64 %13, 16
%38 = icmp eq i64 %37, 10240
br i1 %38, label %39, label %12
39: ; preds = %12
%40 = add <4 x i32> %36, %35
%41 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %40)
%42 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %41)
br label %110
43: ; preds = %43, %0
%44 = phi i64 [ 0, %0 ], [ %74, %43 ]
%45 = load volatile i32, i32* %2
%46 = trunc i64 %44 to i32
%47 = mul nsw i32 %45, %46
%48 = trunc i32 %47 to i8
%49 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %44
store i8 %48, i8* %49
%50 = add nuw nsw i64 %44, 1
%51 = load volatile i32, i32* %2
%52 = trunc i64 %50 to i32
%53 = mul nsw i32 %51, %52
%54 = trunc i32 %53 to i8
%55 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %50
store i8 %54, i8* %55
%56 = add nuw nsw i64 %44, 2
%57 = load volatile i32, i32* %2
%58 = trunc i64 %56 to i32
%59 = mul nsw i32 %57, %58
%60 = trunc i32 %59 to i8
%61 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %56
store i8 %60, i8* %61
%62 = add nuw nsw i64 %44, 3
%63 = load volatile i32, i32* %2
%64 = trunc i64 %62 to i32
%65 = mul nsw i32 %63, %64
%66 = trunc i32 %65 to i8
%67 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %62
store i8 %66, i8* %67
%68 = add nuw nsw i64 %44, 4
%69 = load volatile i32, i32* %2
%70 = trunc i64 %68 to i32
%71 = mul nsw i32 %69, %70
%72 = trunc i32 %71 to i8
%73 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %68
store i8 %72, i8* %73
%74 = add nuw nsw i64 %44, 5
%75 = icmp eq i64 %74, 10240
br i1 %75, label %10, label %43
76: ; preds = %110
%77 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 2
%78 = bitcast i8* %77 to i16*
store i16 -23131, i16* %78
br label %79
79: ; preds = %79, %76
%80 = phi i64 [ 0, %76 ], [ %104, %79 ]
%81 = phi <4 x i32> [ zeroinitializer, %76 ], [ %102, %79 ]
%82 = phi <4 x i32> [ zeroinitializer, %76 ], [ %103, %79 ]
%83 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %80
%84 = bitcast i8* %83 to <4 x i8>*
%85 = load <4 x i8>, <4 x i8>* %84
%86 = getelementptr inbounds i8, i8* %83, i64 4
%87 = bitcast i8* %86 to <4 x i8>*
%88 = load <4 x i8>, <4 x i8>* %87
%89 = zext <4 x i8> %85 to <4 x i32>
%90 = zext <4 x i8> %88 to <4 x i32>
%91 = add <4 x i32> %81, %89
%92 = add <4 x i32> %82, %90
%93 = or i64 %80, 8
%94 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %93
%95 = bitcast i8* %94 to <4 x i8>*
%96 = load <4 x i8>, <4 x i8>* %95
%97 = getelementptr inbounds i8, i8* %94, i64 4
%98 = bitcast i8* %97 to <4 x i8>*
%99 = load <4 x i8>, <4 x i8>* %98
%100 = zext <4 x i8> %96 to <4 x i32>
%101 = zext <4 x i8> %99 to <4 x i32>
%102 = add <4 x i32> %91, %100
%103 = add <4 x i32> %92, %101
%104 = add nuw nsw i64 %80, 16
%105 = icmp eq i64 %104, 10240
br i1 %105, label %106, label %79
106: ; preds = %79
%107 = add <4 x i32> %103, %102
%108 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %107)
%109 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %108)
br label %176
110: ; preds = %110, %39
%111 = phi i64 [ 0, %39 ], [ %141, %110 ]
%112 = load volatile i32, i32* %2
%113 = trunc i64 %111 to i32
%114 = mul nsw i32 %112, %113
%115 = trunc i32 %114 to i8
%116 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %111
store i8 %115, i8* %116
%117 = add nuw nsw i64 %111, 1
%118 = load volatile i32, i32* %2
%119 = trunc i64 %117 to i32
%120 = mul nsw i32 %118, %119
%121 = trunc i32 %120 to i8
%122 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %117
store i8 %121, i8* %122
%123 = add nuw nsw i64 %111, 2
%124 = load volatile i32, i32* %2
%125 = trunc i64 %123 to i32
%126 = mul nsw i32 %124, %125
%127 = trunc i32 %126 to i8
%128 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %123
store i8 %127, i8* %128
%129 = add nuw nsw i64 %111, 3
%130 = load volatile i32, i32* %2
%131 = trunc i64 %129 to i32
%132 = mul nsw i32 %130, %131
%133 = trunc i32 %132 to i8
%134 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %129
store i8 %133, i8* %134
%135 = add nuw nsw i64 %111, 4
%136 = load volatile i32, i32* %2
%137 = trunc i64 %135 to i32
%138 = mul nsw i32 %136, %137
%139 = trunc i32 %138 to i8
%140 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %135
store i8 %139, i8* %140
%141 = add nuw nsw i64 %111, 5
%142 = icmp eq i64 %141, 10240
br i1 %142, label %76, label %110
143: ; preds = %176
%144 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 3
br label %145
145: ; preds = %145, %143
%146 = phi i64 [ 0, %143 ], [ %170, %145 ]
%147 = phi <4 x i32> [ zeroinitializer, %143 ], [ %168, %145 ]
%148 = phi <4 x i32> [ zeroinitializer, %143 ], [ %169, %145 ]
%149 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %146
%150 = bitcast i8* %149 to <4 x i8>*
%151 = load <4 x i8>, <4 x i8>* %150
%152 = getelementptr inbounds i8, i8* %149, i64 4
%153 = bitcast i8* %152 to <4 x i8>*
%154 = load <4 x i8>, <4 x i8>* %153
%155 = zext <4 x i8> %151 to <4 x i32>
%156 = zext <4 x i8> %154 to <4 x i32>
%157 = add <4 x i32> %147, %155
%158 = add <4 x i32> %148, %156
%159 = or i64 %146, 8
%160 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %159
%161 = bitcast i8* %160 to <4 x i8>*
%162 = load <4 x i8>, <4 x i8>* %161
%163 = getelementptr inbounds i8, i8* %160, i64 4
%164 = bitcast i8* %163 to <4 x i8>*
%165 = load <4 x i8>, <4 x i8>* %164
%166 = zext <4 x i8> %162 to <4 x i32>
%167 = zext <4 x i8> %165 to <4 x i32>
%168 = add <4 x i32> %157, %166
%169 = add <4 x i32> %158, %167
%170 = add nuw nsw i64 %146, 16
%171 = icmp eq i64 %170, 10240
br i1 %171, label %172, label %145
172: ; preds = %145
%173 = add <4 x i32> %169, %168
%174 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %173)
%175 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %174)
br label %243
176: ; preds = %176, %106
%177 = phi i64 [ 0, %106 ], [ %207, %176 ]
%178 = load volatile i32, i32* %2
%179 = trunc i64 %177 to i32
%180 = mul nsw i32 %178, %179
%181 = trunc i32 %180 to i8
%182 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %177
store i8 %181, i8* %182
%183 = add nuw nsw i64 %177, 1
%184 = load volatile i32, i32* %2
%185 = trunc i64 %183 to i32
%186 = mul nsw i32 %184, %185
%187 = trunc i32 %186 to i8
%188 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %183
store i8 %187, i8* %188
%189 = add nuw nsw i64 %177, 2
%190 = load volatile i32, i32* %2
%191 = trunc i64 %189 to i32
%192 = mul nsw i32 %190, %191
%193 = trunc i32 %192 to i8
%194 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %189
store i8 %193, i8* %194
%195 = add nuw nsw i64 %177, 3
%196 = load volatile i32, i32* %2
%197 = trunc i64 %195 to i32
%198 = mul nsw i32 %196, %197
%199 = trunc i32 %198 to i8
%200 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %195
store i8 %199, i8* %200
%201 = add nuw nsw i64 %177, 4
%202 = load volatile i32, i32* %2
%203 = trunc i64 %201 to i32
%204 = mul nsw i32 %202, %203
%205 = trunc i32 %204 to i8
%206 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %201
store i8 %205, i8* %206
%207 = add nuw nsw i64 %177, 5
%208 = icmp eq i64 %207, 10240
br i1 %208, label %143, label %176
209: ; preds = %243
%210 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 4
%211 = bitcast i8* %210 to i32*
store i32 -1515870811, i32* %211
br label %212
212: ; preds = %212, %209
%213 = phi i64 [ 0, %209 ], [ %237, %212 ]
%214 = phi <4 x i32> [ zeroinitializer, %209 ], [ %235, %212 ]
%215 = phi <4 x i32> [ zeroinitializer, %209 ], [ %236, %212 ]
%216 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %213
%217 = bitcast i8* %216 to <4 x i8>*
%218 = load <4 x i8>, <4 x i8>* %217
%219 = getelementptr inbounds i8, i8* %216, i64 4
%220 = bitcast i8* %219 to <4 x i8>*
%221 = load <4 x i8>, <4 x i8>* %220
%222 = zext <4 x i8> %218 to <4 x i32>
%223 = zext <4 x i8> %221 to <4 x i32>
%224 = add <4 x i32> %214, %222
%225 = add <4 x i32> %215, %223
%226 = or i64 %213, 8
%227 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %226
%228 = bitcast i8* %227 to <4 x i8>*
%229 = load <4 x i8>, <4 x i8>* %228
%230 = getelementptr inbounds i8, i8* %227, i64 4
%231 = bitcast i8* %230 to <4 x i8>*
%232 = load <4 x i8>, <4 x i8>* %231
%233 = zext <4 x i8> %229 to <4 x i32>
%234 = zext <4 x i8> %232 to <4 x i32>
%235 = add <4 x i32> %224, %233
%236 = add <4 x i32> %225, %234
%237 = add nuw nsw i64 %213, 16
%238 = icmp eq i64 %237, 10240
br i1 %238, label %239, label %212
239: ; preds = %212
%240 = add <4 x i32> %236, %235
%241 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %240)
%242 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %241)
br label %309
243: ; preds = %243, %172
%244 = phi i64 [ 0, %172 ], [ %274, %243 ]
%245 = load volatile i32, i32* %2
%246 = trunc i64 %244 to i32
%247 = mul nsw i32 %245, %246
%248 = trunc i32 %247 to i8
%249 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %244
store i8 %248, i8* %249
%250 = add nuw nsw i64 %244, 1
%251 = load volatile i32, i32* %2
%252 = trunc i64 %250 to i32
%253 = mul nsw i32 %251, %252
%254 = trunc i32 %253 to i8
%255 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %250
store i8 %254, i8* %255
%256 = add nuw nsw i64 %244, 2
%257 = load volatile i32, i32* %2
%258 = trunc i64 %256 to i32
%259 = mul nsw i32 %257, %258
%260 = trunc i32 %259 to i8
%261 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %256
store i8 %260, i8* %261
%262 = add nuw nsw i64 %244, 3
%263 = load volatile i32, i32* %2
%264 = trunc i64 %262 to i32
%265 = mul nsw i32 %263, %264
%266 = trunc i32 %265 to i8
%267 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %262
store i8 %266, i8* %267
%268 = add nuw nsw i64 %244, 4
%269 = load volatile i32, i32* %2
%270 = trunc i64 %268 to i32
%271 = mul nsw i32 %269, %270
%272 = trunc i32 %271 to i8
%273 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %268
store i8 %272, i8* %273
%274 = add nuw nsw i64 %244, 5
%275 = icmp eq i64 %274, 10240
br i1 %275, label %209, label %243
276: ; preds = %309
%277 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 5
br label %278
278: ; preds = %278, %276
%279 = phi i64 [ 0, %276 ], [ %303, %278 ]
%280 = phi <4 x i32> [ zeroinitializer, %276 ], [ %301, %278 ]
%281 = phi <4 x i32> [ zeroinitializer, %276 ], [ %302, %278 ]
%282 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %279
%283 = bitcast i8* %282 to <4 x i8>*
%284 = load <4 x i8>, <4 x i8>* %283
%285 = getelementptr inbounds i8, i8* %282, i64 4
%286 = bitcast i8* %285 to <4 x i8>*
%287 = load <4 x i8>, <4 x i8>* %286
%288 = zext <4 x i8> %284 to <4 x i32>
%289 = zext <4 x i8> %287 to <4 x i32>
%290 = add <4 x i32> %280, %288
%291 = add <4 x i32> %281, %289
%292 = or i64 %279, 8
%293 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %292
%294 = bitcast i8* %293 to <4 x i8>*
%295 = load <4 x i8>, <4 x i8>* %294
%296 = getelementptr inbounds i8, i8* %293, i64 4
%297 = bitcast i8* %296 to <4 x i8>*
%298 = load <4 x i8>, <4 x i8>* %297
%299 = zext <4 x i8> %295 to <4 x i32>
%300 = zext <4 x i8> %298 to <4 x i32>
%301 = add <4 x i32> %290, %299
%302 = add <4 x i32> %291, %300
%303 = add nuw nsw i64 %279, 16
%304 = icmp eq i64 %303, 10240
br i1 %304, label %305, label %278
305: ; preds = %278
%306 = add <4 x i32> %302, %301
%307 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %306)
%308 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %307)
br label %375
309: ; preds = %309, %239
%310 = phi i64 [ 0, %239 ], [ %340, %309 ]
%311 = load volatile i32, i32* %2
%312 = trunc i64 %310 to i32
%313 = mul nsw i32 %311, %312
%314 = trunc i32 %313 to i8
%315 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %310
store i8 %314, i8* %315
%316 = add nuw nsw i64 %310, 1
%317 = load volatile i32, i32* %2
%318 = trunc i64 %316 to i32
%319 = mul nsw i32 %317, %318
%320 = trunc i32 %319 to i8
%321 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %316
store i8 %320, i8* %321
%322 = add nuw nsw i64 %310, 2
%323 = load volatile i32, i32* %2
%324 = trunc i64 %322 to i32
%325 = mul nsw i32 %323, %324
%326 = trunc i32 %325 to i8
%327 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %322
store i8 %326, i8* %327
%328 = add nuw nsw i64 %310, 3
%329 = load volatile i32, i32* %2
%330 = trunc i64 %328 to i32
%331 = mul nsw i32 %329, %330
%332 = trunc i32 %331 to i8
%333 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %328
store i8 %332, i8* %333
%334 = add nuw nsw i64 %310, 4
%335 = load volatile i32, i32* %2
%336 = trunc i64 %334 to i32
%337 = mul nsw i32 %335, %336
%338 = trunc i32 %337 to i8
%339 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %334
store i8 %338, i8* %339
%340 = add nuw nsw i64 %310, 5
%341 = icmp eq i64 %340, 10240
br i1 %341, label %276, label %309
342: ; preds = %375
%343 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 6
br label %344
344: ; preds = %344, %342
%345 = phi i64 [ 0, %342 ], [ %369, %344 ]
%346 = phi <4 x i32> [ zeroinitializer, %342 ], [ %367, %344 ]
%347 = phi <4 x i32> [ zeroinitializer, %342 ], [ %368, %344 ]
%348 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %345
%349 = bitcast i8* %348 to <4 x i8>*
%350 = load <4 x i8>, <4 x i8>* %349
%351 = getelementptr inbounds i8, i8* %348, i64 4
%352 = bitcast i8* %351 to <4 x i8>*
%353 = load <4 x i8>, <4 x i8>* %352
%354 = zext <4 x i8> %350 to <4 x i32>
%355 = zext <4 x i8> %353 to <4 x i32>
%356 = add <4 x i32> %346, %354
%357 = add <4 x i32> %347, %355
%358 = or i64 %345, 8
%359 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %358
%360 = bitcast i8* %359 to <4 x i8>*
%361 = load <4 x i8>, <4 x i8>* %360
%362 = getelementptr inbounds i8, i8* %359, i64 4
%363 = bitcast i8* %362 to <4 x i8>*
%364 = load <4 x i8>, <4 x i8>* %363
%365 = zext <4 x i8> %361 to <4 x i32>
%366 = zext <4 x i8> %364 to <4 x i32>
%367 = add <4 x i32> %356, %365
%368 = add <4 x i32> %357, %366
%369 = add nuw nsw i64 %345, 16
%370 = icmp eq i64 %369, 10240
br i1 %370, label %371, label %344
371: ; preds = %344
%372 = add <4 x i32> %368, %367
%373 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %372)
%374 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %373)
br label %441
375: ; preds = %375, %305
%376 = phi i64 [ 0, %305 ], [ %406, %375 ]
%377 = load volatile i32, i32* %2
%378 = trunc i64 %376 to i32
%379 = mul nsw i32 %377, %378
%380 = trunc i32 %379 to i8
%381 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %376
store i8 %380, i8* %381
%382 = add nuw nsw i64 %376, 1
%383 = load volatile i32, i32* %2
%384 = trunc i64 %382 to i32
%385 = mul nsw i32 %383, %384
%386 = trunc i32 %385 to i8
%387 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %382
store i8 %386, i8* %387
%388 = add nuw nsw i64 %376, 2
%389 = load volatile i32, i32* %2
%390 = trunc i64 %388 to i32
%391 = mul nsw i32 %389, %390
%392 = trunc i32 %391 to i8
%393 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %388
store i8 %392, i8* %393
%394 = add nuw nsw i64 %376, 3
%395 = load volatile i32, i32* %2
%396 = trunc i64 %394 to i32
%397 = mul nsw i32 %395, %396
%398 = trunc i32 %397 to i8
%399 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %394
store i8 %398, i8* %399
%400 = add nuw nsw i64 %376, 4
%401 = load volatile i32, i32* %2
%402 = trunc i64 %400 to i32
%403 = mul nsw i32 %401, %402
%404 = trunc i32 %403 to i8
%405 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %400
store i8 %404, i8* %405
%406 = add nuw nsw i64 %376, 5
%407 = icmp eq i64 %406, 10240
br i1 %407, label %342, label %375
408: ; preds = %441
%409 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 7
br label %410
410: ; preds = %410, %408
%411 = phi i64 [ 0, %408 ], [ %435, %410 ]
%412 = phi <4 x i32> [ zeroinitializer, %408 ], [ %433, %410 ]
%413 = phi <4 x i32> [ zeroinitializer, %408 ], [ %434, %410 ]
%414 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %411
%415 = bitcast i8* %414 to <4 x i8>*
%416 = load <4 x i8>, <4 x i8>* %415
%417 = getelementptr inbounds i8, i8* %414, i64 4
%418 = bitcast i8* %417 to <4 x i8>*
%419 = load <4 x i8>, <4 x i8>* %418
%420 = zext <4 x i8> %416 to <4 x i32>
%421 = zext <4 x i8> %419 to <4 x i32>
%422 = add <4 x i32> %412, %420
%423 = add <4 x i32> %413, %421
%424 = or i64 %411, 8
%425 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %424
%426 = bitcast i8* %425 to <4 x i8>*
%427 = load <4 x i8>, <4 x i8>* %426
%428 = getelementptr inbounds i8, i8* %425, i64 4
%429 = bitcast i8* %428 to <4 x i8>*
%430 = load <4 x i8>, <4 x i8>* %429
%431 = zext <4 x i8> %427 to <4 x i32>
%432 = zext <4 x i8> %430 to <4 x i32>
%433 = add <4 x i32> %422, %431
%434 = add <4 x i32> %423, %432
%435 = add nuw nsw i64 %411, 16
%436 = icmp eq i64 %435, 10240
br i1 %436, label %437, label %410
437: ; preds = %410
%438 = add <4 x i32> %434, %433
%439 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %438)
%440 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %439)
br label %508
441: ; preds = %441, %371
%442 = phi i64 [ 0, %371 ], [ %472, %441 ]
%443 = load volatile i32, i32* %2
%444 = trunc i64 %442 to i32
%445 = mul nsw i32 %443, %444
%446 = trunc i32 %445 to i8
%447 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %442
store i8 %446, i8* %447
%448 = add nuw nsw i64 %442, 1
%449 = load volatile i32, i32* %2
%450 = trunc i64 %448 to i32
%451 = mul nsw i32 %449, %450
%452 = trunc i32 %451 to i8
%453 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %448
store i8 %452, i8* %453
%454 = add nuw nsw i64 %442, 2
%455 = load volatile i32, i32* %2
%456 = trunc i64 %454 to i32
%457 = mul nsw i32 %455, %456
%458 = trunc i32 %457 to i8
%459 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %454
store i8 %458, i8* %459
%460 = add nuw nsw i64 %442, 3
%461 = load volatile i32, i32* %2
%462 = trunc i64 %460 to i32
%463 = mul nsw i32 %461, %462
%464 = trunc i32 %463 to i8
%465 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %460
store i8 %464, i8* %465
%466 = add nuw nsw i64 %442, 4
%467 = load volatile i32, i32* %2
%468 = trunc i64 %466 to i32
%469 = mul nsw i32 %467, %468
%470 = trunc i32 %469 to i8
%471 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %466
store i8 %470, i8* %471
%472 = add nuw nsw i64 %442, 5
%473 = icmp eq i64 %472, 10240
br i1 %473, label %408, label %441
474: ; preds = %508
%475 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 8
%476 = bitcast i8* %475 to i64*
store i64 -6510615555426900571, i64* %476
br label %477
477: ; preds = %477, %474
%478 = phi i64 [ 0, %474 ], [ %502, %477 ]
%479 = phi <4 x i32> [ zeroinitializer, %474 ], [ %500, %477 ]
%480 = phi <4 x i32> [ zeroinitializer, %474 ], [ %501, %477 ]
%481 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %478
%482 = bitcast i8* %481 to <4 x i8>*
%483 = load <4 x i8>, <4 x i8>* %482
%484 = getelementptr inbounds i8, i8* %481, i64 4
%485 = bitcast i8* %484 to <4 x i8>*
%486 = load <4 x i8>, <4 x i8>* %485
%487 = zext <4 x i8> %483 to <4 x i32>
%488 = zext <4 x i8> %486 to <4 x i32>
%489 = add <4 x i32> %479, %487
%490 = add <4 x i32> %480, %488
%491 = or i64 %478, 8
%492 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %491
%493 = bitcast i8* %492 to <4 x i8>*
%494 = load <4 x i8>, <4 x i8>* %493
%495 = getelementptr inbounds i8, i8* %492, i64 4
%496 = bitcast i8* %495 to <4 x i8>*
%497 = load <4 x i8>, <4 x i8>* %496
%498 = zext <4 x i8> %494 to <4 x i32>
%499 = zext <4 x i8> %497 to <4 x i32>
%500 = add <4 x i32> %489, %498
%501 = add <4 x i32> %490, %499
%502 = add nuw nsw i64 %478, 16
%503 = icmp eq i64 %502, 10240
br i1 %503, label %504, label %477
504: ; preds = %477
%505 = add <4 x i32> %501, %500
%506 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %505)
%507 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %506)
br label %574
508: ; preds = %508, %437
%509 = phi i64 [ 0, %437 ], [ %539, %508 ]
%510 = load volatile i32, i32* %2
%511 = trunc i64 %509 to i32
%512 = mul nsw i32 %510, %511
%513 = trunc i32 %512 to i8
%514 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %509
store i8 %513, i8* %514
%515 = add nuw nsw i64 %509, 1
%516 = load volatile i32, i32* %2
%517 = trunc i64 %515 to i32
%518 = mul nsw i32 %516, %517
%519 = trunc i32 %518 to i8
%520 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %515
store i8 %519, i8* %520
%521 = add nuw nsw i64 %509, 2
%522 = load volatile i32, i32* %2
%523 = trunc i64 %521 to i32
%524 = mul nsw i32 %522, %523
%525 = trunc i32 %524 to i8
%526 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %521
store i8 %525, i8* %526
%527 = add nuw nsw i64 %509, 3
%528 = load volatile i32, i32* %2
%529 = trunc i64 %527 to i32
%530 = mul nsw i32 %528, %529
%531 = trunc i32 %530 to i8
%532 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %527
store i8 %531, i8* %532
%533 = add nuw nsw i64 %509, 4
%534 = load volatile i32, i32* %2
%535 = trunc i64 %533 to i32
%536 = mul nsw i32 %534, %535
%537 = trunc i32 %536 to i8
%538 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %533
store i8 %537, i8* %538
%539 = add nuw nsw i64 %509, 5
%540 = icmp eq i64 %539, 10240
br i1 %540, label %474, label %508
541: ; preds = %574
%542 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 9
br label %543
543: ; preds = %543, %541
%544 = phi i64 [ 0, %541 ], [ %568, %543 ]
%545 = phi <4 x i32> [ zeroinitializer, %541 ], [ %566, %543 ]
%546 = phi <4 x i32> [ zeroinitializer, %541 ], [ %567, %543 ]
%547 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %544
%548 = bitcast i8* %547 to <4 x i8>*
%549 = load <4 x i8>, <4 x i8>* %548
%550 = getelementptr inbounds i8, i8* %547, i64 4
%551 = bitcast i8* %550 to <4 x i8>*
%552 = load <4 x i8>, <4 x i8>* %551
%553 = zext <4 x i8> %549 to <4 x i32>
%554 = zext <4 x i8> %552 to <4 x i32>
%555 = add <4 x i32> %545, %553
%556 = add <4 x i32> %546, %554
%557 = or i64 %544, 8
%558 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %557
%559 = bitcast i8* %558 to <4 x i8>*
%560 = load <4 x i8>, <4 x i8>* %559
%561 = getelementptr inbounds i8, i8* %558, i64 4
%562 = bitcast i8* %561 to <4 x i8>*
%563 = load <4 x i8>, <4 x i8>* %562
%564 = zext <4 x i8> %560 to <4 x i32>
%565 = zext <4 x i8> %563 to <4 x i32>
%566 = add <4 x i32> %555, %564
%567 = add <4 x i32> %556, %565
%568 = add nuw nsw i64 %544, 16
%569 = icmp eq i64 %568, 10240
br i1 %569, label %570, label %543
570: ; preds = %543
%571 = add <4 x i32> %567, %566
%572 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %571)
%573 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %572)
br label %640
574: ; preds = %574, %504
%575 = phi i64 [ 0, %504 ], [ %605, %574 ]
%576 = load volatile i32, i32* %2
%577 = trunc i64 %575 to i32
%578 = mul nsw i32 %576, %577
%579 = trunc i32 %578 to i8
%580 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %575
store i8 %579, i8* %580
%581 = add nuw nsw i64 %575, 1
%582 = load volatile i32, i32* %2
%583 = trunc i64 %581 to i32
%584 = mul nsw i32 %582, %583
%585 = trunc i32 %584 to i8
%586 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %581
store i8 %585, i8* %586
%587 = add nuw nsw i64 %575, 2
%588 = load volatile i32, i32* %2
%589 = trunc i64 %587 to i32
%590 = mul nsw i32 %588, %589
%591 = trunc i32 %590 to i8
%592 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %587
store i8 %591, i8* %592
%593 = add nuw nsw i64 %575, 3
%594 = load volatile i32, i32* %2
%595 = trunc i64 %593 to i32
%596 = mul nsw i32 %594, %595
%597 = trunc i32 %596 to i8
%598 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %593
store i8 %597, i8* %598
%599 = add nuw nsw i64 %575, 4
%600 = load volatile i32, i32* %2
%601 = trunc i64 %599 to i32
%602 = mul nsw i32 %600, %601
%603 = trunc i32 %602 to i8
%604 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %599
store i8 %603, i8* %604
%605 = add nuw nsw i64 %575, 5
%606 = icmp eq i64 %605, 10240
br i1 %606, label %541, label %574
607: ; preds = %640
%608 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 10
br label %609
609: ; preds = %609, %607
%610 = phi i64 [ 0, %607 ], [ %634, %609 ]
%611 = phi <4 x i32> [ zeroinitializer, %607 ], [ %632, %609 ]
%612 = phi <4 x i32> [ zeroinitializer, %607 ], [ %633, %609 ]
%613 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %610
%614 = bitcast i8* %613 to <4 x i8>*
%615 = load <4 x i8>, <4 x i8>* %614
%616 = getelementptr inbounds i8, i8* %613, i64 4
%617 = bitcast i8* %616 to <4 x i8>*
%618 = load <4 x i8>, <4 x i8>* %617
%619 = zext <4 x i8> %615 to <4 x i32>
%620 = zext <4 x i8> %618 to <4 x i32>
%621 = add <4 x i32> %611, %619
%622 = add <4 x i32> %612, %620
%623 = or i64 %610, 8
%624 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %623
%625 = bitcast i8* %624 to <4 x i8>*
%626 = load <4 x i8>, <4 x i8>* %625
%627 = getelementptr inbounds i8, i8* %624, i64 4
%628 = bitcast i8* %627 to <4 x i8>*
%629 = load <4 x i8>, <4 x i8>* %628
%630 = zext <4 x i8> %626 to <4 x i32>
%631 = zext <4 x i8> %629 to <4 x i32>
%632 = add <4 x i32> %621, %630
%633 = add <4 x i32> %622, %631
%634 = add nuw nsw i64 %610, 16
%635 = icmp eq i64 %634, 10240
br i1 %635, label %636, label %609
636: ; preds = %609
%637 = add <4 x i32> %633, %632
%638 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %637)
%639 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %638)
br label %706
640: ; preds = %640, %570
%641 = phi i64 [ 0, %570 ], [ %671, %640 ]
%642 = load volatile i32, i32* %2
%643 = trunc i64 %641 to i32
%644 = mul nsw i32 %642, %643
%645 = trunc i32 %644 to i8
%646 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %641
store i8 %645, i8* %646
%647 = add nuw nsw i64 %641, 1
%648 = load volatile i32, i32* %2
%649 = trunc i64 %647 to i32
%650 = mul nsw i32 %648, %649
%651 = trunc i32 %650 to i8
%652 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %647
store i8 %651, i8* %652
%653 = add nuw nsw i64 %641, 2
%654 = load volatile i32, i32* %2
%655 = trunc i64 %653 to i32
%656 = mul nsw i32 %654, %655
%657 = trunc i32 %656 to i8
%658 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %653
store i8 %657, i8* %658
%659 = add nuw nsw i64 %641, 3
%660 = load volatile i32, i32* %2
%661 = trunc i64 %659 to i32
%662 = mul nsw i32 %660, %661
%663 = trunc i32 %662 to i8
%664 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %659
store i8 %663, i8* %664
%665 = add nuw nsw i64 %641, 4
%666 = load volatile i32, i32* %2
%667 = trunc i64 %665 to i32
%668 = mul nsw i32 %666, %667
%669 = trunc i32 %668 to i8
%670 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %665
store i8 %669, i8* %670
%671 = add nuw nsw i64 %641, 5
%672 = icmp eq i64 %671, 10240
br i1 %672, label %607, label %640
673: ; preds = %706
%674 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 16
br label %675
675: ; preds = %675, %673
%676 = phi i64 [ 0, %673 ], [ %700, %675 ]
%677 = phi <4 x i32> [ zeroinitializer, %673 ], [ %698, %675 ]
%678 = phi <4 x i32> [ zeroinitializer, %673 ], [ %699, %675 ]
%679 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %676
%680 = bitcast i8* %679 to <4 x i8>*
%681 = load <4 x i8>, <4 x i8>* %680
%682 = getelementptr inbounds i8, i8* %679, i64 4
%683 = bitcast i8* %682 to <4 x i8>*
%684 = load <4 x i8>, <4 x i8>* %683
%685 = zext <4 x i8> %681 to <4 x i32>
%686 = zext <4 x i8> %684 to <4 x i32>
%687 = add <4 x i32> %677, %685
%688 = add <4 x i32> %678, %686
%689 = or i64 %676, 8
%690 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %689
%691 = bitcast i8* %690 to <4 x i8>*
%692 = load <4 x i8>, <4 x i8>* %691
%693 = getelementptr inbounds i8, i8* %690, i64 4
%694 = bitcast i8* %693 to <4 x i8>*
%695 = load <4 x i8>, <4 x i8>* %694
%696 = zext <4 x i8> %692 to <4 x i32>
%697 = zext <4 x i8> %695 to <4 x i32>
%698 = add <4 x i32> %687, %696
%699 = add <4 x i32> %688, %697
%700 = add nuw nsw i64 %676, 16
%701 = icmp eq i64 %700, 10240
br i1 %701, label %702, label %675
702: ; preds = %675
%703 = add <4 x i32> %699, %698
%704 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %703)
%705 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %704)
br label %772
706: ; preds = %706, %636
%707 = phi i64 [ 0, %636 ], [ %737, %706 ]
%708 = load volatile i32, i32* %2
%709 = trunc i64 %707 to i32
%710 = mul nsw i32 %708, %709
%711 = trunc i32 %710 to i8
%712 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %707
store i8 %711, i8* %712
%713 = add nuw nsw i64 %707, 1
%714 = load volatile i32, i32* %2
%715 = trunc i64 %713 to i32
%716 = mul nsw i32 %714, %715
%717 = trunc i32 %716 to i8
%718 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %713
store i8 %717, i8* %718
%719 = add nuw nsw i64 %707, 2
%720 = load volatile i32, i32* %2
%721 = trunc i64 %719 to i32
%722 = mul nsw i32 %720, %721
%723 = trunc i32 %722 to i8
%724 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %719
store i8 %723, i8* %724
%725 = add nuw nsw i64 %707, 3
%726 = load volatile i32, i32* %2
%727 = trunc i64 %725 to i32
%728 = mul nsw i32 %726, %727
%729 = trunc i32 %728 to i8
%730 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %725
store i8 %729, i8* %730
%731 = add nuw nsw i64 %707, 4
%732 = load volatile i32, i32* %2
%733 = trunc i64 %731 to i32
%734 = mul nsw i32 %732, %733
%735 = trunc i32 %734 to i8
%736 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %731
store i8 %735, i8* %736
%737 = add nuw nsw i64 %707, 5
%738 = icmp eq i64 %737, 10240
br i1 %738, label %673, label %706
739: ; preds = %772
%740 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 15
br label %741
741: ; preds = %741, %739
%742 = phi i64 [ 0, %739 ], [ %766, %741 ]
%743 = phi <4 x i32> [ zeroinitializer, %739 ], [ %764, %741 ]
%744 = phi <4 x i32> [ zeroinitializer, %739 ], [ %765, %741 ]
%745 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %742
%746 = bitcast i8* %745 to <4 x i8>*
%747 = load <4 x i8>, <4 x i8>* %746
%748 = getelementptr inbounds i8, i8* %745, i64 4
%749 = bitcast i8* %748 to <4 x i8>*
%750 = load <4 x i8>, <4 x i8>* %749
%751 = zext <4 x i8> %747 to <4 x i32>
%752 = zext <4 x i8> %750 to <4 x i32>
%753 = add <4 x i32> %743, %751
%754 = add <4 x i32> %744, %752
%755 = or i64 %742, 8
%756 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %755
%757 = bitcast i8* %756 to <4 x i8>*
%758 = load <4 x i8>, <4 x i8>* %757
%759 = getelementptr inbounds i8, i8* %756, i64 4
%760 = bitcast i8* %759 to <4 x i8>*
%761 = load <4 x i8>, <4 x i8>* %760
%762 = zext <4 x i8> %758 to <4 x i32>
%763 = zext <4 x i8> %761 to <4 x i32>
%764 = add <4 x i32> %753, %762
%765 = add <4 x i32> %754, %763
%766 = add nuw nsw i64 %742, 16
%767 = icmp eq i64 %766, 10240
br i1 %767, label %768, label %741
768: ; preds = %741
%769 = add <4 x i32> %765, %764
%770 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %769)
%771 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %770)
br label %838
772: ; preds = %772, %702
%773 = phi i64 [ 0, %702 ], [ %803, %772 ]
%774 = load volatile i32, i32* %2
%775 = trunc i64 %773 to i32
%776 = mul nsw i32 %774, %775
%777 = trunc i32 %776 to i8
%778 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %773
store i8 %777, i8* %778
%779 = add nuw nsw i64 %773, 1
%780 = load volatile i32, i32* %2
%781 = trunc i64 %779 to i32
%782 = mul nsw i32 %780, %781
%783 = trunc i32 %782 to i8
%784 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %779
store i8 %783, i8* %784
%785 = add nuw nsw i64 %773, 2
%786 = load volatile i32, i32* %2
%787 = trunc i64 %785 to i32
%788 = mul nsw i32 %786, %787
%789 = trunc i32 %788 to i8
%790 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %785
store i8 %789, i8* %790
%791 = add nuw nsw i64 %773, 3
%792 = load volatile i32, i32* %2
%793 = trunc i64 %791 to i32
%794 = mul nsw i32 %792, %793
%795 = trunc i32 %794 to i8
%796 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %791
store i8 %795, i8* %796
%797 = add nuw nsw i64 %773, 4
%798 = load volatile i32, i32* %2
%799 = trunc i64 %797 to i32
%800 = mul nsw i32 %798, %799
%801 = trunc i32 %800 to i8
%802 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %797
store i8 %801, i8* %802
%803 = add nuw nsw i64 %773, 5
%804 = icmp eq i64 %803, 10240
br i1 %804, label %739, label %772
805: ; preds = %838
%806 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 13
br label %807
807: ; preds = %807, %805
%808 = phi i64 [ 0, %805 ], [ %832, %807 ]
%809 = phi <4 x i32> [ zeroinitializer, %805 ], [ %830, %807 ]
%810 = phi <4 x i32> [ zeroinitializer, %805 ], [ %831, %807 ]
%811 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %808
%812 = bitcast i8* %811 to <4 x i8>*
%813 = load <4 x i8>, <4 x i8>* %812
%814 = getelementptr inbounds i8, i8* %811, i64 4
%815 = bitcast i8* %814 to <4 x i8>*
%816 = load <4 x i8>, <4 x i8>* %815
%817 = zext <4 x i8> %813 to <4 x i32>
%818 = zext <4 x i8> %816 to <4 x i32>
%819 = add <4 x i32> %809, %817
%820 = add <4 x i32> %810, %818
%821 = or i64 %808, 8
%822 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %821
%823 = bitcast i8* %822 to <4 x i8>*
%824 = load <4 x i8>, <4 x i8>* %823
%825 = getelementptr inbounds i8, i8* %822, i64 4
%826 = bitcast i8* %825 to <4 x i8>*
%827 = load <4 x i8>, <4 x i8>* %826
%828 = zext <4 x i8> %824 to <4 x i32>
%829 = zext <4 x i8> %827 to <4 x i32>
%830 = add <4 x i32> %819, %828
%831 = add <4 x i32> %820, %829
%832 = add nuw nsw i64 %808, 16
%833 = icmp eq i64 %832, 10240
br i1 %833, label %834, label %807
834: ; preds = %807
%835 = add <4 x i32> %831, %830
%836 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %835)
%837 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %836)
br label %903
838: ; preds = %838, %768
%839 = phi i64 [ 0, %768 ], [ %869, %838 ]
%840 = load volatile i32, i32* %2
%841 = trunc i64 %839 to i32
%842 = mul nsw i32 %840, %841
%843 = trunc i32 %842 to i8
%844 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %839
store i8 %843, i8* %844
%845 = add nuw nsw i64 %839, 1
%846 = load volatile i32, i32* %2
%847 = trunc i64 %845 to i32
%848 = mul nsw i32 %846, %847
%849 = trunc i32 %848 to i8
%850 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %845
store i8 %849, i8* %850
%851 = add nuw nsw i64 %839, 2
%852 = load volatile i32, i32* %2
%853 = trunc i64 %851 to i32
%854 = mul nsw i32 %852, %853
%855 = trunc i32 %854 to i8
%856 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %851
store i8 %855, i8* %856
%857 = add nuw nsw i64 %839, 3
%858 = load volatile i32, i32* %2
%859 = trunc i64 %857 to i32
%860 = mul nsw i32 %858, %859
%861 = trunc i32 %860 to i8
%862 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %857
store i8 %861, i8* %862
%863 = add nuw nsw i64 %839, 4
%864 = load volatile i32, i32* %2
%865 = trunc i64 %863 to i32
%866 = mul nsw i32 %864, %865
%867 = trunc i32 %866 to i8
%868 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %863
store i8 %867, i8* %868
%869 = add nuw nsw i64 %839, 5
%870 = icmp eq i64 %869, 10240
br i1 %870, label %805, label %838
871: ; preds = %903
br label %872
872: ; preds = %872, %871
%873 = phi i64 [ 0, %871 ], [ %897, %872 ]
%874 = phi <4 x i32> [ zeroinitializer, %871 ], [ %895, %872 ]
%875 = phi <4 x i32> [ zeroinitializer, %871 ], [ %896, %872 ]
%876 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %873
%877 = bitcast i8* %876 to <4 x i8>*
%878 = load <4 x i8>, <4 x i8>* %877
%879 = getelementptr inbounds i8, i8* %876, i64 4
%880 = bitcast i8* %879 to <4 x i8>*
%881 = load <4 x i8>, <4 x i8>* %880
%882 = zext <4 x i8> %878 to <4 x i32>
%883 = zext <4 x i8> %881 to <4 x i32>
%884 = add <4 x i32> %874, %882
%885 = add <4 x i32> %875, %883
%886 = or i64 %873, 8
%887 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %886
%888 = bitcast i8* %887 to <4 x i8>*
%889 = load <4 x i8>, <4 x i8>* %888
%890 = getelementptr inbounds i8, i8* %887, i64 4
%891 = bitcast i8* %890 to <4 x i8>*
%892 = load <4 x i8>, <4 x i8>* %891
%893 = zext <4 x i8> %889 to <4 x i32>
%894 = zext <4 x i8> %892 to <4 x i32>
%895 = add <4 x i32> %884, %893
%896 = add <4 x i32> %885, %894
%897 = add nuw nsw i64 %873, 16
%898 = icmp eq i64 %897, 10240
br i1 %898, label %899, label %872
899: ; preds = %872
%900 = add <4 x i32> %896, %895
%901 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %900)
%902 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %901)
br label %968
903: ; preds = %903, %834
%904 = phi i64 [ 0, %834 ], [ %934, %903 ]
%905 = load volatile i32, i32* %2
%906 = trunc i64 %904 to i32
%907 = mul nsw i32 %905, %906
%908 = trunc i32 %907 to i8
%909 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %904
store i8 %908, i8* %909
%910 = add nuw nsw i64 %904, 1
%911 = load volatile i32, i32* %2
%912 = trunc i64 %910 to i32
%913 = mul nsw i32 %911, %912
%914 = trunc i32 %913 to i8
%915 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %910
store i8 %914, i8* %915
%916 = add nuw nsw i64 %904, 2
%917 = load volatile i32, i32* %2
%918 = trunc i64 %916 to i32
%919 = mul nsw i32 %917, %918
%920 = trunc i32 %919 to i8
%921 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %916
store i8 %920, i8* %921
%922 = add nuw nsw i64 %904, 3
%923 = load volatile i32, i32* %2
%924 = trunc i64 %922 to i32
%925 = mul nsw i32 %923, %924
%926 = trunc i32 %925 to i8
%927 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %922
store i8 %926, i8* %927
%928 = add nuw nsw i64 %904, 4
%929 = load volatile i32, i32* %2
%930 = trunc i64 %928 to i32
%931 = mul nsw i32 %929, %930
%932 = trunc i32 %931 to i8
%933 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %928
store i8 %932, i8* %933
%934 = add nuw nsw i64 %904, 5
%935 = icmp eq i64 %934, 10240
br i1 %935, label %871, label %903
936: ; preds = %968
br label %937
937: ; preds = %937, %936
%938 = phi i64 [ 0, %936 ], [ %962, %937 ]
%939 = phi <4 x i32> [ zeroinitializer, %936 ], [ %960, %937 ]
%940 = phi <4 x i32> [ zeroinitializer, %936 ], [ %961, %937 ]
%941 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %938
%942 = bitcast i8* %941 to <4 x i8>*
%943 = load <4 x i8>, <4 x i8>* %942
%944 = getelementptr inbounds i8, i8* %941, i64 4
%945 = bitcast i8* %944 to <4 x i8>*
%946 = load <4 x i8>, <4 x i8>* %945
%947 = zext <4 x i8> %943 to <4 x i32>
%948 = zext <4 x i8> %946 to <4 x i32>
%949 = add <4 x i32> %939, %947
%950 = add <4 x i32> %940, %948
%951 = or i64 %938, 8
%952 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %951
%953 = bitcast i8* %952 to <4 x i8>*
%954 = load <4 x i8>, <4 x i8>* %953
%955 = getelementptr inbounds i8, i8* %952, i64 4
%956 = bitcast i8* %955 to <4 x i8>*
%957 = load <4 x i8>, <4 x i8>* %956
%958 = zext <4 x i8> %954 to <4 x i32>
%959 = zext <4 x i8> %957 to <4 x i32>
%960 = add <4 x i32> %949, %958
%961 = add <4 x i32> %950, %959
%962 = add nuw nsw i64 %938, 16
%963 = icmp eq i64 %962, 10240
br i1 %963, label %964, label %937
964: ; preds = %937
%965 = add <4 x i32> %961, %960
%966 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %965)
%967 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %966)
br label %1033
968: ; preds = %968, %899
%969 = phi i64 [ 0, %899 ], [ %999, %968 ]
%970 = load volatile i32, i32* %2
%971 = trunc i64 %969 to i32
%972 = mul nsw i32 %970, %971
%973 = trunc i32 %972 to i8
%974 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %969
store i8 %973, i8* %974
%975 = add nuw nsw i64 %969, 1
%976 = load volatile i32, i32* %2
%977 = trunc i64 %975 to i32
%978 = mul nsw i32 %976, %977
%979 = trunc i32 %978 to i8
%980 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %975
store i8 %979, i8* %980
%981 = add nuw nsw i64 %969, 2
%982 = load volatile i32, i32* %2
%983 = trunc i64 %981 to i32
%984 = mul nsw i32 %982, %983
%985 = trunc i32 %984 to i8
%986 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %981
store i8 %985, i8* %986
%987 = add nuw nsw i64 %969, 3
%988 = load volatile i32, i32* %2
%989 = trunc i64 %987 to i32
%990 = mul nsw i32 %988, %989
%991 = trunc i32 %990 to i8
%992 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %987
store i8 %991, i8* %992
%993 = add nuw nsw i64 %969, 4
%994 = load volatile i32, i32* %2
%995 = trunc i64 %993 to i32
%996 = mul nsw i32 %994, %995
%997 = trunc i32 %996 to i8
%998 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %993
store i8 %997, i8* %998
%999 = add nuw nsw i64 %969, 5
%1000 = icmp eq i64 %999, 10240
br i1 %1000, label %936, label %968
1001: ; preds = %1033
br label %1002
1002: ; preds = %1002, %1001
%1003 = phi i64 [ 0, %1001 ], [ %1027, %1002 ]
%1004 = phi <4 x i32> [ zeroinitializer, %1001 ], [ %1025, %1002 ]
%1005 = phi <4 x i32> [ zeroinitializer, %1001 ], [ %1026, %1002 ]
%1006 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1003
%1007 = bitcast i8* %1006 to <4 x i8>*
%1008 = load <4 x i8>, <4 x i8>* %1007
%1009 = getelementptr inbounds i8, i8* %1006, i64 4
%1010 = bitcast i8* %1009 to <4 x i8>*
%1011 = load <4 x i8>, <4 x i8>* %1010
%1012 = zext <4 x i8> %1008 to <4 x i32>
%1013 = zext <4 x i8> %1011 to <4 x i32>
%1014 = add <4 x i32> %1004, %1012
%1015 = add <4 x i32> %1005, %1013
%1016 = or i64 %1003, 8
%1017 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1016
%1018 = bitcast i8* %1017 to <4 x i8>*
%1019 = load <4 x i8>, <4 x i8>* %1018
%1020 = getelementptr inbounds i8, i8* %1017, i64 4
%1021 = bitcast i8* %1020 to <4 x i8>*
%1022 = load <4 x i8>, <4 x i8>* %1021
%1023 = zext <4 x i8> %1019 to <4 x i32>
%1024 = zext <4 x i8> %1022 to <4 x i32>
%1025 = add <4 x i32> %1014, %1023
%1026 = add <4 x i32> %1015, %1024
%1027 = add nuw nsw i64 %1003, 16
%1028 = icmp eq i64 %1027, 10240
br i1 %1028, label %1029, label %1002
1029: ; preds = %1002
%1030 = add <4 x i32> %1026, %1025
%1031 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1030)
%1032 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %1031)
br label %1098
1033: ; preds = %1033, %964
%1034 = phi i64 [ 0, %964 ], [ %1064, %1033 ]
%1035 = load volatile i32, i32* %2
%1036 = trunc i64 %1034 to i32
%1037 = mul nsw i32 %1035, %1036
%1038 = trunc i32 %1037 to i8
%1039 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1034
store i8 %1038, i8* %1039
%1040 = add nuw nsw i64 %1034, 1
%1041 = load volatile i32, i32* %2
%1042 = trunc i64 %1040 to i32
%1043 = mul nsw i32 %1041, %1042
%1044 = trunc i32 %1043 to i8
%1045 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1040
store i8 %1044, i8* %1045
%1046 = add nuw nsw i64 %1034, 2
%1047 = load volatile i32, i32* %2
%1048 = trunc i64 %1046 to i32
%1049 = mul nsw i32 %1047, %1048
%1050 = trunc i32 %1049 to i8
%1051 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1046
store i8 %1050, i8* %1051
%1052 = add nuw nsw i64 %1034, 3
%1053 = load volatile i32, i32* %2
%1054 = trunc i64 %1052 to i32
%1055 = mul nsw i32 %1053, %1054
%1056 = trunc i32 %1055 to i8
%1057 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1052
store i8 %1056, i8* %1057
%1058 = add nuw nsw i64 %1034, 4
%1059 = load volatile i32, i32* %2
%1060 = trunc i64 %1058 to i32
%1061 = mul nsw i32 %1059, %1060
%1062 = trunc i32 %1061 to i8
%1063 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1058
store i8 %1062, i8* %1063
%1064 = add nuw nsw i64 %1034, 5
%1065 = icmp eq i64 %1064, 10240
br i1 %1065, label %1001, label %1033
1066: ; preds = %1098
br label %1067
1067: ; preds = %1067, %1066
%1068 = phi i64 [ 0, %1066 ], [ %1092, %1067 ]
%1069 = phi <4 x i32> [ zeroinitializer, %1066 ], [ %1090, %1067 ]
%1070 = phi <4 x i32> [ zeroinitializer, %1066 ], [ %1091, %1067 ]
%1071 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1068
%1072 = bitcast i8* %1071 to <4 x i8>*
%1073 = load <4 x i8>, <4 x i8>* %1072
%1074 = getelementptr inbounds i8, i8* %1071, i64 4
%1075 = bitcast i8* %1074 to <4 x i8>*
%1076 = load <4 x i8>, <4 x i8>* %1075
%1077 = zext <4 x i8> %1073 to <4 x i32>
%1078 = zext <4 x i8> %1076 to <4 x i32>
%1079 = add <4 x i32> %1069, %1077
%1080 = add <4 x i32> %1070, %1078
%1081 = or i64 %1068, 8
%1082 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1081
%1083 = bitcast i8* %1082 to <4 x i8>*
%1084 = load <4 x i8>, <4 x i8>* %1083
%1085 = getelementptr inbounds i8, i8* %1082, i64 4
%1086 = bitcast i8* %1085 to <4 x i8>*
%1087 = load <4 x i8>, <4 x i8>* %1086
%1088 = zext <4 x i8> %1084 to <4 x i32>
%1089 = zext <4 x i8> %1087 to <4 x i32>
%1090 = add <4 x i32> %1079, %1088
%1091 = add <4 x i32> %1080, %1089
%1092 = add nuw nsw i64 %1068, 16
%1093 = icmp eq i64 %1092, 10240
br i1 %1093, label %1094, label %1067
1094: ; preds = %1067
%1095 = add <4 x i32> %1091, %1090
%1096 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1095)
%1097 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %1096)
br label %1131
1098: ; preds = %1098, %1029
%1099 = phi i64 [ 0, %1029 ], [ %1129, %1098 ]
%1100 = load volatile i32, i32* %2
%1101 = trunc i64 %1099 to i32
%1102 = mul nsw i32 %1100, %1101
%1103 = trunc i32 %1102 to i8
%1104 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1099
store i8 %1103, i8* %1104
%1105 = add nuw nsw i64 %1099, 1
%1106 = load volatile i32, i32* %2
%1107 = trunc i64 %1105 to i32
%1108 = mul nsw i32 %1106, %1107
%1109 = trunc i32 %1108 to i8
%1110 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1105
store i8 %1109, i8* %1110
%1111 = add nuw nsw i64 %1099, 2
%1112 = load volatile i32, i32* %2
%1113 = trunc i64 %1111 to i32
%1114 = mul nsw i32 %1112, %1113
%1115 = trunc i32 %1114 to i8
%1116 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1111
store i8 %1115, i8* %1116
%1117 = add nuw nsw i64 %1099, 3
%1118 = load volatile i32, i32* %2
%1119 = trunc i64 %1117 to i32
%1120 = mul nsw i32 %1118, %1119
%1121 = trunc i32 %1120 to i8
%1122 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1117
store i8 %1121, i8* %1122
%1123 = add nuw nsw i64 %1099, 4
%1124 = load volatile i32, i32* %2
%1125 = trunc i64 %1123 to i32
%1126 = mul nsw i32 %1124, %1125
%1127 = trunc i32 %1126 to i8
%1128 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1123
store i8 %1127, i8* %1128
%1129 = add nuw nsw i64 %1099, 5
%1130 = icmp eq i64 %1129, 10240
br i1 %1130, label %1066, label %1098
1131: ; preds = %1094, %1169
%1132 = phi i64 [ 10, %1094 ], [ %1173, %1169 ]
br label %1175
1133: ; preds = %1169
%1134 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.4, i64 0, i64 0))
%1135 = bitcast [10240 x i16]* %3 to i8*
%1136 = bitcast i32* %4 to i8*
store volatile i32 123, i32* %4
br label %1242
1137: ; preds = %1175
%1138 = trunc i64 %1132 to i32
%1139 = urem i32 %1138, 17
%1140 = zext i32 %1139 to i64
%1141 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1140
br label %1142
1142: ; preds = %1142, %1137
%1143 = phi i64 [ 0, %1137 ], [ %1167, %1142 ]
%1144 = phi <4 x i32> [ zeroinitializer, %1137 ], [ %1165, %1142 ]
%1145 = phi <4 x i32> [ zeroinitializer, %1137 ], [ %1166, %1142 ]
%1146 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1143
%1147 = bitcast i8* %1146 to <4 x i8>*
%1148 = load <4 x i8>, <4 x i8>* %1147
%1149 = getelementptr inbounds i8, i8* %1146, i64 4
%1150 = bitcast i8* %1149 to <4 x i8>*
%1151 = load <4 x i8>, <4 x i8>* %1150
%1152 = zext <4 x i8> %1148 to <4 x i32>
%1153 = zext <4 x i8> %1151 to <4 x i32>
%1154 = add <4 x i32> %1144, %1152
%1155 = add <4 x i32> %1145, %1153
%1156 = or i64 %1143, 8
%1157 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1156
%1158 = bitcast i8* %1157 to <4 x i8>*
%1159 = load <4 x i8>, <4 x i8>* %1158
%1160 = getelementptr inbounds i8, i8* %1157, i64 4
%1161 = bitcast i8* %1160 to <4 x i8>*
%1162 = load <4 x i8>, <4 x i8>* %1161
%1163 = zext <4 x i8> %1159 to <4 x i32>
%1164 = zext <4 x i8> %1162 to <4 x i32>
%1165 = add <4 x i32> %1154, %1163
%1166 = add <4 x i32> %1155, %1164
%1167 = add nuw nsw i64 %1143, 16
%1168 = icmp eq i64 %1167, 10240
br i1 %1168, label %1169, label %1142
1169: ; preds = %1142
%1170 = add <4 x i32> %1166, %1165
%1171 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1170)
%1172 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %1138, i32 %1171)
%1173 = add nuw nsw i64 %1132, 10
%1174 = icmp ult i64 %1132, 90
br i1 %1174, label %1131, label %1133
1175: ; preds = %1175, %1131
%1176 = phi i64 [ 0, %1131 ], [ %1206, %1175 ]
%1177 = load volatile i32, i32* %2
%1178 = trunc i64 %1176 to i32
%1179 = mul nsw i32 %1177, %1178
%1180 = trunc i32 %1179 to i8
%1181 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1176
store i8 %1180, i8* %1181
%1182 = add nuw nsw i64 %1176, 1
%1183 = load volatile i32, i32* %2
%1184 = trunc i64 %1182 to i32
%1185 = mul nsw i32 %1183, %1184
%1186 = trunc i32 %1185 to i8
%1187 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1182
store i8 %1186, i8* %1187
%1188 = add nuw nsw i64 %1176, 2
%1189 = load volatile i32, i32* %2
%1190 = trunc i64 %1188 to i32
%1191 = mul nsw i32 %1189, %1190
%1192 = trunc i32 %1191 to i8
%1193 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1188
store i8 %1192, i8* %1193
%1194 = add nuw nsw i64 %1176, 3
%1195 = load volatile i32, i32* %2
%1196 = trunc i64 %1194 to i32
%1197 = mul nsw i32 %1195, %1196
%1198 = trunc i32 %1197 to i8
%1199 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1194
store i8 %1198, i8* %1199
%1200 = add nuw nsw i64 %1176, 4
%1201 = load volatile i32, i32* %2
%1202 = trunc i64 %1200 to i32
%1203 = mul nsw i32 %1201, %1202
%1204 = trunc i32 %1203 to i8
%1205 = getelementptr inbounds [10240 x i8], [10240 x i8]* %1, i64 0, i64 %1200
store i8 %1204, i8* %1205
%1206 = add nuw nsw i64 %1176, 5
%1207 = icmp eq i64 %1206, 10240
br i1 %1207, label %1137, label %1175
1208: ; preds = %1242
%1209 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 1
%1210 = bitcast i16* %1209 to i8*
store i8 -91, i8* %1210
br label %1211
1211: ; preds = %1211, %1208
%1212 = phi i64 [ 0, %1208 ], [ %1236, %1211 ]
%1213 = phi <4 x i32> [ zeroinitializer, %1208 ], [ %1234, %1211 ]
%1214 = phi <4 x i32> [ zeroinitializer, %1208 ], [ %1235, %1211 ]
%1215 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1212
%1216 = bitcast i16* %1215 to <4 x i16>*
%1217 = load <4 x i16>, <4 x i16>* %1216
%1218 = getelementptr inbounds i16, i16* %1215, i64 4
%1219 = bitcast i16* %1218 to <4 x i16>*
%1220 = load <4 x i16>, <4 x i16>* %1219
%1221 = zext <4 x i16> %1217 to <4 x i32>
%1222 = zext <4 x i16> %1220 to <4 x i32>
%1223 = add <4 x i32> %1213, %1221
%1224 = add <4 x i32> %1214, %1222
%1225 = or i64 %1212, 8
%1226 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1225
%1227 = bitcast i16* %1226 to <4 x i16>*
%1228 = load <4 x i16>, <4 x i16>* %1227
%1229 = getelementptr inbounds i16, i16* %1226, i64 4
%1230 = bitcast i16* %1229 to <4 x i16>*
%1231 = load <4 x i16>, <4 x i16>* %1230
%1232 = zext <4 x i16> %1228 to <4 x i32>
%1233 = zext <4 x i16> %1231 to <4 x i32>
%1234 = add <4 x i32> %1223, %1232
%1235 = add <4 x i32> %1224, %1233
%1236 = add nuw nsw i64 %1212, 16
%1237 = icmp eq i64 %1236, 10240
br i1 %1237, label %1238, label %1211
1238: ; preds = %1211
%1239 = add <4 x i32> %1235, %1234
%1240 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1239)
%1241 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %1240)
br label %1308
1242: ; preds = %1242, %1133
%1243 = phi i64 [ 0, %1133 ], [ %1273, %1242 ]
%1244 = load volatile i32, i32* %4
%1245 = trunc i64 %1243 to i32
%1246 = mul nsw i32 %1244, %1245
%1247 = trunc i32 %1246 to i16
%1248 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1243
store i16 %1247, i16* %1248
%1249 = add nuw nsw i64 %1243, 1
%1250 = load volatile i32, i32* %4
%1251 = trunc i64 %1249 to i32
%1252 = mul nsw i32 %1250, %1251
%1253 = trunc i32 %1252 to i16
%1254 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1249
store i16 %1253, i16* %1254
%1255 = add nuw nsw i64 %1243, 2
%1256 = load volatile i32, i32* %4
%1257 = trunc i64 %1255 to i32
%1258 = mul nsw i32 %1256, %1257
%1259 = trunc i32 %1258 to i16
%1260 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1255
store i16 %1259, i16* %1260
%1261 = add nuw nsw i64 %1243, 3
%1262 = load volatile i32, i32* %4
%1263 = trunc i64 %1261 to i32
%1264 = mul nsw i32 %1262, %1263
%1265 = trunc i32 %1264 to i16
%1266 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1261
store i16 %1265, i16* %1266
%1267 = add nuw nsw i64 %1243, 4
%1268 = load volatile i32, i32* %4
%1269 = trunc i64 %1267 to i32
%1270 = mul nsw i32 %1268, %1269
%1271 = trunc i32 %1270 to i16
%1272 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1267
store i16 %1271, i16* %1272
%1273 = add nuw nsw i64 %1243, 5
%1274 = icmp eq i64 %1273, 10240
br i1 %1274, label %1208, label %1242
1275: ; preds = %1308
%1276 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 2
store i16 -23131, i16* %1276
br label %1277
1277: ; preds = %1277, %1275
%1278 = phi i64 [ 0, %1275 ], [ %1302, %1277 ]
%1279 = phi <4 x i32> [ zeroinitializer, %1275 ], [ %1300, %1277 ]
%1280 = phi <4 x i32> [ zeroinitializer, %1275 ], [ %1301, %1277 ]
%1281 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1278
%1282 = bitcast i16* %1281 to <4 x i16>*
%1283 = load <4 x i16>, <4 x i16>* %1282
%1284 = getelementptr inbounds i16, i16* %1281, i64 4
%1285 = bitcast i16* %1284 to <4 x i16>*
%1286 = load <4 x i16>, <4 x i16>* %1285
%1287 = zext <4 x i16> %1283 to <4 x i32>
%1288 = zext <4 x i16> %1286 to <4 x i32>
%1289 = add <4 x i32> %1279, %1287
%1290 = add <4 x i32> %1280, %1288
%1291 = or i64 %1278, 8
%1292 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1291
%1293 = bitcast i16* %1292 to <4 x i16>*
%1294 = load <4 x i16>, <4 x i16>* %1293
%1295 = getelementptr inbounds i16, i16* %1292, i64 4
%1296 = bitcast i16* %1295 to <4 x i16>*
%1297 = load <4 x i16>, <4 x i16>* %1296
%1298 = zext <4 x i16> %1294 to <4 x i32>
%1299 = zext <4 x i16> %1297 to <4 x i32>
%1300 = add <4 x i32> %1289, %1298
%1301 = add <4 x i32> %1290, %1299
%1302 = add nuw nsw i64 %1278, 16
%1303 = icmp eq i64 %1302, 10240
br i1 %1303, label %1304, label %1277
1304: ; preds = %1277
%1305 = add <4 x i32> %1301, %1300
%1306 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1305)
%1307 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %1306)
br label %1375
1308: ; preds = %1308, %1238
%1309 = phi i64 [ 0, %1238 ], [ %1339, %1308 ]
%1310 = load volatile i32, i32* %4
%1311 = trunc i64 %1309 to i32
%1312 = mul nsw i32 %1310, %1311
%1313 = trunc i32 %1312 to i16
%1314 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1309
store i16 %1313, i16* %1314
%1315 = add nuw nsw i64 %1309, 1
%1316 = load volatile i32, i32* %4
%1317 = trunc i64 %1315 to i32
%1318 = mul nsw i32 %1316, %1317
%1319 = trunc i32 %1318 to i16
%1320 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1315
store i16 %1319, i16* %1320
%1321 = add nuw nsw i64 %1309, 2
%1322 = load volatile i32, i32* %4
%1323 = trunc i64 %1321 to i32
%1324 = mul nsw i32 %1322, %1323
%1325 = trunc i32 %1324 to i16
%1326 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1321
store i16 %1325, i16* %1326
%1327 = add nuw nsw i64 %1309, 3
%1328 = load volatile i32, i32* %4
%1329 = trunc i64 %1327 to i32
%1330 = mul nsw i32 %1328, %1329
%1331 = trunc i32 %1330 to i16
%1332 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1327
store i16 %1331, i16* %1332
%1333 = add nuw nsw i64 %1309, 4
%1334 = load volatile i32, i32* %4
%1335 = trunc i64 %1333 to i32
%1336 = mul nsw i32 %1334, %1335
%1337 = trunc i32 %1336 to i16
%1338 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1333
store i16 %1337, i16* %1338
%1339 = add nuw nsw i64 %1309, 5
%1340 = icmp eq i64 %1339, 10240
br i1 %1340, label %1275, label %1308
1341: ; preds = %1375
%1342 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 3
%1343 = bitcast i16* %1342 to i8*
br label %1344
1344: ; preds = %1344, %1341
%1345 = phi i64 [ 0, %1341 ], [ %1369, %1344 ]
%1346 = phi <4 x i32> [ zeroinitializer, %1341 ], [ %1367, %1344 ]
%1347 = phi <4 x i32> [ zeroinitializer, %1341 ], [ %1368, %1344 ]
%1348 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1345
%1349 = bitcast i16* %1348 to <4 x i16>*
%1350 = load <4 x i16>, <4 x i16>* %1349
%1351 = getelementptr inbounds i16, i16* %1348, i64 4
%1352 = bitcast i16* %1351 to <4 x i16>*
%1353 = load <4 x i16>, <4 x i16>* %1352
%1354 = zext <4 x i16> %1350 to <4 x i32>
%1355 = zext <4 x i16> %1353 to <4 x i32>
%1356 = add <4 x i32> %1346, %1354
%1357 = add <4 x i32> %1347, %1355
%1358 = or i64 %1345, 8
%1359 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1358
%1360 = bitcast i16* %1359 to <4 x i16>*
%1361 = load <4 x i16>, <4 x i16>* %1360
%1362 = getelementptr inbounds i16, i16* %1359, i64 4
%1363 = bitcast i16* %1362 to <4 x i16>*
%1364 = load <4 x i16>, <4 x i16>* %1363
%1365 = zext <4 x i16> %1361 to <4 x i32>
%1366 = zext <4 x i16> %1364 to <4 x i32>
%1367 = add <4 x i32> %1356, %1365
%1368 = add <4 x i32> %1357, %1366
%1369 = add nuw nsw i64 %1345, 16
%1370 = icmp eq i64 %1369, 10240
br i1 %1370, label %1371, label %1344
1371: ; preds = %1344
%1372 = add <4 x i32> %1368, %1367
%1373 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1372)
%1374 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %1373)
br label %1443
1375: ; preds = %1375, %1304
%1376 = phi i64 [ 0, %1304 ], [ %1406, %1375 ]
%1377 = load volatile i32, i32* %4
%1378 = trunc i64 %1376 to i32
%1379 = mul nsw i32 %1377, %1378
%1380 = trunc i32 %1379 to i16
%1381 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1376
store i16 %1380, i16* %1381
%1382 = add nuw nsw i64 %1376, 1
%1383 = load volatile i32, i32* %4
%1384 = trunc i64 %1382 to i32
%1385 = mul nsw i32 %1383, %1384
%1386 = trunc i32 %1385 to i16
%1387 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1382
store i16 %1386, i16* %1387
%1388 = add nuw nsw i64 %1376, 2
%1389 = load volatile i32, i32* %4
%1390 = trunc i64 %1388 to i32
%1391 = mul nsw i32 %1389, %1390
%1392 = trunc i32 %1391 to i16
%1393 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1388
store i16 %1392, i16* %1393
%1394 = add nuw nsw i64 %1376, 3
%1395 = load volatile i32, i32* %4
%1396 = trunc i64 %1394 to i32
%1397 = mul nsw i32 %1395, %1396
%1398 = trunc i32 %1397 to i16
%1399 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1394
store i16 %1398, i16* %1399
%1400 = add nuw nsw i64 %1376, 4
%1401 = load volatile i32, i32* %4
%1402 = trunc i64 %1400 to i32
%1403 = mul nsw i32 %1401, %1402
%1404 = trunc i32 %1403 to i16
%1405 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1400
store i16 %1404, i16* %1405
%1406 = add nuw nsw i64 %1376, 5
%1407 = icmp eq i64 %1406, 10240
br i1 %1407, label %1341, label %1375
1408: ; preds = %1443
%1409 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 4
%1410 = bitcast i16* %1409 to i32*
store i32 -1515870811, i32* %1410
br label %1411
1411: ; preds = %1411, %1408
%1412 = phi i64 [ 0, %1408 ], [ %1436, %1411 ]
%1413 = phi <4 x i32> [ zeroinitializer, %1408 ], [ %1434, %1411 ]
%1414 = phi <4 x i32> [ zeroinitializer, %1408 ], [ %1435, %1411 ]
%1415 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1412
%1416 = bitcast i16* %1415 to <4 x i16>*
%1417 = load <4 x i16>, <4 x i16>* %1416
%1418 = getelementptr inbounds i16, i16* %1415, i64 4
%1419 = bitcast i16* %1418 to <4 x i16>*
%1420 = load <4 x i16>, <4 x i16>* %1419
%1421 = zext <4 x i16> %1417 to <4 x i32>
%1422 = zext <4 x i16> %1420 to <4 x i32>
%1423 = add <4 x i32> %1413, %1421
%1424 = add <4 x i32> %1414, %1422
%1425 = or i64 %1412, 8
%1426 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1425
%1427 = bitcast i16* %1426 to <4 x i16>*
%1428 = load <4 x i16>, <4 x i16>* %1427
%1429 = getelementptr inbounds i16, i16* %1426, i64 4
%1430 = bitcast i16* %1429 to <4 x i16>*
%1431 = load <4 x i16>, <4 x i16>* %1430
%1432 = zext <4 x i16> %1428 to <4 x i32>
%1433 = zext <4 x i16> %1431 to <4 x i32>
%1434 = add <4 x i32> %1423, %1432
%1435 = add <4 x i32> %1424, %1433
%1436 = add nuw nsw i64 %1412, 16
%1437 = icmp eq i64 %1436, 10240
br i1 %1437, label %1438, label %1411
1438: ; preds = %1411
%1439 = add <4 x i32> %1435, %1434
%1440 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1439)
%1441 = bitcast i16* %1276 to i8*
%1442 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %1440)
br label %1510
1443: ; preds = %1443, %1371
%1444 = phi i64 [ 0, %1371 ], [ %1474, %1443 ]
%1445 = load volatile i32, i32* %4
%1446 = trunc i64 %1444 to i32
%1447 = mul nsw i32 %1445, %1446
%1448 = trunc i32 %1447 to i16
%1449 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1444
store i16 %1448, i16* %1449
%1450 = add nuw nsw i64 %1444, 1
%1451 = load volatile i32, i32* %4
%1452 = trunc i64 %1450 to i32
%1453 = mul nsw i32 %1451, %1452
%1454 = trunc i32 %1453 to i16
%1455 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1450
store i16 %1454, i16* %1455
%1456 = add nuw nsw i64 %1444, 2
%1457 = load volatile i32, i32* %4
%1458 = trunc i64 %1456 to i32
%1459 = mul nsw i32 %1457, %1458
%1460 = trunc i32 %1459 to i16
%1461 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1456
store i16 %1460, i16* %1461
%1462 = add nuw nsw i64 %1444, 3
%1463 = load volatile i32, i32* %4
%1464 = trunc i64 %1462 to i32
%1465 = mul nsw i32 %1463, %1464
%1466 = trunc i32 %1465 to i16
%1467 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1462
store i16 %1466, i16* %1467
%1468 = add nuw nsw i64 %1444, 4
%1469 = load volatile i32, i32* %4
%1470 = trunc i64 %1468 to i32
%1471 = mul nsw i32 %1469, %1470
%1472 = trunc i32 %1471 to i16
%1473 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1468
store i16 %1472, i16* %1473
%1474 = add nuw nsw i64 %1444, 5
%1475 = icmp eq i64 %1474, 10240
br i1 %1475, label %1408, label %1443
1476: ; preds = %1510
%1477 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 5
%1478 = bitcast i16* %1477 to i8*
br label %1479
1479: ; preds = %1479, %1476
%1480 = phi i64 [ 0, %1476 ], [ %1504, %1479 ]
%1481 = phi <4 x i32> [ zeroinitializer, %1476 ], [ %1502, %1479 ]
%1482 = phi <4 x i32> [ zeroinitializer, %1476 ], [ %1503, %1479 ]
%1483 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1480
%1484 = bitcast i16* %1483 to <4 x i16>*
%1485 = load <4 x i16>, <4 x i16>* %1484
%1486 = getelementptr inbounds i16, i16* %1483, i64 4
%1487 = bitcast i16* %1486 to <4 x i16>*
%1488 = load <4 x i16>, <4 x i16>* %1487
%1489 = zext <4 x i16> %1485 to <4 x i32>
%1490 = zext <4 x i16> %1488 to <4 x i32>
%1491 = add <4 x i32> %1481, %1489
%1492 = add <4 x i32> %1482, %1490
%1493 = or i64 %1480, 8
%1494 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1493
%1495 = bitcast i16* %1494 to <4 x i16>*
%1496 = load <4 x i16>, <4 x i16>* %1495
%1497 = getelementptr inbounds i16, i16* %1494, i64 4
%1498 = bitcast i16* %1497 to <4 x i16>*
%1499 = load <4 x i16>, <4 x i16>* %1498
%1500 = zext <4 x i16> %1496 to <4 x i32>
%1501 = zext <4 x i16> %1499 to <4 x i32>
%1502 = add <4 x i32> %1491, %1500
%1503 = add <4 x i32> %1492, %1501
%1504 = add nuw nsw i64 %1480, 16
%1505 = icmp eq i64 %1504, 10240
br i1 %1505, label %1506, label %1479
1506: ; preds = %1479
%1507 = add <4 x i32> %1503, %1502
%1508 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1507)
%1509 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %1508)
br label %1577
1510: ; preds = %1510, %1438
%1511 = phi i64 [ 0, %1438 ], [ %1541, %1510 ]
%1512 = load volatile i32, i32* %4
%1513 = trunc i64 %1511 to i32
%1514 = mul nsw i32 %1512, %1513
%1515 = trunc i32 %1514 to i16
%1516 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1511
store i16 %1515, i16* %1516
%1517 = add nuw nsw i64 %1511, 1
%1518 = load volatile i32, i32* %4
%1519 = trunc i64 %1517 to i32
%1520 = mul nsw i32 %1518, %1519
%1521 = trunc i32 %1520 to i16
%1522 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1517
store i16 %1521, i16* %1522
%1523 = add nuw nsw i64 %1511, 2
%1524 = load volatile i32, i32* %4
%1525 = trunc i64 %1523 to i32
%1526 = mul nsw i32 %1524, %1525
%1527 = trunc i32 %1526 to i16
%1528 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1523
store i16 %1527, i16* %1528
%1529 = add nuw nsw i64 %1511, 3
%1530 = load volatile i32, i32* %4
%1531 = trunc i64 %1529 to i32
%1532 = mul nsw i32 %1530, %1531
%1533 = trunc i32 %1532 to i16
%1534 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1529
store i16 %1533, i16* %1534
%1535 = add nuw nsw i64 %1511, 4
%1536 = load volatile i32, i32* %4
%1537 = trunc i64 %1535 to i32
%1538 = mul nsw i32 %1536, %1537
%1539 = trunc i32 %1538 to i16
%1540 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1535
store i16 %1539, i16* %1540
%1541 = add nuw nsw i64 %1511, 5
%1542 = icmp eq i64 %1541, 10240
br i1 %1542, label %1476, label %1510
1543: ; preds = %1577
%1544 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 6
%1545 = bitcast i16* %1544 to i8*
br label %1546
1546: ; preds = %1546, %1543
%1547 = phi i64 [ 0, %1543 ], [ %1571, %1546 ]
%1548 = phi <4 x i32> [ zeroinitializer, %1543 ], [ %1569, %1546 ]
%1549 = phi <4 x i32> [ zeroinitializer, %1543 ], [ %1570, %1546 ]
%1550 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1547
%1551 = bitcast i16* %1550 to <4 x i16>*
%1552 = load <4 x i16>, <4 x i16>* %1551
%1553 = getelementptr inbounds i16, i16* %1550, i64 4
%1554 = bitcast i16* %1553 to <4 x i16>*
%1555 = load <4 x i16>, <4 x i16>* %1554
%1556 = zext <4 x i16> %1552 to <4 x i32>
%1557 = zext <4 x i16> %1555 to <4 x i32>
%1558 = add <4 x i32> %1548, %1556
%1559 = add <4 x i32> %1549, %1557
%1560 = or i64 %1547, 8
%1561 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1560
%1562 = bitcast i16* %1561 to <4 x i16>*
%1563 = load <4 x i16>, <4 x i16>* %1562
%1564 = getelementptr inbounds i16, i16* %1561, i64 4
%1565 = bitcast i16* %1564 to <4 x i16>*
%1566 = load <4 x i16>, <4 x i16>* %1565
%1567 = zext <4 x i16> %1563 to <4 x i32>
%1568 = zext <4 x i16> %1566 to <4 x i32>
%1569 = add <4 x i32> %1558, %1567
%1570 = add <4 x i32> %1559, %1568
%1571 = add nuw nsw i64 %1547, 16
%1572 = icmp eq i64 %1571, 10240
br i1 %1572, label %1573, label %1546
1573: ; preds = %1546
%1574 = add <4 x i32> %1570, %1569
%1575 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1574)
%1576 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %1575)
br label %1644
1577: ; preds = %1577, %1506
%1578 = phi i64 [ 0, %1506 ], [ %1608, %1577 ]
%1579 = load volatile i32, i32* %4
%1580 = trunc i64 %1578 to i32
%1581 = mul nsw i32 %1579, %1580
%1582 = trunc i32 %1581 to i16
%1583 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1578
store i16 %1582, i16* %1583
%1584 = add nuw nsw i64 %1578, 1
%1585 = load volatile i32, i32* %4
%1586 = trunc i64 %1584 to i32
%1587 = mul nsw i32 %1585, %1586
%1588 = trunc i32 %1587 to i16
%1589 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1584
store i16 %1588, i16* %1589
%1590 = add nuw nsw i64 %1578, 2
%1591 = load volatile i32, i32* %4
%1592 = trunc i64 %1590 to i32
%1593 = mul nsw i32 %1591, %1592
%1594 = trunc i32 %1593 to i16
%1595 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1590
store i16 %1594, i16* %1595
%1596 = add nuw nsw i64 %1578, 3
%1597 = load volatile i32, i32* %4
%1598 = trunc i64 %1596 to i32
%1599 = mul nsw i32 %1597, %1598
%1600 = trunc i32 %1599 to i16
%1601 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1596
store i16 %1600, i16* %1601
%1602 = add nuw nsw i64 %1578, 4
%1603 = load volatile i32, i32* %4
%1604 = trunc i64 %1602 to i32
%1605 = mul nsw i32 %1603, %1604
%1606 = trunc i32 %1605 to i16
%1607 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1602
store i16 %1606, i16* %1607
%1608 = add nuw nsw i64 %1578, 5
%1609 = icmp eq i64 %1608, 10240
br i1 %1609, label %1543, label %1577
1610: ; preds = %1644
%1611 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 7
%1612 = bitcast i16* %1611 to i8*
br label %1613
1613: ; preds = %1613, %1610
%1614 = phi i64 [ 0, %1610 ], [ %1638, %1613 ]
%1615 = phi <4 x i32> [ zeroinitializer, %1610 ], [ %1636, %1613 ]
%1616 = phi <4 x i32> [ zeroinitializer, %1610 ], [ %1637, %1613 ]
%1617 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1614
%1618 = bitcast i16* %1617 to <4 x i16>*
%1619 = load <4 x i16>, <4 x i16>* %1618
%1620 = getelementptr inbounds i16, i16* %1617, i64 4
%1621 = bitcast i16* %1620 to <4 x i16>*
%1622 = load <4 x i16>, <4 x i16>* %1621
%1623 = zext <4 x i16> %1619 to <4 x i32>
%1624 = zext <4 x i16> %1622 to <4 x i32>
%1625 = add <4 x i32> %1615, %1623
%1626 = add <4 x i32> %1616, %1624
%1627 = or i64 %1614, 8
%1628 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1627
%1629 = bitcast i16* %1628 to <4 x i16>*
%1630 = load <4 x i16>, <4 x i16>* %1629
%1631 = getelementptr inbounds i16, i16* %1628, i64 4
%1632 = bitcast i16* %1631 to <4 x i16>*
%1633 = load <4 x i16>, <4 x i16>* %1632
%1634 = zext <4 x i16> %1630 to <4 x i32>
%1635 = zext <4 x i16> %1633 to <4 x i32>
%1636 = add <4 x i32> %1625, %1634
%1637 = add <4 x i32> %1626, %1635
%1638 = add nuw nsw i64 %1614, 16
%1639 = icmp eq i64 %1638, 10240
br i1 %1639, label %1640, label %1613
1640: ; preds = %1613
%1641 = add <4 x i32> %1637, %1636
%1642 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1641)
%1643 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %1642)
br label %1711
1644: ; preds = %1644, %1573
%1645 = phi i64 [ 0, %1573 ], [ %1675, %1644 ]
%1646 = load volatile i32, i32* %4
%1647 = trunc i64 %1645 to i32
%1648 = mul nsw i32 %1646, %1647
%1649 = trunc i32 %1648 to i16
%1650 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1645
store i16 %1649, i16* %1650
%1651 = add nuw nsw i64 %1645, 1
%1652 = load volatile i32, i32* %4
%1653 = trunc i64 %1651 to i32
%1654 = mul nsw i32 %1652, %1653
%1655 = trunc i32 %1654 to i16
%1656 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1651
store i16 %1655, i16* %1656
%1657 = add nuw nsw i64 %1645, 2
%1658 = load volatile i32, i32* %4
%1659 = trunc i64 %1657 to i32
%1660 = mul nsw i32 %1658, %1659
%1661 = trunc i32 %1660 to i16
%1662 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1657
store i16 %1661, i16* %1662
%1663 = add nuw nsw i64 %1645, 3
%1664 = load volatile i32, i32* %4
%1665 = trunc i64 %1663 to i32
%1666 = mul nsw i32 %1664, %1665
%1667 = trunc i32 %1666 to i16
%1668 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1663
store i16 %1667, i16* %1668
%1669 = add nuw nsw i64 %1645, 4
%1670 = load volatile i32, i32* %4
%1671 = trunc i64 %1669 to i32
%1672 = mul nsw i32 %1670, %1671
%1673 = trunc i32 %1672 to i16
%1674 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1669
store i16 %1673, i16* %1674
%1675 = add nuw nsw i64 %1645, 5
%1676 = icmp eq i64 %1675, 10240
br i1 %1676, label %1610, label %1644
1677: ; preds = %1711
%1678 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 8
%1679 = bitcast i16* %1678 to i64*
store i64 -6510615555426900571, i64* %1679
br label %1680
1680: ; preds = %1680, %1677
%1681 = phi i64 [ 0, %1677 ], [ %1705, %1680 ]
%1682 = phi <4 x i32> [ zeroinitializer, %1677 ], [ %1703, %1680 ]
%1683 = phi <4 x i32> [ zeroinitializer, %1677 ], [ %1704, %1680 ]
%1684 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1681
%1685 = bitcast i16* %1684 to <4 x i16>*
%1686 = load <4 x i16>, <4 x i16>* %1685
%1687 = getelementptr inbounds i16, i16* %1684, i64 4
%1688 = bitcast i16* %1687 to <4 x i16>*
%1689 = load <4 x i16>, <4 x i16>* %1688
%1690 = zext <4 x i16> %1686 to <4 x i32>
%1691 = zext <4 x i16> %1689 to <4 x i32>
%1692 = add <4 x i32> %1682, %1690
%1693 = add <4 x i32> %1683, %1691
%1694 = or i64 %1681, 8
%1695 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1694
%1696 = bitcast i16* %1695 to <4 x i16>*
%1697 = load <4 x i16>, <4 x i16>* %1696
%1698 = getelementptr inbounds i16, i16* %1695, i64 4
%1699 = bitcast i16* %1698 to <4 x i16>*
%1700 = load <4 x i16>, <4 x i16>* %1699
%1701 = zext <4 x i16> %1697 to <4 x i32>
%1702 = zext <4 x i16> %1700 to <4 x i32>
%1703 = add <4 x i32> %1692, %1701
%1704 = add <4 x i32> %1693, %1702
%1705 = add nuw nsw i64 %1681, 16
%1706 = icmp eq i64 %1705, 10240
br i1 %1706, label %1707, label %1680
1707: ; preds = %1680
%1708 = add <4 x i32> %1704, %1703
%1709 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1708)
%1710 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %1709)
br label %1778
1711: ; preds = %1711, %1640
%1712 = phi i64 [ 0, %1640 ], [ %1742, %1711 ]
%1713 = load volatile i32, i32* %4
%1714 = trunc i64 %1712 to i32
%1715 = mul nsw i32 %1713, %1714
%1716 = trunc i32 %1715 to i16
%1717 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1712
store i16 %1716, i16* %1717
%1718 = add nuw nsw i64 %1712, 1
%1719 = load volatile i32, i32* %4
%1720 = trunc i64 %1718 to i32
%1721 = mul nsw i32 %1719, %1720
%1722 = trunc i32 %1721 to i16
%1723 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1718
store i16 %1722, i16* %1723
%1724 = add nuw nsw i64 %1712, 2
%1725 = load volatile i32, i32* %4
%1726 = trunc i64 %1724 to i32
%1727 = mul nsw i32 %1725, %1726
%1728 = trunc i32 %1727 to i16
%1729 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1724
store i16 %1728, i16* %1729
%1730 = add nuw nsw i64 %1712, 3
%1731 = load volatile i32, i32* %4
%1732 = trunc i64 %1730 to i32
%1733 = mul nsw i32 %1731, %1732
%1734 = trunc i32 %1733 to i16
%1735 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1730
store i16 %1734, i16* %1735
%1736 = add nuw nsw i64 %1712, 4
%1737 = load volatile i32, i32* %4
%1738 = trunc i64 %1736 to i32
%1739 = mul nsw i32 %1737, %1738
%1740 = trunc i32 %1739 to i16
%1741 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1736
store i16 %1740, i16* %1741
%1742 = add nuw nsw i64 %1712, 5
%1743 = icmp eq i64 %1742, 10240
br i1 %1743, label %1677, label %1711
1744: ; preds = %1778
%1745 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 9
%1746 = bitcast i16* %1745 to i8*
br label %1747
1747: ; preds = %1747, %1744
%1748 = phi i64 [ 0, %1744 ], [ %1772, %1747 ]
%1749 = phi <4 x i32> [ zeroinitializer, %1744 ], [ %1770, %1747 ]
%1750 = phi <4 x i32> [ zeroinitializer, %1744 ], [ %1771, %1747 ]
%1751 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1748
%1752 = bitcast i16* %1751 to <4 x i16>*
%1753 = load <4 x i16>, <4 x i16>* %1752
%1754 = getelementptr inbounds i16, i16* %1751, i64 4
%1755 = bitcast i16* %1754 to <4 x i16>*
%1756 = load <4 x i16>, <4 x i16>* %1755
%1757 = zext <4 x i16> %1753 to <4 x i32>
%1758 = zext <4 x i16> %1756 to <4 x i32>
%1759 = add <4 x i32> %1749, %1757
%1760 = add <4 x i32> %1750, %1758
%1761 = or i64 %1748, 8
%1762 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1761
%1763 = bitcast i16* %1762 to <4 x i16>*
%1764 = load <4 x i16>, <4 x i16>* %1763
%1765 = getelementptr inbounds i16, i16* %1762, i64 4
%1766 = bitcast i16* %1765 to <4 x i16>*
%1767 = load <4 x i16>, <4 x i16>* %1766
%1768 = zext <4 x i16> %1764 to <4 x i32>
%1769 = zext <4 x i16> %1767 to <4 x i32>
%1770 = add <4 x i32> %1759, %1768
%1771 = add <4 x i32> %1760, %1769
%1772 = add nuw nsw i64 %1748, 16
%1773 = icmp eq i64 %1772, 10240
br i1 %1773, label %1774, label %1747
1774: ; preds = %1747
%1775 = add <4 x i32> %1771, %1770
%1776 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1775)
%1777 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %1776)
br label %1845
1778: ; preds = %1778, %1707
%1779 = phi i64 [ 0, %1707 ], [ %1809, %1778 ]
%1780 = load volatile i32, i32* %4
%1781 = trunc i64 %1779 to i32
%1782 = mul nsw i32 %1780, %1781
%1783 = trunc i32 %1782 to i16
%1784 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1779
store i16 %1783, i16* %1784
%1785 = add nuw nsw i64 %1779, 1
%1786 = load volatile i32, i32* %4
%1787 = trunc i64 %1785 to i32
%1788 = mul nsw i32 %1786, %1787
%1789 = trunc i32 %1788 to i16
%1790 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1785
store i16 %1789, i16* %1790
%1791 = add nuw nsw i64 %1779, 2
%1792 = load volatile i32, i32* %4
%1793 = trunc i64 %1791 to i32
%1794 = mul nsw i32 %1792, %1793
%1795 = trunc i32 %1794 to i16
%1796 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1791
store i16 %1795, i16* %1796
%1797 = add nuw nsw i64 %1779, 3
%1798 = load volatile i32, i32* %4
%1799 = trunc i64 %1797 to i32
%1800 = mul nsw i32 %1798, %1799
%1801 = trunc i32 %1800 to i16
%1802 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1797
store i16 %1801, i16* %1802
%1803 = add nuw nsw i64 %1779, 4
%1804 = load volatile i32, i32* %4
%1805 = trunc i64 %1803 to i32
%1806 = mul nsw i32 %1804, %1805
%1807 = trunc i32 %1806 to i16
%1808 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1803
store i16 %1807, i16* %1808
%1809 = add nuw nsw i64 %1779, 5
%1810 = icmp eq i64 %1809, 10240
br i1 %1810, label %1744, label %1778
1811: ; preds = %1845
%1812 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 10
%1813 = bitcast i16* %1812 to i8*
br label %1814
1814: ; preds = %1814, %1811
%1815 = phi i64 [ 0, %1811 ], [ %1839, %1814 ]
%1816 = phi <4 x i32> [ zeroinitializer, %1811 ], [ %1837, %1814 ]
%1817 = phi <4 x i32> [ zeroinitializer, %1811 ], [ %1838, %1814 ]
%1818 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1815
%1819 = bitcast i16* %1818 to <4 x i16>*
%1820 = load <4 x i16>, <4 x i16>* %1819
%1821 = getelementptr inbounds i16, i16* %1818, i64 4
%1822 = bitcast i16* %1821 to <4 x i16>*
%1823 = load <4 x i16>, <4 x i16>* %1822
%1824 = zext <4 x i16> %1820 to <4 x i32>
%1825 = zext <4 x i16> %1823 to <4 x i32>
%1826 = add <4 x i32> %1816, %1824
%1827 = add <4 x i32> %1817, %1825
%1828 = or i64 %1815, 8
%1829 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1828
%1830 = bitcast i16* %1829 to <4 x i16>*
%1831 = load <4 x i16>, <4 x i16>* %1830
%1832 = getelementptr inbounds i16, i16* %1829, i64 4
%1833 = bitcast i16* %1832 to <4 x i16>*
%1834 = load <4 x i16>, <4 x i16>* %1833
%1835 = zext <4 x i16> %1831 to <4 x i32>
%1836 = zext <4 x i16> %1834 to <4 x i32>
%1837 = add <4 x i32> %1826, %1835
%1838 = add <4 x i32> %1827, %1836
%1839 = add nuw nsw i64 %1815, 16
%1840 = icmp eq i64 %1839, 10240
br i1 %1840, label %1841, label %1814
1841: ; preds = %1814
%1842 = add <4 x i32> %1838, %1837
%1843 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1842)
%1844 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %1843)
br label %1912
1845: ; preds = %1845, %1774
%1846 = phi i64 [ 0, %1774 ], [ %1876, %1845 ]
%1847 = load volatile i32, i32* %4
%1848 = trunc i64 %1846 to i32
%1849 = mul nsw i32 %1847, %1848
%1850 = trunc i32 %1849 to i16
%1851 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1846
store i16 %1850, i16* %1851
%1852 = add nuw nsw i64 %1846, 1
%1853 = load volatile i32, i32* %4
%1854 = trunc i64 %1852 to i32
%1855 = mul nsw i32 %1853, %1854
%1856 = trunc i32 %1855 to i16
%1857 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1852
store i16 %1856, i16* %1857
%1858 = add nuw nsw i64 %1846, 2
%1859 = load volatile i32, i32* %4
%1860 = trunc i64 %1858 to i32
%1861 = mul nsw i32 %1859, %1860
%1862 = trunc i32 %1861 to i16
%1863 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1858
store i16 %1862, i16* %1863
%1864 = add nuw nsw i64 %1846, 3
%1865 = load volatile i32, i32* %4
%1866 = trunc i64 %1864 to i32
%1867 = mul nsw i32 %1865, %1866
%1868 = trunc i32 %1867 to i16
%1869 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1864
store i16 %1868, i16* %1869
%1870 = add nuw nsw i64 %1846, 4
%1871 = load volatile i32, i32* %4
%1872 = trunc i64 %1870 to i32
%1873 = mul nsw i32 %1871, %1872
%1874 = trunc i32 %1873 to i16
%1875 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1870
store i16 %1874, i16* %1875
%1876 = add nuw nsw i64 %1846, 5
%1877 = icmp eq i64 %1876, 10240
br i1 %1877, label %1811, label %1845
1878: ; preds = %1912
%1879 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 16
%1880 = bitcast i16* %1879 to i8*
br label %1881
1881: ; preds = %1881, %1878
%1882 = phi i64 [ 0, %1878 ], [ %1906, %1881 ]
%1883 = phi <4 x i32> [ zeroinitializer, %1878 ], [ %1904, %1881 ]
%1884 = phi <4 x i32> [ zeroinitializer, %1878 ], [ %1905, %1881 ]
%1885 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1882
%1886 = bitcast i16* %1885 to <4 x i16>*
%1887 = load <4 x i16>, <4 x i16>* %1886
%1888 = getelementptr inbounds i16, i16* %1885, i64 4
%1889 = bitcast i16* %1888 to <4 x i16>*
%1890 = load <4 x i16>, <4 x i16>* %1889
%1891 = zext <4 x i16> %1887 to <4 x i32>
%1892 = zext <4 x i16> %1890 to <4 x i32>
%1893 = add <4 x i32> %1883, %1891
%1894 = add <4 x i32> %1884, %1892
%1895 = or i64 %1882, 8
%1896 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1895
%1897 = bitcast i16* %1896 to <4 x i16>*
%1898 = load <4 x i16>, <4 x i16>* %1897
%1899 = getelementptr inbounds i16, i16* %1896, i64 4
%1900 = bitcast i16* %1899 to <4 x i16>*
%1901 = load <4 x i16>, <4 x i16>* %1900
%1902 = zext <4 x i16> %1898 to <4 x i32>
%1903 = zext <4 x i16> %1901 to <4 x i32>
%1904 = add <4 x i32> %1893, %1902
%1905 = add <4 x i32> %1894, %1903
%1906 = add nuw nsw i64 %1882, 16
%1907 = icmp eq i64 %1906, 10240
br i1 %1907, label %1908, label %1881
1908: ; preds = %1881
%1909 = add <4 x i32> %1905, %1904
%1910 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1909)
%1911 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %1910)
br label %1979
1912: ; preds = %1912, %1841
%1913 = phi i64 [ 0, %1841 ], [ %1943, %1912 ]
%1914 = load volatile i32, i32* %4
%1915 = trunc i64 %1913 to i32
%1916 = mul nsw i32 %1914, %1915
%1917 = trunc i32 %1916 to i16
%1918 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1913
store i16 %1917, i16* %1918
%1919 = add nuw nsw i64 %1913, 1
%1920 = load volatile i32, i32* %4
%1921 = trunc i64 %1919 to i32
%1922 = mul nsw i32 %1920, %1921
%1923 = trunc i32 %1922 to i16
%1924 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1919
store i16 %1923, i16* %1924
%1925 = add nuw nsw i64 %1913, 2
%1926 = load volatile i32, i32* %4
%1927 = trunc i64 %1925 to i32
%1928 = mul nsw i32 %1926, %1927
%1929 = trunc i32 %1928 to i16
%1930 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1925
store i16 %1929, i16* %1930
%1931 = add nuw nsw i64 %1913, 3
%1932 = load volatile i32, i32* %4
%1933 = trunc i64 %1931 to i32
%1934 = mul nsw i32 %1932, %1933
%1935 = trunc i32 %1934 to i16
%1936 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1931
store i16 %1935, i16* %1936
%1937 = add nuw nsw i64 %1913, 4
%1938 = load volatile i32, i32* %4
%1939 = trunc i64 %1937 to i32
%1940 = mul nsw i32 %1938, %1939
%1941 = trunc i32 %1940 to i16
%1942 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1937
store i16 %1941, i16* %1942
%1943 = add nuw nsw i64 %1913, 5
%1944 = icmp eq i64 %1943, 10240
br i1 %1944, label %1878, label %1912
1945: ; preds = %1979
%1946 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 15
%1947 = bitcast i16* %1946 to i8*
br label %1948
1948: ; preds = %1948, %1945
%1949 = phi i64 [ 0, %1945 ], [ %1973, %1948 ]
%1950 = phi <4 x i32> [ zeroinitializer, %1945 ], [ %1971, %1948 ]
%1951 = phi <4 x i32> [ zeroinitializer, %1945 ], [ %1972, %1948 ]
%1952 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1949
%1953 = bitcast i16* %1952 to <4 x i16>*
%1954 = load <4 x i16>, <4 x i16>* %1953
%1955 = getelementptr inbounds i16, i16* %1952, i64 4
%1956 = bitcast i16* %1955 to <4 x i16>*
%1957 = load <4 x i16>, <4 x i16>* %1956
%1958 = zext <4 x i16> %1954 to <4 x i32>
%1959 = zext <4 x i16> %1957 to <4 x i32>
%1960 = add <4 x i32> %1950, %1958
%1961 = add <4 x i32> %1951, %1959
%1962 = or i64 %1949, 8
%1963 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1962
%1964 = bitcast i16* %1963 to <4 x i16>*
%1965 = load <4 x i16>, <4 x i16>* %1964
%1966 = getelementptr inbounds i16, i16* %1963, i64 4
%1967 = bitcast i16* %1966 to <4 x i16>*
%1968 = load <4 x i16>, <4 x i16>* %1967
%1969 = zext <4 x i16> %1965 to <4 x i32>
%1970 = zext <4 x i16> %1968 to <4 x i32>
%1971 = add <4 x i32> %1960, %1969
%1972 = add <4 x i32> %1961, %1970
%1973 = add nuw nsw i64 %1949, 16
%1974 = icmp eq i64 %1973, 10240
br i1 %1974, label %1975, label %1948
1975: ; preds = %1948
%1976 = add <4 x i32> %1972, %1971
%1977 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %1976)
%1978 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %1977)
br label %2046
1979: ; preds = %1979, %1908
%1980 = phi i64 [ 0, %1908 ], [ %2010, %1979 ]
%1981 = load volatile i32, i32* %4
%1982 = trunc i64 %1980 to i32
%1983 = mul nsw i32 %1981, %1982
%1984 = trunc i32 %1983 to i16
%1985 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1980
store i16 %1984, i16* %1985
%1986 = add nuw nsw i64 %1980, 1
%1987 = load volatile i32, i32* %4
%1988 = trunc i64 %1986 to i32
%1989 = mul nsw i32 %1987, %1988
%1990 = trunc i32 %1989 to i16
%1991 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1986
store i16 %1990, i16* %1991
%1992 = add nuw nsw i64 %1980, 2
%1993 = load volatile i32, i32* %4
%1994 = trunc i64 %1992 to i32
%1995 = mul nsw i32 %1993, %1994
%1996 = trunc i32 %1995 to i16
%1997 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1992
store i16 %1996, i16* %1997
%1998 = add nuw nsw i64 %1980, 3
%1999 = load volatile i32, i32* %4
%2000 = trunc i64 %1998 to i32
%2001 = mul nsw i32 %1999, %2000
%2002 = trunc i32 %2001 to i16
%2003 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %1998
store i16 %2002, i16* %2003
%2004 = add nuw nsw i64 %1980, 4
%2005 = load volatile i32, i32* %4
%2006 = trunc i64 %2004 to i32
%2007 = mul nsw i32 %2005, %2006
%2008 = trunc i32 %2007 to i16
%2009 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2004
store i16 %2008, i16* %2009
%2010 = add nuw nsw i64 %1980, 5
%2011 = icmp eq i64 %2010, 10240
br i1 %2011, label %1945, label %1979
2012: ; preds = %2046
%2013 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 13
%2014 = bitcast i16* %2013 to i8*
br label %2015
2015: ; preds = %2015, %2012
%2016 = phi i64 [ 0, %2012 ], [ %2040, %2015 ]
%2017 = phi <4 x i32> [ zeroinitializer, %2012 ], [ %2038, %2015 ]
%2018 = phi <4 x i32> [ zeroinitializer, %2012 ], [ %2039, %2015 ]
%2019 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2016
%2020 = bitcast i16* %2019 to <4 x i16>*
%2021 = load <4 x i16>, <4 x i16>* %2020
%2022 = getelementptr inbounds i16, i16* %2019, i64 4
%2023 = bitcast i16* %2022 to <4 x i16>*
%2024 = load <4 x i16>, <4 x i16>* %2023
%2025 = zext <4 x i16> %2021 to <4 x i32>
%2026 = zext <4 x i16> %2024 to <4 x i32>
%2027 = add <4 x i32> %2017, %2025
%2028 = add <4 x i32> %2018, %2026
%2029 = or i64 %2016, 8
%2030 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2029
%2031 = bitcast i16* %2030 to <4 x i16>*
%2032 = load <4 x i16>, <4 x i16>* %2031
%2033 = getelementptr inbounds i16, i16* %2030, i64 4
%2034 = bitcast i16* %2033 to <4 x i16>*
%2035 = load <4 x i16>, <4 x i16>* %2034
%2036 = zext <4 x i16> %2032 to <4 x i32>
%2037 = zext <4 x i16> %2035 to <4 x i32>
%2038 = add <4 x i32> %2027, %2036
%2039 = add <4 x i32> %2028, %2037
%2040 = add nuw nsw i64 %2016, 16
%2041 = icmp eq i64 %2040, 10240
br i1 %2041, label %2042, label %2015
2042: ; preds = %2015
%2043 = add <4 x i32> %2039, %2038
%2044 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2043)
%2045 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %2044)
br label %2111
2046: ; preds = %2046, %1975
%2047 = phi i64 [ 0, %1975 ], [ %2077, %2046 ]
%2048 = load volatile i32, i32* %4
%2049 = trunc i64 %2047 to i32
%2050 = mul nsw i32 %2048, %2049
%2051 = trunc i32 %2050 to i16
%2052 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2047
store i16 %2051, i16* %2052
%2053 = add nuw nsw i64 %2047, 1
%2054 = load volatile i32, i32* %4
%2055 = trunc i64 %2053 to i32
%2056 = mul nsw i32 %2054, %2055
%2057 = trunc i32 %2056 to i16
%2058 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2053
store i16 %2057, i16* %2058
%2059 = add nuw nsw i64 %2047, 2
%2060 = load volatile i32, i32* %4
%2061 = trunc i64 %2059 to i32
%2062 = mul nsw i32 %2060, %2061
%2063 = trunc i32 %2062 to i16
%2064 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2059
store i16 %2063, i16* %2064
%2065 = add nuw nsw i64 %2047, 3
%2066 = load volatile i32, i32* %4
%2067 = trunc i64 %2065 to i32
%2068 = mul nsw i32 %2066, %2067
%2069 = trunc i32 %2068 to i16
%2070 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2065
store i16 %2069, i16* %2070
%2071 = add nuw nsw i64 %2047, 4
%2072 = load volatile i32, i32* %4
%2073 = trunc i64 %2071 to i32
%2074 = mul nsw i32 %2072, %2073
%2075 = trunc i32 %2074 to i16
%2076 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2071
store i16 %2075, i16* %2076
%2077 = add nuw nsw i64 %2047, 5
%2078 = icmp eq i64 %2077, 10240
br i1 %2078, label %2012, label %2046
2079: ; preds = %2111
br label %2080
2080: ; preds = %2080, %2079
%2081 = phi i64 [ 0, %2079 ], [ %2105, %2080 ]
%2082 = phi <4 x i32> [ zeroinitializer, %2079 ], [ %2103, %2080 ]
%2083 = phi <4 x i32> [ zeroinitializer, %2079 ], [ %2104, %2080 ]
%2084 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2081
%2085 = bitcast i16* %2084 to <4 x i16>*
%2086 = load <4 x i16>, <4 x i16>* %2085
%2087 = getelementptr inbounds i16, i16* %2084, i64 4
%2088 = bitcast i16* %2087 to <4 x i16>*
%2089 = load <4 x i16>, <4 x i16>* %2088
%2090 = zext <4 x i16> %2086 to <4 x i32>
%2091 = zext <4 x i16> %2089 to <4 x i32>
%2092 = add <4 x i32> %2082, %2090
%2093 = add <4 x i32> %2083, %2091
%2094 = or i64 %2081, 8
%2095 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2094
%2096 = bitcast i16* %2095 to <4 x i16>*
%2097 = load <4 x i16>, <4 x i16>* %2096
%2098 = getelementptr inbounds i16, i16* %2095, i64 4
%2099 = bitcast i16* %2098 to <4 x i16>*
%2100 = load <4 x i16>, <4 x i16>* %2099
%2101 = zext <4 x i16> %2097 to <4 x i32>
%2102 = zext <4 x i16> %2100 to <4 x i32>
%2103 = add <4 x i32> %2092, %2101
%2104 = add <4 x i32> %2093, %2102
%2105 = add nuw nsw i64 %2081, 16
%2106 = icmp eq i64 %2105, 10240
br i1 %2106, label %2107, label %2080
2107: ; preds = %2080
%2108 = add <4 x i32> %2104, %2103
%2109 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2108)
%2110 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %2109)
br label %2176
2111: ; preds = %2111, %2042
%2112 = phi i64 [ 0, %2042 ], [ %2142, %2111 ]
%2113 = load volatile i32, i32* %4
%2114 = trunc i64 %2112 to i32
%2115 = mul nsw i32 %2113, %2114
%2116 = trunc i32 %2115 to i16
%2117 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2112
store i16 %2116, i16* %2117
%2118 = add nuw nsw i64 %2112, 1
%2119 = load volatile i32, i32* %4
%2120 = trunc i64 %2118 to i32
%2121 = mul nsw i32 %2119, %2120
%2122 = trunc i32 %2121 to i16
%2123 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2118
store i16 %2122, i16* %2123
%2124 = add nuw nsw i64 %2112, 2
%2125 = load volatile i32, i32* %4
%2126 = trunc i64 %2124 to i32
%2127 = mul nsw i32 %2125, %2126
%2128 = trunc i32 %2127 to i16
%2129 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2124
store i16 %2128, i16* %2129
%2130 = add nuw nsw i64 %2112, 3
%2131 = load volatile i32, i32* %4
%2132 = trunc i64 %2130 to i32
%2133 = mul nsw i32 %2131, %2132
%2134 = trunc i32 %2133 to i16
%2135 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2130
store i16 %2134, i16* %2135
%2136 = add nuw nsw i64 %2112, 4
%2137 = load volatile i32, i32* %4
%2138 = trunc i64 %2136 to i32
%2139 = mul nsw i32 %2137, %2138
%2140 = trunc i32 %2139 to i16
%2141 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2136
store i16 %2140, i16* %2141
%2142 = add nuw nsw i64 %2112, 5
%2143 = icmp eq i64 %2142, 10240
br i1 %2143, label %2079, label %2111
2144: ; preds = %2176
br label %2145
2145: ; preds = %2145, %2144
%2146 = phi i64 [ 0, %2144 ], [ %2170, %2145 ]
%2147 = phi <4 x i32> [ zeroinitializer, %2144 ], [ %2168, %2145 ]
%2148 = phi <4 x i32> [ zeroinitializer, %2144 ], [ %2169, %2145 ]
%2149 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2146
%2150 = bitcast i16* %2149 to <4 x i16>*
%2151 = load <4 x i16>, <4 x i16>* %2150
%2152 = getelementptr inbounds i16, i16* %2149, i64 4
%2153 = bitcast i16* %2152 to <4 x i16>*
%2154 = load <4 x i16>, <4 x i16>* %2153
%2155 = zext <4 x i16> %2151 to <4 x i32>
%2156 = zext <4 x i16> %2154 to <4 x i32>
%2157 = add <4 x i32> %2147, %2155
%2158 = add <4 x i32> %2148, %2156
%2159 = or i64 %2146, 8
%2160 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2159
%2161 = bitcast i16* %2160 to <4 x i16>*
%2162 = load <4 x i16>, <4 x i16>* %2161
%2163 = getelementptr inbounds i16, i16* %2160, i64 4
%2164 = bitcast i16* %2163 to <4 x i16>*
%2165 = load <4 x i16>, <4 x i16>* %2164
%2166 = zext <4 x i16> %2162 to <4 x i32>
%2167 = zext <4 x i16> %2165 to <4 x i32>
%2168 = add <4 x i32> %2157, %2166
%2169 = add <4 x i32> %2158, %2167
%2170 = add nuw nsw i64 %2146, 16
%2171 = icmp eq i64 %2170, 10240
br i1 %2171, label %2172, label %2145
2172: ; preds = %2145
%2173 = add <4 x i32> %2169, %2168
%2174 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2173)
%2175 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %2174)
br label %2241
2176: ; preds = %2176, %2107
%2177 = phi i64 [ 0, %2107 ], [ %2207, %2176 ]
%2178 = load volatile i32, i32* %4
%2179 = trunc i64 %2177 to i32
%2180 = mul nsw i32 %2178, %2179
%2181 = trunc i32 %2180 to i16
%2182 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2177
store i16 %2181, i16* %2182
%2183 = add nuw nsw i64 %2177, 1
%2184 = load volatile i32, i32* %4
%2185 = trunc i64 %2183 to i32
%2186 = mul nsw i32 %2184, %2185
%2187 = trunc i32 %2186 to i16
%2188 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2183
store i16 %2187, i16* %2188
%2189 = add nuw nsw i64 %2177, 2
%2190 = load volatile i32, i32* %4
%2191 = trunc i64 %2189 to i32
%2192 = mul nsw i32 %2190, %2191
%2193 = trunc i32 %2192 to i16
%2194 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2189
store i16 %2193, i16* %2194
%2195 = add nuw nsw i64 %2177, 3
%2196 = load volatile i32, i32* %4
%2197 = trunc i64 %2195 to i32
%2198 = mul nsw i32 %2196, %2197
%2199 = trunc i32 %2198 to i16
%2200 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2195
store i16 %2199, i16* %2200
%2201 = add nuw nsw i64 %2177, 4
%2202 = load volatile i32, i32* %4
%2203 = trunc i64 %2201 to i32
%2204 = mul nsw i32 %2202, %2203
%2205 = trunc i32 %2204 to i16
%2206 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2201
store i16 %2205, i16* %2206
%2207 = add nuw nsw i64 %2177, 5
%2208 = icmp eq i64 %2207, 10240
br i1 %2208, label %2144, label %2176
2209: ; preds = %2241
br label %2210
2210: ; preds = %2210, %2209
%2211 = phi i64 [ 0, %2209 ], [ %2235, %2210 ]
%2212 = phi <4 x i32> [ zeroinitializer, %2209 ], [ %2233, %2210 ]
%2213 = phi <4 x i32> [ zeroinitializer, %2209 ], [ %2234, %2210 ]
%2214 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2211
%2215 = bitcast i16* %2214 to <4 x i16>*
%2216 = load <4 x i16>, <4 x i16>* %2215
%2217 = getelementptr inbounds i16, i16* %2214, i64 4
%2218 = bitcast i16* %2217 to <4 x i16>*
%2219 = load <4 x i16>, <4 x i16>* %2218
%2220 = zext <4 x i16> %2216 to <4 x i32>
%2221 = zext <4 x i16> %2219 to <4 x i32>
%2222 = add <4 x i32> %2212, %2220
%2223 = add <4 x i32> %2213, %2221
%2224 = or i64 %2211, 8
%2225 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2224
%2226 = bitcast i16* %2225 to <4 x i16>*
%2227 = load <4 x i16>, <4 x i16>* %2226
%2228 = getelementptr inbounds i16, i16* %2225, i64 4
%2229 = bitcast i16* %2228 to <4 x i16>*
%2230 = load <4 x i16>, <4 x i16>* %2229
%2231 = zext <4 x i16> %2227 to <4 x i32>
%2232 = zext <4 x i16> %2230 to <4 x i32>
%2233 = add <4 x i32> %2222, %2231
%2234 = add <4 x i32> %2223, %2232
%2235 = add nuw nsw i64 %2211, 16
%2236 = icmp eq i64 %2235, 10240
br i1 %2236, label %2237, label %2210
2237: ; preds = %2210
%2238 = add <4 x i32> %2234, %2233
%2239 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2238)
%2240 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %2239)
br label %2307
2241: ; preds = %2241, %2172
%2242 = phi i64 [ 0, %2172 ], [ %2272, %2241 ]
%2243 = load volatile i32, i32* %4
%2244 = trunc i64 %2242 to i32
%2245 = mul nsw i32 %2243, %2244
%2246 = trunc i32 %2245 to i16
%2247 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2242
store i16 %2246, i16* %2247
%2248 = add nuw nsw i64 %2242, 1
%2249 = load volatile i32, i32* %4
%2250 = trunc i64 %2248 to i32
%2251 = mul nsw i32 %2249, %2250
%2252 = trunc i32 %2251 to i16
%2253 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2248
store i16 %2252, i16* %2253
%2254 = add nuw nsw i64 %2242, 2
%2255 = load volatile i32, i32* %4
%2256 = trunc i64 %2254 to i32
%2257 = mul nsw i32 %2255, %2256
%2258 = trunc i32 %2257 to i16
%2259 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2254
store i16 %2258, i16* %2259
%2260 = add nuw nsw i64 %2242, 3
%2261 = load volatile i32, i32* %4
%2262 = trunc i64 %2260 to i32
%2263 = mul nsw i32 %2261, %2262
%2264 = trunc i32 %2263 to i16
%2265 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2260
store i16 %2264, i16* %2265
%2266 = add nuw nsw i64 %2242, 4
%2267 = load volatile i32, i32* %4
%2268 = trunc i64 %2266 to i32
%2269 = mul nsw i32 %2267, %2268
%2270 = trunc i32 %2269 to i16
%2271 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2266
store i16 %2270, i16* %2271
%2272 = add nuw nsw i64 %2242, 5
%2273 = icmp eq i64 %2272, 10240
br i1 %2273, label %2209, label %2241
2274: ; preds = %2307
%2275 = bitcast i16* %1409 to i8*
br label %2276
2276: ; preds = %2276, %2274
%2277 = phi i64 [ 0, %2274 ], [ %2301, %2276 ]
%2278 = phi <4 x i32> [ zeroinitializer, %2274 ], [ %2299, %2276 ]
%2279 = phi <4 x i32> [ zeroinitializer, %2274 ], [ %2300, %2276 ]
%2280 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2277
%2281 = bitcast i16* %2280 to <4 x i16>*
%2282 = load <4 x i16>, <4 x i16>* %2281
%2283 = getelementptr inbounds i16, i16* %2280, i64 4
%2284 = bitcast i16* %2283 to <4 x i16>*
%2285 = load <4 x i16>, <4 x i16>* %2284
%2286 = zext <4 x i16> %2282 to <4 x i32>
%2287 = zext <4 x i16> %2285 to <4 x i32>
%2288 = add <4 x i32> %2278, %2286
%2289 = add <4 x i32> %2279, %2287
%2290 = or i64 %2277, 8
%2291 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2290
%2292 = bitcast i16* %2291 to <4 x i16>*
%2293 = load <4 x i16>, <4 x i16>* %2292
%2294 = getelementptr inbounds i16, i16* %2291, i64 4
%2295 = bitcast i16* %2294 to <4 x i16>*
%2296 = load <4 x i16>, <4 x i16>* %2295
%2297 = zext <4 x i16> %2293 to <4 x i32>
%2298 = zext <4 x i16> %2296 to <4 x i32>
%2299 = add <4 x i32> %2288, %2297
%2300 = add <4 x i32> %2289, %2298
%2301 = add nuw nsw i64 %2277, 16
%2302 = icmp eq i64 %2301, 10240
br i1 %2302, label %2303, label %2276
2303: ; preds = %2276
%2304 = add <4 x i32> %2300, %2299
%2305 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2304)
%2306 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %2305)
br label %2340
2307: ; preds = %2307, %2237
%2308 = phi i64 [ 0, %2237 ], [ %2338, %2307 ]
%2309 = load volatile i32, i32* %4
%2310 = trunc i64 %2308 to i32
%2311 = mul nsw i32 %2309, %2310
%2312 = trunc i32 %2311 to i16
%2313 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2308
store i16 %2312, i16* %2313
%2314 = add nuw nsw i64 %2308, 1
%2315 = load volatile i32, i32* %4
%2316 = trunc i64 %2314 to i32
%2317 = mul nsw i32 %2315, %2316
%2318 = trunc i32 %2317 to i16
%2319 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2314
store i16 %2318, i16* %2319
%2320 = add nuw nsw i64 %2308, 2
%2321 = load volatile i32, i32* %4
%2322 = trunc i64 %2320 to i32
%2323 = mul nsw i32 %2321, %2322
%2324 = trunc i32 %2323 to i16
%2325 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2320
store i16 %2324, i16* %2325
%2326 = add nuw nsw i64 %2308, 3
%2327 = load volatile i32, i32* %4
%2328 = trunc i64 %2326 to i32
%2329 = mul nsw i32 %2327, %2328
%2330 = trunc i32 %2329 to i16
%2331 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2326
store i16 %2330, i16* %2331
%2332 = add nuw nsw i64 %2308, 4
%2333 = load volatile i32, i32* %4
%2334 = trunc i64 %2332 to i32
%2335 = mul nsw i32 %2333, %2334
%2336 = trunc i32 %2335 to i16
%2337 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2332
store i16 %2336, i16* %2337
%2338 = add nuw nsw i64 %2308, 5
%2339 = icmp eq i64 %2338, 10240
br i1 %2339, label %2274, label %2307
2340: ; preds = %2303, %2379
%2341 = phi i64 [ 10, %2303 ], [ %2383, %2379 ]
br label %2385
2342: ; preds = %2379
%2343 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.5, i64 0, i64 0))
%2344 = bitcast [10240 x i32]* %5 to i8*
%2345 = bitcast i32* %6 to i8*
store volatile i32 123, i32* %6
br label %2475
2346: ; preds = %2385
%2347 = trunc i64 %2341 to i32
%2348 = urem i32 %2347, 17
%2349 = zext i32 %2348 to i64
%2350 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2349
%2351 = bitcast i16* %2350 to i8*
br label %2352
2352: ; preds = %2352, %2346
%2353 = phi i64 [ 0, %2346 ], [ %2377, %2352 ]
%2354 = phi <4 x i32> [ zeroinitializer, %2346 ], [ %2375, %2352 ]
%2355 = phi <4 x i32> [ zeroinitializer, %2346 ], [ %2376, %2352 ]
%2356 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2353
%2357 = bitcast i16* %2356 to <4 x i16>*
%2358 = load <4 x i16>, <4 x i16>* %2357
%2359 = getelementptr inbounds i16, i16* %2356, i64 4
%2360 = bitcast i16* %2359 to <4 x i16>*
%2361 = load <4 x i16>, <4 x i16>* %2360
%2362 = zext <4 x i16> %2358 to <4 x i32>
%2363 = zext <4 x i16> %2361 to <4 x i32>
%2364 = add <4 x i32> %2354, %2362
%2365 = add <4 x i32> %2355, %2363
%2366 = or i64 %2353, 8
%2367 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2366
%2368 = bitcast i16* %2367 to <4 x i16>*
%2369 = load <4 x i16>, <4 x i16>* %2368
%2370 = getelementptr inbounds i16, i16* %2367, i64 4
%2371 = bitcast i16* %2370 to <4 x i16>*
%2372 = load <4 x i16>, <4 x i16>* %2371
%2373 = zext <4 x i16> %2369 to <4 x i32>
%2374 = zext <4 x i16> %2372 to <4 x i32>
%2375 = add <4 x i32> %2364, %2373
%2376 = add <4 x i32> %2365, %2374
%2377 = add nuw nsw i64 %2353, 16
%2378 = icmp eq i64 %2377, 10240
br i1 %2378, label %2379, label %2352
2379: ; preds = %2352
%2380 = add <4 x i32> %2376, %2375
%2381 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2380)
%2382 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %2347, i32 %2381)
%2383 = add nuw nsw i64 %2341, 10
%2384 = icmp ult i64 %2341, 90
br i1 %2384, label %2340, label %2342
2385: ; preds = %2385, %2340
%2386 = phi i64 [ 0, %2340 ], [ %2416, %2385 ]
%2387 = load volatile i32, i32* %4
%2388 = trunc i64 %2386 to i32
%2389 = mul nsw i32 %2387, %2388
%2390 = trunc i32 %2389 to i16
%2391 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2386
store i16 %2390, i16* %2391
%2392 = add nuw nsw i64 %2386, 1
%2393 = load volatile i32, i32* %4
%2394 = trunc i64 %2392 to i32
%2395 = mul nsw i32 %2393, %2394
%2396 = trunc i32 %2395 to i16
%2397 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2392
store i16 %2396, i16* %2397
%2398 = add nuw nsw i64 %2386, 2
%2399 = load volatile i32, i32* %4
%2400 = trunc i64 %2398 to i32
%2401 = mul nsw i32 %2399, %2400
%2402 = trunc i32 %2401 to i16
%2403 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2398
store i16 %2402, i16* %2403
%2404 = add nuw nsw i64 %2386, 3
%2405 = load volatile i32, i32* %4
%2406 = trunc i64 %2404 to i32
%2407 = mul nsw i32 %2405, %2406
%2408 = trunc i32 %2407 to i16
%2409 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2404
store i16 %2408, i16* %2409
%2410 = add nuw nsw i64 %2386, 4
%2411 = load volatile i32, i32* %4
%2412 = trunc i64 %2410 to i32
%2413 = mul nsw i32 %2411, %2412
%2414 = trunc i32 %2413 to i16
%2415 = getelementptr inbounds [10240 x i16], [10240 x i16]* %3, i64 0, i64 %2410
store i16 %2414, i16* %2415
%2416 = add nuw nsw i64 %2386, 5
%2417 = icmp eq i64 %2416, 10240
br i1 %2417, label %2346, label %2385
2418: ; preds = %2475
%2419 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 1
%2420 = bitcast i32* %2419 to i8*
store i8 -91, i8* %2420
br label %2421
2421: ; preds = %2421, %2418
%2422 = phi i64 [ 0, %2418 ], [ %2469, %2421 ]
%2423 = phi <4 x i32> [ zeroinitializer, %2418 ], [ %2467, %2421 ]
%2424 = phi <4 x i32> [ zeroinitializer, %2418 ], [ %2468, %2421 ]
%2425 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2422
%2426 = bitcast i32* %2425 to <4 x i32>*
%2427 = load <4 x i32>, <4 x i32>* %2426
%2428 = getelementptr inbounds i32, i32* %2425, i64 4
%2429 = bitcast i32* %2428 to <4 x i32>*
%2430 = load <4 x i32>, <4 x i32>* %2429
%2431 = add <4 x i32> %2427, %2423
%2432 = add <4 x i32> %2430, %2424
%2433 = add nuw nsw i64 %2422, 8
%2434 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2433
%2435 = bitcast i32* %2434 to <4 x i32>*
%2436 = load <4 x i32>, <4 x i32>* %2435
%2437 = getelementptr inbounds i32, i32* %2434, i64 4
%2438 = bitcast i32* %2437 to <4 x i32>*
%2439 = load <4 x i32>, <4 x i32>* %2438
%2440 = add <4 x i32> %2436, %2431
%2441 = add <4 x i32> %2439, %2432
%2442 = add nuw nsw i64 %2422, 16
%2443 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2442
%2444 = bitcast i32* %2443 to <4 x i32>*
%2445 = load <4 x i32>, <4 x i32>* %2444
%2446 = getelementptr inbounds i32, i32* %2443, i64 4
%2447 = bitcast i32* %2446 to <4 x i32>*
%2448 = load <4 x i32>, <4 x i32>* %2447
%2449 = add <4 x i32> %2445, %2440
%2450 = add <4 x i32> %2448, %2441
%2451 = add nuw nsw i64 %2422, 24
%2452 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2451
%2453 = bitcast i32* %2452 to <4 x i32>*
%2454 = load <4 x i32>, <4 x i32>* %2453
%2455 = getelementptr inbounds i32, i32* %2452, i64 4
%2456 = bitcast i32* %2455 to <4 x i32>*
%2457 = load <4 x i32>, <4 x i32>* %2456
%2458 = add <4 x i32> %2454, %2449
%2459 = add <4 x i32> %2457, %2450
%2460 = add nuw nsw i64 %2422, 32
%2461 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2460
%2462 = bitcast i32* %2461 to <4 x i32>*
%2463 = load <4 x i32>, <4 x i32>* %2462
%2464 = getelementptr inbounds i32, i32* %2461, i64 4
%2465 = bitcast i32* %2464 to <4 x i32>*
%2466 = load <4 x i32>, <4 x i32>* %2465
%2467 = add <4 x i32> %2463, %2458
%2468 = add <4 x i32> %2466, %2459
%2469 = add nuw nsw i64 %2422, 40
%2470 = icmp eq i64 %2469, 10240
br i1 %2470, label %2471, label %2421
2471: ; preds = %2421
%2472 = add <4 x i32> %2468, %2467
%2473 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2472)
%2474 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1, i32 %2473)
br label %2560
2475: ; preds = %2475, %2342
%2476 = phi i64 [ 0, %2342 ], [ %2501, %2475 ]
%2477 = load volatile i32, i32* %6
%2478 = trunc i64 %2476 to i32
%2479 = mul nsw i32 %2477, %2478
%2480 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2476
store i32 %2479, i32* %2480
%2481 = add nuw nsw i64 %2476, 1
%2482 = load volatile i32, i32* %6
%2483 = trunc i64 %2481 to i32
%2484 = mul nsw i32 %2482, %2483
%2485 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2481
store i32 %2484, i32* %2485
%2486 = add nuw nsw i64 %2476, 2
%2487 = load volatile i32, i32* %6
%2488 = trunc i64 %2486 to i32
%2489 = mul nsw i32 %2487, %2488
%2490 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2486
store i32 %2489, i32* %2490
%2491 = add nuw nsw i64 %2476, 3
%2492 = load volatile i32, i32* %6
%2493 = trunc i64 %2491 to i32
%2494 = mul nsw i32 %2492, %2493
%2495 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2491
store i32 %2494, i32* %2495
%2496 = add nuw nsw i64 %2476, 4
%2497 = load volatile i32, i32* %6
%2498 = trunc i64 %2496 to i32
%2499 = mul nsw i32 %2497, %2498
%2500 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2496
store i32 %2499, i32* %2500
%2501 = add nuw nsw i64 %2476, 5
%2502 = icmp eq i64 %2501, 10240
br i1 %2502, label %2418, label %2475
2503: ; preds = %2560
%2504 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 2
%2505 = bitcast i32* %2504 to i16*
store i16 -23131, i16* %2505
br label %2506
2506: ; preds = %2506, %2503
%2507 = phi i64 [ 0, %2503 ], [ %2554, %2506 ]
%2508 = phi <4 x i32> [ zeroinitializer, %2503 ], [ %2552, %2506 ]
%2509 = phi <4 x i32> [ zeroinitializer, %2503 ], [ %2553, %2506 ]
%2510 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2507
%2511 = bitcast i32* %2510 to <4 x i32>*
%2512 = load <4 x i32>, <4 x i32>* %2511
%2513 = getelementptr inbounds i32, i32* %2510, i64 4
%2514 = bitcast i32* %2513 to <4 x i32>*
%2515 = load <4 x i32>, <4 x i32>* %2514
%2516 = add <4 x i32> %2512, %2508
%2517 = add <4 x i32> %2515, %2509
%2518 = add nuw nsw i64 %2507, 8
%2519 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2518
%2520 = bitcast i32* %2519 to <4 x i32>*
%2521 = load <4 x i32>, <4 x i32>* %2520
%2522 = getelementptr inbounds i32, i32* %2519, i64 4
%2523 = bitcast i32* %2522 to <4 x i32>*
%2524 = load <4 x i32>, <4 x i32>* %2523
%2525 = add <4 x i32> %2521, %2516
%2526 = add <4 x i32> %2524, %2517
%2527 = add nuw nsw i64 %2507, 16
%2528 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2527
%2529 = bitcast i32* %2528 to <4 x i32>*
%2530 = load <4 x i32>, <4 x i32>* %2529
%2531 = getelementptr inbounds i32, i32* %2528, i64 4
%2532 = bitcast i32* %2531 to <4 x i32>*
%2533 = load <4 x i32>, <4 x i32>* %2532
%2534 = add <4 x i32> %2530, %2525
%2535 = add <4 x i32> %2533, %2526
%2536 = add nuw nsw i64 %2507, 24
%2537 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2536
%2538 = bitcast i32* %2537 to <4 x i32>*
%2539 = load <4 x i32>, <4 x i32>* %2538
%2540 = getelementptr inbounds i32, i32* %2537, i64 4
%2541 = bitcast i32* %2540 to <4 x i32>*
%2542 = load <4 x i32>, <4 x i32>* %2541
%2543 = add <4 x i32> %2539, %2534
%2544 = add <4 x i32> %2542, %2535
%2545 = add nuw nsw i64 %2507, 32
%2546 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2545
%2547 = bitcast i32* %2546 to <4 x i32>*
%2548 = load <4 x i32>, <4 x i32>* %2547
%2549 = getelementptr inbounds i32, i32* %2546, i64 4
%2550 = bitcast i32* %2549 to <4 x i32>*
%2551 = load <4 x i32>, <4 x i32>* %2550
%2552 = add <4 x i32> %2548, %2543
%2553 = add <4 x i32> %2551, %2544
%2554 = add nuw nsw i64 %2507, 40
%2555 = icmp eq i64 %2554, 10240
br i1 %2555, label %2556, label %2506
2556: ; preds = %2506
%2557 = add <4 x i32> %2553, %2552
%2558 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2557)
%2559 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 2, i32 %2558)
br label %2645
2560: ; preds = %2560, %2471
%2561 = phi i64 [ 0, %2471 ], [ %2586, %2560 ]
%2562 = load volatile i32, i32* %6
%2563 = trunc i64 %2561 to i32
%2564 = mul nsw i32 %2562, %2563
%2565 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2561
store i32 %2564, i32* %2565
%2566 = add nuw nsw i64 %2561, 1
%2567 = load volatile i32, i32* %6
%2568 = trunc i64 %2566 to i32
%2569 = mul nsw i32 %2567, %2568
%2570 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2566
store i32 %2569, i32* %2570
%2571 = add nuw nsw i64 %2561, 2
%2572 = load volatile i32, i32* %6
%2573 = trunc i64 %2571 to i32
%2574 = mul nsw i32 %2572, %2573
%2575 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2571
store i32 %2574, i32* %2575
%2576 = add nuw nsw i64 %2561, 3
%2577 = load volatile i32, i32* %6
%2578 = trunc i64 %2576 to i32
%2579 = mul nsw i32 %2577, %2578
%2580 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2576
store i32 %2579, i32* %2580
%2581 = add nuw nsw i64 %2561, 4
%2582 = load volatile i32, i32* %6
%2583 = trunc i64 %2581 to i32
%2584 = mul nsw i32 %2582, %2583
%2585 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2581
store i32 %2584, i32* %2585
%2586 = add nuw nsw i64 %2561, 5
%2587 = icmp eq i64 %2586, 10240
br i1 %2587, label %2503, label %2560
2588: ; preds = %2645
%2589 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 3
%2590 = bitcast i32* %2589 to i8*
br label %2591
2591: ; preds = %2591, %2588
%2592 = phi i64 [ 0, %2588 ], [ %2639, %2591 ]
%2593 = phi <4 x i32> [ zeroinitializer, %2588 ], [ %2637, %2591 ]
%2594 = phi <4 x i32> [ zeroinitializer, %2588 ], [ %2638, %2591 ]
%2595 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2592
%2596 = bitcast i32* %2595 to <4 x i32>*
%2597 = load <4 x i32>, <4 x i32>* %2596
%2598 = getelementptr inbounds i32, i32* %2595, i64 4
%2599 = bitcast i32* %2598 to <4 x i32>*
%2600 = load <4 x i32>, <4 x i32>* %2599
%2601 = add <4 x i32> %2597, %2593
%2602 = add <4 x i32> %2600, %2594
%2603 = add nuw nsw i64 %2592, 8
%2604 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2603
%2605 = bitcast i32* %2604 to <4 x i32>*
%2606 = load <4 x i32>, <4 x i32>* %2605
%2607 = getelementptr inbounds i32, i32* %2604, i64 4
%2608 = bitcast i32* %2607 to <4 x i32>*
%2609 = load <4 x i32>, <4 x i32>* %2608
%2610 = add <4 x i32> %2606, %2601
%2611 = add <4 x i32> %2609, %2602
%2612 = add nuw nsw i64 %2592, 16
%2613 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2612
%2614 = bitcast i32* %2613 to <4 x i32>*
%2615 = load <4 x i32>, <4 x i32>* %2614
%2616 = getelementptr inbounds i32, i32* %2613, i64 4
%2617 = bitcast i32* %2616 to <4 x i32>*
%2618 = load <4 x i32>, <4 x i32>* %2617
%2619 = add <4 x i32> %2615, %2610
%2620 = add <4 x i32> %2618, %2611
%2621 = add nuw nsw i64 %2592, 24
%2622 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2621
%2623 = bitcast i32* %2622 to <4 x i32>*
%2624 = load <4 x i32>, <4 x i32>* %2623
%2625 = getelementptr inbounds i32, i32* %2622, i64 4
%2626 = bitcast i32* %2625 to <4 x i32>*
%2627 = load <4 x i32>, <4 x i32>* %2626
%2628 = add <4 x i32> %2624, %2619
%2629 = add <4 x i32> %2627, %2620
%2630 = add nuw nsw i64 %2592, 32
%2631 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2630
%2632 = bitcast i32* %2631 to <4 x i32>*
%2633 = load <4 x i32>, <4 x i32>* %2632
%2634 = getelementptr inbounds i32, i32* %2631, i64 4
%2635 = bitcast i32* %2634 to <4 x i32>*
%2636 = load <4 x i32>, <4 x i32>* %2635
%2637 = add <4 x i32> %2633, %2628
%2638 = add <4 x i32> %2636, %2629
%2639 = add nuw nsw i64 %2592, 40
%2640 = icmp eq i64 %2639, 10240
br i1 %2640, label %2641, label %2591
2641: ; preds = %2591
%2642 = add <4 x i32> %2638, %2637
%2643 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2642)
%2644 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 3, i32 %2643)
br label %2730
2645: ; preds = %2645, %2556
%2646 = phi i64 [ 0, %2556 ], [ %2671, %2645 ]
%2647 = load volatile i32, i32* %6
%2648 = trunc i64 %2646 to i32
%2649 = mul nsw i32 %2647, %2648
%2650 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2646
store i32 %2649, i32* %2650
%2651 = add nuw nsw i64 %2646, 1
%2652 = load volatile i32, i32* %6
%2653 = trunc i64 %2651 to i32
%2654 = mul nsw i32 %2652, %2653
%2655 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2651
store i32 %2654, i32* %2655
%2656 = add nuw nsw i64 %2646, 2
%2657 = load volatile i32, i32* %6
%2658 = trunc i64 %2656 to i32
%2659 = mul nsw i32 %2657, %2658
%2660 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2656
store i32 %2659, i32* %2660
%2661 = add nuw nsw i64 %2646, 3
%2662 = load volatile i32, i32* %6
%2663 = trunc i64 %2661 to i32
%2664 = mul nsw i32 %2662, %2663
%2665 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2661
store i32 %2664, i32* %2665
%2666 = add nuw nsw i64 %2646, 4
%2667 = load volatile i32, i32* %6
%2668 = trunc i64 %2666 to i32
%2669 = mul nsw i32 %2667, %2668
%2670 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2666
store i32 %2669, i32* %2670
%2671 = add nuw nsw i64 %2646, 5
%2672 = icmp eq i64 %2671, 10240
br i1 %2672, label %2588, label %2645
2673: ; preds = %2730
%2674 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 4
store i32 -1515870811, i32* %2674
br label %2675
2675: ; preds = %2675, %2673
%2676 = phi i64 [ 0, %2673 ], [ %2723, %2675 ]
%2677 = phi <4 x i32> [ zeroinitializer, %2673 ], [ %2721, %2675 ]
%2678 = phi <4 x i32> [ zeroinitializer, %2673 ], [ %2722, %2675 ]
%2679 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2676
%2680 = bitcast i32* %2679 to <4 x i32>*
%2681 = load <4 x i32>, <4 x i32>* %2680
%2682 = getelementptr inbounds i32, i32* %2679, i64 4
%2683 = bitcast i32* %2682 to <4 x i32>*
%2684 = load <4 x i32>, <4 x i32>* %2683
%2685 = add <4 x i32> %2681, %2677
%2686 = add <4 x i32> %2684, %2678
%2687 = add nuw nsw i64 %2676, 8
%2688 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2687
%2689 = bitcast i32* %2688 to <4 x i32>*
%2690 = load <4 x i32>, <4 x i32>* %2689
%2691 = getelementptr inbounds i32, i32* %2688, i64 4
%2692 = bitcast i32* %2691 to <4 x i32>*
%2693 = load <4 x i32>, <4 x i32>* %2692
%2694 = add <4 x i32> %2690, %2685
%2695 = add <4 x i32> %2693, %2686
%2696 = add nuw nsw i64 %2676, 16
%2697 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2696
%2698 = bitcast i32* %2697 to <4 x i32>*
%2699 = load <4 x i32>, <4 x i32>* %2698
%2700 = getelementptr inbounds i32, i32* %2697, i64 4
%2701 = bitcast i32* %2700 to <4 x i32>*
%2702 = load <4 x i32>, <4 x i32>* %2701
%2703 = add <4 x i32> %2699, %2694
%2704 = add <4 x i32> %2702, %2695
%2705 = add nuw nsw i64 %2676, 24
%2706 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2705
%2707 = bitcast i32* %2706 to <4 x i32>*
%2708 = load <4 x i32>, <4 x i32>* %2707
%2709 = getelementptr inbounds i32, i32* %2706, i64 4
%2710 = bitcast i32* %2709 to <4 x i32>*
%2711 = load <4 x i32>, <4 x i32>* %2710
%2712 = add <4 x i32> %2708, %2703
%2713 = add <4 x i32> %2711, %2704
%2714 = add nuw nsw i64 %2676, 32
%2715 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2714
%2716 = bitcast i32* %2715 to <4 x i32>*
%2717 = load <4 x i32>, <4 x i32>* %2716
%2718 = getelementptr inbounds i32, i32* %2715, i64 4
%2719 = bitcast i32* %2718 to <4 x i32>*
%2720 = load <4 x i32>, <4 x i32>* %2719
%2721 = add <4 x i32> %2717, %2712
%2722 = add <4 x i32> %2720, %2713
%2723 = add nuw nsw i64 %2676, 40
%2724 = icmp eq i64 %2723, 10240
br i1 %2724, label %2725, label %2675
2725: ; preds = %2675
%2726 = add <4 x i32> %2722, %2721
%2727 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2726)
%2728 = bitcast i32* %2504 to i8*
%2729 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 4, i32 %2727)
br label %2815
2730: ; preds = %2730, %2641
%2731 = phi i64 [ 0, %2641 ], [ %2756, %2730 ]
%2732 = load volatile i32, i32* %6
%2733 = trunc i64 %2731 to i32
%2734 = mul nsw i32 %2732, %2733
%2735 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2731
store i32 %2734, i32* %2735
%2736 = add nuw nsw i64 %2731, 1
%2737 = load volatile i32, i32* %6
%2738 = trunc i64 %2736 to i32
%2739 = mul nsw i32 %2737, %2738
%2740 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2736
store i32 %2739, i32* %2740
%2741 = add nuw nsw i64 %2731, 2
%2742 = load volatile i32, i32* %6
%2743 = trunc i64 %2741 to i32
%2744 = mul nsw i32 %2742, %2743
%2745 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2741
store i32 %2744, i32* %2745
%2746 = add nuw nsw i64 %2731, 3
%2747 = load volatile i32, i32* %6
%2748 = trunc i64 %2746 to i32
%2749 = mul nsw i32 %2747, %2748
%2750 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2746
store i32 %2749, i32* %2750
%2751 = add nuw nsw i64 %2731, 4
%2752 = load volatile i32, i32* %6
%2753 = trunc i64 %2751 to i32
%2754 = mul nsw i32 %2752, %2753
%2755 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2751
store i32 %2754, i32* %2755
%2756 = add nuw nsw i64 %2731, 5
%2757 = icmp eq i64 %2756, 10240
br i1 %2757, label %2673, label %2730
2758: ; preds = %2815
%2759 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 5
%2760 = bitcast i32* %2759 to i8*
br label %2761
2761: ; preds = %2761, %2758
%2762 = phi i64 [ 0, %2758 ], [ %2809, %2761 ]
%2763 = phi <4 x i32> [ zeroinitializer, %2758 ], [ %2807, %2761 ]
%2764 = phi <4 x i32> [ zeroinitializer, %2758 ], [ %2808, %2761 ]
%2765 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2762
%2766 = bitcast i32* %2765 to <4 x i32>*
%2767 = load <4 x i32>, <4 x i32>* %2766
%2768 = getelementptr inbounds i32, i32* %2765, i64 4
%2769 = bitcast i32* %2768 to <4 x i32>*
%2770 = load <4 x i32>, <4 x i32>* %2769
%2771 = add <4 x i32> %2767, %2763
%2772 = add <4 x i32> %2770, %2764
%2773 = add nuw nsw i64 %2762, 8
%2774 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2773
%2775 = bitcast i32* %2774 to <4 x i32>*
%2776 = load <4 x i32>, <4 x i32>* %2775
%2777 = getelementptr inbounds i32, i32* %2774, i64 4
%2778 = bitcast i32* %2777 to <4 x i32>*
%2779 = load <4 x i32>, <4 x i32>* %2778
%2780 = add <4 x i32> %2776, %2771
%2781 = add <4 x i32> %2779, %2772
%2782 = add nuw nsw i64 %2762, 16
%2783 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2782
%2784 = bitcast i32* %2783 to <4 x i32>*
%2785 = load <4 x i32>, <4 x i32>* %2784
%2786 = getelementptr inbounds i32, i32* %2783, i64 4
%2787 = bitcast i32* %2786 to <4 x i32>*
%2788 = load <4 x i32>, <4 x i32>* %2787
%2789 = add <4 x i32> %2785, %2780
%2790 = add <4 x i32> %2788, %2781
%2791 = add nuw nsw i64 %2762, 24
%2792 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2791
%2793 = bitcast i32* %2792 to <4 x i32>*
%2794 = load <4 x i32>, <4 x i32>* %2793
%2795 = getelementptr inbounds i32, i32* %2792, i64 4
%2796 = bitcast i32* %2795 to <4 x i32>*
%2797 = load <4 x i32>, <4 x i32>* %2796
%2798 = add <4 x i32> %2794, %2789
%2799 = add <4 x i32> %2797, %2790
%2800 = add nuw nsw i64 %2762, 32
%2801 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2800
%2802 = bitcast i32* %2801 to <4 x i32>*
%2803 = load <4 x i32>, <4 x i32>* %2802
%2804 = getelementptr inbounds i32, i32* %2801, i64 4
%2805 = bitcast i32* %2804 to <4 x i32>*
%2806 = load <4 x i32>, <4 x i32>* %2805
%2807 = add <4 x i32> %2803, %2798
%2808 = add <4 x i32> %2806, %2799
%2809 = add nuw nsw i64 %2762, 40
%2810 = icmp eq i64 %2809, 10240
br i1 %2810, label %2811, label %2761
2811: ; preds = %2761
%2812 = add <4 x i32> %2808, %2807
%2813 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2812)
%2814 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 5, i32 %2813)
br label %2900
2815: ; preds = %2815, %2725
%2816 = phi i64 [ 0, %2725 ], [ %2841, %2815 ]
%2817 = load volatile i32, i32* %6
%2818 = trunc i64 %2816 to i32
%2819 = mul nsw i32 %2817, %2818
%2820 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2816
store i32 %2819, i32* %2820
%2821 = add nuw nsw i64 %2816, 1
%2822 = load volatile i32, i32* %6
%2823 = trunc i64 %2821 to i32
%2824 = mul nsw i32 %2822, %2823
%2825 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2821
store i32 %2824, i32* %2825
%2826 = add nuw nsw i64 %2816, 2
%2827 = load volatile i32, i32* %6
%2828 = trunc i64 %2826 to i32
%2829 = mul nsw i32 %2827, %2828
%2830 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2826
store i32 %2829, i32* %2830
%2831 = add nuw nsw i64 %2816, 3
%2832 = load volatile i32, i32* %6
%2833 = trunc i64 %2831 to i32
%2834 = mul nsw i32 %2832, %2833
%2835 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2831
store i32 %2834, i32* %2835
%2836 = add nuw nsw i64 %2816, 4
%2837 = load volatile i32, i32* %6
%2838 = trunc i64 %2836 to i32
%2839 = mul nsw i32 %2837, %2838
%2840 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2836
store i32 %2839, i32* %2840
%2841 = add nuw nsw i64 %2816, 5
%2842 = icmp eq i64 %2841, 10240
br i1 %2842, label %2758, label %2815
2843: ; preds = %2900
%2844 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 6
%2845 = bitcast i32* %2844 to i8*
br label %2846
2846: ; preds = %2846, %2843
%2847 = phi i64 [ 0, %2843 ], [ %2894, %2846 ]
%2848 = phi <4 x i32> [ zeroinitializer, %2843 ], [ %2892, %2846 ]
%2849 = phi <4 x i32> [ zeroinitializer, %2843 ], [ %2893, %2846 ]
%2850 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2847
%2851 = bitcast i32* %2850 to <4 x i32>*
%2852 = load <4 x i32>, <4 x i32>* %2851
%2853 = getelementptr inbounds i32, i32* %2850, i64 4
%2854 = bitcast i32* %2853 to <4 x i32>*
%2855 = load <4 x i32>, <4 x i32>* %2854
%2856 = add <4 x i32> %2852, %2848
%2857 = add <4 x i32> %2855, %2849
%2858 = add nuw nsw i64 %2847, 8
%2859 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2858
%2860 = bitcast i32* %2859 to <4 x i32>*
%2861 = load <4 x i32>, <4 x i32>* %2860
%2862 = getelementptr inbounds i32, i32* %2859, i64 4
%2863 = bitcast i32* %2862 to <4 x i32>*
%2864 = load <4 x i32>, <4 x i32>* %2863
%2865 = add <4 x i32> %2861, %2856
%2866 = add <4 x i32> %2864, %2857
%2867 = add nuw nsw i64 %2847, 16
%2868 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2867
%2869 = bitcast i32* %2868 to <4 x i32>*
%2870 = load <4 x i32>, <4 x i32>* %2869
%2871 = getelementptr inbounds i32, i32* %2868, i64 4
%2872 = bitcast i32* %2871 to <4 x i32>*
%2873 = load <4 x i32>, <4 x i32>* %2872
%2874 = add <4 x i32> %2870, %2865
%2875 = add <4 x i32> %2873, %2866
%2876 = add nuw nsw i64 %2847, 24
%2877 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2876
%2878 = bitcast i32* %2877 to <4 x i32>*
%2879 = load <4 x i32>, <4 x i32>* %2878
%2880 = getelementptr inbounds i32, i32* %2877, i64 4
%2881 = bitcast i32* %2880 to <4 x i32>*
%2882 = load <4 x i32>, <4 x i32>* %2881
%2883 = add <4 x i32> %2879, %2874
%2884 = add <4 x i32> %2882, %2875
%2885 = add nuw nsw i64 %2847, 32
%2886 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2885
%2887 = bitcast i32* %2886 to <4 x i32>*
%2888 = load <4 x i32>, <4 x i32>* %2887
%2889 = getelementptr inbounds i32, i32* %2886, i64 4
%2890 = bitcast i32* %2889 to <4 x i32>*
%2891 = load <4 x i32>, <4 x i32>* %2890
%2892 = add <4 x i32> %2888, %2883
%2893 = add <4 x i32> %2891, %2884
%2894 = add nuw nsw i64 %2847, 40
%2895 = icmp eq i64 %2894, 10240
br i1 %2895, label %2896, label %2846
2896: ; preds = %2846
%2897 = add <4 x i32> %2893, %2892
%2898 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2897)
%2899 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 6, i32 %2898)
br label %2985
2900: ; preds = %2900, %2811
%2901 = phi i64 [ 0, %2811 ], [ %2926, %2900 ]
%2902 = load volatile i32, i32* %6
%2903 = trunc i64 %2901 to i32
%2904 = mul nsw i32 %2902, %2903
%2905 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2901
store i32 %2904, i32* %2905
%2906 = add nuw nsw i64 %2901, 1
%2907 = load volatile i32, i32* %6
%2908 = trunc i64 %2906 to i32
%2909 = mul nsw i32 %2907, %2908
%2910 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2906
store i32 %2909, i32* %2910
%2911 = add nuw nsw i64 %2901, 2
%2912 = load volatile i32, i32* %6
%2913 = trunc i64 %2911 to i32
%2914 = mul nsw i32 %2912, %2913
%2915 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2911
store i32 %2914, i32* %2915
%2916 = add nuw nsw i64 %2901, 3
%2917 = load volatile i32, i32* %6
%2918 = trunc i64 %2916 to i32
%2919 = mul nsw i32 %2917, %2918
%2920 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2916
store i32 %2919, i32* %2920
%2921 = add nuw nsw i64 %2901, 4
%2922 = load volatile i32, i32* %6
%2923 = trunc i64 %2921 to i32
%2924 = mul nsw i32 %2922, %2923
%2925 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2921
store i32 %2924, i32* %2925
%2926 = add nuw nsw i64 %2901, 5
%2927 = icmp eq i64 %2926, 10240
br i1 %2927, label %2843, label %2900
2928: ; preds = %2985
%2929 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 7
%2930 = bitcast i32* %2929 to i8*
br label %2931
2931: ; preds = %2931, %2928
%2932 = phi i64 [ 0, %2928 ], [ %2979, %2931 ]
%2933 = phi <4 x i32> [ zeroinitializer, %2928 ], [ %2977, %2931 ]
%2934 = phi <4 x i32> [ zeroinitializer, %2928 ], [ %2978, %2931 ]
%2935 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2932
%2936 = bitcast i32* %2935 to <4 x i32>*
%2937 = load <4 x i32>, <4 x i32>* %2936
%2938 = getelementptr inbounds i32, i32* %2935, i64 4
%2939 = bitcast i32* %2938 to <4 x i32>*
%2940 = load <4 x i32>, <4 x i32>* %2939
%2941 = add <4 x i32> %2937, %2933
%2942 = add <4 x i32> %2940, %2934
%2943 = add nuw nsw i64 %2932, 8
%2944 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2943
%2945 = bitcast i32* %2944 to <4 x i32>*
%2946 = load <4 x i32>, <4 x i32>* %2945
%2947 = getelementptr inbounds i32, i32* %2944, i64 4
%2948 = bitcast i32* %2947 to <4 x i32>*
%2949 = load <4 x i32>, <4 x i32>* %2948
%2950 = add <4 x i32> %2946, %2941
%2951 = add <4 x i32> %2949, %2942
%2952 = add nuw nsw i64 %2932, 16
%2953 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2952
%2954 = bitcast i32* %2953 to <4 x i32>*
%2955 = load <4 x i32>, <4 x i32>* %2954
%2956 = getelementptr inbounds i32, i32* %2953, i64 4
%2957 = bitcast i32* %2956 to <4 x i32>*
%2958 = load <4 x i32>, <4 x i32>* %2957
%2959 = add <4 x i32> %2955, %2950
%2960 = add <4 x i32> %2958, %2951
%2961 = add nuw nsw i64 %2932, 24
%2962 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2961
%2963 = bitcast i32* %2962 to <4 x i32>*
%2964 = load <4 x i32>, <4 x i32>* %2963
%2965 = getelementptr inbounds i32, i32* %2962, i64 4
%2966 = bitcast i32* %2965 to <4 x i32>*
%2967 = load <4 x i32>, <4 x i32>* %2966
%2968 = add <4 x i32> %2964, %2959
%2969 = add <4 x i32> %2967, %2960
%2970 = add nuw nsw i64 %2932, 32
%2971 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2970
%2972 = bitcast i32* %2971 to <4 x i32>*
%2973 = load <4 x i32>, <4 x i32>* %2972
%2974 = getelementptr inbounds i32, i32* %2971, i64 4
%2975 = bitcast i32* %2974 to <4 x i32>*
%2976 = load <4 x i32>, <4 x i32>* %2975
%2977 = add <4 x i32> %2973, %2968
%2978 = add <4 x i32> %2976, %2969
%2979 = add nuw nsw i64 %2932, 40
%2980 = icmp eq i64 %2979, 10240
br i1 %2980, label %2981, label %2931
2981: ; preds = %2931
%2982 = add <4 x i32> %2978, %2977
%2983 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %2982)
%2984 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 7, i32 %2983)
br label %3070
2985: ; preds = %2985, %2896
%2986 = phi i64 [ 0, %2896 ], [ %3011, %2985 ]
%2987 = load volatile i32, i32* %6
%2988 = trunc i64 %2986 to i32
%2989 = mul nsw i32 %2987, %2988
%2990 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2986
store i32 %2989, i32* %2990
%2991 = add nuw nsw i64 %2986, 1
%2992 = load volatile i32, i32* %6
%2993 = trunc i64 %2991 to i32
%2994 = mul nsw i32 %2992, %2993
%2995 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2991
store i32 %2994, i32* %2995
%2996 = add nuw nsw i64 %2986, 2
%2997 = load volatile i32, i32* %6
%2998 = trunc i64 %2996 to i32
%2999 = mul nsw i32 %2997, %2998
%3000 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %2996
store i32 %2999, i32* %3000
%3001 = add nuw nsw i64 %2986, 3
%3002 = load volatile i32, i32* %6
%3003 = trunc i64 %3001 to i32
%3004 = mul nsw i32 %3002, %3003
%3005 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3001
store i32 %3004, i32* %3005
%3006 = add nuw nsw i64 %2986, 4
%3007 = load volatile i32, i32* %6
%3008 = trunc i64 %3006 to i32
%3009 = mul nsw i32 %3007, %3008
%3010 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3006
store i32 %3009, i32* %3010
%3011 = add nuw nsw i64 %2986, 5
%3012 = icmp eq i64 %3011, 10240
br i1 %3012, label %2928, label %2985
3013: ; preds = %3070
%3014 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 8
%3015 = bitcast i32* %3014 to i64*
store i64 -6510615555426900571, i64* %3015
br label %3016
3016: ; preds = %3016, %3013
%3017 = phi i64 [ 0, %3013 ], [ %3064, %3016 ]
%3018 = phi <4 x i32> [ zeroinitializer, %3013 ], [ %3062, %3016 ]
%3019 = phi <4 x i32> [ zeroinitializer, %3013 ], [ %3063, %3016 ]
%3020 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3017
%3021 = bitcast i32* %3020 to <4 x i32>*
%3022 = load <4 x i32>, <4 x i32>* %3021
%3023 = getelementptr inbounds i32, i32* %3020, i64 4
%3024 = bitcast i32* %3023 to <4 x i32>*
%3025 = load <4 x i32>, <4 x i32>* %3024
%3026 = add <4 x i32> %3022, %3018
%3027 = add <4 x i32> %3025, %3019
%3028 = add nuw nsw i64 %3017, 8
%3029 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3028
%3030 = bitcast i32* %3029 to <4 x i32>*
%3031 = load <4 x i32>, <4 x i32>* %3030
%3032 = getelementptr inbounds i32, i32* %3029, i64 4
%3033 = bitcast i32* %3032 to <4 x i32>*
%3034 = load <4 x i32>, <4 x i32>* %3033
%3035 = add <4 x i32> %3031, %3026
%3036 = add <4 x i32> %3034, %3027
%3037 = add nuw nsw i64 %3017, 16
%3038 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3037
%3039 = bitcast i32* %3038 to <4 x i32>*
%3040 = load <4 x i32>, <4 x i32>* %3039
%3041 = getelementptr inbounds i32, i32* %3038, i64 4
%3042 = bitcast i32* %3041 to <4 x i32>*
%3043 = load <4 x i32>, <4 x i32>* %3042
%3044 = add <4 x i32> %3040, %3035
%3045 = add <4 x i32> %3043, %3036
%3046 = add nuw nsw i64 %3017, 24
%3047 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3046
%3048 = bitcast i32* %3047 to <4 x i32>*
%3049 = load <4 x i32>, <4 x i32>* %3048
%3050 = getelementptr inbounds i32, i32* %3047, i64 4
%3051 = bitcast i32* %3050 to <4 x i32>*
%3052 = load <4 x i32>, <4 x i32>* %3051
%3053 = add <4 x i32> %3049, %3044
%3054 = add <4 x i32> %3052, %3045
%3055 = add nuw nsw i64 %3017, 32
%3056 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3055
%3057 = bitcast i32* %3056 to <4 x i32>*
%3058 = load <4 x i32>, <4 x i32>* %3057
%3059 = getelementptr inbounds i32, i32* %3056, i64 4
%3060 = bitcast i32* %3059 to <4 x i32>*
%3061 = load <4 x i32>, <4 x i32>* %3060
%3062 = add <4 x i32> %3058, %3053
%3063 = add <4 x i32> %3061, %3054
%3064 = add nuw nsw i64 %3017, 40
%3065 = icmp eq i64 %3064, 10240
br i1 %3065, label %3066, label %3016
3066: ; preds = %3016
%3067 = add <4 x i32> %3063, %3062
%3068 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3067)
%3069 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 8, i32 %3068)
br label %3155
3070: ; preds = %3070, %2981
%3071 = phi i64 [ 0, %2981 ], [ %3096, %3070 ]
%3072 = load volatile i32, i32* %6
%3073 = trunc i64 %3071 to i32
%3074 = mul nsw i32 %3072, %3073
%3075 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3071
store i32 %3074, i32* %3075
%3076 = add nuw nsw i64 %3071, 1
%3077 = load volatile i32, i32* %6
%3078 = trunc i64 %3076 to i32
%3079 = mul nsw i32 %3077, %3078
%3080 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3076
store i32 %3079, i32* %3080
%3081 = add nuw nsw i64 %3071, 2
%3082 = load volatile i32, i32* %6
%3083 = trunc i64 %3081 to i32
%3084 = mul nsw i32 %3082, %3083
%3085 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3081
store i32 %3084, i32* %3085
%3086 = add nuw nsw i64 %3071, 3
%3087 = load volatile i32, i32* %6
%3088 = trunc i64 %3086 to i32
%3089 = mul nsw i32 %3087, %3088
%3090 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3086
store i32 %3089, i32* %3090
%3091 = add nuw nsw i64 %3071, 4
%3092 = load volatile i32, i32* %6
%3093 = trunc i64 %3091 to i32
%3094 = mul nsw i32 %3092, %3093
%3095 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3091
store i32 %3094, i32* %3095
%3096 = add nuw nsw i64 %3071, 5
%3097 = icmp eq i64 %3096, 10240
br i1 %3097, label %3013, label %3070
3098: ; preds = %3155
%3099 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 9
%3100 = bitcast i32* %3099 to i8*
br label %3101
3101: ; preds = %3101, %3098
%3102 = phi i64 [ 0, %3098 ], [ %3149, %3101 ]
%3103 = phi <4 x i32> [ zeroinitializer, %3098 ], [ %3147, %3101 ]
%3104 = phi <4 x i32> [ zeroinitializer, %3098 ], [ %3148, %3101 ]
%3105 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3102
%3106 = bitcast i32* %3105 to <4 x i32>*
%3107 = load <4 x i32>, <4 x i32>* %3106
%3108 = getelementptr inbounds i32, i32* %3105, i64 4
%3109 = bitcast i32* %3108 to <4 x i32>*
%3110 = load <4 x i32>, <4 x i32>* %3109
%3111 = add <4 x i32> %3107, %3103
%3112 = add <4 x i32> %3110, %3104
%3113 = add nuw nsw i64 %3102, 8
%3114 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3113
%3115 = bitcast i32* %3114 to <4 x i32>*
%3116 = load <4 x i32>, <4 x i32>* %3115
%3117 = getelementptr inbounds i32, i32* %3114, i64 4
%3118 = bitcast i32* %3117 to <4 x i32>*
%3119 = load <4 x i32>, <4 x i32>* %3118
%3120 = add <4 x i32> %3116, %3111
%3121 = add <4 x i32> %3119, %3112
%3122 = add nuw nsw i64 %3102, 16
%3123 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3122
%3124 = bitcast i32* %3123 to <4 x i32>*
%3125 = load <4 x i32>, <4 x i32>* %3124
%3126 = getelementptr inbounds i32, i32* %3123, i64 4
%3127 = bitcast i32* %3126 to <4 x i32>*
%3128 = load <4 x i32>, <4 x i32>* %3127
%3129 = add <4 x i32> %3125, %3120
%3130 = add <4 x i32> %3128, %3121
%3131 = add nuw nsw i64 %3102, 24
%3132 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3131
%3133 = bitcast i32* %3132 to <4 x i32>*
%3134 = load <4 x i32>, <4 x i32>* %3133
%3135 = getelementptr inbounds i32, i32* %3132, i64 4
%3136 = bitcast i32* %3135 to <4 x i32>*
%3137 = load <4 x i32>, <4 x i32>* %3136
%3138 = add <4 x i32> %3134, %3129
%3139 = add <4 x i32> %3137, %3130
%3140 = add nuw nsw i64 %3102, 32
%3141 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3140
%3142 = bitcast i32* %3141 to <4 x i32>*
%3143 = load <4 x i32>, <4 x i32>* %3142
%3144 = getelementptr inbounds i32, i32* %3141, i64 4
%3145 = bitcast i32* %3144 to <4 x i32>*
%3146 = load <4 x i32>, <4 x i32>* %3145
%3147 = add <4 x i32> %3143, %3138
%3148 = add <4 x i32> %3146, %3139
%3149 = add nuw nsw i64 %3102, 40
%3150 = icmp eq i64 %3149, 10240
br i1 %3150, label %3151, label %3101
3151: ; preds = %3101
%3152 = add <4 x i32> %3148, %3147
%3153 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3152)
%3154 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 9, i32 %3153)
br label %3240
3155: ; preds = %3155, %3066
%3156 = phi i64 [ 0, %3066 ], [ %3181, %3155 ]
%3157 = load volatile i32, i32* %6
%3158 = trunc i64 %3156 to i32
%3159 = mul nsw i32 %3157, %3158
%3160 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3156
store i32 %3159, i32* %3160
%3161 = add nuw nsw i64 %3156, 1
%3162 = load volatile i32, i32* %6
%3163 = trunc i64 %3161 to i32
%3164 = mul nsw i32 %3162, %3163
%3165 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3161
store i32 %3164, i32* %3165
%3166 = add nuw nsw i64 %3156, 2
%3167 = load volatile i32, i32* %6
%3168 = trunc i64 %3166 to i32
%3169 = mul nsw i32 %3167, %3168
%3170 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3166
store i32 %3169, i32* %3170
%3171 = add nuw nsw i64 %3156, 3
%3172 = load volatile i32, i32* %6
%3173 = trunc i64 %3171 to i32
%3174 = mul nsw i32 %3172, %3173
%3175 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3171
store i32 %3174, i32* %3175
%3176 = add nuw nsw i64 %3156, 4
%3177 = load volatile i32, i32* %6
%3178 = trunc i64 %3176 to i32
%3179 = mul nsw i32 %3177, %3178
%3180 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3176
store i32 %3179, i32* %3180
%3181 = add nuw nsw i64 %3156, 5
%3182 = icmp eq i64 %3181, 10240
br i1 %3182, label %3098, label %3155
3183: ; preds = %3240
%3184 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 10
%3185 = bitcast i32* %3184 to i8*
br label %3186
3186: ; preds = %3186, %3183
%3187 = phi i64 [ 0, %3183 ], [ %3234, %3186 ]
%3188 = phi <4 x i32> [ zeroinitializer, %3183 ], [ %3232, %3186 ]
%3189 = phi <4 x i32> [ zeroinitializer, %3183 ], [ %3233, %3186 ]
%3190 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3187
%3191 = bitcast i32* %3190 to <4 x i32>*
%3192 = load <4 x i32>, <4 x i32>* %3191
%3193 = getelementptr inbounds i32, i32* %3190, i64 4
%3194 = bitcast i32* %3193 to <4 x i32>*
%3195 = load <4 x i32>, <4 x i32>* %3194
%3196 = add <4 x i32> %3192, %3188
%3197 = add <4 x i32> %3195, %3189
%3198 = add nuw nsw i64 %3187, 8
%3199 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3198
%3200 = bitcast i32* %3199 to <4 x i32>*
%3201 = load <4 x i32>, <4 x i32>* %3200
%3202 = getelementptr inbounds i32, i32* %3199, i64 4
%3203 = bitcast i32* %3202 to <4 x i32>*
%3204 = load <4 x i32>, <4 x i32>* %3203
%3205 = add <4 x i32> %3201, %3196
%3206 = add <4 x i32> %3204, %3197
%3207 = add nuw nsw i64 %3187, 16
%3208 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3207
%3209 = bitcast i32* %3208 to <4 x i32>*
%3210 = load <4 x i32>, <4 x i32>* %3209
%3211 = getelementptr inbounds i32, i32* %3208, i64 4
%3212 = bitcast i32* %3211 to <4 x i32>*
%3213 = load <4 x i32>, <4 x i32>* %3212
%3214 = add <4 x i32> %3210, %3205
%3215 = add <4 x i32> %3213, %3206
%3216 = add nuw nsw i64 %3187, 24
%3217 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3216
%3218 = bitcast i32* %3217 to <4 x i32>*
%3219 = load <4 x i32>, <4 x i32>* %3218
%3220 = getelementptr inbounds i32, i32* %3217, i64 4
%3221 = bitcast i32* %3220 to <4 x i32>*
%3222 = load <4 x i32>, <4 x i32>* %3221
%3223 = add <4 x i32> %3219, %3214
%3224 = add <4 x i32> %3222, %3215
%3225 = add nuw nsw i64 %3187, 32
%3226 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3225
%3227 = bitcast i32* %3226 to <4 x i32>*
%3228 = load <4 x i32>, <4 x i32>* %3227
%3229 = getelementptr inbounds i32, i32* %3226, i64 4
%3230 = bitcast i32* %3229 to <4 x i32>*
%3231 = load <4 x i32>, <4 x i32>* %3230
%3232 = add <4 x i32> %3228, %3223
%3233 = add <4 x i32> %3231, %3224
%3234 = add nuw nsw i64 %3187, 40
%3235 = icmp eq i64 %3234, 10240
br i1 %3235, label %3236, label %3186
3236: ; preds = %3186
%3237 = add <4 x i32> %3233, %3232
%3238 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3237)
%3239 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 10, i32 %3238)
br label %3325
3240: ; preds = %3240, %3151
%3241 = phi i64 [ 0, %3151 ], [ %3266, %3240 ]
%3242 = load volatile i32, i32* %6
%3243 = trunc i64 %3241 to i32
%3244 = mul nsw i32 %3242, %3243
%3245 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3241
store i32 %3244, i32* %3245
%3246 = add nuw nsw i64 %3241, 1
%3247 = load volatile i32, i32* %6
%3248 = trunc i64 %3246 to i32
%3249 = mul nsw i32 %3247, %3248
%3250 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3246
store i32 %3249, i32* %3250
%3251 = add nuw nsw i64 %3241, 2
%3252 = load volatile i32, i32* %6
%3253 = trunc i64 %3251 to i32
%3254 = mul nsw i32 %3252, %3253
%3255 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3251
store i32 %3254, i32* %3255
%3256 = add nuw nsw i64 %3241, 3
%3257 = load volatile i32, i32* %6
%3258 = trunc i64 %3256 to i32
%3259 = mul nsw i32 %3257, %3258
%3260 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3256
store i32 %3259, i32* %3260
%3261 = add nuw nsw i64 %3241, 4
%3262 = load volatile i32, i32* %6
%3263 = trunc i64 %3261 to i32
%3264 = mul nsw i32 %3262, %3263
%3265 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3261
store i32 %3264, i32* %3265
%3266 = add nuw nsw i64 %3241, 5
%3267 = icmp eq i64 %3266, 10240
br i1 %3267, label %3183, label %3240
3268: ; preds = %3325
%3269 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 16
%3270 = bitcast i32* %3269 to i8*
br label %3271
3271: ; preds = %3271, %3268
%3272 = phi i64 [ 0, %3268 ], [ %3319, %3271 ]
%3273 = phi <4 x i32> [ zeroinitializer, %3268 ], [ %3317, %3271 ]
%3274 = phi <4 x i32> [ zeroinitializer, %3268 ], [ %3318, %3271 ]
%3275 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3272
%3276 = bitcast i32* %3275 to <4 x i32>*
%3277 = load <4 x i32>, <4 x i32>* %3276
%3278 = getelementptr inbounds i32, i32* %3275, i64 4
%3279 = bitcast i32* %3278 to <4 x i32>*
%3280 = load <4 x i32>, <4 x i32>* %3279
%3281 = add <4 x i32> %3277, %3273
%3282 = add <4 x i32> %3280, %3274
%3283 = add nuw nsw i64 %3272, 8
%3284 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3283
%3285 = bitcast i32* %3284 to <4 x i32>*
%3286 = load <4 x i32>, <4 x i32>* %3285
%3287 = getelementptr inbounds i32, i32* %3284, i64 4
%3288 = bitcast i32* %3287 to <4 x i32>*
%3289 = load <4 x i32>, <4 x i32>* %3288
%3290 = add <4 x i32> %3286, %3281
%3291 = add <4 x i32> %3289, %3282
%3292 = add nuw nsw i64 %3272, 16
%3293 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3292
%3294 = bitcast i32* %3293 to <4 x i32>*
%3295 = load <4 x i32>, <4 x i32>* %3294
%3296 = getelementptr inbounds i32, i32* %3293, i64 4
%3297 = bitcast i32* %3296 to <4 x i32>*
%3298 = load <4 x i32>, <4 x i32>* %3297
%3299 = add <4 x i32> %3295, %3290
%3300 = add <4 x i32> %3298, %3291
%3301 = add nuw nsw i64 %3272, 24
%3302 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3301
%3303 = bitcast i32* %3302 to <4 x i32>*
%3304 = load <4 x i32>, <4 x i32>* %3303
%3305 = getelementptr inbounds i32, i32* %3302, i64 4
%3306 = bitcast i32* %3305 to <4 x i32>*
%3307 = load <4 x i32>, <4 x i32>* %3306
%3308 = add <4 x i32> %3304, %3299
%3309 = add <4 x i32> %3307, %3300
%3310 = add nuw nsw i64 %3272, 32
%3311 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3310
%3312 = bitcast i32* %3311 to <4 x i32>*
%3313 = load <4 x i32>, <4 x i32>* %3312
%3314 = getelementptr inbounds i32, i32* %3311, i64 4
%3315 = bitcast i32* %3314 to <4 x i32>*
%3316 = load <4 x i32>, <4 x i32>* %3315
%3317 = add <4 x i32> %3313, %3308
%3318 = add <4 x i32> %3316, %3309
%3319 = add nuw nsw i64 %3272, 40
%3320 = icmp eq i64 %3319, 10240
br i1 %3320, label %3321, label %3271
3321: ; preds = %3271
%3322 = add <4 x i32> %3318, %3317
%3323 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3322)
%3324 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 16, i32 %3323)
br label %3410
3325: ; preds = %3325, %3236
%3326 = phi i64 [ 0, %3236 ], [ %3351, %3325 ]
%3327 = load volatile i32, i32* %6
%3328 = trunc i64 %3326 to i32
%3329 = mul nsw i32 %3327, %3328
%3330 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3326
store i32 %3329, i32* %3330
%3331 = add nuw nsw i64 %3326, 1
%3332 = load volatile i32, i32* %6
%3333 = trunc i64 %3331 to i32
%3334 = mul nsw i32 %3332, %3333
%3335 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3331
store i32 %3334, i32* %3335
%3336 = add nuw nsw i64 %3326, 2
%3337 = load volatile i32, i32* %6
%3338 = trunc i64 %3336 to i32
%3339 = mul nsw i32 %3337, %3338
%3340 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3336
store i32 %3339, i32* %3340
%3341 = add nuw nsw i64 %3326, 3
%3342 = load volatile i32, i32* %6
%3343 = trunc i64 %3341 to i32
%3344 = mul nsw i32 %3342, %3343
%3345 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3341
store i32 %3344, i32* %3345
%3346 = add nuw nsw i64 %3326, 4
%3347 = load volatile i32, i32* %6
%3348 = trunc i64 %3346 to i32
%3349 = mul nsw i32 %3347, %3348
%3350 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3346
store i32 %3349, i32* %3350
%3351 = add nuw nsw i64 %3326, 5
%3352 = icmp eq i64 %3351, 10240
br i1 %3352, label %3268, label %3325
3353: ; preds = %3410
%3354 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 15
%3355 = bitcast i32* %3354 to i8*
br label %3356
3356: ; preds = %3356, %3353
%3357 = phi i64 [ 0, %3353 ], [ %3404, %3356 ]
%3358 = phi <4 x i32> [ zeroinitializer, %3353 ], [ %3402, %3356 ]
%3359 = phi <4 x i32> [ zeroinitializer, %3353 ], [ %3403, %3356 ]
%3360 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3357
%3361 = bitcast i32* %3360 to <4 x i32>*
%3362 = load <4 x i32>, <4 x i32>* %3361
%3363 = getelementptr inbounds i32, i32* %3360, i64 4
%3364 = bitcast i32* %3363 to <4 x i32>*
%3365 = load <4 x i32>, <4 x i32>* %3364
%3366 = add <4 x i32> %3362, %3358
%3367 = add <4 x i32> %3365, %3359
%3368 = add nuw nsw i64 %3357, 8
%3369 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3368
%3370 = bitcast i32* %3369 to <4 x i32>*
%3371 = load <4 x i32>, <4 x i32>* %3370
%3372 = getelementptr inbounds i32, i32* %3369, i64 4
%3373 = bitcast i32* %3372 to <4 x i32>*
%3374 = load <4 x i32>, <4 x i32>* %3373
%3375 = add <4 x i32> %3371, %3366
%3376 = add <4 x i32> %3374, %3367
%3377 = add nuw nsw i64 %3357, 16
%3378 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3377
%3379 = bitcast i32* %3378 to <4 x i32>*
%3380 = load <4 x i32>, <4 x i32>* %3379
%3381 = getelementptr inbounds i32, i32* %3378, i64 4
%3382 = bitcast i32* %3381 to <4 x i32>*
%3383 = load <4 x i32>, <4 x i32>* %3382
%3384 = add <4 x i32> %3380, %3375
%3385 = add <4 x i32> %3383, %3376
%3386 = add nuw nsw i64 %3357, 24
%3387 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3386
%3388 = bitcast i32* %3387 to <4 x i32>*
%3389 = load <4 x i32>, <4 x i32>* %3388
%3390 = getelementptr inbounds i32, i32* %3387, i64 4
%3391 = bitcast i32* %3390 to <4 x i32>*
%3392 = load <4 x i32>, <4 x i32>* %3391
%3393 = add <4 x i32> %3389, %3384
%3394 = add <4 x i32> %3392, %3385
%3395 = add nuw nsw i64 %3357, 32
%3396 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3395
%3397 = bitcast i32* %3396 to <4 x i32>*
%3398 = load <4 x i32>, <4 x i32>* %3397
%3399 = getelementptr inbounds i32, i32* %3396, i64 4
%3400 = bitcast i32* %3399 to <4 x i32>*
%3401 = load <4 x i32>, <4 x i32>* %3400
%3402 = add <4 x i32> %3398, %3393
%3403 = add <4 x i32> %3401, %3394
%3404 = add nuw nsw i64 %3357, 40
%3405 = icmp eq i64 %3404, 10240
br i1 %3405, label %3406, label %3356
3406: ; preds = %3356
%3407 = add <4 x i32> %3403, %3402
%3408 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3407)
%3409 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 32, i32 %3408)
br label %3495
3410: ; preds = %3410, %3321
%3411 = phi i64 [ 0, %3321 ], [ %3436, %3410 ]
%3412 = load volatile i32, i32* %6
%3413 = trunc i64 %3411 to i32
%3414 = mul nsw i32 %3412, %3413
%3415 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3411
store i32 %3414, i32* %3415
%3416 = add nuw nsw i64 %3411, 1
%3417 = load volatile i32, i32* %6
%3418 = trunc i64 %3416 to i32
%3419 = mul nsw i32 %3417, %3418
%3420 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3416
store i32 %3419, i32* %3420
%3421 = add nuw nsw i64 %3411, 2
%3422 = load volatile i32, i32* %6
%3423 = trunc i64 %3421 to i32
%3424 = mul nsw i32 %3422, %3423
%3425 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3421
store i32 %3424, i32* %3425
%3426 = add nuw nsw i64 %3411, 3
%3427 = load volatile i32, i32* %6
%3428 = trunc i64 %3426 to i32
%3429 = mul nsw i32 %3427, %3428
%3430 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3426
store i32 %3429, i32* %3430
%3431 = add nuw nsw i64 %3411, 4
%3432 = load volatile i32, i32* %6
%3433 = trunc i64 %3431 to i32
%3434 = mul nsw i32 %3432, %3433
%3435 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3431
store i32 %3434, i32* %3435
%3436 = add nuw nsw i64 %3411, 5
%3437 = icmp eq i64 %3436, 10240
br i1 %3437, label %3353, label %3410
3438: ; preds = %3495
%3439 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 13
%3440 = bitcast i32* %3439 to i8*
br label %3441
3441: ; preds = %3441, %3438
%3442 = phi i64 [ 0, %3438 ], [ %3489, %3441 ]
%3443 = phi <4 x i32> [ zeroinitializer, %3438 ], [ %3487, %3441 ]
%3444 = phi <4 x i32> [ zeroinitializer, %3438 ], [ %3488, %3441 ]
%3445 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3442
%3446 = bitcast i32* %3445 to <4 x i32>*
%3447 = load <4 x i32>, <4 x i32>* %3446
%3448 = getelementptr inbounds i32, i32* %3445, i64 4
%3449 = bitcast i32* %3448 to <4 x i32>*
%3450 = load <4 x i32>, <4 x i32>* %3449
%3451 = add <4 x i32> %3447, %3443
%3452 = add <4 x i32> %3450, %3444
%3453 = add nuw nsw i64 %3442, 8
%3454 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3453
%3455 = bitcast i32* %3454 to <4 x i32>*
%3456 = load <4 x i32>, <4 x i32>* %3455
%3457 = getelementptr inbounds i32, i32* %3454, i64 4
%3458 = bitcast i32* %3457 to <4 x i32>*
%3459 = load <4 x i32>, <4 x i32>* %3458
%3460 = add <4 x i32> %3456, %3451
%3461 = add <4 x i32> %3459, %3452
%3462 = add nuw nsw i64 %3442, 16
%3463 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3462
%3464 = bitcast i32* %3463 to <4 x i32>*
%3465 = load <4 x i32>, <4 x i32>* %3464
%3466 = getelementptr inbounds i32, i32* %3463, i64 4
%3467 = bitcast i32* %3466 to <4 x i32>*
%3468 = load <4 x i32>, <4 x i32>* %3467
%3469 = add <4 x i32> %3465, %3460
%3470 = add <4 x i32> %3468, %3461
%3471 = add nuw nsw i64 %3442, 24
%3472 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3471
%3473 = bitcast i32* %3472 to <4 x i32>*
%3474 = load <4 x i32>, <4 x i32>* %3473
%3475 = getelementptr inbounds i32, i32* %3472, i64 4
%3476 = bitcast i32* %3475 to <4 x i32>*
%3477 = load <4 x i32>, <4 x i32>* %3476
%3478 = add <4 x i32> %3474, %3469
%3479 = add <4 x i32> %3477, %3470
%3480 = add nuw nsw i64 %3442, 32
%3481 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3480
%3482 = bitcast i32* %3481 to <4 x i32>*
%3483 = load <4 x i32>, <4 x i32>* %3482
%3484 = getelementptr inbounds i32, i32* %3481, i64 4
%3485 = bitcast i32* %3484 to <4 x i32>*
%3486 = load <4 x i32>, <4 x i32>* %3485
%3487 = add <4 x i32> %3483, %3478
%3488 = add <4 x i32> %3486, %3479
%3489 = add nuw nsw i64 %3442, 40
%3490 = icmp eq i64 %3489, 10240
br i1 %3490, label %3491, label %3441
3491: ; preds = %3441
%3492 = add <4 x i32> %3488, %3487
%3493 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3492)
%3494 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 64, i32 %3493)
br label %3578
3495: ; preds = %3495, %3406
%3496 = phi i64 [ 0, %3406 ], [ %3521, %3495 ]
%3497 = load volatile i32, i32* %6
%3498 = trunc i64 %3496 to i32
%3499 = mul nsw i32 %3497, %3498
%3500 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3496
store i32 %3499, i32* %3500
%3501 = add nuw nsw i64 %3496, 1
%3502 = load volatile i32, i32* %6
%3503 = trunc i64 %3501 to i32
%3504 = mul nsw i32 %3502, %3503
%3505 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3501
store i32 %3504, i32* %3505
%3506 = add nuw nsw i64 %3496, 2
%3507 = load volatile i32, i32* %6
%3508 = trunc i64 %3506 to i32
%3509 = mul nsw i32 %3507, %3508
%3510 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3506
store i32 %3509, i32* %3510
%3511 = add nuw nsw i64 %3496, 3
%3512 = load volatile i32, i32* %6
%3513 = trunc i64 %3511 to i32
%3514 = mul nsw i32 %3512, %3513
%3515 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3511
store i32 %3514, i32* %3515
%3516 = add nuw nsw i64 %3496, 4
%3517 = load volatile i32, i32* %6
%3518 = trunc i64 %3516 to i32
%3519 = mul nsw i32 %3517, %3518
%3520 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3516
store i32 %3519, i32* %3520
%3521 = add nuw nsw i64 %3496, 5
%3522 = icmp eq i64 %3521, 10240
br i1 %3522, label %3438, label %3495
3523: ; preds = %3578
br label %3524
3524: ; preds = %3524, %3523
%3525 = phi i64 [ 0, %3523 ], [ %3572, %3524 ]
%3526 = phi <4 x i32> [ zeroinitializer, %3523 ], [ %3570, %3524 ]
%3527 = phi <4 x i32> [ zeroinitializer, %3523 ], [ %3571, %3524 ]
%3528 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3525
%3529 = bitcast i32* %3528 to <4 x i32>*
%3530 = load <4 x i32>, <4 x i32>* %3529
%3531 = getelementptr inbounds i32, i32* %3528, i64 4
%3532 = bitcast i32* %3531 to <4 x i32>*
%3533 = load <4 x i32>, <4 x i32>* %3532
%3534 = add <4 x i32> %3530, %3526
%3535 = add <4 x i32> %3533, %3527
%3536 = add nuw nsw i64 %3525, 8
%3537 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3536
%3538 = bitcast i32* %3537 to <4 x i32>*
%3539 = load <4 x i32>, <4 x i32>* %3538
%3540 = getelementptr inbounds i32, i32* %3537, i64 4
%3541 = bitcast i32* %3540 to <4 x i32>*
%3542 = load <4 x i32>, <4 x i32>* %3541
%3543 = add <4 x i32> %3539, %3534
%3544 = add <4 x i32> %3542, %3535
%3545 = add nuw nsw i64 %3525, 16
%3546 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3545
%3547 = bitcast i32* %3546 to <4 x i32>*
%3548 = load <4 x i32>, <4 x i32>* %3547
%3549 = getelementptr inbounds i32, i32* %3546, i64 4
%3550 = bitcast i32* %3549 to <4 x i32>*
%3551 = load <4 x i32>, <4 x i32>* %3550
%3552 = add <4 x i32> %3548, %3543
%3553 = add <4 x i32> %3551, %3544
%3554 = add nuw nsw i64 %3525, 24
%3555 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3554
%3556 = bitcast i32* %3555 to <4 x i32>*
%3557 = load <4 x i32>, <4 x i32>* %3556
%3558 = getelementptr inbounds i32, i32* %3555, i64 4
%3559 = bitcast i32* %3558 to <4 x i32>*
%3560 = load <4 x i32>, <4 x i32>* %3559
%3561 = add <4 x i32> %3557, %3552
%3562 = add <4 x i32> %3560, %3553
%3563 = add nuw nsw i64 %3525, 32
%3564 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3563
%3565 = bitcast i32* %3564 to <4 x i32>*
%3566 = load <4 x i32>, <4 x i32>* %3565
%3567 = getelementptr inbounds i32, i32* %3564, i64 4
%3568 = bitcast i32* %3567 to <4 x i32>*
%3569 = load <4 x i32>, <4 x i32>* %3568
%3570 = add <4 x i32> %3566, %3561
%3571 = add <4 x i32> %3569, %3562
%3572 = add nuw nsw i64 %3525, 40
%3573 = icmp eq i64 %3572, 10240
br i1 %3573, label %3574, label %3524
3574: ; preds = %3524
%3575 = add <4 x i32> %3571, %3570
%3576 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3575)
%3577 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 128, i32 %3576)
br label %3661
3578: ; preds = %3578, %3491
%3579 = phi i64 [ 0, %3491 ], [ %3604, %3578 ]
%3580 = load volatile i32, i32* %6
%3581 = trunc i64 %3579 to i32
%3582 = mul nsw i32 %3580, %3581
%3583 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3579
store i32 %3582, i32* %3583
%3584 = add nuw nsw i64 %3579, 1
%3585 = load volatile i32, i32* %6
%3586 = trunc i64 %3584 to i32
%3587 = mul nsw i32 %3585, %3586
%3588 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3584
store i32 %3587, i32* %3588
%3589 = add nuw nsw i64 %3579, 2
%3590 = load volatile i32, i32* %6
%3591 = trunc i64 %3589 to i32
%3592 = mul nsw i32 %3590, %3591
%3593 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3589
store i32 %3592, i32* %3593
%3594 = add nuw nsw i64 %3579, 3
%3595 = load volatile i32, i32* %6
%3596 = trunc i64 %3594 to i32
%3597 = mul nsw i32 %3595, %3596
%3598 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3594
store i32 %3597, i32* %3598
%3599 = add nuw nsw i64 %3579, 4
%3600 = load volatile i32, i32* %6
%3601 = trunc i64 %3599 to i32
%3602 = mul nsw i32 %3600, %3601
%3603 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3599
store i32 %3602, i32* %3603
%3604 = add nuw nsw i64 %3579, 5
%3605 = icmp eq i64 %3604, 10240
br i1 %3605, label %3523, label %3578
3606: ; preds = %3661
br label %3607
3607: ; preds = %3607, %3606
%3608 = phi i64 [ 0, %3606 ], [ %3655, %3607 ]
%3609 = phi <4 x i32> [ zeroinitializer, %3606 ], [ %3653, %3607 ]
%3610 = phi <4 x i32> [ zeroinitializer, %3606 ], [ %3654, %3607 ]
%3611 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3608
%3612 = bitcast i32* %3611 to <4 x i32>*
%3613 = load <4 x i32>, <4 x i32>* %3612
%3614 = getelementptr inbounds i32, i32* %3611, i64 4
%3615 = bitcast i32* %3614 to <4 x i32>*
%3616 = load <4 x i32>, <4 x i32>* %3615
%3617 = add <4 x i32> %3613, %3609
%3618 = add <4 x i32> %3616, %3610
%3619 = add nuw nsw i64 %3608, 8
%3620 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3619
%3621 = bitcast i32* %3620 to <4 x i32>*
%3622 = load <4 x i32>, <4 x i32>* %3621
%3623 = getelementptr inbounds i32, i32* %3620, i64 4
%3624 = bitcast i32* %3623 to <4 x i32>*
%3625 = load <4 x i32>, <4 x i32>* %3624
%3626 = add <4 x i32> %3622, %3617
%3627 = add <4 x i32> %3625, %3618
%3628 = add nuw nsw i64 %3608, 16
%3629 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3628
%3630 = bitcast i32* %3629 to <4 x i32>*
%3631 = load <4 x i32>, <4 x i32>* %3630
%3632 = getelementptr inbounds i32, i32* %3629, i64 4
%3633 = bitcast i32* %3632 to <4 x i32>*
%3634 = load <4 x i32>, <4 x i32>* %3633
%3635 = add <4 x i32> %3631, %3626
%3636 = add <4 x i32> %3634, %3627
%3637 = add nuw nsw i64 %3608, 24
%3638 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3637
%3639 = bitcast i32* %3638 to <4 x i32>*
%3640 = load <4 x i32>, <4 x i32>* %3639
%3641 = getelementptr inbounds i32, i32* %3638, i64 4
%3642 = bitcast i32* %3641 to <4 x i32>*
%3643 = load <4 x i32>, <4 x i32>* %3642
%3644 = add <4 x i32> %3640, %3635
%3645 = add <4 x i32> %3643, %3636
%3646 = add nuw nsw i64 %3608, 32
%3647 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3646
%3648 = bitcast i32* %3647 to <4 x i32>*
%3649 = load <4 x i32>, <4 x i32>* %3648
%3650 = getelementptr inbounds i32, i32* %3647, i64 4
%3651 = bitcast i32* %3650 to <4 x i32>*
%3652 = load <4 x i32>, <4 x i32>* %3651
%3653 = add <4 x i32> %3649, %3644
%3654 = add <4 x i32> %3652, %3645
%3655 = add nuw nsw i64 %3608, 40
%3656 = icmp eq i64 %3655, 10240
br i1 %3656, label %3657, label %3607
3657: ; preds = %3607
%3658 = add <4 x i32> %3654, %3653
%3659 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3658)
%3660 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 256, i32 %3659)
br label %3744
3661: ; preds = %3661, %3574
%3662 = phi i64 [ 0, %3574 ], [ %3687, %3661 ]
%3663 = load volatile i32, i32* %6
%3664 = trunc i64 %3662 to i32
%3665 = mul nsw i32 %3663, %3664
%3666 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3662
store i32 %3665, i32* %3666
%3667 = add nuw nsw i64 %3662, 1
%3668 = load volatile i32, i32* %6
%3669 = trunc i64 %3667 to i32
%3670 = mul nsw i32 %3668, %3669
%3671 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3667
store i32 %3670, i32* %3671
%3672 = add nuw nsw i64 %3662, 2
%3673 = load volatile i32, i32* %6
%3674 = trunc i64 %3672 to i32
%3675 = mul nsw i32 %3673, %3674
%3676 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3672
store i32 %3675, i32* %3676
%3677 = add nuw nsw i64 %3662, 3
%3678 = load volatile i32, i32* %6
%3679 = trunc i64 %3677 to i32
%3680 = mul nsw i32 %3678, %3679
%3681 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3677
store i32 %3680, i32* %3681
%3682 = add nuw nsw i64 %3662, 4
%3683 = load volatile i32, i32* %6
%3684 = trunc i64 %3682 to i32
%3685 = mul nsw i32 %3683, %3684
%3686 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3682
store i32 %3685, i32* %3686
%3687 = add nuw nsw i64 %3662, 5
%3688 = icmp eq i64 %3687, 10240
br i1 %3688, label %3606, label %3661
3689: ; preds = %3744
br label %3690
3690: ; preds = %3690, %3689
%3691 = phi i64 [ 0, %3689 ], [ %3738, %3690 ]
%3692 = phi <4 x i32> [ zeroinitializer, %3689 ], [ %3736, %3690 ]
%3693 = phi <4 x i32> [ zeroinitializer, %3689 ], [ %3737, %3690 ]
%3694 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3691
%3695 = bitcast i32* %3694 to <4 x i32>*
%3696 = load <4 x i32>, <4 x i32>* %3695
%3697 = getelementptr inbounds i32, i32* %3694, i64 4
%3698 = bitcast i32* %3697 to <4 x i32>*
%3699 = load <4 x i32>, <4 x i32>* %3698
%3700 = add <4 x i32> %3696, %3692
%3701 = add <4 x i32> %3699, %3693
%3702 = add nuw nsw i64 %3691, 8
%3703 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3702
%3704 = bitcast i32* %3703 to <4 x i32>*
%3705 = load <4 x i32>, <4 x i32>* %3704
%3706 = getelementptr inbounds i32, i32* %3703, i64 4
%3707 = bitcast i32* %3706 to <4 x i32>*
%3708 = load <4 x i32>, <4 x i32>* %3707
%3709 = add <4 x i32> %3705, %3700
%3710 = add <4 x i32> %3708, %3701
%3711 = add nuw nsw i64 %3691, 16
%3712 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3711
%3713 = bitcast i32* %3712 to <4 x i32>*
%3714 = load <4 x i32>, <4 x i32>* %3713
%3715 = getelementptr inbounds i32, i32* %3712, i64 4
%3716 = bitcast i32* %3715 to <4 x i32>*
%3717 = load <4 x i32>, <4 x i32>* %3716
%3718 = add <4 x i32> %3714, %3709
%3719 = add <4 x i32> %3717, %3710
%3720 = add nuw nsw i64 %3691, 24
%3721 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3720
%3722 = bitcast i32* %3721 to <4 x i32>*
%3723 = load <4 x i32>, <4 x i32>* %3722
%3724 = getelementptr inbounds i32, i32* %3721, i64 4
%3725 = bitcast i32* %3724 to <4 x i32>*
%3726 = load <4 x i32>, <4 x i32>* %3725
%3727 = add <4 x i32> %3723, %3718
%3728 = add <4 x i32> %3726, %3719
%3729 = add nuw nsw i64 %3691, 32
%3730 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3729
%3731 = bitcast i32* %3730 to <4 x i32>*
%3732 = load <4 x i32>, <4 x i32>* %3731
%3733 = getelementptr inbounds i32, i32* %3730, i64 4
%3734 = bitcast i32* %3733 to <4 x i32>*
%3735 = load <4 x i32>, <4 x i32>* %3734
%3736 = add <4 x i32> %3732, %3727
%3737 = add <4 x i32> %3735, %3728
%3738 = add nuw nsw i64 %3691, 40
%3739 = icmp eq i64 %3738, 10240
br i1 %3739, label %3740, label %3690
3740: ; preds = %3690
%3741 = add <4 x i32> %3737, %3736
%3742 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3741)
%3743 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 512, i32 %3742)
br label %3828
3744: ; preds = %3744, %3657
%3745 = phi i64 [ 0, %3657 ], [ %3770, %3744 ]
%3746 = load volatile i32, i32* %6
%3747 = trunc i64 %3745 to i32
%3748 = mul nsw i32 %3746, %3747
%3749 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3745
store i32 %3748, i32* %3749
%3750 = add nuw nsw i64 %3745, 1
%3751 = load volatile i32, i32* %6
%3752 = trunc i64 %3750 to i32
%3753 = mul nsw i32 %3751, %3752
%3754 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3750
store i32 %3753, i32* %3754
%3755 = add nuw nsw i64 %3745, 2
%3756 = load volatile i32, i32* %6
%3757 = trunc i64 %3755 to i32
%3758 = mul nsw i32 %3756, %3757
%3759 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3755
store i32 %3758, i32* %3759
%3760 = add nuw nsw i64 %3745, 3
%3761 = load volatile i32, i32* %6
%3762 = trunc i64 %3760 to i32
%3763 = mul nsw i32 %3761, %3762
%3764 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3760
store i32 %3763, i32* %3764
%3765 = add nuw nsw i64 %3745, 4
%3766 = load volatile i32, i32* %6
%3767 = trunc i64 %3765 to i32
%3768 = mul nsw i32 %3766, %3767
%3769 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3765
store i32 %3768, i32* %3769
%3770 = add nuw nsw i64 %3745, 5
%3771 = icmp eq i64 %3770, 10240
br i1 %3771, label %3689, label %3744
3772: ; preds = %3828
%3773 = bitcast i32* %2674 to i8*
br label %3774
3774: ; preds = %3774, %3772
%3775 = phi i64 [ 0, %3772 ], [ %3822, %3774 ]
%3776 = phi <4 x i32> [ zeroinitializer, %3772 ], [ %3820, %3774 ]
%3777 = phi <4 x i32> [ zeroinitializer, %3772 ], [ %3821, %3774 ]
%3778 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3775
%3779 = bitcast i32* %3778 to <4 x i32>*
%3780 = load <4 x i32>, <4 x i32>* %3779
%3781 = getelementptr inbounds i32, i32* %3778, i64 4
%3782 = bitcast i32* %3781 to <4 x i32>*
%3783 = load <4 x i32>, <4 x i32>* %3782
%3784 = add <4 x i32> %3780, %3776
%3785 = add <4 x i32> %3783, %3777
%3786 = add nuw nsw i64 %3775, 8
%3787 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3786
%3788 = bitcast i32* %3787 to <4 x i32>*
%3789 = load <4 x i32>, <4 x i32>* %3788
%3790 = getelementptr inbounds i32, i32* %3787, i64 4
%3791 = bitcast i32* %3790 to <4 x i32>*
%3792 = load <4 x i32>, <4 x i32>* %3791
%3793 = add <4 x i32> %3789, %3784
%3794 = add <4 x i32> %3792, %3785
%3795 = add nuw nsw i64 %3775, 16
%3796 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3795
%3797 = bitcast i32* %3796 to <4 x i32>*
%3798 = load <4 x i32>, <4 x i32>* %3797
%3799 = getelementptr inbounds i32, i32* %3796, i64 4
%3800 = bitcast i32* %3799 to <4 x i32>*
%3801 = load <4 x i32>, <4 x i32>* %3800
%3802 = add <4 x i32> %3798, %3793
%3803 = add <4 x i32> %3801, %3794
%3804 = add nuw nsw i64 %3775, 24
%3805 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3804
%3806 = bitcast i32* %3805 to <4 x i32>*
%3807 = load <4 x i32>, <4 x i32>* %3806
%3808 = getelementptr inbounds i32, i32* %3805, i64 4
%3809 = bitcast i32* %3808 to <4 x i32>*
%3810 = load <4 x i32>, <4 x i32>* %3809
%3811 = add <4 x i32> %3807, %3802
%3812 = add <4 x i32> %3810, %3803
%3813 = add nuw nsw i64 %3775, 32
%3814 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3813
%3815 = bitcast i32* %3814 to <4 x i32>*
%3816 = load <4 x i32>, <4 x i32>* %3815
%3817 = getelementptr inbounds i32, i32* %3814, i64 4
%3818 = bitcast i32* %3817 to <4 x i32>*
%3819 = load <4 x i32>, <4 x i32>* %3818
%3820 = add <4 x i32> %3816, %3811
%3821 = add <4 x i32> %3819, %3812
%3822 = add nuw nsw i64 %3775, 40
%3823 = icmp eq i64 %3822, 10240
br i1 %3823, label %3824, label %3774
3824: ; preds = %3774
%3825 = add <4 x i32> %3821, %3820
%3826 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3825)
%3827 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 1024, i32 %3826)
br label %3856
3828: ; preds = %3828, %3740
%3829 = phi i64 [ 0, %3740 ], [ %3854, %3828 ]
%3830 = load volatile i32, i32* %6
%3831 = trunc i64 %3829 to i32
%3832 = mul nsw i32 %3830, %3831
%3833 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3829
store i32 %3832, i32* %3833
%3834 = add nuw nsw i64 %3829, 1
%3835 = load volatile i32, i32* %6
%3836 = trunc i64 %3834 to i32
%3837 = mul nsw i32 %3835, %3836
%3838 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3834
store i32 %3837, i32* %3838
%3839 = add nuw nsw i64 %3829, 2
%3840 = load volatile i32, i32* %6
%3841 = trunc i64 %3839 to i32
%3842 = mul nsw i32 %3840, %3841
%3843 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3839
store i32 %3842, i32* %3843
%3844 = add nuw nsw i64 %3829, 3
%3845 = load volatile i32, i32* %6
%3846 = trunc i64 %3844 to i32
%3847 = mul nsw i32 %3845, %3846
%3848 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3844
store i32 %3847, i32* %3848
%3849 = add nuw nsw i64 %3829, 4
%3850 = load volatile i32, i32* %6
%3851 = trunc i64 %3849 to i32
%3852 = mul nsw i32 %3850, %3851
%3853 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3849
store i32 %3852, i32* %3853
%3854 = add nuw nsw i64 %3829, 5
%3855 = icmp eq i64 %3854, 10240
br i1 %3855, label %3772, label %3828
3856: ; preds = %3824, %3915
%3857 = phi i64 [ 10, %3824 ], [ %3919, %3915 ]
br label %3921
3858: ; preds = %3915
ret i32 1
3859: ; preds = %3921
%3860 = trunc i64 %3857 to i32
%3861 = urem i32 %3860, 17
%3862 = zext i32 %3861 to i64
%3863 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3862
%3864 = bitcast i32* %3863 to i8*
br label %3865
3865: ; preds = %3865, %3859
%3866 = phi i64 [ 0, %3859 ], [ %3913, %3865 ]
%3867 = phi <4 x i32> [ zeroinitializer, %3859 ], [ %3911, %3865 ]
%3868 = phi <4 x i32> [ zeroinitializer, %3859 ], [ %3912, %3865 ]
%3869 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3866
%3870 = bitcast i32* %3869 to <4 x i32>*
%3871 = load <4 x i32>, <4 x i32>* %3870
%3872 = getelementptr inbounds i32, i32* %3869, i64 4
%3873 = bitcast i32* %3872 to <4 x i32>*
%3874 = load <4 x i32>, <4 x i32>* %3873
%3875 = add <4 x i32> %3871, %3867
%3876 = add <4 x i32> %3874, %3868
%3877 = add nuw nsw i64 %3866, 8
%3878 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3877
%3879 = bitcast i32* %3878 to <4 x i32>*
%3880 = load <4 x i32>, <4 x i32>* %3879
%3881 = getelementptr inbounds i32, i32* %3878, i64 4
%3882 = bitcast i32* %3881 to <4 x i32>*
%3883 = load <4 x i32>, <4 x i32>* %3882
%3884 = add <4 x i32> %3880, %3875
%3885 = add <4 x i32> %3883, %3876
%3886 = add nuw nsw i64 %3866, 16
%3887 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3886
%3888 = bitcast i32* %3887 to <4 x i32>*
%3889 = load <4 x i32>, <4 x i32>* %3888
%3890 = getelementptr inbounds i32, i32* %3887, i64 4
%3891 = bitcast i32* %3890 to <4 x i32>*
%3892 = load <4 x i32>, <4 x i32>* %3891
%3893 = add <4 x i32> %3889, %3884
%3894 = add <4 x i32> %3892, %3885
%3895 = add nuw nsw i64 %3866, 24
%3896 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3895
%3897 = bitcast i32* %3896 to <4 x i32>*
%3898 = load <4 x i32>, <4 x i32>* %3897
%3899 = getelementptr inbounds i32, i32* %3896, i64 4
%3900 = bitcast i32* %3899 to <4 x i32>*
%3901 = load <4 x i32>, <4 x i32>* %3900
%3902 = add <4 x i32> %3898, %3893
%3903 = add <4 x i32> %3901, %3894
%3904 = add nuw nsw i64 %3866, 32
%3905 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3904
%3906 = bitcast i32* %3905 to <4 x i32>*
%3907 = load <4 x i32>, <4 x i32>* %3906
%3908 = getelementptr inbounds i32, i32* %3905, i64 4
%3909 = bitcast i32* %3908 to <4 x i32>*
%3910 = load <4 x i32>, <4 x i32>* %3909
%3911 = add <4 x i32> %3907, %3902
%3912 = add <4 x i32> %3910, %3903
%3913 = add nuw nsw i64 %3866, 40
%3914 = icmp eq i64 %3913, 10240
br i1 %3914, label %3915, label %3865
3915: ; preds = %3865
%3916 = add <4 x i32> %3912, %3911
%3917 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %3916)
%3918 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0), i32 %3860, i32 %3917)
%3919 = add nuw nsw i64 %3857, 10
%3920 = icmp ult i64 %3857, 90
br i1 %3920, label %3856, label %3858
3921: ; preds = %3921, %3856
%3922 = phi i64 [ 0, %3856 ], [ %3947, %3921 ]
%3923 = load volatile i32, i32* %6
%3924 = trunc i64 %3922 to i32
%3925 = mul nsw i32 %3923, %3924
%3926 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3922
store i32 %3925, i32* %3926
%3927 = add nuw nsw i64 %3922, 1
%3928 = load volatile i32, i32* %6
%3929 = trunc i64 %3927 to i32
%3930 = mul nsw i32 %3928, %3929
%3931 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3927
store i32 %3930, i32* %3931
%3932 = add nuw nsw i64 %3922, 2
%3933 = load volatile i32, i32* %6
%3934 = trunc i64 %3932 to i32
%3935 = mul nsw i32 %3933, %3934
%3936 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3932
store i32 %3935, i32* %3936
%3937 = add nuw nsw i64 %3922, 3
%3938 = load volatile i32, i32* %6
%3939 = trunc i64 %3937 to i32
%3940 = mul nsw i32 %3938, %3939
%3941 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3937
store i32 %3940, i32* %3941
%3942 = add nuw nsw i64 %3922, 4
%3943 = load volatile i32, i32* %6
%3944 = trunc i64 %3942 to i32
%3945 = mul nsw i32 %3943, %3944
%3946 = getelementptr inbounds [10240 x i32], [10240 x i32]* %5, i64 0, i64 %3942
store i32 %3945, i32* %3946
%3947 = add nuw nsw i64 %3922, 5
%3948 = icmp eq i64 %3947, 10240
br i1 %3948, label %3859, label %3921
}