#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float cos(int);
float sin(int);
void fk2mtg(float az, int npt, float *fk[12], float *mt[18]) {
  int i;
  float sa, ca, sa2, ca2;
  az = az * 1.745329252e-2;
  sa = sin(az);
  ca = cos(az);
  sa2 = sin(2 * az);
  ca2 = cos(2 * az);
  for (i = 0; i < npt; i++)
    mt[0][i] = fk[9][i] / 3. - fk[0][i] / 6. - fk[6][i] * ca2 / 2;
  for (i = 0; i < npt; i++)
    mt[1][i] = fk[10][i] / 3. - fk[1][i] / 6. - fk[7][i] * ca2 / 2;
  for (i = 0; i < npt; i++)
    mt[2][i] = -fk[8][i] * sa2 / 2;
  for (i = 0; i < npt; i++)
    mt[3][i] = -fk[6][i] * sa2;
  for (i = 0; i < npt; i++)
    mt[4][i] = -fk[7][i] * sa2;
  for (i = 0; i < npt; i++)
    mt[5][i] = fk[8][i] * ca2;
  for (i = 0; i < npt; i++)
    mt[6][i] = -fk[3][i] * ca;
  for (i = 0; i < npt; i++)
    mt[7][i] = -fk[4][i] * ca;
  for (i = 0; i < npt; i++)
    mt[8][i] = -fk[5][i] * sa;
  for (i = 0; i < npt; i++)
    mt[9][i] = fk[9][i] / 3. - fk[0][i] / 6. + fk[6][i] * ca2 / 2;
  for (i = 0; i < npt; i++)
    mt[10][i] = fk[10][i] / 3. - fk[1][i] / 6. + fk[7][i] * ca2 / 2;
  for (i = 0; i < npt; i++)
    mt[11][i] = -mt[2][i];
  for (i = 0; i < npt; i++)
    mt[12][i] = -fk[3][i] * sa;
  for (i = 0; i < npt; i++)
    mt[13][i] = -fk[4][i] * sa;
  for (i = 0; i < npt; i++)
    mt[14][i] = fk[5][i] * ca;
  for (i = 0; i < npt; i++)
    mt[15][i] = (fk[9][i] + fk[0][i]) / 3.;
  for (i = 0; i < npt; i++)
    mt[16][i] = (fk[10][i] + fk[1][i]) / 3.;
  for (i = 0; i < npt; i++)
    mt[17][i] = 0.;
  return;
}


