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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float M_PI;
int cos(float);
double drand48();
void grid(float **gridcp, float **gridcs, float **gridro, int *zp, float **cp,
          float **cs, float **ro, int minx, int maxx, int optgrad,
          float gradlen, float gradcp, float gradcs, float gradro, float dx,
          float dz, int nz) {
  int g, ngrad, gradend, i, k, j;
  float deltcp, deltcs, deltro, co;
  if (gridcs == NULL && gridro == NULL) {
    if (optgrad == 1) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          gridcp[i][j] = cp[0][i] + deltcp * k;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
        }
      }
    } else if (optgrad == 2) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          co = -g * (cos(M_PI * ((float)k / (float)g)) - 1) / 2.0;
          gridcp[i][j] = cp[0][i] + deltcp * co;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
        }
      }
    } else if (optgrad == 3) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
        }
      }
    } else if (optgrad == 4) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)(drand48() - 0.5) * 2.0 * gradcp;
        }
      }
    }
    return;
  } else if (gridcs == NULL) {
    if (optgrad == 1) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        deltro = (ro[1][i] - ro[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          gridcp[i][j] = cp[0][i] + deltcp * k;
          gridro[i][j] = ro[0][i] + deltro * k;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 2) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        deltro = (ro[1][i] - ro[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          co = -g * (cos(M_PI * ((float)k / (float)g)) - 1) / 2.0;
          gridcp[i][j] = cp[0][i] + deltcp * co;
          gridro[i][j] = ro[0][i] + deltro * co;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 3) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 4) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)(drand48() - 0.5) * 2.0 * gradcp;
          gridro[i][j] = ro[1][i] + (float)(drand48() - 0.5) * 2.0 * gradro;
        }
      }
    }
    return;
  } else {
    if (optgrad == 1) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        deltcs = (cs[1][i] - cs[0][i]) / g;
        deltro = (ro[1][i] - ro[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          gridcp[i][j] = cp[0][i] + deltcp * k;
          gridcs[i][j] = cs[0][i] + deltcs * k;
          gridro[i][j] = ro[0][i] + deltro * k;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridcs[i][j] = cs[1][i] + (float)k * gradcs;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 2) {
      g = ((int)((gradlen / dz) > 0.0 ? (gradlen / dz) + 0.5
                                      : (gradlen / dz) - 0.5)) -
          1;
      for (i = minx; i < maxx; i++) {
        deltcp = (cp[1][i] - cp[0][i]) / g;
        deltcs = (cs[1][i] - cs[0][i]) / g;
        deltro = (ro[1][i] - ro[0][i]) / g;
        if (zp[i] == 0)
          k = 1;
        else
          k = 0;
        ngrad = zp[i] + g;
        gradend = ((ngrad) < (nz) ? (ngrad) : (nz));
        for (j = zp[i]; j <= gradend; j++) {
          co = -g * (cos(M_PI * ((float)k / (float)g)) - 1) / 2.0;
          gridcp[i][j] = cp[0][i] + deltcp * co;
          gridcs[i][j] = cs[0][i] + deltcs * co;
          gridro[i][j] = ro[0][i] + deltro * co;
          k += 1;
        }
        for (j = gradend + 1, k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridcs[i][j] = cs[1][i] + (float)k * gradcs;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 3) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridcs[i][j] = cs[1][i] + (float)k * gradcs;
          gridro[i][j] = ro[1][i] + (float)k * gradro;
        }
      }
    } else if (optgrad == 4) {
      for (i = minx; i < maxx; i++) {
        for (j = zp[i], k = 0; j < nz; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)(drand48() - 0.5) * 2.0 * gradcp;
          gridcs[i][j] = cs[1][i] + (float)(drand48() - 0.5) * 2.0 * gradcs;
          gridro[i][j] = ro[1][i] + (float)(drand48() - 0.5) * 2.0 * gradro;
        }
      }
    }
    return;
  }
}


