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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float sqrt(float);
int to_ribbon(int num, float xt[], float yt[], float zt[], int itint[],
              float xn[], float yn[], float zn[]) {
  int i, it, ip, il, ih;
  int iuu, imm, idd, iu, id;
  float ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez;
  float cc, dd, ee;
  float scale;
  float xr[5000], yr[5000], zr[5000];
  int itinr[5000];
  scale = 2.0 / 150.0;
  for (i = 0; i < num; i++) {
    xr[i] = xt[i];
    yr[i] = yt[i];
    zr[i] = zt[i];
    itinr[i] = itint[i];
  }
  il = 0;
  ih = num;
  for (i = il; i < ih; i++) {
    it = 2 * i - 0;
    ip = it + 1;
    if (ih - il <= 2) {
      xt[it] = xr[i];
      yt[it] = yr[i];
      zt[it] = zr[i];
      xn[it] = 1.0;
      yn[it] = 0.0;
      zn[it] = 0.0;
      itint[it] = 0;
      xt[ip] = xr[i];
      yt[ip] = yr[i];
      zt[ip] = zr[i];
      xn[ip] = 1.0;
      yn[ip] = 0.0;
      zn[ip] = 0.0;
      itint[ip] = itinr[i];
    } else {
      iuu = i + 1;
      imm = i;
      idd = i - 1;
      if (i == il) {
        iuu = i + 2;
        imm = i + 1;
        idd = i;
      }
      if (i == ih - 1) {
        iuu = i;
        imm = i - 1;
        idd = i - 2;
      }
      ax = xr[iuu] - xr[imm];
      ay = yr[iuu] - yr[imm];
      az = zr[iuu] - zr[imm];
      bx = xr[imm] - xr[idd];
      by = yr[imm] - yr[idd];
      bz = zr[imm] - zr[idd];
      cx = ay * bz - az * by;
      cy = az * bx - ax * bz;
      cz = ax * by - ay * bx;
      cc = sqrt(cx * cx + cy * cy + cz * cz);
      if (cc < 0.0000000001)
        cc = 0.0000000001;
      cc = 1.0 / cc;
      xn[ip] = cx * cc;
      yn[ip] = cy * cc;
      zn[ip] = cz * cc;
      iu = i + 1;
      id = i - 1;
      if (i == il)
        id = i;
      if (i == ih - 1)
        iu = i;
      dx = xr[iu] - xr[id];
      dy = yr[iu] - yr[id];
      dz = zr[iu] - zr[id];
      dd = sqrt(dx * dx + dy * dy + dz * dz);
      if (dd < 0.0000000001)
        dd = 0.0000000001;
      dd = 1.0 / dd;
      xn[it] = dx * dd;
      yn[it] = dy * dd;
      zn[it] = dz * dd;
    }
  }
  if (ih - il < 2)
    return 0;
  cx = 0.0;
  cy = 0.0;
  cz = 0.0;
  for (i = il; i < ih; i++) {
    it = 2 * i - 0;
    ip = it + 1;
    ax = xn[ip];
    ay = yn[ip];
    az = zn[ip];
    if (ax * cx + ay * cy + az * cz > 0.0) {
      cx = cx + ax;
      cy = cy + ay;
      cz = cz + az;
    } else {
      cx = cx - ax;
      cy = cy - ay;
      cz = cz - az;
    }
    dx = xn[it];
    dy = yn[it];
    dz = zn[it];
    dd = cx * dx + cy * dy + cz * dz;
    cx = cx - dd * dx;
    cy = cy - dd * dy;
    cz = cz - dd * dz;
    cc = sqrt(cx * cx + cy * cy + cz * cz);
    if (cc < 0.0000000001)
      cc = 0.0000000001;
    cc = 10.0 / cc;
    cx = cx * cc;
    cy = cy * cc;
    cz = cz * cc;
    xt[it] = cx;
    yt[it] = cy;
    zt[it] = cz;
  }
  for (i = il; i < ih; i++) {
    it = 2 * i - 0;
    ip = it + 1;
    cx = xt[it];
    cy = yt[it];
    cz = zt[it];
    dx = xn[it];
    dy = yn[it];
    dz = zn[it];
    cc = scale / 10.0;
    cx = cx * cc;
    cy = cy * cc;
    cz = cz * cc;
    ex = cy * dz - cz * dy;
    ey = cz * dx - cx * dz;
    ez = cx * dy - cy * dx;
    ee = sqrt(ex * ex + ey * ey + ez * ez);
    if (ee < 0.0000000001)
      ee = 0.0000000001;
    ee = 1.0 / ee;
    ex = ex * ee;
    ey = ey * ee;
    ez = ez * ee;
    xt[it] = xr[i] - cx;
    yt[it] = yr[i] - cy;
    zt[it] = zr[i] - cz;
    xn[it] = ex;
    yn[it] = ey;
    zn[it] = ez;
    itint[it] = 0;
    xt[ip] = xr[i] + cx;
    yt[ip] = yr[i] + cy;
    zt[ip] = zr[i] + cz;
    xn[ip] = ex;
    yn[ip] = ey;
    zn[ip] = ez;
    itint[ip] = itinr[i];
  }
  return num * 2;
}


