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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int fabs(float);
int /*<<< orphan*/ posit(int, int, float *, float *, float *, float *);
float sqrt(int);
void wray(int np, int nr, int *line, float *weight, int *numb, float *snorm) {
  float sorx, sory, cf, sf, rcosphi, tanphi, rtnphi, c, fp, w, yc;
  int ix, iy, incx, incy, index, next, flip, flipxy;
  int idx, idx_;
  int tmpinc;
  int idy;
  float fy;
  int tmpline[512][2] = {0};
  float tmpweight[512][2] = {0.0};
  float l;
  *numb = 0;
  *snorm = 0;
  posit(np, nr, &sorx, &sory, &cf, &sf);
  if (sf < -1e-8) {
    sf = -sf;
    cf = -cf;
  }
  flip = 0;
  if (sf * cf < -1e-8 * 1e-8) {
    flip = 1;
    cf = -cf;
  }
  if (flip > 0) {
    sorx = -sorx;
  }
  if (fabs(sf) <= 1e-8) {
    if (sf < 0)
      sf = -1e-8 * 1e-8;
    else
      sf = 1e-8 * 1e-8;
  }
  if (fabs(cf) <= 1e-8) {
    if (cf < 0)
      cf = -1e-8 * 1e-8;
    else
      cf = 1e-8 * 1e-8;
  }
  if (fabs(cf) > 1e-8)
    tanphi = sf / cf;
  else
    tanphi = 1 / (1e-8 * 1e-8);
  if (fabs(sf) > 1e-8)
    rtnphi = cf / sf;
  else
    rtnphi = 1 / (1e-8 * 1e-8);
  flipxy = 0;
  if (tanphi > 1 + 1e-8) {
    flipxy = 1;
    tanphi = 1 / tanphi;
    rtnphi = 1 / rtnphi;
    sf = sory;
    sory = sorx;
    sorx = sf;
  }
  rcosphi = (sqrt(1 + tanphi * tanphi));
  sory += 512 / 2.0;
  sorx += 512 / 2.0;
  c = sory - sorx * tanphi;
  if ((c - 512) >= 1e-2)
    return;
  if (c < -1e-2) {
    c = -c * rtnphi;
    if ((c - 512) >= 1e-2)
      return;
    ix = (int)c;
    iy = 0;
    fp = ((float)(ix + 1)) - c;
    yc = fp * tanphi;
    yc += -1.0;
  } else {
    ix = 0;
    iy = (int)c;
    fp = ((float)(iy + 1)) - c;
    yc = -fp;
    yc += tanphi;
  }
  if (yc >= 0)
    next = 1;
  else
    next = 2;
  if (flipxy > 0) {
    index = iy + ix * 512;
    incx = 512;
    incy = 1;
    if (flip > 0) {
      index = 512 - 1 - iy + ix * 512;
      incx = 512;
      incy = -1;
    }
  } else {
    index = iy * 512 + ix;
    incx = 1;
    incy = 512;
    if (flip > 0) {
      index = 512 - 1 - ix + iy * 512;
      incx = -1;
      incy = 512;
    }
  }
  if (iy == 0) {
    iy = ix;
    ix = 0;
    tanphi = 1 / tanphi;
    rtnphi = 1 / rtnphi;
    rcosphi = (sqrt(1 + tanphi * tanphi));
    tmpinc = incx;
    incx = incy;
    incy = tmpinc;
  }
  for (idx = 0; idx < 512; ++idx) {
    fy = iy + (idx * tanphi);
    idy = (int)fy;
    if (idy + 1 >= 512 || idy < 0)
      break;
    l = fy - idy + tanphi - 1;
    if (l > 0) {
      tmpweight[idx][0] = rcosphi * (1 - l * rtnphi);
      tmpline[idx][0] = idx * incx + idy * incy;
      tmpweight[idx][1] = rcosphi * (l * rtnphi);
      tmpline[idx][1] = idx * incx + (idy + 1) * incy;
    } else {
      tmpweight[idx][0] = rcosphi;
      tmpline[idx][0] = idx * incx + idy * incy;
      tmpweight[idx][1] = 0;
    }
  }
  for (idx_ = 0; idx_ < idx; ++idx_) {
    weight[*numb] = tmpweight[idx_][0];
    line[*numb] = tmpline[idx_][0];
    ++(*numb);
    if (tmpweight[idx_][1] != 0) {
      weight[*numb] = tmpweight[idx_][1];
      line[*numb] = tmpline[idx_][1];
      ++(*numb);
    }
  }
}