x86 assembly (clang, -O0):
<grid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
movss  %xmm1,-0x38(%rbp)
movss  %xmm2,-0x3c(%rbp)
movss  %xmm3,-0x40(%rbp)
movss  %xmm4,-0x44(%rbp)
movss  %xmm5,-0x48(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    177f <grid+0x65f>
cmpq   $0x0,-0x18(%rbp)
jne    177f <grid+0x65f>
cmpl   $0x1,0x28(%rbp)
jne    1383 <grid+0x263>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    11d0 <grid+0xb0>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e46(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    11ef <grid+0xcf>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e22(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    137e <grid+0x25e>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    125d <grid+0x13d>
movl   $0x1,-0x5c(%rbp)
jmp    1264 <grid+0x144>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    128c <grid+0x16c>
mov    -0x50(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    1292 <grid+0x172>
mov    0x30(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1300 <grid+0x1e0>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12a6 <grid+0x186>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    136b <grid+0x24b>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1310 <grid+0x1f0>
jmp    1370 <grid+0x250>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1204 <grid+0xe4>
jmp    177a <grid+0x65a>
cmpl   $0x2,0x28(%rbp)
jne    15e5 <grid+0x4c5>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13cf <grid+0x2af>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c4a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    13f1 <grid+0x2d1>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c23(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    15e0 <grid+0x4c0>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1462 <grid+0x342>
movl   $0x1,-0x5c(%rbp)
jmp    1469 <grid+0x349>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1494 <grid+0x374>
mov    -0x50(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    149d <grid+0x37d>
mov    0x30(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1562 <grid+0x442>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    0x3b16(%rip),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
cvtsi2ssl -0x4c(%rbp),%xmm2
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
call   1030 <cos@plt>
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  0x1af9(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14b4 <grid+0x394>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    15cd <grid+0x4ad>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1572 <grid+0x452>
jmp    15d2 <grid+0x4b2>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1409 <grid+0x2e9>
jmp    1775 <grid+0x655>
cmpl   $0x3,0x28(%rbp)
jne    1689 <grid+0x569>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1684 <grid+0x564>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1671 <grid+0x551>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1616 <grid+0x4f6>
jmp    1676 <grid+0x556>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15f5 <grid+0x4d5>
jmp    1770 <grid+0x650>
cmpl   $0x4,0x28(%rbp)
jne    176b <grid+0x64b>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1766 <grid+0x646>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1753 <grid+0x633>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x190e(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x18f2(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    16ba <grid+0x59a>
jmp    1758 <grid+0x638>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1699 <grid+0x579>
jmp    176b <grid+0x64b>
jmp    1770 <grid+0x650>
jmp    1775 <grid+0x655>
jmp    177a <grid+0x65a>
jmp    295c <grid+0x183c>
cmpq   $0x0,-0x10(%rbp)
jne    1f7e <grid+0xe5e>
cmpl   $0x1,0x28(%rbp)
jne    1a36 <grid+0x916>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17d6 <grid+0x6b6>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1843(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    17f8 <grid+0x6d8>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x181c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1a31 <grid+0x911>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1898 <grid+0x778>
movl   $0x1,-0x5c(%rbp)
jmp    189f <grid+0x77f>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    18ca <grid+0x7aa>
mov    -0x50(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    18d3 <grid+0x7b3>
mov    0x30(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     197b <grid+0x85b>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x6c(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    18ea <grid+0x7ca>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1a1e <grid+0x8fe>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    198b <grid+0x86b>
jmp    1a23 <grid+0x903>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1810 <grid+0x6f0>
jmp    1f79 <grid+0xe59>
cmpl   $0x2,0x28(%rbp)
jne    1d36 <grid+0xc16>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a82 <grid+0x962>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1597(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1aa4 <grid+0x984>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1570(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1d31 <grid+0xc11>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1b44 <grid+0xa24>
movl   $0x1,-0x5c(%rbp)
jmp    1b4b <grid+0xa2b>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1b76 <grid+0xa56>
mov    -0x50(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    1b7f <grid+0xa5f>
mov    0x30(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1c7b <grid+0xb5b>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    0x3434(%rip),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
cvtsi2ssl -0x4c(%rbp),%xmm2
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
call   1030 <cos@plt>
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  0x1417(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x6c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b96 <grid+0xa76>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1d1e <grid+0xbfe>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1c8b <grid+0xb6b>
jmp    1d23 <grid+0xc03>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1abc <grid+0x99c>
jmp    1f74 <grid+0xe54>
cmpl   $0x3,0x28(%rbp)
jne    1e12 <grid+0xcf2>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1e0d <grid+0xced>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1dfa <grid+0xcda>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1d67 <grid+0xc47>
jmp    1dff <grid+0xcdf>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1d46 <grid+0xc26>
jmp    1f6f <grid+0xe4f>
cmpl   $0x4,0x28(%rbp)
jne    1f6a <grid+0xe4a>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1f65 <grid+0xe45>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1f52 <grid+0xe32>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0x1185(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1169(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x110f(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10f3(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x40(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1e43 <grid+0xd23>
jmp    1f57 <grid+0xe37>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1e22 <grid+0xd02>
jmp    1f6a <grid+0xe4a>
jmp    1f6f <grid+0xe4f>
jmp    1f74 <grid+0xe54>
jmp    1f79 <grid+0xe59>
jmp    295c <grid+0x183c>
cmpl   $0x1,0x28(%rbp)
jne    22c8 <grid+0x11a8>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1fca <grid+0xeaa>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x104f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1fec <grid+0xecc>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1028(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    22c3 <grid+0x11a3>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    20bb <grid+0xf9b>
movl   $0x1,-0x5c(%rbp)
jmp    20c2 <grid+0xfa2>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    20ed <grid+0xfcd>
mov    -0x50(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    20f6 <grid+0xfd6>
mov    0x30(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     21d5 <grid+0x10b5>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x68(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x6c(%rbp),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    210d <grid+0xfed>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    22b0 <grid+0x1190>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    21e5 <grid+0x10c5>
jmp    22b5 <grid+0x1195>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    2004 <grid+0xee4>
jmp    2957 <grid+0x1837>
cmpl   $0x2,0x28(%rbp)
jne    2666 <grid+0x1546>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2314 <grid+0x11f4>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd05(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    2336 <grid+0x1216>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcde(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2661 <grid+0x1541>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2405 <grid+0x12e5>
movl   $0x1,-0x5c(%rbp)
jmp    240c <grid+0x12ec>
movl   $0x0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    2437 <grid+0x1317>
mov    -0x50(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    2440 <grid+0x1320>
mov    0x30(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     2573 <grid+0x1453>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    0x2b73(%rip),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0x5c(%rbp),%xmm1
cvtsi2ssl -0x4c(%rbp),%xmm2
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
call   1030 <cos@plt>
mov    %eax,%ecx
mov    -0xe8(%rbp),%eax
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  0xb56(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x68(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x6c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2457 <grid+0x1337>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    264e <grid+0x152e>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2583 <grid+0x1463>
jmp    2653 <grid+0x1533>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    234e <grid+0x122e>
jmp    2952 <grid+0x1832>
cmpl   $0x3,0x28(%rbp)
jne    277a <grid+0x165a>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2775 <grid+0x1655>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    2762 <grid+0x1642>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtsi2ssl -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2697 <grid+0x1577>
jmp    2767 <grid+0x1647>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    2676 <grid+0x1556>
jmp    294d <grid+0x182d>
cmpl   $0x4,0x28(%rbp)
jne    2948 <grid+0x1828>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2943 <grid+0x1823>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    2930 <grid+0x1810>
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0x100(%rbp),%xmm1
ff
movsd  0x81d(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x801(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x38(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0xf8(%rbp),%xmm1
ff
movsd  0x7a7(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x78b(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x3c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    $0x0,%al
call   1040 <drand48@plt>
movsd  -0xf0(%rbp),%xmm1
ff
movsd  0x731(%rip),%xmm2
subsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x715(%rip),%xmm2
mulsd  %xmm2,%xmm0
movss  -0x40(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x60(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    27ab <grid+0x168b>
jmp    2935 <grid+0x1815>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    278a <grid+0x166a>
jmp    2948 <grid+0x1828>
jmp    294d <grid+0x182d>
jmp    2952 <grid+0x1832>
jmp    2957 <grid+0x1837>
jmp    295c <grid+0x183c>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<grid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movaps %xmm1,%xmm15
mov    %r8,%r13
mov    %rcx,0x70(%rsp)
mov    %rdi,0x38(%rsp)
mov    0x158(%rsp),%eax
mov    0x150(%rsp),%r12d
mov    0x148(%rsp),%ebx
mov    %rsi,%rcx
or     %rdx,%rcx
movaps %xmm1,0xf0(%rsp)
mov    %r8,0x40(%rsp)
jne    15d3 <grid+0x4b3>
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     34ff <grid+0x23df>
lea    0x2f00(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x2e5e(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%esi
add    $0xffffffff,%esi
mov    0x0(%r13),%r14
mov    %r12d,%eax
mov    0x8(%r13),%r12
cvtsi2ss %esi,%xmm10
movslq %ebx,%rdi
movslq %eax,%r10
mov    0x160(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x18(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x8(%rsp)
movaps %xmm15,%xmm1
shufps $0x0,%xmm15,%xmm1
xor    %r15d,%r15d
movdqa 0x2e20(%rip),%xmm8
movdqa 0x2e27(%rip),%xmm13
movdqa 0x2e2f(%rip),%xmm4
movss  0x2e46(%rip),%xmm9
pcmpeqd %xmm11,%xmm11
movdqa 0x2e28(%rip),%xmm12
mov    %rsi,0x30(%rsp)
mov    %r10,0x40(%rsp)
jmp    1251 <grid+0x131>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
add    $0x1,%r15
cmp    %r10,%rdi
je     34ff <grid+0x23df>
mov    0x8(%rsp),%rax
lea    (%rax,%r15,1),%r9
mov    0x70(%rsp),%rax
movslq (%rax,%rdi,4),%r8
lea    (%r8,%rsi,1),%ebp
mov    0x160(%rsp),%r11d
cmp    %r11d,%ebp
cmovge %r11d,%ebp
lea    0x1(%rbp),%r13d
cmp    %ebp,%r8d
jg     12d4 <grid+0x1b4>
xor    %r10d,%r10d
movaps %xmm9,%xmm2
test   %r8d,%r8d
sete   %al
je     1291 <grid+0x171>
xorps  %xmm2,%xmm2
movss  (%r12,%rdi,4),%xmm0
movss  (%r14,%rdi,4),%xmm5
subss  %xmm5,%xmm0
divss  %xmm10,%xmm0
mov    0x38(%rsp),%rcx
mov    (%rcx,%rdi,8),%rcx
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%r8,4)
lea    0x1(%r8),%rsi
cmp    %esi,%r13d
jne    13b0 <grid+0x290>
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%r10
cmp    %r11d,%r13d
jge    1240 <grid+0x120>
mov    0x38(%rsp),%rax
mov    (%rax,%rdi,8),%r8
movslq %r13d,%rdx
mov    0x18(%rsp),%eax
mov    %eax,%ecx
sub    %ebp,%ecx
xor    %eax,%eax
cmp    $0x7,%ecx
jb     1322 <grid+0x202>
lea    (%r12,%r9,4),%r9
lea    (%r8,%rdx,4),%rbx
cmp    %r9,%rbx
jae    1426 <grid+0x306>
lea    (%r12,%rdi,4),%r9
lea    (%rdx,%rcx,1),%rbx
lea    (%r8,%rbx,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%r9
jae    1426 <grid+0x306>
mov    %rdx,%r9
mov    %eax,%edx
not    %edx
add    %r11d,%edx
sub    %ebp,%edx
lea    (%rax,%rbp,1),%ecx
test   $0x1,%dl
je     1355 <grid+0x235>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm15,%xmm0
addss  (%r12,%rdi,4),%xmm0
movss  %xmm0,(%r8,%r9,4)
add    $0x1,%eax
add    $0x1,%r9
cmp    %ecx,0x18(%rsp)
je     1240 <grid+0x120>
not    %ebp
add    %r11d,%ebp
lea    (%r8,%r9,4),%rcx
add    $0x4,%rcx
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm15,%xmm0
addss  (%r12,%rdi,4),%xmm0
lea    0x1(%rax),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
movss  %xmm0,-0x4(%rcx)
mulss  %xmm15,%xmm2
addss  (%r12,%rdi,4),%xmm2
movss  %xmm2,(%rcx)
add    $0x8,%rcx
add    $0x2,%eax
cmp    %ebp,%eax
jne    1370 <grid+0x250>
jmp    1240 <grid+0x120>
mov    %al,%r10b
mov    %r8d,%r11d
not    %r11d
add    %ebp,%r11d
cmp    $0x7,%r11d
jb     13f6 <grid+0x2d6>
lea    (%r14,%r9,4),%rax
lea    (%rcx,%r8,4),%rdx
add    $0x4,%rdx
cmp    %rax,%rdx
jae    1510 <grid+0x3f0>
lea    (%r14,%rdi,4),%rax
mov    %r8d,%edx
not    %edx
add    %ebp,%edx
add    %r8,%rdx
lea    (%rcx,%rdx,4),%rdx
add    $0x8,%rdx
cmp    %rdx,%rax
jae    1510 <grid+0x3f0>
mov    %r10d,%eax
mov    0x40(%rsp),%r10
mov    %ebp,%edx
sub    %esi,%edx
add    $0x1,%edx
test   $0x1,%dl
mov    0x160(%rsp),%r11d
jne    149f <grid+0x37f>
mov    %rsi,%rbx
cmp    %esi,%ebp
jne    14c7 <grid+0x3a7>
jmp    15c0 <grid+0x4a0>
add    $0x1,%rcx
mov    %rcx,%rax
movabs $0x1fffffff8,%rbx
and    %rbx,%rax
lea    (%rax,%rdx,1),%r9
movss  (%r12,%rdi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%r8,%rdx,4),%rdx
add    $0x10,%rdx
xor    %ebx,%ebx
movdqa %xmm8,%xmm2
nopw   0x0(%rax,%rax,1)
movdqa %xmm2,%xmm3
paddd  %xmm13,%xmm3
cvtdq2ps %xmm2,%xmm5
cvtdq2ps %xmm3,%xmm3
mulps  %xmm1,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm1,%xmm3
addps  %xmm0,%xmm3
movups %xmm5,-0x10(%rdx,%rbx,4)
movups %xmm3,(%rdx,%rbx,4)
add    $0x8,%rbx
paddd  %xmm4,%xmm2
cmp    %rbx,%rax
jne    1460 <grid+0x340>
cmp    %rax,%rcx
je     1240 <grid+0x120>
jmp    1325 <grid+0x205>
add    $0x1,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  %xmm0,%xmm2
addss  (%r14,%rdi,4),%xmm2
movss  %xmm2,(%rcx,%rsi,4)
mov    %rsi,%rbx
add    $0x1,%rbx
cmp    %esi,%ebp
je     15c0 <grid+0x4a0>
mov    %r13d,%edx
add    $0x2,%eax
nopl   (%rax)
lea    -0x1(%rax),%esi
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
mulss  %xmm0,%xmm2
addss  (%r14,%rdi,4),%xmm2
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movss  %xmm2,(%rcx,%rbx,4)
mulss  %xmm0,%xmm3
addss  (%r14,%rdi,4),%xmm3
movss  %xmm3,0x4(%rcx,%rbx,4)
add    $0x2,%rbx
add    $0x2,%eax
cmp    %ebx,%edx
jne    14d0 <grid+0x3b0>
jmp    15c0 <grid+0x4a0>
mov    %r9,0x28(%rsp)
add    $0x1,%r11
mov    %r11,%r9
movabs $0x1fffffff8,%rax
and    %rax,%r9
add    %r9,%rsi
movd   %r10d,%xmm2
mov    %r9d,%eax
or     %r10d,%eax
pshufd $0x0,%xmm2,%xmm3
paddd  %xmm8,%xmm3
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movss  (%r14,%rdi,4),%xmm6
shufps $0x0,%xmm6,%xmm6
lea    (%rcx,%r8,4),%rdx
add    $0x14,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movdqa %xmm3,%xmm5
psubd  %xmm11,%xmm5
movdqa %xmm3,%xmm7
paddd  %xmm12,%xmm7
cvtdq2ps %xmm5,%xmm5
cvtdq2ps %xmm7,%xmm7
mulps  %xmm2,%xmm5
addps  %xmm6,%xmm5
mulps  %xmm2,%xmm7
addps  %xmm6,%xmm7
movups %xmm5,-0x10(%rdx,%rbx,4)
movups %xmm7,(%rdx,%rbx,4)
add    $0x8,%rbx
paddd  %xmm4,%xmm3
cmp    %rbx,%r9
jne    1560 <grid+0x440>
cmp    %r9,%r11
mov    0x40(%rsp),%r10
mov    0x28(%rsp),%r9
jne    13fe <grid+0x2de>
mov    0x160(%rsp),%r11d
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x30(%rsp),%rsi
cmp    %r11d,%r13d
jge    1240 <grid+0x120>
jmp    12dd <grid+0x1bd>
mov    %rdx,0x30(%rsp)
test   %rsi,%rsi
movaps %xmm3,0xc0(%rsp)
je     1839 <grid+0x719>
mov    %rsi,0x8(%rsp)
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     34ff <grid+0x23df>
lea    0x2a63(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x29e1(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%ebp
add    $0xffffffff,%ebp
cvtsi2ss %ebp,%xmm8
mov    0x0(%r13),%r10
mov    0x8(%r13),%r15
mov    %r12d,%ecx
mov    (%r9),%r12
mov    0x8(%r9),%r14
mov    0x140(%rsp),%rax
mov    (%rax),%r13
mov    0x8(%rax),%r11
movslq %ebx,%rax
movslq %ecx,%rbx
mov    %rbp,0x28(%rsp)
mov    %rbx,0x40(%rsp)
jmp    168d <grid+0x56d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
cmp    %rbx,%rax
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
lea    (%rcx,%rbp,1),%r8d
mov    0x160(%rsp),%edx
cmp    %edx,%r8d
cmovge %edx,%r8d
cmp    %r8d,%ecx
jle    16c0 <grid+0x5a0>
lea    0x1(%r8),%edx
jmp    179e <grid+0x67e>
cs nopw 0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm1
movss  (%r10,%rax,4),%xmm4
subss  %xmm4,%xmm1
divss  %xmm8,%xmm1
movss  (%r14,%rax,4),%xmm0
subss  (%r12,%rax,4),%xmm0
divss  %xmm8,%xmm0
movss  (%r11,%rax,4),%xmm7
subss  0x0(%r13,%rax,4),%xmm7
divss  %xmm8,%xmm7
xor    %r9d,%r9d
test   %ecx,%ecx
sete   %r9b
lea    0x1(%r8),%edx
mov    %edx,0x18(%rsp)
mov    %rcx,%rdi
shl    $0x2,%rdi
mov    0x38(%rsp),%rdx
mov    (%rdx,%rax,8),%rbp
add    %rdi,%rbp
mov    0x8(%rsp),%rdx
mov    (%rdx,%rax,8),%rbx
add    %rdi,%rbx
mov    0x30(%rsp),%rdx
add    (%rdx,%rax,8),%rdi
mov    %r8d,%edx
sub    %ecx,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rcx,1),%esi
xorps  %xmm5,%xmm5
cvtsi2ss %esi,%xmm5
movaps %xmm1,%xmm6
mulss  %xmm5,%xmm6
addss  %xmm4,%xmm6
movss  %xmm6,0x0(%rbp,%rcx,4)
movaps %xmm0,%xmm4
mulss  %xmm5,%xmm4
addss  (%r12,%rax,4),%xmm4
movss  %xmm4,(%rbx,%rcx,4)
mulss  %xmm7,%xmm5
addss  0x0(%r13,%rax,4),%xmm5
movss  %xmm5,(%rdi,%rcx,4)
cmp    %ecx,%edx
je     1790 <grid+0x670>
movss  (%r10,%rax,4),%xmm4
add    $0x1,%rcx
jmp    1740 <grid+0x620>
xchg   %ax,%ax
mov    0x28(%rsp),%rbp
mov    0x40(%rsp),%rbx
mov    0x18(%rsp),%edx
mov    0x160(%rsp),%ecx
cmp    %ecx,%edx
jge    1680 <grid+0x560>
movslq %edx,%rsi
not    %r8d
mov    0x160(%rsp),%ecx
add    %ecx,%r8d
shl    $0x2,%rsi
mov    0x38(%rsp),%rcx
mov    (%rcx,%rax,8),%rdx
add    %rsi,%rdx
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
add    %rsi,%rcx
mov    0x30(%rsp),%rdi
add    (%rdi,%rax,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
movaps %xmm1,%xmm0
mulss  %xmm15,%xmm0
addss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
addss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdi,4)
mulss  %xmm3,%xmm1
addss  (%r11,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%r8d
jne    17f0 <grid+0x6d0>
jmp    1680 <grid+0x560>
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     34ff <grid+0x23df>
lea    0x2828(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x2796(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%edx
add    $0xffffffff,%edx
mov    0x0(%r13),%rcx
mov    0x8(%r13),%r11
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
cvtsi2ss %edx,%xmm10
mov    0x140(%rsp),%rax
mov    (%rax),%r14
mov    0x8(%rax),%r13
movslq %ebx,%rbx
movslq %r12d,%rax
mov    %rax,0x40(%rsp)
mov    %rcx,%r12
mov    0x160(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x78(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x28(%rsp)
movaps %xmm15,%xmm13
shufps $0x0,%xmm15,%xmm13
movaps %xmm3,%xmm14
shufps $0x0,%xmm3,%xmm14
xor    %r15d,%r15d
movdqa 0x2733(%rip),%xmm8
movdqa 0x273a(%rip),%xmm12
movss  0x2761(%rip),%xmm9
pcmpeqd %xmm11,%xmm11
mov    %rcx,0x58(%rsp)
mov    %r14,0x10(%rsp)
jmp    1923 <grid+0x803>
add    $0x1,%rbx
add    $0x1,%r15
cmp    0x40(%rsp),%rbx
je     34ff <grid+0x23df>
mov    0x28(%rsp),%rax
lea    (%rax,%r15,1),%rsi
mov    0x70(%rsp),%rax
movslq (%rax,%rbx,4),%rcx
mov    0x18(%rsp),%rax
lea    (%rcx,%rax,1),%r8d
mov    0x160(%rsp),%eax
cmp    %eax,%r8d
cmovge %eax,%r8d
cmp    %r8d,%ecx
jle    1960 <grid+0x840>
lea    0x1(%r8),%edi
jmp    1d40 <grid+0xc20>
nopw   0x0(%rax,%rax,1)
mov    %r15,0x8(%rsp)
lea    0x1(%r8),%edi
xor    %ebp,%ebp
movaps %xmm9,%xmm0
test   %ecx,%ecx
sete   %dl
je     1979 <grid+0x859>
xorps  %xmm0,%xmm0
movss  (%r11,%rbx,4),%xmm7
movss  (%r12,%rbx,4),%xmm1
subss  %xmm1,%xmm7
divss  %xmm10,%xmm7
movss  0x0(%r13,%rbx,4),%xmm3
subss  (%r14,%rbx,4),%xmm3
divss  %xmm10,%xmm3
mov    0x38(%rsp),%rax
mov    (%rax,%rbx,8),%r9
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,8),%r10
movaps %xmm7,%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%r9,%rcx,4)
mulss  %xmm3,%xmm0
addss  (%r14,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rcx,4)
lea    0x1(%rcx),%rax
cmp    %eax,%edi
jne    19ed <grid+0x8cd>
movaps 0xc0(%rsp),%xmm3
mov    0x8(%rsp),%r15
jmp    1d40 <grid+0xc20>
mov    %dl,%bpl
mov    %ecx,%edx
not    %edx
add    %r8d,%edx
cmp    $0x3,%edx
jae    1a03 <grid+0x8e3>
mov    %ebp,%ecx
jmp    1c52 <grid+0xb32>
mov    %ebp,0x98(%rsp)
mov    %edi,0x48(%rsp)
mov    %rax,0x50(%rsp)
lea    (%r12,%rbx,4),%rbp
mov    %rbp,0x68(%rsp)
lea    (%r12,%rsi,4),%rax
mov    %rax,0xa0(%rsp)
lea    (%r14,%rbx,4),%rax
mov    %rax,0x20(%rsp)
mov    %rsi,0x80(%rsp)
lea    (%r14,%rsi,4),%r15
mov    %r15,0xe8(%rsp)
lea    (%r9,%rcx,4),%r14
add    $0x4,%r14
mov    %ecx,%edi
not    %edi
add    %r8d,%edi
add    %rcx,%rdi
lea    (%r9,%rdi,4),%rax
add    $0x8,%rax
lea    (%r10,%rcx,4),%r12
add    $0x4,%r12
lea    (%r10,%rdi,4),%rdi
add    $0x8,%rdi
cmp    %rdi,%r14
setb   0xb0(%rsp)
cmp    %rax,%r12
setb   0x60(%rsp)
mov    0xa0(%rsp),%rcx
cmp    %rcx,%r14
setb   %sil
cmp    %rax,%rbp
setb   0xe0(%rsp)
cmp    %r15,%r14
setb   %bpl
cmp    %rax,0x20(%rsp)
setb   0xd8(%rsp)
cmp    %rcx,%r12
setb   %r15b
cmp    %rdi,0x68(%rsp)
setb   0xa0(%rsp)
cmp    0xe8(%rsp),%r12
setb   0x68(%rsp)
cmp    %rdi,0x20(%rsp)
setb   %al
mov    0x60(%rsp),%cl
test   %cl,0xb0(%rsp)
jne    1c2e <grid+0xb0e>
and    0xe0(%rsp),%sil
mov    0x48(%rsp),%edi
jne    1c0c <grid+0xaec>
and    0xd8(%rsp),%bpl
jne    1c0c <grid+0xaec>
and    0xa0(%rsp),%r15b
mov    0x80(%rsp),%rsi
jne    1bf2 <grid+0xad2>
mov    %eax,%ecx
and    %al,0x68(%rsp)
jne    1bf2 <grid+0xad2>
add    $0x1,%rdx
movabs $0x1fffffff8,%rax
lea    0x4(%rax),%rdi
and    %rdx,%rdi
add    %rdi,0x50(%rsp)
mov    0x98(%rsp),%ebp
movd   %ebp,%xmm0
mov    %edi,%ecx
or     %ebp,%ecx
pshufd $0x0,%xmm0,%xmm2
paddd  %xmm8,%xmm2
movaps %xmm7,%xmm15
shufps $0x0,%xmm7,%xmm15
movaps %xmm3,%xmm6
shufps $0x0,%xmm3,%xmm6
mov    0x58(%rsp),%rax
movss  (%rax,%rbx,4),%xmm4
shufps $0x0,%xmm4,%xmm4
mov    0x10(%rsp),%rax
movss  (%rax,%rbx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %esi,%esi
nopl   (%rax)
movdqa %xmm2,%xmm5
psubd  %xmm11,%xmm5
cvtdq2ps %xmm5,%xmm5
movaps %xmm15,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm4,%xmm0
movups %xmm0,(%r14,%rsi,4)
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%r12,%rsi,4)
add    $0x4,%rsi
paddd  %xmm12,%xmm2
cmp    %rsi,%rdi
jne    1b90 <grid+0xa70>
cmp    %rdi,%rdx
movaps 0xf0(%rsp),%xmm15
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x80(%rsp),%rsi
mov    0x50(%rsp),%rax
mov    0x48(%rsp),%edi
jne    1c52 <grid+0xb32>
jmp    19db <grid+0x8bb>
mov    0x98(%rsp),%eax
mov    %eax,%ecx
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%rax
jmp    1c52 <grid+0xb32>
mov    0x98(%rsp),%eax
mov    %eax,%ecx
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x80(%rsp),%rsi
mov    0x50(%rsp),%rax
jmp    1c52 <grid+0xb32>
mov    0x98(%rsp),%eax
mov    %eax,%ecx
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x80(%rsp),%rsi
mov    0x50(%rsp),%rax
mov    0x48(%rsp),%edi
mov    %r8d,%edx
sub    %eax,%edx
add    $0x1,%edx
test   $0x1,%dl
jne    1c6d <grid+0xb4d>
mov    %rax,%rdx
cmp    %eax,%r8d
je     19db <grid+0x8bb>
jmp    1caa <grid+0xb8a>
add    $0x1,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
addss  (%r12,%rbx,4),%xmm1
movss  %xmm1,(%r9,%rax,4)
mulss  %xmm3,%xmm0
addss  (%r14,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rax,4)
mov    %rax,%rdx
add    $0x1,%rdx
cmp    %eax,%r8d
je     19db <grid+0x8bb>
mov    %rsi,%rax
mov    %edi,%ebp
mov    %edi,%edi
add    $0x2,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rcx),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
addss  (%r12,%rbx,4),%xmm1
movss  %xmm1,(%r9,%rdx,4)
mulss  %xmm3,%xmm0
addss  (%r14,%rbx,4),%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
movss  %xmm0,(%r10,%rdx,4)
movaps %xmm7,%xmm0
mulss  %xmm1,%xmm0
addss  (%r12,%rbx,4),%xmm0
movss  %xmm0,0x4(%r9,%rdx,4)
mulss  %xmm3,%xmm1
addss  (%r14,%rbx,4),%xmm1
movss  %xmm1,0x4(%r10,%rdx,4)
add    $0x2,%rdx
add    $0x2,%ecx
cmp    %edx,%edi
jne    1cc0 <grid+0xba0>
movaps 0xc0(%rsp),%xmm3
mov    0x8(%rsp),%r15
mov    %rax,%rsi
mov    %ebp,%edi
cs nopw 0x0(%rax,%rax,1)
mov    0x160(%rsp),%eax
cmp    %eax,%edi
jge    1910 <grid+0x7f0>
mov    0x38(%rsp),%rax
mov    (%rax,%rbx,8),%rbp
mov    0x30(%rsp),%rax
mov    (%rax,%rbx,8),%r10
movslq %edi,%rdi
mov    0x78(%rsp),%eax
mov    %eax,%r14d
sub    %r8d,%r14d
xor    %edx,%edx
cmp    $0x3,%r14d
jae    1d80 <grid+0xc60>
mov    0x10(%rsp),%r14
jmp    1f31 <grid+0xe11>
mov    %r15,0x8(%rsp)
lea    (%r11,%rbx,4),%rax
mov    %rax,0xb0(%rsp)
lea    (%r11,%rsi,4),%r12
lea    0x0(,%rbx,4),%rcx
add    %r13,%rcx
mov    %rcx,0x48(%rsp)
lea    0x0(%r13,%rsi,4),%r9
mov    %rdi,%rcx
lea    0x0(%rbp,%rdi,4),%rdi
lea    (%r14,%rcx,1),%rsi
mov    %rbp,0xa0(%rsp)
lea    0x4(%rbp,%rsi,4),%r15
mov    %rcx,0x20(%rsp)
lea    (%r10,%rcx,4),%rcx
mov    %r10,0x60(%rsp)
lea    (%r10,%rsi,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rdi
setb   0x80(%rsp)
cmp    %r15,%rcx
setb   0x50(%rsp)
cmp    %r12,%rdi
setb   %sil
cmp    %r15,%rax
setb   0x68(%rsp)
cmp    %r9,%rdi
setb   %r10b
mov    0x48(%rsp),%rax
cmp    %r15,%rax
setb   %r15b
cmp    %r12,%rcx
setb   %r12b
cmp    %rbp,0xb0(%rsp)
setb   0xb0(%rsp)
cmp    %r9,%rcx
setb   %r9b
cmp    %rbp,%rax
setb   %bpl
mov    0x50(%rsp),%al
test   %al,0x80(%rsp)
jne    1f10 <grid+0xdf0>
and    0x68(%rsp),%sil
jne    1f10 <grid+0xdf0>
and    %r15b,%r10b
jne    1f10 <grid+0xdf0>
mov    %ebp,%eax
and    0xb0(%rsp),%r12b
mov    0xa0(%rsp),%rbp
mov    0x60(%rsp),%r10
jne    1eff <grid+0xddf>
and    %al,%r9b
jne    1eff <grid+0xddf>
add    $0x1,%r14
movabs $0x1fffffff8,%rax
lea    0x4(%rax),%rdx
and    %r14,%rdx
add    %rdx,0x20(%rsp)
movss  (%r11,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  0x0(%r13,%rbx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %esi,%esi
movdqa %xmm8,%xmm5
mov    0x58(%rsp),%r12
mov    0x8(%rsp),%r15
xchg   %ax,%ax
cvtdq2ps %xmm5,%xmm2
movaps %xmm2,%xmm4
mulps  %xmm13,%xmm4
addps  %xmm0,%xmm4
movups %xmm4,(%rdi,%rsi,4)
mulps  %xmm14,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rcx,%rsi,4)
add    $0x4,%rsi
paddd  %xmm12,%xmm5
cmp    %rsi,%rdx
jne    1ec0 <grid+0xda0>
cmp    %rdx,%r14
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%rdi
je     1910 <grid+0x7f0>
jmp    1f31 <grid+0xe11>
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
jmp    1f2c <grid+0xe0c>
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
mov    0xa0(%rsp),%rbp
mov    0x60(%rsp),%r10
mov    0x20(%rsp),%rdi
mov    %edx,%esi
not    %esi
mov    0x160(%rsp),%eax
add    %eax,%esi
sub    %r8d,%esi
lea    (%rdx,%r8,1),%ecx
test   $0x1,%sil
je     1f7e <grid+0xe5e>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r11,%rbx,4),%xmm1
movss  %xmm1,0x0(%rbp,%rdi,4)
mulss  %xmm3,%xmm0
addss  0x0(%r13,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rdi,4)
add    $0x1,%edx
add    $0x1,%rdi
cmp    %ecx,0x78(%rsp)
je     1910 <grid+0x7f0>
not    %r8d
mov    0x160(%rsp),%eax
add    %eax,%r8d
lea    0x4(,%rdi,4),%rcx
add    %rbp,%rcx
lea    (%r10,%rdi,4),%rdi
add    $0x4,%rdi
mov    %edx,%edx
xor    %esi,%esi
xor    %ebp,%ebp
xchg   %ax,%ax
lea    (%rdx,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r11,%rbx,4),%xmm1
movss  %xmm1,-0x4(%rcx,%rsi,4)
mulss  %xmm3,%xmm0
addss  0x0(%r13,%rbx,4),%xmm0
lea    0x1(%rdx,%rsi,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  %xmm0,-0x4(%rdi,%rsi,4)
movaps %xmm1,%xmm0
mulss  %xmm15,%xmm0
addss  (%r11,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
mulss  %xmm3,%xmm1
addss  0x0(%r13,%rbx,4),%xmm1
movss  %xmm1,(%rdi,%rsi,4)
add    $0x2,%rbp
lea    (%rdx,%rsi,1),%eax
add    $0x2,%eax
mov    %rbp,%rsi
cmp    %r8d,%eax
jne    1fb0 <grid+0xe90>
jmp    1910 <grid+0x7f0>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x1fc7(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%r14d
cvtsi2ss %r14d,%xmm4
mov    $0x1,%ecx
sub    %eax,%ecx
mov    %ecx,0x30(%rsp)
movslq %ebx,%r10
mov    0x0(%r13),%rax
mov    0x160(%rsp),%ecx
add    $0xfffffffe,%ecx
mov    %ecx,0x20(%rsp)
lea    0x1(%r10),%rcx
mov    %rcx,0x48(%rsp)
movaps %xmm15,%xmm8
shufps $0x0,%xmm15,%xmm8
xor    %r13d,%r13d
movdqa 0x1f98(%rip),%xmm6
movdqa 0x1fa0(%rip),%xmm7
mov    0x3f41(%rip),%rbx
mov    %r14,0x28(%rsp)
movss  %xmm4,0x18(%rsp)
movaps %xmm8,0x80(%rsp)
jmp    20d1 <grid+0xfb1>
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%r13
cmp    %r12d,%r10d
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rcx
movslq (%rcx,%r10,4),%rbp
lea    (%r14,%rbp,1),%edi
mov    0x160(%rsp),%r11d
cmp    %r11d,%edi
cmovge %r11d,%edi
cmp    %edi,%ebp
jle    2100 <grid+0xfe0>
lea    0x1(%rdi),%ebp
cmp    %r11d,%ebp
jge    20c0 <grid+0xfa0>
jmp    220f <grid+0x10ef>
xchg   %ax,%ax
mov    %r13,0x78(%rsp)
mov    0x40(%rsp),%r13
mov    0x8(%r13),%rcx
movss  (%rcx,%r10,4),%xmm0
subss  (%rax,%r10,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,0x8(%rsp)
xor    %r15d,%r15d
test   %ebp,%ebp
sete   %r15b
mov    %rdi,0x10(%rsp)
lea    0x1(%rdi),%r12d
mov    %r12d,0xc0(%rsp)
sub    %ebp,%r12d
mov    0x38(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
divss  %xmm4,%xmm0
mulss  (%rbx),%xmm0
mov    %r10,%rbx
call   1030 <cos@plt>
movsd  0x1e98(%rip),%xmm1
mov    %rbx,%r10
mov    0x3e6e(%rip),%rbx
movss  0x18(%rsp),%xmm4
add    $0xffffffff,%eax
imul   0x30(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  0x8(%rsp),%xmm0
mov    0x0(%r13),%rax
addss  (%rax,%r10,4),%xmm0
mov    (%r14,%r10,8),%rcx
movss  %xmm0,(%rcx,%rbp,4)
add    $0x1,%r15d
add    $0x1,%rbp
add    $0xffffffff,%r12d
jne    2150 <grid+0x1030>
mov    0x160(%rsp),%r11d
movaps 0xf0(%rsp),%xmm15
mov    0x150(%rsp),%r12d
mov    0x28(%rsp),%r14
movaps 0x80(%rsp),%xmm8
mov    0x78(%rsp),%r13
movdqa 0x1e3e(%rip),%xmm6
movdqa 0x1e46(%rip),%xmm7
mov    0x10(%rsp),%rdi
mov    0xc0(%rsp),%ebp
cmp    %r11d,%ebp
jge    20c0 <grid+0xfa0>
mov    0x40(%rsp),%rcx
mov    0x8(%rcx),%rsi
lea    (%rsi,%r10,4),%rcx
mov    0x38(%rsp),%rdx
mov    (%rdx,%r10,8),%r8
movslq %ebp,%r15
mov    0x20(%rsp),%edx
mov    %edx,%ebp
mov    %rdi,%r14
sub    %edi,%ebp
xor    %edx,%edx
cmp    $0x7,%ebp
jae    2240 <grid+0x1120>
mov    %r15,%r9
jmp    2283 <grid+0x1163>
nop
mov    %r10,0x8(%rsp)
mov    0x48(%rsp),%rdi
lea    (%rdi,%r13,1),%r9
lea    (%r8,%r15,4),%r10
lea    (%rsi,%r9,4),%rsi
cmp    %rsi,%r10
jae    231c <grid+0x11fc>
lea    (%r15,%rbp,1),%rsi
lea    (%r8,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rcx
jae    231c <grid+0x11fc>
mov    %r15,%r9
mov    0x3d6a(%rip),%rbx
mov    0x8(%rsp),%r10
mov    %r14,%rbp
mov    0x28(%rsp),%r14
mov    %edx,%edi
not    %edi
add    %r11d,%edi
sub    %ebp,%edi
lea    (%rdx,%rbp,1),%esi
test   $0x1,%dil
je     22ba <grid+0x119a>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm15,%xmm0
addss  (%rcx),%xmm0
movss  %xmm0,(%r8,%r9,4)
add    $0x1,%edx
add    $0x1,%r9
cmp    %esi,0x20(%rsp)
je     20c0 <grid+0xfa0>
not    %ebp
add    %r11d,%ebp
lea    (%r8,%r9,4),%rsi
add    $0x4,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  %xmm15,%xmm0
addss  (%rcx),%xmm0
lea    0x1(%rdx),%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
movss  %xmm0,-0x4(%rsi)
mulss  %xmm15,%xmm1
addss  (%rcx),%xmm1
movss  %xmm1,(%rsi)
add    $0x8,%rsi
add    $0x2,%edx
cmp    %ebp,%edx
jne    22e0 <grid+0x11c0>
jmp    20c0 <grid+0xfa0>
add    $0x1,%rbp
mov    %rbp,%rdx
movabs $0x1fffffff8,%rsi
and    %rsi,%rdx
lea    (%rdx,%r15,1),%r9
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%r8,%r15,4),%rdi
add    $0x10,%rdi
xor    %esi,%esi
movdqa 0x1cd2(%rip),%xmm1
xchg   %ax,%ax
movdqa %xmm1,%xmm2
paddd  %xmm6,%xmm2
cvtdq2ps %xmm1,%xmm3
cvtdq2ps %xmm2,%xmm2
mulps  %xmm8,%xmm3
addps  %xmm0,%xmm3
mulps  %xmm8,%xmm2
addps  %xmm0,%xmm2
movups %xmm3,-0x10(%rdi,%rsi,4)
movups %xmm2,(%rdi,%rsi,4)
add    $0x8,%rsi
paddd  %xmm7,%xmm1
cmp    %rsi,%rdx
jne    2350 <grid+0x1230>
cmp    %rdx,%rbp
mov    0x3c5c(%rip),%rbx
mov    0x8(%rsp),%r10
mov    %r14,%rbp
mov    0x28(%rsp),%r14
je     20c0 <grid+0xfa0>
jmp    228b <grid+0x116b>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
movabs $0x1fffffff8,%r8
movslq %ebx,%rcx
movslq %r12d,%r10
lea    0x1(%rcx),%r9
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
xor    %r15d,%r15d
movdqa 0x1c4b(%rip),%xmm1
movdqa 0x1c53(%rip),%xmm2
movdqa 0x1c5b(%rip),%xmm3
jmp    2401 <grid+0x12e1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%r15
cmp    %r10,%rcx
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%rcx,4),%rdx
mov    0x160(%rsp),%eax
cmp    %eax,%edx
mov    0x38(%rsp),%rax
jge    23f0 <grid+0x12d0>
mov    0x8(%r13),%rsi
lea    (%rsi,%rcx,4),%rbp
mov    (%rax,%rcx,8),%r11
mov    %edx,%eax
not    %eax
mov    0x160(%rsp),%edi
add    %edi,%eax
xor    %ebx,%ebx
cmp    $0x7,%eax
jae    2450 <grid+0x1330>
mov    %rdx,%r14
jmp    24f0 <grid+0x13d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r9,%r15,1),%rdi
lea    (%r11,%rdx,4),%r14
lea    (%rsi,%rdi,4),%rsi
cmp    %rsi,%r14
jae    2481 <grid+0x1361>
mov    %edx,%esi
not    %esi
mov    0x160(%rsp),%edi
add    %edi,%esi
add    %rdx,%rsi
lea    (%r11,%rsi,4),%rsi
add    $0x4,%rsi
mov    %rdx,%r14
cmp    %rsi,%rbp
jb     24f0 <grid+0x13d0>
add    $0x1,%rax
mov    %rax,%rbx
and    %r8,%rbx
lea    (%rbx,%rdx,1),%r14
movss  0x0(%rbp),%xmm4
shufps $0x0,%xmm4,%xmm4
lea    (%r11,%rdx,4),%rsi
add    $0x10,%rsi
xor    %edi,%edi
movdqa %xmm1,%xmm5
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
cvtdq2ps %xmm5,%xmm7
cvtdq2ps %xmm6,%xmm6
mulps  %xmm0,%xmm7
addps  %xmm4,%xmm7
mulps  %xmm0,%xmm6
addps  %xmm4,%xmm6
movups %xmm7,-0x10(%rsi,%rdi,4)
movups %xmm6,(%rsi,%rdi,4)
add    $0x8,%rdi
paddd  %xmm3,%xmm5
cmp    %rdi,%rbx
jne    24b0 <grid+0x1390>
cmp    %rbx,%rax
je     23f0 <grid+0x12d0>
nopl   0x0(%rax)
mov    0x160(%rsp),%esi
mov    %rsi,%rdi
sub    %edx,%esi
sub    %ebx,%esi
mov    %ebx,%eax
not    %eax
add    %edi,%eax
test   $0x1,%sil
je     2528 <grid+0x1408>
xorps  %xmm4,%xmm4
cvtsi2ss %ebx,%xmm4
mulss  %xmm15,%xmm4
addss  0x0(%rbp),%xmm4
movss  %xmm4,(%r11,%r14,4)
add    $0x1,%r14
add    $0x1,%ebx
cmp    %edx,%eax
je     23f0 <grid+0x12d0>
mov    0x160(%rsp),%eax
sub    %edx,%eax
lea    (%r11,%r14,4),%rdx
add    $0x4,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm4,%xmm4
cvtsi2ss %ebx,%xmm4
mulss  %xmm15,%xmm4
addss  0x0(%rbp),%xmm4
lea    0x1(%rbx),%esi
xorps  %xmm5,%xmm5
cvtsi2ss %esi,%xmm5
movss  %xmm4,-0x4(%rdx)
mulss  %xmm15,%xmm5
addss  0x0(%rbp),%xmm5
movss  %xmm5,(%rdx)
add    $0x8,%rdx
add    $0x2,%ebx
cmp    %eax,%ebx
jne    2550 <grid+0x1430>
jmp    23f0 <grid+0x12d0>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
xorps  %xmm1,%xmm1
cvtss2sd %xmm15,%xmm1
movslq %ebx,%rbx
mov    0x160(%rsp),%eax
movslq %eax,%r14
movsd  %xmm1,0x18(%rsp)
mov    0x38(%rsp),%r15
jmp    25cd <grid+0x14ad>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %r12d,%ebx
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%rbx,4),%rbp
mov    0x160(%rsp),%eax
cmp    %eax,%ebp
jge    25c0 <grid+0x14a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x8(%r13),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1040 <drand48@plt>
movsd  0x19ee(%rip),%xmm2
movsd  0x18(%rsp),%xmm1
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r15,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    25f0 <grid+0x14d0>
jmp    25c0 <grid+0x14a0>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x199e(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%edx
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
cvtsi2ss %edx,%xmm4
mov    $0x1,%r12d
sub    %eax,%r12d
movslq %ebx,%r15
mov    0x0(%r13),%rax
mov    (%r9),%rcx
mov    0x140(%rsp),%rdx
mov    (%rdx),%rdx
mov    %r12d,0x80(%rsp)
movss  %xmm2,0xb0(%rsp)
movss  %xmm4,0x10(%rsp)
jmp    26ea <grid+0x15ca>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x150(%rsp),%r15d
mov    0x80(%rsp),%r12d
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rsi
movslq (%rsi,%r15,4),%r13
mov    0x20(%rsp),%rsi
lea    (%rsi,%r13,1),%ebx
mov    0x160(%rsp),%esi
cmp    %esi,%ebx
cmovge %esi,%ebx
cmp    %ebx,%r13d
jle    2730 <grid+0x1610>
lea    0x1(%rbx),%ebp
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r12
mov    0x40(%rsp),%rdi
mov    %rbx,%r13
cmp    %esi,%ebp
jge    26d0 <grid+0x15b0>
jmp    28b5 <grid+0x1795>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rsi
mov    0x8(%rsi),%rsi
movss  (%rsi,%r15,4),%xmm0
subss  (%rax,%r15,4),%xmm0
mov    0x8(%r9),%rax
movss  (%rax,%r15,4),%xmm1
subss  (%rcx,%r15,4),%xmm1
divss  %xmm4,%xmm0
movss  %xmm0,0x18(%rsp)
divss  %xmm4,%xmm1
movss  %xmm1,0x28(%rsp)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%rax
movss  (%rax,%r15,4),%xmm0
subss  (%rdx,%r15,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,0x78(%rsp)
xor    %ebp,%ebp
test   %r13d,%r13d
sete   %bpl
mov    %rbx,0x48(%rsp)
add    $0x1,%ebx
mov    %ebx,0x50(%rsp)
sub    %r13d,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
divss  %xmm4,%xmm0
mov    0x3826(%rip),%rax
mulss  (%rax),%xmm0
mov    %r9,%r14
call   1030 <cos@plt>
movsd  0x1832(%rip),%xmm1
movss  0x10(%rsp),%xmm4
mov    %r14,%r9
add    $0xffffffff,%eax
imul   %r12d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x40(%rsp),%rax
mov    (%rax),%rax
movss  0x18(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%rax,%r15,4),%xmm1
mov    0x38(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
movss  %xmm1,(%rcx,%r13,4)
mov    (%r14),%rcx
movss  0x28(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r15,4),%xmm1
mov    0x8(%rsp),%rdx
mov    (%rdx,%r15,8),%rdx
movss  %xmm1,(%rdx,%r13,4)
mov    0x140(%rsp),%rdx
mov    (%rdx),%rdx
mulss  0x78(%rsp),%xmm0
addss  (%rdx,%r15,4),%xmm0
mov    0x30(%rsp),%rsi
mov    (%rsi,%r15,8),%rsi
movss  %xmm0,(%rsi,%r13,4)
add    $0x1,%ebp
add    $0x1,%r13
add    $0xffffffff,%ebx
jne    27b0 <grid+0x1690>
mov    0x38(%rsp),%r14
mov    0x160(%rsp),%esi
movaps 0xf0(%rsp),%xmm15
mov    0x30(%rsp),%r12
mov    0x40(%rsp),%rdi
movaps 0xc0(%rsp),%xmm3
movss  0xb0(%rsp),%xmm2
mov    0x48(%rsp),%r13
mov    0x50(%rsp),%ebp
cmp    %esi,%ebp
jge    26d0 <grid+0x15b0>
mov    0x8(%rdi),%r8
mov    0x8(%r9),%r11
mov    0x140(%rsp),%rdi
mov    0x8(%rdi),%r10
movslq %ebp,%rbx
not    %r13d
add    %esi,%r13d
shl    $0x2,%rbx
mov    (%r14,%r15,8),%rsi
add    %rbx,%rsi
mov    0x8(%rsp),%rdi
mov    (%rdi,%r15,8),%rdi
add    %rbx,%rdi
add    (%r12,%r15,8),%rbx
xor    %ebp,%ebp
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r8,%r15,4),%xmm1
movss  %xmm1,(%rsi,%rbp,4)
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
addss  (%r11,%r15,4),%xmm1
movss  %xmm1,(%rdi,%rbp,4)
mulss  %xmm3,%xmm0
addss  (%r10,%r15,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%r13d
jne    28f0 <grid+0x17d0>
jmp    26d0 <grid+0x15b0>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
movslq %ebx,%rax
movslq %r12d,%r8
jmp    295d <grid+0x183d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r8,%rax
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rcx
movslq (%rcx,%rax,4),%rdx
mov    0x160(%rsp),%ebx
cmp    %ebx,%edx
jge    2950 <grid+0x1830>
mov    0x8(%r13),%r11
mov    0x8(%r9),%r10
mov    0x140(%rsp),%rcx
mov    0x8(%rcx),%rbp
sub    %edx,%ebx
shl    $0x2,%rdx
mov    0x38(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
add    %rdx,%rcx
mov    0x8(%rsp),%rsi
mov    (%rsi,%rax,8),%rsi
add    %rdx,%rsi
mov    0x30(%rsp),%rdi
add    (%rdi,%rax,8),%rdx
xor    %edi,%edi
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r11,%rax,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
addss  (%r10,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rdi,4)
mulss  %xmm3,%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%ebx
jne    29b0 <grid+0x1890>
jmp    2950 <grid+0x1830>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
xorps  %xmm0,%xmm0
cvtss2sd %xmm15,%xmm0
movsd  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movsd  %xmm0,0x78(%rsp)
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movslq %ebx,%rbx
mov    0x160(%rsp),%eax
movslq %eax,%r14
movsd  %xmm1,0x10(%rsp)
mov    0x30(%rsp),%r15
jmp    2a54 <grid+0x1934>
nopl   (%rax)
add    $0x1,%rbx
cmp    0x150(%rsp),%ebx
mov    %r12,%r9
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%rbx,4),%rbp
mov    0x160(%rsp),%eax
cmp    %eax,%ebp
mov    %r9,%r12
jge    2a40 <grid+0x1920>
nopl   0x0(%rax,%rax,1)
mov    0x8(%r13),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x156e(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x28(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x38(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    0x8(%r12),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %eax,%eax
call   1040 <drand48@plt>
addsd  0x1521(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x78(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x8(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %eax,%eax
call   1040 <drand48@plt>
movsd  0x14cd(%rip),%xmm2
movsd  0x10(%rsp),%xmm1
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x18(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r15,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    2a70 <grid+0x1950>
jmp    2a40 <grid+0x1920>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
movabs $0x1fffffff8,%rax
movslq %ebx,%r8
movslq %r12d,%r15
lea    0x1(%r8),%rcx
mov    %rcx,0x48(%rsp)
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
movaps %xmm3,%xmm1
shufps $0x0,%xmm3,%xmm1
xor    %r14d,%r14d
add    $0x4,%rax
mov    %rax,0x50(%rsp)
movaps 0x1468(%rip),%xmm8
movdqa 0x146f(%rip),%xmm9
mov    %r15,0x80(%rsp)
jmp    2be1 <grid+0x1ac1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x1,%r14
cmp    %r15,%r8
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%r8,4),%r13
mov    0x160(%rsp),%edx
cmp    %edx,%r13d
jge    2bd0 <grid+0x1ab0>
mov    0x40(%rsp),%rax
mov    0x8(%rax),%r11
lea    (%r11,%r8,4),%r9
mov    0x38(%rsp),%rax
mov    (%rax,%r8,8),%rax
mov    %rax,0x8(%rsp)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%r12
lea    (%r12,%r8,4),%r10
mov    0x30(%rsp),%rax
mov    (%rax,%r8,8),%rbx
mov    %r13d,%eax
not    %eax
add    %edx,%eax
xor    %esi,%esi
cmp    $0x3,%eax
mov    %rbx,0x18(%rsp)
jae    2c48 <grid+0x1b28>
mov    %r13,%r12
mov    %rdx,%rbp
jmp    2db0 <grid+0x1c90>
mov    0x48(%rsp),%rcx
mov    0x8(%rsp),%rbp
add    %r14,%rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%r13,4),%rdi
add    %rbp,%rdi
mov    %r13d,%ecx
not    %ecx
add    %edx,%ecx
add    %r13,%rcx
lea    0x4(,%rcx,4),%r15
add    %rbp,%r15
lea    (%rbx,%r13,4),%rdx
lea    0x4(%rbx,%rcx,4),%rbp
mov    0x28(%rsp),%rcx
lea    (%r11,%rcx,4),%r11
lea    (%r12,%rcx,4),%rbx
cmp    %rbp,%rdi
setb   0x28(%rsp)
cmp    %r15,%rdx
setb   0x78(%rsp)
cmp    %r11,%rdi
setb   %cl
cmp    %r15,%r9
setb   0x10(%rsp)
cmp    %rbx,%rdi
setb   %r12b
cmp    %r15,%r10
setb   0xf0(%rsp)
cmp    %r11,%rdx
setb   %r15b
cmp    %rbp,%r9
setb   0x20(%rsp)
cmp    %rbx,%rdx
setb   %r11b
cmp    %rbp,%r10
setb   %bpl
mov    0x78(%rsp),%bl
test   %bl,0x28(%rsp)
jne    2d9b <grid+0x1c7b>
and    0x10(%rsp),%cl
jne    2d9b <grid+0x1c7b>
and    0xf0(%rsp),%r12b
jne    2d9b <grid+0x1c7b>
and    0x20(%rsp),%r15b
jne    2d9b <grid+0x1c7b>
mov    %r13,%r12
and    %bpl,%r11b
mov    0x160(%rsp),%ebp
mov    0x80(%rsp),%r15
jne    2db0 <grid+0x1c90>
add    $0x1,%rax
mov    %rax,%rsi
and    0x50(%rsp),%rsi
lea    (%rsi,%r13,1),%r12
movss  (%r9),%xmm4
shufps $0x0,%xmm4,%xmm4
movss  (%r10),%xmm5
shufps $0x0,%xmm5,%xmm5
xor    %ecx,%ecx
movaps %xmm8,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtdq2ps %xmm6,%xmm2
movaps %xmm2,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm4,%xmm7
movups %xmm7,(%rdi,%rcx,4)
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
movups %xmm2,(%rdx,%rcx,4)
add    $0x4,%rcx
paddd  %xmm9,%xmm6
cmp    %rcx,%rsi
jne    2d60 <grid+0x1c40>
cmp    %rsi,%rax
movaps 0xc0(%rsp),%xmm3
je     2bd0 <grid+0x1ab0>
jmp    2db0 <grid+0x1c90>
mov    %r13,%r12
mov    0x160(%rsp),%ebp
mov    0x80(%rsp),%r15
nopl   (%rax)
mov    %ebp,%ecx
sub    %r13d,%ecx
sub    %esi,%ecx
mov    %esi,%eax
not    %eax
add    %ebp,%eax
test   $0x1,%cl
je     2dfc <grid+0x1cdc>
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
movaps %xmm2,%xmm4
mulss  %xmm15,%xmm4
addss  (%r9),%xmm4
mov    0x8(%rsp),%rcx
movss  %xmm4,(%rcx,%r12,4)
mulss  %xmm3,%xmm2
addss  (%r10),%xmm2
mov    0x18(%rsp),%rcx
movss  %xmm2,(%rcx,%r12,4)
add    $0x1,%r12
add    $0x1,%esi
cmp    %r13d,%eax
je     2bd0 <grid+0x1ab0>
mov    %ebp,%eax
sub    %r13d,%eax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r12,4),%rdx
add    $0x4,%rdx
mov    0x18(%rsp),%rcx
lea    (%rcx,%r12,4),%rdi
add    $0x4,%rdi
mov    %esi,%esi
xor    %ecx,%ecx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    (%rsi,%rcx,1),%ebx
xorps  %xmm2,%xmm2
cvtsi2ss %ebx,%xmm2
movaps %xmm2,%xmm4
mulss  %xmm15,%xmm4
addss  (%r9),%xmm4
movss  %xmm4,-0x4(%rdx,%rcx,4)
mulss  %xmm3,%xmm2
addss  (%r10),%xmm2
lea    0x1(%rsi,%rcx,1),%ebx
xorps  %xmm4,%xmm4
cvtsi2ss %ebx,%xmm4
movss  %xmm2,-0x4(%rdi,%rcx,4)
movaps %xmm4,%xmm2
mulss  %xmm15,%xmm2
addss  (%r9),%xmm2
movss  %xmm2,(%rdx,%rcx,4)
mulss  %xmm3,%xmm4
addss  (%r10),%xmm4
movss  %xmm4,(%rdi,%rcx,4)
add    $0x2,%rbp
lea    (%rsi,%rcx,1),%ebx
add    $0x2,%ebx
mov    %rbp,%rcx
cmp    %eax,%ebx
jne    2e30 <grid+0x1d10>
jmp    2bd0 <grid+0x1ab0>
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
xorps  %xmm0,%xmm0
cvtss2sd %xmm15,%xmm0
movsd  %xmm0,0x18(%rsp)
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movslq %ebx,%rbx
mov    0x160(%rsp),%eax
movslq %eax,%rcx
movsd  %xmm1,0x28(%rsp)
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%r12
jmp    2ef4 <grid+0x1dd4>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    0x150(%rsp),%ebx
mov    %r14,%r13
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%rbx,4),%rbp
mov    0x160(%rsp),%eax
cmp    %eax,%ebp
mov    %r13,%r14
jge    2ee0 <grid+0x1dc0>
nopl   0x0(%rax,%rax,1)
mov    0x8(%r14),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
mov    %rcx,%r13
call   1040 <drand48@plt>
addsd  0x10cb(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r15,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%rax
movss  (%rax,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1040 <drand48@plt>
movsd  0x107c(%rip),%xmm2
mov    %r13,%rcx
movsd  0x28(%rsp),%xmm1
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r12,%rbx,8),%rax
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    2f10 <grid+0x1df0>
jmp    2ee0 <grid+0x1dc0>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    34ff <grid+0x23df>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x1025(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%ebp
cvtsi2ss %ebp,%xmm10
movabs $0x1fffffff8,%rdx
mov    $0x1,%ecx
sub    %eax,%ecx
mov    %ecx,0x78(%rsp)
movslq %ebx,%rdi
mov    0x0(%r13),%r11
mov    0x140(%rsp),%rax
mov    (%rax),%r10
mov    0x160(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x50(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xe0(%rsp)
movaps %xmm15,%xmm8
shufps $0x0,%xmm15,%xmm8
movaps %xmm3,%xmm9
shufps $0x0,%xmm3,%xmm9
xor    %r15d,%r15d
add    $0x4,%rdx
mov    %rdx,0xd8(%rsp)
movdqa 0xfca(%rip),%xmm7
mov    0x2f7b(%rip),%rcx
mov    %rbp,0x80(%rsp)
movss  %xmm10,0x28(%rsp)
movaps %xmm8,0xb0(%rsp)
movaps %xmm9,0xa0(%rsp)
jmp    30b6 <grid+0x1f96>
add    $0x1,%rdi
add    $0x1,%r15
mov    0x150(%rsp),%eax
cmp    %eax,%edi
mov    0x2f40(%rip),%rcx
mov    0x80(%rsp),%rbp
je     34ff <grid+0x23df>
mov    0x70(%rsp),%rax
movslq (%rax,%rdi,4),%rbx
lea    (%rbx,%rbp,1),%esi
mov    0x160(%rsp),%eax
cmp    %eax,%esi
cmovge %eax,%esi
cmp    %esi,%ebx
mov    %rsi,0x10(%rsp)
jle    30e0 <grid+0x1fc0>
lea    0x1(%rsi),%ebx
jmp    3214 <grid+0x20f4>
nop
mov    %r15,0x20(%rsp)
mov    0x8(%r13),%rdx
movss  (%rdx,%rdi,4),%xmm0
subss  (%r11,%rdi,4),%xmm0
divss  %xmm10,%xmm0
movss  %xmm0,0x8(%rsp)
mov    0x140(%rsp),%rax
mov    0x8(%rax),%rax
movss  (%rax,%rdi,4),%xmm0
subss  (%r10,%rdi,4),%xmm0
divss  %xmm10,%xmm0
movss  %xmm0,0x18(%rsp)
xor    %ebp,%ebp
test   %ebx,%ebx
sete   %bpl
lea    0x1(%rsi),%r14d
mov    %r14d,0x48(%rsp)
sub    %ebx,%r14d
mov    0x38(%rsp),%r13
mov    0x30(%rsp),%r15
nop
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
divss  %xmm10,%xmm0
mulss  (%rcx),%xmm0
mov    %rdi,%r12
call   1030 <cos@plt>
movsd  0xea8(%rip),%xmm1
mov    %r12,%rdi
movss  0x28(%rsp),%xmm10
add    $0xffffffff,%eax
imul   0x78(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x40(%rsp),%rax
mov    (%rax),%r11
movss  0x8(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%r11,%r12,4),%xmm1
mov    0x0(%r13,%r12,8),%rcx
movss  %xmm1,(%rcx,%rbx,4)
mov    0x2e3e(%rip),%rcx
mov    0x140(%rsp),%rax
mov    (%rax),%r10
mulss  0x18(%rsp),%xmm0
addss  (%r10,%r12,4),%xmm0
mov    (%r15,%r12,8),%rdx
movss  %xmm0,(%rdx,%rbx,4)
add    $0x1,%ebp
add    $0x1,%rbx
add    $0xffffffff,%r14d
jne    3140 <grid+0x2020>
movaps 0xf0(%rsp),%xmm15
mov    0x40(%rsp),%r13
movaps 0xc0(%rsp),%xmm3
movaps 0xb0(%rsp),%xmm8
movaps 0xa0(%rsp),%xmm9
mov    0x20(%rsp),%r15
movdqa 0xe20(%rip),%xmm7
mov    0x48(%rsp),%ebx
mov    0x160(%rsp),%eax
cmp    %eax,%ebx
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%rcx
jge    3090 <grid+0x1f70>
mov    0x8(%r13),%rdx
lea    (%rdx,%rdi,4),%r8
mov    0x38(%rsp),%rax
mov    (%rax,%rdi,8),%rbp
mov    0x140(%rsp),%rax
mov    0x8(%rax),%r12
lea    (%r12,%rdi,4),%r9
mov    (%rsi,%rdi,8),%rax
mov    %rax,0x18(%rsp)
movslq %ebx,%rsi
mov    0x50(%rsp),%eax
sub    %ecx,%eax
xor    %r14d,%r14d
cmp    $0x3,%eax
mov    %rsi,0x8(%rsp)
jae    3277 <grid+0x2157>
mov    0x10(%rsp),%rcx
jmp    33e8 <grid+0x22c8>
mov    %rdi,0x68(%rsp)
mov    0xe0(%rsp),%rcx
mov    %r15,0x20(%rsp)
add    %r15,%rcx
mov    %rcx,0x48(%rsp)
lea    0x0(%rbp,%rsi,4),%r15
mov    %r12,%rdi
mov    0x18(%rsp),%r12
mov    %rax,0x98(%rsp)
add    %rsi,%rax
mov    %rbp,0x60(%rsp)
lea    0x4(%rbp,%rax,4),%rcx
lea    (%r12,%rsi,4),%rbx
lea    0x4(%r12,%rax,4),%rsi
mov    0x48(%rsp),%rax
lea    (%rdx,%rax,4),%rbp
lea    (%rdi,%rax,4),%rdx
cmp    %rsi,%r15
setb   0x48(%rsp)
cmp    %rcx,%rbx
setb   %dil
cmp    %rbp,%r15
setb   %al
cmp    %rcx,%r8
setb   0x58(%rsp)
cmp    %rdx,%r15
setb   %r12b
cmp    %rcx,%r9
setb   0xe8(%rsp)
cmp    %rbp,%rbx
setb   %cl
cmp    %rsi,%r8
setb   %bpl
cmp    %rdx,%rbx
setb   %dl
cmp    %rsi,%r9
setb   %sil
test   %dil,0x48(%rsp)
jne    33d4 <grid+0x22b4>
and    0x58(%rsp),%al
jne    33d4 <grid+0x22b4>
and    0xe8(%rsp),%r12b
jne    33d4 <grid+0x22b4>
and    %bpl,%cl
jne    33d4 <grid+0x22b4>
and    %sil,%dl
jne    33d4 <grid+0x22b4>
mov    0x98(%rsp),%rax
add    $0x1,%rax
mov    %rax,%r14
and    0xd8(%rsp),%r14
add    %r14,0x8(%rsp)
movss  (%r8),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  (%r9),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %ebp,%ebp
movaps 0xca2(%rip),%xmm2
mov    0x68(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtdq2ps %xmm2,%xmm5
movaps %xmm5,%xmm4
mulps  %xmm8,%xmm4
addps  %xmm0,%xmm4
movups %xmm4,(%r15,%rbp,4)
mulps  %xmm9,%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%rbx,%rbp,4)
add    $0x4,%rbp
paddd  %xmm7,%xmm2
cmp    %rbp,%r14
jne    3390 <grid+0x2270>
cmp    %r14,%rax
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%rcx
mov    0x60(%rsp),%rbp
je     3090 <grid+0x1f70>
jmp    33e8 <grid+0x22c8>
mov    0x68(%rsp),%rdi
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%rcx
mov    0x60(%rsp),%rbp
mov    %r14d,%edx
not    %edx
mov    0x160(%rsp),%eax
add    %eax,%edx
sub    %ecx,%edx
lea    (%r14,%rcx,1),%eax
test   $0x1,%dl
je     3441 <grid+0x2321>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r8),%xmm1
mov    0x8(%rsp),%rdx
movss  %xmm1,0x0(%rbp,%rdx,4)
mulss  %xmm3,%xmm0
addss  (%r9),%xmm0
mov    0x18(%rsp),%rcx
movss  %xmm0,(%rcx,%rdx,4)
add    $0x1,%r14d
add    $0x1,%rdx
mov    %rdx,0x8(%rsp)
cmp    %eax,0x50(%rsp)
mov    0x10(%rsp),%r12
je     3090 <grid+0x1f70>
not    %r12d
mov    0x160(%rsp),%eax
add    %eax,%r12d
mov    0x8(%rsp),%rdx
lea    0x4(,%rdx,4),%rcx
add    %rbp,%rcx
mov    0x18(%rsp),%rax
lea    (%rax,%rdx,4),%rbp
add    $0x4,%rbp
mov    %r14d,%ebx
xor    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rdx,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r8),%xmm1
movss  %xmm1,-0x4(%rcx,%rdx,4)
mulss  %xmm3,%xmm0
addss  (%r9),%xmm0
lea    0x1(%rbx,%rdx,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  %xmm0,-0x4(%rbp,%rdx,4)
movaps %xmm1,%xmm0
mulss  %xmm15,%xmm0
addss  (%r8),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
mulss  %xmm3,%xmm1
addss  (%r9),%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
add    $0x2,%rsi
lea    (%rbx,%rdx,1),%eax
add    $0x2,%eax
mov    %rsi,%rdx
cmp    %r12d,%eax
jne    3490 <grid+0x2370>
jmp    3090 <grid+0x1f70>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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