x86 assembly (clang, -O0):
<fk2mtg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movss  %xmm0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xebf(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
cvttss2si -0x4(%rbp),%edi
call   1030 <sin@plt>
movss  %xmm0,-0x20(%rbp)
cvttss2si -0x4(%rbp),%edi
call   1040 <cos@plt>
movss  %xmm0,-0x24(%rbp)
movss  0xe84(%rip),%xmm0
mulss  -0x4(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1030 <sin@plt>
movss  %xmm0,-0x28(%rbp)
movss  0xe69(%rip),%xmm0
mulss  -0x4(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1040 <cos@plt>
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    124e <fk2mtg+0x12e>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe36(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe1e(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x2c(%rbp),%xmm1
movss  0xde0(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b1 <fk2mtg+0x91>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12f4 <fk2mtg+0x1d4>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd92(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd79(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x2c(%rbp),%xmm1
movss  0xd3b(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1255 <fk2mtg+0x135>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1355 <fk2mtg+0x235>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x28(%rbp),%xmm0
movss  0xcce(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12fb <fk2mtg+0x1db>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13aa <fk2mtg+0x28a>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    135c <fk2mtg+0x23c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13ff <fk2mtg+0x2df>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b1 <fk2mtg+0x291>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1447 <fk2mtg+0x327>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1406 <fk2mtg+0x2e6>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    149c <fk2mtg+0x37c>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    144e <fk2mtg+0x32e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14f1 <fk2mtg+0x3d1>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14a3 <fk2mtg+0x383>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1546 <fk2mtg+0x426>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14f8 <fk2mtg+0x3d8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15eb <fk2mtg+0x4cb>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa9a(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xa82(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x2c(%rbp),%xmm1
movss  0xa44(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x48(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    154d <fk2mtg+0x42d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1691 <fk2mtg+0x571>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9f5(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x9dc(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x2c(%rbp),%xmm1
movss  0x99e(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x50(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15f2 <fk2mtg+0x4d2>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16e1 <fk2mtg+0x5c1>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    0x58(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1698 <fk2mtg+0x578>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1736 <fk2mtg+0x616>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x60(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16e8 <fk2mtg+0x5c8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    178b <fk2mtg+0x66b>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x68(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    173d <fk2mtg+0x61d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17d3 <fk2mtg+0x6b3>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    0x70(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1792 <fk2mtg+0x672>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    183a <fk2mtg+0x71a>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x1c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x7fd(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x78(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17da <fk2mtg+0x6ba>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18a5 <fk2mtg+0x785>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x1c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x795(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    0x80(%rax),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1841 <fk2mtg+0x721>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    18dd <fk2mtg+0x7bd>
mov    -0x18(%rbp),%rax
mov    0x88(%rax),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    18ac <fk2mtg+0x78c>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fk2mtg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rsi,%r15
mov    %edi,%r12d
cvtss2sd %xmm0,%xmm0
mulsd  0x1ead(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
cvttss2si %xmm0,%ebx
mov    %ebx,%edi
call   1040 <sin@plt>
movaps %xmm0,0x30(%rsp)
mov    %ebx,%edi
call   1050 <cos@plt>
movaps %xmm0,0x20(%rsp)
movss  0x10(%rsp),%xmm0
addss  %xmm0,%xmm0
cvttss2si %xmm0,%ebx
mov    %ebx,%edi
call   1040 <sin@plt>
movaps %xmm0,0x10(%rsp)
mov    %ebx,%edi
call   1050 <cos@plt>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x48(%r15),%rax
mov    (%r15),%rcx
mov    0x30(%r15),%rsi
mov    (%r14),%rdi
mov    %r12d,%edx
cmp    $0x4,%r12d
jae    136a <fk2mtg+0x23a>
xor    %ebx,%ebx
movsd  0x1e40(%rip),%xmm1
movsd  0x1e40(%rip),%xmm2
movss  0x1ea8(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rbx,4),%xmm4
cvtss2sd %xmm4,%xmm4
divsd  %xmm1,%xmm4
movss  (%rcx,%rbx,4),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movss  (%rsi,%rbx,4),%xmm4
mulss  %xmm0,%xmm4
mulss  %xmm3,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rdi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    11e0 <fk2mtg+0xb0>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x50(%r15),%rax
mov    0x8(%r15),%rcx
mov    0x38(%r15),%rsi
mov    0x8(%r14),%rdi
cmp    $0x4,%r12d
jae    147e <fk2mtg+0x34e>
xor    %ebx,%ebx
movsd  0x1db6(%rip),%xmm1
movsd  0x1db6(%rip),%xmm2
movss  0x1e1e(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rbx,4),%xmm4
cvtss2sd %xmm4,%xmm4
divsd  %xmm1,%xmm4
movss  (%rcx,%rbx,4),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movss  (%rsi,%rbx,4),%xmm4
mulss  %xmm0,%xmm4
mulss  %xmm3,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rdi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1270 <fk2mtg+0x140>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
movaps 0x10(%rsp),%xmm7
movaps %xmm7,%xmm1
mov    0x40(%r15),%rax
mov    0x10(%r14),%rcx
cmp    $0x8,%r12d
jb     12ee <fk2mtg+0x1be>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
jae    159e <fk2mtg+0x46e>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    159e <fk2mtg+0x46e>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
test   $0x1,%dl
je     1315 <fk2mtg+0x1e5>
movss  (%rax,%rsi,4),%xmm2
mulss  %xmm1,%xmm2
mulss  0x1d74(%rip),%xmm2
movss  %xmm2,(%rcx,%rsi,4)
or     $0x1,%rsi
add    %rdx,%rdi
je     1675 <fk2mtg+0x545>
movaps 0x1d2b(%rip),%xmm2
movss  0x1d57(%rip),%xmm3
nopl   (%rax)
movss  (%rax,%rsi,4),%xmm4
xorps  %xmm2,%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm4
xorps  %xmm2,%xmm4
mulss  %xmm7,%xmm4
mulss  %xmm3,%xmm4
movss  %xmm4,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    1330 <fk2mtg+0x200>
jmp    1675 <fk2mtg+0x545>
mov    %r12d,0xc(%rsp)
mov    %r15,%r12
mov    %r14,%r15
lea    (%rdi,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
lea    (%rcx,%rdx,4),%r8
lea    (%rsi,%rdx,4),%r9
cmp    %rbx,%rdi
setb   %r13b
cmp    %rbp,%rax
setb   %r14b
cmp    %r8,%rdi
setb   %r8b
cmp    %rbp,%rcx
setb   %r10b
cmp    %r9,%rdi
setb   %r9b
cmp    %rbp,%rsi
setb   %r11b
xor    %ebx,%ebx
test   %r14b,%r13b
jne    158e <fk2mtg+0x45e>
and    %r10b,%r8b
jne    158e <fk2mtg+0x45e>
and    %r11b,%r9b
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jne    11c0 <fk2mtg+0x90>
mov    %edx,%ebx
and    $0xfffffffc,%ebx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    0x0(,%rdx,4),%r8
and    $0xfffffffffffffff0,%r8
xor    %ebp,%ebp
movapd 0x1c27(%rip),%xmm2
movapd 0x1c2f(%rip),%xmm3
movaps 0x1c37(%rip),%xmm8
nopl   0x0(%rax)
cvtps2pd (%rax,%rbp,1),%xmm5
cvtps2pd 0x8(%rax,%rbp,1),%xmm6
divpd  %xmm2,%xmm6
divpd  %xmm2,%xmm5
cvtps2pd (%rcx,%rbp,1),%xmm7
cvtps2pd 0x8(%rcx,%rbp,1),%xmm4
divpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
divpd  %xmm3,%xmm7
addpd  %xmm5,%xmm7
movups (%rsi,%rbp,1),%xmm5
mulps  %xmm1,%xmm5
mulps  %xmm8,%xmm5
cvtps2pd %xmm5,%xmm6
addpd  %xmm7,%xmm6
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
addpd  %xmm4,%xmm5
cvtpd2ps %xmm6,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm5,%xmm4
movupd %xmm4,(%rdi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r8
jne    1410 <fk2mtg+0x2e0>
cmp    %rdx,%rbx
jne    11c0 <fk2mtg+0x90>
jmp    1225 <fk2mtg+0xf5>
mov    %r12d,0xc(%rsp)
mov    %r15,%r12
mov    %r14,%r15
lea    (%rdi,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
lea    (%rcx,%rdx,4),%r8
lea    (%rsi,%rdx,4),%r9
cmp    %rbx,%rdi
setb   %r14b
cmp    %rbp,%rax
setb   %r13b
cmp    %r8,%rdi
setb   %r8b
cmp    %rbp,%rcx
setb   %r10b
cmp    %r9,%rdi
setb   %r9b
cmp    %rbp,%rsi
setb   %r11b
xor    %ebx,%ebx
test   %r13b,%r14b
jne    16b6 <fk2mtg+0x586>
and    %r10b,%r8b
jne    16b6 <fk2mtg+0x586>
and    %r11b,%r9b
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jne    124a <fk2mtg+0x11a>
mov    %edx,%ebx
and    $0xfffffffc,%ebx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    0x0(,%rdx,4),%r8
and    $0xfffffffffffffff0,%r8
xor    %ebp,%ebp
movapd 0x1b13(%rip),%xmm2
movapd 0x1b1b(%rip),%xmm3
movaps 0x1b23(%rip),%xmm8
nopl   (%rax)
cvtps2pd (%rax,%rbp,1),%xmm5
cvtps2pd 0x8(%rax,%rbp,1),%xmm6
divpd  %xmm2,%xmm6
divpd  %xmm2,%xmm5
cvtps2pd (%rcx,%rbp,1),%xmm7
cvtps2pd 0x8(%rcx,%rbp,1),%xmm4
divpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
divpd  %xmm3,%xmm7
addpd  %xmm5,%xmm7
movups (%rsi,%rbp,1),%xmm5
mulps  %xmm1,%xmm5
mulps  %xmm8,%xmm5
cvtps2pd %xmm5,%xmm6
addpd  %xmm7,%xmm6
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
addpd  %xmm4,%xmm5
cvtpd2ps %xmm6,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm5,%xmm4
movupd %xmm4,(%rdi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r8
jne    1520 <fk2mtg+0x3f0>
cmp    %rdx,%rbx
jne    124a <fk2mtg+0x11a>
jmp    12b5 <fk2mtg+0x185>
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jmp    11c0 <fk2mtg+0x90>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     174a <fk2mtg+0x61a>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x1a7e(%rip),%xmm3
movaps 0x1a87(%rip),%xmm4
nopl   0x0(%rax)
movups (%rax,%rdi,4),%xmm5
movups 0x10(%rax,%rdi,4),%xmm6
xorps  %xmm3,%xmm5
xorps  %xmm3,%xmm6
mulps  %xmm2,%xmm5
mulps  %xmm2,%xmm6
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,(%rcx,%rdi,4)
movups %xmm6,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm5
movups 0x30(%rax,%rdi,4),%xmm6
xorps  %xmm3,%xmm5
xorps  %xmm3,%xmm6
mulps  %xmm2,%xmm5
mulps  %xmm2,%xmm6
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,0x20(%rcx,%rdi,4)
movups %xmm6,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    15e0 <fk2mtg+0x4b0>
test   $0x1,%bpl
je     166c <fk2mtg+0x53c>
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
movaps 0x1a06(%rip),%xmm5
xorps  %xmm5,%xmm3
xorps  %xmm5,%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movaps 0x1a03(%rip),%xmm2
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
jne    12f0 <fk2mtg+0x1c0>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x30(%r15),%rax
mov    0x18(%r14),%rcx
cmp    $0x8,%r12d
jae    1698 <fk2mtg+0x568>
xor    %esi,%esi
movaps 0x10(%rsp),%xmm6
jmp    1791 <fk2mtg+0x661>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x10(%rsp),%xmm6
jae    16c6 <fk2mtg+0x596>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    16c6 <fk2mtg+0x596>
xor    %esi,%esi
jmp    1791 <fk2mtg+0x661>
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jmp    124a <fk2mtg+0x11a>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     175b <fk2mtg+0x62b>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x195a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm4
movups 0x10(%rax,%rdi,4),%xmm5
xorps  %xmm3,%xmm4
xorps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
mulps  %xmm2,%xmm5
movups %xmm4,(%rcx,%rdi,4)
movups %xmm5,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm4
movups 0x30(%rax,%rdi,4),%xmm5
xorps  %xmm3,%xmm4
xorps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
mulps  %xmm2,%xmm5
movups %xmm4,0x20(%rcx,%rdi,4)
movups %xmm5,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1700 <fk2mtg+0x5d0>
jmp    175d <fk2mtg+0x62d>
xor    %edi,%edi
test   $0x1,%bpl
jne    163a <fk2mtg+0x50a>
jmp    166c <fk2mtg+0x53c>
xor    %edi,%edi
test   $0x1,%bpl
je     1788 <fk2mtg+0x658>
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
movaps 0x18dd(%rip),%xmm5
xorps  %xmm5,%xmm3
xorps  %xmm5,%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     1833 <fk2mtg+0x703>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     17cb <fk2mtg+0x69b>
movaps 0x18a6(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    17b0 <fk2mtg+0x680>
cmp    $0x3,%rdi
jb     1833 <fk2mtg+0x703>
movaps 0x1878(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    17e0 <fk2mtg+0x6b0>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x38(%r15),%rax
mov    0x20(%r14),%rcx
cmp    $0x8,%r12d
jae    1856 <fk2mtg+0x726>
xor    %esi,%esi
movaps 0x10(%rsp),%xmm5
jmp    1930 <fk2mtg+0x800>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x10(%rsp),%xmm5
jae    1874 <fk2mtg+0x744>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1874 <fk2mtg+0x744>
xor    %esi,%esi
jmp    1930 <fk2mtg+0x800>
mov    %edx,%esi
and    $0xfffffff8,%esi
shufps $0x0,%xmm1,%xmm1
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     18fa <fk2mtg+0x7ca>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x17af(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm3
movups 0x30(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,0x20(%rcx,%rdi,4)
movups %xmm4,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    18b0 <fk2mtg+0x780>
jmp    18fc <fk2mtg+0x7cc>
xor    %edi,%edi
test   $0x1,%bpl
je     1927 <fk2mtg+0x7f7>
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
movaps 0x173e(%rip),%xmm4
xorps  %xmm4,%xmm2
xorps  %xmm4,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     19d3 <fk2mtg+0x8a3>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     196b <fk2mtg+0x83b>
movaps 0x1707(%rip),%xmm1
nopl   0x0(%rax)
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1950 <fk2mtg+0x820>
cmp    $0x3,%rdi
jb     19d3 <fk2mtg+0x8a3>
movaps 0x16d8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1980 <fk2mtg+0x850>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x40(%r15),%rax
mov    0x28(%r14),%rcx
cmp    $0x8,%r12d
jb     1a04 <fk2mtg+0x8d4>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
jae    1a9c <fk2mtg+0x96c>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1a9c <fk2mtg+0x96c>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     1a38 <fk2mtg+0x908>
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1a20 <fk2mtg+0x8f0>
cmp    $0x3,%rdi
jb     1b36 <fk2mtg+0xa06>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1a50 <fk2mtg+0x920>
jmp    1b36 <fk2mtg+0xa06>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rdi,%rdi
je     1b0e <fk2mtg+0x9de>
mov    %rbx,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm2
movups 0x30(%rax,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%rcx,%rdi,4)
movups %xmm3,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1ad0 <fk2mtg+0x9a0>
jmp    1b10 <fk2mtg+0x9e0>
xor    %edi,%edi
test   $0x1,%bl
je     1b2d <fk2mtg+0x9fd>
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
jne    1a06 <fk2mtg+0x8d6>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x18(%r15),%rax
mov    0x30(%r14),%rcx
cmp    $0x8,%r12d
jae    1b59 <fk2mtg+0xa29>
xor    %esi,%esi
movaps 0x20(%rsp),%xmm5
jmp    1c27 <fk2mtg+0xaf7>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x20(%rsp),%xmm5
jae    1b77 <fk2mtg+0xa47>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1b77 <fk2mtg+0xa47>
xor    %esi,%esi
jmp    1c27 <fk2mtg+0xaf7>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm5,%xmm1
shufps $0x0,%xmm5,%xmm1
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     1bf1 <fk2mtg+0xac1>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x14a9(%rip),%xmm2
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm3
movups 0x30(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,0x20(%rcx,%rdi,4)
movups %xmm4,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1ba7 <fk2mtg+0xa77>
jmp    1bf3 <fk2mtg+0xac3>
xor    %edi,%edi
test   $0x1,%bpl
je     1c1e <fk2mtg+0xaee>
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
movaps 0x1447(%rip),%xmm4
xorps  %xmm4,%xmm2
xorps  %xmm4,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     1cc3 <fk2mtg+0xb93>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     1c5b <fk2mtg+0xb2b>
movaps 0x1410(%rip),%xmm1
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1c40 <fk2mtg+0xb10>
cmp    $0x3,%rdi
jb     1cc3 <fk2mtg+0xb93>
movaps 0x13e8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1c70 <fk2mtg+0xb40>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x20(%r15),%rax
mov    0x38(%r14),%rcx
cmp    $0x8,%r12d
jae    1ce6 <fk2mtg+0xbb6>
xor    %esi,%esi
movaps 0x20(%rsp),%xmm5
jmp    1db4 <fk2mtg+0xc84>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x20(%rsp),%xmm5
jae    1d04 <fk2mtg+0xbd4>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1d04 <fk2mtg+0xbd4>
xor    %esi,%esi
jmp    1db4 <fk2mtg+0xc84>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm5,%xmm1
shufps $0x0,%xmm5,%xmm1
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     1d7e <fk2mtg+0xc4e>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x131c(%rip),%xmm2
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm3
movups 0x30(%rax,%rdi,4),%xmm4
xorps  %xmm2,%xmm3
xorps  %xmm2,%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,0x20(%rcx,%rdi,4)
movups %xmm4,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1d34 <fk2mtg+0xc04>
jmp    1d80 <fk2mtg+0xc50>
xor    %edi,%edi
test   $0x1,%bpl
je     1dab <fk2mtg+0xc7b>
movups (%rax,%rdi,4),%xmm2
movups 0x10(%rax,%rdi,4),%xmm3
movaps 0x12ba(%rip),%xmm4
xorps  %xmm4,%xmm2
xorps  %xmm4,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     1e53 <fk2mtg+0xd23>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     1deb <fk2mtg+0xcbb>
movaps 0x1283(%rip),%xmm1
nopl   (%rax)
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1dd0 <fk2mtg+0xca0>
cmp    $0x3,%rdi
jb     1e53 <fk2mtg+0xd23>
movaps 0x1258(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm5,%xmm2
movss  %xmm2,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1e00 <fk2mtg+0xcd0>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
movaps 0x30(%rsp),%xmm6
movaps %xmm6,%xmm8
mov    0x28(%r15),%rax
mov    0x40(%r14),%rcx
cmp    $0x8,%r12d
jb     1e8d <fk2mtg+0xd5d>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
jae    1f38 <fk2mtg+0xe08>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1f38 <fk2mtg+0xe08>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     1ecb <fk2mtg+0xd9b>
movaps 0x11a8(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rsi,4),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm6,%xmm3
movss  %xmm3,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1eb0 <fk2mtg+0xd80>
cmp    $0x3,%rdi
jb     1fea <fk2mtg+0xeba>
movaps 0x1174(%rip),%xmm2
nopl   0x0(%rax)
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm2,%xmm1
mulss  %xmm6,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
xorps  %xmm2,%xmm1
mulss  %xmm6,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm1
xorps  %xmm2,%xmm1
mulss  %xmm6,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm1
xorps  %xmm2,%xmm1
mulss  %xmm6,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1ee0 <fk2mtg+0xdb0>
jmp    1fea <fk2mtg+0xeba>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm8,%xmm2
shufps $0x0,%xmm8,%xmm2
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     1fb4 <fk2mtg+0xe84>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x10e6(%rip),%xmm3
movups (%rax,%rdi,4),%xmm4
movups 0x10(%rax,%rdi,4),%xmm5
xorps  %xmm3,%xmm4
xorps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
mulps  %xmm2,%xmm5
movups %xmm4,(%rcx,%rdi,4)
movups %xmm5,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm4
movups 0x30(%rax,%rdi,4),%xmm5
xorps  %xmm3,%xmm4
xorps  %xmm3,%xmm5
mulps  %xmm2,%xmm4
mulps  %xmm2,%xmm5
movups %xmm4,0x20(%rcx,%rdi,4)
movups %xmm5,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1f6a <fk2mtg+0xe3a>
jmp    1fb6 <fk2mtg+0xe86>
xor    %edi,%edi
test   $0x1,%bpl
je     1fe1 <fk2mtg+0xeb1>
movups (%rax,%rdi,4),%xmm3
movups 0x10(%rax,%rdi,4),%xmm4
movaps 0x1084(%rip),%xmm5
xorps  %xmm5,%xmm3
xorps  %xmm5,%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%rcx,%rdi,4)
movups %xmm4,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
jne    1e8f <fk2mtg+0xd5f>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x48(%r15),%rax
mov    (%r15),%rcx
mov    0x30(%r15),%rsi
mov    0x48(%r14),%rdi
cmp    $0x4,%r12d
jae    21b3 <fk2mtg+0x1083>
xor    %ebx,%ebx
movsd  0xff2(%rip),%xmm2
movsd  0xff2(%rip),%xmm3
movss  0x105e(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm2,%xmm1
movss  (%rcx,%rbx,4),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm3,%xmm5
addsd  %xmm1,%xmm5
movss  (%rsi,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm5,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    2030 <fk2mtg+0xf00>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x50(%r15),%rax
mov    0x8(%r15),%rcx
mov    0x38(%r15),%rsi
mov    0x50(%r14),%rdi
cmp    $0x4,%r12d
jae    22c0 <fk2mtg+0x1190>
xor    %ebx,%ebx
movsd  0xf66(%rip),%xmm2
movsd  0xf66(%rip),%xmm3
movss  0xfd2(%rip),%xmm4
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm2,%xmm1
movss  (%rcx,%rbx,4),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm3,%xmm5
addsd  %xmm1,%xmm5
movss  (%rsi,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm5,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdi,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    20b2 <fk2mtg+0xf82>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x10(%r14),%rax
mov    0x58(%r14),%rcx
cmp    $0x8,%r12d
jb     2128 <fk2mtg+0xff8>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
jae    23dd <fk2mtg+0x12ad>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    23dd <fk2mtg+0x12ad>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     215a <fk2mtg+0x102a>
movaps 0xf0d(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    2143 <fk2mtg+0x1013>
cmp    $0x3,%rdi
jb     2483 <fk2mtg+0x1353>
movaps 0xee5(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    216b <fk2mtg+0x103b>
jmp    2483 <fk2mtg+0x1353>
mov    %r12d,0xc(%rsp)
mov    %r15,%r12
mov    %r14,%r15
lea    (%rdi,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
lea    (%rcx,%rdx,4),%r8
lea    (%rsi,%rdx,4),%r9
cmp    %rbx,%rdi
setb   %r14b
cmp    %rbp,%rax
setb   %r13b
cmp    %r8,%rdi
setb   %r8b
cmp    %rbp,%rcx
setb   %r10b
cmp    %r9,%rdi
setb   %r9b
cmp    %rbp,%rsi
setb   %r11b
xor    %ebx,%ebx
test   %r13b,%r14b
jne    23cd <fk2mtg+0x129d>
and    %r10b,%r8b
jne    23cd <fk2mtg+0x129d>
and    %r11b,%r9b
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jne    200e <fk2mtg+0xede>
mov    %edx,%ebx
and    $0xfffffffc,%ebx
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
lea    0x0(,%rdx,4),%r8
and    $0xfffffffffffffff0,%r8
xor    %ebp,%ebp
movapd 0xdde(%rip),%xmm3
movapd 0xde6(%rip),%xmm4
movaps 0xe0e(%rip),%xmm9
cvtps2pd (%rax,%rbp,1),%xmm6
cvtps2pd 0x8(%rax,%rbp,1),%xmm7
divpd  %xmm3,%xmm7
divpd  %xmm3,%xmm6
cvtps2pd (%rcx,%rbp,1),%xmm1
cvtps2pd 0x8(%rcx,%rbp,1),%xmm5
divpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
divpd  %xmm4,%xmm1
addpd  %xmm6,%xmm1
movups (%rsi,%rbp,1),%xmm6
mulps  %xmm2,%xmm6
mulps  %xmm9,%xmm6
cvtps2pd %xmm6,%xmm7
addpd  %xmm1,%xmm7
movhlps %xmm6,%xmm6
cvtps2pd %xmm6,%xmm1
addpd  %xmm5,%xmm1
cvtpd2ps %xmm7,%xmm5
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm5
movupd %xmm5,(%rdi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r8
jne    2252 <fk2mtg+0x1122>
cmp    %rdx,%rbx
jne    200e <fk2mtg+0xede>
jmp    2075 <fk2mtg+0xf45>
mov    %r12d,0xc(%rsp)
mov    %r15,%r12
mov    %r14,%r15
lea    (%rdi,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
lea    (%rcx,%rdx,4),%r8
lea    (%rsi,%rdx,4),%r9
cmp    %rbx,%rdi
setb   %r14b
cmp    %rbp,%rax
setb   %r13b
cmp    %r8,%rdi
setb   %r8b
cmp    %rbp,%rcx
setb   %r10b
cmp    %r9,%rdi
setb   %r9b
cmp    %rbp,%rsi
setb   %r11b
xor    %ebx,%ebx
test   %r13b,%r14b
jne    2444 <fk2mtg+0x1314>
and    %r10b,%r8b
jne    2444 <fk2mtg+0x1314>
and    %r11b,%r9b
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jne    209a <fk2mtg+0xf6a>
mov    %edx,%ebx
and    $0xfffffffc,%ebx
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
lea    0x0(,%rdx,4),%r8
and    $0xfffffffffffffff0,%r8
xor    %ebp,%ebp
movapd 0xcd1(%rip),%xmm3
movapd 0xcd9(%rip),%xmm4
movaps 0xd01(%rip),%xmm9
cvtps2pd (%rax,%rbp,1),%xmm1
cvtps2pd 0x8(%rax,%rbp,1),%xmm6
divpd  %xmm3,%xmm6
divpd  %xmm3,%xmm1
cvtps2pd (%rcx,%rbp,1),%xmm7
cvtps2pd 0x8(%rcx,%rbp,1),%xmm5
divpd  %xmm4,%xmm5
addpd  %xmm6,%xmm5
divpd  %xmm4,%xmm7
addpd  %xmm1,%xmm7
movups (%rsi,%rbp,1),%xmm1
mulps  %xmm2,%xmm1
mulps  %xmm9,%xmm1
cvtps2pd %xmm1,%xmm6
addpd  %xmm7,%xmm6
movhlps %xmm1,%xmm1
cvtps2pd %xmm1,%xmm1
addpd  %xmm5,%xmm1
cvtpd2ps %xmm6,%xmm5
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm5
movupd %xmm5,(%rdi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r8
jne    235f <fk2mtg+0x122f>
cmp    %rdx,%rbx
jne    209a <fk2mtg+0xf6a>
jmp    20f7 <fk2mtg+0xfc7>
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jmp    200e <fk2mtg+0xede>
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rdi,%rdi
je     2454 <fk2mtg+0x1324>
mov    %rbx,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
movaps 0xc4a(%rip),%xmm0
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm1
movups 0x30(%rax,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
movups %xmm1,0x20(%rcx,%rdi,4)
movups %xmm2,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    2406 <fk2mtg+0x12d6>
jmp    2456 <fk2mtg+0x1326>
mov    %r15,%r14
mov    %r12,%r15
mov    0xc(%rsp),%r12d
jmp    209a <fk2mtg+0xf6a>
xor    %edi,%edi
test   $0x1,%bl
je     247a <fk2mtg+0x134a>
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movaps 0xbe5(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
movups %xmm0,(%rcx,%rdi,4)
movups %xmm1,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
jne    212a <fk2mtg+0xffa>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x18(%r15),%rax
mov    0x60(%r14),%rcx
cmp    $0x8,%r12d
jae    24a6 <fk2mtg+0x1376>
xor    %esi,%esi
movaps 0x30(%rsp),%xmm4
jmp    2576 <fk2mtg+0x1446>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x30(%rsp),%xmm4
jae    24c4 <fk2mtg+0x1394>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    24c4 <fk2mtg+0x1394>
xor    %esi,%esi
jmp    2576 <fk2mtg+0x1446>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     2540 <fk2mtg+0x1410>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0xb5a(%rip),%xmm2
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm3
xorps  %xmm2,%xmm1
xorps  %xmm2,%xmm3
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm3
movups %xmm1,(%rcx,%rdi,4)
movups %xmm3,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm1
movups 0x30(%rax,%rdi,4),%xmm3
xorps  %xmm2,%xmm1
xorps  %xmm2,%xmm3
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm3
movups %xmm1,0x20(%rcx,%rdi,4)
movups %xmm3,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    24f6 <fk2mtg+0x13c6>
jmp    2542 <fk2mtg+0x1412>
xor    %edi,%edi
test   $0x1,%bpl
je     256d <fk2mtg+0x143d>
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm2
movaps 0xaf8(%rip),%xmm3
xorps  %xmm3,%xmm1
xorps  %xmm3,%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     260a <fk2mtg+0x14da>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     25aa <fk2mtg+0x147a>
movaps 0xac1(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    258f <fk2mtg+0x145f>
cmp    $0x3,%rdi
jb     260a <fk2mtg+0x14da>
movaps 0xa99(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm4,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    25b7 <fk2mtg+0x1487>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x20(%r15),%rax
mov    0x68(%r14),%rcx
cmp    $0x8,%r12d
jae    262d <fk2mtg+0x14fd>
xor    %esi,%esi
movaps 0x30(%rsp),%xmm3
jmp    26ff <fk2mtg+0x15cf>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x30(%rsp),%xmm3
jae    264b <fk2mtg+0x151b>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    264b <fk2mtg+0x151b>
xor    %esi,%esi
jmp    26ff <fk2mtg+0x15cf>
mov    %edx,%esi
and    $0xfffffff8,%esi
shufps $0x0,%xmm8,%xmm8
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdi,%rdi
je     26c7 <fk2mtg+0x1597>
mov    %rbp,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
movaps 0x9d7(%rip),%xmm0
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
mulps  %xmm8,%xmm1
mulps  %xmm8,%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm1
movups 0x30(%rax,%rdi,4),%xmm2
xorps  %xmm0,%xmm1
xorps  %xmm0,%xmm2
mulps  %xmm8,%xmm1
mulps  %xmm8,%xmm2
movups %xmm1,0x20(%rcx,%rdi,4)
movups %xmm2,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2679 <fk2mtg+0x1549>
jmp    26c9 <fk2mtg+0x1599>
xor    %edi,%edi
test   $0x1,%bpl
je     26f6 <fk2mtg+0x15c6>
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movaps 0x971(%rip),%xmm2
xorps  %xmm2,%xmm0
xorps  %xmm2,%xmm1
mulps  %xmm8,%xmm0
mulps  %xmm8,%xmm1
movups %xmm0,(%rcx,%rdi,4)
movups %xmm1,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     2793 <fk2mtg+0x1663>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     2733 <fk2mtg+0x1603>
movaps 0x938(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    2718 <fk2mtg+0x15e8>
cmp    $0x3,%rdi
jb     2793 <fk2mtg+0x1663>
movaps 0x910(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    2740 <fk2mtg+0x1610>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x28(%r15),%rax
mov    0x70(%r14),%rcx
cmp    $0x8,%r12d
jae    27b6 <fk2mtg+0x1686>
xor    %esi,%esi
movaps 0x20(%rsp),%xmm3
jmp    285f <fk2mtg+0x172f>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%rcx
movaps 0x20(%rsp),%xmm3
jae    27d4 <fk2mtg+0x16a4>
lea    (%rcx,%rdx,4),%rsi
cmp    %rsi,%rax
jae    27d4 <fk2mtg+0x16a4>
xor    %esi,%esi
jmp    285f <fk2mtg+0x172f>
mov    %edx,%esi
and    $0xfffffff8,%esi
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x8(%rsi),%rdi
mov    %rdi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rdi,%rdi
je     283b <fk2mtg+0x170b>
mov    %rbx,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm1
movups 0x30(%rax,%rdi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x20(%rcx,%rdi,4)
movups %xmm2,0x30(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    27fd <fk2mtg+0x16cd>
jmp    283d <fk2mtg+0x170d>
xor    %edi,%edi
test   $0x1,%bl
je     285a <fk2mtg+0x172a>
movups (%rax,%rdi,4),%xmm1
movups 0x10(%rax,%rdi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
cmp    %rdx,%rsi
je     28d6 <fk2mtg+0x17a6>
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdx,%rbp
and    $0x3,%rbp
je     2889 <fk2mtg+0x1759>
movss  (%rax,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    2871 <fk2mtg+0x1741>
cmp    $0x3,%rdi
jb     28d6 <fk2mtg+0x17a6>
movss  (%rax,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x4(%rcx,%rsi,4)
movss  0x8(%rax,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x8(%rcx,%rsi,4)
movss  0xc(%rax,%rsi,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    288f <fk2mtg+0x175f>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    (%r15),%rax
mov    0x48(%r15),%rcx
mov    0x78(%r14),%rsi
cmp    $0x4,%r12d
jae    28f7 <fk2mtg+0x17c7>
xor    %edi,%edi
jmp    29ad <fk2mtg+0x187d>
lea    (%rsi,%rdx,4),%rdi
lea    (%rcx,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
cmp    %rbp,%rsi
setb   %r9b
cmp    %rdi,%rcx
setb   %r10b
cmp    %rbx,%rsi
setb   %bl
cmp    %rdi,%rax
setb   %r8b
xor    %edi,%edi
test   %r10b,%r9b
jne    29ad <fk2mtg+0x187d>
and    %r8b,%bl
jne    29ad <fk2mtg+0x187d>
mov    %edx,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rbp
mov    %rbp,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rbp,%rbp
je     298a <fk2mtg+0x185a>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
movaps 0x719(%rip),%xmm0
movups (%rcx,%rbx,4),%xmm1
movups (%rax,%rbx,4),%xmm2
addps  %xmm1,%xmm2
divps  %xmm0,%xmm2
movups %xmm2,(%rsi,%rbx,4)
movups 0x10(%rcx,%rbx,4),%xmm1
movups 0x10(%rax,%rbx,4),%xmm2
addps  %xmm1,%xmm2
divps  %xmm0,%xmm2
movups %xmm2,0x10(%rsi,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    2957 <fk2mtg+0x1827>
jmp    298c <fk2mtg+0x185c>
xor    %ebx,%ebx
test   $0x1,%r8b
je     29a8 <fk2mtg+0x1878>
movups (%rcx,%rbx,4),%xmm0
movups (%rax,%rbx,4),%xmm1
addps  %xmm0,%xmm1
divps  0x6cc(%rip),%xmm1
movups %xmm1,(%rsi,%rbx,4)
cmp    %rdx,%rdi
je     2a12 <fk2mtg+0x18e2>
mov    %rdi,%rbp
not    %rbp
test   $0x1,%dl
je     29d3 <fk2mtg+0x18a3>
movss  (%rcx,%rdi,4),%xmm0
addss  (%rax,%rdi,4),%xmm0
divss  0x6be(%rip),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
or     $0x1,%rdi
add    %rdx,%rbp
je     2a12 <fk2mtg+0x18e2>
movss  0x6a8(%rip),%xmm0
movss  (%rcx,%rdi,4),%xmm1
addss  (%rax,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm1
addss  0x4(%rax,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsi,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    29e0 <fk2mtg+0x18b0>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x8(%r15),%rax
mov    0x50(%r15),%rcx
mov    0x80(%r14),%rsi
cmp    $0x4,%r12d
jae    2aa0 <fk2mtg+0x1970>
xor    %edi,%edi
mov    %rdi,%rbp
not    %rbp
test   $0x1,%dl
je     2a58 <fk2mtg+0x1928>
movss  (%rcx,%rdi,4),%xmm0
addss  (%rax,%rdi,4),%xmm0
divss  0x639(%rip),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
or     $0x1,%rdi
add    %rdx,%rbp
je     2b5e <fk2mtg+0x1a2e>
movss  0x61f(%rip),%xmm0
movss  (%rcx,%rdi,4),%xmm1
addss  (%rax,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm1
addss  0x4(%rax,%rdi,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsi,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    2a69 <fk2mtg+0x1939>
jmp    2b5e <fk2mtg+0x1a2e>
lea    (%rsi,%rdx,4),%rdi
lea    (%rcx,%rdx,4),%rbp
lea    (%rax,%rdx,4),%rbx
cmp    %rbp,%rsi
setb   %r9b
cmp    %rdi,%rcx
setb   %r10b
cmp    %rbx,%rsi
setb   %bl
cmp    %rdi,%rax
setb   %r8b
xor    %edi,%edi
test   %r10b,%r9b
jne    2a32 <fk2mtg+0x1902>
and    %r8b,%bl
jne    2a32 <fk2mtg+0x1902>
mov    %edx,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rbp
mov    %rbp,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rbp,%rbp
je     2b37 <fk2mtg+0x1a07>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
movaps 0x56c(%rip),%xmm0
movups (%rcx,%rbx,4),%xmm1
movups (%rax,%rbx,4),%xmm2
addps  %xmm1,%xmm2
divps  %xmm0,%xmm2
movups %xmm2,(%rsi,%rbx,4)
movups 0x10(%rcx,%rbx,4),%xmm1
movups 0x10(%rax,%rbx,4),%xmm2
addps  %xmm1,%xmm2
divps  %xmm0,%xmm2
movups %xmm2,0x10(%rsi,%rbx,4)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    2b04 <fk2mtg+0x19d4>
jmp    2b39 <fk2mtg+0x1a09>
xor    %ebx,%ebx
test   $0x1,%r8b
je     2b55 <fk2mtg+0x1a25>
movups (%rcx,%rbx,4),%xmm0
movups (%rax,%rbx,4),%xmm1
addps  %xmm0,%xmm1
divps  0x51f(%rip),%xmm1
movups %xmm1,(%rsi,%rbx,4)
cmp    %rdx,%rdi
jne    2a32 <fk2mtg+0x1902>
test   %r12d,%r12d
jle    2b75 <fk2mtg+0x1a45>
mov    0x88(%r14),%rdi
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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