void larger_sads(unsigned short *sads, int mbs) {
  int macroblock;
  int block_x, block_y;
  unsigned short *x, *y;
  unsigned short *z;
  int count;
  for (macroblock = 0; macroblock < mbs; macroblock++) {
    for (block_y = 0; block_y < 2; block_y++)
      for (block_x = 0; block_x < 4; block_x++) {
        x = sads + ((mbs) * (25 * 1096)) + macroblock * 16 * 1096 +
            (8 * block_y + block_x) * 1096;
        y = x + 4 * 1096;
        z = sads + ((mbs) * (17 * 1096)) + macroblock * 8 * 1096 +
            (4 * block_y + block_x) * 1096;
        for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
          *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
      }
    for (block_y = 0; block_y < 4; block_y++)
      for (block_x = 0; block_x < 2; block_x++) {
        x = sads + ((mbs) * (25 * 1096)) + macroblock * 16 * 1096 +
            (4 * block_y + 2 * block_x) * 1096;
        y = x + 1096;
        z = sads + ((mbs) * (9 * 1096)) + macroblock * 8 * 1096 +
            (2 * block_y + block_x) * 1096;
        for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
          *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
      }
    for (block_y = 0; block_y < 2; block_y++)
      for (block_x = 0; block_x < 2; block_x++) {
        x = sads + ((mbs) * (9 * 1096)) + macroblock * 8 * 1096 +
            (4 * block_y + block_x) * 1096;
        y = x + 2 * 1096;
        z = sads + ((mbs) * (5 * 1096)) + macroblock * 4 * 1096 +
            (2 * block_y + block_x) * 1096;
        for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
          *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
      }
    x = sads + ((mbs) * (5 * 1096)) + macroblock * 4 * 1096;
    y = x + 2 * 1096;
    z = sads + ((mbs) * (3 * 1096)) + macroblock * 2 * 1096;
    for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
      *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
    x = sads + ((mbs) * (5 * 1096)) + macroblock * 4 * 1096 + 1096;
    y = x + 2 * 1096;
    z = sads + ((mbs) * (3 * 1096)) + macroblock * 2 * 1096 + 1096;
    for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
      *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
    x = sads + ((mbs) * (5 * 1096)) + macroblock * 4 * 1096;
    y = x + 1096;
    z = sads + ((mbs)*1096) + macroblock * 2 * 1096;
    for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
      *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
    x = sads + ((mbs) * (5 * 1096)) + macroblock * 4 * 1096 + 2 * 1096;
    y = x + 1096;
    z = sads + ((mbs)*1096) + macroblock * 2 * 1096 + 1096;
    for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
      *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
    x = sads + ((mbs)*1096) + macroblock * 2 * 1096;
    y = x + 1096;
    z = sads + 0 + macroblock * 1 * 1096;
    for (count = 0; count < (1089 + 1) / 2; count++, z += 2, x += 2, y += 2)
      *(unsigned int *)z = *(unsigned int *)x + *(unsigned int *)y;
  }
}