x86 assembly (clang, -O0):
<wray>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20a0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
lea    -0x1090(%rbp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
lea    -0x2090(%rbp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
lea    -0x2c(%rbp),%rdx
lea    -0x30(%rbp),%rcx
lea    -0x34(%rbp),%r8
lea    -0x38(%rbp),%r9
call   1050 <posit@plt>
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe38(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1200 <wray+0xc0>
movss  -0x38(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x70(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdeb(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1245 <wray+0x105>
movl   $0x1,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
cmpl   $0x0,-0x70(%rbp)
jle    1266 <wray+0x126>
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x38(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd94(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     12b7 <wray+0x177>
xorps  %xmm0,%xmm0
ucomiss -0x38(%rbp),%xmm0
jbe    12a5 <wray+0x165>
movss  0xda9(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    12b2 <wray+0x172>
movss  0xd93(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    12b7 <wray+0x177>
movss  -0x34(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0xd43(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1308 <wray+0x1c8>
xorps  %xmm0,%xmm0
ucomiss -0x34(%rbp),%xmm0
jbe    12f6 <wray+0x1b6>
movss  0xd58(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1303 <wray+0x1c3>
movss  0xd42(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1308 <wray+0x1c8>
movss  -0x34(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0xcf2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    133c <wray+0x1fc>
movss  -0x38(%rbp),%xmm0
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1349 <wray+0x209>
movss  0xd04(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0xcb1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    137d <wray+0x23d>
movss  -0x34(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    138a <wray+0x24a>
movss  0xcc3(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc76(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13f5 <wray+0x2b5>
movl   $0x1,-0x74(%rbp)
movss  0xc91(%rip),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xc7f(%rip),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc41(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbfa(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbdc(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  0xbc1(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb81(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     14ae <wray+0x36e>
jmp    1956 <wray+0x816>
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb71(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1566 <wray+0x426>
movss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  0xb5e(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb1e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1511 <wray+0x3d1>
jmp    1956 <wray+0x816>
cvttss2si -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xae4(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    15af <wray+0x46f>
movl   $0x0,-0x58(%rbp)
cvttss2si -0x48(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
subss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     15cc <wray+0x48c>
movl   $0x1,-0x6c(%rbp)
jmp    15d3 <wray+0x493>
movl   $0x2,-0x6c(%rbp)
cmpl   $0x0,-0x74(%rbp)
jle    1629 <wray+0x4e9>
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
shl    $0x9,%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
movl   $0x200,-0x60(%rbp)
movl   $0x1,-0x64(%rbp)
cmpl   $0x0,-0x70(%rbp)
jle    1624 <wray+0x4e4>
mov    $0x1ff,%eax
sub    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
shl    $0x9,%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
movl   $0x200,-0x60(%rbp)
movl   $0xffffffff,-0x64(%rbp)
jmp    1673 <wray+0x533>
mov    -0x5c(%rbp),%eax
shl    $0x9,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x1,-0x60(%rbp)
movl   $0x200,-0x64(%rbp)
cmpl   $0x0,-0x70(%rbp)
jle    166e <wray+0x52e>
mov    $0x1ff,%eax
sub    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
shl    $0x9,%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
movl   $0xffffffff,-0x60(%rbp)
movl   $0x200,-0x64(%rbp)
jmp    1673 <wray+0x533>
cmpl   $0x0,-0x5c(%rbp)
jne    16e8 <wray+0x5a8>
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x58(%rbp)
movss  0x9ba(%rip),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0x9a8(%rip),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0x988(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
movss  %xmm0,-0x3c(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x78(%rbp)
cmpl   $0x200,-0x78(%rbp)
jge    188a <wray+0x74a>
cvtsi2ssl -0x5c(%rbp),%xmm1
cvtsi2ssl -0x78(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
cvttss2si -0x88(%rbp),%eax
ff
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
cmp    $0x200,%eax
jge    174a <wray+0x60a>
cmpl   $0x0,-0x84(%rbp)
jge    174f <wray+0x60f>
jmp    188a <wray+0x74a>
movss  -0x88(%rbp),%xmm0
ff
cvtsi2ssl -0x84(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
addss  -0x40(%rbp),%xmm0
movss  0x8dc(%rip),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x2094(%rbp)
ff
movss  -0x2094(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1837 <wray+0x6f7>
movss  -0x3c(%rbp),%xmm0
movss  -0x2094(%rbp),%xmm1
ff
movss  -0x44(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
movss  0x891(%rip),%xmm2
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x2090(%rbp,%rax,8)
ff ff
mov    -0x78(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x84(%rbp),%eax
imul   -0x64(%rbp),%eax
add    %eax,%ecx
movslq -0x78(%rbp),%rax
mov    %ecx,-0x1090(%rbp,%rax,8)
movss  -0x3c(%rbp),%xmm0
movss  -0x2094(%rbp),%xmm1
ff
mulss  -0x44(%rbp),%xmm1
mulss  %xmm1,%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x208c(%rbp,%rax,8)
ff ff
mov    -0x78(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x84(%rbp),%eax
add    $0x1,%eax
imul   -0x64(%rbp),%eax
add    %eax,%ecx
movslq -0x78(%rbp),%rax
mov    %ecx,-0x108c(%rbp,%rax,8)
jmp    1877 <wray+0x737>
movss  -0x3c(%rbp),%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x2090(%rbp,%rax,8)
ff ff
mov    -0x78(%rbp),%ecx
imul   -0x60(%rbp),%ecx
mov    -0x84(%rbp),%eax
imul   -0x64(%rbp),%eax
add    %eax,%ecx
movslq -0x78(%rbp),%rax
mov    %ecx,-0x1090(%rbp,%rax,8)
movslq -0x78(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x208c(%rbp,%rax,8)
ff ff
jmp    187c <wray+0x73c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16ef <wray+0x5af>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1956 <wray+0x816>
movslq -0x7c(%rbp),%rax
movss  -0x2090(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x7c(%rbp),%rax
mov    -0x1090(%rbp,%rax,8),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movslq -0x7c(%rbp),%rax
movss  -0x208c(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1902 <wray+0x7c2>
jp     1902 <wray+0x7c2>
jmp    1943 <wray+0x803>
movslq -0x7c(%rbp),%rax
movss  -0x208c(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x7c(%rbp),%rax
mov    -0x108c(%rbp,%rax,8),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1948 <wray+0x808>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1891 <wray+0x751>
add    $0x20a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wray>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2038,%rsp
mov    %r9,%r12
mov    %r8,%rbx
mov    %rcx,%r14
mov    %rdx,%r15
mov    %esi,%r13d
mov    %edi,%ebp
lea    0x1030(%rsp),%rdi
mov    $0x1000,%edx
xor    %esi,%esi
call   1030 <memset@plt>
lea    0x30(%rsp),%rdi
mov    $0x1000,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,(%rbx)
movl   $0x0,(%r12)
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    %rsp,%r8
lea    0x4(%rsp),%r9
mov    %ebp,%edi
mov    %r13d,%esi
call   1050 <posit@plt>
movss  0x4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe3d(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    11e8 <wray+0xa8>
movaps 0xe60(%rip),%xmm2
xorps  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
movss  (%rsp),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,(%rsp)
jmp    11ed <wray+0xad>
movss  (%rsp),%xmm1
movaps %xmm0,%xmm2
mulss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xe08(%rip),%xmm3
movsd  %xmm2,0x28(%rsp)
ucomisd %xmm2,%xmm3
jbe    122a <wray+0xea>
movaps 0xe1d(%rip),%xmm2
xorps  %xmm2,%xmm1
movss  %xmm1,(%rsp)
movss  0x8(%rsp),%xmm1
xorps  %xmm2,%xmm1
movss  %xmm1,0x8(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
jg     124f <wray+0x10f>
xorps  %xmm0,%xmm0
ucomiss 0x4(%rsp),%xmm0
jbe    1247 <wray+0x107>
movl   $0xa4e69595,0x4(%rsp)
a4
jmp    124f <wray+0x10f>
movl   $0x24e69595,0x4(%rsp)
24
movss  (%rsp),%xmm0
call   1040 <fabs@plt>
movss  (%rsp),%xmm0
test   %eax,%eax
jg     128a <wray+0x14a>
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
jbe    127b <wray+0x13b>
movl   $0xa4e69595,(%rsp)
movss  0xddb(%rip),%xmm0
jmp    128a <wray+0x14a>
movl   $0x24e69595,(%rsp)
movss  0xdc6(%rip),%xmm0
call   1040 <fabs@plt>
movss  0xdc1(%rip),%xmm1
movss  0x4(%rsp),%xmm0
test   %eax,%eax
jle    12a9 <wray+0x169>
movaps %xmm0,%xmm1
divss  (%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
call   1040 <fabs@plt>
test   %eax,%eax
movss  0xd9b(%rip),%xmm2
jle    12ca <wray+0x18a>
movss  (%rsp),%xmm2
divss  0x4(%rsp),%xmm2
movaps 0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
ucomisd 0xd32(%rip),%xmm0
unpcklps %xmm2,%xmm1
movsd  %xmm0,0x20(%rsp)
jbe    1314 <wray+0x1d4>
movaps 0xd50(%rip),%xmm0
divps  %xmm1,%xmm0
movss  0xc(%rsp),%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x8(%rsp),%xmm2
movss  %xmm2,0xc(%rsp)
movss  %xmm1,0x8(%rsp)
movaps %xmm0,%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  0xd34(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
movaps 0x10(%rsp),%xmm5
movss  0xd22(%rip),%xmm2
movss  0xc(%rsp),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0xc(%rsp)
addss  0x8(%rsp),%xmm2
movss  %xmm2,0x8(%rsp)
mulss  %xmm5,%xmm2
subss  %xmm2,%xmm1
movss  0xcfa(%rip),%xmm2
addss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm2
ucomisd 0xc9e(%rip),%xmm2
jae    1524 <wray+0x3e4>
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movsd  0xc91(%rip),%xmm3
ucomisd %xmm2,%xmm3
jbe    13ce <wray+0x28e>
xorps  0xc94(%rip),%xmm1
movaps %xmm5,%xmm2
shufps $0x55,%xmm5,%xmm2
mulss  %xmm1,%xmm2
movss  0xcb5(%rip),%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd 0xc59(%rip),%xmm1
jae    1524 <wray+0x3e4>
cvttss2si %xmm2,%r12d
xor    %eax,%eax
jmp    13d5 <wray+0x295>
cvttss2si %xmm1,%eax
xor    %r12d,%r12d
movsd  0x28(%rsp),%xmm1
movsd  0xc25(%rip),%xmm2
movsd  0x20(%rsp),%xmm3
ucomisd 0xc1f(%rip),%xmm3
jbe    140c <wray+0x2cc>
mov    $0x1,%r13d
mov    $0x200,%ebp
ucomisd %xmm1,%xmm2
jbe    1422 <wray+0x2e2>
mov    $0xffffffff,%r13d
jmp    1422 <wray+0x2e2>
mov    $0x200,%r13d
mov    $0x1,%ebp
ucomisd %xmm1,%xmm2
jbe    1422 <wray+0x2e2>
mov    $0xffffffff,%ebp
test   %eax,%eax
je     1430 <wray+0x2f0>
mov    %eax,%r12d
mov    %ebp,%ecx
mov    %r13d,%ebp
jmp    145c <wray+0x31c>
movaps 0xc09(%rip),%xmm0
divps  %xmm5,%xmm0
movaps %xmm0,0x10(%rsp)
mulss  %xmm0,%xmm0
addss  0xc11(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
mov    %r13d,%ecx
movaps 0x10(%rsp),%xmm5
xorps  %xmm1,%xmm1
cvtsi2ss %r12d,%xmm1
movaps %xmm5,%xmm2
shufps $0x55,%xmm5,%xmm2
xor    %edx,%edx
movss  0xbf3(%rip),%xmm3
xorps  %xmm4,%xmm4
movss  0xbdb(%rip),%xmm8
xor    %eax,%eax
jmp    14c1 <wray+0x381>
cs nopw 0x0(%rax,%rax,1)
nop
imul   %ebp,%esi
mov    %ecx,%edi
imul   %eax,%edi
add    %esi,%edi
xorps  %xmm6,%xmm6
movaps %xmm0,%xmm7
movss  %xmm7,0x30(%rsp,%rax,8)
mov    %edi,0x1030(%rsp,%rax,8)
movss  %xmm6,0x34(%rsp,%rax,8)
add    $0x1,%rax
add    %ecx,%edx
cmp    $0x200,%rax
je     1536 <wray+0x3f6>
xorps  %xmm6,%xmm6
cvtsi2ss %eax,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm1,%xmm6
cvttss2si %xmm6,%esi
cmp    $0x1fe,%esi
ja     1520 <wray+0x3e0>
xorps  %xmm7,%xmm7
cvtsi2ss %esi,%xmm7
subss  %xmm7,%xmm6
addss  %xmm5,%xmm6
addss  %xmm3,%xmm6
ucomiss %xmm4,%xmm6
jbe    1490 <wray+0x350>
mulss  %xmm2,%xmm6
movaps %xmm8,%xmm7
subss  %xmm6,%xmm7
mulss  %xmm0,%xmm7
mov    %ebp,%edi
imul   %esi,%edi
add    $0x1,%esi
add    %edx,%edi
mulss  %xmm0,%xmm6
imul   %ebp,%esi
add    %edx,%esi
mov    %esi,0x1034(%rsp,%rax,8)
jmp    14a0 <wray+0x360>
test   %eax,%eax
jne    153b <wray+0x3fb>
add    $0x2038,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x200,%eax
mov    (%rbx),%edx
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
jmp    1559 <wray+0x419>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %rcx,%rax
je     1524 <wray+0x3e4>
movss  0x30(%rsp,%rcx,8),%xmm1
movslq %edx,%rdx
movss  %xmm1,(%r14,%rdx,4)
mov    0x1030(%rsp,%rcx,8),%esi
mov    %esi,(%r15,%rdx,4)
movslq (%rbx),%rsi
lea    0x1(%rsi),%edx
mov    %edx,(%rbx)
movss  0x34(%rsp,%rcx,8),%xmm1
ucomiss %xmm0,%xmm1
jne    1588 <wray+0x448>
jnp    1550 <wray+0x410>
movss  %xmm1,0x4(%r14,%rsi,4)
mov    0x1034(%rsp,%rcx,8),%edx
mov    %edx,0x4(%r15,%rsi,4)
mov    (%rbx),%edx
add    $0x1,%edx
mov    %edx,(%rbx)
jmp    1550 <wray+0x410>

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

LLVM IR (-O2):
define void @wray(i32 %0, i32 %1, i32* nocapture writeonly %2, float* nocapture writeonly %3, i32* nocapture %4, float* nocapture writeonly %5) {
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca [512 x [2 x i32]]
%12 = alloca [512 x [2 x float]]
%13 = bitcast float* %7 to i8*
%14 = bitcast float* %8 to i8*
%15 = bitcast float* %9 to i8*
%16 = bitcast float* %10 to i8*
%17 = bitcast [512 x [2 x i32]]* %11 to i8*
%18 = bitcast [512 x [2 x float]]* %12 to i8*
store i32 0, i32* %4
store float 0.000000e+00, float* %5
%19 = call i32 @posit(i32 %0, i32 %1, float* %7, float* %8, float* %9, float* %10)
%20 = load float, float* %10
%21 = fpext float %20 to double
%22 = fcmp olt double %21, -1.000000e-08
br i1 %22, label %25, label %23
23: ; preds = %6
%24 = load float, float* %9
br label %29
25: ; preds = %6
%26 = fneg float %20
store float %26, float* %10
%27 = load float, float* %9
%28 = fneg float %27
store float %28, float* %9
br label %29
29: ; preds = %23, %25
%30 = phi float [ %28, %25 ], [ %24, %23 ]
%31 = phi float [ %26, %25 ], [ %20, %23 ]
%32 = fmul float %31, %30
%33 = fpext float %32 to double
%34 = fcmp olt double %33, 0xBC9CD2B297D889BD
br i1 %34, label %35, label %39
35: ; preds = %29
%36 = fneg float %30
store float %36, float* %9
%37 = load float, float* %7
%38 = fneg float %37
store float %38, float* %7
br label %39
39: ; preds = %29, %35
%40 = call i32 @fabs(float %31)
%41 = icmp slt i32 %40, 1
br i1 %41, label %42, label %47
42: ; preds = %39
%43 = load float, float* %10
%44 = fcmp olt float %43, 0.000000e+00
br i1 %44, label %45, label %46
45: ; preds = %42
store float 0xBC9CD2B2A0000000, float* %10
br label %47
46: ; preds = %42
store float 0x3C9CD2B2A0000000, float* %10
br label %47
47: ; preds = %45, %46, %39
%48 = load float, float* %9
%49 = call i32 @fabs(float %48)
%50 = icmp slt i32 %49, 1
%51 = load float, float* %9
br i1 %50, label %52, label %56
52: ; preds = %47
%53 = fcmp olt float %51, 0.000000e+00
br i1 %53, label %54, label %55
54: ; preds = %52
store float 0xBC9CD2B2A0000000, float* %9
br label %56
55: ; preds = %52
store float 0x3C9CD2B2A0000000, float* %9
br label %56
56: ; preds = %47, %54, %55
%57 = phi float [ 0xBC9CD2B2A0000000, %54 ], [ 0x3C9CD2B2A0000000, %55 ], [ %51, %47 ]
%58 = call i32 @fabs(float %57)
%59 = icmp sgt i32 %58, 0
%60 = load float, float* %10
br i1 %59, label %61, label %64
61: ; preds = %56
%62 = load float, float* %9
%63 = fdiv float %60, %62
br label %64
64: ; preds = %56, %61
%65 = phi float [ %63, %61 ], [ 0x4341C37940000000, %56 ]
%66 = call i32 @fabs(float %60)
%67 = icmp sgt i32 %66, 0
br i1 %67, label %68, label %72
68: ; preds = %64
%69 = load float, float* %9
%70 = load float, float* %10
%71 = fdiv float %69, %70
br label %72
72: ; preds = %64, %68
%73 = phi float [ %71, %68 ], [ 0x4341C37940000000, %64 ]
%74 = fpext float %65 to double
%75 = fcmp ogt double %74, 0x3FF0000002AF31DC
%76 = insertelement <2 x float> poison, float %65, i64 0
%77 = insertelement <2 x float> %76, float %73, i64 1
br i1 %75, label %78, label %82
78: ; preds = %72
%79 = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, %77
%80 = load float, float* %8
store float %80, float* %10
%81 = load float, float* %7
store float %81, float* %8
store float %80, float* %7
br label %82
82: ; preds = %78, %72
%83 = phi <2 x float> [ %79, %78 ], [ %77, %72 ]
%84 = extractelement <2 x float> %83, i64 0
%85 = call float @llvm.fmuladd.f32(float %84, float %84, float 1.000000e+00)
%86 = fptosi float %85 to i32
%87 = call float @sqrt(i32 %86)
%88 = load float, float* %8
%89 = fadd float %88, 2.560000e+02
store float %89, float* %8
%90 = load float, float* %7
%91 = fadd float %90, 2.560000e+02
store float %91, float* %7
%92 = fneg float %91
%93 = call float @llvm.fmuladd.f32(float %92, float %84, float %89)
%94 = fadd float %93, -5.120000e+02
%95 = fpext float %94 to double
%96 = fcmp ult double %95, 1.000000e-02
br i1 %96, label %97, label %212
97: ; preds = %82
%98 = fpext float %93 to double
%99 = fcmp olt double %98, -1.000000e-02
br i1 %99, label %100, label %109
100: ; preds = %97
%101 = fneg float %93
%102 = extractelement <2 x float> %83, i64 1
%103 = fmul float %102, %101
%104 = fadd float %103, -5.120000e+02
%105 = fpext float %104 to double
%106 = fcmp ult double %105, 1.000000e-02
br i1 %106, label %107, label %212
107: ; preds = %100
%108 = fptosi float %103 to i32
br label %111
109: ; preds = %97
%110 = fptosi float %93 to i32
br label %111
111: ; preds = %109, %107
%112 = phi i32 [ %108, %107 ], [ 0, %109 ]
%113 = phi i32 [ 0, %107 ], [ %110, %109 ]
br i1 %75, label %114, label %116
114: ; preds = %111
br i1 %34, label %115, label %118
115: ; preds = %114
br label %118
116: ; preds = %111
br i1 %34, label %117, label %118
117: ; preds = %116
br label %118
118: ; preds = %116, %117, %114, %115
%119 = phi i32 [ 512, %115 ], [ 512, %114 ], [ -1, %117 ], [ 1, %116 ]
%120 = phi i32 [ -1, %115 ], [ 1, %114 ], [ 512, %117 ], [ 512, %116 ]
%121 = icmp eq i32 %113, 0
br i1 %121, label %122, label %128
122: ; preds = %118
%123 = fdiv <2 x float> <float 1.000000e+00, float 1.000000e+00>, %83
%124 = extractelement <2 x float> %123, i64 0
%125 = call float @llvm.fmuladd.f32(float %124, float %124, float 1.000000e+00)
%126 = fptosi float %125 to i32
%127 = call float @sqrt(i32 %126)
br label %128
128: ; preds = %122, %118
%129 = phi i32 [ %112, %122 ], [ %113, %118 ]
%130 = phi i32 [ %120, %122 ], [ %119, %118 ]
%131 = phi i32 [ %119, %122 ], [ %120, %118 ]
%132 = phi float [ %127, %122 ], [ %87, %118 ]
%133 = phi <2 x float> [ %123, %122 ], [ %83, %118 ]
%134 = sitofp i32 %129 to float
%135 = extractelement <2 x float> %133, i64 0
%136 = extractelement <2 x float> %133, i64 1
br label %137
137: ; preds = %128, %169
%138 = phi i64 [ 0, %128 ], [ %176, %169 ]
%139 = trunc i64 %138 to i32
%140 = sitofp i32 %139 to float
%141 = call float @llvm.fmuladd.f32(float %140, float %135, float %134)
%142 = fptosi float %141 to i32
%143 = add nsw i32 %142, 1
%144 = icmp ugt i32 %142, 510
br i1 %144, label %178, label %145
145: ; preds = %137
%146 = sitofp i32 %142 to float
%147 = fsub float %141, %146
%148 = fadd float %135, %147
%149 = fadd float %148, -1.000000e+00
%150 = fcmp ogt float %149, 0.000000e+00
br i1 %150, label %151, label %164
151: ; preds = %145
%152 = fneg float %149
%153 = call float @llvm.fmuladd.f32(float %152, float %136, float 1.000000e+00)
%154 = fmul float %132, %153
%155 = mul nsw i32 %131, %142
%156 = trunc i64 %138 to i32
%157 = mul i32 %130, %156
%158 = add nsw i32 %155, %157
%159 = fmul float %136, %149
%160 = fmul float %132, %159
%161 = mul nsw i32 %143, %131
%162 = add nsw i32 %161, %157
%163 = getelementptr inbounds [512 x [2 x i32]], [512 x [2 x i32]]* %11, i64 0, i64 %138, i64 1
store i32 %162, i32* %163
br label %169
164: ; preds = %145
%165 = mul nsw i32 %131, %142
%166 = trunc i64 %138 to i32
%167 = mul i32 %130, %166
%168 = add nsw i32 %165, %167
br label %169
169: ; preds = %151, %164
%170 = phi float [ %154, %151 ], [ %132, %164 ]
%171 = phi i32 [ %158, %151 ], [ %168, %164 ]
%172 = phi float [ %160, %151 ], [ 0.000000e+00, %164 ]
%173 = getelementptr inbounds [512 x [2 x float]], [512 x [2 x float]]* %12, i64 0, i64 %138, i64 0
store float %170, float* %173
%174 = getelementptr inbounds [512 x [2 x i32]], [512 x [2 x i32]]* %11, i64 0, i64 %138, i64 0
store i32 %171, i32* %174
%175 = getelementptr inbounds [512 x [2 x float]], [512 x [2 x float]]* %12, i64 0, i64 %138, i64 1
store float %172, float* %175
%176 = add nuw nsw i64 %138, 1
%177 = icmp eq i64 %176, 512
br i1 %177, label %181, label %137
178: ; preds = %137
%179 = trunc i64 %138 to i32
%180 = icmp eq i32 %179, 0
br i1 %180, label %212, label %181
181: ; preds = %169, %178
%182 = phi i64 [ %138, %178 ], [ 512, %169 ]
%183 = and i64 %182, 4294967295
%184 = load i32, i32* %4
br label %185
185: ; preds = %181, %208
%186 = phi i32 [ %184, %181 ], [ %209, %208 ]
%187 = phi i64 [ 0, %181 ], [ %210, %208 ]
%188 = getelementptr inbounds [512 x [2 x float]], [512 x [2 x float]]* %12, i64 0, i64 %187, i64 0
%189 = load float, float* %188
%190 = sext i32 %186 to i64
%191 = getelementptr inbounds float, float* %3, i64 %190
store float %189, float* %191
%192 = getelementptr inbounds [512 x [2 x i32]], [512 x [2 x i32]]* %11, i64 0, i64 %187, i64 0
%193 = load i32, i32* %192
%194 = getelementptr inbounds i32, i32* %2, i64 %190
store i32 %193, i32* %194
%195 = load i32, i32* %4
%196 = add nsw i32 %195, 1
store i32 %196, i32* %4
%197 = getelementptr inbounds [512 x [2 x float]], [512 x [2 x float]]* %12, i64 0, i64 %187, i64 1
%198 = load float, float* %197
%199 = fcmp une float %198, 0.000000e+00
br i1 %199, label %200, label %208
200: ; preds = %185
%201 = sext i32 %196 to i64
%202 = getelementptr inbounds float, float* %3, i64 %201
store float %198, float* %202
%203 = getelementptr inbounds [512 x [2 x i32]], [512 x [2 x i32]]* %11, i64 0, i64 %187, i64 1
%204 = load i32, i32* %203
%205 = getelementptr inbounds i32, i32* %2, i64 %201
store i32 %204, i32* %205
%206 = load i32, i32* %4
%207 = add nsw i32 %206, 1
store i32 %207, i32* %4
br label %208
208: ; preds = %185, %200
%209 = phi i32 [ %196, %185 ], [ %207, %200 ]
%210 = add nuw nsw i64 %187, 1
%211 = icmp eq i64 %210, %183
br i1 %211, label %212, label %185
212: ; preds = %208, %178, %100, %82
ret void
}