int main(int argc, char *argv[]) {
  __attribute__((vector_size((8) * sizeof(short)))) short v0 = {argc, 1, 2, 3,
                                                                4,    5, 6, 7};
  __attribute__((vector_size((8) * sizeof(short)))) short v1;
  __attribute__((vector_size((4) * sizeof(float)))) float f0 = {1., 2., 3., 4.};
  __attribute__((vector_size((4) * sizeof(float)))) float f1, f2;
  __attribute__((vector_size((2) * sizeof(double)))) double d0 = {1., 2.};
  __attribute__((vector_size((2) * sizeof(double)))) double d1, d2;
  v1 = 2 + v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 + (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 - v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 - (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 * v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 * (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 / v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 / (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 % v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 % (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 ^ v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 ^ (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 & v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 & (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 | v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 | (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 << v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 << (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = 2 >> v0;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != (2 >> (*((short *)&(v0) + __i))))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 + 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) + 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 - 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) - 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 * 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) * 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 / 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) / 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 % 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) % 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 ^ 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) ^ 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 & 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) & 2))
        __builtin_abort();
    }
  } while (0);
  v1 = v0 | 2;
  do {
    int __i;
    for (__i = 0; __i < 8; __i++) {
      if ((*((short *)&(v1) + __i)) != ((*((short *)&(v0) + __i)) | 2))
        __builtin_abort();
    }
  } while (0);
  f1 = 2. + f0;
  f2 = (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2., 2.,
                                                                 2.} +
       f0;
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = 2. - f0;
  f2 = (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2., 2.,
                                                                 2.} -
       f0;
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = 2. * f0;
  f2 = (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2., 2.,
                                                                 2.} *
       f0;
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = 2. / f0;
  f2 = (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2., 2.,
                                                                 2.} /
       f0;
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = f0 + 2.;
  f2 = f0 + (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2.,
                                                                      2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = f0 - 2.;
  f2 = f0 - (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2.,
                                                                      2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = f0 * 2.;
  f2 = f0 * (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2.,
                                                                      2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  f1 = f0 / 2.;
  f2 = f0 / (__attribute__((vector_size((4) * sizeof(float)))) float){2., 2.,
                                                                      2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 4; __i++) {
      if ((*((float *)&(f1) + __i)) != (*((float *)&(f2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = 2. + d0;
  d2 = (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.} + d0;
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = 2. - d0;
  d2 = (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.} - d0;
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = 2. * d0;
  d2 = (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.} * d0;
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = 2. / d0;
  d2 = (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.} / d0;
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = d0 + 2.;
  d2 = d0 + (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = d0 - 2.;
  d2 = d0 - (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = d0 * 2.;
  d2 = d0 * (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  d1 = d0 / 2.;
  d2 = d0 / (__attribute__((vector_size((2) * sizeof(double)))) double){2., 2.};
  do {
    int __i;
    for (__i = 0; __i < 2; __i++) {
      if ((*((double *)&(d1) + __i)) != (*((double *)&(d2) + __i)))
        __builtin_abort();
    }
  } while (0);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movaps 0x1ed0(%rip),%xmm0
mov    -0x8(%rbp),%eax
pinsrw $0x0,%eax,%xmm0
movaps %xmm0,-0x20(%rbp)
movaps 0x1ecd(%rip),%xmm0
movaps %xmm0,-0x40(%rbp)
movapd 0x1ed1(%rip),%xmm0
movapd %xmm0,-0x70(%rbp)
movaps -0x20(%rbp),%xmm0
movaps 0x1ed1(%rip),%xmm1
paddw  %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x8,-0x94(%rbp)
jge    11c0 <main+0xb0>
movslq -0x94(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0x94(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     11a7 <main+0x97>
call   1030 <abort@plt>
jmp    11ac <main+0x9c>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1172 <main+0x62>
jmp    11c5 <main+0xb5>
movaps -0x20(%rbp),%xmm1
movaps 0x1e60(%rip),%xmm0
psubw  %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0x98(%rbp)
cmpl   $0x8,-0x98(%rbp)
jge    1235 <main+0x125>
movslq -0x98(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0x98(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%edx
mov    $0x2,%ecx
sub    %edx,%ecx
cmp    %ecx,%eax
je     121c <main+0x10c>
call   1030 <abort@plt>
jmp    1221 <main+0x111>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    11e3 <main+0xd3>
jmp    123a <main+0x12a>
movaps -0x20(%rbp),%xmm0
paddw  %xmm0,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0x9c(%rbp)
cmpl   $0x8,-0x9c(%rbp)
jge    129f <main+0x18f>
movslq -0x9c(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0x9c(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
je     1286 <main+0x176>
call   1030 <abort@plt>
jmp    128b <main+0x17b>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1251 <main+0x141>
jmp    12a4 <main+0x194>
movaps -0x20(%rbp),%xmm0
movaps %xmm0,-0x2f0(%rbp)
xor    %eax,%eax
mov    %ax,%dx
mov    %dx,-0x2d8(%rbp)
pextrw $0x7,%xmm0,%eax
mov    %ax,%cx
mov    $0x2,%ax
mov    %ax,-0x2d6(%rbp)
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm1
pextrw $0x6,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm2
punpcklwd %xmm1,%xmm2
pextrw $0x5,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm3
pextrw $0x4,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm1
punpcklwd %xmm3,%xmm1
punpckldq %xmm2,%xmm1
pextrw $0x3,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm3
pextrw $0x2,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm2
punpcklwd %xmm3,%xmm2
pextrw $0x1,%xmm0,%ecx
idiv   %cx
mov    -0x2d8(%rbp),%dx
mov    %ax,%si
mov    -0x2d6(%rbp),%ax
mov    %si,%cx
movd   %ecx,%xmm3
movd   %xmm0,%ecx
idiv   %cx
mov    %ax,%cx
mov    %cx,%ax
movd   %eax,%xmm0
punpcklwd %xmm3,%xmm0
punpckldq %xmm2,%xmm0
punpcklqdq %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xa0(%rbp)
cmpl   $0x8,-0xa0(%rbp)
jge    1446 <main+0x336>
movslq -0xa0(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
mov    %eax,-0x2f4(%rbp)
movslq -0xa0(%rbp),%rax
movswl -0x20(%rbp,%rax,2),%ecx
mov    $0x2,%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2f4(%rbp),%eax
cmp    %ecx,%eax
je     142d <main+0x31d>
call   1030 <abort@plt>
jmp    1432 <main+0x322>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13e5 <main+0x2d5>
jmp    144b <main+0x33b>
movaps -0x20(%rbp),%xmm0
movaps %xmm0,-0x310(%rbp)
xor    %eax,%eax
mov    %ax,%dx
mov    %dx,-0x2f6(%rbp)
pextrw $0x7,%xmm0,%eax
mov    %ax,%cx
mov    $0x2,%ax
mov    %ax,-0x2f8(%rbp)
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm1
pextrw $0x6,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm2
punpcklwd %xmm1,%xmm2
pextrw $0x5,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm3
pextrw $0x4,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm1
punpcklwd %xmm3,%xmm1
punpckldq %xmm2,%xmm1
pextrw $0x3,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm3
pextrw $0x2,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm2
punpcklwd %xmm3,%xmm2
pextrw $0x1,%xmm0,%ecx
idiv   %cx
mov    -0x2f8(%rbp),%ax
mov    %dx,%si
mov    -0x2f6(%rbp),%dx
mov    %si,%cx
movd   %ecx,%xmm3
movd   %xmm0,%ecx
idiv   %cx
mov    %dx,%ax
movd   %eax,%xmm0
punpcklwd %xmm3,%xmm0
punpckldq %xmm2,%xmm0
punpcklqdq %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xa4(%rbp)
cmpl   $0x8,-0xa4(%rbp)
jge    15e8 <main+0x4d8>
movslq -0xa4(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
mov    %eax,-0x314(%rbp)
movslq -0xa4(%rbp),%rax
movswl -0x20(%rbp,%rax,2),%ecx
mov    $0x2,%eax
cltd
idiv   %ecx
mov    -0x314(%rbp),%eax
cmp    %edx,%eax
je     15cf <main+0x4bf>
call   1030 <abort@plt>
jmp    15d4 <main+0x4c4>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1589 <main+0x479>
jmp    15ed <main+0x4dd>
movaps -0x20(%rbp),%xmm0
movaps 0x1a38(%rip),%xmm1
pxor   %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xa8(%rbp)
cmpl   $0x8,-0xa8(%rbp)
jge    1659 <main+0x549>
movslq -0xa8(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xa8(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
xor    $0x2,%ecx
cmp    %ecx,%eax
je     1640 <main+0x530>
call   1030 <abort@plt>
jmp    1645 <main+0x535>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    160b <main+0x4fb>
jmp    165e <main+0x54e>
movaps -0x20(%rbp),%xmm0
movaps 0x19c7(%rip),%xmm1
pand   %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xac(%rbp)
cmpl   $0x8,-0xac(%rbp)
jge    16ca <main+0x5ba>
movslq -0xac(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xac(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
and    $0x2,%ecx
cmp    %ecx,%eax
je     16b1 <main+0x5a1>
call   1030 <abort@plt>
jmp    16b6 <main+0x5a6>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    167c <main+0x56c>
jmp    16cf <main+0x5bf>
movaps -0x20(%rbp),%xmm0
movaps 0x1956(%rip),%xmm1
por    %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xb0(%rbp)
cmpl   $0x8,-0xb0(%rbp)
jge    173b <main+0x62b>
movslq -0xb0(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xb0(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
or     $0x2,%ecx
cmp    %ecx,%eax
je     1722 <main+0x612>
call   1030 <abort@plt>
jmp    1727 <main+0x617>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    16ed <main+0x5dd>
jmp    1740 <main+0x630>
movaps -0x20(%rbp),%xmm0
movaps %xmm0,%xmm1
punpckhwd %xmm2,%xmm1
pslld  $0x17,%xmm1
movaps 0x18e9(%rip),%xmm2
paddd  %xmm2,%xmm1
cvttps2dq %xmm1,%xmm1
pslld  $0x10,%xmm1
psrad  $0x10,%xmm1
punpcklwd %xmm3,%xmm0
pslld  $0x17,%xmm0
paddd  %xmm2,%xmm0
cvttps2dq %xmm0,%xmm0
pslld  $0x10,%xmm0
psrad  $0x10,%xmm0
packssdw %xmm1,%xmm0
paddw  %xmm0,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xb4(%rbp)
cmpl   $0x8,-0xb4(%rbp)
jge    17ef <main+0x6df>
movslq -0xb4(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xb4(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
mov    $0x2,%edx
shl    %cl,%edx
mov    %edx,%ecx
cmp    %ecx,%eax
je     17d6 <main+0x6c6>
call   1030 <abort@plt>
jmp    17db <main+0x6cb>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    179b <main+0x68b>
jmp    17f4 <main+0x6e4>
movaps -0x20(%rbp),%xmm1
psllw  $0xc,%xmm1
movaps %xmm1,%xmm2
paddw  %xmm2,%xmm2
movaps %xmm2,%xmm0
psraw  $0xf,%xmm0
pcmpeqd %xmm3,%xmm3
pxor   %xmm3,%xmm0
psraw  $0xf,%xmm1
pandn  %xmm0,%xmm1
movaps 0x180c(%rip),%xmm0
pand   %xmm0,%xmm1
paddw  %xmm2,%xmm2
movaps %xmm2,%xmm0
psraw  $0xf,%xmm0
pandn  %xmm1,%xmm0
paddw  %xmm2,%xmm2
psraw  $0xf,%xmm2
movaps %xmm2,%xmm1
pandn  %xmm0,%xmm1
psrlw  $0x1,%xmm0
pand   %xmm2,%xmm0
por    %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xb8(%rbp)
cmpl   $0x8,-0xb8(%rbp)
jge    18b8 <main+0x7a8>
movslq -0xb8(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xb8(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
mov    $0x2,%edx
sar    %cl,%edx
mov    %edx,%ecx
cmp    %ecx,%eax
je     189f <main+0x78f>
call   1030 <abort@plt>
jmp    18a4 <main+0x794>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1864 <main+0x754>
jmp    18bd <main+0x7ad>
movaps -0x20(%rbp),%xmm0
movaps 0x1768(%rip),%xmm1
paddw  %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xbc(%rbp)
cmpl   $0x8,-0xbc(%rbp)
jge    1929 <main+0x819>
movslq -0xbc(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xbc(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
je     1910 <main+0x800>
call   1030 <abort@plt>
jmp    1915 <main+0x805>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    18db <main+0x7cb>
jmp    192e <main+0x81e>
movaps -0x20(%rbp),%xmm0
movaps 0x16f7(%rip),%xmm1
psubw  %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xc0(%rbp)
cmpl   $0x8,-0xc0(%rbp)
jge    199a <main+0x88a>
movslq -0xc0(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xc0(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
je     1981 <main+0x871>
call   1030 <abort@plt>
jmp    1986 <main+0x876>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    194c <main+0x83c>
jmp    199f <main+0x88f>
movaps -0x20(%rbp),%xmm0
paddw  %xmm0,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x8,-0xc4(%rbp)
jge    1a04 <main+0x8f4>
movslq -0xc4(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xc4(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
je     19eb <main+0x8db>
call   1030 <abort@plt>
jmp    19f0 <main+0x8e0>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    19b6 <main+0x8a6>
jmp    1a09 <main+0x8f9>
movaps -0x20(%rbp),%xmm0
movaps %xmm0,%xmm1
psrlw  $0xf,%xmm1
paddw  %xmm1,%xmm0
psraw  $0x1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xc8(%rbp)
cmpl   $0x8,-0xc8(%rbp)
jge    1a8e <main+0x97e>
movslq -0xc8(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
mov    %eax,-0x318(%rbp)
movslq -0xc8(%rbp),%rax
movswl -0x20(%rbp,%rax,2),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x318(%rbp),%eax
cmp    %ecx,%eax
je     1a75 <main+0x965>
call   1030 <abort@plt>
jmp    1a7a <main+0x96a>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1a2d <main+0x91d>
jmp    1a93 <main+0x983>
movaps -0x20(%rbp),%xmm0
movaps %xmm0,%xmm2
psrlw  $0xf,%xmm2
movaps %xmm0,%xmm1
paddw  %xmm2,%xmm1
psraw  $0x1,%xmm1
paddw  %xmm1,%xmm1
psubw  %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xcc(%rbp)
cmpl   $0x8,-0xcc(%rbp)
jge    1b21 <main+0xa11>
movslq -0xcc(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
mov    %eax,-0x31c(%rbp)
movslq -0xcc(%rbp),%rax
movswl -0x20(%rbp,%rax,2),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x31c(%rbp),%eax
cmp    %edx,%eax
je     1b08 <main+0x9f8>
call   1030 <abort@plt>
jmp    1b0d <main+0x9fd>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1ac2 <main+0x9b2>
jmp    1b26 <main+0xa16>
movaps -0x20(%rbp),%xmm0
movaps 0x14ff(%rip),%xmm1
pxor   %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xd0(%rbp)
cmpl   $0x8,-0xd0(%rbp)
jge    1b92 <main+0xa82>
movslq -0xd0(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xd0(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
xor    $0x2,%ecx
cmp    %ecx,%eax
je     1b79 <main+0xa69>
call   1030 <abort@plt>
jmp    1b7e <main+0xa6e>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    1b44 <main+0xa34>
jmp    1b97 <main+0xa87>
movaps -0x20(%rbp),%xmm0
movaps 0x148e(%rip),%xmm1
pand   %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xd4(%rbp)
cmpl   $0x8,-0xd4(%rbp)
jge    1c03 <main+0xaf3>
movslq -0xd4(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xd4(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
and    $0x2,%ecx
cmp    %ecx,%eax
je     1bea <main+0xada>
call   1030 <abort@plt>
jmp    1bef <main+0xadf>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1bb5 <main+0xaa5>
jmp    1c08 <main+0xaf8>
movaps -0x20(%rbp),%xmm0
movaps 0x141d(%rip),%xmm1
por    %xmm1,%xmm0
movdqa %xmm0,-0x30(%rbp)
movl   $0x0,-0xd8(%rbp)
cmpl   $0x8,-0xd8(%rbp)
jge    1c74 <main+0xb64>
movslq -0xd8(%rbp),%rax
movswl -0x30(%rbp,%rax,2),%eax
movslq -0xd8(%rbp),%rcx
movswl -0x20(%rbp,%rcx,2),%ecx
or     $0x2,%ecx
cmp    %ecx,%eax
je     1c5b <main+0xb4b>
call   1030 <abort@plt>
jmp    1c60 <main+0xb50>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    1c26 <main+0xb16>
jmp    1c79 <main+0xb69>
movaps -0x40(%rbp),%xmm1
movaps 0x13cc(%rip),%xmm0
addps  %xmm0,%xmm1
movaps %xmm1,-0x50(%rbp)
movaps %xmm0,-0xf0(%rbp)
movaps -0xf0(%rbp),%xmm0
addps  -0x40(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0xf4(%rbp)
cmpl   $0x4,-0xf4(%rbp)
jge    1d00 <main+0xbf0>
movslq -0xf4(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0xf4(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1ce2 <main+0xbd2>
jp     1ce2 <main+0xbd2>
jmp    1ce7 <main+0xbd7>
call   1030 <abort@plt>
jmp    1cec <main+0xbdc>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1cab <main+0xb9b>
jmp    1d05 <main+0xbf5>
movaps -0x40(%rbp),%xmm2
movaps 0x1340(%rip),%xmm0
movaps %xmm0,%xmm1
subps  %xmm2,%xmm1
movaps %xmm1,-0x50(%rbp)
movaps %xmm0,-0x110(%rbp)
movaps -0x110(%rbp),%xmm0
subps  -0x40(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x114(%rbp)
cmpl   $0x4,-0x114(%rbp)
jge    1d8f <main+0xc7f>
movslq -0x114(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x114(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1d71 <main+0xc61>
jp     1d71 <main+0xc61>
jmp    1d76 <main+0xc66>
call   1030 <abort@plt>
jmp    1d7b <main+0xc6b>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1d3a <main+0xc2a>
jmp    1d94 <main+0xc84>
movaps -0x40(%rbp),%xmm1
addps  %xmm1,%xmm1
movaps 0x12ae(%rip),%xmm0
movaps %xmm1,-0x50(%rbp)
movaps %xmm0,-0x130(%rbp)
movaps -0x130(%rbp),%xmm0
mulps  -0x40(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x134(%rbp)
cmpl   $0x4,-0x134(%rbp)
jge    1e1b <main+0xd0b>
movslq -0x134(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x134(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1dfd <main+0xced>
jp     1dfd <main+0xced>
jmp    1e02 <main+0xcf2>
call   1030 <abort@plt>
jmp    1e07 <main+0xcf7>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1dc6 <main+0xcb6>
jmp    1e20 <main+0xd10>
movaps -0x40(%rbp),%xmm2
movaps 0x1225(%rip),%xmm0
movaps %xmm0,%xmm1
divps  %xmm2,%xmm1
movaps %xmm1,-0x50(%rbp)
movaps %xmm0,-0x150(%rbp)
movaps -0x150(%rbp),%xmm0
divps  -0x40(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x4,-0x154(%rbp)
jge    1eaa <main+0xd9a>
movslq -0x154(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x154(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1e8c <main+0xd7c>
jp     1e8c <main+0xd7c>
jmp    1e91 <main+0xd81>
call   1030 <abort@plt>
jmp    1e96 <main+0xd86>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1e55 <main+0xd45>
jmp    1eaf <main+0xd9f>
movaps -0x40(%rbp),%xmm0
movaps 0x1196(%rip),%xmm1
addps  %xmm1,%xmm0
movaps %xmm0,-0x50(%rbp)
movaps -0x40(%rbp),%xmm0
movaps %xmm1,-0x170(%rbp)
addps  -0x170(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x174(%rbp)
cmpl   $0x4,-0x174(%rbp)
jge    1f36 <main+0xe26>
movslq -0x174(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x174(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1f18 <main+0xe08>
jp     1f18 <main+0xe08>
jmp    1f1d <main+0xe0d>
call   1030 <abort@plt>
jmp    1f22 <main+0xe12>
mov    -0x174(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x174(%rbp)
jmp    1ee1 <main+0xdd1>
jmp    1f3b <main+0xe2b>
movaps -0x40(%rbp),%xmm0
movaps 0x110a(%rip),%xmm1
subps  %xmm1,%xmm0
movaps %xmm0,-0x50(%rbp)
movaps -0x40(%rbp),%xmm0
movaps %xmm1,-0x190(%rbp)
subps  -0x190(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x194(%rbp)
cmpl   $0x4,-0x194(%rbp)
jge    1fc2 <main+0xeb2>
movslq -0x194(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x194(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    1fa4 <main+0xe94>
jp     1fa4 <main+0xe94>
jmp    1fa9 <main+0xe99>
call   1030 <abort@plt>
jmp    1fae <main+0xe9e>
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    1f6d <main+0xe5d>
jmp    1fc7 <main+0xeb7>
movaps -0x40(%rbp),%xmm0
addps  %xmm0,%xmm0
movaps 0x107b(%rip),%xmm1
movaps %xmm0,-0x50(%rbp)
movaps -0x40(%rbp),%xmm0
movaps %xmm1,-0x1b0(%rbp)
mulps  -0x1b0(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x1b4(%rbp)
cmpl   $0x4,-0x1b4(%rbp)
jge    204e <main+0xf3e>
movslq -0x1b4(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x1b4(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    2030 <main+0xf20>
jp     2030 <main+0xf20>
jmp    2035 <main+0xf25>
call   1030 <abort@plt>
jmp    203a <main+0xf2a>
mov    -0x1b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
jmp    1ff9 <main+0xee9>
jmp    2053 <main+0xf43>
movaps -0x40(%rbp),%xmm0
movaps 0xff2(%rip),%xmm1
divps  %xmm1,%xmm0
movaps %xmm0,-0x50(%rbp)
movaps -0x40(%rbp),%xmm0
movaps %xmm1,-0x1d0(%rbp)
divps  -0x1d0(%rbp),%xmm0
movaps %xmm0,-0x60(%rbp)
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x4,-0x1d4(%rbp)
jge    20da <main+0xfca>
movslq -0x1d4(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x1d4(%rbp),%rax
ucomiss -0x60(%rbp,%rax,4),%xmm0
jne    20bc <main+0xfac>
jp     20bc <main+0xfac>
jmp    20c1 <main+0xfb1>
call   1030 <abort@plt>
jmp    20c6 <main+0xfb6>
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    2085 <main+0xf75>
jmp    20df <main+0xfcf>
movapd -0x70(%rbp),%xmm1
movapd 0xf74(%rip),%xmm0
addpd  %xmm0,%xmm1
movapd %xmm1,-0x80(%rbp)
movapd %xmm0,-0x1f0(%rbp)
ff
movapd -0x1f0(%rbp),%xmm0
ff
addpd  -0x70(%rbp),%xmm0
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x1f4(%rbp)
cmpl   $0x2,-0x1f4(%rbp)
jge    2175 <main+0x1065>
movslq -0x1f4(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x1f4(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    2157 <main+0x1047>
jp     2157 <main+0x1047>
jmp    215c <main+0x104c>
call   1030 <abort@plt>
jmp    2161 <main+0x1051>
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    211c <main+0x100c>
jmp    217a <main+0x106a>
movapd -0x70(%rbp),%xmm2
movapd 0xed9(%rip),%xmm0
movaps %xmm0,%xmm1
subpd  %xmm2,%xmm1
movapd %xmm1,-0x80(%rbp)
movapd %xmm0,-0x210(%rbp)
ff
movapd -0x210(%rbp),%xmm0
ff
subpd  -0x70(%rbp),%xmm0
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x214(%rbp)
cmpl   $0x2,-0x214(%rbp)
jge    2213 <main+0x1103>
movslq -0x214(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x214(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    21f5 <main+0x10e5>
jp     21f5 <main+0x10e5>
jmp    21fa <main+0x10ea>
call   1030 <abort@plt>
jmp    21ff <main+0x10ef>
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
jmp    21ba <main+0x10aa>
jmp    2218 <main+0x1108>
movapd -0x70(%rbp),%xmm1
addpd  %xmm1,%xmm1
movapd 0xe37(%rip),%xmm0
movapd %xmm1,-0x80(%rbp)
movapd %xmm0,-0x230(%rbp)
ff
movapd -0x230(%rbp),%xmm0
ff
mulpd  -0x70(%rbp),%xmm0
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x234(%rbp)
cmpl   $0x2,-0x234(%rbp)
jge    22ae <main+0x119e>
movslq -0x234(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x234(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    2290 <main+0x1180>
jp     2290 <main+0x1180>
jmp    2295 <main+0x1185>
call   1030 <abort@plt>
jmp    229a <main+0x118a>
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    2255 <main+0x1145>
jmp    22b3 <main+0x11a3>
movapd -0x70(%rbp),%xmm2
movapd 0xda0(%rip),%xmm0
movaps %xmm0,%xmm1
divpd  %xmm2,%xmm1
movapd %xmm1,-0x80(%rbp)
movapd %xmm0,-0x250(%rbp)
ff
movapd -0x250(%rbp),%xmm0
ff
divpd  -0x70(%rbp),%xmm0
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x254(%rbp)
cmpl   $0x2,-0x254(%rbp)
jge    234c <main+0x123c>
movslq -0x254(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x254(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    232e <main+0x121e>
jp     232e <main+0x121e>
jmp    2333 <main+0x1223>
call   1030 <abort@plt>
jmp    2338 <main+0x1228>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    22f3 <main+0x11e3>
jmp    2351 <main+0x1241>
movapd -0x70(%rbp),%xmm0
movapd 0xd02(%rip),%xmm1
addpd  %xmm1,%xmm0
movapd %xmm0,-0x80(%rbp)
movapd -0x70(%rbp),%xmm0
movapd %xmm1,-0x270(%rbp)
ff
addpd  -0x270(%rbp),%xmm0
ff
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x274(%rbp)
cmpl   $0x2,-0x274(%rbp)
jge    23e7 <main+0x12d7>
movslq -0x274(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x274(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    23c9 <main+0x12b9>
jp     23c9 <main+0x12b9>
jmp    23ce <main+0x12be>
call   1030 <abort@plt>
jmp    23d3 <main+0x12c3>
mov    -0x274(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x274(%rbp)
jmp    238e <main+0x127e>
jmp    23ec <main+0x12dc>
movapd -0x70(%rbp),%xmm0
movapd 0xc67(%rip),%xmm1
subpd  %xmm1,%xmm0
movapd %xmm0,-0x80(%rbp)
movapd -0x70(%rbp),%xmm0
movapd %xmm1,-0x290(%rbp)
ff
subpd  -0x290(%rbp),%xmm0
ff
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x294(%rbp)
cmpl   $0x2,-0x294(%rbp)
jge    2482 <main+0x1372>
movslq -0x294(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x294(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    2464 <main+0x1354>
jp     2464 <main+0x1354>
jmp    2469 <main+0x1359>
call   1030 <abort@plt>
jmp    246e <main+0x135e>
mov    -0x294(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x294(%rbp)
jmp    2429 <main+0x1319>
jmp    2487 <main+0x1377>
movapd -0x70(%rbp),%xmm0
addpd  %xmm0,%xmm0
movapd 0xbc8(%rip),%xmm1
movapd %xmm0,-0x80(%rbp)
movapd -0x70(%rbp),%xmm0
movapd %xmm1,-0x2b0(%rbp)
ff
mulpd  -0x2b0(%rbp),%xmm0
ff
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x2b4(%rbp)
cmpl   $0x2,-0x2b4(%rbp)
jge    251d <main+0x140d>
movslq -0x2b4(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x2b4(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    24ff <main+0x13ef>
jp     24ff <main+0x13ef>
jmp    2504 <main+0x13f4>
call   1030 <abort@plt>
jmp    2509 <main+0x13f9>
mov    -0x2b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b4(%rbp)
jmp    24c4 <main+0x13b4>
jmp    2522 <main+0x1412>
movapd -0x70(%rbp),%xmm0
movapd 0xb31(%rip),%xmm1
divpd  %xmm1,%xmm0
movapd %xmm0,-0x80(%rbp)
movapd -0x70(%rbp),%xmm0
movapd %xmm1,-0x2d0(%rbp)
ff
divpd  -0x2d0(%rbp),%xmm0
ff
movapd %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x2d4(%rbp)
cmpl   $0x2,-0x2d4(%rbp)
jge    25b8 <main+0x14a8>
movslq -0x2d4(%rbp),%rax
movsd  -0x80(%rbp,%rax,8),%xmm0
movslq -0x2d4(%rbp),%rax
ucomisd -0x90(%rbp,%rax,8),%xmm0
ff ff
jne    259a <main+0x148a>
jp     259a <main+0x148a>
jmp    259f <main+0x148f>
call   1030 <abort@plt>
jmp    25a4 <main+0x1494>
mov    -0x2d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d4(%rbp)
jmp    255f <main+0x144f>
jmp    25bd <main+0x14ad>
xor    %eax,%eax
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    %edi,%eax
shl    $0x10,%eax
lea    0x20000(%rax),%ecx
sar    $0x10,%ecx
movswl %di,%r8d
lea    0x2(%r8),%edx
cmp    %ecx,%edx
jne    125f <main+0x14f>
mov    $0x20000,%ecx
sub    %eax,%ecx
sar    $0x10,%ecx
mov    $0x2,%edx
sub    %r8d,%edx
cmp    %ecx,%edx
jne    125f <main+0x14f>
lea    (%rdi,%rdi,1),%ecx
movswl %cx,%ecx
sar    $0xf,%eax
cmp    %ecx,%eax
jne    125f <main+0x14f>
mov    $0x2,%ax
xor    %edx,%edx
idiv   %di
movdqa 0xe95(%rip),%xmm0
mov    $0x1,%eax
pinsrw $0x0,%eax,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    125f <main+0x14f>
mov    %edx,%ecx
mov    $0x2,%ax
xor    %edx,%edx
idiv   %di
xor    %eax,%eax
cmp    %dx,%cx
sete   %al
movdqa 0xe5b(%rip),%xmm0
pinsrw $0x0,%eax,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    125f <main+0x14f>
mov    $0x2,%eax
mov    %edi,%ecx
shl    %cl,%eax
mov    $0x2,%edx
cwtl
mov    $0x2,%esi
shl    %cl,%esi
cmp    %eax,%esi
jne    125f <main+0x14f>
movzwl %di,%eax
mov    $0x2,%esi
mov    %edi,%ecx
shr    %cl,%esi
mov    %eax,%ecx
shr    %cl,%edx
cmp    %esi,%edx
jne    125f <main+0x14f>
mov    %edi,%eax
add    $0xfffffffe,%eax
cwtl
add    $0xfffffffe,%r8d
cmp    %eax,%r8d
jne    125f <main+0x14f>
movdqa 0xdf8(%rip),%xmm0
mov    $0x1,%eax
pinsrw $0x0,%eax,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    125f <main+0x14f>
movzwl %di,%eax
mov    %eax,%ecx
shr    $0xf,%ecx
add    %eax,%ecx
and    $0xfffe,%ecx
sub    %ecx,%eax
xor    %ecx,%ecx
cmp    %ax,%ax
sete   %cl
movdqa 0xdbb(%rip),%xmm0
pinsrw $0x0,%ecx,%xmm0
psllw  $0xf,%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
cmp    $0xff,%al
jne    125f <main+0x14f>
xor    %eax,%eax
pop    %rcx
ret
call   1030 <abort@plt>

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca <8 x i16>
%7 = alloca <8 x i16>
%8 = alloca <4 x float>
%9 = alloca <4 x float>
%10 = alloca <4 x float>
%11 = alloca <2 x double>
%12 = alloca <2 x double>
%13 = alloca <2 x double>
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca <4 x float>
%33 = alloca i32
%34 = alloca <4 x float>
%35 = alloca i32
%36 = alloca <4 x float>
%37 = alloca i32
%38 = alloca <4 x float>
%39 = alloca i32
%40 = alloca <4 x float>
%41 = alloca i32
%42 = alloca <4 x float>
%43 = alloca i32
%44 = alloca <4 x float>
%45 = alloca i32
%46 = alloca <4 x float>
%47 = alloca i32
%48 = alloca <2 x double>
%49 = alloca i32
%50 = alloca <2 x double>
%51 = alloca i32
%52 = alloca <2 x double>
%53 = alloca i32
%54 = alloca <2 x double>
%55 = alloca i32
%56 = alloca <2 x double>
%57 = alloca i32
%58 = alloca <2 x double>
%59 = alloca i32
%60 = alloca <2 x double>
%61 = alloca i32
%62 = alloca <2 x double>
%63 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%64 = load i32, i32* %4
%65 = trunc i32 %64 to i16
%66 = insertelement <8 x i16> undef, i16 %65, i32 0
%67 = insertelement <8 x i16> %66, i16 1, i32 1
%68 = insertelement <8 x i16> %67, i16 2, i32 2
%69 = insertelement <8 x i16> %68, i16 3, i32 3
%70 = insertelement <8 x i16> %69, i16 4, i32 4
%71 = insertelement <8 x i16> %70, i16 5, i32 5
%72 = insertelement <8 x i16> %71, i16 6, i32 6
%73 = insertelement <8 x i16> %72, i16 7, i32 7
store <8 x i16> %73, <8 x i16>* %6
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, <4 x float>* %8
store <2 x double> <double 1.000000e+00, double 2.000000e+00>, <2 x double>* %11
%74 = load <8 x i16>, <8 x i16>* %6
%75 = add <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %74
store <8 x i16> %75, <8 x i16>* %7
br label %76
76: ; preds = %2
store i32 0, i32* %14
br label %77
77: ; preds = %97, %76
%78 = load i32, i32* %14
%79 = icmp slt i32 %78, 8
br i1 %79, label %80, label %100
80: ; preds = %77
%81 = bitcast <8 x i16>* %7 to i16*
%82 = load i32, i32* %14
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i16, i16* %81, i64 %83
%85 = load i16, i16* %84
%86 = sext i16 %85 to i32
%87 = bitcast <8 x i16>* %6 to i16*
%88 = load i32, i32* %14
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i16, i16* %87, i64 %89
%91 = load i16, i16* %90
%92 = sext i16 %91 to i32
%93 = add nsw i32 2, %92
%94 = icmp ne i32 %86, %93
br i1 %94, label %95, label %96
95: ; preds = %80
unreachable
96: ; preds = %80
br label %97
97: ; preds = %96
%98 = load i32, i32* %14
%99 = add nsw i32 %98, 1
store i32 %99, i32* %14
br label %77
100: ; preds = %77
br label %101
101: ; preds = %100
%102 = load <8 x i16>, <8 x i16>* %6
%103 = sub <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %102
store <8 x i16> %103, <8 x i16>* %7
br label %104
104: ; preds = %101
store i32 0, i32* %15
br label %105
105: ; preds = %125, %104
%106 = load i32, i32* %15
%107 = icmp slt i32 %106, 8
br i1 %107, label %108, label %128
108: ; preds = %105
%109 = bitcast <8 x i16>* %7 to i16*
%110 = load i32, i32* %15
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i16, i16* %109, i64 %111
%113 = load i16, i16* %112
%114 = sext i16 %113 to i32
%115 = bitcast <8 x i16>* %6 to i16*
%116 = load i32, i32* %15
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i16, i16* %115, i64 %117
%119 = load i16, i16* %118
%120 = sext i16 %119 to i32
%121 = sub nsw i32 2, %120
%122 = icmp ne i32 %114, %121
br i1 %122, label %123, label %124
123: ; preds = %108
unreachable
124: ; preds = %108
br label %125
125: ; preds = %124
%126 = load i32, i32* %15
%127 = add nsw i32 %126, 1
store i32 %127, i32* %15
br label %105
128: ; preds = %105
br label %129
129: ; preds = %128
%130 = load <8 x i16>, <8 x i16>* %6
%131 = mul <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %130
store <8 x i16> %131, <8 x i16>* %7
br label %132
132: ; preds = %129
store i32 0, i32* %16
br label %133
133: ; preds = %153, %132
%134 = load i32, i32* %16
%135 = icmp slt i32 %134, 8
br i1 %135, label %136, label %156
136: ; preds = %133
%137 = bitcast <8 x i16>* %7 to i16*
%138 = load i32, i32* %16
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i16, i16* %137, i64 %139
%141 = load i16, i16* %140
%142 = sext i16 %141 to i32
%143 = bitcast <8 x i16>* %6 to i16*
%144 = load i32, i32* %16
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i16, i16* %143, i64 %145
%147 = load i16, i16* %146
%148 = sext i16 %147 to i32
%149 = mul nsw i32 2, %148
%150 = icmp ne i32 %142, %149
br i1 %150, label %151, label %152
151: ; preds = %136
unreachable
152: ; preds = %136
br label %153
153: ; preds = %152
%154 = load i32, i32* %16
%155 = add nsw i32 %154, 1
store i32 %155, i32* %16
br label %133
156: ; preds = %133
br label %157
157: ; preds = %156
%158 = load <8 x i16>, <8 x i16>* %6
%159 = sdiv <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %158
store <8 x i16> %159, <8 x i16>* %7
br label %160
160: ; preds = %157
store i32 0, i32* %17
br label %161
161: ; preds = %181, %160
%162 = load i32, i32* %17
%163 = icmp slt i32 %162, 8
br i1 %163, label %164, label %184
164: ; preds = %161
%165 = bitcast <8 x i16>* %7 to i16*
%166 = load i32, i32* %17
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i16, i16* %165, i64 %167
%169 = load i16, i16* %168
%170 = sext i16 %169 to i32
%171 = bitcast <8 x i16>* %6 to i16*
%172 = load i32, i32* %17
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i16, i16* %171, i64 %173
%175 = load i16, i16* %174
%176 = sext i16 %175 to i32
%177 = sdiv i32 2, %176
%178 = icmp ne i32 %170, %177
br i1 %178, label %179, label %180
179: ; preds = %164
unreachable
180: ; preds = %164
br label %181
181: ; preds = %180
%182 = load i32, i32* %17
%183 = add nsw i32 %182, 1
store i32 %183, i32* %17
br label %161
184: ; preds = %161
br label %185
185: ; preds = %184
%186 = load <8 x i16>, <8 x i16>* %6
%187 = srem <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %186
store <8 x i16> %187, <8 x i16>* %7
br label %188
188: ; preds = %185
store i32 0, i32* %18
br label %189
189: ; preds = %209, %188
%190 = load i32, i32* %18
%191 = icmp slt i32 %190, 8
br i1 %191, label %192, label %212
192: ; preds = %189
%193 = bitcast <8 x i16>* %7 to i16*
%194 = load i32, i32* %18
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i16, i16* %193, i64 %195
%197 = load i16, i16* %196
%198 = sext i16 %197 to i32
%199 = bitcast <8 x i16>* %6 to i16*
%200 = load i32, i32* %18
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i16, i16* %199, i64 %201
%203 = load i16, i16* %202
%204 = sext i16 %203 to i32
%205 = srem i32 2, %204
%206 = icmp ne i32 %198, %205
br i1 %206, label %207, label %208
207: ; preds = %192
unreachable
208: ; preds = %192
br label %209
209: ; preds = %208
%210 = load i32, i32* %18
%211 = add nsw i32 %210, 1
store i32 %211, i32* %18
br label %189
212: ; preds = %189
br label %213
213: ; preds = %212
%214 = load <8 x i16>, <8 x i16>* %6
%215 = xor <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %214
store <8 x i16> %215, <8 x i16>* %7
br label %216
216: ; preds = %213
store i32 0, i32* %19
br label %217
217: ; preds = %237, %216
%218 = load i32, i32* %19
%219 = icmp slt i32 %218, 8
br i1 %219, label %220, label %240
220: ; preds = %217
%221 = bitcast <8 x i16>* %7 to i16*
%222 = load i32, i32* %19
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i16, i16* %221, i64 %223
%225 = load i16, i16* %224
%226 = sext i16 %225 to i32
%227 = bitcast <8 x i16>* %6 to i16*
%228 = load i32, i32* %19
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i16, i16* %227, i64 %229
%231 = load i16, i16* %230
%232 = sext i16 %231 to i32
%233 = xor i32 2, %232
%234 = icmp ne i32 %226, %233
br i1 %234, label %235, label %236
235: ; preds = %220
unreachable
236: ; preds = %220
br label %237
237: ; preds = %236
%238 = load i32, i32* %19
%239 = add nsw i32 %238, 1
store i32 %239, i32* %19
br label %217
240: ; preds = %217
br label %241
241: ; preds = %240
%242 = load <8 x i16>, <8 x i16>* %6
%243 = and <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %242
store <8 x i16> %243, <8 x i16>* %7
br label %244
244: ; preds = %241
store i32 0, i32* %20
br label %245
245: ; preds = %265, %244
%246 = load i32, i32* %20
%247 = icmp slt i32 %246, 8
br i1 %247, label %248, label %268
248: ; preds = %245
%249 = bitcast <8 x i16>* %7 to i16*
%250 = load i32, i32* %20
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i16, i16* %249, i64 %251
%253 = load i16, i16* %252
%254 = sext i16 %253 to i32
%255 = bitcast <8 x i16>* %6 to i16*
%256 = load i32, i32* %20
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i16, i16* %255, i64 %257
%259 = load i16, i16* %258
%260 = sext i16 %259 to i32
%261 = and i32 2, %260
%262 = icmp ne i32 %254, %261
br i1 %262, label %263, label %264
263: ; preds = %248
unreachable
264: ; preds = %248
br label %265
265: ; preds = %264
%266 = load i32, i32* %20
%267 = add nsw i32 %266, 1
store i32 %267, i32* %20
br label %245
268: ; preds = %245
br label %269
269: ; preds = %268
%270 = load <8 x i16>, <8 x i16>* %6
%271 = or <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %270
store <8 x i16> %271, <8 x i16>* %7
br label %272
272: ; preds = %269
store i32 0, i32* %21
br label %273
273: ; preds = %293, %272
%274 = load i32, i32* %21
%275 = icmp slt i32 %274, 8
br i1 %275, label %276, label %296
276: ; preds = %273
%277 = bitcast <8 x i16>* %7 to i16*
%278 = load i32, i32* %21
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i16, i16* %277, i64 %279
%281 = load i16, i16* %280
%282 = sext i16 %281 to i32
%283 = bitcast <8 x i16>* %6 to i16*
%284 = load i32, i32* %21
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i16, i16* %283, i64 %285
%287 = load i16, i16* %286
%288 = sext i16 %287 to i32
%289 = or i32 2, %288
%290 = icmp ne i32 %282, %289
br i1 %290, label %291, label %292
291: ; preds = %276
unreachable
292: ; preds = %276
br label %293
293: ; preds = %292
%294 = load i32, i32* %21
%295 = add nsw i32 %294, 1
store i32 %295, i32* %21
br label %273
296: ; preds = %273
br label %297
297: ; preds = %296
%298 = load <8 x i16>, <8 x i16>* %6
%299 = shl <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %298
store <8 x i16> %299, <8 x i16>* %7
br label %300
300: ; preds = %297
store i32 0, i32* %22
br label %301
301: ; preds = %321, %300
%302 = load i32, i32* %22
%303 = icmp slt i32 %302, 8
br i1 %303, label %304, label %324
304: ; preds = %301
%305 = bitcast <8 x i16>* %7 to i16*
%306 = load i32, i32* %22
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i16, i16* %305, i64 %307
%309 = load i16, i16* %308
%310 = sext i16 %309 to i32
%311 = bitcast <8 x i16>* %6 to i16*
%312 = load i32, i32* %22
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i16, i16* %311, i64 %313
%315 = load i16, i16* %314
%316 = sext i16 %315 to i32
%317 = shl i32 2, %316
%318 = icmp ne i32 %310, %317
br i1 %318, label %319, label %320
319: ; preds = %304
unreachable
320: ; preds = %304
br label %321
321: ; preds = %320
%322 = load i32, i32* %22
%323 = add nsw i32 %322, 1
store i32 %323, i32* %22
br label %301
324: ; preds = %301
br label %325
325: ; preds = %324
%326 = load <8 x i16>, <8 x i16>* %6
%327 = ashr <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %326
store <8 x i16> %327, <8 x i16>* %7
br label %328
328: ; preds = %325
store i32 0, i32* %23
br label %329
329: ; preds = %349, %328
%330 = load i32, i32* %23
%331 = icmp slt i32 %330, 8
br i1 %331, label %332, label %352
332: ; preds = %329
%333 = bitcast <8 x i16>* %7 to i16*
%334 = load i32, i32* %23
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i16, i16* %333, i64 %335
%337 = load i16, i16* %336
%338 = sext i16 %337 to i32
%339 = bitcast <8 x i16>* %6 to i16*
%340 = load i32, i32* %23
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i16, i16* %339, i64 %341
%343 = load i16, i16* %342
%344 = sext i16 %343 to i32
%345 = ashr i32 2, %344
%346 = icmp ne i32 %338, %345
br i1 %346, label %347, label %348
347: ; preds = %332
unreachable
348: ; preds = %332
br label %349
349: ; preds = %348
%350 = load i32, i32* %23
%351 = add nsw i32 %350, 1
store i32 %351, i32* %23
br label %329
352: ; preds = %329
br label %353
353: ; preds = %352
%354 = load <8 x i16>, <8 x i16>* %6
%355 = add <8 x i16> %354, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %355, <8 x i16>* %7
br label %356
356: ; preds = %353
store i32 0, i32* %24
br label %357
357: ; preds = %377, %356
%358 = load i32, i32* %24
%359 = icmp slt i32 %358, 8
br i1 %359, label %360, label %380
360: ; preds = %357
%361 = bitcast <8 x i16>* %7 to i16*
%362 = load i32, i32* %24
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i16, i16* %361, i64 %363
%365 = load i16, i16* %364
%366 = sext i16 %365 to i32
%367 = bitcast <8 x i16>* %6 to i16*
%368 = load i32, i32* %24
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds i16, i16* %367, i64 %369
%371 = load i16, i16* %370
%372 = sext i16 %371 to i32
%373 = add nsw i32 %372, 2
%374 = icmp ne i32 %366, %373
br i1 %374, label %375, label %376
375: ; preds = %360
unreachable
376: ; preds = %360
br label %377
377: ; preds = %376
%378 = load i32, i32* %24
%379 = add nsw i32 %378, 1
store i32 %379, i32* %24
br label %357
380: ; preds = %357
br label %381
381: ; preds = %380
%382 = load <8 x i16>, <8 x i16>* %6
%383 = sub <8 x i16> %382, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %383, <8 x i16>* %7
br label %384
384: ; preds = %381
store i32 0, i32* %25
br label %385
385: ; preds = %405, %384
%386 = load i32, i32* %25
%387 = icmp slt i32 %386, 8
br i1 %387, label %388, label %408
388: ; preds = %385
%389 = bitcast <8 x i16>* %7 to i16*
%390 = load i32, i32* %25
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i16, i16* %389, i64 %391
%393 = load i16, i16* %392
%394 = sext i16 %393 to i32
%395 = bitcast <8 x i16>* %6 to i16*
%396 = load i32, i32* %25
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i16, i16* %395, i64 %397
%399 = load i16, i16* %398
%400 = sext i16 %399 to i32
%401 = sub nsw i32 %400, 2
%402 = icmp ne i32 %394, %401
br i1 %402, label %403, label %404
403: ; preds = %388
unreachable
404: ; preds = %388
br label %405
405: ; preds = %404
%406 = load i32, i32* %25
%407 = add nsw i32 %406, 1
store i32 %407, i32* %25
br label %385
408: ; preds = %385
br label %409
409: ; preds = %408
%410 = load <8 x i16>, <8 x i16>* %6
%411 = mul <8 x i16> %410, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %411, <8 x i16>* %7
br label %412
412: ; preds = %409
store i32 0, i32* %26
br label %413
413: ; preds = %433, %412
%414 = load i32, i32* %26
%415 = icmp slt i32 %414, 8
br i1 %415, label %416, label %436
416: ; preds = %413
%417 = bitcast <8 x i16>* %7 to i16*
%418 = load i32, i32* %26
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i16, i16* %417, i64 %419
%421 = load i16, i16* %420
%422 = sext i16 %421 to i32
%423 = bitcast <8 x i16>* %6 to i16*
%424 = load i32, i32* %26
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds i16, i16* %423, i64 %425
%427 = load i16, i16* %426
%428 = sext i16 %427 to i32
%429 = mul nsw i32 %428, 2
%430 = icmp ne i32 %422, %429
br i1 %430, label %431, label %432
431: ; preds = %416
unreachable
432: ; preds = %416
br label %433
433: ; preds = %432
%434 = load i32, i32* %26
%435 = add nsw i32 %434, 1
store i32 %435, i32* %26
br label %413
436: ; preds = %413
br label %437
437: ; preds = %436
%438 = load <8 x i16>, <8 x i16>* %6
%439 = sdiv <8 x i16> %438, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %439, <8 x i16>* %7
br label %440
440: ; preds = %437
store i32 0, i32* %27
br label %441
441: ; preds = %461, %440
%442 = load i32, i32* %27
%443 = icmp slt i32 %442, 8
br i1 %443, label %444, label %464
444: ; preds = %441
%445 = bitcast <8 x i16>* %7 to i16*
%446 = load i32, i32* %27
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i16, i16* %445, i64 %447
%449 = load i16, i16* %448
%450 = sext i16 %449 to i32
%451 = bitcast <8 x i16>* %6 to i16*
%452 = load i32, i32* %27
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i16, i16* %451, i64 %453
%455 = load i16, i16* %454
%456 = sext i16 %455 to i32
%457 = sdiv i32 %456, 2
%458 = icmp ne i32 %450, %457
br i1 %458, label %459, label %460
459: ; preds = %444
unreachable
460: ; preds = %444
br label %461
461: ; preds = %460
%462 = load i32, i32* %27
%463 = add nsw i32 %462, 1
store i32 %463, i32* %27
br label %441
464: ; preds = %441
br label %465
465: ; preds = %464
%466 = load <8 x i16>, <8 x i16>* %6
%467 = srem <8 x i16> %466, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %467, <8 x i16>* %7
br label %468
468: ; preds = %465
store i32 0, i32* %28
br label %469
469: ; preds = %489, %468
%470 = load i32, i32* %28
%471 = icmp slt i32 %470, 8
br i1 %471, label %472, label %492
472: ; preds = %469
%473 = bitcast <8 x i16>* %7 to i16*
%474 = load i32, i32* %28
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds i16, i16* %473, i64 %475
%477 = load i16, i16* %476
%478 = sext i16 %477 to i32
%479 = bitcast <8 x i16>* %6 to i16*
%480 = load i32, i32* %28
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i16, i16* %479, i64 %481
%483 = load i16, i16* %482
%484 = sext i16 %483 to i32
%485 = srem i32 %484, 2
%486 = icmp ne i32 %478, %485
br i1 %486, label %487, label %488
487: ; preds = %472
unreachable
488: ; preds = %472
br label %489
489: ; preds = %488
%490 = load i32, i32* %28
%491 = add nsw i32 %490, 1
store i32 %491, i32* %28
br label %469
492: ; preds = %469
br label %493
493: ; preds = %492
%494 = load <8 x i16>, <8 x i16>* %6
%495 = xor <8 x i16> %494, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %495, <8 x i16>* %7
br label %496
496: ; preds = %493
store i32 0, i32* %29
br label %497
497: ; preds = %517, %496
%498 = load i32, i32* %29
%499 = icmp slt i32 %498, 8
br i1 %499, label %500, label %520
500: ; preds = %497
%501 = bitcast <8 x i16>* %7 to i16*
%502 = load i32, i32* %29
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i16, i16* %501, i64 %503
%505 = load i16, i16* %504
%506 = sext i16 %505 to i32
%507 = bitcast <8 x i16>* %6 to i16*
%508 = load i32, i32* %29
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i16, i16* %507, i64 %509
%511 = load i16, i16* %510
%512 = sext i16 %511 to i32
%513 = xor i32 %512, 2
%514 = icmp ne i32 %506, %513
br i1 %514, label %515, label %516
515: ; preds = %500
unreachable
516: ; preds = %500
br label %517
517: ; preds = %516
%518 = load i32, i32* %29
%519 = add nsw i32 %518, 1
store i32 %519, i32* %29
br label %497
520: ; preds = %497
br label %521
521: ; preds = %520
%522 = load <8 x i16>, <8 x i16>* %6
%523 = and <8 x i16> %522, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %523, <8 x i16>* %7
br label %524
524: ; preds = %521
store i32 0, i32* %30
br label %525
525: ; preds = %545, %524
%526 = load i32, i32* %30
%527 = icmp slt i32 %526, 8
br i1 %527, label %528, label %548
528: ; preds = %525
%529 = bitcast <8 x i16>* %7 to i16*
%530 = load i32, i32* %30
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds i16, i16* %529, i64 %531
%533 = load i16, i16* %532
%534 = sext i16 %533 to i32
%535 = bitcast <8 x i16>* %6 to i16*
%536 = load i32, i32* %30
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds i16, i16* %535, i64 %537
%539 = load i16, i16* %538
%540 = sext i16 %539 to i32
%541 = and i32 %540, 2
%542 = icmp ne i32 %534, %541
br i1 %542, label %543, label %544
543: ; preds = %528
unreachable
544: ; preds = %528
br label %545
545: ; preds = %544
%546 = load i32, i32* %30
%547 = add nsw i32 %546, 1
store i32 %547, i32* %30
br label %525
548: ; preds = %525
br label %549
549: ; preds = %548
%550 = load <8 x i16>, <8 x i16>* %6
%551 = or <8 x i16> %550, <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>
store <8 x i16> %551, <8 x i16>* %7
br label %552
552: ; preds = %549
store i32 0, i32* %31
br label %553
553: ; preds = %573, %552
%554 = load i32, i32* %31
%555 = icmp slt i32 %554, 8
br i1 %555, label %556, label %576
556: ; preds = %553
%557 = bitcast <8 x i16>* %7 to i16*
%558 = load i32, i32* %31
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds i16, i16* %557, i64 %559
%561 = load i16, i16* %560
%562 = sext i16 %561 to i32
%563 = bitcast <8 x i16>* %6 to i16*
%564 = load i32, i32* %31
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds i16, i16* %563, i64 %565
%567 = load i16, i16* %566
%568 = sext i16 %567 to i32
%569 = or i32 %568, 2
%570 = icmp ne i32 %562, %569
br i1 %570, label %571, label %572
571: ; preds = %556
unreachable
572: ; preds = %556
br label %573
573: ; preds = %572
%574 = load i32, i32* %31
%575 = add nsw i32 %574, 1
store i32 %575, i32* %31
br label %553
576: ; preds = %553
br label %577
577: ; preds = %576
%578 = load <4 x float>, <4 x float>* %8
%579 = fadd <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, %578
store <4 x float> %579, <4 x float>* %9
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %32
%580 = load <4 x float>, <4 x float>* %32
%581 = load <4 x float>, <4 x float>* %8
%582 = fadd <4 x float> %580, %581
store <4 x float> %582, <4 x float>* %10
br label %583
583: ; preds = %577
store i32 0, i32* %33
br label %584
584: ; preds = %601, %583
%585 = load i32, i32* %33
%586 = icmp slt i32 %585, 4
br i1 %586, label %587, label %604
587: ; preds = %584
%588 = bitcast <4 x float>* %9 to float*
%589 = load i32, i32* %33
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
%593 = bitcast <4 x float>* %10 to float*
%594 = load i32, i32* %33
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds float, float* %593, i64 %595
%597 = load float, float* %596
%598 = fcmp une float %592, %597
br i1 %598, label %599, label %600
599: ; preds = %587
unreachable
600: ; preds = %587
br label %601
601: ; preds = %600
%602 = load i32, i32* %33
%603 = add nsw i32 %602, 1
store i32 %603, i32* %33
br label %584
604: ; preds = %584
br label %605
605: ; preds = %604
%606 = load <4 x float>, <4 x float>* %8
%607 = fsub <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, %606
store <4 x float> %607, <4 x float>* %9
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %34
%608 = load <4 x float>, <4 x float>* %34
%609 = load <4 x float>, <4 x float>* %8
%610 = fsub <4 x float> %608, %609
store <4 x float> %610, <4 x float>* %10
br label %611
611: ; preds = %605
store i32 0, i32* %35
br label %612
612: ; preds = %629, %611
%613 = load i32, i32* %35
%614 = icmp slt i32 %613, 4
br i1 %614, label %615, label %632
615: ; preds = %612
%616 = bitcast <4 x float>* %9 to float*
%617 = load i32, i32* %35
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds float, float* %616, i64 %618
%620 = load float, float* %619
%621 = bitcast <4 x float>* %10 to float*
%622 = load i32, i32* %35
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds float, float* %621, i64 %623
%625 = load float, float* %624
%626 = fcmp une float %620, %625
br i1 %626, label %627, label %628
627: ; preds = %615
unreachable
628: ; preds = %615
br label %629
629: ; preds = %628
%630 = load i32, i32* %35
%631 = add nsw i32 %630, 1
store i32 %631, i32* %35
br label %612
632: ; preds = %612
br label %633
633: ; preds = %632
%634 = load <4 x float>, <4 x float>* %8
%635 = fmul <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, %634
store <4 x float> %635, <4 x float>* %9
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %36
%636 = load <4 x float>, <4 x float>* %36
%637 = load <4 x float>, <4 x float>* %8
%638 = fmul <4 x float> %636, %637
store <4 x float> %638, <4 x float>* %10
br label %639
639: ; preds = %633
store i32 0, i32* %37
br label %640
640: ; preds = %657, %639
%641 = load i32, i32* %37
%642 = icmp slt i32 %641, 4
br i1 %642, label %643, label %660
643: ; preds = %640
%644 = bitcast <4 x float>* %9 to float*
%645 = load i32, i32* %37
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds float, float* %644, i64 %646
%648 = load float, float* %647
%649 = bitcast <4 x float>* %10 to float*
%650 = load i32, i32* %37
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %649, i64 %651
%653 = load float, float* %652
%654 = fcmp une float %648, %653
br i1 %654, label %655, label %656
655: ; preds = %643
unreachable
656: ; preds = %643
br label %657
657: ; preds = %656
%658 = load i32, i32* %37
%659 = add nsw i32 %658, 1
store i32 %659, i32* %37
br label %640
660: ; preds = %640
br label %661
661: ; preds = %660
%662 = load <4 x float>, <4 x float>* %8
%663 = fdiv <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, %662
store <4 x float> %663, <4 x float>* %9
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %38
%664 = load <4 x float>, <4 x float>* %38
%665 = load <4 x float>, <4 x float>* %8
%666 = fdiv <4 x float> %664, %665
store <4 x float> %666, <4 x float>* %10
br label %667
667: ; preds = %661
store i32 0, i32* %39
br label %668
668: ; preds = %685, %667
%669 = load i32, i32* %39
%670 = icmp slt i32 %669, 4
br i1 %670, label %671, label %688
671: ; preds = %668
%672 = bitcast <4 x float>* %9 to float*
%673 = load i32, i32* %39
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds float, float* %672, i64 %674
%676 = load float, float* %675
%677 = bitcast <4 x float>* %10 to float*
%678 = load i32, i32* %39
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds float, float* %677, i64 %679
%681 = load float, float* %680
%682 = fcmp une float %676, %681
br i1 %682, label %683, label %684
683: ; preds = %671
unreachable
684: ; preds = %671
br label %685
685: ; preds = %684
%686 = load i32, i32* %39
%687 = add nsw i32 %686, 1
store i32 %687, i32* %39
br label %668
688: ; preds = %668
br label %689
689: ; preds = %688
%690 = load <4 x float>, <4 x float>* %8
%691 = fadd <4 x float> %690, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
store <4 x float> %691, <4 x float>* %9
%692 = load <4 x float>, <4 x float>* %8
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %40
%693 = load <4 x float>, <4 x float>* %40
%694 = fadd <4 x float> %692, %693
store <4 x float> %694, <4 x float>* %10
br label %695
695: ; preds = %689
store i32 0, i32* %41
br label %696
696: ; preds = %713, %695
%697 = load i32, i32* %41
%698 = icmp slt i32 %697, 4
br i1 %698, label %699, label %716
699: ; preds = %696
%700 = bitcast <4 x float>* %9 to float*
%701 = load i32, i32* %41
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %700, i64 %702
%704 = load float, float* %703
%705 = bitcast <4 x float>* %10 to float*
%706 = load i32, i32* %41
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds float, float* %705, i64 %707
%709 = load float, float* %708
%710 = fcmp une float %704, %709
br i1 %710, label %711, label %712
711: ; preds = %699
unreachable
712: ; preds = %699
br label %713
713: ; preds = %712
%714 = load i32, i32* %41
%715 = add nsw i32 %714, 1
store i32 %715, i32* %41
br label %696
716: ; preds = %696
br label %717
717: ; preds = %716
%718 = load <4 x float>, <4 x float>* %8
%719 = fsub <4 x float> %718, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
store <4 x float> %719, <4 x float>* %9
%720 = load <4 x float>, <4 x float>* %8
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %42
%721 = load <4 x float>, <4 x float>* %42
%722 = fsub <4 x float> %720, %721
store <4 x float> %722, <4 x float>* %10
br label %723
723: ; preds = %717
store i32 0, i32* %43
br label %724
724: ; preds = %741, %723
%725 = load i32, i32* %43
%726 = icmp slt i32 %725, 4
br i1 %726, label %727, label %744
727: ; preds = %724
%728 = bitcast <4 x float>* %9 to float*
%729 = load i32, i32* %43
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %728, i64 %730
%732 = load float, float* %731
%733 = bitcast <4 x float>* %10 to float*
%734 = load i32, i32* %43
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds float, float* %733, i64 %735
%737 = load float, float* %736
%738 = fcmp une float %732, %737
br i1 %738, label %739, label %740
739: ; preds = %727
unreachable
740: ; preds = %727
br label %741
741: ; preds = %740
%742 = load i32, i32* %43
%743 = add nsw i32 %742, 1
store i32 %743, i32* %43
br label %724
744: ; preds = %724
br label %745
745: ; preds = %744
%746 = load <4 x float>, <4 x float>* %8
%747 = fmul <4 x float> %746, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
store <4 x float> %747, <4 x float>* %9
%748 = load <4 x float>, <4 x float>* %8
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %44
%749 = load <4 x float>, <4 x float>* %44
%750 = fmul <4 x float> %748, %749
store <4 x float> %750, <4 x float>* %10
br label %751
751: ; preds = %745
store i32 0, i32* %45
br label %752
752: ; preds = %769, %751
%753 = load i32, i32* %45
%754 = icmp slt i32 %753, 4
br i1 %754, label %755, label %772
755: ; preds = %752
%756 = bitcast <4 x float>* %9 to float*
%757 = load i32, i32* %45
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds float, float* %756, i64 %758
%760 = load float, float* %759
%761 = bitcast <4 x float>* %10 to float*
%762 = load i32, i32* %45
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds float, float* %761, i64 %763
%765 = load float, float* %764
%766 = fcmp une float %760, %765
br i1 %766, label %767, label %768
767: ; preds = %755
unreachable
768: ; preds = %755
br label %769
769: ; preds = %768
%770 = load i32, i32* %45
%771 = add nsw i32 %770, 1
store i32 %771, i32* %45
br label %752
772: ; preds = %752
br label %773
773: ; preds = %772
%774 = load <4 x float>, <4 x float>* %8
%775 = fdiv <4 x float> %774, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
store <4 x float> %775, <4 x float>* %9
%776 = load <4 x float>, <4 x float>* %8
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>, <4 x float>* %46
%777 = load <4 x float>, <4 x float>* %46
%778 = fdiv <4 x float> %776, %777
store <4 x float> %778, <4 x float>* %10
br label %779
779: ; preds = %773
store i32 0, i32* %47
br label %780
780: ; preds = %797, %779
%781 = load i32, i32* %47
%782 = icmp slt i32 %781, 4
br i1 %782, label %783, label %800
783: ; preds = %780
%784 = bitcast <4 x float>* %9 to float*
%785 = load i32, i32* %47
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float, float* %784, i64 %786
%788 = load float, float* %787
%789 = bitcast <4 x float>* %10 to float*
%790 = load i32, i32* %47
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds float, float* %789, i64 %791
%793 = load float, float* %792
%794 = fcmp une float %788, %793
br i1 %794, label %795, label %796
795: ; preds = %783
unreachable
796: ; preds = %783
br label %797
797: ; preds = %796
%798 = load i32, i32* %47
%799 = add nsw i32 %798, 1
store i32 %799, i32* %47
br label %780
800: ; preds = %780
br label %801
801: ; preds = %800
%802 = load <2 x double>, <2 x double>* %11
%803 = fadd <2 x double> <double 2.000000e+00, double 2.000000e+00>, %802
store <2 x double> %803, <2 x double>* %12
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %48
%804 = load <2 x double>, <2 x double>* %48
%805 = load <2 x double>, <2 x double>* %11
%806 = fadd <2 x double> %804, %805
store <2 x double> %806, <2 x double>* %13
br label %807
807: ; preds = %801
store i32 0, i32* %49
br label %808
808: ; preds = %825, %807
%809 = load i32, i32* %49
%810 = icmp slt i32 %809, 2
br i1 %810, label %811, label %828
811: ; preds = %808
%812 = bitcast <2 x double>* %12 to double*
%813 = load i32, i32* %49
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds double, double* %812, i64 %814
%816 = load double, double* %815
%817 = bitcast <2 x double>* %13 to double*
%818 = load i32, i32* %49
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double, double* %817, i64 %819
%821 = load double, double* %820
%822 = fcmp une double %816, %821
br i1 %822, label %823, label %824
823: ; preds = %811
unreachable
824: ; preds = %811
br label %825
825: ; preds = %824
%826 = load i32, i32* %49
%827 = add nsw i32 %826, 1
store i32 %827, i32* %49
br label %808
828: ; preds = %808
br label %829
829: ; preds = %828
%830 = load <2 x double>, <2 x double>* %11
%831 = fsub <2 x double> <double 2.000000e+00, double 2.000000e+00>, %830
store <2 x double> %831, <2 x double>* %12
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %50
%832 = load <2 x double>, <2 x double>* %50
%833 = load <2 x double>, <2 x double>* %11
%834 = fsub <2 x double> %832, %833
store <2 x double> %834, <2 x double>* %13
br label %835
835: ; preds = %829
store i32 0, i32* %51
br label %836
836: ; preds = %853, %835
%837 = load i32, i32* %51
%838 = icmp slt i32 %837, 2
br i1 %838, label %839, label %856
839: ; preds = %836
%840 = bitcast <2 x double>* %12 to double*
%841 = load i32, i32* %51
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds double, double* %840, i64 %842
%844 = load double, double* %843
%845 = bitcast <2 x double>* %13 to double*
%846 = load i32, i32* %51
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds double, double* %845, i64 %847
%849 = load double, double* %848
%850 = fcmp une double %844, %849
br i1 %850, label %851, label %852
851: ; preds = %839
unreachable
852: ; preds = %839
br label %853
853: ; preds = %852
%854 = load i32, i32* %51
%855 = add nsw i32 %854, 1
store i32 %855, i32* %51
br label %836
856: ; preds = %836
br label %857
857: ; preds = %856
%858 = load <2 x double>, <2 x double>* %11
%859 = fmul <2 x double> <double 2.000000e+00, double 2.000000e+00>, %858
store <2 x double> %859, <2 x double>* %12
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %52
%860 = load <2 x double>, <2 x double>* %52
%861 = load <2 x double>, <2 x double>* %11
%862 = fmul <2 x double> %860, %861
store <2 x double> %862, <2 x double>* %13
br label %863
863: ; preds = %857
store i32 0, i32* %53
br label %864
864: ; preds = %881, %863
%865 = load i32, i32* %53
%866 = icmp slt i32 %865, 2
br i1 %866, label %867, label %884
867: ; preds = %864
%868 = bitcast <2 x double>* %12 to double*
%869 = load i32, i32* %53
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds double, double* %868, i64 %870
%872 = load double, double* %871
%873 = bitcast <2 x double>* %13 to double*
%874 = load i32, i32* %53
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds double, double* %873, i64 %875
%877 = load double, double* %876
%878 = fcmp une double %872, %877
br i1 %878, label %879, label %880
879: ; preds = %867
unreachable
880: ; preds = %867
br label %881
881: ; preds = %880
%882 = load i32, i32* %53
%883 = add nsw i32 %882, 1
store i32 %883, i32* %53
br label %864
884: ; preds = %864
br label %885
885: ; preds = %884
%886 = load <2 x double>, <2 x double>* %11
%887 = fdiv <2 x double> <double 2.000000e+00, double 2.000000e+00>, %886
store <2 x double> %887, <2 x double>* %12
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %54
%888 = load <2 x double>, <2 x double>* %54
%889 = load <2 x double>, <2 x double>* %11
%890 = fdiv <2 x double> %888, %889
store <2 x double> %890, <2 x double>* %13
br label %891
891: ; preds = %885
store i32 0, i32* %55
br label %892
892: ; preds = %909, %891
%893 = load i32, i32* %55
%894 = icmp slt i32 %893, 2
br i1 %894, label %895, label %912
895: ; preds = %892
%896 = bitcast <2 x double>* %12 to double*
%897 = load i32, i32* %55
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds double, double* %896, i64 %898
%900 = load double, double* %899
%901 = bitcast <2 x double>* %13 to double*
%902 = load i32, i32* %55
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds double, double* %901, i64 %903
%905 = load double, double* %904
%906 = fcmp une double %900, %905
br i1 %906, label %907, label %908
907: ; preds = %895
unreachable
908: ; preds = %895
br label %909
909: ; preds = %908
%910 = load i32, i32* %55
%911 = add nsw i32 %910, 1
store i32 %911, i32* %55
br label %892
912: ; preds = %892
br label %913
913: ; preds = %912
%914 = load <2 x double>, <2 x double>* %11
%915 = fadd <2 x double> %914, <double 2.000000e+00, double 2.000000e+00>
store <2 x double> %915, <2 x double>* %12
%916 = load <2 x double>, <2 x double>* %11
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %56
%917 = load <2 x double>, <2 x double>* %56
%918 = fadd <2 x double> %916, %917
store <2 x double> %918, <2 x double>* %13
br label %919
919: ; preds = %913
store i32 0, i32* %57
br label %920
920: ; preds = %937, %919
%921 = load i32, i32* %57
%922 = icmp slt i32 %921, 2
br i1 %922, label %923, label %940
923: ; preds = %920
%924 = bitcast <2 x double>* %12 to double*
%925 = load i32, i32* %57
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds double, double* %924, i64 %926
%928 = load double, double* %927
%929 = bitcast <2 x double>* %13 to double*
%930 = load i32, i32* %57
%931 = sext i32 %930 to i64
%932 = getelementptr inbounds double, double* %929, i64 %931
%933 = load double, double* %932
%934 = fcmp une double %928, %933
br i1 %934, label %935, label %936
935: ; preds = %923
unreachable
936: ; preds = %923
br label %937
937: ; preds = %936
%938 = load i32, i32* %57
%939 = add nsw i32 %938, 1
store i32 %939, i32* %57
br label %920
940: ; preds = %920
br label %941
941: ; preds = %940
%942 = load <2 x double>, <2 x double>* %11
%943 = fsub <2 x double> %942, <double 2.000000e+00, double 2.000000e+00>
store <2 x double> %943, <2 x double>* %12
%944 = load <2 x double>, <2 x double>* %11
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %58
%945 = load <2 x double>, <2 x double>* %58
%946 = fsub <2 x double> %944, %945
store <2 x double> %946, <2 x double>* %13
br label %947
947: ; preds = %941
store i32 0, i32* %59
br label %948
948: ; preds = %965, %947
%949 = load i32, i32* %59
%950 = icmp slt i32 %949, 2
br i1 %950, label %951, label %968
951: ; preds = %948
%952 = bitcast <2 x double>* %12 to double*
%953 = load i32, i32* %59
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds double, double* %952, i64 %954
%956 = load double, double* %955
%957 = bitcast <2 x double>* %13 to double*
%958 = load i32, i32* %59
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds double, double* %957, i64 %959
%961 = load double, double* %960
%962 = fcmp une double %956, %961
br i1 %962, label %963, label %964
963: ; preds = %951
unreachable
964: ; preds = %951
br label %965
965: ; preds = %964
%966 = load i32, i32* %59
%967 = add nsw i32 %966, 1
store i32 %967, i32* %59
br label %948
968: ; preds = %948
br label %969
969: ; preds = %968
%970 = load <2 x double>, <2 x double>* %11
%971 = fmul <2 x double> %970, <double 2.000000e+00, double 2.000000e+00>
store <2 x double> %971, <2 x double>* %12
%972 = load <2 x double>, <2 x double>* %11
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %60
%973 = load <2 x double>, <2 x double>* %60
%974 = fmul <2 x double> %972, %973
store <2 x double> %974, <2 x double>* %13
br label %975
975: ; preds = %969
store i32 0, i32* %61
br label %976
976: ; preds = %993, %975
%977 = load i32, i32* %61
%978 = icmp slt i32 %977, 2
br i1 %978, label %979, label %996
979: ; preds = %976
%980 = bitcast <2 x double>* %12 to double*
%981 = load i32, i32* %61
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds double, double* %980, i64 %982
%984 = load double, double* %983
%985 = bitcast <2 x double>* %13 to double*
%986 = load i32, i32* %61
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds double, double* %985, i64 %987
%989 = load double, double* %988
%990 = fcmp une double %984, %989
br i1 %990, label %991, label %992
991: ; preds = %979
unreachable
992: ; preds = %979
br label %993
993: ; preds = %992
%994 = load i32, i32* %61
%995 = add nsw i32 %994, 1
store i32 %995, i32* %61
br label %976
996: ; preds = %976
br label %997
997: ; preds = %996
%998 = load <2 x double>, <2 x double>* %11
%999 = fdiv <2 x double> %998, <double 2.000000e+00, double 2.000000e+00>
store <2 x double> %999, <2 x double>* %12
%1000 = load <2 x double>, <2 x double>* %11
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %62
%1001 = load <2 x double>, <2 x double>* %62
%1002 = fdiv <2 x double> %1000, %1001
store <2 x double> %1002, <2 x double>* %13
br label %1003
1003: ; preds = %997
store i32 0, i32* %63
br label %1004
1004: ; preds = %1021, %1003
%1005 = load i32, i32* %63
%1006 = icmp slt i32 %1005, 2
br i1 %1006, label %1007, label %1024
1007: ; preds = %1004
%1008 = bitcast <2 x double>* %12 to double*
%1009 = load i32, i32* %63
%1010 = sext i32 %1009 to i64
%1011 = getelementptr inbounds double, double* %1008, i64 %1010
%1012 = load double, double* %1011
%1013 = bitcast <2 x double>* %13 to double*
%1014 = load i32, i32* %63
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds double, double* %1013, i64 %1015
%1017 = load double, double* %1016
%1018 = fcmp une double %1012, %1017
br i1 %1018, label %1019, label %1020
1019: ; preds = %1007
unreachable
1020: ; preds = %1007
br label %1021
1021: ; preds = %1020
%1022 = load i32, i32* %63
%1023 = add nsw i32 %1022, 1
store i32 %1023, i32* %63
br label %1004
1024: ; preds = %1004
br label %1025
1025: ; preds = %1024
ret i32 0
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = trunc i32 %0 to i16
%4 = shl i32 %0, 16
%5 = add i32 %4, 131072
%6 = ashr exact i32 %5, 16
%7 = shl i32 %0, 16
%8 = ashr exact i32 %7, 16
%9 = add nsw i32 %8, 2
%10 = icmp eq i32 %9, %6
br i1 %10, label %11, label %17
11: ; preds = %2
%12 = mul i32 %0, -65536
%13 = add i32 %12, 131072
%14 = ashr exact i32 %13, 16
%15 = sub nsw i32 2, %8
%16 = icmp eq i32 %15, %14
br i1 %16, label %18, label %23
17: ; preds = %2
tail call void @abort()
unreachable
18: ; preds = %11
%19 = shl i16 %3, 1
%20 = sext i16 %19 to i32
%21 = ashr exact i32 %7, 15
%22 = icmp eq i32 %21, %20
br i1 %22, label %24, label %33
23: ; preds = %11
tail call void @abort()
unreachable
24: ; preds = %18
%25 = sdiv i16 2, %3
%26 = sdiv i16 2, %3
%27 = srem i16 2, %3
%28 = icmp eq i16 %26, %25
%29 = freeze <8 x i1> <i1 poison, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
%30 = insertelement <8 x i1> %29, i1 %28, i64 0
%31 = bitcast <8 x i1> %30 to i8
%32 = icmp eq i8 %31, -1
br i1 %32, label %34, label %41
33: ; preds = %18
tail call void @abort()
unreachable
34: ; preds = %24
%35 = srem i16 2, %3
%36 = icmp eq i16 %27, %35
%37 = freeze <8 x i1> <i1 poison, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
%38 = insertelement <8 x i1> %37, i1 %36, i64 0
%39 = bitcast <8 x i1> %38 to i8
%40 = icmp eq i8 %39, -1
br i1 %40, label %43, label %42
41: ; preds = %24
tail call void @abort()
unreachable
42: ; preds = %34
tail call void @abort()
unreachable
43: ; preds = %34
%44 = shl i16 2, %3
%45 = sext i16 %44 to i32
%46 = and i32 %0, 65535
%47 = shl i32 2, %46
%48 = icmp eq i32 %47, %45
br i1 %48, label %49, label %54
49: ; preds = %43
%50 = lshr i16 2, %3
%51 = zext i16 %50 to i32
%52 = lshr i32 2, %46
%53 = icmp eq i32 %52, %51
br i1 %53, label %56, label %55
54: ; preds = %43
tail call void @abort()
unreachable
55: ; preds = %49
tail call void @abort()
unreachable
56: ; preds = %49
%57 = shl i32 %0, 16
%58 = add i32 %57, -131072
%59 = ashr exact i32 %58, 16
%60 = add nsw i32 %8, -2
%61 = icmp eq i32 %60, %59
br i1 %61, label %63, label %62
62: ; preds = %56
tail call void @abort()
unreachable
63: ; preds = %56
%64 = sdiv i16 %3, 2
%65 = sdiv i16 %3, 2
%66 = srem i16 %3, 2
%67 = icmp eq i16 %64, %65
%68 = freeze <8 x i1> <i1 poison, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
%69 = insertelement <8 x i1> %68, i1 %67, i64 0
%70 = bitcast <8 x i1> %69 to i8
%71 = icmp eq i8 %70, -1
br i1 %71, label %72, label %79
72: ; preds = %63
%73 = srem i16 %3, 2
%74 = icmp eq i16 %66, %73
%75 = freeze <8 x i1> <i1 poison, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>
%76 = insertelement <8 x i1> %75, i1 %74, i64 0
%77 = bitcast <8 x i1> %76 to i8
%78 = icmp eq i8 %77, -1
br i1 %78, label %81, label %80
79: ; preds = %63
tail call void @abort()
unreachable
80: ; preds = %72
tail call void @abort()
unreachable
81: ; preds = %72
ret i32 0
}