x86 assembly (clang, -O0):
<to_ribbon>:
push   %rbp
mov    %rsp,%rbp
sub    $0x13930,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  0xebe(%rip),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11cf <to_ribbon+0xbf>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x34(%rbp),%rax
movss  %xmm0,-0x4ed0(%rbp,%rax,4)
ff ff
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x34(%rbp),%rax
movss  %xmm0,-0x9cf0(%rbp,%rax,4)
ff ff
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x34(%rbp),%rax
movss  %xmm0,-0xeb10(%rbp,%rax,4)
ff ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0x13930(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1151 <to_ribbon+0x41>
movl   $0x0,-0x40(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1764 <to_ribbon+0x654>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
sub    $0x0,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x2,%eax
jg     1342 <to_ribbon+0x232>
movslq -0x34(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  0xd98(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  0xd06(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
mov    -0x13930(%rbp,%rax,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1751 <to_ribbon+0x641>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    137e <to_ribbon+0x26e>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    13a7 <to_ribbon+0x297>
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x50(%rbp)
movslq -0x48(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
subss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x5c(%rbp)
movslq -0x48(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
subss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x60(%rbp)
movslq -0x48(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
subss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x64(%rbp)
movslq -0x4c(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x50(%rbp),%rax
subss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x68(%rbp)
movslq -0x4c(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x50(%rbp),%rax
subss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x6c(%rbp)
movslq -0x4c(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movslq -0x50(%rbp),%rax
subss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x70(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x64(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x78(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xad6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1554 <to_ribbon+0x444>
movss  0xab8(%rip),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xab8(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    15ea <to_ribbon+0x4da>
mov    -0x34(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1601 <to_ribbon+0x4f1>
mov    -0x34(%rbp),%eax
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x58(%rbp),%rax
subss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x80(%rbp)
movslq -0x54(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x58(%rbp),%rax
subss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x84(%rbp)
ff
movslq -0x54(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movslq -0x58(%rbp),%rax
subss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x951(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16d9 <to_ribbon+0x5c9>
movss  0x933(%rip),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x933(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x9c(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1756 <to_ribbon+0x646>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11e2 <to_ribbon+0xd2>
mov    -0x44(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x2,%eax
jge    177f <to_ribbon+0x66f>
movl   $0x0,-0x4(%rbp)
jmp    1e88 <to_ribbon+0xd78>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a9b <to_ribbon+0x98b>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
sub    $0x0,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x60(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1865 <to_ribbon+0x755>
movss  -0x74(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    1892 <to_ribbon+0x782>
movss  -0x74(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x74(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x78(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x74(%rbp),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm1
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x78(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x7c(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x62d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    19fd <to_ribbon+0x8ed>
movss  0x60f(%rip),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x607(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    179d <to_ribbon+0x68d>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1e7f <to_ribbon+0xd6f>
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
sub    $0x0,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x4d0(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x7c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x74(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x90(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x382(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ca8 <to_ribbon+0xb98>
movss  0x364(%rip),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x364(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
movslq -0x34(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
subss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
subss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
subss  -0x7c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x4ed0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x74(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0x9cf0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
movss  -0xeb10(%rbp,%rax,4),%xmm0
ff ff
addss  -0x7c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x34(%rbp),%rax
mov    -0x13930(%rbp,%rax,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1aa1 <to_ribbon+0x991>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x13930,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<to_ribbon>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138e8,%rsp
test   %edi,%edi
jle    1702 <to_ribbon+0x5e2>
mov    %r9,%rbx
mov    %r8,%r13
mov    %rcx,%r14
mov    %rdx,%rbp
mov    %edi,%eax
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,4),%r15
mov    %rdi,0x10(%rsp)
lea    0x9ca0(%rsp),%rdi
mov    %rsi,0x18(%rsp)
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    0x4e80(%rsp),%rdi
mov    %rbp,0x50(%rsp)
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    0x60(%rsp),%rdi
mov    %r14,0x58(%rsp)
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
lea    0xeac0(%rsp),%rdi
mov    %r13,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
mov    0x10(%rsp),%r8
lea    -0x1(%r8),%r9d
xorps  %xmm8,%xmm8
movss  0xe3d(%rip),%xmm7
movsd  0xe4c(%rip),%xmm13
xor    %r15d,%r15d
mov    %r9,0x30(%rsp)
mov    %r13,0x48(%rsp)
jmp    1290 <to_ribbon+0x170>
xchg   %ax,%ax
movss  0x9ca0(%rsp,%r15,4),%xmm0
mov    0x18(%rsp),%rsi
movss  %xmm0,(%rsi,%r14,4)
movss  0x4e80(%rsp,%r15,4),%xmm1
mov    0x50(%rsp),%rdx
movss  %xmm1,(%rdx,%r14,4)
movss  0x60(%rsp,%r15,4),%xmm2
mov    0x58(%rsp),%rax
movss  %xmm2,(%rax,%r14,4)
movl   $0x3f800000,(%rbx,%r14,4)
3f
mov    0x13920(%rsp),%rcx
movl   $0x0,(%rcx,%r14,4)
mov    0x13928(%rsp),%rdi
movl   $0x0,(%rdi,%r14,4)
movl   $0x0,0x0(%r13,%r14,4)
movss  %xmm0,(%rsi,%rbp,4)
movss  %xmm1,(%rdx,%rbp,4)
movss  %xmm2,(%rax,%rbp,4)
movl   $0x3f800000,(%rbx,%rbp,4)
movl   $0x0,(%rcx,%rbp,4)
movl   $0x0,(%rdi,%rbp,4)
mov    0xeac0(%rsp,%r15,4),%eax
mov    %eax,0x0(%r13,%rbp,4)
add    $0x1,%r15
mov    %r15,%r12
cmp    0x20(%rsp),%r12
je     1546 <to_ribbon+0x426>
lea    (%r15,%r15,1),%r14
lea    (%r15,%r15,1),%rbp
add    $0x1,%rbp
cmp    $0x2,%r8d
jbe    11e0 <to_ribbon+0xc0>
lea    0x1(%r15),%r12
lea    -0x1(%r15),%eax
test   %r15,%r15
mov    %r12,%rcx
mov    $0x2,%edx
cmove  %rdx,%rcx
mov    %r15d,%edx
mov    $0x1,%esi
cmove  %esi,%edx
mov    %eax,%r13d
mov    $0x0,%esi
cmove  %esi,%r13d
lea    -0x2(%r15),%esi
cmp    %r9,%r15
cmove  %r15,%rcx
cmove  %eax,%edx
cmovne %r13d,%esi
mov    %ecx,%eax
shl    $0x2,%rax
movss  0x9ca0(%rsp,%rax,1),%xmm0
movslq %edx,%rcx
movss  0x9ca0(%rsp,%rcx,4),%xmm1
subss  %xmm1,%xmm0
movss  0x4e80(%rsp,%rax,1),%xmm2
movss  0x4e80(%rsp,%rcx,4),%xmm4
subss  %xmm4,%xmm2
movss  0x60(%rsp,%rax,1),%xmm6
movss  0x60(%rsp,%rcx,4),%xmm3
subss  %xmm3,%xmm6
movslq %esi,%rax
subss  0x9ca0(%rsp,%rax,4),%xmm1
subss  0x4e80(%rsp,%rax,4),%xmm4
subss  0x60(%rsp,%rax,4),%xmm3
movaps %xmm4,%xmm5
mulss  %xmm6,%xmm5
mulss  %xmm1,%xmm6
mulss  %xmm2,%xmm1
mulss  %xmm3,%xmm2
subss  %xmm5,%xmm2
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm0,%xmm4
subss  %xmm1,%xmm4
movaps %xmm6,%xmm0
mulss  %xmm6,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm8,%xmm0
jb     13a0 <to_ribbon+0x280>
sqrtss %xmm0,%xmm0
jmp    13e3 <to_ribbon+0x2c3>
cs nopw 0x0(%rax,%rax,1)
movss  %xmm4,0x4(%rsp)
movss  %xmm6,0xc(%rsp)
movss  %xmm2,0x8(%rsp)
call   1040 <sqrt@plt>
movss  0x8(%rsp),%xmm2
movss  0xc(%rsp),%xmm6
movss  0x4(%rsp),%xmm4
movss  0xc2f(%rip),%xmm7
xorps  %xmm8,%xmm8
mov    0x30(%rsp),%r9
movsd  0xc35(%rip),%xmm13
mov    0x13928(%rsp),%rdx
mov    0x13920(%rsp),%rsi
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm1,%xmm13
movaps %xmm7,%xmm1
ja     1410 <to_ribbon+0x2f0>
movss  0xbf8(%rip),%xmm1
divss  %xmm0,%xmm1
xor    %eax,%eax
cmp    %r9,%r15
setne  %al
mulss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%rbp,4)
mulss  %xmm1,%xmm6
movss  %xmm6,(%rsi,%rbp,4)
mulss  %xmm1,%xmm4
movss  %xmm4,(%rdx,%rbp,4)
add    %eax,%r15d
movss  0x9ca0(%rsp,%r15,4),%xmm2
movslq %r13d,%rax
subss  0x9ca0(%rsp,%rax,4),%xmm2
movss  0x4e80(%rsp,%r15,4),%xmm3
subss  0x4e80(%rsp,%rax,4),%xmm3
movss  0x60(%rsp,%r15,4),%xmm4
subss  0x60(%rsp,%rax,4),%xmm4
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm8,%xmm0
jb     14a0 <to_ribbon+0x380>
sqrtss %xmm0,%xmm0
jmp    14f3 <to_ribbon+0x3d3>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm2,0x4(%rsp)
movss  %xmm3,0xc(%rsp)
movss  %xmm4,0x8(%rsp)
call   1040 <sqrt@plt>
movss  0x8(%rsp),%xmm4
movss  0xc(%rsp),%xmm3
movss  0x4(%rsp),%xmm2
movss  0xb2f(%rip),%xmm7
xorps  %xmm8,%xmm8
mov    0x30(%rsp),%r9
movsd  0xb35(%rip),%xmm13
mov    0x13920(%rsp),%rsi
mov    0x13928(%rsp),%rdx
mov    0x48(%rsp),%r13
mov    0x10(%rsp),%r8
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm1,%xmm13
movaps %xmm7,%xmm1
ja     151a <to_ribbon+0x3fa>
movss  0xaee(%rip),%xmm1
divss  %xmm0,%xmm1
mulss  %xmm1,%xmm2
movss  %xmm2,(%rbx,%r14,4)
mulss  %xmm1,%xmm3
movss  %xmm3,(%rsi,%r14,4)
mulss  %xmm1,%xmm4
movss  %xmm4,(%rdx,%r14,4)
mov    %r12,%r15
cmp    0x20(%rsp),%r12
jne    1290 <to_ribbon+0x170>
xor    %eax,%eax
cmp    $0x2,%r8d
jl     1948 <to_ribbon+0x828>
xorps  %xmm6,%xmm6
xorps  %xmm9,%xmm9
xor    %ebp,%ebp
movss  0xaa4(%rip),%xmm8
xorps  %xmm7,%xmm7
mov    0x58(%rsp),%r14
mov    0x50(%rsp),%r15
mov    0x18(%rsp),%rdx
mov    0x13928(%rsp),%rsi
mov    0x13920(%rsp),%rdi
jmp    15c2 <to_ribbon+0x4a2>
nopl   0x0(%rax,%rax,1)
mulss  %xmm1,%xmm7
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
movss  %xmm7,(%rdx,%rbp,8)
movss  %xmm6,(%r15,%rbp,8)
movss  %xmm0,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,0x20(%rsp)
je     1709 <to_ribbon+0x5e9>
movss  0x4(%rbx,%rbp,8),%xmm2
movss  0x4(%rdi,%rbp,8),%xmm0
movss  0x4(%rsi,%rbp,8),%xmm1
movaps %xmm6,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm2,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm3,%xmm4
movaps %xmm6,%xmm3
shufps $0x55,%xmm6,%xmm3
mulss  %xmm1,%xmm3
addss  %xmm4,%xmm3
ucomiss %xmm9,%xmm3
jbe    1610 <to_ribbon+0x4f0>
addss  %xmm2,%xmm7
unpcklps %xmm1,%xmm0
addps  %xmm0,%xmm6
jmp    161a <to_ribbon+0x4fa>
nopw   0x0(%rax,%rax,1)
subss  %xmm2,%xmm7
unpcklps %xmm1,%xmm0
subps  %xmm0,%xmm6
movss  (%rbx,%rbp,8),%xmm0
movss  (%rdi,%rbp,8),%xmm1
movss  (%rsi,%rbp,8),%xmm2
movaps %xmm6,%xmm3
mulss  %xmm1,%xmm3
movaps %xmm7,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
movaps %xmm6,%xmm3
shufps $0x55,%xmm6,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm7
shufps $0x0,%xmm3,%xmm3
unpcklps %xmm2,%xmm1
mulps  %xmm3,%xmm1
subps  %xmm1,%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
movaps %xmm6,%xmm1
mulss  %xmm6,%xmm1
movaps %xmm7,%xmm2
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
ucomiss %xmm9,%xmm0
jb     1690 <to_ribbon+0x570>
sqrtss %xmm0,%xmm0
jmp    16db <to_ribbon+0x5bb>
nopl   0x0(%rax)
movaps %xmm6,0x30(%rsp)
movss  %xmm7,0x4(%rsp)
call   1040 <sqrt@plt>
movss  0x4(%rsp),%xmm7
movss  0x959(%rip),%xmm8
xorps  %xmm9,%xmm9
movaps 0x30(%rsp),%xmm6
movsd  0x957(%rip),%xmm13
mov    0x13920(%rsp),%rdi
mov    0x13928(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%r8
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm1,%xmm13
movaps %xmm8,%xmm1
ja     1590 <to_ribbon+0x470>
movss  0x913(%rip),%xmm1
divss  %xmm0,%xmm1
jmp    1590 <to_ribbon+0x470>
xor    %eax,%eax
jmp    1948 <to_ribbon+0x828>
test   %r8d,%r8d
jle    1942 <to_ribbon+0x822>
shlq   $0x2,0x20(%rsp)
xor    %ebp,%ebp
movss  0x8ee(%rip),%xmm4
xorps  %xmm8,%xmm8
movss  0x8d2(%rip),%xmm7
jmp    17f9 <to_ribbon+0x6d9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulss  %xmm1,%xmm6
mulss  %xmm1,%xmm5
mulss  %xmm1,%xmm12
movss  0x9ca0(%rsp,%rbp,1),%xmm0
movaps %xmm0,%xmm1
subss  %xmm9,%xmm1
movss  %xmm1,(%rdx,%rbp,2)
movss  0x4e80(%rsp,%rbp,1),%xmm1
movaps %xmm1,%xmm2
subss  %xmm10,%xmm2
movss  %xmm2,(%r15,%rbp,2)
movss  0x60(%rsp,%rbp,1),%xmm2
movaps %xmm2,%xmm3
subss  %xmm11,%xmm3
movss  %xmm3,(%r14,%rbp,2)
movss  %xmm6,(%rbx,%rbp,2)
movss  %xmm5,(%rdi,%rbp,2)
movss  %xmm12,(%rsi,%rbp,2)
movl   $0x0,0x0(%r13,%rbp,2)
addss  %xmm0,%xmm9
movss  %xmm9,0x4(%rdx,%rbp,2)
addss  %xmm1,%xmm10
movss  %xmm10,0x4(%r15,%rbp,2)
addss  %xmm2,%xmm11
movss  %xmm11,0x4(%r14,%rbp,2)
movss  %xmm6,0x4(%rbx,%rbp,2)
movss  %xmm5,0x4(%rdi,%rbp,2)
movss  %xmm12,0x4(%rsi,%rbp,2)
mov    0xeac0(%rsp,%rbp,1),%eax
mov    %eax,0x4(%r13,%rbp,2)
add    $0x4,%rbp
cmp    %rbp,0x20(%rsp)
je     1942 <to_ribbon+0x822>
movss  (%rbx,%rbp,2),%xmm0
movss  (%rdi,%rbp,2),%xmm1
movss  (%rsi,%rbp,2),%xmm2
movss  (%rdx,%rbp,2),%xmm9
mulss  %xmm4,%xmm9
movss  (%r15,%rbp,2),%xmm10
mulss  %xmm4,%xmm10
movss  (%r14,%rbp,2),%xmm11
mulss  %xmm4,%xmm11
movaps %xmm9,%xmm12
mulss  %xmm1,%xmm12
mulss  %xmm11,%xmm1
movaps %xmm10,%xmm6
mulss  %xmm2,%xmm6
subss  %xmm1,%xmm6
mulss  %xmm9,%xmm2
movaps %xmm11,%xmm5
mulss  %xmm0,%xmm5
subss  %xmm2,%xmm5
mulss  %xmm10,%xmm0
subss  %xmm0,%xmm12
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
movaps %xmm6,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
movaps %xmm12,%xmm0
mulss  %xmm12,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm8,%xmm0
jb     1890 <to_ribbon+0x770>
sqrtss %xmm0,%xmm0
jmp    191c <to_ribbon+0x7fc>
nopl   0x0(%rax)
movss  %xmm12,0x30(%rsp)
movss  %xmm9,0x4(%rsp)
movss  %xmm10,0xc(%rsp)
movss  %xmm11,0x8(%rsp)
movss  %xmm6,0x2c(%rsp)
movss  %xmm5,0x28(%rsp)
call   1040 <sqrt@plt>
movss  0x2c(%rsp),%xmm6
movss  0x8(%rsp),%xmm11
movss  0xc(%rsp),%xmm10
movss  0x4(%rsp),%xmm9
movss  0x30(%rsp),%xmm12
movss  0x719(%rip),%xmm7
xorps  %xmm8,%xmm8
movss  0x71d(%rip),%xmm4
movsd  0x71c(%rip),%xmm13
movss  0x28(%rsp),%xmm5
mov    0x13920(%rsp),%rdi
mov    0x13928(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%r8
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd %xmm1,%xmm13
movaps %xmm7,%xmm1
ja     1740 <to_ribbon+0x620>
movss  0x6cb(%rip),%xmm1
divss  %xmm0,%xmm1
jmp    1740 <to_ribbon+0x620>
add    %r8d,%r8d
mov    %r8d,%eax
add    $0x138e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @to_ribbon(i32 %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, i32* nocapture %4, float* nocapture %5, float* nocapture %6, float* nocapture %7) {
%9 = alloca [5000 x float]
%10 = bitcast [5000 x float]* %9 to i8*
%11 = alloca [5000 x float]
%12 = bitcast [5000 x float]* %11 to i8*
%13 = alloca [5000 x float]
%14 = bitcast [5000 x float]* %13 to i8*
%15 = alloca [5000 x i32]
%16 = bitcast [5000 x i32]* %15 to i8*
%17 = icmp sgt i32 %0, 0
br i1 %17, label %18, label %301
18: ; preds = %8
%19 = bitcast i32* %4 to i8*
%20 = bitcast float* %3 to i8*
%21 = bitcast float* %2 to i8*
%22 = bitcast float* %1 to i8*
%23 = zext i32 %0 to i64
%24 = shl nuw nsw i64 %23, 2
%25 = icmp ult i32 %0, 3
%26 = add nsw i32 %0, -1
%27 = zext i32 %26 to i64
%28 = zext i32 %0 to i64
br label %29
29: ; preds = %18, %156
%30 = phi i64 [ 0, %18 ], [ %157, %156 ]
%31 = shl nuw nsw i64 %30, 1
%32 = or i64 %31, 1
br i1 %25, label %33, label %57
33: ; preds = %29
%34 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %30
%35 = load float, float* %34
%36 = getelementptr inbounds float, float* %1, i64 %31
store float %35, float* %36
%37 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %30
%38 = load float, float* %37
%39 = getelementptr inbounds float, float* %2, i64 %31
store float %38, float* %39
%40 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %30
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %3, i64 %31
store float %41, float* %42
%43 = getelementptr inbounds float, float* %5, i64 %31
store float 1.000000e+00, float* %43
%44 = getelementptr inbounds float, float* %6, i64 %31
store float 0.000000e+00, float* %44
%45 = getelementptr inbounds float, float* %7, i64 %31
store float 0.000000e+00, float* %45
%46 = getelementptr inbounds i32, i32* %4, i64 %31
store i32 0, i32* %46
%47 = getelementptr inbounds float, float* %1, i64 %32
store float %35, float* %47
%48 = getelementptr inbounds float, float* %2, i64 %32
store float %38, float* %48
%49 = getelementptr inbounds float, float* %3, i64 %32
store float %41, float* %49
%50 = getelementptr inbounds float, float* %5, i64 %32
store float 1.000000e+00, float* %50
%51 = getelementptr inbounds float, float* %6, i64 %32
store float 0.000000e+00, float* %51
%52 = getelementptr inbounds float, float* %7, i64 %32
store float 0.000000e+00, float* %52
%53 = getelementptr inbounds [5000 x i32], [5000 x i32]* %15, i64 0, i64 %30
%54 = load i32, i32* %53
%55 = getelementptr inbounds i32, i32* %4, i64 %32
store i32 %54, i32* %55
%56 = add nuw nsw i64 %30, 1
br label %156
57: ; preds = %29
%58 = trunc i64 %30 to i32
%59 = add nuw nsw i64 %30, 1
%60 = icmp eq i64 %30, 0
%61 = select i1 %60, i64 2, i64 %59
%62 = select i1 %60, i32 1, i32 %58
%63 = trunc i64 %30 to i32
%64 = add i32 %63, -1
%65 = select i1 %60, i32 0, i32 %64
%66 = icmp eq i64 %30, %27
%67 = select i1 %66, i64 %30, i64 %61
%68 = select i1 %66, i32 %64, i32 %62
%69 = trunc i64 %30 to i32
%70 = add i32 %69, -2
%71 = select i1 %66, i32 %70, i32 %65
%72 = and i64 %67, 4294967295
%73 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %72
%74 = load float, float* %73
%75 = sext i32 %68 to i64
%76 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %75
%77 = load float, float* %76
%78 = fsub float %74, %77
%79 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %72
%80 = load float, float* %79
%81 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %75
%82 = load float, float* %81
%83 = fsub float %80, %82
%84 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %72
%85 = load float, float* %84
%86 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %75
%87 = load float, float* %86
%88 = fsub float %85, %87
%89 = sext i32 %71 to i64
%90 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %89
%91 = load float, float* %90
%92 = fsub float %77, %91
%93 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %89
%94 = load float, float* %93
%95 = fsub float %82, %94
%96 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %89
%97 = load float, float* %96
%98 = fsub float %87, %97
%99 = fneg float %88
%100 = fmul float %95, %99
%101 = tail call float @llvm.fmuladd.f32(float %83, float %98, float %100)
%102 = fneg float %78
%103 = fmul float %98, %102
%104 = tail call float @llvm.fmuladd.f32(float %88, float %92, float %103)
%105 = fneg float %83
%106 = fmul float %92, %105
%107 = tail call float @llvm.fmuladd.f32(float %78, float %95, float %106)
%108 = fmul float %104, %104
%109 = tail call float @llvm.fmuladd.f32(float %101, float %101, float %108)
%110 = tail call float @llvm.fmuladd.f32(float %107, float %107, float %109)
%111 = tail call float @sqrt(float %110)
%112 = fpext float %111 to double
%113 = fcmp olt double %112, 1.000000e-10
%114 = fdiv float 1.000000e+00, %111
%115 = select i1 %113, float 1.000000e+10, float %114
%116 = fmul float %101, %115
%117 = getelementptr inbounds float, float* %5, i64 %32
store float %116, float* %117
%118 = fmul float %104, %115
%119 = getelementptr inbounds float, float* %6, i64 %32
store float %118, float* %119
%120 = fmul float %107, %115
%121 = getelementptr inbounds float, float* %7, i64 %32
store float %120, float* %121
%122 = xor i1 %66, true
%123 = zext i1 %122 to i64
%124 = add i64 %30, %123
%125 = and i64 %124, 4294967295
%126 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %125
%127 = load float, float* %126
%128 = sext i32 %65 to i64
%129 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %128
%130 = load float, float* %129
%131 = fsub float %127, %130
%132 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %125
%133 = load float, float* %132
%134 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %128
%135 = load float, float* %134
%136 = fsub float %133, %135
%137 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %125
%138 = load float, float* %137
%139 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %128
%140 = load float, float* %139
%141 = fsub float %138, %140
%142 = fmul float %136, %136
%143 = tail call float @llvm.fmuladd.f32(float %131, float %131, float %142)
%144 = tail call float @llvm.fmuladd.f32(float %141, float %141, float %143)
%145 = tail call float @sqrt(float %144)
%146 = fpext float %145 to double
%147 = fcmp olt double %146, 1.000000e-10
%148 = fdiv float 1.000000e+00, %145
%149 = select i1 %147, float 1.000000e+10, float %148
%150 = fmul float %131, %149
%151 = getelementptr inbounds float, float* %5, i64 %31
store float %150, float* %151
%152 = fmul float %136, %149
%153 = getelementptr inbounds float, float* %6, i64 %31
store float %152, float* %153
%154 = fmul float %141, %149
%155 = getelementptr inbounds float, float* %7, i64 %31
store float %154, float* %155
br label %156
156: ; preds = %33, %57
%157 = phi i64 [ %56, %33 ], [ %59, %57 ]
%158 = icmp eq i64 %157, %28
br i1 %158, label %159, label %29
159: ; preds = %156
%160 = icmp slt i32 %0, 2
br i1 %160, label %301, label %161
161: ; preds = %159
%162 = zext i32 %0 to i64
br label %166
163: ; preds = %194
br i1 %17, label %164, label %299
164: ; preds = %163
%165 = zext i32 %0 to i64
br label %236
166: ; preds = %161, %194
%167 = phi i64 [ 0, %161 ], [ %234, %194 ]
%168 = phi float [ 0.000000e+00, %161 ], [ %225, %194 ]
%169 = phi <2 x float> [ zeroinitializer, %161 ], [ %228, %194 ]
%170 = shl nuw nsw i64 %167, 1
%171 = or i64 %170, 1
%172 = getelementptr inbounds float, float* %5, i64 %171
%173 = load float, float* %172
%174 = getelementptr inbounds float, float* %6, i64 %171
%175 = load float, float* %174
%176 = getelementptr inbounds float, float* %7, i64 %171
%177 = load float, float* %176
%178 = extractelement <2 x float> %169, i64 0
%179 = fmul float %178, %175
%180 = tail call float @llvm.fmuladd.f32(float %173, float %168, float %179)
%181 = extractelement <2 x float> %169, i64 1
%182 = tail call float @llvm.fmuladd.f32(float %177, float %181, float %180)
%183 = fcmp ogt float %182, 0.000000e+00
br i1 %183, label %184, label %189
184: ; preds = %166
%185 = fadd float %168, %173
%186 = insertelement <2 x float> poison, float %175, i64 0
%187 = insertelement <2 x float> %186, float %177, i64 1
%188 = fadd <2 x float> %169, %187
br label %194
189: ; preds = %166
%190 = fsub float %168, %173
%191 = insertelement <2 x float> poison, float %175, i64 0
%192 = insertelement <2 x float> %191, float %177, i64 1
%193 = fsub <2 x float> %169, %192
br label %194
194: ; preds = %189, %184
%195 = phi float [ %185, %184 ], [ %190, %189 ]
%196 = phi <2 x float> [ %188, %184 ], [ %193, %189 ]
%197 = getelementptr inbounds float, float* %5, i64 %170
%198 = load float, float* %197
%199 = getelementptr inbounds float, float* %6, i64 %170
%200 = load float, float* %199
%201 = getelementptr inbounds float, float* %7, i64 %170
%202 = load float, float* %201
%203 = extractelement <2 x float> %196, i64 0
%204 = fmul float %203, %200
%205 = tail call float @llvm.fmuladd.f32(float %195, float %198, float %204)
%206 = extractelement <2 x float> %196, i64 1
%207 = tail call float @llvm.fmuladd.f32(float %206, float %202, float %205)
%208 = fneg float %207
%209 = tail call float @llvm.fmuladd.f32(float %208, float %198, float %195)
%210 = insertelement <2 x float> poison, float %208, i64 0
%211 = shufflevector <2 x float> %210, <2 x float> poison, <2 x i32> zeroinitializer
%212 = insertelement <2 x float> poison, float %200, i64 0
%213 = insertelement <2 x float> %212, float %202, i64 1
%214 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %211, <2 x float> %213, <2 x float> %196)
%215 = fmul <2 x float> %214, %214
%216 = extractelement <2 x float> %215, i64 0
%217 = tail call float @llvm.fmuladd.f32(float %209, float %209, float %216)
%218 = extractelement <2 x float> %214, i64 1
%219 = tail call float @llvm.fmuladd.f32(float %218, float %218, float %217)
%220 = tail call float @sqrt(float %219)
%221 = fpext float %220 to double
%222 = fcmp olt double %221, 1.000000e-10
%223 = fdiv float 1.000000e+01, %220
%224 = select i1 %222, float 0x42374876E0000000, float %223
%225 = fmul float %209, %224
%226 = insertelement <2 x float> poison, float %224, i64 0
%227 = shufflevector <2 x float> %226, <2 x float> poison, <2 x i32> zeroinitializer
%228 = fmul <2 x float> %214, %227
%229 = getelementptr inbounds float, float* %1, i64 %170
store float %225, float* %229
%230 = getelementptr inbounds float, float* %2, i64 %170
%231 = extractelement <2 x float> %228, i64 0
store float %231, float* %230
%232 = getelementptr inbounds float, float* %3, i64 %170
%233 = extractelement <2 x float> %228, i64 1
store float %233, float* %232
%234 = add nuw nsw i64 %167, 1
%235 = icmp eq i64 %234, %162
br i1 %235, label %163, label %166
236: ; preds = %164, %236
%237 = phi i64 [ 0, %164 ], [ %297, %236 ]
%238 = shl nuw nsw i64 %237, 1
%239 = or i64 %238, 1
%240 = getelementptr inbounds float, float* %1, i64 %238
%241 = load float, float* %240
%242 = getelementptr inbounds float, float* %2, i64 %238
%243 = load float, float* %242
%244 = getelementptr inbounds float, float* %3, i64 %238
%245 = load float, float* %244
%246 = getelementptr inbounds float, float* %5, i64 %238
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %6, i64 %238
%249 = load float, float* %248
%250 = getelementptr inbounds float, float* %7, i64 %238
%251 = load float, float* %250
%252 = fmul float %241, 0x3F55D867C0000000
%253 = fmul float %243, 0x3F55D867C0000000
%254 = fmul float %245, 0x3F55D867C0000000
%255 = fneg float %254
%256 = fmul float %249, %255
%257 = tail call float @llvm.fmuladd.f32(float %253, float %251, float %256)
%258 = fneg float %252
%259 = fmul float %251, %258
%260 = tail call float @llvm.fmuladd.f32(float %254, float %247, float %259)
%261 = fneg float %253
%262 = fmul float %247, %261
%263 = tail call float @llvm.fmuladd.f32(float %252, float %249, float %262)
%264 = fmul float %260, %260
%265 = tail call float @llvm.fmuladd.f32(float %257, float %257, float %264)
%266 = tail call float @llvm.fmuladd.f32(float %263, float %263, float %265)
%267 = tail call float @sqrt(float %266)
%268 = fpext float %267 to double
%269 = fcmp olt double %268, 1.000000e-10
%270 = fdiv float 1.000000e+00, %267
%271 = select i1 %269, float 1.000000e+10, float %270
%272 = fmul float %257, %271
%273 = fmul float %260, %271
%274 = fmul float %263, %271
%275 = getelementptr inbounds [5000 x float], [5000 x float]* %9, i64 0, i64 %237
%276 = load float, float* %275
%277 = fsub float %276, %252
store float %277, float* %240
%278 = getelementptr inbounds [5000 x float], [5000 x float]* %11, i64 0, i64 %237
%279 = load float, float* %278
%280 = fsub float %279, %253
store float %280, float* %242
%281 = getelementptr inbounds [5000 x float], [5000 x float]* %13, i64 0, i64 %237
%282 = load float, float* %281
%283 = fsub float %282, %254
store float %283, float* %244
store float %272, float* %246
store float %273, float* %248
store float %274, float* %250
%284 = getelementptr inbounds i32, i32* %4, i64 %238
store i32 0, i32* %284
%285 = fadd float %252, %276
%286 = getelementptr inbounds float, float* %1, i64 %239
store float %285, float* %286
%287 = fadd float %253, %279
%288 = getelementptr inbounds float, float* %2, i64 %239
store float %287, float* %288
%289 = fadd float %254, %282
%290 = getelementptr inbounds float, float* %3, i64 %239
store float %289, float* %290
%291 = getelementptr inbounds float, float* %5, i64 %239
store float %272, float* %291
%292 = getelementptr inbounds float, float* %6, i64 %239
store float %273, float* %292
%293 = getelementptr inbounds float, float* %7, i64 %239
store float %274, float* %293
%294 = getelementptr inbounds [5000 x i32], [5000 x i32]* %15, i64 0, i64 %237
%295 = load i32, i32* %294
%296 = getelementptr inbounds i32, i32* %4, i64 %239
store i32 %295, i32* %296
%297 = add nuw nsw i64 %237, 1
%298 = icmp eq i64 %297, %165
br i1 %298, label %299, label %236
299: ; preds = %236, %163
%300 = shl nsw i32 %0, 1
br label %301
301: ; preds = %8, %159, %299
%302 = phi i32 [ %300, %299 ], [ 0, %159 ], [ 0, %8 ]
ret i32 %302
}