void bioD1__3d(invector, HHH, HHL, HLH, HLL, LHH, LHL, LLH, LLL, xlength,
               ylength, zlength, X, norm) float *invector;
float *HLL, *HLH, *HHL, *HHH;
float *LLL, *LLH, *LHL, *LHH;
int xlength, ylength, zlength;
float X, norm;
{
  register int j, s;
  float *vptr, *vptrend_1;
  float *HLLptr, *HLHptr, *HHLptr, *HHHptr;
  float *LLLptr, *LLHptr, *LHLptr, *LHHptr;
  float x1, x0, x_1, x_2;
  int dim;
  vptr = invector;
  HHHptr = HHH;
  HHLptr = HHL;
  HLHptr = HLH;
  HLLptr = HLL;
  LHHptr = LHH;
  LHLptr = LHL;
  LLHptr = LLH;
  LLLptr = LLL;
  dim = (xlength > 1) + (ylength > 1) + (zlength > 1);
  if (dim == 3) {
    x1 = X * norm;
    x0 = norm;
    x_1 = norm / X;
    x_2 = x_1 / X;
  }
  if (dim == 2) {
    x1 = 0;
    x0 = X * norm;
    x_1 = norm;
    x_2 = norm / X;
  }
  if (dim == 1) {
    x_1 = X * norm;
    x_2 = norm;
    x1 = 0;
    x0 = 0;
  }
  if (dim == 0) {
    X = 1.0;
    norm = 1.0;
    x_2 = X * norm;
    x1 = 0;
    x0 = 0;
    x_1 = 0;
  }
  s = 0;
  while (s < zlength - 1) {
    j = 0;
    while (j < ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
        *(LLHptr++) = x_1 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
      }
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LHLptr++) = x_1 * *(vptr++);
        *(LHHptr++) = x0 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LHLptr++) = x_1 * *(vptr++);
      }
      j += 2;
    }
    if (j == ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
        *(LLHptr++) = x_1 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
      }
      j++;
    }
    j = 0;
    while (j < ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(HLLptr++) = x_1 * *(vptr++);
        *(HLHptr++) = x0 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(HLLptr++) = x_1 * *(vptr++);
      }
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(HHLptr++) = x0 * *(vptr++);
        *(HHHptr++) = x1 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(HHLptr++) = x0 * *(vptr++);
      }
      j += 2;
    }
    if (j == ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(HLLptr++) = x_1 * *(vptr++);
        *(HLHptr++) = x0 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(HLLptr++) = x_1 * *(vptr++);
      }
      j++;
    }
    s += 2;
  }
  if (s == zlength - 1) {
    j = 0;
    while (j < ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
        *(LLHptr++) = x_1 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
      }
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LHLptr++) = x_1 * *(vptr++);
        *(LHHptr++) = x0 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LHLptr++) = x_1 * *(vptr++);
      }
      j += 2;
    }
    if (j == ylength - 1) {
      vptrend_1 = vptr + xlength - 1;
      while (vptr < vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
        *(LLHptr++) = x_1 * *(vptr++);
      }
      if (vptr == vptrend_1) {
        *(LLLptr++) = x_2 * *(vptr++);
      }
      j++;
    }
    s++;
  }
}