x86 assembly (clang, -O0):
<larger_sads>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18cb <larger_sads+0x7cb>
movl   $0x0,-0x18(%rbp)
cmpl   $0x2,-0x18(%rbp)
jge    125c <larger_sads+0x15c>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    1249 <larger_sads+0x149>
mov    -0x8(%rbp),%rax
imul   $0x6b08,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x4,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x3,%ecx
add    -0x14(%rbp),%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x2240,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x48c8,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x3,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    -0x14(%rbp),%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    1236 <larger_sads+0x136>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    11e5 <larger_sads+0xe5>
jmp    123b <larger_sads+0x13b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1136 <larger_sads+0x36>
jmp    124e <larger_sads+0x14e>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1125 <larger_sads+0x25>
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    139f <larger_sads+0x29f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
jge    138c <larger_sads+0x28c>
mov    -0x8(%rbp),%rax
imul   $0x6b08,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x4,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x14(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x890,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x2688,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x3,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
add    -0x14(%rbp),%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    1379 <larger_sads+0x279>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1328 <larger_sads+0x228>
jmp    137e <larger_sads+0x27e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1274 <larger_sads+0x174>
jmp    1391 <larger_sads+0x291>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1263 <larger_sads+0x163>
movl   $0x0,-0x18(%rbp)
cmpl   $0x2,-0x18(%rbp)
jge    14dd <larger_sads+0x3dd>
movl   $0x0,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
jge    14ca <larger_sads+0x3ca>
mov    -0x8(%rbp),%rax
imul   $0x2688,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x3,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x2,%ecx
add    -0x14(%rbp),%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1120,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x1568,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
shl    $0x1,%ecx
add    -0x14(%rbp),%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    14b7 <larger_sads+0x3b7>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1466 <larger_sads+0x366>
jmp    14bc <larger_sads+0x3bc>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13b7 <larger_sads+0x2b7>
jmp    14cf <larger_sads+0x3cf>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13a6 <larger_sads+0x2a6>
mov    -0x8(%rbp),%rax
imul   $0x1568,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1120,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xcd8,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    15a1 <larger_sads+0x4a1>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1550 <larger_sads+0x450>
mov    -0x8(%rbp),%rax
imul   $0x1568,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x890,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1120,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0xcd8,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x890,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    1671 <larger_sads+0x571>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1620 <larger_sads+0x520>
mov    -0x8(%rbp),%rax
imul   $0x1568,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x890,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x448,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    1735 <larger_sads+0x635>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    16e4 <larger_sads+0x5e4>
mov    -0x8(%rbp),%rax
imul   $0x1568,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x2,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x1120,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x890,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x448,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
add    $0x890,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    1805 <larger_sads+0x705>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    17b4 <larger_sads+0x6b4>
mov    -0x8(%rbp),%rax
imul   $0x448,-0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x890,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
shl    $0x0,%ecx
imul   $0x448,%ecx,%ecx
movslq %ecx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x221,-0x34(%rbp)
jge    18b8 <larger_sads+0x7b8>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%rax
add    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1867 <larger_sads+0x767>
jmp    18bd <larger_sads+0x7bd>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <larger_sads+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<larger_sads>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x480,%rsp
mov    %rdi,-0x50(%rsp)
test   %esi,%esi
jle    419e <larger_sads+0x309e>
imul   $0x6b08,%esi,%eax
cltq
imul   $0x48c8,%esi,%ecx
movslq %ecx,%r8
mov    -0x50(%rsp),%rbx
lea    (%rbx,%r8,2),%rcx
mov    %rcx,0x350(%rsp)
imul   $0x2688,%esi,%ecx
movslq %ecx,%rcx
imul   $0x1568,%esi,%edx
movslq %edx,%rdx
imul   $0xcd8,%esi,%edi
movslq %edi,%rdi
imul   $0x448,%esi,%ebp
movslq %ebp,%r9
mov    %esi,%esi
mov    %rsi,0x348(%rsp)
lea    (%rbx,%r8,2),%rsi
add    $0x30,%rsi
mov    %rsi,0x238(%rsp)
lea    0x8c0(%rbx,%r8,2),%rsi
mov    %rsi,0x340(%rsp)
lea    0x1150(%rbx,%r8,2),%rsi
mov    %rsi,0x338(%rsp)
lea    0x19e0(%rbx,%r8,2),%rsi
mov    %rsi,0x330(%rsp)
lea    0x2270(%rbx,%r8,2),%rsi
mov    %rsi,0x328(%rsp)
lea    0x2b00(%rbx,%r8,2),%rsi
mov    %rsi,0x320(%rsp)
lea    0x3390(%rbx,%r8,2),%rsi
mov    %rsi,0x318(%rsp)
lea    0x3c20(%rbx,%r8,2),%rsi
mov    %rsi,0x310(%rsp)
lea    (%rbx,%rax,2),%rsi
lea    0x2270(%rbx,%rax,2),%rbp
mov    %rbp,0x230(%rsp)
lea    0x2b00(%rbx,%rax,2),%rbp
mov    %rbp,0x308(%rsp)
lea    0x3390(%rbx,%rax,2),%rbp
mov    %rbp,0x300(%rsp)
lea    0x3c20(%rbx,%rax,2),%rbp
mov    %rbp,0x2f8(%rsp)
lea    0x66f0(%rbx,%rax,2),%rbp
mov    %rbp,0x2f0(%rsp)
lea    0x6f80(%rbx,%rax,2),%rbp
mov    %rbp,0x2e8(%rsp)
lea    0x7810(%rbx,%rax,2),%rbp
mov    %rbp,0x2e0(%rsp)
lea    0x80a0(%rbx,%rax,2),%rbp
mov    %rbp,0x2d8(%rsp)
lea    0x19e0(%rbx,%rax,2),%rbp
mov    %rbp,0x2d0(%rsp)
lea    0x4d40(%rbx,%rax,2),%rbp
mov    %rbp,0x2c8(%rsp)
lea    0x5e60(%rbx,%rax,2),%rax
mov    %rax,0x2c0(%rsp)
lea    (%rbx,%rcx,2),%rax
mov    %rax,0x2b8(%rsp)
lea    0x8c0(%rbx,%rcx,2),%rax
mov    %rax,0x2b0(%rsp)
lea    0x1150(%rbx,%rcx,2),%rax
mov    %rax,0x2a8(%rsp)
lea    0x19e0(%rbx,%rcx,2),%rax
mov    %rax,0x2a0(%rsp)
lea    0x2270(%rbx,%rcx,2),%rax
mov    %rax,0x298(%rsp)
lea    0x2b00(%rbx,%rcx,2),%rax
mov    %rax,0x290(%rsp)
lea    0x3390(%rbx,%rcx,2),%rax
mov    %rax,0x288(%rsp)
lea    0x3c20(%rbx,%rcx,2),%rax
mov    %rax,0x280(%rsp)
lea    (%rbx,%rdx,2),%rax
mov    %rax,-0x18(%rsp)
lea    0x30(%rbx,%rdx,2),%rax
mov    %rax,0x278(%rsp)
lea    0x8c0(%rbx,%rdx,2),%rax
mov    %rax,0x270(%rsp)
lea    0x1150(%rbx,%rdx,2),%rax
mov    %rax,0x268(%rsp)
lea    0x19e0(%rbx,%rdx,2),%rax
mov    %rax,0x260(%rsp)
lea    (%rbx,%rdi,2),%rax
mov    %rax,0xb0(%rsp)
lea    0x30(%rbx,%rdi,2),%rax
mov    %rax,0x258(%rsp)
lea    0x8c0(%rbx,%rdi,2),%rax
mov    %rax,0x250(%rsp)
lea    (%rbx,%r9,2),%rax
mov    %rax,-0x20(%rsp)
lea    0x8c0(%rbx,%r9,2),%rax
mov    %rax,0x248(%rsp)
lea    0x884(%rbx),%rax
mov    %rax,0x240(%rsp)
xor    %r11d,%r11d
xor    %r12d,%r12d
xor    %r14d,%r14d
xor    %eax,%eax
xor    %r13d,%r13d
mov    %rsi,0x30(%rsp)
jmp    1404 <larger_sads+0x304>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    %r15,%rax
add    $0x89,%eax
add    $0x89,%r14d
add    $0x89,%r12d
add    $0x89,%r11d
cmp    0x348(%rsp),%r13
mov    0x30(%rsp),%rsi
je     419e <larger_sads+0x309e>
mov    %r12,0xa0(%rsp)
mov    %r11,0xa8(%rsp)
mov    %r11d,%r15d
and    $0x1fffffff,%r15d
shl    $0x4,%r15
mov    %r12d,%r11d
and    $0xfffffff,%r11d
shl    $0x5,%r11
mov    %r13,%rbx
mov    %r14,%r13
and    $0x7ffffff,%r14d
shl    $0x6,%r14
mov    %eax,%ebp
and    $0x3ffffff,%ebp
shl    $0x7,%rbp
mov    %rax,%r10
mov    %rax,0x90(%rsp)
and    $0x1ffffff,%r10d
shl    $0x8,%r10
imul   $0x2240,%ebx,%r8d
mov    0x350(%rsp),%rdi
lea    (%rdi,%r8,2),%r12
lea    (%rdi,%r8,2),%rax
add    $0x884,%rax
imul   $0x4480,%ebx,%r9d
lea    (%rsi,%r9,2),%rdx
add    $0x884,%rdx
imul   $0x1120,%ebx,%ecx
mov    %rcx,-0x68(%rsp)
imul   $0x890,%ebx,%ecx
mov    %rcx,-0x58(%rsp)
mov    %rbx,-0x28(%rsp)
imul   $0x448,%ebx,%ecx
mov    %rcx,-0x40(%rsp)
lea    (%rsi,%r9,2),%rcx
mov    %rdx,0x448(%rsp)
cmp    %rdx,%r12
setb   %dl
cmp    %rax,%rcx
lea    0x2ac4(%rsi,%r9,2),%rbx
setb   %cl
and    %dl,%cl
mov    %rbx,0x458(%rsp)
cmp    %rbx,%r12
setb   %dl
lea    (%rsi,%r9,2),%rbx
add    $0x2240,%rbx
mov    %rbx,0x450(%rsp)
cmp    %rax,%rbx
setb   %al
and    %dl,%al
or     %cl,%al
mov    %r13,%rcx
mov    %al,-0x60(%rsp)
lea    (%rsi,%r9,2),%rdx
lea    0x2240(%rsi,%r9,2),%r13
mov    $0x0,%eax
mov    %r12,-0x70(%rsp)
mov    %r12,%rbx
mov    %r13,0xb8(%rsp)
mov    %rdx,-0x80(%rsp)
mov    %rcx,0x98(%rsp)
jne    15f9 <larger_sads+0x4f9>
mov    0x238(%rsp),%rax
add    %rbp,%rax
mov    0x230(%rsp),%rcx
add    %r10,%rcx
mov    -0x70(%rsp),%rdx
lea    0x880(%rdx),%rbx
mov    0xb8(%rsp),%rdx
lea    0x880(%rdx),%r13
mov    -0x80(%rsp),%rdx
add    $0x880,%rdx
xor    %esi,%esi
nop
movdqu -0x2270(%rcx,%rsi,4),%xmm0
ff ff
movdqu -0x2260(%rcx,%rsi,4),%xmm1
ff ff
movdqu -0x30(%rcx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rcx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rax,%rsi,4)
movdqu %xmm0,-0x20(%rax,%rsi,4)
movdqu -0x2250(%rcx,%rsi,4),%xmm0
ff ff
movdqu -0x2240(%rcx,%rsi,4),%xmm1
ff ff
movdqu -0x10(%rcx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rcx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rax,%rsi,4)
movdqu %xmm0,(%rax,%rsi,4)
add    $0x10,%rsi
cmp    $0x220,%rsi
jne    1580 <larger_sads+0x480>
mov    $0x220,%eax
mov    0x30(%rsp),%rsi
mov    %eax,0x2c(%rsp)
add    -0x50(%rsp),%r15
mov    %r15,0x3f8(%rsp)
mov    -0x20(%rsp),%rax
add    %r11,%rax
mov    %rax,0x88(%rsp)
mov    0x248(%rsp),%rax
lea    (%rax,%r11,1),%rax
mov    %rax,0x3f0(%rsp)
mov    0x260(%rsp),%rax
add    %r14,%rax
mov    %rax,-0x38(%rsp)
mov    -0x18(%rsp),%rax
add    %r14,%rax
mov    %rax,0x3e8(%rsp)
mov    0x250(%rsp),%rax
add    %r11,%rax
mov    %rax,0x3e0(%rsp)
add    0x258(%rsp),%r11
mov    %r11,0x3d8(%rsp)
mov    0x268(%rsp),%rax
add    %r14,%rax
mov    %rax,0x80(%rsp)
mov    0x270(%rsp),%rax
add    %r14,%rax
mov    %rax,0x3d0(%rsp)
add    0x278(%rsp),%r14
mov    %r14,0x3c8(%rsp)
mov    0x2d8(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x58(%rsp)
mov    0x2e8(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x50(%rsp)
mov    0x2c0(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x3c0(%rsp)
mov    0x2c8(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x3b0(%rsp)
mov    0x2f8(%rsp),%rcx
lea    (%rcx,%r10,1),%r14
mov    0x308(%rsp),%rcx
lea    (%rcx,%r10,1),%r12
mov    0x2d0(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x3a0(%rsp)
lea    (%rsi,%r10,1),%rax
mov    %rax,0x390(%rsp)
mov    0x2e0(%rsp),%rcx
lea    (%rcx,%r10,1),%rax
mov    %rax,0x378(%rsp)
mov    0x2f0(%rsp),%rcx
lea    (%rcx,%r10,1),%r11
add    0x300(%rsp),%r10
mov    0x280(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x70(%rsp)
mov    0x288(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0x68(%rsp)
mov    0x2a0(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0x60(%rsp)
mov    0x2a8(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0xc0(%rsp)
mov    0x290(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0x3b8(%rsp)
mov    0x298(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0x3a8(%rsp)
mov    0x2b0(%rsp),%rax
lea    (%rax,%rbp,1),%rax
mov    %rax,0x398(%rsp)
mov    0x2b8(%rsp),%rax
lea    (%rax,%rbp,1),%rcx
mov    %rcx,0x388(%rsp)
mov    0x310(%rsp),%rcx
lea    (%rcx,%rbp,1),%rcx
mov    %rcx,0x380(%rsp)
mov    0x318(%rsp),%rcx
lea    (%rcx,%rbp,1),%rcx
mov    %rcx,0x370(%rsp)
mov    0x320(%rsp),%rcx
lea    (%rcx,%rbp,1),%rcx
mov    %rcx,0x368(%rsp)
mov    0x328(%rsp),%rcx
add    %rbp,%rcx
mov    %rcx,0x360(%rsp)
mov    0x330(%rsp),%rcx
add    %rbp,%rcx
mov    %rcx,0x358(%rsp)
mov    0x338(%rsp),%rcx
lea    (%rcx,%rbp,1),%r15
add    0x340(%rsp),%rbp
lea    (%rsi,%r9,2),%rcx
add    $0x890,%rcx
mov    %rcx,0xd0(%rsp)
lea    0x1114(%rsi,%r9,2),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x2ad0(%rsi,%r9,2),%rcx
mov    %rcx,0x100(%rsp)
lea    0x3354(%rsi,%r9,2),%rcx
mov    %rcx,0xf8(%rsp)
lea    0x1120(%rsi,%r9,2),%rcx
mov    %rcx,0xe8(%rsp)
lea    0x19a4(%rsi,%r9,2),%rcx
mov    %rcx,0xd8(%rsp)
lea    0x3360(%rsi,%r9,2),%rcx
mov    %rcx,0x120(%rsp)
lea    0x3be4(%rsi,%r9,2),%rcx
mov    %rcx,0x110(%rsp)
lea    0x19b0(%rsi,%r9,2),%rcx
mov    %rcx,0xf0(%rsp)
lea    0x2234(%rsi,%r9,2),%rcx
mov    %rcx,0xe0(%rsp)
lea    0x3bf0(%rsi,%r9,2),%rcx
mov    %rcx,0x118(%rsp)
lea    0x4474(%rsi,%r9,2),%rcx
mov    %rcx,0x108(%rsp)
lea    0x4480(%rsi,%r9,2),%rcx
mov    %rcx,-0x30(%rsp)
lea    0x4d04(%rsi,%r9,2),%rcx
mov    %rcx,0x130(%rsp)
lea    0x66c0(%rsi,%r9,2),%rcx
mov    %rcx,0x178(%rsp)
lea    0x6f44(%rsi,%r9,2),%rcx
mov    %rcx,0x168(%rsp)
lea    0x4d10(%rsi,%r9,2),%rcx
mov    %rcx,0x138(%rsp)
lea    0x5594(%rsi,%r9,2),%rcx
mov    %rcx,0x128(%rsp)
lea    0x6f50(%rsi,%r9,2),%rcx
mov    %rcx,0x170(%rsp)
lea    0x77d4(%rsi,%r9,2),%rcx
mov    %rcx,0x160(%rsp)
lea    0x55a0(%rsi,%r9,2),%rcx
mov    %rcx,0x158(%rsp)
lea    0x5e24(%rsi,%r9,2),%rcx
mov    %rcx,0x148(%rsp)
lea    0x77e0(%rsi,%r9,2),%rcx
mov    %rcx,0x198(%rsp)
lea    0x8064(%rsi,%r9,2),%rcx
mov    %rcx,0x188(%rsp)
lea    0x5e30(%rsi,%r9,2),%rcx
mov    %rcx,0x150(%rsp)
lea    0x66b4(%rsi,%r9,2),%rcx
mov    %rcx,0x140(%rsp)
lea    0x8070(%rsi,%r9,2),%rcx
mov    %rcx,0x190(%rsp)
lea    0x88f4(%rsi,%r9,2),%rcx
mov    %rcx,0x180(%rsp)
lea    0x890(%rdi,%r8,2),%r9
lea    0x1114(%rdi,%r8,2),%rcx
mov    %rcx,0x400(%rsp)
lea    0x1120(%rdi,%r8,2),%rcx
mov    %rcx,0x408(%rsp)
lea    0x19a4(%rdi,%r8,2),%rcx
mov    %rcx,0x410(%rsp)
lea    0x19b0(%rdi,%r8,2),%rcx
mov    %rcx,-0x48(%rsp)
lea    0x2234(%rdi,%r8,2),%rcx
mov    %rcx,0x38(%rsp)
lea    0x2240(%rdi,%r8,2),%rcx
mov    %rcx,0x418(%rsp)
lea    0x2ac4(%rdi,%r8,2),%rcx
mov    %rcx,0x420(%rsp)
lea    0x2ad0(%rdi,%r8,2),%rcx
mov    %rcx,0x428(%rsp)
lea    0x3354(%rdi,%r8,2),%rcx
mov    %rcx,0x40(%rsp)
lea    0x3360(%rdi,%r8,2),%rcx
mov    %rcx,0x430(%rsp)
lea    0x3be4(%rdi,%r8,2),%rcx
mov    %rcx,0x48(%rsp)
lea    0x3bf0(%rdi,%r8,2),%rcx
mov    %rcx,0x438(%rsp)
lea    0x4474(%rdi,%r8,2),%rcx
mov    %rcx,0x440(%rsp)
lea    (%rax,%r8,2),%rcx
mov    %rcx,-0x78(%rsp)
lea    0x884(%rax,%r8,2),%rcx
mov    %rcx,0x1a0(%rsp)
lea    0x890(%rax,%r8,2),%rcx
mov    %rcx,0x1c0(%rsp)
lea    0x1114(%rax,%r8,2),%rcx
mov    %rcx,0x1b8(%rsp)
lea    0x1120(%rax,%r8,2),%rcx
mov    %rcx,0x1b0(%rsp)
lea    0x19a4(%rax,%r8,2),%rcx
mov    %rcx,0x1a8(%rsp)
lea    0x19b0(%rax,%r8,2),%rcx
mov    %rcx,0x1d0(%rsp)
lea    0x2234(%rax,%r8,2),%rcx
mov    %rcx,0x1c8(%rsp)
lea    0x2240(%rax,%r8,2),%rcx
mov    %rcx,0x1e0(%rsp)
lea    0x2ac4(%rax,%r8,2),%rcx
mov    %rcx,0x1d8(%rsp)
lea    0x2ad0(%rax,%r8,2),%rcx
mov    %rcx,0x208(%rsp)
lea    0x3354(%rax,%r8,2),%rcx
mov    %rcx,0x1f8(%rsp)
lea    0x3360(%rax,%r8,2),%rcx
mov    %rcx,0x1f0(%rsp)
lea    0x3be4(%rax,%r8,2),%rcx
mov    %rcx,0x1e8(%rsp)
lea    0x3bf0(%rax,%r8,2),%rcx
mov    %rcx,0x210(%rsp)
lea    0x4474(%rax,%r8,2),%rax
mov    %rax,0x200(%rsp)
mov    -0x68(%rsp),%rcx
mov    -0x18(%rsp),%rsi
lea    (%rsi,%rcx,2),%rax
mov    %rax,-0x8(%rsp)
lea    0x884(%rsi,%rcx,2),%rax
mov    %rax,-0x10(%rsp)
lea    0x890(%rsi,%rcx,2),%rax
mov    %rax,0x8(%rsp)
lea    0x1114(%rsi,%rcx,2),%rax
mov    %rax,(%rsp)
lea    0x1120(%rsi,%rcx,2),%rax
mov    %rax,0x18(%rsp)
lea    0x19a4(%rsi,%rcx,2),%rax
mov    %rax,0x10(%rsp)
lea    0x19b0(%rsi,%rcx,2),%rax
mov    %rax,0x20(%rsp)
lea    0x2234(%rsi,%rcx,2),%rax
mov    %rax,-0x68(%rsp)
mov    0xb0(%rsp),%rax
mov    -0x58(%rsp),%rsi
lea    (%rax,%rsi,2),%rcx
mov    %rcx,0x460(%rsp)
lea    0x884(%rax,%rsi,2),%rcx
mov    %rcx,0x78(%rsp)
lea    0x890(%rax,%rsi,2),%rcx
mov    %rcx,0x468(%rsp)
lea    0x1114(%rax,%rsi,2),%rax
mov    %rax,0x470(%rsp)
mov    -0x20(%rsp),%rcx
lea    (%rcx,%rsi,2),%rax
mov    %rax,0x220(%rsp)
lea    0x884(%rcx,%rsi,2),%rax
mov    %rax,0x218(%rsp)
lea    0x890(%rcx,%rsi,2),%rax
mov    %rax,0x228(%rsp)
lea    0x1114(%rcx,%rsi,2),%rax
mov    %rax,-0x58(%rsp)
mov    -0x40(%rsp),%rcx
mov    -0x50(%rsp),%rax
lea    (%rax,%rcx,2),%rax
mov    %rax,0x478(%rsp)
mov    0x240(%rsp),%rax
lea    (%rax,%rcx,2),%rax
mov    %rax,-0x40(%rsp)
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%rax
mov    0x0(%r13,%rdi,4),%esi
add    (%rdx,%rdi,4),%esi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rax),%rsi
cmp    $0x1,%edi
jne    1d10 <larger_sads+0xc10>
cmpb   $0x0,-0x60(%rsp)
je     1d8a <larger_sads+0xc8a>
mov    $0x220,%ecx
sub    0x2c(%rsp),%ecx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x0(%r13,%rax,4),%esi
add    (%rdx,%rax,4),%esi
mov    %esi,(%rbx,%rax,4)
mov    0x4(%r13,%rax,4),%esi
add    0x4(%rdx,%rax,4),%esi
mov    %esi,0x4(%rbx,%rax,4)
mov    0x8(%r13,%rax,4),%esi
add    0x8(%rdx,%rax,4),%esi
mov    %esi,0x8(%rbx,%rax,4)
mov    0xc(%r13,%rax,4),%esi
add    0xc(%rdx,%rax,4),%esi
mov    %esi,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %eax,%ecx
jne    1d50 <larger_sads+0xc50>
mov    -0x80(%rsp),%rax
lea    0x890(%rax),%r13
lea    0x2ad0(%rax),%rdx
mov    -0x70(%rsp),%rax
lea    0x890(%rax),%rbx
cmp    0xc8(%rsp),%r9
setb   %al
mov    0x400(%rsp),%rsi
cmp    %rsi,0xd0(%rsp)
setb   %cl
and    %al,%cl
cmp    0xf8(%rsp),%r9
setb   %al
cmp    %rsi,0x100(%rsp)
setb   %r8b
and    %al,%r8b
xor    %r9d,%r9d
or     %cl,%r8b
je     1e00 <larger_sads+0xd00>
mov    %r13,%rax
jmp    1e9e <larger_sads+0xd9e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x880,%rbx
add    $0x880,%rdx
lea    0x880(%r13),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movdqu -0x2270(%r12,%rcx,4),%xmm0
dd ff ff
movdqu -0x2260(%r12,%rcx,4),%xmm1
dd ff ff
movdqu -0x30(%r12,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r12,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rbp,%rcx,4)
movdqu %xmm0,-0x20(%rbp,%rcx,4)
movdqu -0x2250(%r12,%rcx,4),%xmm0
dd ff ff
movdqu -0x2240(%r12,%rcx,4),%xmm1
dd ff ff
movdqu -0x10(%r12,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r12,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rbp,%rcx,4)
movdqu %xmm0,0x0(%rbp,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    1e20 <larger_sads+0xd20>
mov    $0x220,%r9d
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rbp
mov    (%rdx,%rdi,4),%esi
add    (%rax,%rdi,4),%esi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbp),%rsi
cmp    $0x1,%edi
jne    1eb0 <larger_sads+0xdb0>
mov    %r13,-0x60(%rsp)
test   %r8b,%r8b
je     1f25 <larger_sads+0xe25>
mov    $0x220,%ecx
sub    %r9d,%ecx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdx,%rbp,4),%esi
add    (%rax,%rbp,4),%esi
mov    %esi,(%rbx,%rbp,4)
mov    0x4(%rdx,%rbp,4),%esi
add    0x4(%rax,%rbp,4),%esi
mov    %esi,0x4(%rbx,%rbp,4)
mov    0x8(%rdx,%rbp,4),%esi
add    0x8(%rax,%rbp,4),%esi
mov    %esi,0x8(%rbx,%rbp,4)
mov    0xc(%rdx,%rbp,4),%esi
add    0xc(%rax,%rbp,4),%esi
mov    %esi,0xc(%rbx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%ecx
jne    1ef0 <larger_sads+0xdf0>
mov    -0x80(%rsp),%rax
lea    0x1120(%rax),%r8
lea    0x3360(%rax),%rdx
mov    -0x70(%rsp),%rax
lea    0x1120(%rax),%rbp
mov    0x408(%rsp),%rdi
cmp    0xd8(%rsp),%rdi
setb   %al
mov    0x410(%rsp),%rsi
cmp    %rsi,0xe8(%rsp)
setb   %cl
and    %al,%cl
cmp    0x110(%rsp),%rdi
setb   %al
cmp    %rsi,0x120(%rsp)
setb   %r9b
and    %al,%r9b
xor    %r13d,%r13d
or     %cl,%r9b
je     1fa0 <larger_sads+0xea0>
mov    %r8,%rax
jmp    2041 <larger_sads+0xf41>
cs nopw 0x0(%rax,%rax,1)
add    $0x880,%rbp
add    $0x880,%rdx
lea    0x880(%r8),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movdqu -0x2270(%r10,%rcx,4),%xmm0
dd ff ff
movdqu -0x2260(%r10,%rcx,4),%xmm1
dd ff ff
movdqu -0x30(%r10,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r10,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%r15,%rcx,4)
movdqu %xmm0,-0x20(%r15,%rcx,4)
movdqu -0x2250(%r10,%rcx,4),%xmm0
dd ff ff
movdqu -0x2240(%r10,%rcx,4),%xmm1
movdqu -0x10(%r10,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r10,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%r15,%rcx,4)
movdqu %xmm0,(%r15,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    1fc0 <larger_sads+0xec0>
mov    $0x220,%r13d
mov    -0x30(%rsp),%r15
mov    0x38(%rsp),%r10
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rsi,%rbx
mov    (%rdx,%rdi,4),%esi
add    (%rax,%rdi,4),%esi
mov    %esi,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbx),%rsi
cmp    $0x1,%edi
jne    2060 <larger_sads+0xf60>
test   %r9b,%r9b
je     20c6 <larger_sads+0xfc6>
mov    $0x220,%ecx
sub    %r13d,%ecx
add    $0x1,%rcx
nop
mov    (%rdx,%rbx,4),%esi
add    (%rax,%rbx,4),%esi
mov    %esi,0x0(%rbp,%rbx,4)
mov    0x4(%rdx,%rbx,4),%esi
add    0x4(%rax,%rbx,4),%esi
mov    %esi,0x4(%rbp,%rbx,4)
mov    0x8(%rdx,%rbx,4),%esi
add    0x8(%rax,%rbx,4),%esi
mov    %esi,0x8(%rbp,%rbx,4)
mov    0xc(%rdx,%rbx,4),%esi
add    0xc(%rax,%rbx,4),%esi
mov    %esi,0xc(%rbp,%rbx,4)
add    $0x4,%rbx
cmp    %ebx,%ecx
jne    2090 <larger_sads+0xf90>
mov    -0x80(%rsp),%rax
lea    0x19b0(%rax),%rdx
lea    0x3bf0(%rax),%rbp
mov    -0x70(%rsp),%rax
lea    0x19b0(%rax),%rbx
mov    -0x48(%rsp),%rdi
cmp    0xe0(%rsp),%rdi
setb   %al
mov    0xf0(%rsp),%rsi
cmp    %r10,%rsi
setb   %cl
and    %al,%cl
cmp    0x108(%rsp),%rdi
setb   %al
cmp    %r10,0x118(%rsp)
setb   %r9b
and    %al,%r9b
xor    %r10d,%r10d
or     %cl,%r9b
jne    21cc <larger_sads+0x10cc>
add    $0x880,%rbx
add    $0x880,%rbp
add    $0x880,%rdx
xor    %eax,%eax
mov    0x358(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movdqu -0x2270(%r14,%rax,4),%xmm0
dd ff ff
movdqu -0x2260(%r14,%rax,4),%xmm1
dd ff ff
movdqu -0x30(%r14,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r14,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rcx,%rax,4)
movdqu %xmm0,-0x20(%rcx,%rax,4)
movdqu -0x2250(%r14,%rax,4),%xmm0
dd ff ff
movdqu -0x2240(%r14,%rax,4),%xmm1
dd ff ff
movdqu -0x10(%r14,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r14,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rcx,%rax,4)
movdqu %xmm0,(%rcx,%rax,4)
add    $0x10,%rax
cmp    $0x220,%rax
jne    2150 <larger_sads+0x1050>
mov    $0x220,%r10d
mov    0x48(%rsp),%r13
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rax
mov    0x0(%rbp,%rdi,4),%esi
add    (%rdx,%rdi,4),%esi
mov    %esi,(%rbx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rax),%rsi
cmp    $0x1,%edi
jne    21e0 <larger_sads+0x10e0>
test   %r9b,%r9b
je     2246 <larger_sads+0x1146>
mov    $0x220,%ecx
sub    %r10d,%ecx
add    $0x1,%rcx
nop
mov    0x0(%rbp,%rax,4),%esi
add    (%rdx,%rax,4),%esi
mov    %esi,(%rbx,%rax,4)
mov    0x4(%rbp,%rax,4),%esi
add    0x4(%rdx,%rax,4),%esi
mov    %esi,0x4(%rbx,%rax,4)
mov    0x8(%rbp,%rax,4),%esi
add    0x8(%rdx,%rax,4),%esi
mov    %esi,0x8(%rbx,%rax,4)
mov    0xc(%rbp,%rax,4),%esi
add    0xc(%rdx,%rax,4),%esi
mov    %esi,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %eax,%ecx
jne    2210 <larger_sads+0x1110>
mov    -0x80(%rsp),%rax
lea    0x4480(%rax),%rbp
add    $0x66c0,%rax
mov    -0x70(%rsp),%rcx
lea    0x2240(%rcx),%rdx
mov    0x418(%rsp),%rdi
cmp    0x130(%rsp),%rdi
setb   %cl
mov    0x420(%rsp),%rsi
cmp    %rsi,%r15
setb   %bl
and    %cl,%bl
cmp    0x168(%rsp),%rdi
setb   %cl
cmp    %rsi,0x178(%rsp)
setb   %r9b
and    %cl,%r9b
xor    %r10d,%r10d
or     %bl,%r9b
mov    %rbp,-0x48(%rsp)
jne    234d <larger_sads+0x124d>
add    $0x880,%rdx
add    $0x880,%rax
add    $0x880,%rbp
xor    %ecx,%ecx
mov    0x360(%rsp),%rsi
movdqu -0x2270(%r11,%rcx,4),%xmm0
dd ff ff
movdqu -0x2260(%r11,%rcx,4),%xmm1
dd ff ff
movdqu -0x30(%r11,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r11,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x2250(%r11,%rcx,4),%xmm0
dd ff ff
movdqu -0x2240(%r11,%rcx,4),%xmm1
dd ff ff
movdqu -0x10(%r11,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r11,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    22d0 <larger_sads+0x11d0>
mov    $0x220,%r10d
mov    0x40(%rsp),%r11
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rbx
mov    (%rax,%rdi,4),%esi
add    0x0(%rbp,%rdi,4),%esi
mov    %esi,(%rdx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbx),%rsi
cmp    $0x1,%edi
jne    2360 <larger_sads+0x1260>
test   %r9b,%r9b
je     23c6 <larger_sads+0x12c6>
mov    $0x220,%ecx
sub    %r10d,%ecx
add    $0x1,%rcx
nop
mov    (%rax,%rbx,4),%esi
add    0x0(%rbp,%rbx,4),%esi
mov    %esi,(%rdx,%rbx,4)
mov    0x4(%rax,%rbx,4),%esi
add    0x4(%rbp,%rbx,4),%esi
mov    %esi,0x4(%rdx,%rbx,4)
mov    0x8(%rax,%rbx,4),%esi
add    0x8(%rbp,%rbx,4),%esi
mov    %esi,0x8(%rdx,%rbx,4)
mov    0xc(%rax,%rbx,4),%esi
add    0xc(%rbp,%rbx,4),%esi
mov    %esi,0xc(%rdx,%rbx,4)
add    $0x4,%rbx
cmp    %ebx,%ecx
jne    2390 <larger_sads+0x1290>
mov    -0x80(%rsp),%rcx
lea    0x4d10(%rcx),%rax
lea    0x6f50(%rcx),%rdx
mov    -0x70(%rsp),%rcx
lea    0x2ad0(%rcx),%rbp
mov    0x428(%rsp),%rsi
cmp    0x128(%rsp),%rsi
setb   %cl
cmp    %r11,0x138(%rsp)
setb   %bl
and    %cl,%bl
cmp    0x160(%rsp),%rsi
setb   %cl
cmp    %r11,0x170(%rsp)
setb   %r9b
and    %cl,%r9b
xor    %r10d,%r10d
or     %bl,%r9b
jne    24c5 <larger_sads+0x13c5>
add    $0x880,%rbp
add    $0x880,%rdx
add    $0x880,%rax
xor    %ecx,%ecx
mov    0x50(%rsp),%rsi
mov    0x368(%rsp),%rdi
xchg   %ax,%ax
movdqu -0x2270(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x2260(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rcx,4)
movdqu %xmm0,-0x20(%rdi,%rcx,4)
movdqu -0x2250(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x2240(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rcx,4)
movdqu %xmm0,(%rdi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    2450 <larger_sads+0x1350>
mov    $0x220,%r10d
mov    $0x1,%esi
xor    %ecx,%ecx
xor    %edi,%edi
xchg   %ax,%ax
mov    %rsi,%rbx
mov    (%rdx,%rdi,4),%esi
add    (%rax,%rdi,4),%esi
mov    %esi,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbx),%rsi
cmp    $0x1,%edi
jne    24d0 <larger_sads+0x13d0>
test   %r9b,%r9b
je     2536 <larger_sads+0x1436>
mov    $0x220,%ecx
sub    %r10d,%ecx
add    $0x1,%rcx
nop
mov    (%rdx,%rbx,4),%esi
add    (%rax,%rbx,4),%esi
mov    %esi,0x0(%rbp,%rbx,4)
mov    0x4(%rdx,%rbx,4),%esi
add    0x4(%rax,%rbx,4),%esi
mov    %esi,0x4(%rbp,%rbx,4)
mov    0x8(%rdx,%rbx,4),%esi
add    0x8(%rax,%rbx,4),%esi
mov    %esi,0x8(%rbp,%rbx,4)
mov    0xc(%rdx,%rbx,4),%esi
add    0xc(%rax,%rbx,4),%esi
mov    %esi,0xc(%rbp,%rbx,4)
add    $0x4,%rbx
cmp    %ebx,%ecx
jne    2500 <larger_sads+0x1400>
mov    -0x80(%rsp),%rax
lea    0x55a0(%rax),%r11
add    $0x77e0,%rax
mov    -0x70(%rsp),%rcx
lea    0x3360(%rcx),%rdx
mov    0x430(%rsp),%rsi
cmp    0x148(%rsp),%rsi
setb   %cl
cmp    %r13,0x158(%rsp)
setb   %bl
and    %cl,%bl
cmp    0x188(%rsp),%rsi
setb   %cl
cmp    %r13,0x198(%rsp)
setb   %r10b
and    %cl,%r10b
xor    %r9d,%r9d
or     %bl,%r10b
je     25a0 <larger_sads+0x14a0>
mov    %r11,%rbp
jmp    2645 <larger_sads+0x1545>
xchg   %ax,%ax
add    $0x880,%rdx
add    $0x880,%rax
lea    0x880(%r11),%rbp
xor    %ecx,%ecx
mov    0x378(%rsp),%rsi
mov    0x370(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movdqu -0x2270(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x2260(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rcx,4)
movdqu %xmm0,-0x20(%rdi,%rcx,4)
movdqu -0x2250(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x2240(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rcx,4)
movdqu %xmm0,(%rdi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    25d0 <larger_sads+0x14d0>
mov    $0x220,%r9d
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %edi,%edi
xchg   %ax,%ax
mov    %rsi,%rcx
mov    (%rax,%rdi,4),%esi
add    0x0(%rbp,%rdi,4),%esi
mov    %esi,(%rdx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rcx),%rsi
cmp    $0x1,%edi
jne    2650 <larger_sads+0x1550>
test   %r10b,%r10b
je     26b6 <larger_sads+0x15b6>
mov    $0x220,%ebx
sub    %r9d,%ebx
add    $0x1,%rbx
nop
mov    (%rax,%rcx,4),%esi
add    0x0(%rbp,%rcx,4),%esi
mov    %esi,(%rdx,%rcx,4)
mov    0x4(%rax,%rcx,4),%esi
add    0x4(%rbp,%rcx,4),%esi
mov    %esi,0x4(%rdx,%rcx,4)
mov    0x8(%rax,%rcx,4),%esi
add    0x8(%rbp,%rcx,4),%esi
mov    %esi,0x8(%rdx,%rcx,4)
mov    0xc(%rax,%rcx,4),%esi
add    0xc(%rbp,%rcx,4),%esi
mov    %esi,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%ebx
jne    2680 <larger_sads+0x1580>
mov    -0x80(%rsp),%rcx
lea    0x5e30(%rcx),%rax
add    $0x8070,%rcx
mov    -0x70(%rsp),%r15
add    $0x3bf0,%r15
mov    0x438(%rsp),%rdi
cmp    0x140(%rsp),%rdi
setb   %dl
mov    0x440(%rsp),%rsi
cmp    %rsi,0x150(%rsp)
setb   %bl
and    %dl,%bl
cmp    0x180(%rsp),%rdi
setb   %dl
cmp    %rsi,0x190(%rsp)
setb   %r10b
and    %dl,%r10b
xor    %r9d,%r9d
or     %bl,%r10b
jne    27c5 <larger_sads+0x16c5>
add    $0x880,%r15
add    $0x880,%rcx
add    $0x880,%rax
xor    %ebp,%ebp
mov    0x58(%rsp),%rdx
mov    0x380(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movdqu -0x2270(%rdx,%rbp,4),%xmm0
ff ff
movdqu -0x2260(%rdx,%rbp,4),%xmm1
ff ff
movdqu -0x30(%rdx,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdx,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rbp,4)
movdqu %xmm0,-0x20(%rsi,%rbp,4)
movdqu -0x2250(%rdx,%rbp,4),%xmm0
ff ff
movdqu -0x2240(%rdx,%rbp,4),%xmm1
ff ff
movdqu -0x10(%rdx,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdx,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rbp,4)
movdqu %xmm0,(%rsi,%rbp,4)
add    $0x10,%rbp
cmp    $0x220,%rbp
jne    2750 <larger_sads+0x1650>
mov    $0x220,%r9d
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %edi,%edi
xchg   %ax,%ax
mov    %rsi,%rbp
mov    (%rcx,%rdi,4),%edx
add    (%rax,%rdi,4),%edx
mov    %edx,(%r15,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rsi
cmp    $0x1,%edi
jne    27d0 <larger_sads+0x16d0>
test   %r10b,%r10b
je     2839 <larger_sads+0x1739>
mov    $0x220,%edx
sub    %r9d,%edx
add    $0x1,%rdx
nop
mov    (%rcx,%rbp,4),%esi
add    (%rax,%rbp,4),%esi
mov    %esi,(%r15,%rbp,4)
mov    0x4(%rcx,%rbp,4),%esi
add    0x4(%rax,%rbp,4),%esi
mov    %esi,0x4(%r15,%rbp,4)
mov    0x8(%rcx,%rbp,4),%esi
add    0x8(%rax,%rbp,4),%esi
mov    %esi,0x8(%r15,%rbp,4)
mov    0xc(%rcx,%rbp,4),%esi
add    0xc(%rax,%rbp,4),%esi
mov    %esi,0xc(%r15,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edx
jne    2800 <larger_sads+0x1700>
mov    -0x78(%rsp),%rdi
cmp    0x448(%rsp),%rdi
setb   %al
mov    -0x80(%rsp),%rsi
mov    0x1a0(%rsp),%rdx
cmp    %rdx,%rsi
setb   %cl
and    %al,%cl
cmp    0xc8(%rsp),%rdi
setb   %al
cmp    %rdx,0xd0(%rsp)
setb   %r10b
and    %al,%r10b
xor    %r9d,%r9d
or     %cl,%r10b
je     2890 <larger_sads+0x1790>
mov    %rdi,%rax
mov    %rsi,%rcx
mov    -0x60(%rsp),%rdx
jmp    2935 <larger_sads+0x1835>
lea    0x880(%rdi),%rax
mov    -0x60(%rsp),%rdx
add    $0x880,%rdx
lea    0x880(%rsi),%rcx
mov    $0xc,%ebp
mov    0x390(%rsp),%rsi
mov    0x388(%rsp),%rdi
nop
movdqu -0x30(%rsi,%rbp,4),%xmm0
movdqu -0x20(%rsi,%rbp,4),%xmm1
movdqu 0x860(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x870(%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rbp,4)
movdqu %xmm0,-0x20(%rdi,%rbp,4)
movdqu -0x10(%rsi,%rbp,4),%xmm0
movdqu (%rsi,%rbp,4),%xmm1
movdqu 0x880(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x890(%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rbp,4)
movdqu %xmm0,(%rdi,%rbp,4)
add    $0x10,%rbp
cmp    $0x22c,%rbp
jne    28c0 <larger_sads+0x17c0>
mov    $0x220,%r9d
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %edi,%edi
xchg   %ax,%ax
mov    %rsi,%rbp
mov    (%rdx,%rdi,4),%esi
add    (%rcx,%rdi,4),%esi
mov    %esi,(%rax,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rbp),%rsi
cmp    $0x1,%edi
jne    2940 <larger_sads+0x1840>
test   %r10b,%r10b
je     29a5 <larger_sads+0x18a5>
mov    $0x220,%edi
sub    %r9d,%edi
add    $0x1,%rdi
xchg   %ax,%ax
mov    (%rdx,%rbp,4),%esi
add    (%rcx,%rbp,4),%esi
mov    %esi,(%rax,%rbp,4)
mov    0x4(%rdx,%rbp,4),%esi
add    0x4(%rcx,%rbp,4),%esi
mov    %esi,0x4(%rax,%rbp,4)
mov    0x8(%rdx,%rbp,4),%esi
add    0x8(%rcx,%rbp,4),%esi
mov    %esi,0x8(%rax,%rbp,4)
mov    0xc(%rdx,%rbp,4),%esi
add    0xc(%rcx,%rbp,4),%esi
mov    %esi,0xc(%rax,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edi
jne    2970 <larger_sads+0x1870>
lea    0x890(%r8),%rax
mov    -0x78(%rsp),%rcx
lea    0x890(%rcx),%r9
mov    0x1c0(%rsp),%rdx
cmp    0xd8(%rsp),%rdx
setb   %cl
mov    0x1b8(%rsp),%rsi
cmp    %rsi,0xe8(%rsp)
setb   %bl
and    %cl,%bl
cmp    0xe0(%rsp),%rdx
setb   %cl
cmp    %rsi,0xf0(%rsp)
setb   %dl
and    %cl,%dl
xor    %r10d,%r10d
or     %bl,%dl
je     2a10 <larger_sads+0x1910>
mov    %r9,%rcx
jmp    2ab5 <larger_sads+0x19b5>
nopw   0x0(%rax,%rax,1)
lea    0x880(%r9),%rcx
add    $0x880,%rax
add    $0x880,%r8
xor    %ebp,%ebp
mov    0x3a0(%rsp),%rsi
mov    0x398(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movdqu -0x8c0(%rsi,%rbp,4),%xmm0
ff ff
movdqu -0x8b0(%rsi,%rbp,4),%xmm1
ff ff
movdqu -0x30(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rbp,4)
movdqu %xmm0,-0x20(%rdi,%rbp,4)
movdqu -0x8a0(%rsi,%rbp,4),%xmm0
ff ff
movdqu -0x890(%rsi,%rbp,4),%xmm1
ff ff
movdqu -0x10(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rbp,4)
movdqu %xmm0,(%rdi,%rbp,4)
add    $0x10,%rbp
cmp    $0x220,%rbp
jne    2a40 <larger_sads+0x1940>
mov    $0x220,%r10d
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %edi,%edi
xchg   %ax,%ax
mov    %rsi,%rbp
mov    (%rax,%rdi,4),%esi
add    (%r8,%rdi,4),%esi
mov    %esi,(%rcx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rbp),%rsi
cmp    $0x1,%edi
jne    2ac0 <larger_sads+0x19c0>
test   %dl,%dl
je     2b29 <larger_sads+0x1a29>
mov    $0x220,%edx
sub    %r10d,%edx
add    $0x1,%rdx
xchg   %ax,%ax
mov    (%rax,%rbp,4),%esi
add    (%r8,%rbp,4),%esi
mov    %esi,(%rcx,%rbp,4)
mov    0x4(%rax,%rbp,4),%esi
add    0x4(%r8,%rbp,4),%esi
mov    %esi,0x4(%rcx,%rbp,4)
mov    0x8(%rax,%rbp,4),%esi
add    0x8(%r8,%rbp,4),%esi
mov    %esi,0x8(%rcx,%rbp,4)
mov    0xc(%rax,%rbp,4),%esi
add    0xc(%r8,%rbp,4),%esi
mov    %esi,0xc(%rcx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edx
jne    2af0 <larger_sads+0x19f0>
mov    0xb8(%rsp),%rdx
lea    0x890(%rdx),%rax
mov    -0x78(%rsp),%rcx
lea    0x1120(%rcx),%r13
mov    0x1b0(%rsp),%rdi
cmp    0x458(%rsp),%rdi
setb   %cl
mov    0x1a8(%rsp),%rsi
cmp    %rsi,0x450(%rsp)
setb   %bl
and    %cl,%bl
cmp    0xf8(%rsp),%rdi
setb   %cl
cmp    %rsi,0x100(%rsp)
setb   %r10b
and    %cl,%r10b
xor    %r8d,%r8d
or     %bl,%r10b
je     2ba0 <larger_sads+0x1aa0>
mov    %r13,%rcx
jmp    2c3d <larger_sads+0x1b3d>
cs nopw 0x0(%rax,%rax,1)
lea    0x880(%r13),%rcx
add    $0x880,%rax
add    $0x880,%rdx
xor    %ebp,%ebp
mov    0xc0(%rsp),%rsi
xchg   %ax,%ax
movdqu -0x8c0(%r12,%rbp,4),%xmm0
f7 ff ff
movdqu -0x8b0(%r12,%rbp,4),%xmm1
f7 ff ff
movdqu -0x30(%r12,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r12,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rbp,4)
movdqu %xmm0,-0x20(%rsi,%rbp,4)
movdqu -0x8a0(%r12,%rbp,4),%xmm0
f7 ff ff
movdqu -0x890(%r12,%rbp,4),%xmm1
f7 ff ff
movdqu -0x10(%r12,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r12,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rbp,4)
movdqu %xmm0,(%rsi,%rbp,4)
add    $0x10,%rbp
cmp    $0x220,%rbp
jne    2bc0 <larger_sads+0x1ac0>
mov    $0x220,%r8d
mov    0x60(%rsp),%r12
mov    $0x1,%ebp
xor    %ebx,%ebx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rsi
mov    (%rax,%rdi,4),%ebp
add    (%rdx,%rdi,4),%ebp
mov    %ebp,(%rcx,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rsi),%rbp
cmp    $0x1,%edi
jne    2c50 <larger_sads+0x1b50>
test   %r10b,%r10b
je     2cb5 <larger_sads+0x1bb5>
mov    $0x220,%ebp
sub    %r8d,%ebp
add    $0x1,%rbp
xchg   %ax,%ax
mov    (%rax,%rsi,4),%edi
add    (%rdx,%rsi,4),%edi
mov    %edi,(%rcx,%rsi,4)
mov    0x4(%rax,%rsi,4),%edi
add    0x4(%rdx,%rsi,4),%edi
mov    %edi,0x4(%rcx,%rsi,4)
mov    0x8(%rax,%rsi,4),%edi
add    0x8(%rdx,%rsi,4),%edi
mov    %edi,0x8(%rcx,%rsi,4)
mov    0xc(%rax,%rsi,4),%edi
add    0xc(%rdx,%rsi,4),%edi
mov    %edi,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%ebp
jne    2c80 <larger_sads+0x1b80>
mov    -0x80(%rsp),%rcx
lea    0x3360(%rcx),%rax
add    $0x3bf0,%rcx
mov    -0x78(%rsp),%rdx
add    $0x19b0,%rdx
mov    0x1d0(%rsp),%rdi
cmp    0x110(%rsp),%rdi
setb   %sil
mov    0x1c8(%rsp),%rbp
cmp    %rbp,0x120(%rsp)
setb   %bl
and    %sil,%bl
cmp    0x108(%rsp),%rdi
setb   %sil
cmp    %rbp,0x118(%rsp)
setb   %r10b
and    %sil,%r10b
xor    %r8d,%r8d
or     %bl,%r10b
jne    2dc1 <larger_sads+0x1cc1>
add    $0x880,%rdx
add    $0x880,%rcx
add    $0x880,%rax
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu -0x8c0(%r14,%rbp,4),%xmm0
f7 ff ff
movdqu -0x8b0(%r14,%rbp,4),%xmm1
f7 ff ff
movdqu -0x30(%r14,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r14,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%r12,%rbp,4)
movdqu %xmm0,-0x20(%r12,%rbp,4)
movdqu -0x8a0(%r14,%rbp,4),%xmm0
f7 ff ff
movdqu -0x890(%r14,%rbp,4),%xmm1
f7 ff ff
movdqu -0x10(%r14,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r14,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%r12,%rbp,4)
movdqu %xmm0,(%r12,%rbp,4)
add    $0x10,%rbp
cmp    $0x220,%rbp
jne    2d40 <larger_sads+0x1c40>
mov    $0x220,%r8d
mov    -0x80(%rsp),%r14
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %ebp,%ebp
nop
mov    %rsi,%rdi
mov    (%rcx,%rbp,4),%esi
add    (%rax,%rbp,4),%esi
mov    %esi,(%rdx,%rbp,4)
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rdi),%rsi
cmp    $0x1,%ebp
jne    2dd0 <larger_sads+0x1cd0>
test   %r10b,%r10b
je     2e35 <larger_sads+0x1d35>
mov    $0x220,%esi
sub    %r8d,%esi
add    $0x1,%rsi
xchg   %ax,%ax
mov    (%rcx,%rdi,4),%ebp
add    (%rax,%rdi,4),%ebp
mov    %ebp,(%rdx,%rdi,4)
mov    0x4(%rcx,%rdi,4),%ebp
add    0x4(%rax,%rdi,4),%ebp
mov    %ebp,0x4(%rdx,%rdi,4)
mov    0x8(%rcx,%rdi,4),%ebp
add    0x8(%rax,%rdi,4),%ebp
mov    %ebp,0x8(%rdx,%rdi,4)
mov    0xc(%rcx,%rdi,4),%ebp
add    0xc(%rax,%rdi,4),%ebp
mov    %ebp,0xc(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %edi,%esi
jne    2e00 <larger_sads+0x1d00>
mov    -0x48(%rsp),%rax
lea    0x890(%rax),%r15
mov    -0x78(%rsp),%rcx
lea    0x2240(%rcx),%r10
mov    0x1e0(%rsp),%rsi
cmp    0x130(%rsp),%rsi
setb   %cl
mov    0x1d8(%rsp),%rdi
cmp    %rdi,-0x30(%rsp)
setb   %dl
and    %cl,%dl
cmp    0x128(%rsp),%rsi
setb   %cl
cmp    %rdi,0x138(%rsp)
setb   %dil
and    %cl,%dil
xor    %r8d,%r8d
or     %dl,%dil
je     2ea0 <larger_sads+0x1da0>
mov    %r10,%rcx
jmp    2f46 <larger_sads+0x1e46>
nopl   0x0(%rax)
lea    0x880(%r10),%rcx
add    $0x880,%r15
add    $0x880,%rax
xor    %esi,%esi
mov    0x3b0(%rsp),%rdx
mov    0x3a8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movdqu -0x8c0(%rdx,%rsi,4),%xmm0
ff ff
movdqu -0x8b0(%rdx,%rsi,4),%xmm1
ff ff
movdqu -0x30(%rdx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rbp,%rsi,4)
movdqu %xmm0,-0x20(%rbp,%rsi,4)
movdqu -0x8a0(%rdx,%rsi,4),%xmm0
ff ff
movdqu -0x890(%rdx,%rsi,4),%xmm1
ff ff
movdqu -0x10(%rdx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rbp,%rsi,4)
movdqu %xmm0,0x0(%rbp,%rsi,4)
add    $0x10,%rsi
cmp    $0x220,%rsi
jne    2ed0 <larger_sads+0x1dd0>
mov    $0x220,%r8d
mov    $0x1,%edx
xor    %ebx,%ebx
xor    %ebp,%ebp
nop
mov    %rdx,%rsi
mov    (%r15,%rbp,4),%edx
add    (%rax,%rbp,4),%edx
mov    %edx,(%rcx,%rbp,4)
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rbx
lea    0x1(%rsi),%rdx
cmp    $0x1,%ebp
jne    2f50 <larger_sads+0x1e50>
test   %dil,%dil
je     2fb9 <larger_sads+0x1eb9>
mov    $0x220,%edx
sub    %r8d,%edx
add    $0x1,%rdx
nop
mov    (%r15,%rsi,4),%edi
add    (%rax,%rsi,4),%edi
mov    %edi,(%rcx,%rsi,4)
mov    0x4(%r15,%rsi,4),%edi
add    0x4(%rax,%rsi,4),%edi
mov    %edi,0x4(%rcx,%rsi,4)
mov    0x8(%r15,%rsi,4),%edi
add    0x8(%rax,%rsi,4),%edi
mov    %edi,0x8(%rcx,%rsi,4)
mov    0xc(%r15,%rsi,4),%edi
add    0xc(%rax,%rsi,4),%edi
mov    %edi,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%edx
jne    2f80 <larger_sads+0x1e80>
lea    0x890(%r11),%rax
mov    -0x78(%rsp),%rcx
lea    0x2ad0(%rcx),%r15
mov    0x208(%rsp),%rsi
cmp    0x148(%rsp),%rsi
setb   %cl
mov    0x1f8(%rsp),%rdi
cmp    %rdi,0x158(%rsp)
setb   %dl
and    %cl,%dl
cmp    0x140(%rsp),%rsi
setb   %cl
cmp    %rdi,0x150(%rsp)
setb   %dil
and    %cl,%dil
xor    %r8d,%r8d
or     %dl,%dil
je     3020 <larger_sads+0x1f20>
mov    %r15,%rcx
jmp    30c6 <larger_sads+0x1fc6>
xchg   %ax,%ax
lea    0x880(%r15),%rcx
add    $0x880,%rax
add    $0x880,%r11
xor    %esi,%esi
mov    0x3c0(%rsp),%rdx
mov    0x3b8(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
movdqu -0x8c0(%rdx,%rsi,4),%xmm0
ff ff
movdqu -0x8b0(%rdx,%rsi,4),%xmm1
ff ff
movdqu -0x30(%rdx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rbp,%rsi,4)
movdqu %xmm0,-0x20(%rbp,%rsi,4)
movdqu -0x8a0(%rdx,%rsi,4),%xmm0
ff ff
movdqu -0x890(%rdx,%rsi,4),%xmm1
ff ff
movdqu -0x10(%rdx,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdx,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rbp,%rsi,4)
movdqu %xmm0,0x0(%rbp,%rsi,4)
add    $0x10,%rsi
cmp    $0x220,%rsi
jne    3050 <larger_sads+0x1f50>
mov    $0x220,%r8d
mov    $0x1,%edx
xor    %esi,%esi
xor    %ebx,%ebx
nop
mov    %rdx,%rbp
mov    (%rax,%rbx,4),%edx
add    (%r11,%rbx,4),%edx
mov    %edx,(%rcx,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rsi
lea    0x1(%rbp),%rdx
cmp    $0x1,%ebx
jne    30d0 <larger_sads+0x1fd0>
test   %dil,%dil
je     3139 <larger_sads+0x2039>
mov    $0x220,%edx
sub    %r8d,%edx
add    $0x1,%rdx
nop
mov    (%rax,%rbp,4),%esi
add    (%r11,%rbp,4),%esi
mov    %esi,(%rcx,%rbp,4)
mov    0x4(%rax,%rbp,4),%esi
add    0x4(%r11,%rbp,4),%esi
mov    %esi,0x4(%rcx,%rbp,4)
mov    0x8(%rax,%rbp,4),%esi
add    0x8(%r11,%rbp,4),%esi
mov    %esi,0x8(%rcx,%rbp,4)
mov    0xc(%rax,%rbp,4),%esi
add    0xc(%r11,%rbp,4),%esi
mov    %esi,0xc(%rcx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edx
jne    3100 <larger_sads+0x2000>
lea    0x66c0(%r14),%rax
lea    0x6f50(%r14),%rcx
mov    -0x78(%rsp),%rdx
add    $0x3360,%rdx
mov    0x1f0(%rsp),%rdi
cmp    0x168(%rsp),%rdi
setb   %sil
mov    0x1e8(%rsp),%rbp
cmp    %rbp,0x178(%rsp)
setb   %bl
and    %sil,%bl
cmp    0x160(%rsp),%rdi
setb   %sil
cmp    %rbp,0x170(%rsp)
setb   %r8b
and    %sil,%r8b
xor    %r11d,%r11d
or     %bl,%r8b
jne    3246 <larger_sads+0x2146>
add    $0x880,%rdx
add    $0x880,%rcx
add    $0x880,%rax
xor    %esi,%esi
mov    0x68(%rsp),%rdi
mov    0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x8c0(%rbp,%rsi,4),%xmm0
ff ff
movdqu -0x8b0(%rbp,%rsi,4),%xmm1
ff ff
movdqu -0x30(%rbp,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rbp,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rsi,4)
movdqu %xmm0,-0x20(%rdi,%rsi,4)
movdqu -0x8a0(%rbp,%rsi,4),%xmm0
ff ff
movdqu -0x890(%rbp,%rsi,4),%xmm1
ff ff
movdqu -0x10(%rbp,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x0(%rbp,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rsi,4)
movdqu %xmm0,(%rdi,%rsi,4)
add    $0x10,%rsi
cmp    $0x220,%rsi
jne    31d0 <larger_sads+0x20d0>
mov    $0x220,%r11d
mov    $0x1,%edi
xor    %esi,%esi
xor    %ebx,%ebx
nop
mov    %rdi,%rbp
mov    (%rcx,%rbx,4),%edi
add    (%rax,%rbx,4),%edi
mov    %edi,(%rdx,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rsi
lea    0x1(%rbp),%rdi
cmp    $0x1,%ebx
jne    3250 <larger_sads+0x2150>
test   %r8b,%r8b
je     32b5 <larger_sads+0x21b5>
mov    $0x220,%ebx
sub    %r11d,%ebx
add    $0x1,%rbx
xchg   %ax,%ax
mov    (%rcx,%rbp,4),%esi
add    (%rax,%rbp,4),%esi
mov    %esi,(%rdx,%rbp,4)
mov    0x4(%rcx,%rbp,4),%esi
add    0x4(%rax,%rbp,4),%esi
mov    %esi,0x4(%rdx,%rbp,4)
mov    0x8(%rcx,%rbp,4),%esi
add    0x8(%rax,%rbp,4),%esi
mov    %esi,0x8(%rdx,%rbp,4)
mov    0xc(%rcx,%rbp,4),%esi
add    0xc(%rax,%rbp,4),%esi
mov    %esi,0xc(%rdx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%ebx
jne    3280 <larger_sads+0x2180>
lea    0x77e0(%r14),%rax
add    $0x8070,%r14
mov    -0x78(%rsp),%rcx
add    $0x3bf0,%rcx
mov    0x210(%rsp),%rsi
cmp    0x188(%rsp),%rsi
setb   %dl
mov    0x200(%rsp),%rdi
cmp    %rdi,0x198(%rsp)
setb   %bl
and    %dl,%bl
cmp    0x180(%rsp),%rsi
setb   %dl
cmp    %rdi,0x190(%rsp)
setb   %r11b
and    %dl,%r11b
xor    %r8d,%r8d
or     %bl,%r11b
jne    33b5 <larger_sads+0x22b5>
add    $0x880,%rcx
add    $0x880,%r14
add    $0x880,%rax
xor    %esi,%esi
mov    0x70(%rsp),%rdx
mov    0x58(%rsp),%rdi
nopl   (%rax)
movdqu -0x8c0(%rdi,%rsi,4),%xmm0
ff ff
movdqu -0x8b0(%rdi,%rsi,4),%xmm1
ff ff
movdqu -0x30(%rdi,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdx,%rsi,4)
movdqu %xmm0,-0x20(%rdx,%rsi,4)
movdqu -0x8a0(%rdi,%rsi,4),%xmm0
ff ff
movdqu -0x890(%rdi,%rsi,4),%xmm1
ff ff
movdqu -0x10(%rdi,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdi,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdx,%rsi,4)
movdqu %xmm0,(%rdx,%rsi,4)
add    $0x10,%rsi
cmp    $0x220,%rsi
jne    3340 <larger_sads+0x2240>
mov    $0x220,%r8d
mov    $0x1,%edi
xor    %esi,%esi
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %rdi,%rbp
mov    (%r14,%rbx,4),%edx
add    (%rax,%rbx,4),%edx
mov    %edx,(%rcx,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rsi
add    $0x1,%rdi
cmp    $0x1,%ebx
jne    33c0 <larger_sads+0x22c0>
test   %r11b,%r11b
je     3429 <larger_sads+0x2329>
mov    $0x220,%edx
sub    %r8d,%edx
add    $0x1,%rdx
nop
mov    (%r14,%rbp,4),%esi
add    (%rax,%rbp,4),%esi
mov    %esi,(%rcx,%rbp,4)
mov    0x4(%r14,%rbp,4),%esi
add    0x4(%rax,%rbp,4),%esi
mov    %esi,0x4(%rcx,%rbp,4)
mov    0x8(%r14,%rbp,4),%esi
add    0x8(%rax,%rbp,4),%esi
mov    %esi,0x8(%rcx,%rbp,4)
mov    0xc(%r14,%rbp,4),%esi
add    0xc(%rax,%rbp,4),%esi
mov    %esi,0xc(%rcx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edx
jne    33f0 <larger_sads+0x22f0>
imul   $0x1120,-0x28(%rsp),%eax
mov    -0x18(%rsp),%rcx
lea    (%rcx,%rax,2),%r8
mov    -0x8(%rsp),%rcx
cmp    0x1a0(%rsp),%rcx
setb   %al
mov    -0x10(%rsp),%rsi
mov    -0x78(%rsp),%rbp
cmp    %rsi,%rbp
setb   %dl
and    %al,%dl
cmp    0x1a8(%rsp),%rcx
setb   %al
cmp    %rsi,0x1b0(%rsp)
setb   %cl
and    %al,%cl
xor    %r11d,%r11d
or     %dl,%cl
mov    0xc0(%rsp),%rdi
je     3490 <larger_sads+0x2390>
mov    %r8,%rax
jmp    3525 <larger_sads+0x2425>
nopl   0x0(%rax,%rax,1)
lea    0x880(%r8),%rax
add    $0x880,%r13
add    $0x880,%rbp
xor    %edx,%edx
mov    0x3c8(%rsp),%rsi
nop
movdqu -0x1150(%rdi,%rdx,4),%xmm0
ff ff
movdqu -0x1140(%rdi,%rdx,4),%xmm1
ff ff
movdqu -0x30(%rdi,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rdx,4)
movdqu %xmm0,-0x20(%rsi,%rdx,4)
movdqu -0x1130(%rdi,%rdx,4),%xmm0
ff ff
movdqu -0x1120(%rdi,%rdx,4),%xmm1
ff ff
movdqu -0x10(%rdi,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdi,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rdx,4)
movdqu %xmm0,(%rsi,%rdx,4)
add    $0x10,%rdx
cmp    $0x220,%rdx
jne    34b0 <larger_sads+0x23b0>
mov    $0x220,%r11d
mov    $0x1,%edi
xor    %esi,%esi
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %rdi,%rdx
mov    0x0(%r13,%rbx,4),%edi
add    0x0(%rbp,%rbx,4),%edi
mov    %edi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rsi
lea    0x1(%rdx),%rdi
cmp    $0x1,%ebx
jne    3530 <larger_sads+0x2430>
test   %cl,%cl
je     359b <larger_sads+0x249b>
mov    $0x220,%ecx
sub    %r11d,%ecx
add    $0x1,%rcx
mov    0x0(%r13,%rdx,4),%esi
add    0x0(%rbp,%rdx,4),%esi
mov    %esi,(%rax,%rdx,4)
mov    0x4(%r13,%rdx,4),%esi
add    0x4(%rbp,%rdx,4),%esi
mov    %esi,0x4(%rax,%rdx,4)
mov    0x8(%r13,%rdx,4),%esi
add    0x8(%rbp,%rdx,4),%esi
mov    %esi,0x8(%rax,%rdx,4)
mov    0xc(%r13,%rdx,4),%esi
add    0xc(%rbp,%rdx,4),%esi
mov    %esi,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%ecx
jne    3560 <larger_sads+0x2460>
lea    0x1120(%r9),%rax
lea    0x890(%r8),%r14
mov    0x8(%rsp),%rsi
cmp    0x1b8(%rsp),%rsi
setb   %cl
mov    (%rsp),%rdi
cmp    %rdi,0x1c0(%rsp)
setb   %dl
and    %cl,%dl
cmp    0x1c8(%rsp),%rsi
setb   %cl
cmp    %rdi,0x1d0(%rsp)
setb   %bl
and    %cl,%bl
xor    %r11d,%r11d
or     %dl,%bl
je     3600 <larger_sads+0x2500>
mov    %r14,%rdx
jmp    369d <larger_sads+0x259d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x880(%r14),%rdx
add    $0x880,%rax
add    $0x880,%r9
xor    %ecx,%ecx
mov    0x3d0(%rsp),%rsi
xchg   %ax,%ax
movdqu -0x1150(%r12,%rcx,4),%xmm0
ee ff ff
movdqu -0x1140(%r12,%rcx,4),%xmm1
ee ff ff
movdqu -0x30(%r12,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%r12,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x1130(%r12,%rcx,4),%xmm0
ee ff ff
movdqu -0x1120(%r12,%rcx,4),%xmm1
ee ff ff
movdqu -0x10(%r12,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%r12,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    3620 <larger_sads+0x2520>
mov    $0x220,%r11d
mov    -0x28(%rsp),%r13
mov    $0x1,%edi
xor    %ecx,%ecx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rbp
mov    (%rax,%rsi,4),%edi
add    (%r9,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbp),%rdi
cmp    $0x1,%esi
jne    36b0 <larger_sads+0x25b0>
test   %bl,%bl
je     3719 <larger_sads+0x2619>
mov    $0x220,%ebx
sub    %r11d,%ebx
add    $0x1,%rbx
xchg   %ax,%ax
mov    (%rax,%rbp,4),%ecx
add    (%r9,%rbp,4),%ecx
mov    %ecx,(%rdx,%rbp,4)
mov    0x4(%rax,%rbp,4),%ecx
add    0x4(%r9,%rbp,4),%ecx
mov    %ecx,0x4(%rdx,%rbp,4)
mov    0x8(%rax,%rbp,4),%ecx
add    0x8(%r9,%rbp,4),%ecx
mov    %ecx,0x8(%rdx,%rbp,4)
mov    0xc(%rax,%rbp,4),%ecx
add    0xc(%r9,%rbp,4),%ecx
mov    %ecx,0xc(%rdx,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%ebx
jne    36e0 <larger_sads+0x25e0>
lea    0x1120(%r10),%rdx
lea    0x1120(%r8),%r12
mov    0x18(%rsp),%rsi
cmp    0x1d8(%rsp),%rsi
setb   %al
mov    0x10(%rsp),%rdi
cmp    %rdi,0x1e0(%rsp)
setb   %cl
and    %al,%cl
cmp    0x1e8(%rsp),%rsi
setb   %al
cmp    %rdi,0x1f0(%rsp)
setb   %r9b
and    %al,%r9b
xor    %edi,%edi
or     %cl,%r9b
je     3780 <larger_sads+0x2680>
mov    %r12,%rax
jmp    3824 <larger_sads+0x2724>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x880(%r12),%rax
add    $0x880,%rdx
add    $0x880,%r10
xor    %ecx,%ecx
mov    0x80(%rsp),%rsi
mov    0x68(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x1150(%rdi,%rcx,4),%xmm0
ff ff
movdqu -0x1140(%rdi,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rdi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x1130(%rdi,%rcx,4),%xmm0
ff ff
movdqu -0x1120(%rdi,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rdi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    37b0 <larger_sads+0x26b0>
mov    $0x220,%edi
mov    0x78(%rsp),%r11
mov    $0x1,%ebx
xor    %ecx,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rbp
mov    (%rdx,%rsi,4),%ebx
add    (%r10,%rsi,4),%ebx
mov    %ebx,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbp),%rbx
cmp    $0x1,%esi
jne    3840 <larger_sads+0x2740>
test   %r9b,%r9b
je     38a9 <larger_sads+0x27a9>
mov    $0x220,%esi
sub    %edi,%esi
add    $0x1,%rsi
xchg   %ax,%ax
mov    (%rdx,%rbp,4),%ecx
add    (%r10,%rbp,4),%ecx
mov    %ecx,(%rax,%rbp,4)
mov    0x4(%rdx,%rbp,4),%ecx
add    0x4(%r10,%rbp,4),%ecx
mov    %ecx,0x4(%rax,%rbp,4)
mov    0x8(%rdx,%rbp,4),%ecx
add    0x8(%r10,%rbp,4),%ecx
mov    %ecx,0x8(%rax,%rbp,4)
mov    0xc(%rdx,%rbp,4),%ecx
add    0xc(%r10,%rbp,4),%ecx
mov    %ecx,0xc(%rax,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%esi
jne    3870 <larger_sads+0x2770>
lea    0x1120(%r15),%rdx
lea    0x19b0(%r8),%rdi
mov    0x20(%rsp),%rsi
cmp    0x1f8(%rsp),%rsi
setb   %al
mov    -0x68(%rsp),%rbp
cmp    %rbp,0x208(%rsp)
setb   %cl
and    %al,%cl
cmp    0x200(%rsp),%rsi
setb   %bl
cmp    %rbp,0x210(%rsp)
setb   %al
and    %bl,%al
xor    %r9d,%r9d
or     %cl,%al
jne    3996 <larger_sads+0x2896>
add    $0x880,%rdi
add    $0x880,%rdx
add    $0x880,%r15
xor    %ecx,%ecx
mov    -0x38(%rsp),%rsi
mov    0x70(%rsp),%rbp
nopl   (%rax)
movdqu -0x1150(%rbp,%rcx,4),%xmm0
ff ff
movdqu -0x1140(%rbp,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rbp,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rbp,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x1130(%rbp,%rcx,4),%xmm0
ff ff
movdqu -0x1120(%rbp,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rbp,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x0(%rbp,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    3920 <larger_sads+0x2820>
mov    $0x220,%r9d
mov    $0x1,%ebx
xor    %ecx,%ecx
xor    %esi,%esi
nop
mov    %rbx,%rbp
mov    (%rdx,%rsi,4),%ebx
add    (%r15,%rsi,4),%ebx
mov    %ebx,(%rdi,%rsi,4)
add    $0x1,%rsi
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rbp),%rbx
cmp    $0x1,%esi
jne    39a0 <larger_sads+0x28a0>
test   %al,%al
je     3a09 <larger_sads+0x2909>
mov    $0x220,%eax
sub    %r9d,%eax
add    $0x1,%rax
xchg   %ax,%ax
mov    (%rdx,%rbp,4),%ecx
add    (%r15,%rbp,4),%ecx
mov    %ecx,(%rdi,%rbp,4)
mov    0x4(%rdx,%rbp,4),%ecx
add    0x4(%r15,%rbp,4),%ecx
mov    %ecx,0x4(%rdi,%rbp,4)
mov    0x8(%rdx,%rbp,4),%ecx
add    0x8(%r15,%rbp,4),%ecx
mov    %ecx,0x8(%rdi,%rbp,4)
mov    0xc(%rdx,%rbp,4),%ecx
add    0xc(%r15,%rbp,4),%ecx
mov    %ecx,0xc(%rdi,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%eax
jne    39d0 <larger_sads+0x28d0>
imul   $0x890,%r13d,%r10d
mov    0xb0(%rsp),%rax
lea    (%rax,%r10,2),%r15
mov    0x460(%rsp),%rdx
cmp    -0x10(%rsp),%rdx
setb   %al
cmp    %r11,-0x8(%rsp)
setb   %cl
and    %al,%cl
cmp    0x10(%rsp),%rdx
setb   %al
cmp    %r11,0x18(%rsp)
setb   %r9b
and    %al,%r9b
xor    %r11d,%r11d
or     %cl,%r9b
mov    %r15,%rax
mov    %r12,%rdx
mov    %r8,%rbp
jne    3b05 <larger_sads+0x2a05>
lea    0x880(%r15),%rax
lea    0x880(%r12),%rdx
lea    0x880(%r8),%rbp
xor    %ecx,%ecx
mov    0x3d8(%rsp),%rsi
mov    0x80(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movdqu -0x1150(%rdi,%rcx,4),%xmm0
ff ff
movdqu -0x1140(%rdi,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rdi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rcx,4)
movdqu %xmm0,-0x20(%rsi,%rcx,4)
movdqu -0x1130(%rdi,%rcx,4),%xmm0
ff ff
movdqu -0x1120(%rdi,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rdi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rcx,4)
movdqu %xmm0,(%rsi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    3a90 <larger_sads+0x2990>
mov    $0x220,%r11d
mov    $0x1,%edi
xor    %ecx,%ecx
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %rdi,%rsi
mov    (%rdx,%rbx,4),%edi
add    0x0(%rbp,%rbx,4),%edi
mov    %edi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rsi),%rdi
cmp    $0x1,%ebx
jne    3b10 <larger_sads+0x2a10>
test   %r9b,%r9b
je     3b76 <larger_sads+0x2a76>
mov    $0x220,%ecx
sub    %r11d,%ecx
add    $0x1,%rcx
nop
mov    (%rdx,%rsi,4),%edi
add    0x0(%rbp,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%rdx,%rsi,4),%edi
add    0x4(%rbp,%rsi,4),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x8(%rdx,%rsi,4),%edi
add    0x8(%rbp,%rsi,4),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0xc(%rdx,%rsi,4),%edi
add    0xc(%rbp,%rsi,4),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    3b40 <larger_sads+0x2a40>
lea    0x1120(%r14),%rdx
add    $0x890,%r15
mov    0x468(%rsp),%rdi
cmp    (%rsp),%rdi
setb   %al
mov    0x470(%rsp),%rsi
cmp    %rsi,0x8(%rsp)
setb   %cl
and    %al,%cl
cmp    -0x68(%rsp),%rdi
setb   %al
cmp    %rsi,0x20(%rsp)
setb   %r9b
and    %al,%r9b
xor    %ebp,%ebp
or     %cl,%r9b
je     3bd0 <larger_sads+0x2ad0>
mov    %r14,%rax
jmp    3c74 <larger_sads+0x2b74>
nopl   0x0(%rax,%rax,1)
add    $0x880,%r15
add    $0x880,%rdx
lea    0x880(%r14),%rax
xor    %ecx,%ecx
mov    -0x38(%rsp),%rsi
mov    0x3e0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x1150(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x1140(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x30(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdi,%rcx,4)
movdqu %xmm0,-0x20(%rdi,%rcx,4)
movdqu -0x1130(%rsi,%rcx,4),%xmm0
ff ff
movdqu -0x1120(%rsi,%rcx,4),%xmm1
ff ff
movdqu -0x10(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdi,%rcx,4)
movdqu %xmm0,(%rdi,%rcx,4)
add    $0x10,%rcx
cmp    $0x220,%rcx
jne    3c00 <larger_sads+0x2b00>
mov    $0x220,%ebp
mov    0xa8(%rsp),%r11
mov    $0x1,%edi
xor    %ecx,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%rsi
mov    (%rdx,%rbx,4),%edi
add    (%rax,%rbx,4),%edi
mov    %edi,(%r15,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rcx
lea    0x1(%rsi),%rdi
cmp    $0x1,%ebx
jne    3c90 <larger_sads+0x2b90>
test   %r9b,%r9b
je     3cf9 <larger_sads+0x2bf9>
mov    $0x220,%ecx
sub    %ebp,%ecx
add    $0x1,%rcx
xchg   %ax,%ax
mov    (%rdx,%rsi,4),%edi
add    (%rax,%rsi,4),%edi
mov    %edi,(%r15,%rsi,4)
mov    0x4(%rdx,%rsi,4),%edi
add    0x4(%rax,%rsi,4),%edi
mov    %edi,0x4(%r15,%rsi,4)
mov    0x8(%rdx,%rsi,4),%edi
add    0x8(%rax,%rsi,4),%edi
mov    %edi,0x8(%r15,%rsi,4)
mov    0xc(%rdx,%rsi,4),%edi
add    0xc(%rax,%rsi,4),%edi
mov    %edi,0xc(%r15,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    3cc0 <larger_sads+0x2bc0>
mov    -0x20(%rsp),%rax
lea    (%rax,%r10,2),%r10
mov    0x220(%rsp),%rdx
cmp    -0x10(%rsp),%rdx
setb   %al
mov    0x218(%rsp),%rsi
cmp    %rsi,-0x8(%rsp)
setb   %cl
and    %al,%cl
cmp    (%rsp),%rdx
setb   %al
cmp    %rsi,0x8(%rsp)
setb   %dl
and    %al,%dl
xor    %r9d,%r9d
or     %cl,%dl
je     3d50 <larger_sads+0x2c50>
mov    %r10,%rax
mov    0x88(%rsp),%r15
jmp    3df9 <larger_sads+0x2cf9>
nopl   0x0(%rax)
lea    0x880(%r10),%rax
add    $0x880,%r14
add    $0x880,%r8
mov    $0xc,%ecx
mov    0x88(%rsp),%r15
mov    0x3e8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rcx,4),%xmm0
movdqu -0x20(%rsi,%rcx,4),%xmm1
movdqu 0x860(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x870(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%r15,%rcx,4)
movdqu %xmm0,-0x20(%r15,%rcx,4)
movdqu -0x10(%rsi,%rcx,4),%xmm0
movdqu (%rsi,%rcx,4),%xmm1
movdqu 0x880(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x890(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%r15,%rcx,4)
movdqu %xmm0,(%r15,%rcx,4)
add    $0x10,%rcx
cmp    $0x22c,%rcx
jne    3d80 <larger_sads+0x2c80>
mov    $0x220,%r9d
mov    $0x1,%ebp
xor    %ecx,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    (%r14,%rbx,4),%esi
add    (%r8,%rbx,4),%esi
mov    %esi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rcx
add    $0x1,%rbp
cmp    $0x1,%ebx
jne    3e10 <larger_sads+0x2d10>
test   %dl,%dl
je     3e7d <larger_sads+0x2d7d>
mov    $0x220,%ecx
sub    %r9d,%ecx
add    $0x1,%rcx
nop
mov    (%r14,%rdi,4),%edx
add    (%r8,%rdi,4),%edx
mov    %edx,(%rax,%rdi,4)
mov    0x4(%r14,%rdi,4),%edx
add    0x4(%r8,%rdi,4),%edx
mov    %edx,0x4(%rax,%rdi,4)
mov    0x8(%r14,%rdi,4),%edx
add    0x8(%r8,%rdi,4),%edx
mov    %edx,0x8(%rax,%rdi,4)
mov    0xc(%r14,%rdi,4),%edx
add    0xc(%r8,%rdi,4),%edx
mov    %edx,0xc(%rax,%rdi,4)
add    $0x4,%rdi
cmp    %edi,%ecx
jne    3e40 <larger_sads+0x2d40>
lea    0x890(%r12),%rdx
lea    0x890(%r10),%rcx
mov    0x228(%rsp),%rsi
cmp    0x10(%rsp),%rsi
setb   %al
mov    -0x58(%rsp),%rdi
cmp    %rdi,0x18(%rsp)
setb   %bl
and    %al,%bl
cmp    -0x68(%rsp),%rsi
setb   %al
cmp    %rdi,0x20(%rsp)
setb   %r9b
and    %al,%r9b
xor    %r8d,%r8d
or     %bl,%r9b
je     3ed0 <larger_sads+0x2dd0>
mov    %rcx,%rax
jmp    3f75 <larger_sads+0x2e75>
nop
lea    0x880(%rcx),%rax
add    $0x880,%rdx
add    $0x880,%r12
xor    %ebp,%ebp
mov    0x3f0(%rsp),%rsi
mov    -0x38(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x8c0(%rdi,%rbp,4),%xmm0
ff ff
movdqu -0x8b0(%rdi,%rbp,4),%xmm1
ff ff
movdqu -0x30(%rdi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rdi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rbp,4)
movdqu %xmm0,-0x20(%rsi,%rbp,4)
movdqu -0x8a0(%rdi,%rbp,4),%xmm0
ff ff
movdqu -0x890(%rdi,%rbp,4),%xmm1
ff ff
movdqu -0x10(%rdi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rdi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rbp,4)
movdqu %xmm0,(%rsi,%rbp,4)
add    $0x10,%rbp
cmp    $0x220,%rbp
jne    3f00 <larger_sads+0x2e00>
mov    $0x220,%r8d
mov    0x98(%rsp),%r14
mov    $0x1,%esi
xor    %edi,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%rbp
mov    (%rdx,%rbx,4),%esi
add    (%r12,%rbx,4),%esi
mov    %esi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rdi
lea    0x1(%rbp),%rsi
cmp    $0x1,%ebx
jne    3f90 <larger_sads+0x2e90>
test   %r9b,%r9b
je     3ff9 <larger_sads+0x2ef9>
mov    $0x220,%edi
sub    %r8d,%edi
add    $0x1,%rdi
nop
mov    (%rdx,%rbp,4),%esi
add    (%r12,%rbp,4),%esi
mov    %esi,(%rax,%rbp,4)
mov    0x4(%rdx,%rbp,4),%esi
add    0x4(%r12,%rbp,4),%esi
mov    %esi,0x4(%rax,%rbp,4)
mov    0x8(%rdx,%rbp,4),%esi
add    0x8(%r12,%rbp,4),%esi
mov    %esi,0x8(%rax,%rbp,4)
mov    0xc(%rdx,%rbp,4),%esi
add    0xc(%r12,%rbp,4),%esi
mov    %esi,0xc(%rax,%rbp,4)
add    $0x4,%rbp
cmp    %ebp,%edi
jne    3fc0 <larger_sads+0x2ec0>
imul   $0x448,%r13d,%eax
mov    -0x50(%rsp),%rdx
lea    (%rdx,%rax,2),%rax
mov    0x478(%rsp),%rdi
cmp    0x218(%rsp),%rdi
setb   %dl
mov    -0x40(%rsp),%rsi
cmp    %rsi,0x220(%rsp)
setb   %bl
and    %dl,%bl
cmp    -0x58(%rsp),%rdi
setb   %dl
cmp    %rsi,0x228(%rsp)
setb   %r9b
and    %dl,%r9b
xor    %r8d,%r8d
or     %bl,%r9b
jne    40fd <larger_sads+0x2ffd>
add    $0x880,%rax
add    $0x880,%rcx
add    $0x880,%r10
mov    $0xc,%edi
mov    0x3f8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x30(%r15,%rdi,4),%xmm0
movdqu -0x20(%r15,%rdi,4),%xmm1
movdqu 0x860(%r15,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x870(%r15,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rdx,%rdi,4)
movdqu %xmm0,-0x20(%rdx,%rdi,4)
movdqu -0x10(%r15,%rdi,4),%xmm0
movdqu (%r15,%rdi,4),%xmm1
movdqu 0x880(%r15,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x890(%r15,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rdx,%rdi,4)
movdqu %xmm0,(%rdx,%rdi,4)
add    $0x10,%rdi
cmp    $0x22c,%rdi
jne    4080 <larger_sads+0x2f80>
mov    $0x220,%r8d
mov    0x90(%rsp),%r15
mov    0xa0(%rsp),%r12
mov    $0x1,%esi
xor    %ebx,%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%rdi
mov    (%rcx,%rbp,4),%edx
add    (%r10,%rbp,4),%edx
mov    %edx,(%rax,%rbp,4)
add    $0x1,%rbp
add    $0xfffffffffffffffc,%rbx
add    $0x1,%rsi
cmp    $0x1,%ebp
jne    4120 <larger_sads+0x3020>
test   %r9b,%r9b
je     13d0 <larger_sads+0x2d0>
mov    $0x220,%edx
sub    %r8d,%edx
add    $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx,%rdi,4),%esi
add    (%r10,%rdi,4),%esi
mov    %esi,(%rax,%rdi,4)
mov    0x4(%rcx,%rdi,4),%esi
add    0x4(%r10,%rdi,4),%esi
mov    %esi,0x4(%rax,%rdi,4)
mov    0x8(%rcx,%rdi,4),%esi
add    0x8(%r10,%rdi,4),%esi
mov    %esi,0x8(%rax,%rdi,4)
mov    0xc(%rcx,%rdi,4),%esi
add    0xc(%r10,%rdi,4),%esi
mov    %esi,0xc(%rax,%rdi,4)
add    $0x4,%rdi
cmp    %edi,%edx
jne    4160 <larger_sads+0x3060>
jmp    13d0 <larger_sads+0x2d0>
add    $0x480,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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