#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 */
double drand48();
float sqrt(float);
void elipse(float *x, float *z, int nxp, float dx, float dz, float **gridcp,
            float **gridcs, float **gridro, float **cp, float **cs, float **ro,
            float *interface, int *zp, int nz, int nx, float r1, float r2,
            float gradcp, float gradcs, float gradro) {
  int i, ix, iz, ixr, izr, ixm, izm;
  float r, zr, xr;
  izr = ((int)((r1 / dz) > 0.0 ? (r1 / dz) + 0.5 : (r1 / dz) - 0.5));
  ixr = ((int)((r2 / dx) > 0.0 ? (r2 / dx) + 0.5 : (r2 / dx) - 0.5));
  for (i = 0; i < nx; i++) {
    interface[i] = 0.0;
    zp[i] = 0;
  }
  if (gridcs == NULL && gridro == NULL) {
    for (i = 0; i < nxp; i++) {
      ixm = ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5));
      izm = ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      interface[ixm] = z[i];
      zp[ixm] = izm;
      for (ix = ((ixm - ixr) > (0) ? (ixm - ixr) : (0));
           ix <= ((ixm + ixr) < (nx - 1) ? (ixm + ixr) : (nx - 1)); ix++) {
        for (iz = ((izm - izr) > (0) ? (izm - izr) : (0));
             iz <= ((izm + izr) < (nz - 1) ? (izm + izr) : (nz - 1)); iz++) {
          xr = (ix - ixm) * dx / r2;
          zr = (iz - izm) * dz / r1;
          r = sqrt(xr * xr + zr * zr);
          if (r <= 1.0) {
            gridcp[ix][iz] = cp[2][i];
            if (gradcp != 0)
              gridcp[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradcp;
          }
        }
      }
    }
  } else if (gridcs == NULL) {
    for (i = 0; i < nxp; i++) {
      ixm = ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5));
      izm = ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      interface[ixm] = z[i];
      zp[ixm] = izm;
      for (ix = ((ixm - ixr) > (0) ? (ixm - ixr) : (0));
           ix <= ((ixm + ixr) < (nx - 1) ? (ixm + ixr) : (nx - 1)); ix++) {
        for (iz = ((izm - izr) > (0) ? (izm - izr) : (0));
             iz <= ((izm + izr) < (nz - 1) ? (izm + izr) : (nz - 1)); iz++) {
          xr = (ix - ixm) * dx / r2;
          zr = (iz - izm) * dz / r1;
          r = sqrt(xr * xr + zr * zr);
          if (r <= 1.0) {
            gridcp[ix][iz] = cp[2][i];
            gridro[ix][iz] = ro[2][i];
            if (gradcp != 0)
              gridcp[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradcp;
            if (gradro != 0)
              gridro[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradro;
          }
        }
      }
    }
  } else {
    for (i = 0; i < nxp; i++) {
      ixm = ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5));
      izm = ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      interface[ixm] = z[i];
      zp[ixm] = izm;
      for (ix = ((ixm - ixr) > (0) ? (ixm - ixr) : (0));
           ix <= ((ixm + ixr) < (nx - 1) ? (ixm + ixr) : (nx - 1)); ix++) {
        for (iz = ((izm - izr) > (0) ? (izm - izr) : (0));
             iz <= ((izm + izr) < (nz - 1) ? (izm + izr) : (nz - 1)); iz++) {
          xr = (ix - ixm) * dx / r2;
          zr = (iz - izm) * dz / r1;
          r = sqrt(xr * xr + zr * zr);
          if (r <= 1.0) {
            gridcp[ix][iz] = cp[2][i];
            gridro[ix][iz] = ro[2][i];
            gridcs[ix][iz] = cs[2][i];
            if (gradcp != 0)
              gridcp[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradcp;
            if (gradcs != 0)
              gridcs[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradcs;
            if (gradro != 0)
              gridro[ix][iz] += (float)(drand48() - 0.5) * 2.0 * gradro;
          }
        }
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<elipse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movss  %xmm2,-0x3c(%rbp)
movss  %xmm3,-0x40(%rbp)
movss  %xmm4,-0x44(%rbp)
movss  %xmm5,-0x48(%rbp)
movss  %xmm6,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    11be <elipse+0x9e>
movss  -0x3c(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe50(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    11dd <elipse+0xbd>
movss  -0x3c(%rbp),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe2c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x60(%rbp)
movss  -0x40(%rbp),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    122b <elipse+0x10b>
movss  -0x40(%rbp),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde6(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    124d <elipse+0x12d>
movss  -0x40(%rbp),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdbf(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    129c <elipse+0x17c>
mov    0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1263 <elipse+0x143>
cmpq   $0x0,-0x30(%rbp)
jne    165d <elipse+0x53d>
cmpq   $0x0,-0x38(%rbp)
jne    165d <elipse+0x53d>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1658 <elipse+0x538>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1317 <elipse+0x1f7>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcfa(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1341 <elipse+0x221>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xccb(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13a2 <elipse+0x282>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc6f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    13cc <elipse+0x2ac>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc40(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
cmp    $0x0,%eax
jle    1423 <elipse+0x303>
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1430 <elipse+0x310>
xor    %eax,%eax
mov    %eax,-0x9c(%rbp)
jmp    1430 <elipse+0x310>
mov    -0x9c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1467 <elipse+0x347>
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    1473 <elipse+0x353>
mov    0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0xa4(%rbp),%ecx
cmp    %ecx,%eax
jg     1645 <elipse+0x525>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jle    14a7 <elipse+0x387>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    14b4 <elipse+0x394>
xor    %eax,%eax
mov    %eax,-0xa8(%rbp)
jmp    14b4 <elipse+0x394>
mov    -0xa8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14eb <elipse+0x3cb>
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0xb0(%rbp)
jmp    14f7 <elipse+0x3d7>
mov    0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xb0(%rbp),%ecx
cmp    %ecx,%eax
jg     1632 <elipse+0x512>
mov    -0x54(%rbp),%eax
sub    -0x64(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x18(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa94(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     161f <elipse+0x4ff>
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    15c0 <elipse+0x4a0>
jp     15c0 <elipse+0x4a0>
jmp    161a <elipse+0x4fa>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0xa31(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa2d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    161f <elipse+0x4ff>
jmp    1624 <elipse+0x504>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14bd <elipse+0x39d>
jmp    1637 <elipse+0x517>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1439 <elipse+0x319>
jmp    164a <elipse+0x52a>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12b9 <elipse+0x199>
jmp    1f97 <elipse+0xe77>
cmpq   $0x0,-0x30(%rbp)
jne    1aaf <elipse+0x98f>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1aaa <elipse+0x98a>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16cd <elipse+0x5ad>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x944(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    16f7 <elipse+0x5d7>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x915(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1758 <elipse+0x638>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8b9(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1782 <elipse+0x662>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x88a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
cmp    $0x0,%eax
jle    17d9 <elipse+0x6b9>
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    17e6 <elipse+0x6c6>
xor    %eax,%eax
mov    %eax,-0xc4(%rbp)
jmp    17e6 <elipse+0x6c6>
mov    -0xc4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    181d <elipse+0x6fd>
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    1829 <elipse+0x709>
mov    0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0xcc(%rbp),%ecx
cmp    %ecx,%eax
jg     1a97 <elipse+0x977>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jle    185d <elipse+0x73d>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    186a <elipse+0x74a>
xor    %eax,%eax
mov    %eax,-0xd0(%rbp)
jmp    186a <elipse+0x74a>
mov    -0xd0(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    18a1 <elipse+0x781>
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    18ad <elipse+0x78d>
mov    0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd4(%rbp),%eax
mov    -0xd8(%rbp),%ecx
cmp    %ecx,%eax
jg     1a84 <elipse+0x964>
mov    -0x54(%rbp),%eax
sub    -0x64(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x18(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x6de(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1a71 <elipse+0x951>
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    199c <elipse+0x87c>
jp     199c <elipse+0x87c>
jmp    19f6 <elipse+0x8d6>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0x655(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x651(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1a12 <elipse+0x8f2>
jp     1a12 <elipse+0x8f2>
jmp    1a6c <elipse+0x94c>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0x5df(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5db(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1a71 <elipse+0x951>
jmp    1a76 <elipse+0x956>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1873 <elipse+0x753>
jmp    1a89 <elipse+0x969>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    17ef <elipse+0x6cf>
jmp    1a9c <elipse+0x97c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    166f <elipse+0x54f>
jmp    1f92 <elipse+0xe72>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f8d <elipse+0xe6d>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b14 <elipse+0x9f4>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4fd(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1b3e <elipse+0xa1e>
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4ce(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b9f <elipse+0xa7f>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x472(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1bc9 <elipse+0xaa9>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x443(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
cmp    $0x0,%eax
jle    1c20 <elipse+0xb00>
mov    -0x64(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0xec(%rbp)
jmp    1c2d <elipse+0xb0d>
xor    %eax,%eax
mov    %eax,-0xec(%rbp)
jmp    1c2d <elipse+0xb0d>
mov    -0xec(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1c64 <elipse+0xb44>
mov    -0x64(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0xf4(%rbp)
jmp    1c70 <elipse+0xb50>
mov    0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf0(%rbp),%eax
mov    -0xf4(%rbp),%ecx
cmp    %ecx,%eax
jg     1f7a <elipse+0xe5a>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jle    1ca4 <elipse+0xb84>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    1cb1 <elipse+0xb91>
xor    %eax,%eax
mov    %eax,-0xf8(%rbp)
jmp    1cb1 <elipse+0xb91>
mov    -0xf8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ce8 <elipse+0xbc8>
mov    -0x68(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x100(%rbp)
jmp    1cf4 <elipse+0xbd4>
mov    0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x100(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x100(%rbp),%ecx
cmp    %ecx,%eax
jg     1f67 <elipse+0xe47>
mov    -0x54(%rbp),%eax
sub    -0x64(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x18(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cvtsi2ss %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
divss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x297(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1f54 <elipse+0xe34>
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e09 <elipse+0xce9>
jp     1e09 <elipse+0xce9>
jmp    1e63 <elipse+0xd43>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0x1e8(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e4(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e7f <elipse+0xd5f>
jp     1e7f <elipse+0xd5f>
jmp    1ed9 <elipse+0xdb9>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0x172(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1ef5 <elipse+0xdd5>
jp     1ef5 <elipse+0xdd5>
jmp    1f4f <elipse+0xe2f>
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  0xfc(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf8(%rip),%xmm1
mulsd  %xmm1,%xmm0
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1f54 <elipse+0xe34>
jmp    1f59 <elipse+0xe39>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1cba <elipse+0xb9a>
jmp    1f6c <elipse+0xe4c>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1c36 <elipse+0xb16>
jmp    1f7f <elipse+0xe5f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1ab6 <elipse+0x996>
jmp    1f92 <elipse+0xe72>
jmp    1f97 <elipse+0xe77>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<elipse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movss  %xmm6,0x18(%rsp)
movss  %xmm5,0x40(%rsp)
movss  %xmm4,0x14(%rsp)
mov    %r9,0x30(%rsp)
mov    %rcx,%r12
mov    %rsi,0x78(%rsp)
mov    %rdi,0x70(%rsp)
movaps %xmm3,0xc0(%rsp)
movaps %xmm3,%xmm5
movaps %xmm2,0xd0(%rsp)
unpcklps %xmm2,%xmm5
movaps %xmm0,0x80(%rsp)
movaps %xmm1,0x90(%rsp)
unpcklps %xmm1,%xmm0
divps  %xmm0,%xmm5
movaps %xmm5,%xmm3
shufps $0x55,%xmm5,%xmm3
xorps  %xmm0,%xmm0
cmpltps %xmm5,%xmm0
unpcklps %xmm0,%xmm0
movmskpd %xmm0,%eax
movsd  0xe62(%rip),%xmm0
movsd  0xe62(%rip),%xmm4
movapd %xmm0,%xmm1
test   $0x2,%al
jne    11b2 <elipse+0x92>
movapd %xmm4,%xmm1
cvtss2sd %xmm3,%xmm3
mov    0x170(%rsp),%ecx
mov    %ecx,0x10(%rsp)
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
test   $0x1,%al
jne    11d0 <elipse+0xb0>
movapd %xmm4,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm3,%xmm1
mov    0x160(%rsp),%r9
mov    0x158(%rsp),%rsi
cmpl   $0x0,0x170(%rsp)
jle    1308 <elipse+0x1e8>
mov    0x170(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    120b <elipse+0xeb>
xor    %ecx,%ecx
jmp    12f0 <elipse+0x1d0>
mov    %r8,%r10
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    1233 <elipse+0x113>
xor    %ebp,%ebp
jmp    12a0 <elipse+0x180>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
xorps  %xmm2,%xmm2
nopl   0x0(%rax)
movups %xmm2,(%rsi,%rbp,4)
movups %xmm2,0x10(%rsi,%rbp,4)
movups %xmm2,(%r9,%rbp,4)
movups %xmm2,0x10(%r9,%rbp,4)
movups %xmm2,0x20(%rsi,%rbp,4)
movups %xmm2,0x30(%rsi,%rbp,4)
movups %xmm2,0x20(%r9,%rbp,4)
movups %xmm2,0x30(%r9,%rbp,4)
movups %xmm2,0x40(%rsi,%rbp,4)
movups %xmm2,0x50(%rsi,%rbp,4)
movups %xmm2,0x40(%r9,%rbp,4)
movups %xmm2,0x50(%r9,%rbp,4)
movups %xmm2,0x60(%rsi,%rbp,4)
movups %xmm2,0x70(%rsi,%rbp,4)
movups %xmm2,0x60(%r9,%rbp,4)
movups %xmm2,0x70(%r9,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1240 <elipse+0x120>
test   %r8,%r8
je     12dc <elipse+0x1bc>
lea    (%r9,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rsi,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %ebx,%ebx
xorps  %xmm2,%xmm2
xchg   %ax,%ax
movups %xmm2,-0x10(%rbp,%rbx,1)
movups %xmm2,0x0(%rbp,%rbx,1)
movups %xmm2,-0x10(%rdi,%rbx,1)
movups %xmm2,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    12c0 <elipse+0x1a0>
cmp    %rax,%rcx
mov    %r10,%r8
je     1308 <elipse+0x1e8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%rsi,%rcx,4)
movl   $0x0,(%r9,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12f0 <elipse+0x1d0>
mov    0x168(%rsp),%eax
mov    %eax,0xc(%rsp)
cvttsd2si %xmm1,%eax
mov    %rax,0x60(%rsp)
cvttsd2si %xmm0,%eax
mov    %rax,0x68(%rsp)
mov    %r8,%rax
or     0x30(%rsp),%rax
jne    15b7 <elipse+0x497>
test   %edx,%edx
jle    1c79 <elipse+0xb59>
addl   $0xffffffff,0x10(%rsp)
addl   $0xffffffff,0xc(%rsp)
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
mov    %edx,%eax
mov    %rax,0x20(%rsp)
movaps 0x90(%rsp),%xmm0
unpcklps 0x80(%rsp),%xmm0
movaps %xmm0,0xa0(%rsp)
movsd  0xc84(%rip),%xmm3
xor    %ebp,%ebp
jmp    13a7 <elipse+0x287>
add    $0x1,%rbp
cmp    0x20(%rsp),%rbp
mov    0x160(%rsp),%r9
mov    0x158(%rsp),%rsi
movsd  0xc5f(%rip),%xmm3
je     1c79 <elipse+0xb59>
mov    0x78(%rsp),%rax
movss  (%rax,%rbp,4),%xmm0
mov    0x70(%rsp),%rax
movss  (%rax,%rbp,4),%xmm2
movaps %xmm0,%xmm1
unpcklps %xmm2,%xmm1
divps  0xa0(%rsp),%xmm1
xorps  %xmm2,%xmm2
cmpltps %xmm1,%xmm2
unpcklps %xmm2,%xmm2
movmskpd %xmm2,%eax
movapd %xmm3,%xmm2
test   $0x2,%al
jne    13e7 <elipse+0x2c7>
movsd  0xc21(%rip),%xmm2
test   $0x1,%al
jne    13f3 <elipse+0x2d3>
movsd  0xc15(%rip),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
shufps $0x55,%xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm2
cvttsd2si %xmm2,%edi
addsd  %xmm3,%xmm4
cvttsd2si %xmm4,%ebx
movslq %edi,%rax
movss  %xmm0,(%rsi,%rax,4)
mov    %ebx,(%r9,%rax,4)
mov    0x68(%rsp),%rcx
sub    %ecx,%eax
mov    $0x0,%edx
cmovs  %edx,%eax
mov    %rdi,0x38(%rsp)
lea    (%rdi,%rcx,1),%edx
mov    0x10(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0x18(%rsp)
cmp    %edx,%eax
jg     1380 <elipse+0x260>
mov    %ebx,%esi
mov    0x60(%rsp),%rcx
sub    %ecx,%esi
mov    $0x0,%edx
cmovs  %edx,%esi
mov    %rsi,0x28(%rsp)
lea    (%rbx,%rcx,1),%edx
mov    0xc(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0x40(%rsp)
lea    0x1(%rdx),%r14d
mov    %eax,%r15d
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
neg    %ebx
jmp    149f <elipse+0x37f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x18(%rsp),%r15
je     1380 <elipse+0x260>
mov    0x40(%rsp),%rax
cmp    %eax,0x28(%rsp)
jg     1490 <elipse+0x370>
mov    %r15d,%eax
sub    0x38(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x80(%rsp),%xmm0
divss  0xc0(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
mov    0x28(%rsp),%r13
jmp    14e9 <elipse+0x3c9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r13,%r14
je     1490 <elipse+0x370>
lea    (%rbx,%r13,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0x90(%rsp),%xmm1
divss  0xd0(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0x30(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss 0xaf5(%rip),%xmm0
jb     1530 <elipse+0x410>
sqrtss %xmm0,%xmm0
jmp    1535 <elipse+0x415>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
movss  0xad3(%rip),%xmm1
ucomiss %xmm0,%xmm1
jb     14e0 <elipse+0x3c0>
movss  0x14(%rsp),%xmm0
ucomiss 0xac5(%rip),%xmm0
mov    0x140(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%rbp,4),%xmm0
mov    (%r12,%r15,8),%rax
movss  %xmm0,(%rax,%r13,4)
jne    1572 <elipse+0x452>
jnp    14e0 <elipse+0x3c0>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0xa87(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x50(%rsp),%xmm0
mov    (%r12,%r15,8),%rax
movss  (%rax,%r13,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%r13,4)
jmp    14e0 <elipse+0x3c0>
test   %r8,%r8
je     196d <elipse+0x84d>
mov    %r8,0x28(%rsp)
test   %edx,%edx
jle    1c79 <elipse+0xb59>
addl   $0xffffffff,0x10(%rsp)
addl   $0xffffffff,0xc(%rsp)
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x38(%rsp)
movss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    %edx,%eax
mov    %rax,0xe0(%rsp)
movaps 0x90(%rsp),%xmm0
unpcklps 0x80(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
movsd  0x9cc(%rip),%xmm3
xor    %ebp,%ebp
jmp    166a <elipse+0x54a>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    0xe0(%rsp),%rbp
mov    0x160(%rsp),%r9
mov    0x158(%rsp),%rsi
movsd  0x99c(%rip),%xmm3
je     1c79 <elipse+0xb59>
mov    0x78(%rsp),%rax
movss  (%rax,%rbp,4),%xmm0
mov    0x70(%rsp),%rax
movss  (%rax,%rbp,4),%xmm2
movaps %xmm0,%xmm1
unpcklps %xmm2,%xmm1
divps  0xf0(%rsp),%xmm1
xorps  %xmm2,%xmm2
cmpltps %xmm1,%xmm2
unpcklps %xmm2,%xmm2
movmskpd %xmm2,%eax
movapd %xmm3,%xmm2
test   $0x2,%al
jne    16aa <elipse+0x58a>
movsd  0x95e(%rip),%xmm2
test   $0x1,%al
jne    16b6 <elipse+0x596>
movsd  0x952(%rip),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
shufps $0x55,%xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm2
cvttsd2si %xmm2,%edi
addsd  %xmm3,%xmm4
cvttsd2si %xmm4,%r15d
movslq %edi,%rax
movss  %xmm0,(%rsi,%rax,4)
mov    %r15d,(%r9,%rax,4)
mov    0x68(%rsp),%rcx
sub    %ecx,%eax
mov    $0x0,%edx
cmovs  %edx,%eax
mov    %rdi,0xe8(%rsp)
lea    (%rdi,%rcx,1),%edx
mov    0x10(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0x48(%rsp)
cmp    %edx,%eax
jg     1640 <elipse+0x520>
mov    %r15d,%esi
mov    0x60(%rsp),%rcx
sub    %ecx,%esi
mov    $0x0,%edx
cmovs  %edx,%esi
mov    %rsi,0x58(%rsp)
lea    (%r15,%rcx,1),%edx
mov    0xc(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0xb0(%rsp)
lea    0x1(%rdx),%r14d
mov    %eax,%r13d
mov    0x48(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x48(%rsp)
neg    %r15d
jmp    176f <elipse+0x64f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x48(%rsp),%r13
je     1640 <elipse+0x520>
mov    0xb0(%rsp),%rax
cmp    %eax,0x58(%rsp)
jg     1760 <elipse+0x640>
mov    %r13d,%eax
sub    0xe8(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x80(%rsp),%xmm0
divss  0xc0(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
mov    0x58(%rsp),%rbx
jmp    17b9 <elipse+0x699>
nopl   (%rax)
add    $0x1,%rbx
cmp    %rbx,%r14
je     1760 <elipse+0x640>
lea    (%r15,%rbx,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0x90(%rsp),%xmm1
divss  0xd0(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss 0x825(%rip),%xmm0
jb     1800 <elipse+0x6e0>
sqrtss %xmm0,%xmm0
jmp    1805 <elipse+0x6e5>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
movss  0x803(%rip),%xmm1
ucomiss %xmm0,%xmm1
jb     17b0 <elipse+0x690>
movss  0x14(%rsp),%xmm0
ucomiss 0x7f5(%rip),%xmm0
mov    0x140(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%rbp,4),%xmm0
mov    (%r12,%r13,8),%rax
movss  %xmm0,(%rax,%rbx,4)
mov    0x150(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%rbp,4),%xmm0
mov    0x30(%rsp),%rax
mov    (%rax,%r13,8),%rax
movss  %xmm0,(%rax,%rbx,4)
mov    0x148(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%rbp,4),%xmm0
mov    0x28(%rsp),%rax
mov    (%rax,%r13,8),%rax
movss  %xmm0,(%rax,%rbx,4)
jne    187b <elipse+0x75b>
jnp    18b9 <elipse+0x799>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x77e(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x38(%rsp),%xmm0
mov    (%r12,%r13,8),%rax
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x40(%rsp),%xmm0
ucomiss 0x74e(%rip),%xmm0
jne    18ca <elipse+0x7aa>
jnp    190d <elipse+0x7ed>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x72f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x20(%rsp),%xmm0
mov    0x28(%rsp),%rax
mov    (%rax,%r13,8),%rax
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x18(%rsp),%xmm0
ucomiss 0x6fa(%rip),%xmm0
jne    1922 <elipse+0x802>
jnp    17b0 <elipse+0x690>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x6d7(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0xa0(%rsp),%xmm0
mov    0x30(%rsp),%rax
mov    (%rax,%r13,8),%rax
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%rbx,4)
jmp    17b0 <elipse+0x690>
test   %edx,%edx
jle    1c79 <elipse+0xb59>
addl   $0xffffffff,0x10(%rsp)
addl   $0xffffffff,0xc(%rsp)
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
mov    %edx,%eax
mov    %rax,0x48(%rsp)
movaps 0x90(%rsp),%xmm0
unpcklps 0x80(%rsp),%xmm0
movaps %xmm0,0xb0(%rsp)
movsd  0x63a(%rip),%xmm3
xor    %r14d,%r14d
jmp    19f7 <elipse+0x8d7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x48(%rsp),%r14
mov    0x160(%rsp),%r9
mov    0x158(%rsp),%rsi
movsd  0x60f(%rip),%xmm3
je     1c79 <elipse+0xb59>
mov    0x78(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
mov    0x70(%rsp),%rax
movss  (%rax,%r14,4),%xmm2
movaps %xmm0,%xmm1
unpcklps %xmm2,%xmm1
divps  0xb0(%rsp),%xmm1
xorps  %xmm2,%xmm2
cmpltps %xmm1,%xmm2
unpcklps %xmm2,%xmm2
movmskpd %xmm2,%eax
movapd %xmm3,%xmm2
test   $0x2,%al
jne    1a39 <elipse+0x919>
movsd  0x5cf(%rip),%xmm2
test   $0x1,%al
jne    1a45 <elipse+0x925>
movsd  0x5c3(%rip),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm1,%xmm4
shufps $0x55,%xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm2
cvttsd2si %xmm2,%edi
addsd  %xmm3,%xmm4
cvttsd2si %xmm4,%ebp
movslq %edi,%rax
movss  %xmm0,(%rsi,%rax,4)
mov    %ebp,(%r9,%rax,4)
mov    0x68(%rsp),%rcx
sub    %ecx,%eax
mov    $0x0,%edx
cmovs  %edx,%eax
mov    %rdi,0x58(%rsp)
lea    (%rdi,%rcx,1),%edx
mov    0x10(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0x20(%rsp)
cmp    %edx,%eax
jg     19d0 <elipse+0x8b0>
mov    %ebp,%esi
mov    0x60(%rsp),%rcx
sub    %ecx,%esi
mov    $0x0,%edx
cmovs  %edx,%esi
mov    %rsi,0x38(%rsp)
lea    (%rcx,%rbp,1),%edx
mov    0xc(%rsp),%ecx
cmp    %ecx,%edx
cmovge %ecx,%edx
mov    %rdx,0xa0(%rsp)
lea    0x1(%rdx),%r13d
mov    %eax,%r15d
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
neg    %ebp
jmp    1aef <elipse+0x9cf>
nop
add    $0x1,%r15
cmp    0x20(%rsp),%r15
je     19d0 <elipse+0x8b0>
mov    0xa0(%rsp),%rax
cmp    %eax,0x38(%rsp)
jg     1ae0 <elipse+0x9c0>
mov    %r15d,%eax
sub    0x58(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  0x80(%rsp),%xmm0
divss  0xc0(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
mov    0x38(%rsp),%rbx
jmp    1b39 <elipse+0xa19>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r13
je     1ae0 <elipse+0x9c0>
lea    (%rbx,%rbp,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mulss  0x90(%rsp),%xmm1
divss  0xd0(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss 0x4a6(%rip),%xmm0
jb     1b80 <elipse+0xa60>
sqrtss %xmm0,%xmm0
jmp    1b85 <elipse+0xa65>
cs nopw 0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
movss  0x483(%rip),%xmm1
ucomiss %xmm0,%xmm1
jb     1b30 <elipse+0xa10>
movss  0x14(%rsp),%xmm0
ucomiss 0x475(%rip),%xmm0
mov    0x140(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    (%r12,%r15,8),%rax
movss  %xmm0,(%rax,%rbx,4)
mov    0x150(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0x30(%rsp),%rax
mov    (%rax,%r15,8),%rax
movss  %xmm0,(%rax,%rbx,4)
jne    1bde <elipse+0xabe>
jnp    1c1c <elipse+0xafc>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x41b(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x28(%rsp),%xmm0
mov    (%r12,%r15,8),%rax
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%rbx,4)
movss  0x18(%rsp),%xmm0
ucomiss 0x3eb(%rip),%xmm0
jne    1c31 <elipse+0xb11>
jnp    1b30 <elipse+0xa10>
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x3c8(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x40(%rsp),%xmm0
mov    0x30(%rsp),%rax
mov    (%rax,%r15,8),%rax
movss  (%rax,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rax,%rbx,4)
jmp    1b30 <elipse+0xa10>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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