x86 assembly (clang, -O0):
<bioD1__3d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movsd  %xmm1,-0xb0(%rbp)
ff
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
cvtsd2ss %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm1,-0x34(%rbp)
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpl   $0x1,0x28(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%eax
cmpl   $0x1,0x30(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
cmpl   $0x1,0x38(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0x3,-0xa4(%rbp)
jne    122b <bioD1__3d+0x12b>
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x38(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
cmpl   $0x2,-0xa4(%rbp)
jne    1274 <bioD1__3d+0x174>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
cmpl   $0x1,-0xa4(%rbp)
jne    12b6 <bioD1__3d+0x1b6>
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
cmpl   $0x0,-0xa4(%rbp)
jne    1310 <bioD1__3d+0x210>
movss  0xd35(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xd28(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1854 <bioD1__3d+0x754>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14e4 <bioD1__3d+0x3e4>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    13c6 <bioD1__3d+0x2c6>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  %xmm0,(%rax)
jmp    1357 <bioD1__3d+0x257>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    1402 <bioD1__3d+0x302>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1494 <bioD1__3d+0x394>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
movss  %xmm0,(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x90(%rbp)
movss  %xmm0,(%rax)
jmp    1419 <bioD1__3d+0x319>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    14d6 <bioD1__3d+0x3d6>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
jmp    132f <bioD1__3d+0x22f>
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15c0 <bioD1__3d+0x4c0>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    157b <bioD1__3d+0x47b>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  %xmm0,(%rax)
jmp    150c <bioD1__3d+0x40c>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    15b7 <bioD1__3d+0x4b7>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    176a <bioD1__3d+0x66a>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    165e <bioD1__3d+0x55e>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  %xmm0,(%rax)
jmp    15ef <bioD1__3d+0x4ef>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    169a <bioD1__3d+0x59a>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1720 <bioD1__3d+0x620>
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  %xmm0,(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  %xmm0,(%rax)
jmp    16b1 <bioD1__3d+0x5b1>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    175c <bioD1__3d+0x65c>
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
jmp    15c7 <bioD1__3d+0x4c7>
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1846 <bioD1__3d+0x746>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1801 <bioD1__3d+0x701>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  %xmm0,(%rax)
jmp    1792 <bioD1__3d+0x692>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    183d <bioD1__3d+0x73d>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x40(%rbp)
jmp    1317 <bioD1__3d+0x217>
mov    -0x40(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1b06 <bioD1__3d+0xa06>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a21 <bioD1__3d+0x921>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1903 <bioD1__3d+0x803>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  %xmm0,(%rax)
jmp    1894 <bioD1__3d+0x794>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    193f <bioD1__3d+0x83f>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    19d1 <bioD1__3d+0x8d1>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
movss  %xmm0,(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x90(%rbp)
movss  %xmm0,(%rax)
jmp    1956 <bioD1__3d+0x856>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    1a13 <bioD1__3d+0x913>
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
jmp    186c <bioD1__3d+0x76c>
mov    -0x3c(%rbp),%eax
mov    0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1afd <bioD1__3d+0x9fd>
mov    -0x48(%rbp),%rax
movslq 0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1ab8 <bioD1__3d+0x9b8>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  %xmm0,(%rax)
jmp    1a49 <bioD1__3d+0x949>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    1af4 <bioD1__3d+0x9f4>
movss  -0xa0(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
mulss  (%rax),%xmm0
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x78(%rbp)
movss  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bioD1__3d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x60(%rsp),%r10d
mov    0x58(%rsp),%ebp
mov    0x50(%rsp),%r11d
cvtsd2ss %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
xor    %eax,%eax
cmp    $0x2,%r11d
setge  %al
xor    %ebx,%ebx
cmp    $0x2,%ebp
setge  %bl
add    %eax,%ebx
xor    %eax,%eax
cmp    $0x2,%r10d
setge  %al
add    %ebx,%eax
cmp    $0x1,%eax
je     1170 <bioD1__3d+0x70>
cmp    $0x2,%eax
je     1182 <bioD1__3d+0x82>
cmp    $0x3,%eax
jne    119c <bioD1__3d+0x9c>
movaps %xmm2,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm0,%xmm3
divss  %xmm2,%xmm3
movaps %xmm3,%xmm4
divss  %xmm2,%xmm4
unpcklps %xmm3,%xmm4
unpcklps %xmm1,%xmm0
movlhps %xmm4,%xmm0
jmp    11a3 <bioD1__3d+0xa3>
mulss  %xmm0,%xmm2
unpcklps %xmm2,%xmm0
xorps  %xmm1,%xmm1
movlhps %xmm0,%xmm1
movaps %xmm1,%xmm0
jmp    11a3 <bioD1__3d+0xa3>
movaps %xmm0,%xmm1
divss  %xmm2,%xmm1
mulss  %xmm0,%xmm2
unpcklps %xmm0,%xmm1
xorps  %xmm0,%xmm0
movss  %xmm2,%xmm0
movlhps %xmm1,%xmm0
jmp    11a3 <bioD1__3d+0xa3>
movaps 0x1e5d(%rip),%xmm0
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%r12
mov    0x60(%rsp),%eax
mov    %rax,%rbx
add    $0xffffffff,%eax
mov    %eax,-0x4(%rsp)
xor    %eax,%eax
movslq %r11d,%r13
cmp    $0x2,%ebx
mov    %r13,-0x30(%rsp)
jl     1feb <bioD1__3d+0xeeb>
mov    0x58(%rsp),%eax
lea    -0x1(%rax),%ebp
mov    %ebp,-0x18(%rsp)
and    $0xfffffffe,%eax
mov    %eax,-0x8(%rsp)
lea    -0x4(,%r13,4),%rax
ff
mov    %rax,-0x20(%rsp)
movaps %xmm0,%xmm8
shufps $0xaa,%xmm0,%xmm8
movaps %xmm0,%xmm2
shufps $0xff,%xmm0,%xmm2
movaps %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
movaps %xmm0,%xmm4
shufps $0x0,%xmm0,%xmm4
movaps %xmm0,%xmm5
shufps $0x55,%xmm0,%xmm5
xor    %eax,%eax
jmp    1232 <bioD1__3d+0x132>
nopl   0x0(%rax,%rax,1)
mov    -0x10(%rsp),%rax
add    $0x2,%eax
cmp    -0x4(%rsp),%eax
jge    1fe4 <bioD1__3d+0xee4>
mov    %rax,-0x10(%rsp)
mov    0x58(%rsp),%eax
cmp    $0x2,%eax
jl     16f0 <bioD1__3d+0x5f0>
xor    %eax,%eax
jmp    1266 <bioD1__3d+0x166>
nopl   0x0(%rax,%rax,1)
cmp    %rbp,%rdi
je     1380 <bioD1__3d+0x280>
add    $0x2,%eax
cmp    -0x18(%rsp),%eax
jge    1700 <bioD1__3d+0x600>
lea    (%rdi,%r13,4),%rbp
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rdi
mov    %eax,-0x34(%rsp)
jae    12dc <bioD1__3d+0x1dc>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%r15
lea    0x8(%rdi),%rax
cmp    %rax,%r15
mov    %rax,%r11
cmova  %r15,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    13a0 <bioD1__3d+0x2a0>
mov    -0x34(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%r10)
add    $0x4,%r10
movss  0x4(%rdi),%xmm1
mulss  %xmm2,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%r14)
add    $0x4,%r14
cmp    %rbp,%rdi
jb     12b0 <bioD1__3d+0x1b0>
cmp    %rbp,%rdi
jne    12fa <bioD1__3d+0x1fa>
movss  0x0(%rbp),%xmm1
mulss  %xmm3,%xmm1
add    $0x4,%rbp
movss  %xmm1,(%r10)
add    $0x4,%r10
mov    %rbp,%rdi
lea    (%rdi,%r13,4),%rbp
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rdi
jae    1250 <bioD1__3d+0x150>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%r15
lea    0x8(%rdi),%rax
cmp    %rax,%r15
mov    %rax,%r11
cmova  %r15,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    1520 <bioD1__3d+0x420>
mov    -0x34(%rsp),%eax
nopl   0x0(%rax)
movss  (%rdi),%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,(%r12)
add    $0x4,%r12
movss  0x4(%rdi),%xmm1
mulss  %xmm0,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%r9)
add    $0x4,%r9
cmp    %rbp,%rdi
jb     1340 <bioD1__3d+0x240>
jmp    1250 <bioD1__3d+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp),%xmm1
mulss  %xmm2,%xmm1
add    $0x4,%rbp
movss  %xmm1,(%r12)
add    $0x4,%r12
mov    %rbp,%rdi
jmp    1259 <bioD1__3d+0x159>
nop
cmp    %rax,%r15
cmova  %r15,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r10,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rax,4),%r13
add    $0x4,%r13
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %r13,%r10
setb   -0x28(%rsp)
cmp    %rbx,%r14
setb   -0x36(%rsp)
cmp    %rax,%r10
setb   %r15b
cmp    %rbx,%rdi
setb   -0x35(%rsp)
cmp    %rax,%r14
setb   %al
cmp    %r13,%rdi
setb   %r13b
mov    -0x36(%rsp),%bl
test   %bl,-0x28(%rsp)
jne    16be <bioD1__3d+0x5be>
mov    %r13d,%ebx
and    -0x35(%rsp),%r15b
mov    -0x30(%rsp),%r13
jne    16cc <bioD1__3d+0x5cc>
and    %bl,%al
jne    1691 <bioD1__3d+0x591>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,%r13
shr    $0x2,%r13
add    $0x1,%r13
test   %rax,%rax
je     16a3 <bioD1__3d+0x5a3>
mov    %r13,%rax
mov    %rbx,%r15
movabs $0x7ffffffffffffffe,%rbx
ff ff 7f
and    %rbx,%rax
mov    %r15,%rbx
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%r15,8),%xmm6
movups 0x10(%rdi,%r15,8),%xmm7
movaps %xmm6,%xmm1
shufps $0x88,%xmm7,%xmm1
shufps $0xdd,%xmm7,%xmm6
mulps  %xmm8,%xmm1
movups %xmm1,(%r10,%r15,4)
mulps  %xmm2,%xmm6
movups %xmm6,(%r14,%r15,4)
movups 0x20(%rdi,%r15,8),%xmm1
movups 0x30(%rdi,%r15,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm8,%xmm7
movups %xmm7,0x10(%r10,%r15,4)
mulps  %xmm2,%xmm1
movups %xmm1,0x10(%r14,%r15,4)
add    $0x8,%r15
add    $0xfffffffffffffffe,%rax
jne    1470 <bioD1__3d+0x370>
test   $0x1,%r13b
je     14f8 <bioD1__3d+0x3f8>
movups (%rdi,%r15,8),%xmm1
movups 0x10(%rdi,%r15,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm8,%xmm7
movups %xmm7,(%r10,%r15,4)
mulps  %xmm2,%xmm1
movups %xmm1,(%r14,%r15,4)
lea    (%r14,%rbx,4),%r14
lea    (%r10,%rbx,4),%r10
lea    (%rdi,%rbx,8),%rdi
cmp    %rbx,%r11
mov    -0x30(%rsp),%r13
mov    -0x34(%rsp),%eax
jne    12b0 <bioD1__3d+0x1b0>
jmp    12dc <bioD1__3d+0x1dc>
nopl   0x0(%rax,%rax,1)
cmp    %rax,%r15
cmova  %r15,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r12,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r9,%rax,4),%r13
add    $0x4,%r13
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %r13,%r12
setb   -0x28(%rsp)
cmp    %rbx,%r9
setb   -0x36(%rsp)
cmp    %rax,%r12
setb   %r15b
cmp    %rbx,%rdi
setb   -0x35(%rsp)
cmp    %rax,%r9
setb   %al
cmp    %r13,%rdi
setb   %r13b
mov    -0x36(%rsp),%bl
test   %bl,-0x28(%rsp)
jne    16d5 <bioD1__3d+0x5d5>
mov    %r13d,%ebx
and    -0x35(%rsp),%r15b
mov    -0x30(%rsp),%r13
jne    16e3 <bioD1__3d+0x5e3>
and    %bl,%al
jne    169a <bioD1__3d+0x59a>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
mov    %rbx,-0x28(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     16b5 <bioD1__3d+0x5b5>
mov    %rbx,%r15
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r12,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%r9,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm1
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,0x10(%r12,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,0x10(%r9,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    15f0 <bioD1__3d+0x4f0>
test   $0x1,%bl
je     166e <bioD1__3d+0x56e>
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r12,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%r9,%rax,4)
mov    -0x28(%rsp),%rax
lea    (%r9,%rax,4),%r9
lea    (%r12,%rax,4),%r12
lea    (%rdi,%rax,8),%rdi
cmp    %rax,%r11
mov    -0x34(%rsp),%eax
jne    1340 <bioD1__3d+0x240>
jmp    1250 <bioD1__3d+0x150>
mov    -0x34(%rsp),%eax
jmp    12b0 <bioD1__3d+0x1b0>
mov    -0x34(%rsp),%eax
jmp    1340 <bioD1__3d+0x240>
xor    %r15d,%r15d
test   $0x1,%r13b
jne    14d1 <bioD1__3d+0x3d1>
jmp    14f8 <bioD1__3d+0x3f8>
xor    %eax,%eax
test   $0x1,%bl
jne    164a <bioD1__3d+0x54a>
jmp    166e <bioD1__3d+0x56e>
mov    -0x30(%rsp),%r13
mov    -0x34(%rsp),%eax
jmp    12b0 <bioD1__3d+0x1b0>
mov    -0x34(%rsp),%eax
jmp    12b0 <bioD1__3d+0x1b0>
mov    -0x30(%rsp),%r13
mov    -0x34(%rsp),%eax
jmp    1340 <bioD1__3d+0x240>
mov    -0x34(%rsp),%eax
jmp    1340 <bioD1__3d+0x240>
nopl   0x0(%rax)
xor    %eax,%eax
cmp    -0x18(%rsp),%eax
je     170e <bioD1__3d+0x60e>
jmp    17a0 <bioD1__3d+0x6a0>
nopl   (%rax)
mov    -0x8(%rsp),%eax
cmp    -0x18(%rsp),%eax
jne    17a0 <bioD1__3d+0x6a0>
lea    (%rdi,%r13,4),%r13
add    $0xfffffffffffffffc,%r13
cmp    %r13,%rdi
jae    177c <bioD1__3d+0x67c>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
lea    0x8(%rdi),%rax
cmp    %rax,%rbp
mov    %rax,%r11
cmova  %rbp,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    1cf6 <bioD1__3d+0xbf6>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi),%xmm1
mulss  %xmm3,%xmm1
movss  %xmm1,(%r10)
add    $0x4,%r10
movss  0x4(%rdi),%xmm1
mulss  %xmm2,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%r14)
add    $0x4,%r14
cmp    %r13,%rdi
jb     1750 <bioD1__3d+0x650>
cmp    %r13,%rdi
jne    179b <bioD1__3d+0x69b>
movss  0x0(%r13),%xmm1
mulss  %xmm3,%xmm1
add    $0x4,%r13
movss  %xmm1,(%r10)
add    $0x4,%r10
mov    %r13,%rdi
mov    -0x30(%rsp),%r13
xor    %eax,%eax
mov    0x58(%rsp),%ebp
cmp    $0x2,%ebp
jl     1c44 <bioD1__3d+0xb44>
xor    %eax,%eax
jmp    17d6 <bioD1__3d+0x6d6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %rbp,%rdi
je     18e0 <bioD1__3d+0x7e0>
add    $0x2,%eax
cmp    -0x18(%rsp),%eax
jge    1c40 <bioD1__3d+0xb40>
lea    (%rdi,%r13,4),%rbp
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rdi
mov    %eax,-0x34(%rsp)
jae    184b <bioD1__3d+0x74b>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%r15
lea    0x8(%rdi),%rax
cmp    %rax,%r15
mov    %rax,%r11
cmova  %r15,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    1900 <bioD1__3d+0x800>
mov    -0x34(%rsp),%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi),%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,(%r8)
add    $0x4,%r8
movss  0x4(%rdi),%xmm1
mulss  %xmm0,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%rcx)
add    $0x4,%rcx
cmp    %rbp,%rdi
jb     1820 <bioD1__3d+0x720>
cmp    %rbp,%rdi
jne    1869 <bioD1__3d+0x769>
movss  0x0(%rbp),%xmm1
mulss  %xmm2,%xmm1
add    $0x4,%rbp
movss  %xmm1,(%r8)
add    $0x4,%r8
mov    %rbp,%rdi
lea    (%rdi,%r13,4),%rbp
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%rdi
jae    17c0 <bioD1__3d+0x6c0>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%r15
lea    0x8(%rdi),%rax
cmp    %rax,%r15
mov    %rax,%r11
cmova  %r15,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    1a70 <bioD1__3d+0x970>
mov    -0x34(%rsp),%eax
nopl   0x0(%rax,%rax,1)
movss  (%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rdx)
add    $0x4,%rdx
movss  0x4(%rdi),%xmm1
mulss  %xmm5,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%rsi)
add    $0x4,%rsi
cmp    %rbp,%rdi
jb     18b0 <bioD1__3d+0x7b0>
jmp    17c0 <bioD1__3d+0x6c0>
nop
movss  0x0(%rbp),%xmm1
mulss  %xmm0,%xmm1
add    $0x4,%rbp
movss  %xmm1,(%rdx)
add    $0x4,%rdx
mov    %rbp,%rdi
jmp    17c9 <bioD1__3d+0x6c9>
nopl   (%rax)
cmp    %rax,%r15
cmova  %r15,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r8,%rax,4),%rbx
add    $0x4,%rbx
lea    (%rcx,%rax,4),%r13
add    $0x4,%r13
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %r13,%r8
setb   -0x28(%rsp)
cmp    %rbx,%rcx
setb   -0x36(%rsp)
cmp    %rax,%r8
setb   %r15b
cmp    %rbx,%rdi
setb   -0x35(%rsp)
cmp    %rax,%rcx
setb   %al
cmp    %r13,%rdi
setb   %r13b
mov    -0x36(%rsp),%bl
test   %bl,-0x28(%rsp)
jne    1c06 <bioD1__3d+0xb06>
mov    %r13d,%ebx
and    -0x35(%rsp),%r15b
mov    -0x30(%rsp),%r13
jne    1c14 <bioD1__3d+0xb14>
and    %bl,%al
jne    1bdb <bioD1__3d+0xadb>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
mov    %rbx,-0x28(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     1bed <bioD1__3d+0xaed>
mov    %rbx,%r15
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%rcx,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm1
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,0x10(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,0x10(%rcx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    19d0 <bioD1__3d+0x8d0>
test   $0x1,%bl
je     1a4b <bioD1__3d+0x94b>
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%rcx,%rax,4)
mov    -0x28(%rsp),%rax
lea    (%rcx,%rax,4),%rcx
lea    (%r8,%rax,4),%r8
lea    (%rdi,%rax,8),%rdi
cmp    %rax,%r11
mov    -0x34(%rsp),%eax
jne    1820 <bioD1__3d+0x720>
jmp    184b <bioD1__3d+0x74b>
xchg   %ax,%ax
cmp    %rax,%r15
cmova  %r15,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%rdx,%rax,4),%rbx
add    $0x4,%rbx
lea    (%rsi,%rax,4),%r13
add    $0x4,%r13
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %r13,%rdx
setb   -0x28(%rsp)
cmp    %rbx,%rsi
setb   -0x36(%rsp)
cmp    %rax,%rdx
setb   %r15b
cmp    %rbx,%rdi
setb   -0x35(%rsp)
cmp    %rax,%rsi
setb   %al
cmp    %r13,%rdi
setb   %r13b
mov    -0x36(%rsp),%bl
test   %bl,-0x28(%rsp)
jne    1c1d <bioD1__3d+0xb1d>
mov    %r13d,%ebx
and    -0x35(%rsp),%r15b
mov    -0x30(%rsp),%r13
jne    1c2b <bioD1__3d+0xb2b>
and    %bl,%al
jne    1be4 <bioD1__3d+0xae4>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
mov    %rbx,-0x28(%rsp)
lea    -0x4(%rbx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     1bfd <bioD1__3d+0xafd>
mov    %rbx,%r15
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm4,%xmm7
movups %xmm7,(%rdx,%rax,4)
mulps  %xmm5,%xmm1
movups %xmm1,(%rsi,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm1
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm4,%xmm7
movups %xmm7,0x10(%rdx,%rax,4)
mulps  %xmm5,%xmm1
movups %xmm1,0x10(%rsi,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    1b40 <bioD1__3d+0xa40>
test   $0x1,%bl
je     1bb8 <bioD1__3d+0xab8>
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm4,%xmm7
movups %xmm7,(%rdx,%rax,4)
mulps  %xmm5,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    -0x28(%rsp),%rax
lea    (%rsi,%rax,4),%rsi
lea    (%rdx,%rax,4),%rdx
lea    (%rdi,%rax,8),%rdi
cmp    %rax,%r11
mov    -0x34(%rsp),%eax
jne    18b0 <bioD1__3d+0x7b0>
jmp    17c0 <bioD1__3d+0x6c0>
mov    -0x34(%rsp),%eax
jmp    1820 <bioD1__3d+0x720>
mov    -0x34(%rsp),%eax
jmp    18b0 <bioD1__3d+0x7b0>
xor    %eax,%eax
test   $0x1,%bl
jne    1a28 <bioD1__3d+0x928>
jmp    1a4b <bioD1__3d+0x94b>
xor    %eax,%eax
test   $0x1,%bl
jne    1b96 <bioD1__3d+0xa96>
jmp    1bb8 <bioD1__3d+0xab8>
mov    -0x30(%rsp),%r13
mov    -0x34(%rsp),%eax
jmp    1820 <bioD1__3d+0x720>
mov    -0x34(%rsp),%eax
jmp    1820 <bioD1__3d+0x720>
mov    -0x30(%rsp),%r13
mov    -0x34(%rsp),%eax
jmp    18b0 <bioD1__3d+0x7b0>
mov    -0x34(%rsp),%eax
jmp    18b0 <bioD1__3d+0x7b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x8(%rsp),%eax
cmp    -0x18(%rsp),%eax
jne    1220 <bioD1__3d+0x120>
lea    (%rdi,%r13,4),%r13
add    $0xfffffffffffffffc,%r13
cmp    %r13,%rdi
jae    1cd0 <bioD1__3d+0xbd0>
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
lea    0x8(%rdi),%rax
cmp    %rax,%rbp
mov    %rax,%r11
cmova  %rbp,%r11
mov    %rdi,%rbx
not    %rbx
add    %rbx,%r11
cmp    $0x18,%r11
jae    1e4c <bioD1__3d+0xd4c>
mov    -0x10(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movss  (%rdi),%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,(%r8)
add    $0x4,%r8
movss  0x4(%rdi),%xmm1
mulss  %xmm0,%xmm1
add    $0x8,%rdi
movss  %xmm1,(%rcx)
add    $0x4,%rcx
cmp    %r13,%rdi
jb     1c90 <bioD1__3d+0xb90>
cmp    %r13,%rdi
je     1cda <bioD1__3d+0xbda>
mov    -0x30(%rsp),%r13
jmp    1225 <bioD1__3d+0x125>
nopw   0x0(%rax,%rax,1)
mov    -0x10(%rsp),%rax
cmp    %r13,%rdi
jne    1cc0 <bioD1__3d+0xbc0>
movss  0x0(%r13),%xmm1
mulss  %xmm2,%xmm1
add    $0x4,%r13
movss  %xmm1,(%r8)
add    $0x4,%r8
mov    %r13,%rdi
jmp    1cc0 <bioD1__3d+0xbc0>
cmp    %rax,%rbp
cmova  %rbp,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r10,%rax,4),%rbx
add    $0x4,%rbx
lea    (%r14,%rax,4),%rbp
add    $0x4,%rbp
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %rbp,%r10
setb   -0x34(%rsp)
cmp    %rbx,%r14
setb   -0x28(%rsp)
cmp    %rax,%r10
setb   %r15b
cmp    %rbx,%rdi
setb   %bl
cmp    %rax,%r14
setb   %al
cmp    %rbp,%rdi
setb   -0x36(%rsp)
mov    -0x28(%rsp),%bpl
test   %bpl,-0x34(%rsp)
jne    1750 <bioD1__3d+0x650>
and    %bl,%r15b
jne    1750 <bioD1__3d+0x650>
and    -0x36(%rsp),%al
jne    1750 <bioD1__3d+0x650>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,%r15
shr    $0x2,%r15
add    $0x1,%r15
test   %rax,%rax
je     1fb5 <bioD1__3d+0xeb5>
mov    %r15,%rbp
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm8,%xmm7
movups %xmm7,(%r10,%rax,4)
mulps  %xmm2,%xmm1
movups %xmm1,(%r14,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm1
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm8,%xmm7
movups %xmm7,0x10(%r10,%rax,4)
mulps  %xmm2,%xmm1
movups %xmm1,0x10(%r14,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1db0 <bioD1__3d+0xcb0>
test   $0x1,%r15b
je     1e32 <bioD1__3d+0xd32>
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm8,%xmm7
movups %xmm7,(%r10,%rax,4)
mulps  %xmm2,%xmm1
movups %xmm1,(%r14,%rax,4)
lea    (%r14,%rbx,4),%r14
lea    (%r10,%rbx,4),%r10
lea    (%rdi,%rbx,8),%rdi
cmp    %rbx,%r11
jne    1750 <bioD1__3d+0x650>
jmp    177c <bioD1__3d+0x67c>
cmp    %rax,%rbp
cmova  %rbp,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r8,%rax,4),%rbx
add    $0x4,%rbx
lea    (%rcx,%rax,4),%rbp
add    $0x4,%rbp
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
cmp    %rbp,%r8
setb   -0x34(%rsp)
cmp    %rbx,%rcx
setb   -0x28(%rsp)
cmp    %rax,%r8
setb   %r15b
cmp    %rbx,%rdi
setb   %bl
cmp    %rax,%rcx
setb   %al
cmp    %rbp,%rdi
setb   -0x36(%rsp)
mov    -0x28(%rsp),%bpl
test   %bpl,-0x34(%rsp)
jne    1fd0 <bioD1__3d+0xed0>
and    %bl,%r15b
jne    1fda <bioD1__3d+0xeda>
and    -0x36(%rsp),%al
jne    1fab <bioD1__3d+0xeab>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,%r15
shr    $0x2,%r15
add    $0x1,%r15
test   %rax,%rax
je     1fc6 <bioD1__3d+0xec6>
mov    %r15,%rbp
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%rcx,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm1
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,0x10(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,0x10(%rcx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1f10 <bioD1__3d+0xe10>
test   $0x1,%r15b
je     1f8c <bioD1__3d+0xe8c>
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm1,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm1
mulps  %xmm2,%xmm7
movups %xmm7,(%r8,%rax,4)
mulps  %xmm4,%xmm1
movups %xmm1,(%rcx,%rax,4)
lea    (%rcx,%rbx,4),%rcx
lea    (%r8,%rbx,4),%r8
lea    (%rdi,%rbx,8),%rdi
cmp    %rbx,%r11
mov    -0x10(%rsp),%rax
jne    1c90 <bioD1__3d+0xb90>
jmp    1cbb <bioD1__3d+0xbbb>
mov    -0x10(%rsp),%rax
jmp    1c90 <bioD1__3d+0xb90>
xor    %eax,%eax
test   $0x1,%r15b
jne    1e0d <bioD1__3d+0xd0d>
jmp    1e32 <bioD1__3d+0xd32>
xor    %eax,%eax
test   $0x1,%r15b
jne    1f69 <bioD1__3d+0xe69>
jmp    1f8c <bioD1__3d+0xe8c>
mov    -0x10(%rsp),%rax
jmp    1c90 <bioD1__3d+0xb90>
mov    -0x10(%rsp),%rax
jmp    1c90 <bioD1__3d+0xb90>
mov    0x60(%rsp),%eax
and    $0xfffffffe,%eax
cmp    -0x4(%rsp),%eax
jne    24ed <bioD1__3d+0x13ed>
mov    0x58(%rsp),%eax
mov    %rax,%rcx
lea    -0x1(%rax),%edx
xor    %eax,%eax
cmp    $0x2,%ecx
jl     2469 <bioD1__3d+0x1369>
lea    -0x4(,%r13,4),%r11
ff
movaps %xmm0,%xmm1
shufps $0xaa,%xmm0,%xmm1
movaps %xmm0,%xmm2
shufps $0xff,%xmm0,%xmm2
movaps %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
movaps %xmm0,%xmm4
shufps $0x0,%xmm0,%xmm4
xor    %r15d,%r15d
mov    %edx,-0x20(%rsp)
mov    %r11,-0x18(%rsp)
jmp    2056 <bioD1__3d+0xf56>
nopl   0x0(%rax)
cmp    %rsi,%rdi
je     21e0 <bioD1__3d+0x10e0>
add    $0x2,%r15d
cmp    %edx,%r15d
jge    2462 <bioD1__3d+0x1362>
lea    (%rdi,%r13,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdi
jae    225c <bioD1__3d+0x115c>
lea    (%r11,%rdi,1),%rcx
lea    0x8(%rdi),%rax
cmp    %rax,%rcx
mov    %rax,%rbp
cmova  %rcx,%rbp
mov    %rdi,%rbx
not    %rbx
add    %rbx,%rbp
cmp    $0x18,%rbp
jb     2230 <bioD1__3d+0x1130>
cmp    %rax,%rcx
cmova  %rcx,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r10,%rax,4),%rcx
add    $0x4,%rcx
lea    (%r14,%rax,4),%rbx
add    $0x4,%rbx
lea    (%rdi,%rax,8),%rdx
add    $0x8,%rdx
cmp    %rbx,%r10
setb   %r11b
cmp    %rcx,%r14
setb   %r8b
cmp    %rdx,%r10
setb   %al
cmp    %rcx,%rdi
setb   %r13b
cmp    %rdx,%r14
setb   %cl
cmp    %rbx,%rdi
setb   %dl
test   %r8b,%r11b
jne    2213 <bioD1__3d+0x1113>
and    %r13b,%al
mov    -0x18(%rsp),%r11
jne    21fe <bioD1__3d+0x10fe>
and    %dl,%cl
jne    21fe <bioD1__3d+0x10fe>
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %rbp,%r13
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r13
lea    -0x4(%r13),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
mov    -0x20(%rsp),%edx
je     2209 <bioD1__3d+0x1109>
mov    %r8,%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movups (%rdi,%rax,8),%xmm5
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm1,%xmm7
movups %xmm7,(%r10,%rax,4)
mulps  %xmm2,%xmm5
movups %xmm5,(%r14,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm5
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm1,%xmm7
movups %xmm7,0x10(%r10,%rax,4)
mulps  %xmm2,%xmm5
movups %xmm5,0x10(%r14,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2140 <bioD1__3d+0x1040>
test   $0x1,%r8b
je     21bf <bioD1__3d+0x10bf>
movups (%rdi,%rax,8),%xmm5
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm1,%xmm7
movups %xmm7,(%r10,%rax,4)
mulps  %xmm2,%xmm5
movups %xmm5,(%r14,%rax,4)
lea    (%r14,%r13,4),%r14
lea    (%r10,%r13,4),%r10
lea    (%rdi,%r13,8),%rdi
cmp    %r13,%rbp
mov    -0x30(%rsp),%r13
jne    2230 <bioD1__3d+0x1130>
jmp    225c <bioD1__3d+0x115c>
nopw   0x0(%rax,%rax,1)
movss  (%rsi),%xmm5
mulss  %xmm2,%xmm5
add    $0x4,%rsi
movss  %xmm5,(%r12)
add    $0x4,%r12
mov    %rsi,%rdi
jmp    2049 <bioD1__3d+0xf49>
mov    -0x30(%rsp),%r13
mov    -0x20(%rsp),%edx
jmp    2230 <bioD1__3d+0x1130>
xor    %eax,%eax
test   $0x1,%r8b
jne    219b <bioD1__3d+0x109b>
jmp    21bf <bioD1__3d+0x10bf>
mov    -0x30(%rsp),%r13
mov    -0x20(%rsp),%edx
mov    -0x18(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi),%xmm5
mulss  %xmm3,%xmm5
movss  %xmm5,(%r10)
add    $0x4,%r10
movss  0x4(%rdi),%xmm5
mulss  %xmm2,%xmm5
add    $0x8,%rdi
movss  %xmm5,(%r14)
add    $0x4,%r14
cmp    %rsi,%rdi
jb     2230 <bioD1__3d+0x1130>
cmp    %rsi,%rdi
jne    2279 <bioD1__3d+0x1179>
movss  (%rsi),%xmm5
mulss  %xmm3,%xmm5
add    $0x4,%rsi
movss  %xmm5,(%r10)
add    $0x4,%r10
mov    %rsi,%rdi
lea    (%rdi,%r13,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdi
jae    2040 <bioD1__3d+0xf40>
lea    (%r11,%rdi,1),%rcx
lea    0x8(%rdi),%rax
cmp    %rax,%rcx
mov    %rax,%rbp
cmova  %rcx,%rbp
mov    %rdi,%rbx
not    %rbx
add    %rbx,%rbp
cmp    $0x18,%rbp
jb     2430 <bioD1__3d+0x1330>
cmp    %rax,%rcx
cmova  %rcx,%rax
add    %rbx,%rax
shr    $0x3,%rax
lea    (%r12,%rax,4),%rcx
add    $0x4,%rcx
lea    (%r9,%rax,4),%rdx
add    $0x4,%rdx
lea    (%rdi,%rax,8),%rbx
add    $0x8,%rbx
cmp    %rdx,%r12
setb   %r13b
cmp    %rcx,%r9
setb   %r8b
cmp    %rbx,%r12
setb   %al
cmp    %rcx,%rdi
setb   %r11b
cmp    %rbx,%r9
setb   %cl
cmp    %rdx,%rdi
setb   %dl
test   %r8b,%r13b
jne    2414 <bioD1__3d+0x1314>
and    %r11b,%al
mov    -0x30(%rsp),%r13
jne    2419 <bioD1__3d+0x1319>
and    %dl,%cl
jne    2419 <bioD1__3d+0x1319>
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %rbp,%r13
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r13
lea    -0x4(%r13),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
mov    -0x20(%rsp),%edx
mov    -0x18(%rsp),%r11
je     240a <bioD1__3d+0x130a>
mov    %r8,%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups (%rdi,%rax,8),%xmm5
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm2,%xmm7
movups %xmm7,(%r12,%rax,4)
mulps  %xmm4,%xmm5
movups %xmm5,(%r9,%rax,4)
movups 0x20(%rdi,%rax,8),%xmm5
movups 0x30(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm2,%xmm7
movups %xmm7,0x10(%r12,%rax,4)
mulps  %xmm4,%xmm5
movups %xmm5,0x10(%r9,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2370 <bioD1__3d+0x1270>
test   $0x1,%r8b
je     23ef <bioD1__3d+0x12ef>
movups (%rdi,%rax,8),%xmm5
movups 0x10(%rdi,%rax,8),%xmm6
movaps %xmm5,%xmm7
shufps $0x88,%xmm6,%xmm7
shufps $0xdd,%xmm6,%xmm5
mulps  %xmm2,%xmm7
movups %xmm7,(%r12,%rax,4)
mulps  %xmm4,%xmm5
movups %xmm5,(%r9,%rax,4)
lea    (%r9,%r13,4),%r9
lea    (%r12,%r13,4),%r12
lea    (%rdi,%r13,8),%rdi
cmp    %r13,%rbp
mov    -0x30(%rsp),%r13
jne    2430 <bioD1__3d+0x1330>
jmp    2040 <bioD1__3d+0xf40>
xor    %eax,%eax
test   $0x1,%r8b
jne    23cb <bioD1__3d+0x12cb>
jmp    23ef <bioD1__3d+0x12ef>
mov    -0x30(%rsp),%r13
mov    -0x20(%rsp),%edx
mov    -0x18(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi),%xmm5
mulss  %xmm2,%xmm5
movss  %xmm5,(%r12)
add    $0x4,%r12
movss  0x4(%rdi),%xmm5
mulss  %xmm0,%xmm5
add    $0x8,%rdi
movss  %xmm5,(%r9)
add    $0x4,%r9
cmp    %rsi,%rdi
jb     2430 <bioD1__3d+0x1330>
jmp    2040 <bioD1__3d+0xf40>
mov    0x58(%rsp),%eax
and    $0xfffffffe,%eax
cmp    %edx,%eax
jne    24ed <bioD1__3d+0x13ed>
lea    (%rdi,%r13,4),%rcx
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%rdi
jae    24dc <bioD1__3d+0x13dc>
lea    0x8(%rdi),%rax
cmp    %rax,%rcx
mov    %rax,%rdx
cmova  %rcx,%rdx
mov    %rdi,%rsi
not    %rsi
add    %rsi,%rdx
movaps %xmm0,%xmm1
shufps $0xff,%xmm0,%xmm1
cmp    $0x18,%rdx
jae    24f8 <bioD1__3d+0x13f8>
movaps %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
nopl   0x0(%rax)
movss  (%rdi),%xmm3
mulss  %xmm2,%xmm3
movss  %xmm3,(%r10)
add    $0x4,%r10
movss  0x4(%rdi),%xmm3
mulss  %xmm1,%xmm3
add    $0x8,%rdi
movss  %xmm3,(%r14)
add    $0x4,%r14
cmp    %rcx,%rdi
jb     24b0 <bioD1__3d+0x13b0>
cmp    %rcx,%rdi
jne    24ed <bioD1__3d+0x13ed>
movhlps %xmm0,%xmm0
mulss  (%rcx),%xmm0
movss  %xmm0,(%r10)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %rax,%rcx
cmova  %rcx,%rax
add    %rsi,%rax
shr    $0x3,%rax
lea    (%r10,%rax,4),%rsi
add    $0x4,%rsi
lea    (%r14,%rax,4),%rbp
add    $0x4,%rbp
lea    (%rdi,%rax,8),%rbx
add    $0x8,%rbx
cmp    %rbp,%r10
setb   %r9b
cmp    %rsi,%r14
setb   %r11b
cmp    %rbx,%r10
setb   %al
cmp    %rsi,%rdi
setb   %sil
cmp    %rbx,%r14
setb   %bl
cmp    %rbp,%rdi
setb   %r8b
test   %r11b,%r9b
jne    24a2 <bioD1__3d+0x13a2>
and    %sil,%al
jne    24a2 <bioD1__3d+0x13a2>
and    %r8b,%bl
jne    24a2 <bioD1__3d+0x13a2>
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rsi
and    $0xfffffffffffffffc,%rsi
movaps %xmm0,%xmm2
shufps $0xaa,%xmm0,%xmm2
lea    -0x4(%rsi),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     25f7 <bioD1__3d+0x14f7>
mov    %rbx,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rbp,8),%xmm3
movups 0x10(%rdi,%rbp,8),%xmm4
movaps %xmm3,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm3
mulps  %xmm2,%xmm5
movups %xmm5,(%r10,%rbp,4)
mulps  %xmm1,%xmm3
movups %xmm3,(%r14,%rbp,4)
movups 0x20(%rdi,%rbp,8),%xmm3
movups 0x30(%rdi,%rbp,8),%xmm4
movaps %xmm3,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm3
mulps  %xmm2,%xmm5
movups %xmm5,0x10(%r10,%rbp,4)
mulps  %xmm1,%xmm3
movups %xmm3,0x10(%r14,%rbp,4)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    25a0 <bioD1__3d+0x14a0>
jmp    25f9 <bioD1__3d+0x14f9>
xor    %ebp,%ebp
test   $0x1,%bl
je     2622 <bioD1__3d+0x1522>
movups (%rdi,%rbp,8),%xmm3
movups 0x10(%rdi,%rbp,8),%xmm4
movaps %xmm3,%xmm5
shufps $0x88,%xmm4,%xmm5
shufps $0xdd,%xmm4,%xmm3
mulps  %xmm5,%xmm2
movups %xmm2,(%r10,%rbp,4)
mulps  %xmm1,%xmm3
movups %xmm3,(%r14,%rbp,4)
lea    (%r10,%rsi,4),%r10
lea    (%rdi,%rsi,8),%rdi
cmp    %rsi,%rdx
je     24dc <bioD1__3d+0x13dc>
lea    (%r14,%rsi,4),%r14
jmp    24a2 <bioD1__3d+0x13a2>

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

LLVM IR (-O2):
define void @bioD1__3d(float* %0, float* nocapture writeonly %1, float* nocapture writeonly %2, float* nocapture writeonly %3, float* nocapture writeonly %4, float* nocapture writeonly %5, float* nocapture writeonly %6, float* nocapture writeonly %7, float* nocapture writeonly %8, i32 %9, i32 %10, i32 %11, double %12, double %13) {
%15 = fptrunc double %12 to float
%16 = fptrunc double %13 to float
%17 = icmp sgt i32 %9, 1
%18 = zext i1 %17 to i32
%19 = icmp sgt i32 %10, 1
%20 = zext i1 %19 to i32
%21 = add nuw nsw i32 %20, %18
%22 = icmp sgt i32 %11, 1
%23 = zext i1 %22 to i32
%24 = add nuw nsw i32 %21, %23
switch i32 %24, label %43 [
i32 3, label %25
i32 2, label %33
i32 1, label %39
]
25: ; preds = %14
%26 = fmul float %15, %16
%27 = fdiv float %16, %15
%28 = fdiv float %27, %15
%29 = insertelement <4 x float> poison, float %16, i64 0
%30 = insertelement <4 x float> %29, float %26, i64 1
%31 = insertelement <4 x float> %30, float %28, i64 2
%32 = insertelement <4 x float> %31, float %27, i64 3
br label %43
33: ; preds = %14
%34 = fmul float %15, %16
%35 = fdiv float %16, %15
%36 = insertelement <4 x float> <float poison, float 0.000000e+00, float poison, float poison>, float %34, i64 0
%37 = insertelement <4 x float> %36, float %35, i64 2
%38 = insertelement <4 x float> %37, float %16, i64 3
br label %43
39: ; preds = %14
%40 = fmul float %15, %16
%41 = insertelement <4 x float> <float 0.000000e+00, float 0.000000e+00, float poison, float poison>, float %16, i64 2
%42 = insertelement <4 x float> %41, float %40, i64 3
br label %43
43: ; preds = %14, %33, %25, %39
%44 = phi <4 x float> [ %42, %39 ], [ %32, %25 ], [ %38, %33 ], [ <float 0.000000e+00, float 0.000000e+00, float 1.000000e+00, float 0.000000e+00>, %14 ]
%45 = add nsw i32 %11, -1
br i1 %22, label %46, label %941
46: ; preds = %43
%47 = add nsw i32 %10, -1
%48 = sext i32 %9 to i64
%49 = and i32 %10, -2
%50 = shl nsw i64 %48, 2
%51 = add nsw i64 %50, -4
%52 = shl nsw i64 %48, 2
%53 = add nsw i64 %52, -4
%54 = shl nsw i64 %48, 2
%55 = add nsw i64 %54, -4
%56 = shl nsw i64 %48, 2
%57 = add nsw i64 %56, -4
%58 = shl nsw i64 %48, 2
%59 = add nsw i64 %58, -4
%60 = shl nsw i64 %48, 2
%61 = add nsw i64 %60, -4
%62 = shl nsw i64 %48, 2
%63 = add nsw i64 %62, -4
%64 = shl nsw i64 %48, 2
%65 = add nsw i64 %64, -4
%66 = shl nsw i64 %48, 2
%67 = add nsw i64 %66, -4
%68 = shl nsw i64 %48, 2
%69 = add nsw i64 %68, -4
%70 = shl nsw i64 %48, 2
%71 = add nsw i64 %70, -4
%72 = shl nsw i64 %48, 2
%73 = add nsw i64 %72, -4
%74 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%75 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%76 = extractelement <4 x float> %44, i64 2
%77 = extractelement <4 x float> %44, i64 3
%78 = extractelement <4 x float> %44, i64 2
%79 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%80 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%81 = extractelement <4 x float> %44, i64 3
%82 = extractelement <4 x float> %44, i64 0
%83 = extractelement <4 x float> %44, i64 3
%84 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%85 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%86 = extractelement <4 x float> %44, i64 2
%87 = extractelement <4 x float> %44, i64 3
%88 = extractelement <4 x float> %44, i64 2
%89 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%90 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%91 = extractelement <4 x float> %44, i64 3
%92 = extractelement <4 x float> %44, i64 0
%93 = extractelement <4 x float> %44, i64 3
%94 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%95 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%96 = extractelement <4 x float> %44, i64 0
%97 = extractelement <4 x float> %44, i64 1
%98 = extractelement <4 x float> %44, i64 0
%99 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%100 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%101 = extractelement <4 x float> %44, i64 3
%102 = extractelement <4 x float> %44, i64 0
%103 = extractelement <4 x float> %44, i64 3
br label %104
104: ; preds = %46, %933
%105 = phi float* [ %5, %46 ], [ %391, %933 ]
%106 = phi float* [ %6, %46 ], [ %390, %933 ]
%107 = phi float* [ %7, %46 ], [ %525, %933 ]
%108 = phi float* [ %8, %46 ], [ %524, %933 ]
%109 = phi float* [ %1, %46 ], [ %802, %933 ]
%110 = phi float* [ %2, %46 ], [ %801, %933 ]
%111 = phi float* [ %3, %46 ], [ %936, %933 ]
%112 = phi float* [ %4, %46 ], [ %935, %933 ]
%113 = phi float* [ %0, %46 ], [ %934, %933 ]
%114 = phi i32 [ 0, %46 ], [ %937, %933 ]
br i1 %19, label %115, label %385
115: ; preds = %104, %380
%116 = phi float* [ %373, %380 ], [ %105, %104 ]
%117 = phi float* [ %382, %380 ], [ %106, %104 ]
%118 = phi float* [ %243, %380 ], [ %107, %104 ]
%119 = phi float* [ %252, %380 ], [ %108, %104 ]
%120 = phi float* [ %381, %380 ], [ %113, %104 ]
%121 = phi i32 [ %383, %380 ], [ 0, %104 ]
%122 = ptrtoint float* %120 to i64
%123 = ptrtoint float* %120 to i64
%124 = getelementptr inbounds float, float* %120, i64 %48
%125 = getelementptr inbounds float, float* %124, i64 -1
%126 = icmp ult float* %120, %125
br i1 %126, label %127, label %240
127: ; preds = %115
%128 = add i64 %73, %122
%129 = add i64 %122, 8
%130 = call i64 @llvm.umax.i64(i64 %128, i64 %129)
%131 = xor i64 %122, -1
%132 = add i64 %130, %131
%133 = lshr i64 %132, 3
%134 = add nuw nsw i64 %133, 1
%135 = icmp ult i64 %132, 24
br i1 %135, label %223, label %136
136: ; preds = %127
%137 = getelementptr float, float* %119, i64 1
%138 = add i64 %71, %123
%139 = add i64 %123, 8
%140 = call i64 @llvm.umax.i64(i64 %138, i64 %139)
%141 = xor i64 %123, -1
%142 = add i64 %140, %141
%143 = lshr i64 %142, 3
%144 = getelementptr float, float* %137, i64 %143
%145 = getelementptr float, float* %118, i64 1
%146 = getelementptr float, float* %145, i64 %143
%147 = getelementptr float, float* %120, i64 2
%148 = shl nuw nsw i64 %143, 1
%149 = getelementptr float, float* %147, i64 %148
%150 = icmp ult float* %119, %146
%151 = icmp ult float* %118, %144
%152 = and i1 %150, %151
%153 = icmp ult float* %119, %149
%154 = icmp ult float* %120, %144
%155 = and i1 %153, %154
%156 = or i1 %152, %155
%157 = icmp ult float* %118, %149
%158 = icmp ult float* %120, %146
%159 = and i1 %157, %158
%160 = or i1 %156, %159
br i1 %160, label %223, label %161
161: ; preds = %136
%162 = and i64 %134, 4611686018427387900
%163 = getelementptr float, float* %118, i64 %162
%164 = getelementptr float, float* %119, i64 %162
%165 = shl nuw nsw i64 %162, 1
%166 = getelementptr float, float* %120, i64 %165
%167 = add nsw i64 %162, -4
%168 = lshr exact i64 %167, 2
%169 = add nuw nsw i64 %168, 1
%170 = and i64 %169, 1
%171 = icmp eq i64 %167, 0
br i1 %171, label %205, label %172
172: ; preds = %161
%173 = and i64 %169, 9223372036854775806
br label %174
174: ; preds = %174, %172
%175 = phi i64 [ 0, %172 ], [ %202, %174 ]
%176 = phi i64 [ 0, %172 ], [ %203, %174 ]
%177 = getelementptr float, float* %118, i64 %175
%178 = getelementptr float, float* %119, i64 %175
%179 = shl i64 %175, 1
%180 = getelementptr float, float* %120, i64 %179
%181 = bitcast float* %180 to <8 x float>*
%182 = load <8 x float>, <8 x float>* %181
%183 = shufflevector <8 x float> %182, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%184 = shufflevector <8 x float> %182, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%185 = fmul <4 x float> %74, %183
%186 = bitcast float* %178 to <4 x float>*
store <4 x float> %185, <4 x float>* %186
%187 = fmul <4 x float> %75, %184
%188 = bitcast float* %177 to <4 x float>*
store <4 x float> %187, <4 x float>* %188
%189 = or i64 %175, 4
%190 = getelementptr float, float* %118, i64 %189
%191 = getelementptr float, float* %119, i64 %189
%192 = shl i64 %189, 1
%193 = getelementptr float, float* %120, i64 %192
%194 = bitcast float* %193 to <8 x float>*
%195 = load <8 x float>, <8 x float>* %194
%196 = shufflevector <8 x float> %195, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%197 = shufflevector <8 x float> %195, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%198 = fmul <4 x float> %74, %196
%199 = bitcast float* %191 to <4 x float>*
store <4 x float> %198, <4 x float>* %199
%200 = fmul <4 x float> %75, %197
%201 = bitcast float* %190 to <4 x float>*
store <4 x float> %200, <4 x float>* %201
%202 = add nuw i64 %175, 8
%203 = add i64 %176, 2
%204 = icmp eq i64 %203, %173
br i1 %204, label %205, label %174
205: ; preds = %174, %161
%206 = phi i64 [ 0, %161 ], [ %202, %174 ]
%207 = icmp eq i64 %170, 0
br i1 %207, label %221, label %208
208: ; preds = %205
%209 = getelementptr float, float* %118, i64 %206
%210 = getelementptr float, float* %119, i64 %206
%211 = shl i64 %206, 1
%212 = getelementptr float, float* %120, i64 %211
%213 = bitcast float* %212 to <8 x float>*
%214 = load <8 x float>, <8 x float>* %213
%215 = shufflevector <8 x float> %214, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%216 = shufflevector <8 x float> %214, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%217 = fmul <4 x float> %74, %215
%218 = bitcast float* %210 to <4 x float>*
store <4 x float> %217, <4 x float>* %218
%219 = fmul <4 x float> %75, %216
%220 = bitcast float* %209 to <4 x float>*
store <4 x float> %219, <4 x float>* %220
br label %221
221: ; preds = %205, %208
%222 = icmp eq i64 %134, %162
br i1 %222, label %240, label %223
223: ; preds = %136, %127, %221
%224 = phi float* [ %118, %136 ], [ %118, %127 ], [ %163, %221 ]
%225 = phi float* [ %119, %136 ], [ %119, %127 ], [ %164, %221 ]
%226 = phi float* [ %120, %136 ], [ %120, %127 ], [ %166, %221 ]
br label %227
227: ; preds = %223, %227
%228 = phi float* [ %238, %227 ], [ %224, %223 ]
%229 = phi float* [ %234, %227 ], [ %225, %223 ]
%230 = phi float* [ %235, %227 ], [ %226, %223 ]
%231 = getelementptr inbounds float, float* %230, i64 1
%232 = load float, float* %230
%233 = fmul float %76, %232
%234 = getelementptr inbounds float, float* %229, i64 1
store float %233, float* %229
%235 = getelementptr inbounds float, float* %230, i64 2
%236 = load float, float* %231
%237 = fmul float %77, %236
%238 = getelementptr inbounds float, float* %228, i64 1
store float %237, float* %228
%239 = icmp ult float* %235, %125
br i1 %239, label %227, label %240
240: ; preds = %227, %221, %115
%241 = phi float* [ %120, %115 ], [ %166, %221 ], [ %235, %227 ]
%242 = phi float* [ %119, %115 ], [ %164, %221 ], [ %234, %227 ]
%243 = phi float* [ %118, %115 ], [ %163, %221 ], [ %238, %227 ]
%244 = icmp eq float* %241, %125
br i1 %244, label %245, label %250
245: ; preds = %240
%246 = getelementptr inbounds float, float* %125, i64 1
%247 = load float, float* %125
%248 = fmul float %78, %247
%249 = getelementptr inbounds float, float* %242, i64 1
store float %248, float* %242
br label %250
250: ; preds = %245, %240
%251 = phi float* [ %246, %245 ], [ %241, %240 ]
%252 = phi float* [ %249, %245 ], [ %242, %240 ]
%253 = ptrtoint float* %251 to i64
%254 = getelementptr inbounds float, float* %251, i64 %48
%255 = getelementptr inbounds float, float* %254, i64 -1
%256 = icmp ult float* %251, %255
br i1 %256, label %257, label %370
257: ; preds = %250
%258 = add i64 %69, %253
%259 = add i64 %253, 8
%260 = call i64 @llvm.umax.i64(i64 %258, i64 %259)
%261 = xor i64 %253, -1
%262 = add i64 %260, %261
%263 = lshr i64 %262, 3
%264 = add nuw nsw i64 %263, 1
%265 = icmp ult i64 %262, 24
br i1 %265, label %353, label %266
266: ; preds = %257
%267 = getelementptr float, float* %117, i64 1
%268 = add i64 %67, %253
%269 = add i64 %253, 8
%270 = call i64 @llvm.umax.i64(i64 %268, i64 %269)
%271 = xor i64 %253, -1
%272 = add i64 %270, %271
%273 = lshr i64 %272, 3
%274 = getelementptr float, float* %267, i64 %273
%275 = getelementptr float, float* %116, i64 1
%276 = getelementptr float, float* %275, i64 %273
%277 = getelementptr float, float* %251, i64 2
%278 = shl nuw nsw i64 %273, 1
%279 = getelementptr float, float* %277, i64 %278
%280 = icmp ult float* %117, %276
%281 = icmp ult float* %116, %274
%282 = and i1 %280, %281
%283 = icmp ult float* %117, %279
%284 = icmp ult float* %251, %274
%285 = and i1 %283, %284
%286 = or i1 %282, %285
%287 = icmp ult float* %116, %279
%288 = icmp ult float* %251, %276
%289 = and i1 %287, %288
%290 = or i1 %286, %289
br i1 %290, label %353, label %291
291: ; preds = %266
%292 = and i64 %264, 4611686018427387900
%293 = getelementptr float, float* %116, i64 %292
%294 = getelementptr float, float* %117, i64 %292
%295 = shl nuw nsw i64 %292, 1
%296 = getelementptr float, float* %251, i64 %295
%297 = add nsw i64 %292, -4
%298 = lshr exact i64 %297, 2
%299 = add nuw nsw i64 %298, 1
%300 = and i64 %299, 1
%301 = icmp eq i64 %297, 0
br i1 %301, label %335, label %302
302: ; preds = %291
%303 = and i64 %299, 9223372036854775806
br label %304
304: ; preds = %304, %302
%305 = phi i64 [ 0, %302 ], [ %332, %304 ]
%306 = phi i64 [ 0, %302 ], [ %333, %304 ]
%307 = getelementptr float, float* %116, i64 %305
%308 = getelementptr float, float* %117, i64 %305
%309 = shl i64 %305, 1
%310 = getelementptr float, float* %251, i64 %309
%311 = bitcast float* %310 to <8 x float>*
%312 = load <8 x float>, <8 x float>* %311
%313 = shufflevector <8 x float> %312, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%314 = shufflevector <8 x float> %312, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%315 = fmul <4 x float> %79, %313
%316 = bitcast float* %308 to <4 x float>*
store <4 x float> %315, <4 x float>* %316
%317 = fmul <4 x float> %80, %314
%318 = bitcast float* %307 to <4 x float>*
store <4 x float> %317, <4 x float>* %318
%319 = or i64 %305, 4
%320 = getelementptr float, float* %116, i64 %319
%321 = getelementptr float, float* %117, i64 %319
%322 = shl i64 %319, 1
%323 = getelementptr float, float* %251, i64 %322
%324 = bitcast float* %323 to <8 x float>*
%325 = load <8 x float>, <8 x float>* %324
%326 = shufflevector <8 x float> %325, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%327 = shufflevector <8 x float> %325, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%328 = fmul <4 x float> %79, %326
%329 = bitcast float* %321 to <4 x float>*
store <4 x float> %328, <4 x float>* %329
%330 = fmul <4 x float> %80, %327
%331 = bitcast float* %320 to <4 x float>*
store <4 x float> %330, <4 x float>* %331
%332 = add nuw i64 %305, 8
%333 = add i64 %306, 2
%334 = icmp eq i64 %333, %303
br i1 %334, label %335, label %304
335: ; preds = %304, %291
%336 = phi i64 [ 0, %291 ], [ %332, %304 ]
%337 = icmp eq i64 %300, 0
br i1 %337, label %351, label %338
338: ; preds = %335
%339 = getelementptr float, float* %116, i64 %336
%340 = getelementptr float, float* %117, i64 %336
%341 = shl i64 %336, 1
%342 = getelementptr float, float* %251, i64 %341
%343 = bitcast float* %342 to <8 x float>*
%344 = load <8 x float>, <8 x float>* %343
%345 = shufflevector <8 x float> %344, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%346 = shufflevector <8 x float> %344, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%347 = fmul <4 x float> %79, %345
%348 = bitcast float* %340 to <4 x float>*
store <4 x float> %347, <4 x float>* %348
%349 = fmul <4 x float> %80, %346
%350 = bitcast float* %339 to <4 x float>*
store <4 x float> %349, <4 x float>* %350
br label %351
351: ; preds = %335, %338
%352 = icmp eq i64 %264, %292
br i1 %352, label %370, label %353
353: ; preds = %266, %257, %351
%354 = phi float* [ %116, %266 ], [ %116, %257 ], [ %293, %351 ]
%355 = phi float* [ %117, %266 ], [ %117, %257 ], [ %294, %351 ]
%356 = phi float* [ %251, %266 ], [ %251, %257 ], [ %296, %351 ]
br label %357
357: ; preds = %353, %357
%358 = phi float* [ %368, %357 ], [ %354, %353 ]
%359 = phi float* [ %364, %357 ], [ %355, %353 ]
%360 = phi float* [ %365, %357 ], [ %356, %353 ]
%361 = getelementptr inbounds float, float* %360, i64 1
%362 = load float, float* %360
%363 = fmul float %81, %362
%364 = getelementptr inbounds float, float* %359, i64 1
store float %363, float* %359
%365 = getelementptr inbounds float, float* %360, i64 2
%366 = load float, float* %361
%367 = fmul float %82, %366
%368 = getelementptr inbounds float, float* %358, i64 1
store float %367, float* %358
%369 = icmp ult float* %365, %255
br i1 %369, label %357, label %370
370: ; preds = %357, %351, %250
%371 = phi float* [ %251, %250 ], [ %296, %351 ], [ %365, %357 ]
%372 = phi float* [ %117, %250 ], [ %294, %351 ], [ %364, %357 ]
%373 = phi float* [ %116, %250 ], [ %293, %351 ], [ %368, %357 ]
%374 = icmp eq float* %371, %255
br i1 %374, label %375, label %380
375: ; preds = %370
%376 = getelementptr inbounds float, float* %255, i64 1
%377 = load float, float* %255
%378 = fmul float %83, %377
%379 = getelementptr inbounds float, float* %372, i64 1
store float %378, float* %372
br label %380
380: ; preds = %375, %370
%381 = phi float* [ %376, %375 ], [ %371, %370 ]
%382 = phi float* [ %379, %375 ], [ %372, %370 ]
%383 = add nuw nsw i32 %121, 2
%384 = icmp slt i32 %383, %47
br i1 %384, label %115, label %385
385: ; preds = %380, %104
%386 = phi i32 [ 0, %104 ], [ %49, %380 ]
%387 = phi float* [ %113, %104 ], [ %381, %380 ]
%388 = phi float* [ %108, %104 ], [ %252, %380 ]
%389 = phi float* [ %107, %104 ], [ %243, %380 ]
%390 = phi float* [ %106, %104 ], [ %382, %380 ]
%391 = phi float* [ %105, %104 ], [ %373, %380 ]
%392 = ptrtoint float* %387 to i64
%393 = ptrtoint float* %387 to i64
%394 = icmp eq i32 %386, %47
br i1 %394, label %395, label %522
395: ; preds = %385
%396 = getelementptr inbounds float, float* %387, i64 %48
%397 = getelementptr inbounds float, float* %396, i64 -1
%398 = icmp ult float* %387, %397
br i1 %398, label %399, label %512
399: ; preds = %395
%400 = add i64 %65, %392
%401 = add i64 %392, 8
%402 = call i64 @llvm.umax.i64(i64 %400, i64 %401)
%403 = xor i64 %392, -1
%404 = add i64 %402, %403
%405 = lshr i64 %404, 3
%406 = add nuw nsw i64 %405, 1
%407 = icmp ult i64 %404, 24
br i1 %407, label %495, label %408
408: ; preds = %399
%409 = getelementptr float, float* %388, i64 1
%410 = add i64 %63, %393
%411 = add i64 %393, 8
%412 = call i64 @llvm.umax.i64(i64 %410, i64 %411)
%413 = xor i64 %393, -1
%414 = add i64 %412, %413
%415 = lshr i64 %414, 3
%416 = getelementptr float, float* %409, i64 %415
%417 = getelementptr float, float* %389, i64 1
%418 = getelementptr float, float* %417, i64 %415
%419 = getelementptr float, float* %387, i64 2
%420 = shl nuw nsw i64 %415, 1
%421 = getelementptr float, float* %419, i64 %420
%422 = icmp ult float* %388, %418
%423 = icmp ult float* %389, %416
%424 = and i1 %422, %423
%425 = icmp ult float* %388, %421
%426 = icmp ult float* %387, %416
%427 = and i1 %425, %426
%428 = or i1 %424, %427
%429 = icmp ult float* %389, %421
%430 = icmp ult float* %387, %418
%431 = and i1 %429, %430
%432 = or i1 %428, %431
br i1 %432, label %495, label %433
433: ; preds = %408
%434 = and i64 %406, 4611686018427387900
%435 = getelementptr float, float* %389, i64 %434
%436 = getelementptr float, float* %388, i64 %434
%437 = shl nuw nsw i64 %434, 1
%438 = getelementptr float, float* %387, i64 %437
%439 = add nsw i64 %434, -4
%440 = lshr exact i64 %439, 2
%441 = add nuw nsw i64 %440, 1
%442 = and i64 %441, 1
%443 = icmp eq i64 %439, 0
br i1 %443, label %477, label %444
444: ; preds = %433
%445 = and i64 %441, 9223372036854775806
br label %446
446: ; preds = %446, %444
%447 = phi i64 [ 0, %444 ], [ %474, %446 ]
%448 = phi i64 [ 0, %444 ], [ %475, %446 ]
%449 = getelementptr float, float* %389, i64 %447
%450 = getelementptr float, float* %388, i64 %447
%451 = shl i64 %447, 1
%452 = getelementptr float, float* %387, i64 %451
%453 = bitcast float* %452 to <8 x float>*
%454 = load <8 x float>, <8 x float>* %453
%455 = shufflevector <8 x float> %454, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%456 = shufflevector <8 x float> %454, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%457 = fmul <4 x float> %84, %455
%458 = bitcast float* %450 to <4 x float>*
store <4 x float> %457, <4 x float>* %458
%459 = fmul <4 x float> %85, %456
%460 = bitcast float* %449 to <4 x float>*
store <4 x float> %459, <4 x float>* %460
%461 = or i64 %447, 4
%462 = getelementptr float, float* %389, i64 %461
%463 = getelementptr float, float* %388, i64 %461
%464 = shl i64 %461, 1
%465 = getelementptr float, float* %387, i64 %464
%466 = bitcast float* %465 to <8 x float>*
%467 = load <8 x float>, <8 x float>* %466
%468 = shufflevector <8 x float> %467, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%469 = shufflevector <8 x float> %467, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%470 = fmul <4 x float> %84, %468
%471 = bitcast float* %463 to <4 x float>*
store <4 x float> %470, <4 x float>* %471
%472 = fmul <4 x float> %85, %469
%473 = bitcast float* %462 to <4 x float>*
store <4 x float> %472, <4 x float>* %473
%474 = add nuw i64 %447, 8
%475 = add i64 %448, 2
%476 = icmp eq i64 %475, %445
br i1 %476, label %477, label %446
477: ; preds = %446, %433
%478 = phi i64 [ 0, %433 ], [ %474, %446 ]
%479 = icmp eq i64 %442, 0
br i1 %479, label %493, label %480
480: ; preds = %477
%481 = getelementptr float, float* %389, i64 %478
%482 = getelementptr float, float* %388, i64 %478
%483 = shl i64 %478, 1
%484 = getelementptr float, float* %387, i64 %483
%485 = bitcast float* %484 to <8 x float>*
%486 = load <8 x float>, <8 x float>* %485
%487 = shufflevector <8 x float> %486, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%488 = shufflevector <8 x float> %486, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%489 = fmul <4 x float> %84, %487
%490 = bitcast float* %482 to <4 x float>*
store <4 x float> %489, <4 x float>* %490
%491 = fmul <4 x float> %85, %488
%492 = bitcast float* %481 to <4 x float>*
store <4 x float> %491, <4 x float>* %492
br label %493
493: ; preds = %477, %480
%494 = icmp eq i64 %406, %434
br i1 %494, label %512, label %495
495: ; preds = %408, %399, %493
%496 = phi float* [ %389, %408 ], [ %389, %399 ], [ %435, %493 ]
%497 = phi float* [ %388, %408 ], [ %388, %399 ], [ %436, %493 ]
%498 = phi float* [ %387, %408 ], [ %387, %399 ], [ %438, %493 ]
br label %499
499: ; preds = %495, %499
%500 = phi float* [ %510, %499 ], [ %496, %495 ]
%501 = phi float* [ %506, %499 ], [ %497, %495 ]
%502 = phi float* [ %507, %499 ], [ %498, %495 ]
%503 = getelementptr inbounds float, float* %502, i64 1
%504 = load float, float* %502
%505 = fmul float %86, %504
%506 = getelementptr inbounds float, float* %501, i64 1
store float %505, float* %501
%507 = getelementptr inbounds float, float* %502, i64 2
%508 = load float, float* %503
%509 = fmul float %87, %508
%510 = getelementptr inbounds float, float* %500, i64 1
store float %509, float* %500
%511 = icmp ult float* %507, %397
br i1 %511, label %499, label %512
512: ; preds = %499, %493, %395
%513 = phi float* [ %387, %395 ], [ %438, %493 ], [ %507, %499 ]
%514 = phi float* [ %388, %395 ], [ %436, %493 ], [ %506, %499 ]
%515 = phi float* [ %389, %395 ], [ %435, %493 ], [ %510, %499 ]
%516 = icmp eq float* %513, %397
br i1 %516, label %517, label %522
517: ; preds = %512
%518 = getelementptr inbounds float, float* %397, i64 1
%519 = load float, float* %397
%520 = fmul float %88, %519
%521 = getelementptr inbounds float, float* %514, i64 1
store float %520, float* %514
br label %522
522: ; preds = %512, %517, %385
%523 = phi float* [ %387, %385 ], [ %518, %517 ], [ %513, %512 ]
%524 = phi float* [ %388, %385 ], [ %521, %517 ], [ %514, %512 ]
%525 = phi float* [ %389, %385 ], [ %515, %517 ], [ %515, %512 ]
br i1 %19, label %526, label %796
526: ; preds = %522, %791
%527 = phi float* [ %784, %791 ], [ %109, %522 ]
%528 = phi float* [ %793, %791 ], [ %110, %522 ]
%529 = phi float* [ %654, %791 ], [ %111, %522 ]
%530 = phi float* [ %663, %791 ], [ %112, %522 ]
%531 = phi float* [ %792, %791 ], [ %523, %522 ]
%532 = phi i32 [ %794, %791 ], [ 0, %522 ]
%533 = ptrtoint float* %531 to i64
%534 = ptrtoint float* %531 to i64
%535 = getelementptr inbounds float, float* %531, i64 %48
%536 = getelementptr inbounds float, float* %535, i64 -1
%537 = icmp ult float* %531, %536
br i1 %537, label %538, label %651
538: ; preds = %526
%539 = add i64 %61, %533
%540 = add i64 %533, 8
%541 = call i64 @llvm.umax.i64(i64 %539, i64 %540)
%542 = xor i64 %533, -1
%543 = add i64 %541, %542
%544 = lshr i64 %543, 3
%545 = add nuw nsw i64 %544, 1
%546 = icmp ult i64 %543, 24
br i1 %546, label %634, label %547
547: ; preds = %538
%548 = getelementptr float, float* %530, i64 1
%549 = add i64 %59, %534
%550 = add i64 %534, 8
%551 = call i64 @llvm.umax.i64(i64 %549, i64 %550)
%552 = xor i64 %534, -1
%553 = add i64 %551, %552
%554 = lshr i64 %553, 3
%555 = getelementptr float, float* %548, i64 %554
%556 = getelementptr float, float* %529, i64 1
%557 = getelementptr float, float* %556, i64 %554
%558 = getelementptr float, float* %531, i64 2
%559 = shl nuw nsw i64 %554, 1
%560 = getelementptr float, float* %558, i64 %559
%561 = icmp ult float* %530, %557
%562 = icmp ult float* %529, %555
%563 = and i1 %561, %562
%564 = icmp ult float* %530, %560
%565 = icmp ult float* %531, %555
%566 = and i1 %564, %565
%567 = or i1 %563, %566
%568 = icmp ult float* %529, %560
%569 = icmp ult float* %531, %557
%570 = and i1 %568, %569
%571 = or i1 %567, %570
br i1 %571, label %634, label %572
572: ; preds = %547
%573 = and i64 %545, 4611686018427387900
%574 = getelementptr float, float* %529, i64 %573
%575 = getelementptr float, float* %530, i64 %573
%576 = shl nuw nsw i64 %573, 1
%577 = getelementptr float, float* %531, i64 %576
%578 = add nsw i64 %573, -4
%579 = lshr exact i64 %578, 2
%580 = add nuw nsw i64 %579, 1
%581 = and i64 %580, 1
%582 = icmp eq i64 %578, 0
br i1 %582, label %616, label %583
583: ; preds = %572
%584 = and i64 %580, 9223372036854775806
br label %585
585: ; preds = %585, %583
%586 = phi i64 [ 0, %583 ], [ %613, %585 ]
%587 = phi i64 [ 0, %583 ], [ %614, %585 ]
%588 = getelementptr float, float* %529, i64 %586
%589 = getelementptr float, float* %530, i64 %586
%590 = shl i64 %586, 1
%591 = getelementptr float, float* %531, i64 %590
%592 = bitcast float* %591 to <8 x float>*
%593 = load <8 x float>, <8 x float>* %592
%594 = shufflevector <8 x float> %593, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%595 = shufflevector <8 x float> %593, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%596 = fmul <4 x float> %89, %594
%597 = bitcast float* %589 to <4 x float>*
store <4 x float> %596, <4 x float>* %597
%598 = fmul <4 x float> %90, %595
%599 = bitcast float* %588 to <4 x float>*
store <4 x float> %598, <4 x float>* %599
%600 = or i64 %586, 4
%601 = getelementptr float, float* %529, i64 %600
%602 = getelementptr float, float* %530, i64 %600
%603 = shl i64 %600, 1
%604 = getelementptr float, float* %531, i64 %603
%605 = bitcast float* %604 to <8 x float>*
%606 = load <8 x float>, <8 x float>* %605
%607 = shufflevector <8 x float> %606, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%608 = shufflevector <8 x float> %606, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%609 = fmul <4 x float> %89, %607
%610 = bitcast float* %602 to <4 x float>*
store <4 x float> %609, <4 x float>* %610
%611 = fmul <4 x float> %90, %608
%612 = bitcast float* %601 to <4 x float>*
store <4 x float> %611, <4 x float>* %612
%613 = add nuw i64 %586, 8
%614 = add i64 %587, 2
%615 = icmp eq i64 %614, %584
br i1 %615, label %616, label %585
616: ; preds = %585, %572
%617 = phi i64 [ 0, %572 ], [ %613, %585 ]
%618 = icmp eq i64 %581, 0
br i1 %618, label %632, label %619
619: ; preds = %616
%620 = getelementptr float, float* %529, i64 %617
%621 = getelementptr float, float* %530, i64 %617
%622 = shl i64 %617, 1
%623 = getelementptr float, float* %531, i64 %622
%624 = bitcast float* %623 to <8 x float>*
%625 = load <8 x float>, <8 x float>* %624
%626 = shufflevector <8 x float> %625, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%627 = shufflevector <8 x float> %625, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%628 = fmul <4 x float> %89, %626
%629 = bitcast float* %621 to <4 x float>*
store <4 x float> %628, <4 x float>* %629
%630 = fmul <4 x float> %90, %627
%631 = bitcast float* %620 to <4 x float>*
store <4 x float> %630, <4 x float>* %631
br label %632
632: ; preds = %616, %619
%633 = icmp eq i64 %545, %573
br i1 %633, label %651, label %634
634: ; preds = %547, %538, %632
%635 = phi float* [ %529, %547 ], [ %529, %538 ], [ %574, %632 ]
%636 = phi float* [ %530, %547 ], [ %530, %538 ], [ %575, %632 ]
%637 = phi float* [ %531, %547 ], [ %531, %538 ], [ %577, %632 ]
br label %638
638: ; preds = %634, %638
%639 = phi float* [ %649, %638 ], [ %635, %634 ]
%640 = phi float* [ %645, %638 ], [ %636, %634 ]
%641 = phi float* [ %646, %638 ], [ %637, %634 ]
%642 = getelementptr inbounds float, float* %641, i64 1
%643 = load float, float* %641
%644 = fmul float %91, %643
%645 = getelementptr inbounds float, float* %640, i64 1
store float %644, float* %640
%646 = getelementptr inbounds float, float* %641, i64 2
%647 = load float, float* %642
%648 = fmul float %92, %647
%649 = getelementptr inbounds float, float* %639, i64 1
store float %648, float* %639
%650 = icmp ult float* %646, %536
br i1 %650, label %638, label %651
651: ; preds = %638, %632, %526
%652 = phi float* [ %531, %526 ], [ %577, %632 ], [ %646, %638 ]
%653 = phi float* [ %530, %526 ], [ %575, %632 ], [ %645, %638 ]
%654 = phi float* [ %529, %526 ], [ %574, %632 ], [ %649, %638 ]
%655 = icmp eq float* %652, %536
br i1 %655, label %656, label %661
656: ; preds = %651
%657 = getelementptr inbounds float, float* %536, i64 1
%658 = load float, float* %536
%659 = fmul float %93, %658
%660 = getelementptr inbounds float, float* %653, i64 1
store float %659, float* %653
br label %661
661: ; preds = %656, %651
%662 = phi float* [ %657, %656 ], [ %652, %651 ]
%663 = phi float* [ %660, %656 ], [ %653, %651 ]
%664 = ptrtoint float* %662 to i64
%665 = getelementptr inbounds float, float* %662, i64 %48
%666 = getelementptr inbounds float, float* %665, i64 -1
%667 = icmp ult float* %662, %666
br i1 %667, label %668, label %781
668: ; preds = %661
%669 = add i64 %57, %664
%670 = add i64 %664, 8
%671 = call i64 @llvm.umax.i64(i64 %669, i64 %670)
%672 = xor i64 %664, -1
%673 = add i64 %671, %672
%674 = lshr i64 %673, 3
%675 = add nuw nsw i64 %674, 1
%676 = icmp ult i64 %673, 24
br i1 %676, label %764, label %677
677: ; preds = %668
%678 = getelementptr float, float* %528, i64 1
%679 = add i64 %55, %664
%680 = add i64 %664, 8
%681 = call i64 @llvm.umax.i64(i64 %679, i64 %680)
%682 = xor i64 %664, -1
%683 = add i64 %681, %682
%684 = lshr i64 %683, 3
%685 = getelementptr float, float* %678, i64 %684
%686 = getelementptr float, float* %527, i64 1
%687 = getelementptr float, float* %686, i64 %684
%688 = getelementptr float, float* %662, i64 2
%689 = shl nuw nsw i64 %684, 1
%690 = getelementptr float, float* %688, i64 %689
%691 = icmp ult float* %528, %687
%692 = icmp ult float* %527, %685
%693 = and i1 %691, %692
%694 = icmp ult float* %528, %690
%695 = icmp ult float* %662, %685
%696 = and i1 %694, %695
%697 = or i1 %693, %696
%698 = icmp ult float* %527, %690
%699 = icmp ult float* %662, %687
%700 = and i1 %698, %699
%701 = or i1 %697, %700
br i1 %701, label %764, label %702
702: ; preds = %677
%703 = and i64 %675, 4611686018427387900
%704 = getelementptr float, float* %527, i64 %703
%705 = getelementptr float, float* %528, i64 %703
%706 = shl nuw nsw i64 %703, 1
%707 = getelementptr float, float* %662, i64 %706
%708 = add nsw i64 %703, -4
%709 = lshr exact i64 %708, 2
%710 = add nuw nsw i64 %709, 1
%711 = and i64 %710, 1
%712 = icmp eq i64 %708, 0
br i1 %712, label %746, label %713
713: ; preds = %702
%714 = and i64 %710, 9223372036854775806
br label %715
715: ; preds = %715, %713
%716 = phi i64 [ 0, %713 ], [ %743, %715 ]
%717 = phi i64 [ 0, %713 ], [ %744, %715 ]
%718 = getelementptr float, float* %527, i64 %716
%719 = getelementptr float, float* %528, i64 %716
%720 = shl i64 %716, 1
%721 = getelementptr float, float* %662, i64 %720
%722 = bitcast float* %721 to <8 x float>*
%723 = load <8 x float>, <8 x float>* %722
%724 = shufflevector <8 x float> %723, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%725 = shufflevector <8 x float> %723, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%726 = fmul <4 x float> %94, %724
%727 = bitcast float* %719 to <4 x float>*
store <4 x float> %726, <4 x float>* %727
%728 = fmul <4 x float> %95, %725
%729 = bitcast float* %718 to <4 x float>*
store <4 x float> %728, <4 x float>* %729
%730 = or i64 %716, 4
%731 = getelementptr float, float* %527, i64 %730
%732 = getelementptr float, float* %528, i64 %730
%733 = shl i64 %730, 1
%734 = getelementptr float, float* %662, i64 %733
%735 = bitcast float* %734 to <8 x float>*
%736 = load <8 x float>, <8 x float>* %735
%737 = shufflevector <8 x float> %736, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%738 = shufflevector <8 x float> %736, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%739 = fmul <4 x float> %94, %737
%740 = bitcast float* %732 to <4 x float>*
store <4 x float> %739, <4 x float>* %740
%741 = fmul <4 x float> %95, %738
%742 = bitcast float* %731 to <4 x float>*
store <4 x float> %741, <4 x float>* %742
%743 = add nuw i64 %716, 8
%744 = add i64 %717, 2
%745 = icmp eq i64 %744, %714
br i1 %745, label %746, label %715
746: ; preds = %715, %702
%747 = phi i64 [ 0, %702 ], [ %743, %715 ]
%748 = icmp eq i64 %711, 0
br i1 %748, label %762, label %749
749: ; preds = %746
%750 = getelementptr float, float* %527, i64 %747
%751 = getelementptr float, float* %528, i64 %747
%752 = shl i64 %747, 1
%753 = getelementptr float, float* %662, i64 %752
%754 = bitcast float* %753 to <8 x float>*
%755 = load <8 x float>, <8 x float>* %754
%756 = shufflevector <8 x float> %755, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%757 = shufflevector <8 x float> %755, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%758 = fmul <4 x float> %94, %756
%759 = bitcast float* %751 to <4 x float>*
store <4 x float> %758, <4 x float>* %759
%760 = fmul <4 x float> %95, %757
%761 = bitcast float* %750 to <4 x float>*
store <4 x float> %760, <4 x float>* %761
br label %762
762: ; preds = %746, %749
%763 = icmp eq i64 %675, %703
br i1 %763, label %781, label %764
764: ; preds = %677, %668, %762
%765 = phi float* [ %527, %677 ], [ %527, %668 ], [ %704, %762 ]
%766 = phi float* [ %528, %677 ], [ %528, %668 ], [ %705, %762 ]
%767 = phi float* [ %662, %677 ], [ %662, %668 ], [ %707, %762 ]
br label %768
768: ; preds = %764, %768
%769 = phi float* [ %779, %768 ], [ %765, %764 ]
%770 = phi float* [ %775, %768 ], [ %766, %764 ]
%771 = phi float* [ %776, %768 ], [ %767, %764 ]
%772 = getelementptr inbounds float, float* %771, i64 1
%773 = load float, float* %771
%774 = fmul float %96, %773
%775 = getelementptr inbounds float, float* %770, i64 1
store float %774, float* %770
%776 = getelementptr inbounds float, float* %771, i64 2
%777 = load float, float* %772
%778 = fmul float %97, %777
%779 = getelementptr inbounds float, float* %769, i64 1
store float %778, float* %769
%780 = icmp ult float* %776, %666
br i1 %780, label %768, label %781
781: ; preds = %768, %762, %661
%782 = phi float* [ %662, %661 ], [ %707, %762 ], [ %776, %768 ]
%783 = phi float* [ %528, %661 ], [ %705, %762 ], [ %775, %768 ]
%784 = phi float* [ %527, %661 ], [ %704, %762 ], [ %779, %768 ]
%785 = icmp eq float* %782, %666
br i1 %785, label %786, label %791
786: ; preds = %781
%787 = getelementptr inbounds float, float* %666, i64 1
%788 = load float, float* %666
%789 = fmul float %98, %788
%790 = getelementptr inbounds float, float* %783, i64 1
store float %789, float* %783
br label %791
791: ; preds = %786, %781
%792 = phi float* [ %787, %786 ], [ %782, %781 ]
%793 = phi float* [ %790, %786 ], [ %783, %781 ]
%794 = add nuw nsw i32 %532, 2
%795 = icmp slt i32 %794, %47
br i1 %795, label %526, label %796
796: ; preds = %791, %522
%797 = phi i32 [ 0, %522 ], [ %49, %791 ]
%798 = phi float* [ %523, %522 ], [ %792, %791 ]
%799 = phi float* [ %112, %522 ], [ %663, %791 ]
%800 = phi float* [ %111, %522 ], [ %654, %791 ]
%801 = phi float* [ %110, %522 ], [ %793, %791 ]
%802 = phi float* [ %109, %522 ], [ %784, %791 ]
%803 = ptrtoint float* %798 to i64
%804 = ptrtoint float* %798 to i64
%805 = icmp eq i32 %797, %47
br i1 %805, label %806, label %933
806: ; preds = %796
%807 = getelementptr inbounds float, float* %798, i64 %48
%808 = getelementptr inbounds float, float* %807, i64 -1
%809 = icmp ult float* %798, %808
br i1 %809, label %810, label %923
810: ; preds = %806
%811 = add i64 %53, %803
%812 = add i64 %803, 8
%813 = call i64 @llvm.umax.i64(i64 %811, i64 %812)
%814 = xor i64 %803, -1
%815 = add i64 %813, %814
%816 = lshr i64 %815, 3
%817 = add nuw nsw i64 %816, 1
%818 = icmp ult i64 %815, 24
br i1 %818, label %906, label %819
819: ; preds = %810
%820 = getelementptr float, float* %799, i64 1
%821 = add i64 %51, %804
%822 = add i64 %804, 8
%823 = call i64 @llvm.umax.i64(i64 %821, i64 %822)
%824 = xor i64 %804, -1
%825 = add i64 %823, %824
%826 = lshr i64 %825, 3
%827 = getelementptr float, float* %820, i64 %826
%828 = getelementptr float, float* %800, i64 1
%829 = getelementptr float, float* %828, i64 %826
%830 = getelementptr float, float* %798, i64 2
%831 = shl nuw nsw i64 %826, 1
%832 = getelementptr float, float* %830, i64 %831
%833 = icmp ult float* %799, %829
%834 = icmp ult float* %800, %827
%835 = and i1 %833, %834
%836 = icmp ult float* %799, %832
%837 = icmp ult float* %798, %827
%838 = and i1 %836, %837
%839 = or i1 %835, %838
%840 = icmp ult float* %800, %832
%841 = icmp ult float* %798, %829
%842 = and i1 %840, %841
%843 = or i1 %839, %842
br i1 %843, label %906, label %844
844: ; preds = %819
%845 = and i64 %817, 4611686018427387900
%846 = getelementptr float, float* %800, i64 %845
%847 = getelementptr float, float* %799, i64 %845
%848 = shl nuw nsw i64 %845, 1
%849 = getelementptr float, float* %798, i64 %848
%850 = add nsw i64 %845, -4
%851 = lshr exact i64 %850, 2
%852 = add nuw nsw i64 %851, 1
%853 = and i64 %852, 1
%854 = icmp eq i64 %850, 0
br i1 %854, label %888, label %855
855: ; preds = %844
%856 = and i64 %852, 9223372036854775806
br label %857
857: ; preds = %857, %855
%858 = phi i64 [ 0, %855 ], [ %885, %857 ]
%859 = phi i64 [ 0, %855 ], [ %886, %857 ]
%860 = getelementptr float, float* %800, i64 %858
%861 = getelementptr float, float* %799, i64 %858
%862 = shl i64 %858, 1
%863 = getelementptr float, float* %798, i64 %862
%864 = bitcast float* %863 to <8 x float>*
%865 = load <8 x float>, <8 x float>* %864
%866 = shufflevector <8 x float> %865, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%867 = shufflevector <8 x float> %865, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%868 = fmul <4 x float> %99, %866
%869 = bitcast float* %861 to <4 x float>*
store <4 x float> %868, <4 x float>* %869
%870 = fmul <4 x float> %100, %867
%871 = bitcast float* %860 to <4 x float>*
store <4 x float> %870, <4 x float>* %871
%872 = or i64 %858, 4
%873 = getelementptr float, float* %800, i64 %872
%874 = getelementptr float, float* %799, i64 %872
%875 = shl i64 %872, 1
%876 = getelementptr float, float* %798, i64 %875
%877 = bitcast float* %876 to <8 x float>*
%878 = load <8 x float>, <8 x float>* %877
%879 = shufflevector <8 x float> %878, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%880 = shufflevector <8 x float> %878, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%881 = fmul <4 x float> %99, %879
%882 = bitcast float* %874 to <4 x float>*
store <4 x float> %881, <4 x float>* %882
%883 = fmul <4 x float> %100, %880
%884 = bitcast float* %873 to <4 x float>*
store <4 x float> %883, <4 x float>* %884
%885 = add nuw i64 %858, 8
%886 = add i64 %859, 2
%887 = icmp eq i64 %886, %856
br i1 %887, label %888, label %857
888: ; preds = %857, %844
%889 = phi i64 [ 0, %844 ], [ %885, %857 ]
%890 = icmp eq i64 %853, 0
br i1 %890, label %904, label %891
891: ; preds = %888
%892 = getelementptr float, float* %800, i64 %889
%893 = getelementptr float, float* %799, i64 %889
%894 = shl i64 %889, 1
%895 = getelementptr float, float* %798, i64 %894
%896 = bitcast float* %895 to <8 x float>*
%897 = load <8 x float>, <8 x float>* %896
%898 = shufflevector <8 x float> %897, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%899 = shufflevector <8 x float> %897, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%900 = fmul <4 x float> %99, %898
%901 = bitcast float* %893 to <4 x float>*
store <4 x float> %900, <4 x float>* %901
%902 = fmul <4 x float> %100, %899
%903 = bitcast float* %892 to <4 x float>*
store <4 x float> %902, <4 x float>* %903
br label %904
904: ; preds = %888, %891
%905 = icmp eq i64 %817, %845
br i1 %905, label %923, label %906
906: ; preds = %819, %810, %904
%907 = phi float* [ %800, %819 ], [ %800, %810 ], [ %846, %904 ]
%908 = phi float* [ %799, %819 ], [ %799, %810 ], [ %847, %904 ]
%909 = phi float* [ %798, %819 ], [ %798, %810 ], [ %849, %904 ]
br label %910
910: ; preds = %906, %910
%911 = phi float* [ %921, %910 ], [ %907, %906 ]
%912 = phi float* [ %917, %910 ], [ %908, %906 ]
%913 = phi float* [ %918, %910 ], [ %909, %906 ]
%914 = getelementptr inbounds float, float* %913, i64 1
%915 = load float, float* %913
%916 = fmul float %101, %915
%917 = getelementptr inbounds float, float* %912, i64 1
store float %916, float* %912
%918 = getelementptr inbounds float, float* %913, i64 2
%919 = load float, float* %914
%920 = fmul float %102, %919
%921 = getelementptr inbounds float, float* %911, i64 1
store float %920, float* %911
%922 = icmp ult float* %918, %808
br i1 %922, label %910, label %923
923: ; preds = %910, %904, %806
%924 = phi float* [ %798, %806 ], [ %849, %904 ], [ %918, %910 ]
%925 = phi float* [ %799, %806 ], [ %847, %904 ], [ %917, %910 ]
%926 = phi float* [ %800, %806 ], [ %846, %904 ], [ %921, %910 ]
%927 = icmp eq float* %924, %808
br i1 %927, label %928, label %933
928: ; preds = %923
%929 = getelementptr inbounds float, float* %808, i64 1
%930 = load float, float* %808
%931 = fmul float %103, %930
%932 = getelementptr inbounds float, float* %925, i64 1
store float %931, float* %925
br label %933
933: ; preds = %923, %928, %796
%934 = phi float* [ %798, %796 ], [ %929, %928 ], [ %924, %923 ]
%935 = phi float* [ %799, %796 ], [ %932, %928 ], [ %925, %923 ]
%936 = phi float* [ %800, %796 ], [ %926, %928 ], [ %926, %923 ]
%937 = add nuw nsw i32 %114, 2
%938 = icmp slt i32 %937, %45
br i1 %938, label %104, label %939
939: ; preds = %933
%940 = and i32 %11, -2
br label %941
941: ; preds = %939, %43
%942 = phi i32 [ 0, %43 ], [ %940, %939 ]
%943 = phi float* [ %0, %43 ], [ %934, %939 ]
%944 = phi float* [ %8, %43 ], [ %524, %939 ]
%945 = phi float* [ %7, %43 ], [ %525, %939 ]
%946 = phi float* [ %6, %43 ], [ %390, %939 ]
%947 = phi float* [ %5, %43 ], [ %391, %939 ]
%948 = icmp eq i32 %942, %45
br i1 %948, label %949, label %1384
949: ; preds = %941
%950 = add nsw i32 %10, -1
br i1 %19, label %951, label %1243
951: ; preds = %949
%952 = sext i32 %9 to i64
%953 = shl nsw i64 %952, 2
%954 = add nsw i64 %953, -4
%955 = shl nsw i64 %952, 2
%956 = add nsw i64 %955, -4
%957 = shl nsw i64 %952, 2
%958 = add nsw i64 %957, -4
%959 = shl nsw i64 %952, 2
%960 = add nsw i64 %959, -4
%961 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%962 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%963 = extractelement <4 x float> %44, i64 2
%964 = extractelement <4 x float> %44, i64 3
%965 = extractelement <4 x float> %44, i64 2
%966 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%967 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%968 = extractelement <4 x float> %44, i64 3
%969 = extractelement <4 x float> %44, i64 0
%970 = extractelement <4 x float> %44, i64 3
br label %971
971: ; preds = %951, %1236
%972 = phi float* [ %947, %951 ], [ %1229, %1236 ]
%973 = phi float* [ %946, %951 ], [ %1238, %1236 ]
%974 = phi float* [ %945, %951 ], [ %1099, %1236 ]
%975 = phi float* [ %944, %951 ], [ %1108, %1236 ]
%976 = phi float* [ %943, %951 ], [ %1237, %1236 ]
%977 = phi i32 [ 0, %951 ], [ %1239, %1236 ]
%978 = ptrtoint float* %976 to i64
%979 = ptrtoint float* %976 to i64
%980 = getelementptr inbounds float, float* %976, i64 %952
%981 = getelementptr inbounds float, float* %980, i64 -1
%982 = icmp ult float* %976, %981
br i1 %982, label %983, label %1096
983: ; preds = %971
%984 = add i64 %960, %978
%985 = add i64 %978, 8
%986 = call i64 @llvm.umax.i64(i64 %984, i64 %985)
%987 = xor i64 %978, -1
%988 = add i64 %986, %987
%989 = lshr i64 %988, 3
%990 = add nuw nsw i64 %989, 1
%991 = icmp ult i64 %988, 24
br i1 %991, label %1079, label %992
992: ; preds = %983
%993 = getelementptr float, float* %975, i64 1
%994 = add i64 %958, %979
%995 = add i64 %979, 8
%996 = call i64 @llvm.umax.i64(i64 %994, i64 %995)
%997 = xor i64 %979, -1
%998 = add i64 %996, %997
%999 = lshr i64 %998, 3
%1000 = getelementptr float, float* %993, i64 %999
%1001 = getelementptr float, float* %974, i64 1
%1002 = getelementptr float, float* %1001, i64 %999
%1003 = getelementptr float, float* %976, i64 2
%1004 = shl nuw nsw i64 %999, 1
%1005 = getelementptr float, float* %1003, i64 %1004
%1006 = icmp ult float* %975, %1002
%1007 = icmp ult float* %974, %1000
%1008 = and i1 %1006, %1007
%1009 = icmp ult float* %975, %1005
%1010 = icmp ult float* %976, %1000
%1011 = and i1 %1009, %1010
%1012 = or i1 %1008, %1011
%1013 = icmp ult float* %974, %1005
%1014 = icmp ult float* %976, %1002
%1015 = and i1 %1013, %1014
%1016 = or i1 %1012, %1015
br i1 %1016, label %1079, label %1017
1017: ; preds = %992
%1018 = and i64 %990, 4611686018427387900
%1019 = getelementptr float, float* %974, i64 %1018
%1020 = getelementptr float, float* %975, i64 %1018
%1021 = shl nuw nsw i64 %1018, 1
%1022 = getelementptr float, float* %976, i64 %1021
%1023 = add nsw i64 %1018, -4
%1024 = lshr exact i64 %1023, 2
%1025 = add nuw nsw i64 %1024, 1
%1026 = and i64 %1025, 1
%1027 = icmp eq i64 %1023, 0
br i1 %1027, label %1061, label %1028
1028: ; preds = %1017
%1029 = and i64 %1025, 9223372036854775806
br label %1030
1030: ; preds = %1030, %1028
%1031 = phi i64 [ 0, %1028 ], [ %1058, %1030 ]
%1032 = phi i64 [ 0, %1028 ], [ %1059, %1030 ]
%1033 = getelementptr float, float* %974, i64 %1031
%1034 = getelementptr float, float* %975, i64 %1031
%1035 = shl i64 %1031, 1
%1036 = getelementptr float, float* %976, i64 %1035
%1037 = bitcast float* %1036 to <8 x float>*
%1038 = load <8 x float>, <8 x float>* %1037
%1039 = shufflevector <8 x float> %1038, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1040 = shufflevector <8 x float> %1038, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1041 = fmul <4 x float> %961, %1039
%1042 = bitcast float* %1034 to <4 x float>*
store <4 x float> %1041, <4 x float>* %1042
%1043 = fmul <4 x float> %962, %1040
%1044 = bitcast float* %1033 to <4 x float>*
store <4 x float> %1043, <4 x float>* %1044
%1045 = or i64 %1031, 4
%1046 = getelementptr float, float* %974, i64 %1045
%1047 = getelementptr float, float* %975, i64 %1045
%1048 = shl i64 %1045, 1
%1049 = getelementptr float, float* %976, i64 %1048
%1050 = bitcast float* %1049 to <8 x float>*
%1051 = load <8 x float>, <8 x float>* %1050
%1052 = shufflevector <8 x float> %1051, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1053 = shufflevector <8 x float> %1051, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1054 = fmul <4 x float> %961, %1052
%1055 = bitcast float* %1047 to <4 x float>*
store <4 x float> %1054, <4 x float>* %1055
%1056 = fmul <4 x float> %962, %1053
%1057 = bitcast float* %1046 to <4 x float>*
store <4 x float> %1056, <4 x float>* %1057
%1058 = add nuw i64 %1031, 8
%1059 = add i64 %1032, 2
%1060 = icmp eq i64 %1059, %1029
br i1 %1060, label %1061, label %1030
1061: ; preds = %1030, %1017
%1062 = phi i64 [ 0, %1017 ], [ %1058, %1030 ]
%1063 = icmp eq i64 %1026, 0
br i1 %1063, label %1077, label %1064
1064: ; preds = %1061
%1065 = getelementptr float, float* %974, i64 %1062
%1066 = getelementptr float, float* %975, i64 %1062
%1067 = shl i64 %1062, 1
%1068 = getelementptr float, float* %976, i64 %1067
%1069 = bitcast float* %1068 to <8 x float>*
%1070 = load <8 x float>, <8 x float>* %1069
%1071 = shufflevector <8 x float> %1070, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1072 = shufflevector <8 x float> %1070, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1073 = fmul <4 x float> %961, %1071
%1074 = bitcast float* %1066 to <4 x float>*
store <4 x float> %1073, <4 x float>* %1074
%1075 = fmul <4 x float> %962, %1072
%1076 = bitcast float* %1065 to <4 x float>*
store <4 x float> %1075, <4 x float>* %1076
br label %1077
1077: ; preds = %1061, %1064
%1078 = icmp eq i64 %990, %1018
br i1 %1078, label %1096, label %1079
1079: ; preds = %992, %983, %1077
%1080 = phi float* [ %974, %992 ], [ %974, %983 ], [ %1019, %1077 ]
%1081 = phi float* [ %975, %992 ], [ %975, %983 ], [ %1020, %1077 ]
%1082 = phi float* [ %976, %992 ], [ %976, %983 ], [ %1022, %1077 ]
br label %1083
1083: ; preds = %1079, %1083
%1084 = phi float* [ %1094, %1083 ], [ %1080, %1079 ]
%1085 = phi float* [ %1090, %1083 ], [ %1081, %1079 ]
%1086 = phi float* [ %1091, %1083 ], [ %1082, %1079 ]
%1087 = getelementptr inbounds float, float* %1086, i64 1
%1088 = load float, float* %1086
%1089 = fmul float %963, %1088
%1090 = getelementptr inbounds float, float* %1085, i64 1
store float %1089, float* %1085
%1091 = getelementptr inbounds float, float* %1086, i64 2
%1092 = load float, float* %1087
%1093 = fmul float %964, %1092
%1094 = getelementptr inbounds float, float* %1084, i64 1
store float %1093, float* %1084
%1095 = icmp ult float* %1091, %981
br i1 %1095, label %1083, label %1096
1096: ; preds = %1083, %1077, %971
%1097 = phi float* [ %976, %971 ], [ %1022, %1077 ], [ %1091, %1083 ]
%1098 = phi float* [ %975, %971 ], [ %1020, %1077 ], [ %1090, %1083 ]
%1099 = phi float* [ %974, %971 ], [ %1019, %1077 ], [ %1094, %1083 ]
%1100 = icmp eq float* %1097, %981
br i1 %1100, label %1101, label %1106
1101: ; preds = %1096
%1102 = getelementptr inbounds float, float* %981, i64 1
%1103 = load float, float* %981
%1104 = fmul float %965, %1103
%1105 = getelementptr inbounds float, float* %1098, i64 1
store float %1104, float* %1098
br label %1106
1106: ; preds = %1101, %1096
%1107 = phi float* [ %1102, %1101 ], [ %1097, %1096 ]
%1108 = phi float* [ %1105, %1101 ], [ %1098, %1096 ]
%1109 = ptrtoint float* %1107 to i64
%1110 = getelementptr inbounds float, float* %1107, i64 %952
%1111 = getelementptr inbounds float, float* %1110, i64 -1
%1112 = icmp ult float* %1107, %1111
br i1 %1112, label %1113, label %1226
1113: ; preds = %1106
%1114 = add i64 %956, %1109
%1115 = add i64 %1109, 8
%1116 = call i64 @llvm.umax.i64(i64 %1114, i64 %1115)
%1117 = xor i64 %1109, -1
%1118 = add i64 %1116, %1117
%1119 = lshr i64 %1118, 3
%1120 = add nuw nsw i64 %1119, 1
%1121 = icmp ult i64 %1118, 24
br i1 %1121, label %1209, label %1122
1122: ; preds = %1113
%1123 = getelementptr float, float* %973, i64 1
%1124 = add i64 %954, %1109
%1125 = add i64 %1109, 8
%1126 = call i64 @llvm.umax.i64(i64 %1124, i64 %1125)
%1127 = xor i64 %1109, -1
%1128 = add i64 %1126, %1127
%1129 = lshr i64 %1128, 3
%1130 = getelementptr float, float* %1123, i64 %1129
%1131 = getelementptr float, float* %972, i64 1
%1132 = getelementptr float, float* %1131, i64 %1129
%1133 = getelementptr float, float* %1107, i64 2
%1134 = shl nuw nsw i64 %1129, 1
%1135 = getelementptr float, float* %1133, i64 %1134
%1136 = icmp ult float* %973, %1132
%1137 = icmp ult float* %972, %1130
%1138 = and i1 %1136, %1137
%1139 = icmp ult float* %973, %1135
%1140 = icmp ult float* %1107, %1130
%1141 = and i1 %1139, %1140
%1142 = or i1 %1138, %1141
%1143 = icmp ult float* %972, %1135
%1144 = icmp ult float* %1107, %1132
%1145 = and i1 %1143, %1144
%1146 = or i1 %1142, %1145
br i1 %1146, label %1209, label %1147
1147: ; preds = %1122
%1148 = and i64 %1120, 4611686018427387900
%1149 = getelementptr float, float* %972, i64 %1148
%1150 = getelementptr float, float* %973, i64 %1148
%1151 = shl nuw nsw i64 %1148, 1
%1152 = getelementptr float, float* %1107, i64 %1151
%1153 = add nsw i64 %1148, -4
%1154 = lshr exact i64 %1153, 2
%1155 = add nuw nsw i64 %1154, 1
%1156 = and i64 %1155, 1
%1157 = icmp eq i64 %1153, 0
br i1 %1157, label %1191, label %1158
1158: ; preds = %1147
%1159 = and i64 %1155, 9223372036854775806
br label %1160
1160: ; preds = %1160, %1158
%1161 = phi i64 [ 0, %1158 ], [ %1188, %1160 ]
%1162 = phi i64 [ 0, %1158 ], [ %1189, %1160 ]
%1163 = getelementptr float, float* %972, i64 %1161
%1164 = getelementptr float, float* %973, i64 %1161
%1165 = shl i64 %1161, 1
%1166 = getelementptr float, float* %1107, i64 %1165
%1167 = bitcast float* %1166 to <8 x float>*
%1168 = load <8 x float>, <8 x float>* %1167
%1169 = shufflevector <8 x float> %1168, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1170 = shufflevector <8 x float> %1168, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1171 = fmul <4 x float> %966, %1169
%1172 = bitcast float* %1164 to <4 x float>*
store <4 x float> %1171, <4 x float>* %1172
%1173 = fmul <4 x float> %967, %1170
%1174 = bitcast float* %1163 to <4 x float>*
store <4 x float> %1173, <4 x float>* %1174
%1175 = or i64 %1161, 4
%1176 = getelementptr float, float* %972, i64 %1175
%1177 = getelementptr float, float* %973, i64 %1175
%1178 = shl i64 %1175, 1
%1179 = getelementptr float, float* %1107, i64 %1178
%1180 = bitcast float* %1179 to <8 x float>*
%1181 = load <8 x float>, <8 x float>* %1180
%1182 = shufflevector <8 x float> %1181, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1183 = shufflevector <8 x float> %1181, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1184 = fmul <4 x float> %966, %1182
%1185 = bitcast float* %1177 to <4 x float>*
store <4 x float> %1184, <4 x float>* %1185
%1186 = fmul <4 x float> %967, %1183
%1187 = bitcast float* %1176 to <4 x float>*
store <4 x float> %1186, <4 x float>* %1187
%1188 = add nuw i64 %1161, 8
%1189 = add i64 %1162, 2
%1190 = icmp eq i64 %1189, %1159
br i1 %1190, label %1191, label %1160
1191: ; preds = %1160, %1147
%1192 = phi i64 [ 0, %1147 ], [ %1188, %1160 ]
%1193 = icmp eq i64 %1156, 0
br i1 %1193, label %1207, label %1194
1194: ; preds = %1191
%1195 = getelementptr float, float* %972, i64 %1192
%1196 = getelementptr float, float* %973, i64 %1192
%1197 = shl i64 %1192, 1
%1198 = getelementptr float, float* %1107, i64 %1197
%1199 = bitcast float* %1198 to <8 x float>*
%1200 = load <8 x float>, <8 x float>* %1199
%1201 = shufflevector <8 x float> %1200, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1202 = shufflevector <8 x float> %1200, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1203 = fmul <4 x float> %966, %1201
%1204 = bitcast float* %1196 to <4 x float>*
store <4 x float> %1203, <4 x float>* %1204
%1205 = fmul <4 x float> %967, %1202
%1206 = bitcast float* %1195 to <4 x float>*
store <4 x float> %1205, <4 x float>* %1206
br label %1207
1207: ; preds = %1191, %1194
%1208 = icmp eq i64 %1120, %1148
br i1 %1208, label %1226, label %1209
1209: ; preds = %1122, %1113, %1207
%1210 = phi float* [ %972, %1122 ], [ %972, %1113 ], [ %1149, %1207 ]
%1211 = phi float* [ %973, %1122 ], [ %973, %1113 ], [ %1150, %1207 ]
%1212 = phi float* [ %1107, %1122 ], [ %1107, %1113 ], [ %1152, %1207 ]
br label %1213
1213: ; preds = %1209, %1213
%1214 = phi float* [ %1224, %1213 ], [ %1210, %1209 ]
%1215 = phi float* [ %1220, %1213 ], [ %1211, %1209 ]
%1216 = phi float* [ %1221, %1213 ], [ %1212, %1209 ]
%1217 = getelementptr inbounds float, float* %1216, i64 1
%1218 = load float, float* %1216
%1219 = fmul float %968, %1218
%1220 = getelementptr inbounds float, float* %1215, i64 1
store float %1219, float* %1215
%1221 = getelementptr inbounds float, float* %1216, i64 2
%1222 = load float, float* %1217
%1223 = fmul float %969, %1222
%1224 = getelementptr inbounds float, float* %1214, i64 1
store float %1223, float* %1214
%1225 = icmp ult float* %1221, %1111
br i1 %1225, label %1213, label %1226
1226: ; preds = %1213, %1207, %1106
%1227 = phi float* [ %1107, %1106 ], [ %1152, %1207 ], [ %1221, %1213 ]
%1228 = phi float* [ %973, %1106 ], [ %1150, %1207 ], [ %1220, %1213 ]
%1229 = phi float* [ %972, %1106 ], [ %1149, %1207 ], [ %1224, %1213 ]
%1230 = icmp eq float* %1227, %1111
br i1 %1230, label %1231, label %1236
1231: ; preds = %1226
%1232 = getelementptr inbounds float, float* %1111, i64 1
%1233 = load float, float* %1111
%1234 = fmul float %970, %1233
%1235 = getelementptr inbounds float, float* %1228, i64 1
store float %1234, float* %1228
br label %1236
1236: ; preds = %1231, %1226
%1237 = phi float* [ %1232, %1231 ], [ %1227, %1226 ]
%1238 = phi float* [ %1235, %1231 ], [ %1228, %1226 ]
%1239 = add nuw nsw i32 %977, 2
%1240 = icmp slt i32 %1239, %950
br i1 %1240, label %971, label %1241
1241: ; preds = %1236
%1242 = and i32 %10, -2
br label %1243
1243: ; preds = %1241, %949
%1244 = phi i32 [ 0, %949 ], [ %1242, %1241 ]
%1245 = phi float* [ %943, %949 ], [ %1237, %1241 ]
%1246 = phi float* [ %944, %949 ], [ %1108, %1241 ]
%1247 = phi float* [ %945, %949 ], [ %1099, %1241 ]
%1248 = ptrtoint float* %1245 to i64
%1249 = ptrtoint float* %1245 to i64
%1250 = icmp eq i32 %1244, %950
br i1 %1250, label %1251, label %1384
1251: ; preds = %1243
%1252 = sext i32 %9 to i64
%1253 = getelementptr inbounds float, float* %1245, i64 %1252
%1254 = getelementptr inbounds float, float* %1253, i64 -1
%1255 = icmp ult float* %1245, %1254
br i1 %1255, label %1256, label %1376
1256: ; preds = %1251
%1257 = shl nsw i64 %1252, 2
%1258 = add i64 %1257, %1248
%1259 = add i64 %1258, -4
%1260 = add i64 %1248, 8
%1261 = call i64 @llvm.umax.i64(i64 %1259, i64 %1260)
%1262 = xor i64 %1248, -1
%1263 = add i64 %1261, %1262
%1264 = lshr i64 %1263, 3
%1265 = add nuw nsw i64 %1264, 1
%1266 = icmp ult i64 %1263, 24
br i1 %1266, label %1357, label %1267
1267: ; preds = %1256
%1268 = shl nsw i64 %1252, 2
%1269 = add i64 %1268, %1249
%1270 = add i64 %1269, -4
%1271 = add i64 %1249, 8
%1272 = call i64 @llvm.umax.i64(i64 %1270, i64 %1271)
%1273 = xor i64 %1249, -1
%1274 = add i64 %1272, %1273
%1275 = lshr i64 %1274, 3
%1276 = add nuw nsw i64 %1275, 1
%1277 = getelementptr float, float* %1246, i64 %1276
%1278 = getelementptr float, float* %1247, i64 %1276
%1279 = shl nuw nsw i64 %1275, 1
%1280 = add nuw nsw i64 %1279, 2
%1281 = getelementptr float, float* %1245, i64 %1280
%1282 = icmp ult float* %1246, %1278
%1283 = icmp ult float* %1247, %1277
%1284 = and i1 %1282, %1283
%1285 = icmp ult float* %1246, %1281
%1286 = icmp ult float* %1245, %1277
%1287 = and i1 %1285, %1286
%1288 = or i1 %1284, %1287
%1289 = icmp ult float* %1247, %1281
%1290 = icmp ult float* %1245, %1278
%1291 = and i1 %1289, %1290
%1292 = or i1 %1288, %1291
br i1 %1292, label %1357, label %1293
1293: ; preds = %1267
%1294 = and i64 %1265, 4611686018427387900
%1295 = getelementptr float, float* %1247, i64 %1294
%1296 = getelementptr float, float* %1246, i64 %1294
%1297 = shl nuw nsw i64 %1294, 1
%1298 = getelementptr float, float* %1245, i64 %1297
%1299 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%1300 = shufflevector <4 x float> %44, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
%1301 = add nsw i64 %1294, -4
%1302 = lshr exact i64 %1301, 2
%1303 = add nuw nsw i64 %1302, 1
%1304 = and i64 %1303, 1
%1305 = icmp eq i64 %1301, 0
br i1 %1305, label %1339, label %1306
1306: ; preds = %1293
%1307 = and i64 %1303, 9223372036854775806
br label %1308
1308: ; preds = %1308, %1306
%1309 = phi i64 [ 0, %1306 ], [ %1336, %1308 ]
%1310 = phi i64 [ 0, %1306 ], [ %1337, %1308 ]
%1311 = getelementptr float, float* %1247, i64 %1309
%1312 = getelementptr float, float* %1246, i64 %1309
%1313 = shl i64 %1309, 1
%1314 = getelementptr float, float* %1245, i64 %1313
%1315 = bitcast float* %1314 to <8 x float>*
%1316 = load <8 x float>, <8 x float>* %1315
%1317 = shufflevector <8 x float> %1316, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1318 = shufflevector <8 x float> %1316, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1319 = fmul <4 x float> %1299, %1317
%1320 = bitcast float* %1312 to <4 x float>*
store <4 x float> %1319, <4 x float>* %1320
%1321 = fmul <4 x float> %1300, %1318
%1322 = bitcast float* %1311 to <4 x float>*
store <4 x float> %1321, <4 x float>* %1322
%1323 = or i64 %1309, 4
%1324 = getelementptr float, float* %1247, i64 %1323
%1325 = getelementptr float, float* %1246, i64 %1323
%1326 = shl i64 %1323, 1
%1327 = getelementptr float, float* %1245, i64 %1326
%1328 = bitcast float* %1327 to <8 x float>*
%1329 = load <8 x float>, <8 x float>* %1328
%1330 = shufflevector <8 x float> %1329, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1331 = shufflevector <8 x float> %1329, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1332 = fmul <4 x float> %1299, %1330
%1333 = bitcast float* %1325 to <4 x float>*
store <4 x float> %1332, <4 x float>* %1333
%1334 = fmul <4 x float> %1300, %1331
%1335 = bitcast float* %1324 to <4 x float>*
store <4 x float> %1334, <4 x float>* %1335
%1336 = add nuw i64 %1309, 8
%1337 = add i64 %1310, 2
%1338 = icmp eq i64 %1337, %1307
br i1 %1338, label %1339, label %1308
1339: ; preds = %1308, %1293
%1340 = phi i64 [ 0, %1293 ], [ %1336, %1308 ]
%1341 = icmp eq i64 %1304, 0
br i1 %1341, label %1355, label %1342
1342: ; preds = %1339
%1343 = getelementptr float, float* %1247, i64 %1340
%1344 = getelementptr float, float* %1246, i64 %1340
%1345 = shl i64 %1340, 1
%1346 = getelementptr float, float* %1245, i64 %1345
%1347 = bitcast float* %1346 to <8 x float>*
%1348 = load <8 x float>, <8 x float>* %1347
%1349 = shufflevector <8 x float> %1348, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%1350 = shufflevector <8 x float> %1348, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%1351 = fmul <4 x float> %1299, %1349
%1352 = bitcast float* %1344 to <4 x float>*
store <4 x float> %1351, <4 x float>* %1352
%1353 = fmul <4 x float> %1300, %1350
%1354 = bitcast float* %1343 to <4 x float>*
store <4 x float> %1353, <4 x float>* %1354
br label %1355
1355: ; preds = %1339, %1342
%1356 = icmp eq i64 %1265, %1294
br i1 %1356, label %1376, label %1357
1357: ; preds = %1267, %1256, %1355
%1358 = phi float* [ %1247, %1267 ], [ %1247, %1256 ], [ %1295, %1355 ]
%1359 = phi float* [ %1246, %1267 ], [ %1246, %1256 ], [ %1296, %1355 ]
%1360 = phi float* [ %1245, %1267 ], [ %1245, %1256 ], [ %1298, %1355 ]
%1361 = extractelement <4 x float> %44, i64 2
%1362 = extractelement <4 x float> %44, i64 3
br label %1363
1363: ; preds = %1357, %1363
%1364 = phi float* [ %1374, %1363 ], [ %1358, %1357 ]
%1365 = phi float* [ %1370, %1363 ], [ %1359, %1357 ]
%1366 = phi float* [ %1371, %1363 ], [ %1360, %1357 ]
%1367 = getelementptr inbounds float, float* %1366, i64 1
%1368 = load float, float* %1366
%1369 = fmul float %1361, %1368
%1370 = getelementptr inbounds float, float* %1365, i64 1
store float %1369, float* %1365
%1371 = getelementptr inbounds float, float* %1366, i64 2
%1372 = load float, float* %1367
%1373 = fmul float %1362, %1372
%1374 = getelementptr inbounds float, float* %1364, i64 1
store float %1373, float* %1364
%1375 = icmp ult float* %1371, %1254
br i1 %1375, label %1363, label %1376
1376: ; preds = %1363, %1355, %1251
%1377 = phi float* [ %1245, %1251 ], [ %1298, %1355 ], [ %1371, %1363 ]
%1378 = phi float* [ %1246, %1251 ], [ %1296, %1355 ], [ %1370, %1363 ]
%1379 = icmp eq float* %1377, %1254
br i1 %1379, label %1380, label %1384
1380: ; preds = %1376
%1381 = load float, float* %1254
%1382 = extractelement <4 x float> %44, i64 2
%1383 = fmul float %1382, %1381
store float %1383, float* %1378
br label %1384
1384: ; preds = %1243, %1380, %1376, %941
ret void
}