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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ makecircle(int, int, int, float **, float);
int /*<<< orphan*/ makediamond(int, int, int, float **, float);
int /*<<< orphan*/ makesquare(int, int, int, float **, float);
void diffraction(float *x, float *z, int nxp, float dx, float dz,
                 float **gridcp, float **gridcs, float **gridro, float **cp,
                 float **cs, float **ro, float *interface, int *zp, int nx,
                 int diffrwidth, int type) {
  int i, j, k;
  for (i = 0; i < nx; i++) {
    interface[i] = 0.0;
    zp[i] = 0;
  }
  if (gridcs == NULL && gridro == NULL) {
    for (i = 0; i < nxp; i++) {
      interface[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5
                                         : (x[i] / dx) - 0.5))] = z[i];
      zp[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5))] =
          ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      switch (type) {
      case 1:
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        break;
      case 2:
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        break;
      default:
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        break;
      }
    }
  } else if (gridcs == NULL) {
    for (i = 0; i < nxp; i++) {
      interface[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5
                                         : (x[i] / dx) - 0.5))] = z[i];
      zp[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5))] =
          ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      switch (type) {
      case 1:
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        break;
      case 2:
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        break;
      default:
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        break;
      }
    }
  } else {
    for (i = 0; i < nxp; i++) {
      interface[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5
                                         : (x[i] / dx) - 0.5))] = z[i];
      zp[((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5))] =
          ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5));
      switch (type) {
      case 1:
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        makediamond(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcs, cs[2][i]);
        break;
      case 2:
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        makecircle(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcs, cs[2][i]);
        break;
      default:
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcp, cp[2][i]);
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridro, ro[2][i]);
        makesquare(
            ((int)((x[i] / dx) > 0.0 ? (x[i] / dx) + 0.5 : (x[i] / dx) - 0.5)),
            ((int)((z[i] / dz) > 0.0 ? (z[i] / dz) + 0.5 : (z[i] / dz) - 0.5)),
            diffrwidth, gridcs, cs[2][i]);
        break;
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<diffraction>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c0,%rsp
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    11b9 <diffraction+0x89>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1180 <diffraction+0x50>
cmpq   $0x0,-0x30(%rbp)
jne    179d <diffraction+0x66d>
cmpq   $0x0,-0x38(%rbp)
jne    179d <diffraction+0x66d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1798 <diffraction+0x668>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    124b <diffraction+0x11b>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1dc3(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1272 <diffraction+0x142>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d97(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x54(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    12db <diffraction+0x1ab>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d33(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1302 <diffraction+0x1d2>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d07(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x74(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1365 <diffraction+0x235>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1ca9(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    138c <diffraction+0x25c>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c7d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x74(%rbp),%edx
movsd  -0x80(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x48(%rbp),%eax
mov    %eax,-0x84(%rbp)
sub    $0x1,%eax
je     13cd <diffraction+0x29d>
jmp    13b9 <diffraction+0x289>
mov    -0x84(%rbp),%eax
sub    $0x2,%eax
je     150c <diffraction+0x3dc>
jmp    164b <diffraction+0x51b>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    141f <diffraction+0x2ef>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1bf2(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1449 <diffraction+0x319>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1bc3(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    14ad <diffraction+0x37d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b64(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    14d7 <diffraction+0x3a7>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b35(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x94(%rbp),%edi
movsd  -0xa0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
jmp    1785 <diffraction+0x655>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    155e <diffraction+0x42e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1ab3(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1588 <diffraction+0x458>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a84(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xac(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15ec <diffraction+0x4bc>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a25(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1616 <diffraction+0x4e6>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x19f6(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xac(%rbp),%edi
movsd  -0xb8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
jmp    1785 <diffraction+0x655>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    169d <diffraction+0x56d>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1974(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    16c7 <diffraction+0x597>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1945(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xc4(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    172b <diffraction+0x5fb>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x18e6(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1755 <diffraction+0x625>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x18b7(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0xc4(%rbp),%edi
movsd  -0xd0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
jmp    178a <diffraction+0x65a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d6 <diffraction+0xa6>
jmp    2eb9 <diffraction+0x1d89>
cmpq   $0x0,-0x30(%rbp)
jne    2157 <diffraction+0x1027>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2152 <diffraction+0x1022>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    0x28(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    182d <diffraction+0x6fd>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x17e4(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1857 <diffraction+0x727>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x17b5(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0xd8(%rbp),%rax
movss  -0xdc(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    18cc <diffraction+0x79c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1745(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    18f6 <diffraction+0x7c6>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1716(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0xfc(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1965 <diffraction+0x835>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16ac(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    198f <diffraction+0x85f>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x167d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0xf8(%rbp),%rax
mov    -0xfc(%rbp),%edx
movsd  -0x108(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x48(%rbp),%eax
mov    %eax,-0x10c(%rbp)
sub    $0x1,%eax
je     19d9 <diffraction+0x8a9>
jmp    19c5 <diffraction+0x895>
mov    -0x10c(%rbp),%eax
sub    $0x2,%eax
je     1c52 <diffraction+0xb22>
jmp    1ecb <diffraction+0xd9b>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a2b <diffraction+0x8fb>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x15e6(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1a55 <diffraction+0x925>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x15b7(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ab9 <diffraction+0x989>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1558(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1ae3 <diffraction+0x9b3>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1529(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x11c(%rbp),%edi
movsd  -0x128(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b65 <diffraction+0xa35>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x14ac(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1b8f <diffraction+0xa5f>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x147d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x134(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1bf3 <diffraction+0xac3>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x141e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    1c1d <diffraction+0xaed>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x13ef(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x134(%rbp),%edi
movsd  -0x140(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
jmp    213f <diffraction+0x100f>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ca4 <diffraction+0xb74>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x136d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    1cce <diffraction+0xb9e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x133e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1d32 <diffraction+0xc02>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x12df(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    1d5c <diffraction+0xc2c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x12b0(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x14c(%rbp),%edi
movsd  -0x158(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1dde <diffraction+0xcae>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1233(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    1e08 <diffraction+0xcd8>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1204(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x164(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1e6c <diffraction+0xd3c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x11a5(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1e96 <diffraction+0xd66>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1176(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x164(%rbp),%edi
movsd  -0x170(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
jmp    213f <diffraction+0x100f>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f1d <diffraction+0xded>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10f4(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
jmp    1f47 <diffraction+0xe17>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10c5(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x17c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1fab <diffraction+0xe7b>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1066(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
jmp    1fd5 <diffraction+0xea5>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1037(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x17c(%rbp),%edi
movsd  -0x188(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2057 <diffraction+0xf27>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xfba(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
jmp    2081 <diffraction+0xf51>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf8b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x194(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    20e5 <diffraction+0xfb5>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf2c(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    210f <diffraction+0xfdf>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xefd(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x194(%rbp),%edi
movsd  -0x1a0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
jmp    2144 <diffraction+0x1014>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17af <diffraction+0x67f>
jmp    2eb4 <diffraction+0x1d84>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2eaf <diffraction+0x1d7f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1ac(%rbp)
ff
mov    0x28(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    21dc <diffraction+0x10ac>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe35(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
jmp    2206 <diffraction+0x10d6>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe06(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x1a8(%rbp),%rax
movss  -0x1ac(%rbp),%xmm0
ff
movsd  -0x1b8(%rbp),%xmm1
ff
cvttsd2si %xmm1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    227b <diffraction+0x114b>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd96(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
jmp    22a5 <diffraction+0x1175>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd67(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x1cc(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2314 <diffraction+0x11e4>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcfd(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
jmp    233e <diffraction+0x120e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcce(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x1c8(%rbp),%rax
mov    -0x1cc(%rbp),%edx
movsd  -0x1d8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x48(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
sub    $0x1,%eax
je     2388 <diffraction+0x1258>
jmp    2374 <diffraction+0x1244>
mov    -0x1dc(%rbp),%eax
sub    $0x2,%eax
je     273b <diffraction+0x160b>
jmp    2aee <diffraction+0x19be>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    23da <diffraction+0x12aa>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc37(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
jmp    2404 <diffraction+0x12d4>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc08(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2468 <diffraction+0x1338>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xba9(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
jmp    2492 <diffraction+0x1362>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb7a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x1ec(%rbp),%edi
movsd  -0x1f8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2514 <diffraction+0x13e4>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xafd(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
jmp    253e <diffraction+0x140e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xace(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x200(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x204(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    25a2 <diffraction+0x1472>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa6f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
jmp    25cc <diffraction+0x149c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa40(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x204(%rbp),%edi
movsd  -0x210(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    264e <diffraction+0x151e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9c3(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
jmp    2678 <diffraction+0x1548>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x994(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    26dc <diffraction+0x15ac>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x935(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
jmp    2706 <diffraction+0x15d6>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x906(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x21c(%rbp),%edi
movsd  -0x228(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1050 <makediamond@plt>
jmp    2e9c <diffraction+0x1d6c>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    278d <diffraction+0x165d>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x884(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
jmp    27b7 <diffraction+0x1687>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x855(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x234(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    281b <diffraction+0x16eb>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x7f6(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
jmp    2845 <diffraction+0x1715>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x7c7(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
mov    -0x234(%rbp),%edi
movsd  -0x240(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    28c7 <diffraction+0x1797>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x74a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
jmp    28f1 <diffraction+0x17c1>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x71b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x24c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2955 <diffraction+0x1825>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x6bc(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
jmp    297f <diffraction+0x184f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x68d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x24c(%rbp),%edi
movsd  -0x258(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2a01 <diffraction+0x18d1>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x610(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
jmp    2a2b <diffraction+0x18fb>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x5e1(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x260(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x264(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2a8f <diffraction+0x195f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x582(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
jmp    2ab9 <diffraction+0x1989>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x553(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x264(%rbp),%edi
movsd  -0x270(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1030 <makecircle@plt>
jmp    2e9c <diffraction+0x1d6c>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2b40 <diffraction+0x1a10>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4d1(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
jmp    2b6a <diffraction+0x1a3a>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x4a2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x278(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x27c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2bce <diffraction+0x1a9e>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x443(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
jmp    2bf8 <diffraction+0x1ac8>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x414(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
mov    -0x27c(%rbp),%edi
movsd  -0x288(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2c7a <diffraction+0x1b4a>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x397(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
jmp    2ca4 <diffraction+0x1b74>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x368(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x290(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x294(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2d08 <diffraction+0x1bd8>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x309(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
jmp    2d32 <diffraction+0x1c02>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2da(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
mov    -0x294(%rbp),%edi
movsd  -0x2a0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    0x20(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2db4 <diffraction+0x1c84>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x25d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
jmp    2dde <diffraction+0x1cae>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x22e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0x2a8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2e42 <diffraction+0x1d12>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1cf(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
jmp    2e6c <diffraction+0x1d3c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a0(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
mov    -0x2ac(%rbp),%edi
movsd  -0x2b8(%rbp),%xmm0
ff
cvttsd2si %xmm0,%esi
mov    0x40(%rbp),%edx
mov    -0x30(%rbp),%rcx
mov    0x18(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x3c(%rbp),%r8
movss  (%rax,%r8,4),%xmm0
call   1040 <makesquare@plt>
jmp    2ea1 <diffraction+0x1d71>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    215e <diffraction+0x102e>
jmp    2eb4 <diffraction+0x1d84>
jmp    2eb9 <diffraction+0x1d89>
add    $0x2c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<diffraction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%rbx
mov    %rcx,0x8(%rsp)
movapd %xmm1,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %rsi,%r15
mov    %rdi,%r12
mov    0xa8(%rsp),%ecx
mov    0xa0(%rsp),%r10
mov    0x98(%rsp),%r13
test   %ecx,%ecx
jle    129a <diffraction+0x16a>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1184 <diffraction+0x54>
xor    %ecx,%ecx
jmp    1280 <diffraction+0x150>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
mov    %rbx,%r9
cmp    $0x18,%rbp
jae    11aa <diffraction+0x7a>
xor    %ebp,%ebp
jmp    1229 <diffraction+0xf9>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,0x0(%r13,%rbp,4)
movups %xmm0,0x10(%r13,%rbp,4)
movups %xmm0,(%r10,%rbp,4)
movups %xmm0,0x10(%r10,%rbp,4)
movups %xmm0,0x20(%r13,%rbp,4)
movups %xmm0,0x30(%r13,%rbp,4)
movups %xmm0,0x20(%r10,%rbp,4)
movups %xmm0,0x30(%r10,%rbp,4)
movups %xmm0,0x40(%r13,%rbp,4)
movups %xmm0,0x50(%r13,%rbp,4)
movups %xmm0,0x40(%r10,%rbp,4)
movups %xmm0,0x50(%r10,%rbp,4)
movups %xmm0,0x60(%r13,%rbp,4)
movups %xmm0,0x70(%r13,%rbp,4)
movups %xmm0,0x60(%r10,%rbp,4)
movups %xmm0,0x70(%r10,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    11c0 <diffraction+0x90>
test   %rsi,%rsi
je     126c <diffraction+0x13c>
lea    (%r10,%rbp,4),%rdi
add    $0x10,%rdi
lea    0x10(,%rbp,4),%rbp
add    %r13,%rbp
shl    $0x5,%rsi
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm0,0x0(%rbp,%rbx,1)
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm0,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1250 <diffraction+0x120>
cmp    %rax,%rcx
mov    %r9,%rbx
je     129a <diffraction+0x16a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,0x0(%r13,%rcx,4)
movl   $0x0,(%r10,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1280 <diffraction+0x150>
mov    0xb8(%rsp),%ecx
mov    %r8,%rax
or     %rbx,%rax
jne    13ff <diffraction+0x2cf>
test   %edx,%edx
jle    1b9a <diffraction+0xa6a>
mov    %edx,%ebp
xor    %ebx,%ebx
xorps  %xmm3,%xmm3
movsd  0xd3c(%rip),%xmm4
jmp    1312 <diffraction+0x1e2>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rax),%rax
movss  (%rax,%rbx,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1040 <makesquare@plt>
movsd  0xd0e(%rip),%xmm4
xorpd  %xmm3,%xmm3
mov    0xb8(%rsp),%ecx
mov    0xa0(%rsp),%r10
add    $0x1,%rbx
cmp    %rbx,%rbp
je     1b9a <diffraction+0xa6a>
movss  (%r12,%rbx,4),%xmm0
divss  0x10(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     132f <diffraction+0x1ff>
movsd  0xcd9(%rip),%xmm1
movss  (%r15,%rbx,4),%xmm2
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
cltq
movss  %xmm2,0x0(%r13,%rax,4)
movss  (%r15,%rbx,4),%xmm0
divss  0x20(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     1367 <diffraction+0x237>
movsd  0xca1(%rip),%xmm1
movss  (%r12,%rbx,4),%xmm2
divss  0x10(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1384 <diffraction+0x254>
movsd  0xc84(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%esi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%edi
movslq %edi,%rax
mov    %esi,(%r10,%rax,4)
mov    0x80(%rsp),%rax
cmp    $0x2,%ecx
je     13e0 <diffraction+0x2b0>
cmp    $0x1,%ecx
jne    12d0 <diffraction+0x1a0>
mov    0x10(%rax),%rax
movss  (%rax,%rbx,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1050 <makediamond@plt>
jmp    12ea <diffraction+0x1ba>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rax),%rax
movss  (%rax,%rbx,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1030 <makecircle@plt>
jmp    12ea <diffraction+0x1ba>
test   %r8,%r8
je     188c <diffraction+0x75c>
test   %edx,%edx
jle    1b9a <diffraction+0xa6a>
mov    %r8,%rbp
mov    %edx,%eax
mov    %rax,0x30(%rsp)
xor    %r14d,%r14d
xorps  %xmm3,%xmm3
movsd  0xbd8(%rip),%xmm4
jmp    1496 <diffraction+0x366>
nopw   0x0(%rax,%rax,1)
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x88(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbp,%rcx
call   1040 <makesquare@plt>
add    $0x1,%r14
cmp    %r14,0x30(%rsp)
mov    0xa0(%rsp),%r10
mov    0xb8(%rsp),%ecx
xorpd  %xmm3,%xmm3
movsd  0xb70(%rip),%xmm4
je     1b9a <diffraction+0xa6a>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     14b3 <diffraction+0x383>
movsd  0xb55(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
cltq
movss  %xmm2,0x0(%r13,%rax,4)
movss  (%r15,%r14,4),%xmm0
divss  0x20(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     14eb <diffraction+0x3bb>
movsd  0xb1d(%rip),%xmm1
movss  (%r12,%r14,4),%xmm2
divss  0x10(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1508 <diffraction+0x3d8>
movsd  0xb00(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%esi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%edi
movslq %edi,%rax
mov    %esi,(%r10,%rax,4)
mov    0x80(%rsp),%rax
cmp    $0x2,%ecx
je     1670 <diffraction+0x540>
cmp    $0x1,%ecx
jne    17a0 <diffraction+0x670>
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1050 <makediamond@plt>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movsd  0xa86(%rip),%xmm4
movapd %xmm4,%xmm1
ja     1588 <diffraction+0x458>
movsd  0xa80(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     15a5 <diffraction+0x475>
movsd  0xa63(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1050 <makediamond@plt>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movsd  0xa04(%rip),%xmm4
movapd %xmm4,%xmm1
ja     160a <diffraction+0x4da>
movsd  0x9fe(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1627 <diffraction+0x4f7>
movsd  0x9e1(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x88(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbp,%rcx
call   1050 <makediamond@plt>
jmp    146c <diffraction+0x33c>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1030 <makecircle@plt>
movsd  0x96d(%rip),%xmm4
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     16b4 <diffraction+0x584>
movsd  0x954(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     16d1 <diffraction+0x5a1>
movsd  0x937(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1030 <makecircle@plt>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movsd  0x8d8(%rip),%xmm4
movapd %xmm4,%xmm1
ja     1736 <diffraction+0x606>
movsd  0x8d2(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1753 <diffraction+0x623>
movsd  0x8b5(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x88(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbp,%rcx
call   1030 <makecircle@plt>
jmp    146c <diffraction+0x33c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1040 <makesquare@plt>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movsd  0x82a(%rip),%xmm4
movapd %xmm4,%xmm1
ja     17e4 <diffraction+0x6b4>
movsd  0x824(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1801 <diffraction+0x6d1>
movsd  0x807(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1040 <makesquare@plt>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
xorpd  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
movsd  0x7a8(%rip),%xmm4
movapd %xmm4,%xmm1
ja     1866 <diffraction+0x736>
movsd  0x7a2(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
divss  0x20(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     1430 <diffraction+0x300>
movsd  0x781(%rip),%xmm3
jmp    1430 <diffraction+0x300>
test   %edx,%edx
jle    1b9a <diffraction+0xa6a>
mov    %edx,%ebp
movaps 0x20(%rsp),%xmm0
unpcklps 0x10(%rsp),%xmm0
movaps %xmm0,0x30(%rsp)
xor    %r14d,%r14d
xorps  %xmm3,%xmm3
movsd  0x74d(%rip),%xmm4
jmp    1928 <diffraction+0x7f8>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
addsd  %xmm2,%xmm3
cvttsd2si %xmm3,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1040 <makesquare@plt>
add    $0x1,%r14
cmp    %r14,%rbp
mov    0xa0(%rsp),%r10
mov    0xb8(%rsp),%ecx
xorpd  %xmm3,%xmm3
movsd  0x6de(%rip),%xmm4
je     1b9a <diffraction+0xa6a>
movss  (%r12,%r14,4),%xmm0
divss  0x10(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     1945 <diffraction+0x815>
movsd  0x6c3(%rip),%xmm1
movss  (%r15,%r14,4),%xmm2
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
cltq
movss  %xmm2,0x0(%r13,%rax,4)
movss  (%r15,%r14,4),%xmm0
divss  0x20(%rsp),%xmm0
ucomiss %xmm3,%xmm0
movapd %xmm4,%xmm1
ja     197d <diffraction+0x84d>
movsd  0x68b(%rip),%xmm1
movss  (%r12,%r14,4),%xmm2
divss  0x10(%rsp),%xmm2
ucomiss %xmm3,%xmm2
movapd %xmm4,%xmm3
ja     199a <diffraction+0x86a>
movsd  0x66e(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%esi
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
addsd  %xmm3,%xmm0
cvttsd2si %xmm0,%edi
movslq %edi,%rax
mov    %esi,(%r10,%rax,4)
mov    0x80(%rsp),%rax
cmp    $0x2,%ecx
je     1a80 <diffraction+0x950>
cmp    $0x1,%ecx
jne    1b30 <diffraction+0xa00>
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1050 <makediamond@plt>
movss  (%r12,%r14,4),%xmm1
movss  (%r15,%r14,4),%xmm0
unpcklps %xmm1,%xmm0
divps  0x30(%rsp),%xmm0
xorps  %xmm1,%xmm1
cmpltps %xmm0,%xmm1
unpcklps %xmm1,%xmm1
movmskpd %xmm1,%eax
movsd  0x5e5(%rip),%xmm2
movapd %xmm2,%xmm1
test   $0x2,%al
jne    1a2b <diffraction+0x8fb>
movsd  0x5dd(%rip),%xmm1
test   $0x1,%al
jne    1a37 <diffraction+0x907>
movsd  0x5d1(%rip),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
addsd  %xmm2,%xmm3
cvttsd2si %xmm3,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1050 <makediamond@plt>
jmp    1900 <diffraction+0x7d0>
nopl   0x0(%rax)
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1030 <makecircle@plt>
movsd  0x55d(%rip),%xmm2
movss  (%r12,%r14,4),%xmm1
movss  (%r15,%r14,4),%xmm0
unpcklps %xmm1,%xmm0
divps  0x30(%rsp),%xmm0
xorps  %xmm1,%xmm1
cmpltps %xmm0,%xmm1
unpcklps %xmm1,%xmm1
movmskpd %xmm1,%eax
movapd %xmm2,%xmm1
test   $0x2,%al
jne    1ad5 <diffraction+0x9a5>
movsd  0x533(%rip),%xmm1
test   $0x1,%al
jne    1ae1 <diffraction+0x9b1>
movsd  0x527(%rip),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
addsd  %xmm2,%xmm3
cvttsd2si %xmm3,%esi
mov    0x90(%rsp),%rax
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    %rbx,%rcx
call   1030 <makecircle@plt>
jmp    1900 <diffraction+0x7d0>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rax),%rax
movss  (%rax,%r14,4),%xmm0
mov    0xb0(%rsp),%edx
mov    0x8(%rsp),%rcx
call   1040 <makesquare@plt>
movss  (%r12,%r14,4),%xmm1
movss  (%r15,%r14,4),%xmm0
unpcklps %xmm1,%xmm0
divps  0x30(%rsp),%xmm0
xorps  %xmm1,%xmm1
cmpltps %xmm0,%xmm1
unpcklps %xmm1,%xmm1
movmskpd %xmm1,%eax
movsd  0x48b(%rip),%xmm2
movapd %xmm2,%xmm1
test   $0x2,%al
jne    1b85 <diffraction+0xa55>
movsd  0x483(%rip),%xmm1
test   $0x1,%al
jne    18c0 <diffraction+0x790>
movsd  0x473(%rip),%xmm2
jmp    18c0 <diffraction+0x790>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @diffraction(float* %0, float* %1, i32 %2, float %3, float %4, float** %5, float** %6, float** %7, float** %8, float** %9, float** %10, float* %11, i32* %12, i32 %13, i32 %14, i32 %15) {
%17 = alloca float*
%18 = alloca float*
%19 = alloca i32
%20 = alloca float
%21 = alloca float
%22 = alloca float**
%23 = alloca float**
%24 = alloca float**
%25 = alloca float**
%26 = alloca float**
%27 = alloca float**
%28 = alloca float*
%29 = alloca i32*
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
store float* %0, float** %17
store float* %1, float** %18
store i32 %2, i32* %19
store float %3, float* %20
store float %4, float* %21
store float** %5, float*** %22
store float** %6, float*** %23
store float** %7, float*** %24
store float** %8, float*** %25
store float** %9, float*** %26
store float** %10, float*** %27
store float* %11, float** %28
store i32* %12, i32** %29
store i32 %13, i32* %30
store i32 %14, i32* %31
store i32 %15, i32* %32
store i32 0, i32* %33
br label %36
36: ; preds = %49, %16
%37 = load i32, i32* %33
%38 = load i32, i32* %30
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %52
40: ; preds = %36
%41 = load float*, float** %28
%42 = load i32, i32* %33
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
store float 0.000000e+00, float* %44
%45 = load i32*, i32** %29
%46 = load i32, i32* %33
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
store i32 0, i32* %48
br label %49
49: ; preds = %40
%50 = load i32, i32* %33
%51 = add nsw i32 %50, 1
store i32 %51, i32* %33
br label %36
52: ; preds = %36
%53 = load float**, float*** %23
%54 = icmp eq float** %53, null
br i1 %54, label %55, label %402
55: ; preds = %52
%56 = load float**, float*** %24
%57 = icmp eq float** %56, null
br i1 %57, label %58, label %402
58: ; preds = %55
store i32 0, i32* %33
br label %59
59: ; preds = %398, %58
%60 = load i32, i32* %33
%61 = load i32, i32* %19
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %401
63: ; preds = %59
%64 = load float*, float** %18
%65 = load i32, i32* %33
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %28
%70 = load float*, float** %17
%71 = load i32, i32* %33
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = load float, float* %20
%76 = fdiv float %74, %75
%77 = fpext float %76 to double
%78 = fcmp ogt double %77, 0.000000e+00
br i1 %78, label %79, label %89
79: ; preds = %63
%80 = load float*, float** %17
%81 = load i32, i32* %33
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = load float, float* %20
%86 = fdiv float %84, %85
%87 = fpext float %86 to double
%88 = fadd double %87, 5.000000e-01
br label %99
89: ; preds = %63
%90 = load float*, float** %17
%91 = load i32, i32* %33
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %90, i64 %92
%94 = load float, float* %93
%95 = load float, float* %20
%96 = fdiv float %94, %95
%97 = fpext float %96 to double
%98 = fsub double %97, 5.000000e-01
br label %99
99: ; preds = %89, %79
%100 = phi double [ %88, %79 ], [ %98, %89 ]
%101 = fptosi double %100 to i32
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %69, i64 %102
store float %68, float* %103
%104 = load float*, float** %18
%105 = load i32, i32* %33
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %104, i64 %106
%108 = load float, float* %107
%109 = load float, float* %21
%110 = fdiv float %108, %109
%111 = fpext float %110 to double
%112 = fcmp ogt double %111, 0.000000e+00
br i1 %112, label %113, label %123
113: ; preds = %99
%114 = load float*, float** %18
%115 = load i32, i32* %33
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %114, i64 %116
%118 = load float, float* %117
%119 = load float, float* %21
%120 = fdiv float %118, %119
%121 = fpext float %120 to double
%122 = fadd double %121, 5.000000e-01
br label %133
123: ; preds = %99
%124 = load float*, float** %18
%125 = load i32, i32* %33
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = load float, float* %21
%130 = fdiv float %128, %129
%131 = fpext float %130 to double
%132 = fsub double %131, 5.000000e-01
br label %133
133: ; preds = %123, %113
%134 = phi double [ %122, %113 ], [ %132, %123 ]
%135 = fptosi double %134 to i32
%136 = load i32*, i32** %29
%137 = load float*, float** %17
%138 = load i32, i32* %33
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds float, float* %137, i64 %139
%141 = load float, float* %140
%142 = load float, float* %20
%143 = fdiv float %141, %142
%144 = fpext float %143 to double
%145 = fcmp ogt double %144, 0.000000e+00
br i1 %145, label %146, label %156
146: ; preds = %133
%147 = load float*, float** %17
%148 = load i32, i32* %33
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = load float, float* %20
%153 = fdiv float %151, %152
%154 = fpext float %153 to double
%155 = fadd double %154, 5.000000e-01
br label %166
156: ; preds = %133
%157 = load float*, float** %17
%158 = load i32, i32* %33
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
%161 = load float, float* %160
%162 = load float, float* %20
%163 = fdiv float %161, %162
%164 = fpext float %163 to double
%165 = fsub double %164, 5.000000e-01
br label %166
166: ; preds = %156, %146
%167 = phi double [ %155, %146 ], [ %165, %156 ]
%168 = fptosi double %167 to i32
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %136, i64 %169
store i32 %135, i32* %170
%171 = load i32, i32* %32
switch i32 %171, label %322 [
i32 1, label %172
i32 2, label %247
]
172: ; preds = %166
%173 = load float*, float** %17
%174 = load i32, i32* %33
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
%178 = load float, float* %20
%179 = fdiv float %177, %178
%180 = fpext float %179 to double
%181 = fcmp ogt double %180, 0.000000e+00
br i1 %181, label %182, label %192
182: ; preds = %172
%183 = load float*, float** %17
%184 = load i32, i32* %33
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
%187 = load float, float* %186
%188 = load float, float* %20
%189 = fdiv float %187, %188
%190 = fpext float %189 to double
%191 = fadd double %190, 5.000000e-01
br label %202
192: ; preds = %172
%193 = load float*, float** %17
%194 = load i32, i32* %33
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
%197 = load float, float* %196
%198 = load float, float* %20
%199 = fdiv float %197, %198
%200 = fpext float %199 to double
%201 = fsub double %200, 5.000000e-01
br label %202
202: ; preds = %192, %182
%203 = phi double [ %191, %182 ], [ %201, %192 ]
%204 = fptosi double %203 to i32
%205 = load float*, float** %18
%206 = load i32, i32* %33
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
%209 = load float, float* %208
%210 = load float, float* %21
%211 = fdiv float %209, %210
%212 = fpext float %211 to double
%213 = fcmp ogt double %212, 0.000000e+00
br i1 %213, label %214, label %224
214: ; preds = %202
%215 = load float*, float** %18
%216 = load i32, i32* %33
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float, float* %215, i64 %217
%219 = load float, float* %218
%220 = load float, float* %21
%221 = fdiv float %219, %220
%222 = fpext float %221 to double
%223 = fadd double %222, 5.000000e-01
br label %234
224: ; preds = %202
%225 = load float*, float** %18
%226 = load i32, i32* %33
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %225, i64 %227
%229 = load float, float* %228
%230 = load float, float* %21
%231 = fdiv float %229, %230
%232 = fpext float %231 to double
%233 = fsub double %232, 5.000000e-01
br label %234
234: ; preds = %224, %214
%235 = phi double [ %223, %214 ], [ %233, %224 ]
%236 = fptosi double %235 to i32
%237 = load i32, i32* %31
%238 = load float**, float*** %22
%239 = load float**, float*** %25
%240 = getelementptr inbounds float*, float** %239, i64 2
%241 = load float*, float** %240
%242 = load i32, i32* %33
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds float, float* %241, i64 %243
%245 = load float, float* %244
%246 = call i32 @makediamond(i32 %204, i32 %236, i32 %237, float** %238, float %245)
br label %397
247: ; preds = %166
%248 = load float*, float** %17
%249 = load i32, i32* %33
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %248, i64 %250
%252 = load float, float* %251
%253 = load float, float* %20
%254 = fdiv float %252, %253
%255 = fpext float %254 to double
%256 = fcmp ogt double %255, 0.000000e+00
br i1 %256, label %257, label %267
257: ; preds = %247
%258 = load float*, float** %17
%259 = load i32, i32* %33
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds float, float* %258, i64 %260
%262 = load float, float* %261
%263 = load float, float* %20
%264 = fdiv float %262, %263
%265 = fpext float %264 to double
%266 = fadd double %265, 5.000000e-01
br label %277
267: ; preds = %247
%268 = load float*, float** %17
%269 = load i32, i32* %33
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float, float* %268, i64 %270
%272 = load float, float* %271
%273 = load float, float* %20
%274 = fdiv float %272, %273
%275 = fpext float %274 to double
%276 = fsub double %275, 5.000000e-01
br label %277
277: ; preds = %267, %257
%278 = phi double [ %266, %257 ], [ %276, %267 ]
%279 = fptosi double %278 to i32
%280 = load float*, float** %18
%281 = load i32, i32* %33
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
%284 = load float, float* %283
%285 = load float, float* %21
%286 = fdiv float %284, %285
%287 = fpext float %286 to double
%288 = fcmp ogt double %287, 0.000000e+00
br i1 %288, label %289, label %299
289: ; preds = %277
%290 = load float*, float** %18
%291 = load i32, i32* %33
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds float, float* %290, i64 %292
%294 = load float, float* %293
%295 = load float, float* %21
%296 = fdiv float %294, %295
%297 = fpext float %296 to double
%298 = fadd double %297, 5.000000e-01
br label %309
299: ; preds = %277
%300 = load float*, float** %18
%301 = load i32, i32* %33
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float, float* %300, i64 %302
%304 = load float, float* %303
%305 = load float, float* %21
%306 = fdiv float %304, %305
%307 = fpext float %306 to double
%308 = fsub double %307, 5.000000e-01
br label %309
309: ; preds = %299, %289
%310 = phi double [ %298, %289 ], [ %308, %299 ]
%311 = fptosi double %310 to i32
%312 = load i32, i32* %31
%313 = load float**, float*** %22
%314 = load float**, float*** %25
%315 = getelementptr inbounds float*, float** %314, i64 2
%316 = load float*, float** %315
%317 = load i32, i32* %33
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %316, i64 %318
%320 = load float, float* %319
%321 = call i32 @makecircle(i32 %279, i32 %311, i32 %312, float** %313, float %320)
br label %397
322: ; preds = %166
%323 = load float*, float** %17
%324 = load i32, i32* %33
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds float, float* %323, i64 %325
%327 = load float, float* %326
%328 = load float, float* %20
%329 = fdiv float %327, %328
%330 = fpext float %329 to double
%331 = fcmp ogt double %330, 0.000000e+00
br i1 %331, label %332, label %342
332: ; preds = %322
%333 = load float*, float** %17
%334 = load i32, i32* %33
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
%337 = load float, float* %336
%338 = load float, float* %20
%339 = fdiv float %337, %338
%340 = fpext float %339 to double
%341 = fadd double %340, 5.000000e-01
br label %352
342: ; preds = %322
%343 = load float*, float** %17
%344 = load i32, i32* %33
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
%348 = load float, float* %20
%349 = fdiv float %347, %348
%350 = fpext float %349 to double
%351 = fsub double %350, 5.000000e-01
br label %352
352: ; preds = %342, %332
%353 = phi double [ %341, %332 ], [ %351, %342 ]
%354 = fptosi double %353 to i32
%355 = load float*, float** %18
%356 = load i32, i32* %33
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %355, i64 %357
%359 = load float, float* %358
%360 = load float, float* %21
%361 = fdiv float %359, %360
%362 = fpext float %361 to double
%363 = fcmp ogt double %362, 0.000000e+00
br i1 %363, label %364, label %374
364: ; preds = %352
%365 = load float*, float** %18
%366 = load i32, i32* %33
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds float, float* %365, i64 %367
%369 = load float, float* %368
%370 = load float, float* %21
%371 = fdiv float %369, %370
%372 = fpext float %371 to double
%373 = fadd double %372, 5.000000e-01
br label %384
374: ; preds = %352
%375 = load float*, float** %18
%376 = load i32, i32* %33
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %375, i64 %377
%379 = load float, float* %378
%380 = load float, float* %21
%381 = fdiv float %379, %380
%382 = fpext float %381 to double
%383 = fsub double %382, 5.000000e-01
br label %384
384: ; preds = %374, %364
%385 = phi double [ %373, %364 ], [ %383, %374 ]
%386 = fptosi double %385 to i32
%387 = load i32, i32* %31
%388 = load float**, float*** %22
%389 = load float**, float*** %25
%390 = getelementptr inbounds float*, float** %389, i64 2
%391 = load float*, float** %390
%392 = load i32, i32* %33
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float, float* %391, i64 %393
%395 = load float, float* %394
%396 = call i32 @makesquare(i32 %354, i32 %386, i32 %387, float** %388, float %395)
br label %397
397: ; preds = %384, %309, %234
br label %398
398: ; preds = %397
%399 = load i32, i32* %33
%400 = add nsw i32 %399, 1
store i32 %400, i32* %33
br label %59
401: ; preds = %59
br label %1760
402: ; preds = %55, %52
%403 = load float**, float*** %23
%404 = icmp eq float** %403, null
br i1 %404, label %405, label %971
405: ; preds = %402
store i32 0, i32* %33
br label %406
406: ; preds = %967, %405
%407 = load i32, i32* %33
%408 = load i32, i32* %19
%409 = icmp slt i32 %407, %408
br i1 %409, label %410, label %970
410: ; preds = %406
%411 = load float*, float** %18
%412 = load i32, i32* %33
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float, float* %411, i64 %413
%415 = load float, float* %414
%416 = load float*, float** %28
%417 = load float*, float** %17
%418 = load i32, i32* %33
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds float, float* %417, i64 %419
%421 = load float, float* %420
%422 = load float, float* %20
%423 = fdiv float %421, %422
%424 = fpext float %423 to double
%425 = fcmp ogt double %424, 0.000000e+00
br i1 %425, label %426, label %436
426: ; preds = %410
%427 = load float*, float** %17
%428 = load i32, i32* %33
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds float, float* %427, i64 %429
%431 = load float, float* %430
%432 = load float, float* %20
%433 = fdiv float %431, %432
%434 = fpext float %433 to double
%435 = fadd double %434, 5.000000e-01
br label %446
436: ; preds = %410
%437 = load float*, float** %17
%438 = load i32, i32* %33
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds float, float* %437, i64 %439
%441 = load float, float* %440
%442 = load float, float* %20
%443 = fdiv float %441, %442
%444 = fpext float %443 to double
%445 = fsub double %444, 5.000000e-01
br label %446
446: ; preds = %436, %426
%447 = phi double [ %435, %426 ], [ %445, %436 ]
%448 = fptosi double %447 to i32
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds float, float* %416, i64 %449
store float %415, float* %450
%451 = load float*, float** %18
%452 = load i32, i32* %33
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds float, float* %451, i64 %453
%455 = load float, float* %454
%456 = load float, float* %21
%457 = fdiv float %455, %456
%458 = fpext float %457 to double
%459 = fcmp ogt double %458, 0.000000e+00
br i1 %459, label %460, label %470
460: ; preds = %446
%461 = load float*, float** %18
%462 = load i32, i32* %33
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds float, float* %461, i64 %463
%465 = load float, float* %464
%466 = load float, float* %21
%467 = fdiv float %465, %466
%468 = fpext float %467 to double
%469 = fadd double %468, 5.000000e-01
br label %480
470: ; preds = %446
%471 = load float*, float** %18
%472 = load i32, i32* %33
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds float, float* %471, i64 %473
%475 = load float, float* %474
%476 = load float, float* %21
%477 = fdiv float %475, %476
%478 = fpext float %477 to double
%479 = fsub double %478, 5.000000e-01
br label %480
480: ; preds = %470, %460
%481 = phi double [ %469, %460 ], [ %479, %470 ]
%482 = fptosi double %481 to i32
%483 = load i32*, i32** %29
%484 = load float*, float** %17
%485 = load i32, i32* %33
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
%488 = load float, float* %487
%489 = load float, float* %20
%490 = fdiv float %488, %489
%491 = fpext float %490 to double
%492 = fcmp ogt double %491, 0.000000e+00
br i1 %492, label %493, label %503
493: ; preds = %480
%494 = load float*, float** %17
%495 = load i32, i32* %33
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds float, float* %494, i64 %496
%498 = load float, float* %497
%499 = load float, float* %20
%500 = fdiv float %498, %499
%501 = fpext float %500 to double
%502 = fadd double %501, 5.000000e-01
br label %513
503: ; preds = %480
%504 = load float*, float** %17
%505 = load i32, i32* %33
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds float, float* %504, i64 %506
%508 = load float, float* %507
%509 = load float, float* %20
%510 = fdiv float %508, %509
%511 = fpext float %510 to double
%512 = fsub double %511, 5.000000e-01
br label %513
513: ; preds = %503, %493
%514 = phi double [ %502, %493 ], [ %512, %503 ]
%515 = fptosi double %514 to i32
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds i32, i32* %483, i64 %516
store i32 %482, i32* %517
%518 = load i32, i32* %32
switch i32 %518, label %817 [
i32 1, label %519
i32 2, label %668
]
519: ; preds = %513
%520 = load float*, float** %17
%521 = load i32, i32* %33
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds float, float* %520, i64 %522
%524 = load float, float* %523
%525 = load float, float* %20
%526 = fdiv float %524, %525
%527 = fpext float %526 to double
%528 = fcmp ogt double %527, 0.000000e+00
br i1 %528, label %529, label %539
529: ; preds = %519
%530 = load float*, float** %17
%531 = load i32, i32* %33
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds float, float* %530, i64 %532
%534 = load float, float* %533
%535 = load float, float* %20
%536 = fdiv float %534, %535
%537 = fpext float %536 to double
%538 = fadd double %537, 5.000000e-01
br label %549
539: ; preds = %519
%540 = load float*, float** %17
%541 = load i32, i32* %33
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds float, float* %540, i64 %542
%544 = load float, float* %543
%545 = load float, float* %20
%546 = fdiv float %544, %545
%547 = fpext float %546 to double
%548 = fsub double %547, 5.000000e-01
br label %549
549: ; preds = %539, %529
%550 = phi double [ %538, %529 ], [ %548, %539 ]
%551 = fptosi double %550 to i32
%552 = load float*, float** %18
%553 = load i32, i32* %33
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds float, float* %552, i64 %554
%556 = load float, float* %555
%557 = load float, float* %21
%558 = fdiv float %556, %557
%559 = fpext float %558 to double
%560 = fcmp ogt double %559, 0.000000e+00
br i1 %560, label %561, label %571
561: ; preds = %549
%562 = load float*, float** %18
%563 = load i32, i32* %33
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds float, float* %562, i64 %564
%566 = load float, float* %565
%567 = load float, float* %21
%568 = fdiv float %566, %567
%569 = fpext float %568 to double
%570 = fadd double %569, 5.000000e-01
br label %581
571: ; preds = %549
%572 = load float*, float** %18
%573 = load i32, i32* %33
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float, float* %572, i64 %574
%576 = load float, float* %575
%577 = load float, float* %21
%578 = fdiv float %576, %577
%579 = fpext float %578 to double
%580 = fsub double %579, 5.000000e-01
br label %581
581: ; preds = %571, %561
%582 = phi double [ %570, %561 ], [ %580, %571 ]
%583 = fptosi double %582 to i32
%584 = load i32, i32* %31
%585 = load float**, float*** %22
%586 = load float**, float*** %25
%587 = getelementptr inbounds float*, float** %586, i64 2
%588 = load float*, float** %587
%589 = load i32, i32* %33
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
%593 = call i32 @makediamond(i32 %551, i32 %583, i32 %584, float** %585, float %592)
%594 = load float*, float** %17
%595 = load i32, i32* %33
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds float, float* %594, i64 %596
%598 = load float, float* %597
%599 = load float, float* %20
%600 = fdiv float %598, %599
%601 = fpext float %600 to double
%602 = fcmp ogt double %601, 0.000000e+00
br i1 %602, label %603, label %613
603: ; preds = %581
%604 = load float*, float** %17
%605 = load i32, i32* %33
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds float, float* %604, i64 %606
%608 = load float, float* %607
%609 = load float, float* %20
%610 = fdiv float %608, %609
%611 = fpext float %610 to double
%612 = fadd double %611, 5.000000e-01
br label %623
613: ; preds = %581
%614 = load float*, float** %17
%615 = load i32, i32* %33
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds float, float* %614, i64 %616
%618 = load float, float* %617
%619 = load float, float* %20
%620 = fdiv float %618, %619
%621 = fpext float %620 to double
%622 = fsub double %621, 5.000000e-01
br label %623
623: ; preds = %613, %603
%624 = phi double [ %612, %603 ], [ %622, %613 ]
%625 = fptosi double %624 to i32
%626 = load float*, float** %18
%627 = load i32, i32* %33
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds float, float* %626, i64 %628
%630 = load float, float* %629
%631 = load float, float* %21
%632 = fdiv float %630, %631
%633 = fpext float %632 to double
%634 = fcmp ogt double %633, 0.000000e+00
br i1 %634, label %635, label %645
635: ; preds = %623
%636 = load float*, float** %18
%637 = load i32, i32* %33
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds float, float* %636, i64 %638
%640 = load float, float* %639
%641 = load float, float* %21
%642 = fdiv float %640, %641
%643 = fpext float %642 to double
%644 = fadd double %643, 5.000000e-01
br label %655
645: ; preds = %623
%646 = load float*, float** %18
%647 = load i32, i32* %33
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds float, float* %646, i64 %648
%650 = load float, float* %649
%651 = load float, float* %21
%652 = fdiv float %650, %651
%653 = fpext float %652 to double
%654 = fsub double %653, 5.000000e-01
br label %655
655: ; preds = %645, %635
%656 = phi double [ %644, %635 ], [ %654, %645 ]
%657 = fptosi double %656 to i32
%658 = load i32, i32* %31
%659 = load float**, float*** %24
%660 = load float**, float*** %27
%661 = getelementptr inbounds float*, float** %660, i64 2
%662 = load float*, float** %661
%663 = load i32, i32* %33
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds float, float* %662, i64 %664
%666 = load float, float* %665
%667 = call i32 @makediamond(i32 %625, i32 %657, i32 %658, float** %659, float %666)
br label %966
668: ; preds = %513
%669 = load float*, float** %17
%670 = load i32, i32* %33
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds float, float* %669, i64 %671
%673 = load float, float* %672
%674 = load float, float* %20
%675 = fdiv float %673, %674
%676 = fpext float %675 to double
%677 = fcmp ogt double %676, 0.000000e+00
br i1 %677, label %678, label %688
678: ; preds = %668
%679 = load float*, float** %17
%680 = load i32, i32* %33
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds float, float* %679, i64 %681
%683 = load float, float* %682
%684 = load float, float* %20
%685 = fdiv float %683, %684
%686 = fpext float %685 to double
%687 = fadd double %686, 5.000000e-01
br label %698
688: ; preds = %668
%689 = load float*, float** %17
%690 = load i32, i32* %33
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %689, i64 %691
%693 = load float, float* %692
%694 = load float, float* %20
%695 = fdiv float %693, %694
%696 = fpext float %695 to double
%697 = fsub double %696, 5.000000e-01
br label %698
698: ; preds = %688, %678
%699 = phi double [ %687, %678 ], [ %697, %688 ]
%700 = fptosi double %699 to i32
%701 = load float*, float** %18
%702 = load i32, i32* %33
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds float, float* %701, i64 %703
%705 = load float, float* %704
%706 = load float, float* %21
%707 = fdiv float %705, %706
%708 = fpext float %707 to double
%709 = fcmp ogt double %708, 0.000000e+00
br i1 %709, label %710, label %720
710: ; preds = %698
%711 = load float*, float** %18
%712 = load i32, i32* %33
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds float, float* %711, i64 %713
%715 = load float, float* %714
%716 = load float, float* %21
%717 = fdiv float %715, %716
%718 = fpext float %717 to double
%719 = fadd double %718, 5.000000e-01
br label %730
720: ; preds = %698
%721 = load float*, float** %18
%722 = load i32, i32* %33
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds float, float* %721, i64 %723
%725 = load float, float* %724
%726 = load float, float* %21
%727 = fdiv float %725, %726
%728 = fpext float %727 to double
%729 = fsub double %728, 5.000000e-01
br label %730
730: ; preds = %720, %710
%731 = phi double [ %719, %710 ], [ %729, %720 ]
%732 = fptosi double %731 to i32
%733 = load i32, i32* %31
%734 = load float**, float*** %22
%735 = load float**, float*** %25
%736 = getelementptr inbounds float*, float** %735, i64 2
%737 = load float*, float** %736
%738 = load i32, i32* %33
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %737, i64 %739
%741 = load float, float* %740
%742 = call i32 @makecircle(i32 %700, i32 %732, i32 %733, float** %734, float %741)
%743 = load float*, float** %17
%744 = load i32, i32* %33
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds float, float* %743, i64 %745
%747 = load float, float* %746
%748 = load float, float* %20
%749 = fdiv float %747, %748
%750 = fpext float %749 to double
%751 = fcmp ogt double %750, 0.000000e+00
br i1 %751, label %752, label %762
752: ; preds = %730
%753 = load float*, float** %17
%754 = load i32, i32* %33
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds float, float* %753, i64 %755
%757 = load float, float* %756
%758 = load float, float* %20
%759 = fdiv float %757, %758
%760 = fpext float %759 to double
%761 = fadd double %760, 5.000000e-01
br label %772
762: ; preds = %730
%763 = load float*, float** %17
%764 = load i32, i32* %33
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds float, float* %763, i64 %765
%767 = load float, float* %766
%768 = load float, float* %20
%769 = fdiv float %767, %768
%770 = fpext float %769 to double
%771 = fsub double %770, 5.000000e-01
br label %772
772: ; preds = %762, %752
%773 = phi double [ %761, %752 ], [ %771, %762 ]
%774 = fptosi double %773 to i32
%775 = load float*, float** %18
%776 = load i32, i32* %33
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds float, float* %775, i64 %777
%779 = load float, float* %778
%780 = load float, float* %21
%781 = fdiv float %779, %780
%782 = fpext float %781 to double
%783 = fcmp ogt double %782, 0.000000e+00
br i1 %783, label %784, label %794
784: ; preds = %772
%785 = load float*, float** %18
%786 = load i32, i32* %33
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds float, float* %785, i64 %787
%789 = load float, float* %788
%790 = load float, float* %21
%791 = fdiv float %789, %790
%792 = fpext float %791 to double
%793 = fadd double %792, 5.000000e-01
br label %804
794: ; preds = %772
%795 = load float*, float** %18
%796 = load i32, i32* %33
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds float, float* %795, i64 %797
%799 = load float, float* %798
%800 = load float, float* %21
%801 = fdiv float %799, %800
%802 = fpext float %801 to double
%803 = fsub double %802, 5.000000e-01
br label %804
804: ; preds = %794, %784
%805 = phi double [ %793, %784 ], [ %803, %794 ]
%806 = fptosi double %805 to i32
%807 = load i32, i32* %31
%808 = load float**, float*** %24
%809 = load float**, float*** %27
%810 = getelementptr inbounds float*, float** %809, i64 2
%811 = load float*, float** %810
%812 = load i32, i32* %33
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds float, float* %811, i64 %813
%815 = load float, float* %814
%816 = call i32 @makecircle(i32 %774, i32 %806, i32 %807, float** %808, float %815)
br label %966
817: ; preds = %513
%818 = load float*, float** %17
%819 = load i32, i32* %33
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds float, float* %818, i64 %820
%822 = load float, float* %821
%823 = load float, float* %20
%824 = fdiv float %822, %823
%825 = fpext float %824 to double
%826 = fcmp ogt double %825, 0.000000e+00
br i1 %826, label %827, label %837
827: ; preds = %817
%828 = load float*, float** %17
%829 = load i32, i32* %33
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds float, float* %828, i64 %830
%832 = load float, float* %831
%833 = load float, float* %20
%834 = fdiv float %832, %833
%835 = fpext float %834 to double
%836 = fadd double %835, 5.000000e-01
br label %847
837: ; preds = %817
%838 = load float*, float** %17
%839 = load i32, i32* %33
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds float, float* %838, i64 %840
%842 = load float, float* %841
%843 = load float, float* %20
%844 = fdiv float %842, %843
%845 = fpext float %844 to double
%846 = fsub double %845, 5.000000e-01
br label %847
847: ; preds = %837, %827
%848 = phi double [ %836, %827 ], [ %846, %837 ]
%849 = fptosi double %848 to i32
%850 = load float*, float** %18
%851 = load i32, i32* %33
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds float, float* %850, i64 %852
%854 = load float, float* %853
%855 = load float, float* %21
%856 = fdiv float %854, %855
%857 = fpext float %856 to double
%858 = fcmp ogt double %857, 0.000000e+00
br i1 %858, label %859, label %869
859: ; preds = %847
%860 = load float*, float** %18
%861 = load i32, i32* %33
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds float, float* %860, i64 %862
%864 = load float, float* %863
%865 = load float, float* %21
%866 = fdiv float %864, %865
%867 = fpext float %866 to double
%868 = fadd double %867, 5.000000e-01
br label %879
869: ; preds = %847
%870 = load float*, float** %18
%871 = load i32, i32* %33
%872 = sext i32 %871 to i64
%873 = getelementptr inbounds float, float* %870, i64 %872
%874 = load float, float* %873
%875 = load float, float* %21
%876 = fdiv float %874, %875
%877 = fpext float %876 to double
%878 = fsub double %877, 5.000000e-01
br label %879
879: ; preds = %869, %859
%880 = phi double [ %868, %859 ], [ %878, %869 ]
%881 = fptosi double %880 to i32
%882 = load i32, i32* %31
%883 = load float**, float*** %22
%884 = load float**, float*** %25
%885 = getelementptr inbounds float*, float** %884, i64 2
%886 = load float*, float** %885
%887 = load i32, i32* %33
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds float, float* %886, i64 %888
%890 = load float, float* %889
%891 = call i32 @makesquare(i32 %849, i32 %881, i32 %882, float** %883, float %890)
%892 = load float*, float** %17
%893 = load i32, i32* %33
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds float, float* %892, i64 %894
%896 = load float, float* %895
%897 = load float, float* %20
%898 = fdiv float %896, %897
%899 = fpext float %898 to double
%900 = fcmp ogt double %899, 0.000000e+00
br i1 %900, label %901, label %911
901: ; preds = %879
%902 = load float*, float** %17
%903 = load i32, i32* %33
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds float, float* %902, i64 %904
%906 = load float, float* %905
%907 = load float, float* %20
%908 = fdiv float %906, %907
%909 = fpext float %908 to double
%910 = fadd double %909, 5.000000e-01
br label %921
911: ; preds = %879
%912 = load float*, float** %17
%913 = load i32, i32* %33
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds float, float* %912, i64 %914
%916 = load float, float* %915
%917 = load float, float* %20
%918 = fdiv float %916, %917
%919 = fpext float %918 to double
%920 = fsub double %919, 5.000000e-01
br label %921
921: ; preds = %911, %901
%922 = phi double [ %910, %901 ], [ %920, %911 ]
%923 = fptosi double %922 to i32
%924 = load float*, float** %18
%925 = load i32, i32* %33
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds float, float* %924, i64 %926
%928 = load float, float* %927
%929 = load float, float* %21
%930 = fdiv float %928, %929
%931 = fpext float %930 to double
%932 = fcmp ogt double %931, 0.000000e+00
br i1 %932, label %933, label %943
933: ; preds = %921
%934 = load float*, float** %18
%935 = load i32, i32* %33
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds float, float* %934, i64 %936
%938 = load float, float* %937
%939 = load float, float* %21
%940 = fdiv float %938, %939
%941 = fpext float %940 to double
%942 = fadd double %941, 5.000000e-01
br label %953
943: ; preds = %921
%944 = load float*, float** %18
%945 = load i32, i32* %33
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds float, float* %944, i64 %946
%948 = load float, float* %947
%949 = load float, float* %21
%950 = fdiv float %948, %949
%951 = fpext float %950 to double
%952 = fsub double %951, 5.000000e-01
br label %953
953: ; preds = %943, %933
%954 = phi double [ %942, %933 ], [ %952, %943 ]
%955 = fptosi double %954 to i32
%956 = load i32, i32* %31
%957 = load float**, float*** %24
%958 = load float**, float*** %27
%959 = getelementptr inbounds float*, float** %958, i64 2
%960 = load float*, float** %959
%961 = load i32, i32* %33
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds float, float* %960, i64 %962
%964 = load float, float* %963
%965 = call i32 @makesquare(i32 %923, i32 %955, i32 %956, float** %957, float %964)
br label %966
966: ; preds = %953, %804, %655
br label %967
967: ; preds = %966
%968 = load i32, i32* %33
%969 = add nsw i32 %968, 1
store i32 %969, i32* %33
br label %406
970: ; preds = %406
br label %1759
971: ; preds = %402
store i32 0, i32* %33
br label %972
972: ; preds = %1755, %971
%973 = load i32, i32* %33
%974 = load i32, i32* %19
%975 = icmp slt i32 %973, %974
br i1 %975, label %976, label %1758
976: ; preds = %972
%977 = load float*, float** %18
%978 = load i32, i32* %33
%979 = sext i32 %978 to i64
%980 = getelementptr inbounds float, float* %977, i64 %979
%981 = load float, float* %980
%982 = load float*, float** %28
%983 = load float*, float** %17
%984 = load i32, i32* %33
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds float, float* %983, i64 %985
%987 = load float, float* %986
%988 = load float, float* %20
%989 = fdiv float %987, %988
%990 = fpext float %989 to double
%991 = fcmp ogt double %990, 0.000000e+00
br i1 %991, label %992, label %1002
992: ; preds = %976
%993 = load float*, float** %17
%994 = load i32, i32* %33
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds float, float* %993, i64 %995
%997 = load float, float* %996
%998 = load float, float* %20
%999 = fdiv float %997, %998
%1000 = fpext float %999 to double
%1001 = fadd double %1000, 5.000000e-01
br label %1012
1002: ; preds = %976
%1003 = load float*, float** %17
%1004 = load i32, i32* %33
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds float, float* %1003, i64 %1005
%1007 = load float, float* %1006
%1008 = load float, float* %20
%1009 = fdiv float %1007, %1008
%1010 = fpext float %1009 to double
%1011 = fsub double %1010, 5.000000e-01
br label %1012
1012: ; preds = %1002, %992
%1013 = phi double [ %1001, %992 ], [ %1011, %1002 ]
%1014 = fptosi double %1013 to i32
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds float, float* %982, i64 %1015
store float %981, float* %1016
%1017 = load float*, float** %18
%1018 = load i32, i32* %33
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds float, float* %1017, i64 %1019
%1021 = load float, float* %1020
%1022 = load float, float* %21
%1023 = fdiv float %1021, %1022
%1024 = fpext float %1023 to double
%1025 = fcmp ogt double %1024, 0.000000e+00
br i1 %1025, label %1026, label %1036
1026: ; preds = %1012
%1027 = load float*, float** %18
%1028 = load i32, i32* %33
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds float, float* %1027, i64 %1029
%1031 = load float, float* %1030
%1032 = load float, float* %21
%1033 = fdiv float %1031, %1032
%1034 = fpext float %1033 to double
%1035 = fadd double %1034, 5.000000e-01
br label %1046
1036: ; preds = %1012
%1037 = load float*, float** %18
%1038 = load i32, i32* %33
%1039 = sext i32 %1038 to i64
%1040 = getelementptr inbounds float, float* %1037, i64 %1039
%1041 = load float, float* %1040
%1042 = load float, float* %21
%1043 = fdiv float %1041, %1042
%1044 = fpext float %1043 to double
%1045 = fsub double %1044, 5.000000e-01
br label %1046
1046: ; preds = %1036, %1026
%1047 = phi double [ %1035, %1026 ], [ %1045, %1036 ]
%1048 = fptosi double %1047 to i32
%1049 = load i32*, i32** %29
%1050 = load float*, float** %17
%1051 = load i32, i32* %33
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds float, float* %1050, i64 %1052
%1054 = load float, float* %1053
%1055 = load float, float* %20
%1056 = fdiv float %1054, %1055
%1057 = fpext float %1056 to double
%1058 = fcmp ogt double %1057, 0.000000e+00
br i1 %1058, label %1059, label %1069
1059: ; preds = %1046
%1060 = load float*, float** %17
%1061 = load i32, i32* %33
%1062 = sext i32 %1061 to i64
%1063 = getelementptr inbounds float, float* %1060, i64 %1062
%1064 = load float, float* %1063
%1065 = load float, float* %20
%1066 = fdiv float %1064, %1065
%1067 = fpext float %1066 to double
%1068 = fadd double %1067, 5.000000e-01
br label %1079
1069: ; preds = %1046
%1070 = load float*, float** %17
%1071 = load i32, i32* %33
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds float, float* %1070, i64 %1072
%1074 = load float, float* %1073
%1075 = load float, float* %20
%1076 = fdiv float %1074, %1075
%1077 = fpext float %1076 to double
%1078 = fsub double %1077, 5.000000e-01
br label %1079
1079: ; preds = %1069, %1059
%1080 = phi double [ %1068, %1059 ], [ %1078, %1069 ]
%1081 = fptosi double %1080 to i32
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds i32, i32* %1049, i64 %1082
store i32 %1048, i32* %1083
%1084 = load i32, i32* %32
switch i32 %1084, label %1531 [
i32 1, label %1085
i32 2, label %1308
]
1085: ; preds = %1079
%1086 = load float*, float** %17
%1087 = load i32, i32* %33
%1088 = sext i32 %1087 to i64
%1089 = getelementptr inbounds float, float* %1086, i64 %1088
%1090 = load float, float* %1089
%1091 = load float, float* %20
%1092 = fdiv float %1090, %1091
%1093 = fpext float %1092 to double
%1094 = fcmp ogt double %1093, 0.000000e+00
br i1 %1094, label %1095, label %1105
1095: ; preds = %1085
%1096 = load float*, float** %17
%1097 = load i32, i32* %33
%1098 = sext i32 %1097 to i64
%1099 = getelementptr inbounds float, float* %1096, i64 %1098
%1100 = load float, float* %1099
%1101 = load float, float* %20
%1102 = fdiv float %1100, %1101
%1103 = fpext float %1102 to double
%1104 = fadd double %1103, 5.000000e-01
br label %1115
1105: ; preds = %1085
%1106 = load float*, float** %17
%1107 = load i32, i32* %33
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds float, float* %1106, i64 %1108
%1110 = load float, float* %1109
%1111 = load float, float* %20
%1112 = fdiv float %1110, %1111
%1113 = fpext float %1112 to double
%1114 = fsub double %1113, 5.000000e-01
br label %1115
1115: ; preds = %1105, %1095
%1116 = phi double [ %1104, %1095 ], [ %1114, %1105 ]
%1117 = fptosi double %1116 to i32
%1118 = load float*, float** %18
%1119 = load i32, i32* %33
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds float, float* %1118, i64 %1120
%1122 = load float, float* %1121
%1123 = load float, float* %21
%1124 = fdiv float %1122, %1123
%1125 = fpext float %1124 to double
%1126 = fcmp ogt double %1125, 0.000000e+00
br i1 %1126, label %1127, label %1137
1127: ; preds = %1115
%1128 = load float*, float** %18
%1129 = load i32, i32* %33
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds float, float* %1128, i64 %1130
%1132 = load float, float* %1131
%1133 = load float, float* %21
%1134 = fdiv float %1132, %1133
%1135 = fpext float %1134 to double
%1136 = fadd double %1135, 5.000000e-01
br label %1147
1137: ; preds = %1115
%1138 = load float*, float** %18
%1139 = load i32, i32* %33
%1140 = sext i32 %1139 to i64
%1141 = getelementptr inbounds float, float* %1138, i64 %1140
%1142 = load float, float* %1141
%1143 = load float, float* %21
%1144 = fdiv float %1142, %1143
%1145 = fpext float %1144 to double
%1146 = fsub double %1145, 5.000000e-01
br label %1147
1147: ; preds = %1137, %1127
%1148 = phi double [ %1136, %1127 ], [ %1146, %1137 ]
%1149 = fptosi double %1148 to i32
%1150 = load i32, i32* %31
%1151 = load float**, float*** %22
%1152 = load float**, float*** %25
%1153 = getelementptr inbounds float*, float** %1152, i64 2
%1154 = load float*, float** %1153
%1155 = load i32, i32* %33
%1156 = sext i32 %1155 to i64
%1157 = getelementptr inbounds float, float* %1154, i64 %1156
%1158 = load float, float* %1157
%1159 = call i32 @makediamond(i32 %1117, i32 %1149, i32 %1150, float** %1151, float %1158)
%1160 = load float*, float** %17
%1161 = load i32, i32* %33
%1162 = sext i32 %1161 to i64
%1163 = getelementptr inbounds float, float* %1160, i64 %1162
%1164 = load float, float* %1163
%1165 = load float, float* %20
%1166 = fdiv float %1164, %1165
%1167 = fpext float %1166 to double
%1168 = fcmp ogt double %1167, 0.000000e+00
br i1 %1168, label %1169, label %1179
1169: ; preds = %1147
%1170 = load float*, float** %17
%1171 = load i32, i32* %33
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds float, float* %1170, i64 %1172
%1174 = load float, float* %1173
%1175 = load float, float* %20
%1176 = fdiv float %1174, %1175
%1177 = fpext float %1176 to double
%1178 = fadd double %1177, 5.000000e-01
br label %1189
1179: ; preds = %1147
%1180 = load float*, float** %17
%1181 = load i32, i32* %33
%1182 = sext i32 %1181 to i64
%1183 = getelementptr inbounds float, float* %1180, i64 %1182
%1184 = load float, float* %1183
%1185 = load float, float* %20
%1186 = fdiv float %1184, %1185
%1187 = fpext float %1186 to double
%1188 = fsub double %1187, 5.000000e-01
br label %1189
1189: ; preds = %1179, %1169
%1190 = phi double [ %1178, %1169 ], [ %1188, %1179 ]
%1191 = fptosi double %1190 to i32
%1192 = load float*, float** %18
%1193 = load i32, i32* %33
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds float, float* %1192, i64 %1194
%1196 = load float, float* %1195
%1197 = load float, float* %21
%1198 = fdiv float %1196, %1197
%1199 = fpext float %1198 to double
%1200 = fcmp ogt double %1199, 0.000000e+00
br i1 %1200, label %1201, label %1211
1201: ; preds = %1189
%1202 = load float*, float** %18
%1203 = load i32, i32* %33
%1204 = sext i32 %1203 to i64
%1205 = getelementptr inbounds float, float* %1202, i64 %1204
%1206 = load float, float* %1205
%1207 = load float, float* %21
%1208 = fdiv float %1206, %1207
%1209 = fpext float %1208 to double
%1210 = fadd double %1209, 5.000000e-01
br label %1221
1211: ; preds = %1189
%1212 = load float*, float** %18
%1213 = load i32, i32* %33
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds float, float* %1212, i64 %1214
%1216 = load float, float* %1215
%1217 = load float, float* %21
%1218 = fdiv float %1216, %1217
%1219 = fpext float %1218 to double
%1220 = fsub double %1219, 5.000000e-01
br label %1221
1221: ; preds = %1211, %1201
%1222 = phi double [ %1210, %1201 ], [ %1220, %1211 ]
%1223 = fptosi double %1222 to i32
%1224 = load i32, i32* %31
%1225 = load float**, float*** %24
%1226 = load float**, float*** %27
%1227 = getelementptr inbounds float*, float** %1226, i64 2
%1228 = load float*, float** %1227
%1229 = load i32, i32* %33
%1230 = sext i32 %1229 to i64
%1231 = getelementptr inbounds float, float* %1228, i64 %1230
%1232 = load float, float* %1231
%1233 = call i32 @makediamond(i32 %1191, i32 %1223, i32 %1224, float** %1225, float %1232)
%1234 = load float*, float** %17
%1235 = load i32, i32* %33
%1236 = sext i32 %1235 to i64
%1237 = getelementptr inbounds float, float* %1234, i64 %1236
%1238 = load float, float* %1237
%1239 = load float, float* %20
%1240 = fdiv float %1238, %1239
%1241 = fpext float %1240 to double
%1242 = fcmp ogt double %1241, 0.000000e+00
br i1 %1242, label %1243, label %1253
1243: ; preds = %1221
%1244 = load float*, float** %17
%1245 = load i32, i32* %33
%1246 = sext i32 %1245 to i64
%1247 = getelementptr inbounds float, float* %1244, i64 %1246
%1248 = load float, float* %1247
%1249 = load float, float* %20
%1250 = fdiv float %1248, %1249
%1251 = fpext float %1250 to double
%1252 = fadd double %1251, 5.000000e-01
br label %1263
1253: ; preds = %1221
%1254 = load float*, float** %17
%1255 = load i32, i32* %33
%1256 = sext i32 %1255 to i64
%1257 = getelementptr inbounds float, float* %1254, i64 %1256
%1258 = load float, float* %1257
%1259 = load float, float* %20
%1260 = fdiv float %1258, %1259
%1261 = fpext float %1260 to double
%1262 = fsub double %1261, 5.000000e-01
br label %1263
1263: ; preds = %1253, %1243
%1264 = phi double [ %1252, %1243 ], [ %1262, %1253 ]
%1265 = fptosi double %1264 to i32
%1266 = load float*, float** %18
%1267 = load i32, i32* %33
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds float, float* %1266, i64 %1268
%1270 = load float, float* %1269
%1271 = load float, float* %21
%1272 = fdiv float %1270, %1271
%1273 = fpext float %1272 to double
%1274 = fcmp ogt double %1273, 0.000000e+00
br i1 %1274, label %1275, label %1285
1275: ; preds = %1263
%1276 = load float*, float** %18
%1277 = load i32, i32* %33
%1278 = sext i32 %1277 to i64
%1279 = getelementptr inbounds float, float* %1276, i64 %1278
%1280 = load float, float* %1279
%1281 = load float, float* %21
%1282 = fdiv float %1280, %1281
%1283 = fpext float %1282 to double
%1284 = fadd double %1283, 5.000000e-01
br label %1295
1285: ; preds = %1263
%1286 = load float*, float** %18
%1287 = load i32, i32* %33
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds float, float* %1286, i64 %1288
%1290 = load float, float* %1289
%1291 = load float, float* %21
%1292 = fdiv float %1290, %1291
%1293 = fpext float %1292 to double
%1294 = fsub double %1293, 5.000000e-01
br label %1295
1295: ; preds = %1285, %1275
%1296 = phi double [ %1284, %1275 ], [ %1294, %1285 ]
%1297 = fptosi double %1296 to i32
%1298 = load i32, i32* %31
%1299 = load float**, float*** %23
%1300 = load float**, float*** %26
%1301 = getelementptr inbounds float*, float** %1300, i64 2
%1302 = load float*, float** %1301
%1303 = load i32, i32* %33
%1304 = sext i32 %1303 to i64
%1305 = getelementptr inbounds float, float* %1302, i64 %1304
%1306 = load float, float* %1305
%1307 = call i32 @makediamond(i32 %1265, i32 %1297, i32 %1298, float** %1299, float %1306)
br label %1754
1308: ; preds = %1079
%1309 = load float*, float** %17
%1310 = load i32, i32* %33
%1311 = sext i32 %1310 to i64
%1312 = getelementptr inbounds float, float* %1309, i64 %1311
%1313 = load float, float* %1312
%1314 = load float, float* %20
%1315 = fdiv float %1313, %1314
%1316 = fpext float %1315 to double
%1317 = fcmp ogt double %1316, 0.000000e+00
br i1 %1317, label %1318, label %1328
1318: ; preds = %1308
%1319 = load float*, float** %17
%1320 = load i32, i32* %33
%1321 = sext i32 %1320 to i64
%1322 = getelementptr inbounds float, float* %1319, i64 %1321
%1323 = load float, float* %1322
%1324 = load float, float* %20
%1325 = fdiv float %1323, %1324
%1326 = fpext float %1325 to double
%1327 = fadd double %1326, 5.000000e-01
br label %1338
1328: ; preds = %1308
%1329 = load float*, float** %17
%1330 = load i32, i32* %33
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds float, float* %1329, i64 %1331
%1333 = load float, float* %1332
%1334 = load float, float* %20
%1335 = fdiv float %1333, %1334
%1336 = fpext float %1335 to double
%1337 = fsub double %1336, 5.000000e-01
br label %1338
1338: ; preds = %1328, %1318
%1339 = phi double [ %1327, %1318 ], [ %1337, %1328 ]
%1340 = fptosi double %1339 to i32
%1341 = load float*, float** %18
%1342 = load i32, i32* %33
%1343 = sext i32 %1342 to i64
%1344 = getelementptr inbounds float, float* %1341, i64 %1343
%1345 = load float, float* %1344
%1346 = load float, float* %21
%1347 = fdiv float %1345, %1346
%1348 = fpext float %1347 to double
%1349 = fcmp ogt double %1348, 0.000000e+00
br i1 %1349, label %1350, label %1360
1350: ; preds = %1338
%1351 = load float*, float** %18
%1352 = load i32, i32* %33
%1353 = sext i32 %1352 to i64
%1354 = getelementptr inbounds float, float* %1351, i64 %1353
%1355 = load float, float* %1354
%1356 = load float, float* %21
%1357 = fdiv float %1355, %1356
%1358 = fpext float %1357 to double
%1359 = fadd double %1358, 5.000000e-01
br label %1370
1360: ; preds = %1338
%1361 = load float*, float** %18
%1362 = load i32, i32* %33
%1363 = sext i32 %1362 to i64
%1364 = getelementptr inbounds float, float* %1361, i64 %1363
%1365 = load float, float* %1364
%1366 = load float, float* %21
%1367 = fdiv float %1365, %1366
%1368 = fpext float %1367 to double
%1369 = fsub double %1368, 5.000000e-01
br label %1370
1370: ; preds = %1360, %1350
%1371 = phi double [ %1359, %1350 ], [ %1369, %1360 ]
%1372 = fptosi double %1371 to i32
%1373 = load i32, i32* %31
%1374 = load float**, float*** %22
%1375 = load float**, float*** %25
%1376 = getelementptr inbounds float*, float** %1375, i64 2
%1377 = load float*, float** %1376
%1378 = load i32, i32* %33
%1379 = sext i32 %1378 to i64
%1380 = getelementptr inbounds float, float* %1377, i64 %1379
%1381 = load float, float* %1380
%1382 = call i32 @makecircle(i32 %1340, i32 %1372, i32 %1373, float** %1374, float %1381)
%1383 = load float*, float** %17
%1384 = load i32, i32* %33
%1385 = sext i32 %1384 to i64
%1386 = getelementptr inbounds float, float* %1383, i64 %1385
%1387 = load float, float* %1386
%1388 = load float, float* %20
%1389 = fdiv float %1387, %1388
%1390 = fpext float %1389 to double
%1391 = fcmp ogt double %1390, 0.000000e+00
br i1 %1391, label %1392, label %1402
1392: ; preds = %1370
%1393 = load float*, float** %17
%1394 = load i32, i32* %33
%1395 = sext i32 %1394 to i64
%1396 = getelementptr inbounds float, float* %1393, i64 %1395
%1397 = load float, float* %1396
%1398 = load float, float* %20
%1399 = fdiv float %1397, %1398
%1400 = fpext float %1399 to double
%1401 = fadd double %1400, 5.000000e-01
br label %1412
1402: ; preds = %1370
%1403 = load float*, float** %17
%1404 = load i32, i32* %33
%1405 = sext i32 %1404 to i64
%1406 = getelementptr inbounds float, float* %1403, i64 %1405
%1407 = load float, float* %1406
%1408 = load float, float* %20
%1409 = fdiv float %1407, %1408
%1410 = fpext float %1409 to double
%1411 = fsub double %1410, 5.000000e-01
br label %1412
1412: ; preds = %1402, %1392
%1413 = phi double [ %1401, %1392 ], [ %1411, %1402 ]
%1414 = fptosi double %1413 to i32
%1415 = load float*, float** %18
%1416 = load i32, i32* %33
%1417 = sext i32 %1416 to i64
%1418 = getelementptr inbounds float, float* %1415, i64 %1417
%1419 = load float, float* %1418
%1420 = load float, float* %21
%1421 = fdiv float %1419, %1420
%1422 = fpext float %1421 to double
%1423 = fcmp ogt double %1422, 0.000000e+00
br i1 %1423, label %1424, label %1434
1424: ; preds = %1412
%1425 = load float*, float** %18
%1426 = load i32, i32* %33
%1427 = sext i32 %1426 to i64
%1428 = getelementptr inbounds float, float* %1425, i64 %1427
%1429 = load float, float* %1428
%1430 = load float, float* %21
%1431 = fdiv float %1429, %1430
%1432 = fpext float %1431 to double
%1433 = fadd double %1432, 5.000000e-01
br label %1444
1434: ; preds = %1412
%1435 = load float*, float** %18
%1436 = load i32, i32* %33
%1437 = sext i32 %1436 to i64
%1438 = getelementptr inbounds float, float* %1435, i64 %1437
%1439 = load float, float* %1438
%1440 = load float, float* %21
%1441 = fdiv float %1439, %1440
%1442 = fpext float %1441 to double
%1443 = fsub double %1442, 5.000000e-01
br label %1444
1444: ; preds = %1434, %1424
%1445 = phi double [ %1433, %1424 ], [ %1443, %1434 ]
%1446 = fptosi double %1445 to i32
%1447 = load i32, i32* %31
%1448 = load float**, float*** %24
%1449 = load float**, float*** %27
%1450 = getelementptr inbounds float*, float** %1449, i64 2
%1451 = load float*, float** %1450
%1452 = load i32, i32* %33
%1453 = sext i32 %1452 to i64
%1454 = getelementptr inbounds float, float* %1451, i64 %1453
%1455 = load float, float* %1454
%1456 = call i32 @makecircle(i32 %1414, i32 %1446, i32 %1447, float** %1448, float %1455)
%1457 = load float*, float** %17
%1458 = load i32, i32* %33
%1459 = sext i32 %1458 to i64
%1460 = getelementptr inbounds float, float* %1457, i64 %1459
%1461 = load float, float* %1460
%1462 = load float, float* %20
%1463 = fdiv float %1461, %1462
%1464 = fpext float %1463 to double
%1465 = fcmp ogt double %1464, 0.000000e+00
br i1 %1465, label %1466, label %1476
1466: ; preds = %1444
%1467 = load float*, float** %17
%1468 = load i32, i32* %33
%1469 = sext i32 %1468 to i64
%1470 = getelementptr inbounds float, float* %1467, i64 %1469
%1471 = load float, float* %1470
%1472 = load float, float* %20
%1473 = fdiv float %1471, %1472
%1474 = fpext float %1473 to double
%1475 = fadd double %1474, 5.000000e-01
br label %1486
1476: ; preds = %1444
%1477 = load float*, float** %17
%1478 = load i32, i32* %33
%1479 = sext i32 %1478 to i64
%1480 = getelementptr inbounds float, float* %1477, i64 %1479
%1481 = load float, float* %1480
%1482 = load float, float* %20
%1483 = fdiv float %1481, %1482
%1484 = fpext float %1483 to double
%1485 = fsub double %1484, 5.000000e-01
br label %1486
1486: ; preds = %1476, %1466
%1487 = phi double [ %1475, %1466 ], [ %1485, %1476 ]
%1488 = fptosi double %1487 to i32
%1489 = load float*, float** %18
%1490 = load i32, i32* %33
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds float, float* %1489, i64 %1491
%1493 = load float, float* %1492
%1494 = load float, float* %21
%1495 = fdiv float %1493, %1494
%1496 = fpext float %1495 to double
%1497 = fcmp ogt double %1496, 0.000000e+00
br i1 %1497, label %1498, label %1508
1498: ; preds = %1486
%1499 = load float*, float** %18
%1500 = load i32, i32* %33
%1501 = sext i32 %1500 to i64
%1502 = getelementptr inbounds float, float* %1499, i64 %1501
%1503 = load float, float* %1502
%1504 = load float, float* %21
%1505 = fdiv float %1503, %1504
%1506 = fpext float %1505 to double
%1507 = fadd double %1506, 5.000000e-01
br label %1518
1508: ; preds = %1486
%1509 = load float*, float** %18
%1510 = load i32, i32* %33
%1511 = sext i32 %1510 to i64
%1512 = getelementptr inbounds float, float* %1509, i64 %1511
%1513 = load float, float* %1512
%1514 = load float, float* %21
%1515 = fdiv float %1513, %1514
%1516 = fpext float %1515 to double
%1517 = fsub double %1516, 5.000000e-01
br label %1518
1518: ; preds = %1508, %1498
%1519 = phi double [ %1507, %1498 ], [ %1517, %1508 ]
%1520 = fptosi double %1519 to i32
%1521 = load i32, i32* %31
%1522 = load float**, float*** %23
%1523 = load float**, float*** %26
%1524 = getelementptr inbounds float*, float** %1523, i64 2
%1525 = load float*, float** %1524
%1526 = load i32, i32* %33
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds float, float* %1525, i64 %1527
%1529 = load float, float* %1528
%1530 = call i32 @makecircle(i32 %1488, i32 %1520, i32 %1521, float** %1522, float %1529)
br label %1754
1531: ; preds = %1079
%1532 = load float*, float** %17
%1533 = load i32, i32* %33
%1534 = sext i32 %1533 to i64
%1535 = getelementptr inbounds float, float* %1532, i64 %1534
%1536 = load float, float* %1535
%1537 = load float, float* %20
%1538 = fdiv float %1536, %1537
%1539 = fpext float %1538 to double
%1540 = fcmp ogt double %1539, 0.000000e+00
br i1 %1540, label %1541, label %1551
1541: ; preds = %1531
%1542 = load float*, float** %17
%1543 = load i32, i32* %33
%1544 = sext i32 %1543 to i64
%1545 = getelementptr inbounds float, float* %1542, i64 %1544
%1546 = load float, float* %1545
%1547 = load float, float* %20
%1548 = fdiv float %1546, %1547
%1549 = fpext float %1548 to double
%1550 = fadd double %1549, 5.000000e-01
br label %1561
1551: ; preds = %1531
%1552 = load float*, float** %17
%1553 = load i32, i32* %33
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds float, float* %1552, i64 %1554
%1556 = load float, float* %1555
%1557 = load float, float* %20
%1558 = fdiv float %1556, %1557
%1559 = fpext float %1558 to double
%1560 = fsub double %1559, 5.000000e-01
br label %1561
1561: ; preds = %1551, %1541
%1562 = phi double [ %1550, %1541 ], [ %1560, %1551 ]
%1563 = fptosi double %1562 to i32
%1564 = load float*, float** %18
%1565 = load i32, i32* %33
%1566 = sext i32 %1565 to i64
%1567 = getelementptr inbounds float, float* %1564, i64 %1566
%1568 = load float, float* %1567
%1569 = load float, float* %21
%1570 = fdiv float %1568, %1569
%1571 = fpext float %1570 to double
%1572 = fcmp ogt double %1571, 0.000000e+00
br i1 %1572, label %1573, label %1583
1573: ; preds = %1561
%1574 = load float*, float** %18
%1575 = load i32, i32* %33
%1576 = sext i32 %1575 to i64
%1577 = getelementptr inbounds float, float* %1574, i64 %1576
%1578 = load float, float* %1577
%1579 = load float, float* %21
%1580 = fdiv float %1578, %1579
%1581 = fpext float %1580 to double
%1582 = fadd double %1581, 5.000000e-01
br label %1593
1583: ; preds = %1561
%1584 = load float*, float** %18
%1585 = load i32, i32* %33
%1586 = sext i32 %1585 to i64
%1587 = getelementptr inbounds float, float* %1584, i64 %1586
%1588 = load float, float* %1587
%1589 = load float, float* %21
%1590 = fdiv float %1588, %1589
%1591 = fpext float %1590 to double
%1592 = fsub double %1591, 5.000000e-01
br label %1593
1593: ; preds = %1583, %1573
%1594 = phi double [ %1582, %1573 ], [ %1592, %1583 ]
%1595 = fptosi double %1594 to i32
%1596 = load i32, i32* %31
%1597 = load float**, float*** %22
%1598 = load float**, float*** %25
%1599 = getelementptr inbounds float*, float** %1598, i64 2
%1600 = load float*, float** %1599
%1601 = load i32, i32* %33
%1602 = sext i32 %1601 to i64
%1603 = getelementptr inbounds float, float* %1600, i64 %1602
%1604 = load float, float* %1603
%1605 = call i32 @makesquare(i32 %1563, i32 %1595, i32 %1596, float** %1597, float %1604)
%1606 = load float*, float** %17
%1607 = load i32, i32* %33
%1608 = sext i32 %1607 to i64
%1609 = getelementptr inbounds float, float* %1606, i64 %1608
%1610 = load float, float* %1609
%1611 = load float, float* %20
%1612 = fdiv float %1610, %1611
%1613 = fpext float %1612 to double
%1614 = fcmp ogt double %1613, 0.000000e+00
br i1 %1614, label %1615, label %1625
1615: ; preds = %1593
%1616 = load float*, float** %17
%1617 = load i32, i32* %33
%1618 = sext i32 %1617 to i64
%1619 = getelementptr inbounds float, float* %1616, i64 %1618
%1620 = load float, float* %1619
%1621 = load float, float* %20
%1622 = fdiv float %1620, %1621
%1623 = fpext float %1622 to double
%1624 = fadd double %1623, 5.000000e-01
br label %1635
1625: ; preds = %1593
%1626 = load float*, float** %17
%1627 = load i32, i32* %33
%1628 = sext i32 %1627 to i64
%1629 = getelementptr inbounds float, float* %1626, i64 %1628
%1630 = load float, float* %1629
%1631 = load float, float* %20
%1632 = fdiv float %1630, %1631
%1633 = fpext float %1632 to double
%1634 = fsub double %1633, 5.000000e-01
br label %1635
1635: ; preds = %1625, %1615
%1636 = phi double [ %1624, %1615 ], [ %1634, %1625 ]
%1637 = fptosi double %1636 to i32
%1638 = load float*, float** %18
%1639 = load i32, i32* %33
%1640 = sext i32 %1639 to i64
%1641 = getelementptr inbounds float, float* %1638, i64 %1640
%1642 = load float, float* %1641
%1643 = load float, float* %21
%1644 = fdiv float %1642, %1643
%1645 = fpext float %1644 to double
%1646 = fcmp ogt double %1645, 0.000000e+00
br i1 %1646, label %1647, label %1657
1647: ; preds = %1635
%1648 = load float*, float** %18
%1649 = load i32, i32* %33
%1650 = sext i32 %1649 to i64
%1651 = getelementptr inbounds float, float* %1648, i64 %1650
%1652 = load float, float* %1651
%1653 = load float, float* %21
%1654 = fdiv float %1652, %1653
%1655 = fpext float %1654 to double
%1656 = fadd double %1655, 5.000000e-01
br label %1667
1657: ; preds = %1635
%1658 = load float*, float** %18
%1659 = load i32, i32* %33
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds float, float* %1658, i64 %1660
%1662 = load float, float* %1661
%1663 = load float, float* %21
%1664 = fdiv float %1662, %1663
%1665 = fpext float %1664 to double
%1666 = fsub double %1665, 5.000000e-01
br label %1667
1667: ; preds = %1657, %1647
%1668 = phi double [ %1656, %1647 ], [ %1666, %1657 ]
%1669 = fptosi double %1668 to i32
%1670 = load i32, i32* %31
%1671 = load float**, float*** %24
%1672 = load float**, float*** %27
%1673 = getelementptr inbounds float*, float** %1672, i64 2
%1674 = load float*, float** %1673
%1675 = load i32, i32* %33
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds float, float* %1674, i64 %1676
%1678 = load float, float* %1677
%1679 = call i32 @makesquare(i32 %1637, i32 %1669, i32 %1670, float** %1671, float %1678)
%1680 = load float*, float** %17
%1681 = load i32, i32* %33
%1682 = sext i32 %1681 to i64
%1683 = getelementptr inbounds float, float* %1680, i64 %1682
%1684 = load float, float* %1683
%1685 = load float, float* %20
%1686 = fdiv float %1684, %1685
%1687 = fpext float %1686 to double
%1688 = fcmp ogt double %1687, 0.000000e+00
br i1 %1688, label %1689, label %1699
1689: ; preds = %1667
%1690 = load float*, float** %17
%1691 = load i32, i32* %33
%1692 = sext i32 %1691 to i64
%1693 = getelementptr inbounds float, float* %1690, i64 %1692
%1694 = load float, float* %1693
%1695 = load float, float* %20
%1696 = fdiv float %1694, %1695
%1697 = fpext float %1696 to double
%1698 = fadd double %1697, 5.000000e-01
br label %1709
1699: ; preds = %1667
%1700 = load float*, float** %17
%1701 = load i32, i32* %33
%1702 = sext i32 %1701 to i64
%1703 = getelementptr inbounds float, float* %1700, i64 %1702
%1704 = load float, float* %1703
%1705 = load float, float* %20
%1706 = fdiv float %1704, %1705
%1707 = fpext float %1706 to double
%1708 = fsub double %1707, 5.000000e-01
br label %1709
1709: ; preds = %1699, %1689
%1710 = phi double [ %1698, %1689 ], [ %1708, %1699 ]
%1711 = fptosi double %1710 to i32
%1712 = load float*, float** %18
%1713 = load i32, i32* %33
%1714 = sext i32 %1713 to i64
%1715 = getelementptr inbounds float, float* %1712, i64 %1714
%1716 = load float, float* %1715
%1717 = load float, float* %21
%1718 = fdiv float %1716, %1717
%1719 = fpext float %1718 to double
%1720 = fcmp ogt double %1719, 0.000000e+00
br i1 %1720, label %1721, label %1731
1721: ; preds = %1709
%1722 = load float*, float** %18
%1723 = load i32, i32* %33
%1724 = sext i32 %1723 to i64
%1725 = getelementptr inbounds float, float* %1722, i64 %1724
%1726 = load float, float* %1725
%1727 = load float, float* %21
%1728 = fdiv float %1726, %1727
%1729 = fpext float %1728 to double
%1730 = fadd double %1729, 5.000000e-01
br label %1741
1731: ; preds = %1709
%1732 = load float*, float** %18
%1733 = load i32, i32* %33
%1734 = sext i32 %1733 to i64
%1735 = getelementptr inbounds float, float* %1732, i64 %1734
%1736 = load float, float* %1735
%1737 = load float, float* %21
%1738 = fdiv float %1736, %1737
%1739 = fpext float %1738 to double
%1740 = fsub double %1739, 5.000000e-01
br label %1741
1741: ; preds = %1731, %1721
%1742 = phi double [ %1730, %1721 ], [ %1740, %1731 ]
%1743 = fptosi double %1742 to i32
%1744 = load i32, i32* %31
%1745 = load float**, float*** %23
%1746 = load float**, float*** %26
%1747 = getelementptr inbounds float*, float** %1746, i64 2
%1748 = load float*, float** %1747
%1749 = load i32, i32* %33
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds float, float* %1748, i64 %1750
%1752 = load float, float* %1751
%1753 = call i32 @makesquare(i32 %1711, i32 %1743, i32 %1744, float** %1745, float %1752)
br label %1754
1754: ; preds = %1741, %1518, %1295
br label %1755
1755: ; preds = %1754
%1756 = load i32, i32* %33
%1757 = add nsw i32 %1756, 1
store i32 %1757, i32* %33
br label %972
1758: ; preds = %972
br label %1759
1759: ; preds = %1758, %970
br label %1760
1760: ; preds = %1759, %401
ret void
}

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