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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
void bioR1_3dskip(float *LLL, float *vector, int xlength, int ylength,
                  int zlength, float X, float norm) {
  float *LLLptr;
  float *vptr, *vptrx0, *vptry0, *vptrz0, *vptrmem;
  float x_2;
  int dim;
  LLLptr = LLL +
           ((zlength + 1) >> 1) * ((ylength + 1) >> 1) * ((xlength + 1) >> 1) -
           1;
  vptr = vector + zlength * ylength * xlength - 1;
  dim = (xlength > 1) + (ylength > 1) + (zlength > 1);
  if (dim == 3) {
    x_2 = norm / (X * X);
  }
  if (dim == 2) {
    x_2 = norm / X;
  }
  if (dim == 1) {
    x_2 = norm;
  }
  if (dim == 0) {
    x_2 = X * norm;
  }
  vptrz0 = vector - 1;
  vptr = vptrz0 + zlength * ylength * xlength;
  vptry0 = vptr;
  vptrx0 = vptr;
  if (1 & zlength) {
    vptry0 -= xlength * ylength;
    if (1 & ylength) {
      vptrx0 -= xlength;
      vptrmem = vptrx0 + ((xlength + 1) >> 1);
      memset(vptrmem + 1, 0, (vptr - vptrmem) * sizeof(float));
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrmem) {
        vptr--;
        *(vptr--) = x_2 * *(LLLptr--);
      }
      while (vptr > vptrx0) {
        *vptr-- = 0;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
    vptrmem = vptry0 + ((xlength + 1) >> 1) * (ylength >> 1);
    memset(vptrmem + 1, 0, (vptr - vptrmem) * sizeof(float));
    while (vptrx0 > vptrmem) {
      vptrx0 -= 2 * xlength;
      vptr -= xlength;
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        vptr--;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
    while (vptrx0 > vptry0) {
      vptrx0 -= 2 * xlength;
      vptr -= xlength;
      memset(vptr, 0, xlength * sizeof(float));
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        *vptr-- = 0;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
  }
  vptrmem =
      vector + ((xlength + 1) >> 1) * ((ylength + 1) >> 1) * (zlength >> 1) - 1;
  memset(vptrmem + 1, 0, (vptr - vptrmem) * sizeof(float));
  vptrmem += 2 * xlength * ylength;
  while (vptry0 > vptrmem) {
    vptry0 -= 2 * xlength * ylength;
    vptrx0 -= xlength * ylength;
    vptr -= xlength * ylength;
    if (1 & ylength) {
      vptrx0 -= xlength;
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        vptr--;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
    while (vptrx0 > vptry0) {
      vptrx0 -= 2 * xlength;
      vptr -= xlength;
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        vptr--;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
  }
  while (vptry0 > vptrz0) {
    vptry0 -= 2 * xlength * ylength;
    vptrx0 -= xlength * ylength;
    vptr -= xlength * ylength;
    memset(vptr, 0, xlength * ylength * sizeof(float));
    if (1 & ylength) {
      vptrx0 -= xlength;
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        *vptr-- = 0;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
    vptrmem = vptry0 + ((xlength + 1) >> 1) * (ylength >> 1);
    memset(vptrmem + 1, 0, (vptr - vptrmem) * sizeof(float));
    vptrmem += 2 * xlength;
    while (vptrx0 > vptrmem) {
      vptrx0 -= 2 * xlength;
      vptr -= xlength;
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        vptr--;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
    while (vptrx0 > vptry0) {
      vptrx0 -= 2 * xlength;
      vptr -= xlength;
      memset(vptr, 0, xlength * sizeof(float));
      if (1 & xlength)
        *(vptr--) = x_2 * *(LLLptr--);
      while (vptr > vptrx0) {
        *vptr-- = 0;
        *(vptr--) = x_2 * *(LLLptr--);
      }
    }
  }
}


x86 assembly (clang, -O0):
<bioR1_3dskip>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
movss  %xmm1,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x1,-0x14(%rbp)
setg   %al
and    $0x1,%al
movzbl %al,%eax
cmpl   $0x1,-0x18(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
cmpl   $0x1,-0x1c(%rbp)
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x3,-0x60(%rbp)
jne    11db <bioR1_3dskip+0xcb>
movss  -0x24(%rbp),%xmm0
movss  -0x20(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x2,-0x60(%rbp)
jne    11f4 <bioR1_3dskip+0xe4>
movss  -0x24(%rbp),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x1,-0x60(%rbp)
jne    1208 <bioR1_3dskip+0xf8>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1221 <bioR1_3dskip+0x111>
movss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     15ed <bioR1_3dskip+0x4dd>
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     13d6 <bioR1_3dskip+0x2c6>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
add    $0x4,%rdi
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1329 <bioR1_3dskip+0x219>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    132e <bioR1_3dskip+0x21e>
mov    -0x38(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    1378 <bioR1_3dskip+0x268>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    132e <bioR1_3dskip+0x21e>
jmp    137d <bioR1_3dskip+0x26d>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    13d1 <bioR1_3dskip+0x2c1>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    137d <bioR1_3dskip+0x26d>
jmp    13d6 <bioR1_3dskip+0x2c6>
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
mov    -0x18(%rbp),%edx
sar    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
add    $0x4,%rdi
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    14f1 <bioR1_3dskip+0x3e1>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     149d <bioR1_3dskip+0x38d>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    14a2 <bioR1_3dskip+0x392>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    14ec <bioR1_3dskip+0x3dc>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    14a2 <bioR1_3dskip+0x392>
jmp    141e <bioR1_3dskip+0x30e>
jmp    14f6 <bioR1_3dskip+0x3e6>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    15e8 <bioR1_3dskip+0x4d8>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     158a <bioR1_3dskip+0x47a>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    158f <bioR1_3dskip+0x47f>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    15e3 <bioR1_3dskip+0x4d3>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    158f <bioR1_3dskip+0x47f>
jmp    14f6 <bioR1_3dskip+0x3e6>
jmp    15ed <bioR1_3dskip+0x4dd>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
sar    $0x1,%edx
imul   %edx,%ecx
mov    -0x1c(%rbp),%edx
sar    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
add    $0x4,%rdi
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    1860 <bioR1_3dskip+0x750>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1783 <bioR1_3dskip+0x673>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     172f <bioR1_3dskip+0x61f>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1734 <bioR1_3dskip+0x624>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    177e <bioR1_3dskip+0x66e>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1734 <bioR1_3dskip+0x624>
jmp    1783 <bioR1_3dskip+0x673>
jmp    1788 <bioR1_3dskip+0x678>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    185b <bioR1_3dskip+0x74b>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1807 <bioR1_3dskip+0x6f7>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    180c <bioR1_3dskip+0x6fc>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    1856 <bioR1_3dskip+0x746>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    180c <bioR1_3dskip+0x6fc>
jmp    1788 <bioR1_3dskip+0x678>
jmp    1661 <bioR1_3dskip+0x551>
jmp    1865 <bioR1_3dskip+0x755>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jbe    1bda <bioR1_3dskip+0xaca>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x18(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     19ab <bioR1_3dskip+0x89b>
mov    -0x14(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     194d <bioR1_3dskip+0x83d>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1952 <bioR1_3dskip+0x842>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    19a6 <bioR1_3dskip+0x896>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1952 <bioR1_3dskip+0x842>
jmp    19ab <bioR1_3dskip+0x89b>
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
mov    -0x18(%rbp),%edx
sar    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
add    $0x4,%rdi
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x58(%rbp),%rax
jbe    1ade <bioR1_3dskip+0x9ce>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1a8a <bioR1_3dskip+0x97a>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1a8f <bioR1_3dskip+0x97f>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    1ad9 <bioR1_3dskip+0x9c9>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1a8f <bioR1_3dskip+0x97f>
jmp    1a0b <bioR1_3dskip+0x8fb>
jmp    1ae3 <bioR1_3dskip+0x9d3>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    1bd5 <bioR1_3dskip+0xac5>
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1b77 <bioR1_3dskip+0xa67>
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1b7c <bioR1_3dskip+0xa6c>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jbe    1bd0 <bioR1_3dskip+0xac0>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
mulss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
jmp    1b7c <bioR1_3dskip+0xa6c>
jmp    1ae3 <bioR1_3dskip+0x9d3>
jmp    1865 <bioR1_3dskip+0x755>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bioR1_3dskip>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %ecx,%r12d
mov    %rsi,%rbp
lea    0x1(%r8),%ebx
lea    0x1(%r12),%eax
sar    %eax
lea    0x1(%rdx),%r9d
sar    %r9d
xor    %ecx,%ecx
mov    %rdx,%rsi
mov    %rdx,0x10(%rsp)
cmp    $0x2,%edx
setge  %cl
xor    %edx,%edx
cmp    $0x2,%r12d
setge  %dl
add    %ecx,%edx
xor    %ecx,%ecx
cmp    $0x2,%r8d
setge  %cl
add    %edx,%ecx
cmp    $0x3,%ecx
jne    116f <bioR1_3dskip+0x5f>
movaps %xmm0,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm1,%xmm2
divss  %xmm3,%xmm2
sar    %ebx
imul   %r9d,%eax
mov    %r12d,%edx
imul   0x10(%rsp),%edx
cmp    $0x2,%ecx
jne    1189 <bioR1_3dskip+0x79>
movaps %xmm1,%xmm2
divss  %xmm0,%xmm2
imul   %eax,%ebx
mov    %edx,%esi
imul   %r8d,%esi
movaps %xmm1,%xmm3
cmp    $0x1,%ecx
je     119d <bioR1_3dskip+0x8d>
movaps %xmm2,%xmm3
movslq %ebx,%rbx
movslq %esi,%rsi
test   %ecx,%ecx
jne    11ae <bioR1_3dskip+0x9e>
mulss  %xmm1,%xmm0
movaps %xmm0,%xmm3
movss  %xmm3,0xc(%rsp)
lea    (%rdi,%rbx,4),%r15
add    $0xfffffffffffffffc,%r15
lea    -0x4(,%rsi,4),%rbx
ff
add    %rbp,%rbx
add    $0xffffffffffffffff,%rsi
movslq %edx,%rdx
movslq 0x10(%rsp),%rcx
mov    %rcx,0x18(%rsp)
test   $0x1,%r8b
mov    %r12,0x58(%rsp)
mov    %r9d,0x48(%rsp)
mov    %rdx,0x50(%rsp)
jne    11fa <bioR1_3dskip+0xea>
mov    %rsi,0x38(%rsp)
mov    %rbx,%r13
jmp    1449 <bioR1_3dskip+0x339>
sub    %rdx,%rsi
lea    0x0(,%rsi,4),%rcx
add    %rbp,%rcx
mov    %rcx,0x40(%rsp)
test   $0x1,%r12b
mov    %rsi,0x38(%rsp)
mov    %r8,0x30(%rsp)
mov    %eax,0x28(%rsp)
jne    1229 <bioR1_3dskip+0x119>
mov    %rbx,%r13
jmp    12e1 <bioR1_3dskip+0x1d1>
mov    0x18(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rbx,%r13
sub    %rax,%r13
movslq %r9d,%rax
lea    0x0(,%rax,4),%r14
add    %r13,%r14
lea    0x4(,%rax,4),%rdi
add    %r13,%rdi
mov    %ebx,%edx
sub    %r14d,%edx
xor    %esi,%esi
call   1030 <memset@plt>
testb  $0x1,0x10(%rsp)
jne    1270 <bioR1_3dskip+0x160>
movss  0xc(%rsp),%xmm1
jmp    128b <bioR1_3dskip+0x17b>
movss  (%r15),%xmm0
movss  0xc(%rsp),%xmm1
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
cmp    %r14,%rbx
mov    0x48(%rsp),%r9d
jbe    12dc <bioR1_3dskip+0x1cc>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r14,%rbx
ja     12a0 <bioR1_3dskip+0x190>
jmp    12dc <bioR1_3dskip+0x1cc>
nopl   (%rax)
movl   $0x0,(%rbx)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     12c0 <bioR1_3dskip+0x1b0>
mov    %r12d,%eax
sar    %eax
imul   %r9d,%eax
cltq
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%r14
lea    (%rcx,%rax,4),%rdi
add    $0x4,%rdi
mov    %ebx,%edx
sub    %r14d,%edx
xor    %esi,%esi
call   1030 <memset@plt>
cmp    %r14,%r13
jbe    137d <bioR1_3dskip+0x26d>
mov    0x10(%rsp),%rax
add    %eax,%eax
cltq
neg    %rax
mov    0x18(%rsp),%rcx
neg    %rcx
movss  0xc(%rsp),%xmm1
jmp    1335 <bioR1_3dskip+0x225>
nopw   0x0(%rax,%rax,1)
cmp    %r14,%r13
jbe    137d <bioR1_3dskip+0x26d>
lea    (%rbx,%rcx,4),%rbx
testb  $0x1,0x10(%rsp)
je     1355 <bioR1_3dskip+0x245>
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%rax,4),%r13
cmp    %r13,%rbx
jbe    1330 <bioR1_3dskip+0x220>
nop
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     1360 <bioR1_3dskip+0x250>
jmp    1330 <bioR1_3dskip+0x220>
cmp    0x40(%rsp),%r13
jbe    1440 <bioR1_3dskip+0x330>
mov    %rbp,0x20(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rcx,1),%eax
movslq %eax,%r14
neg    %r14
mov    0x18(%rsp),%rbp
neg    %rbp
lea    0x0(,%rcx,4),%r12d
jmp    13b7 <bioR1_3dskip+0x2a7>
nopl   (%rax)
cmp    0x40(%rsp),%r13
jbe    1436 <bioR1_3dskip+0x326>
lea    (%rbx,%rbp,4),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1030 <memset@plt>
testb  $0x1,0x10(%rsp)
jne    13e0 <bioR1_3dskip+0x2d0>
movss  0xc(%rsp),%xmm1
jmp    13fb <bioR1_3dskip+0x2eb>
nopw   0x0(%rax,%rax,1)
movss  (%r15),%xmm0
movss  0xc(%rsp),%xmm1
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%r14,4),%r13
cmp    %r13,%rbx
jbe    13b0 <bioR1_3dskip+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rbx)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     1410 <bioR1_3dskip+0x300>
jmp    13b0 <bioR1_3dskip+0x2a0>
mov    0x58(%rsp),%r12
mov    0x20(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%eax
sar    %r8d
imul   %r8d,%eax
cltq
lea    0x0(,%rax,4),%r14
add    %rbp,%r14
lea    -0x4(,%rax,4),%rax
ff
add    %rbp,%rax
mov    %ebx,%edx
sub    %eax,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x10(%rsp),%rax
add    %eax,%eax
movslq %eax,%r9
imul   %r12d,%eax
cltq
mov    %rax,0x30(%rsp)
lea    (%r14,%rax,4),%r8
add    $0xfffffffffffffffc,%r8
mov    0x38(%rsp),%rax
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
cmp    %r8,%rcx
jbe    15a0 <bioR1_3dskip+0x490>
mov    0x50(%rsp),%rcx
neg    %rcx
mov    0x18(%rsp),%rdx
neg    %rdx
mov    %r9,%rsi
neg    %rsi
movss  0xc(%rsp),%xmm1
jmp    14d9 <bioR1_3dskip+0x3c9>
nopw   0x0(%rax,%rax,1)
cmp    %r8,%rdi
jbe    15a0 <bioR1_3dskip+0x490>
sub    0x30(%rsp),%rax
lea    0x0(%r13,%rcx,4),%r13
lea    (%rbx,%rcx,4),%rbx
test   $0x1,%r12b
jne    1550 <bioR1_3dskip+0x440>
lea    0x0(,%rax,4),%rdi
add    %rbp,%rdi
nopl   0x0(%rax,%rax,1)
cmp    %rdi,%r13
jbe    14d0 <bioR1_3dskip+0x3c0>
lea    (%rbx,%rdx,4),%rbx
testb  $0x1,0x10(%rsp)
je     1525 <bioR1_3dskip+0x415>
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%rsi,4),%r13
cmp    %r13,%rbx
jbe    1500 <bioR1_3dskip+0x3f0>
nop
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     1530 <bioR1_3dskip+0x420>
jmp    1500 <bioR1_3dskip+0x3f0>
nopl   (%rax)
testb  $0x1,0x10(%rsp)
je     156c <bioR1_3dskip+0x45c>
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%rdx,4),%r13
cmp    %r13,%rbx
jbe    14ed <bioR1_3dskip+0x3dd>
nopw   0x0(%rax,%rax,1)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     1580 <bioR1_3dskip+0x470>
jmp    14ed <bioR1_3dskip+0x3dd>
mov    %r9,0x28(%rsp)
test   %rax,%rax
js     1806 <bioR1_3dskip+0x6f6>
mov    %rax,%rcx
mov    0x50(%rsp),%rax
mov    %rax,%rdx
neg    %rdx
mov    %rdx,0x60(%rsp)
shl    $0x2,%eax
mov    %rax,0x50(%rsp)
negq   0x18(%rsp)
mov    %r12d,%eax
sar    %eax
mov    0x48(%rsp),%edx
imul   %eax,%edx
movslq %edx,%rax
mov    %rax,0x48(%rsp)
mov    0x28(%rsp),%r14
neg    %r14
mov    0x10(%rsp),%rax
lea    0x0(,%rax,4),%eax
mov    %eax,0x40(%rsp)
mov    %rbp,0x20(%rsp)
nop
sub    0x30(%rsp),%rcx
mov    %rcx,0x38(%rsp)
mov    %r12,%rbp
mov    0x60(%rsp),%r12
lea    (%rbx,%r12,4),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x50(%rsp),%rdx
call   1030 <memset@plt>
lea    0x0(%r13,%r12,4),%r13
test   $0x1,%bpl
jne    1790 <bioR1_3dskip+0x680>
mov    0x20(%rsp),%rbp
mov    0x38(%rsp),%rax
lea    0x0(,%rax,4),%r12
add    %rbp,%r12
mov    0x48(%rsp),%rax
lea    (%r12,%rax,4),%rbp
lea    (%r12,%rax,4),%rdi
add    $0x4,%rdi
mov    %ebx,%edx
sub    %ebp,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x28(%rsp),%rax
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
cmp    %rax,%r13
mov    0x10(%rsp),%rbp
movss  0xc(%rsp),%xmm1
jbe    1771 <bioR1_3dskip+0x661>
jmp    1699 <bioR1_3dskip+0x589>
nopl   0x0(%rax,%rax,1)
cmp    %rax,%r13
jbe    1771 <bioR1_3dskip+0x661>
mov    0x18(%rsp),%rcx
lea    (%rbx,%rcx,4),%rbx
test   $0x1,%bpl
je     16bd <bioR1_3dskip+0x5ad>
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%r14,4),%r13
cmp    %r13,%rbx
jbe    1690 <bioR1_3dskip+0x580>
nopw   0x0(%rax,%rax,1)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     16d0 <bioR1_3dskip+0x5c0>
jmp    1690 <bioR1_3dskip+0x580>
nopl   (%rax)
mov    0x18(%rsp),%rax
lea    (%rbx,%rax,4),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x40(%rsp),%edx
call   1030 <memset@plt>
test   $0x1,%bpl
jne    1720 <bioR1_3dskip+0x610>
movss  0xc(%rsp),%xmm1
jmp    173b <bioR1_3dskip+0x62b>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15),%xmm0
movss  0xc(%rsp),%xmm1
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
lea    0x0(%r13,%r14,4),%r13
cmp    %r13,%rbx
jbe    1771 <bioR1_3dskip+0x661>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rbx)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     1750 <bioR1_3dskip+0x640>
cmp    %r12,%r13
ja     16f0 <bioR1_3dskip+0x5e0>
mov    0x38(%rsp),%rcx
test   %rcx,%rcx
mov    0x58(%rsp),%r12
jns    1600 <bioR1_3dskip+0x4f0>
jmp    1806 <bioR1_3dskip+0x6f6>
nop
testb  $0x1,0x10(%rsp)
jne    17a0 <bioR1_3dskip+0x690>
movss  0xc(%rsp),%xmm1
jmp    17bb <bioR1_3dskip+0x6ab>
nop
movss  (%r15),%xmm0
movss  0xc(%rsp),%xmm1
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,(%rbx)
add    $0xfffffffffffffffc,%rbx
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%rax
lea    0x0(%r13,%rax,4),%r13
cmp    %r13,%rbx
jbe    1639 <bioR1_3dskip+0x529>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,(%rbx)
movss  (%r15),%xmm0
mulss  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r15
movss  %xmm0,-0x4(%rbx)
add    $0xfffffffffffffff8,%rbx
cmp    %r13,%rbx
ja     17e0 <bioR1_3dskip+0x6d0>
jmp    1639 <bioR1_3dskip+0x529>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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