#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);
void gridabove(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 = 0, k = 0; j < zp[i]; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * 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 = 0, k = 0; j < zp[i]; j++, k++) {
          gridcp[i][j] = cp[1][i] + (float)k * gradcp;
          gridro[i][j] = ro[1][i] + (float)k * 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 = 0, k = 0; j < zp[i]; 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;
        }
      }
    }
    return;
  }
}


x86 assembly (clang, -O0):
<gridabove>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%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    1689 <gridabove+0x579>
cmpq   $0x0,-0x18(%rbp)
jne    1689 <gridabove+0x579>
cmpl   $0x1,0x28(%rbp)
jne    1373 <gridabove+0x263>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    11c0 <gridabove+0xb0>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e4e(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    11df <gridabove+0xcf>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e2a(%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    136e <gridabove+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    124d <gridabove+0x13d>
movl   $0x1,-0x5c(%rbp)
jmp    1254 <gridabove+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    127c <gridabove+0x16c>
mov    -0x50(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    1282 <gridabove+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     12f0 <gridabove+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    1296 <gridabove+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    135b <gridabove+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    1300 <gridabove+0x1f0>
jmp    1360 <gridabove+0x250>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11f4 <gridabove+0xe4>
jmp    1684 <gridabove+0x574>
cmpl   $0x2,0x28(%rbp)
jne    15d5 <gridabove+0x4c5>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    13bf <gridabove+0x2af>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c52(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    13e1 <gridabove+0x2d1>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c2b(%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    15d0 <gridabove+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    1452 <gridabove+0x342>
movl   $0x1,-0x5c(%rbp)
jmp    1459 <gridabove+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    1484 <gridabove+0x374>
mov    -0x50(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    148d <gridabove+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     1552 <gridabove+0x442>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    0x3b26(%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  0x1b11(%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    14a4 <gridabove+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    15bd <gridabove+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    1562 <gridabove+0x452>
jmp    15c2 <gridabove+0x4b2>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13f9 <gridabove+0x2e9>
jmp    167f <gridabove+0x56f>
cmpl   $0x3,0x28(%rbp)
jne    167a <gridabove+0x56a>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1675 <gridabove+0x565>
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1662 <gridabove+0x552>
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    15ff <gridabove+0x4ef>
jmp    1667 <gridabove+0x557>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15e5 <gridabove+0x4d5>
jmp    167a <gridabove+0x56a>
jmp    167f <gridabove+0x56f>
jmp    1684 <gridabove+0x574>
jmp    2538 <gridabove+0x1428>
cmpq   $0x0,-0x10(%rbp)
jne    1d2c <gridabove+0xc1c>
cmpl   $0x1,0x28(%rbp)
jne    1940 <gridabove+0x830>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16e0 <gridabove+0x5d0>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1931(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1702 <gridabove+0x5f2>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x190a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%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    193b <gridabove+0x82b>
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    17a2 <gridabove+0x692>
movl   $0x1,-0x5c(%rbp)
jmp    17a9 <gridabove+0x699>
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    17d4 <gridabove+0x6c4>
mov    -0x50(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    17dd <gridabove+0x6cd>
mov    0x30(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%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     1885 <gridabove+0x775>
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    17f4 <gridabove+0x6e4>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1928 <gridabove+0x818>
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    1895 <gridabove+0x785>
jmp    192d <gridabove+0x81d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    171a <gridabove+0x60a>
jmp    1d27 <gridabove+0xc17>
cmpl   $0x2,0x28(%rbp)
jne    1c40 <gridabove+0xb30>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    198c <gridabove+0x87c>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1685(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    19ae <gridabove+0x89e>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x165e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%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    1c3b <gridabove+0xb2b>
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    1a4e <gridabove+0x93e>
movl   $0x1,-0x5c(%rbp)
jmp    1a55 <gridabove+0x945>
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    1a80 <gridabove+0x970>
mov    -0x50(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1a89 <gridabove+0x979>
mov    0x30(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%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     1b85 <gridabove+0xa75>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    0x352a(%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    -0xb0(%rbp),%eax
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  0x1515(%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    1aa0 <gridabove+0x990>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1c28 <gridabove+0xb18>
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    1b95 <gridabove+0xa85>
jmp    1c2d <gridabove+0xb1d>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    19c6 <gridabove+0x8b6>
jmp    1d22 <gridabove+0xc12>
cmpl   $0x3,0x28(%rbp)
jne    1d1d <gridabove+0xc0d>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1d18 <gridabove+0xc08>
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1d05 <gridabove+0xbf5>
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    1c6a <gridabove+0xb5a>
jmp    1d0a <gridabove+0xbfa>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1c50 <gridabove+0xb40>
jmp    1d1d <gridabove+0xc0d>
jmp    1d22 <gridabove+0xc12>
jmp    1d27 <gridabove+0xc17>
jmp    2538 <gridabove+0x1428>
cmpl   $0x1,0x28(%rbp)
jne    2076 <gridabove+0xf66>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1d78 <gridabove+0xc68>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1299(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1d9a <gridabove+0xc8a>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1272(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%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    2071 <gridabove+0xf61>
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    1e69 <gridabove+0xd59>
movl   $0x1,-0x5c(%rbp)
jmp    1e70 <gridabove+0xd60>
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    1e9b <gridabove+0xd8b>
mov    -0x50(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1ea4 <gridabove+0xd94>
mov    0x30(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%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     1f83 <gridabove+0xe73>
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    1ebb <gridabove+0xdab>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    205e <gridabove+0xf4e>
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    1f93 <gridabove+0xe83>
jmp    2063 <gridabove+0xf53>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1db2 <gridabove+0xca2>
jmp    2533 <gridabove+0x1423>
cmpl   $0x2,0x28(%rbp)
jne    2414 <gridabove+0x1304>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    20c2 <gridabove+0xfb2>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf4f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    20e4 <gridabove+0xfd4>
movss  -0x34(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xf28(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%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    240f <gridabove+0x12ff>
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    21b3 <gridabove+0x10a3>
movl   $0x1,-0x5c(%rbp)
jmp    21ba <gridabove+0x10aa>
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    21e5 <gridabove+0x10d5>
mov    -0x50(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    21ee <gridabove+0x10de>
mov    0x30(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%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     2321 <gridabove+0x1211>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    0x2dc5(%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    -0xd0(%rbp),%eax
sub    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  0xdb0(%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    2205 <gridabove+0x10f5>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    23fc <gridabove+0x12ec>
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    2331 <gridabove+0x1221>
jmp    2401 <gridabove+0x12f1>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    20fc <gridabove+0xfec>
jmp    252e <gridabove+0x141e>
cmpl   $0x3,0x28(%rbp)
jne    2529 <gridabove+0x1419>
mov    0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    2524 <gridabove+0x1414>
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    2511 <gridabove+0x1401>
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    243e <gridabove+0x132e>
jmp    2516 <gridabove+0x1406>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    2424 <gridabove+0x1314>
jmp    2529 <gridabove+0x1419>
jmp    252e <gridabove+0x141e>
jmp    2533 <gridabove+0x1423>
jmp    2538 <gridabove+0x1428>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gridabove>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
movaps %xmm1,%xmm15
mov    %r9,0x18(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rdi,0x40(%rsp)
mov    0x138(%rsp),%eax
mov    0x130(%rsp),%r12d
mov    0x128(%rsp),%ebx
mov    %rsi,%rcx
or     %rdx,%rcx
movaps %xmm1,0xc0(%rsp)
mov    %r8,0x10(%rsp)
jne    12de <gridabove+0x1ce>
cmp    $0x1,%eax
je     16e9 <gridabove+0x5d9>
cmp    $0x2,%eax
je     1b3c <gridabove+0xa2c>
cmp    $0x3,%eax
jne    30c4 <gridabove+0x1fb4>
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
movslq %ebx,%rax
movslq %r12d,%r9
lea    0x1(%rax),%r11
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
xor    %r10d,%r10d
movdqa 0x2e68(%rip),%xmm1
movdqa 0x2e70(%rip),%xmm2
movdqa 0x2e78(%rip),%xmm3
jmp    11d1 <gridabove+0xc1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%r10
cmp    %r9,%rax
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rcx
mov    (%rcx,%rax,4),%edi
test   %edi,%edi
jle    11c0 <gridabove+0xb0>
mov    0x8(%r8),%rcx
lea    (%rcx,%rax,4),%rbp
mov    0x40(%rsp),%rdx
mov    (%rdx,%rax,8),%rbx
cmp    $0x8,%edi
jb     120c <gridabove+0xfc>
lea    (%r11,%r10,1),%rdx
lea    (%rcx,%rdx,4),%rcx
cmp    %rcx,%rbx
jae    127e <gridabove+0x16e>
lea    (%rbx,%rdi,4),%rcx
cmp    %rcx,%rbp
jae    127e <gridabove+0x16e>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%dil
je     1234 <gridabove+0x124>
xorps  %xmm4,%xmm4
cvtsi2ss %ecx,%xmm4
mulss  %xmm15,%xmm4
addss  0x0(%rbp),%xmm4
movss  %xmm4,(%rbx,%rcx,4)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rdi,%rcx
je     11c0 <gridabove+0xb0>
nopl   0x0(%rax)
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  %xmm15,%xmm4
addss  0x0(%rbp),%xmm4
lea    0x1(%rdx),%ecx
xorps  %xmm5,%xmm5
cvtsi2ss %ecx,%xmm5
movss  %xmm4,(%rbx,%rdx,4)
mulss  %xmm15,%xmm5
addss  0x0(%rbp),%xmm5
movss  %xmm5,0x4(%rbx,%rdx,4)
add    $0x2,%rdx
cmp    %rdi,%rdx
jne    1240 <gridabove+0x130>
jmp    11c0 <gridabove+0xb0>
mov    %edi,%ecx
and    $0xfffffff8,%ecx
movss  0x0(%rbp),%xmm4
shufps $0x0,%xmm4,%xmm4
lea    0x0(,%rdi,4),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
movdqa %xmm1,%xmm5
xchg   %ax,%ax
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,(%rbx,%rsi,1)
movups %xmm6,0x10(%rbx,%rsi,1)
paddd  %xmm3,%xmm5
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    12a0 <gridabove+0x190>
cmp    %rdi,%rcx
je     11c0 <gridabove+0xb0>
jmp    120e <gridabove+0xfe>
mov    0x120(%rsp),%r13
test   %rsi,%rsi
movaps %xmm3,0xb0(%rsp)
mov    %rdx,0x60(%rsp)
je     13c8 <gridabove+0x2b8>
cmp    $0x1,%eax
mov    %rsi,0x30(%rsp)
je     1ecd <gridabove+0xdbd>
cmp    $0x2,%eax
je     20f9 <gridabove+0xfe9>
cmp    $0x3,%eax
jne    30c4 <gridabove+0x1fb4>
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
movslq %ebx,%rax
movslq %r12d,%r11
jmp    133d <gridabove+0x22d>
nopl   (%rax)
add    $0x1,%rax
cmp    %r11,%rax
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rcx
mov    (%rcx,%rax,4),%r14d
test   %r14d,%r14d
jle    1330 <gridabove+0x220>
mov    0x8(%r8),%r10
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mov    0x18(%rsp),%rcx
mov    0x8(%rcx),%rbp
mov    0x30(%rsp),%rcx
mov    (%rcx,%rax,8),%rbx
mov    0x8(%r13),%rcx
mov    0x60(%rsp),%rdx
mov    (%rdx,%rax,8),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r10,%rax,4),%xmm1
movss  %xmm1,(%rdi,%rsi,4)
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rsi,4)
mulss  %xmm3,%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1380 <gridabove+0x270>
jmp    1330 <gridabove+0x220>
cmp    $0x1,%eax
je     291b <gridabove+0x180b>
cmp    $0x2,%eax
je     23e9 <gridabove+0x12d9>
cmp    $0x3,%eax
jne    30c4 <gridabove+0x1fb4>
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
movslq %ebx,%r15
movslq %r12d,%r9
lea    0x1(%r15),%rax
mov    %rax,0x58(%rsp)
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
movaps %xmm3,%xmm1
shufps $0x0,%xmm3,%xmm1
xor    %r10d,%r10d
movaps 0x2bfa(%rip),%xmm8
movdqa 0x2c01(%rip),%xmm9
movdqa 0x2c09(%rip),%xmm4
mov    %r9,0x38(%rsp)
jmp    1441 <gridabove+0x331>
xchg   %ax,%ax
add    $0x1,%r15
add    $0x1,%r10
cmp    %r9,%r15
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rax
mov    (%rax,%r15,4),%edi
test   %edi,%edi
jle    1430 <gridabove+0x320>
mov    0x8(%r8),%r11
lea    (%r11,%r15,4),%rbp
mov    0x40(%rsp),%rcx
mov    (%rcx,%r15,8),%rbx
mov    0x8(%r13),%rsi
lea    (%rsi,%r15,4),%rdx
mov    0x60(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
cmp    $0x4,%edi
jae    1480 <gridabove+0x370>
xor    %r11d,%r11d
jmp    1620 <gridabove+0x510>
mov    0x58(%rsp),%rax
lea    (%rax,%r10,1),%r8
lea    (%rbx,%rdi,4),%r9
lea    (%rcx,%rdi,4),%r12
lea    (%r11,%r8,4),%rax
lea    (%rsi,%r8,4),%rsi
cmp    %r12,%rbx
setb   0x18(%rsp)
cmp    %r9,%rcx
setb   %r13b
cmp    %rax,%rbx
setb   %r8b
cmp    %r9,%rbp
setb   0x20(%rsp)
cmp    %rsi,%rbx
setb   %r11b
cmp    %r9,%rdx
setb   %r9b
cmp    %rax,%rcx
setb   %r14b
cmp    %r12,%rbp
setb   %al
cmp    %rsi,%rcx
setb   %sil
cmp    %r12,%rdx
setb   %r12b
test   %r13b,0x18(%rsp)
jne    16cf <gridabove+0x5bf>
and    0x20(%rsp),%r8b
mov    0x120(%rsp),%r13
jne    15be <gridabove+0x4ae>
and    %r9b,%r11b
jne    15be <gridabove+0x4ae>
and    %al,%r14b
jne    15be <gridabove+0x4ae>
mov    $0x0,%r11d
and    %r12b,%sil
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r9
jne    1620 <gridabove+0x510>
mov    %edi,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     15cd <gridabove+0x4bd>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
movss  0x0(%rbp),%xmm6
shufps $0x0,%xmm6,%xmm6
movss  (%rdx),%xmm7
shufps $0x0,%xmm7,%xmm7
xor    %esi,%esi
movaps %xmm8,%xmm5
cs nopw 0x0(%rax,%rax,1)
cvtdq2ps %xmm5,%xmm3
movaps %xmm3,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm6,%xmm2
movups %xmm2,(%rbx,%rsi,4)
mulps  %xmm1,%xmm3
addps  %xmm7,%xmm3
movups %xmm3,(%rcx,%rsi,4)
movaps %xmm5,%xmm2
paddd  %xmm9,%xmm2
cvtdq2ps %xmm2,%xmm2
movaps %xmm2,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm6,%xmm3
movups %xmm3,0x10(%rbx,%rsi,4)
mulps  %xmm1,%xmm2
addps  %xmm7,%xmm2
movups %xmm2,0x10(%rcx,%rsi,4)
add    $0x8,%rsi
paddd  %xmm4,%xmm5
add    $0xfffffffffffffffe,%rax
jne    1570 <gridabove+0x460>
jmp    15d3 <gridabove+0x4c3>
xor    %r11d,%r11d
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    1620 <gridabove+0x510>
xor    %esi,%esi
movaps %xmm8,%xmm5
test   $0x1,%r14b
movaps 0xb0(%rsp),%xmm3
je     160c <gridabove+0x4fc>
movss  0x0(%rbp),%xmm2
shufps $0x0,%xmm2,%xmm2
cvtdq2ps %xmm5,%xmm6
movaps %xmm6,%xmm5
mulps  %xmm0,%xmm5
addps  %xmm2,%xmm5
movups %xmm5,(%rbx,%rsi,4)
movss  (%rdx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm6
addps  %xmm2,%xmm6
movups %xmm6,(%rcx,%rsi,4)
cmp    %rdi,%r11
je     1430 <gridabove+0x320>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r11,%rax
test   $0x1,%dil
je     1659 <gridabove+0x549>
xorps  %xmm2,%xmm2
cvtsi2ss %r11d,%xmm2
movaps %xmm2,%xmm5
mulss  %xmm15,%xmm5
addss  0x0(%rbp),%xmm5
movss  %xmm5,(%rbx,%r11,4)
mulss  %xmm3,%xmm2
addss  (%rdx),%xmm2
movss  %xmm2,(%rcx,%r11,4)
mov    %r11,%rax
or     $0x1,%rax
not    %r11
add    %rdi,%r11
je     1430 <gridabove+0x320>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
movaps %xmm2,%xmm5
mulss  %xmm15,%xmm5
addss  0x0(%rbp),%xmm5
movss  %xmm5,(%rbx,%rax,4)
mulss  %xmm3,%xmm2
addss  (%rdx),%xmm2
lea    0x1(%rax),%esi
xorps  %xmm5,%xmm5
cvtsi2ss %esi,%xmm5
movss  %xmm2,(%rcx,%rax,4)
movaps %xmm5,%xmm2
mulss  %xmm15,%xmm2
addss  0x0(%rbp),%xmm2
movss  %xmm2,0x4(%rbx,%rax,4)
mulss  %xmm3,%xmm5
addss  (%rdx),%xmm5
movss  %xmm5,0x4(%rcx,%rax,4)
add    $0x2,%rax
cmp    %rdi,%rax
jne    1670 <gridabove+0x560>
jmp    1430 <gridabove+0x320>
xor    %r11d,%r11d
mov    0x10(%rsp),%r8
mov    0x120(%rsp),%r13
mov    0x38(%rsp),%r9
jmp    1620 <gridabove+0x510>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x28f2(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%r11d
add    $0xffffffff,%r11d
mov    (%r8),%r15
mov    %r12d,%eax
mov    0x8(%r8),%r12
cvtsi2ss %r11d,%xmm10
movslq %ebx,%rdi
movslq %eax,%r10
mov    0x140(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x60(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x10(%rsp)
movaps %xmm15,%xmm1
shufps $0x0,%xmm15,%xmm1
xor    %r14d,%r14d
movdqa 0x28b3(%rip),%xmm8
movdqa 0x28ba(%rip),%xmm13
movdqa 0x28c2(%rip),%xmm4
movss  0x28e1(%rip),%xmm9
pcmpeqd %xmm11,%xmm11
movdqa 0x28bb(%rip),%xmm12
mov    %r11,0x20(%rsp)
mov    %r10,0x18(%rsp)
jmp    17b1 <gridabove+0x6a1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x1,%r14
cmp    %r10,%rdi
je     30c4 <gridabove+0x1fb4>
mov    0x10(%rsp),%rax
lea    (%rax,%r14,1),%r9
mov    0x80(%rsp),%rax
movslq (%rax,%rdi,4),%r8
lea    (%r8,%r11,1),%ebp
mov    0x140(%rsp),%eax
cmp    %eax,%ebp
cmovge %eax,%ebp
lea    0x1(%rbp),%r13d
cmp    %ebp,%r8d
jle    17f0 <gridabove+0x6e0>
mov    0x40(%rsp),%rdx
jmp    1840 <gridabove+0x730>
cs nopw 0x0(%rax,%rax,1)
xor    %r10d,%r10d
movaps %xmm9,%xmm2
test   %r8d,%r8d
sete   %al
je     1802 <gridabove+0x6f2>
xorps  %xmm2,%xmm2
movss  (%r12,%rdi,4),%xmm0
movss  (%r15,%rdi,4),%xmm5
subss  %xmm5,%xmm0
divss  %xmm10,%xmm0
mov    0x40(%rsp),%rdx
mov    (%rdx,%rdi,8),%rcx
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
movss  %xmm2,(%rcx,%r8,4)
lea    0x1(%r8),%rsi
cmp    %esi,%r13d
jne    1930 <gridabove+0x820>
mov    0x18(%rsp),%r10
mov    0x140(%rsp),%eax
cmp    %eax,%r13d
jge    17a0 <gridabove+0x690>
mov    (%rdx,%rdi,8),%r8
movslq %r13d,%rdx
mov    0x60(%rsp),%eax
mov    %eax,%ecx
sub    %ebp,%ecx
xor    %eax,%eax
cmp    $0x7,%ecx
jb     1890 <gridabove+0x780>
lea    (%r12,%r9,4),%r9
lea    (%r8,%rdx,4),%rbx
cmp    %r9,%rbx
jae    19a3 <gridabove+0x893>
lea    (%r12,%rdi,4),%r9
lea    (%rdx,%rcx,1),%rbx
lea    (%r8,%rbx,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%r9
jae    19a3 <gridabove+0x893>
mov    %rdx,%r9
mov    %eax,%edx
not    %edx
mov    0x140(%rsp),%ecx
add    %ecx,%edx
sub    %ebp,%edx
lea    (%rax,%rbp,1),%ecx
test   $0x1,%dl
je     18c9 <gridabove+0x7b9>
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,0x60(%rsp)
je     17a0 <gridabove+0x690>
not    %ebp
mov    0x140(%rsp),%ecx
add    %ecx,%ebp
lea    (%r8,%r9,4),%rcx
add    $0x4,%rcx
cs nopw 0x0(%rax,%rax,1)
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    18f0 <gridabove+0x7e0>
jmp    17a0 <gridabove+0x690>
mov    %al,%r10b
mov    %r8d,%r11d
not    %r11d
add    %ebp,%r11d
cmp    $0x7,%r11d
jb     1976 <gridabove+0x866>
lea    (%r15,%r9,4),%rax
lea    (%rcx,%r8,4),%rdx
add    $0x4,%rdx
cmp    %rax,%rdx
jae    1a90 <gridabove+0x980>
lea    (%r15,%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    1a90 <gridabove+0x980>
mov    %r10d,%eax
mov    0x18(%rsp),%r10
mov    %ebp,%edx
sub    %esi,%edx
add    $0x1,%edx
test   $0x1,%dl
mov    0x20(%rsp),%r11
jne    1a1f <gridabove+0x90f>
mov    %rsi,%rbx
cmp    %esi,%ebp
je     17df <gridabove+0x6cf>
jmp    1a47 <gridabove+0x937>
add    $0x1,%rcx
mov    %rcx,%rax
movabs $0x1fffffff8,%rsi
and    %rsi,%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
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    19e0 <gridabove+0x8d0>
cmp    %rax,%rcx
je     17a0 <gridabove+0x690>
jmp    1893 <gridabove+0x783>
add    $0x1,%eax
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  %xmm0,%xmm2
addss  (%r15,%rdi,4),%xmm2
movss  %xmm2,(%rcx,%rsi,4)
mov    %rsi,%rbx
add    $0x1,%rbx
cmp    %esi,%ebp
je     17df <gridabove+0x6cf>
mov    %r13d,%edx
add    $0x2,%eax
nopl   (%rax)
lea    -0x1(%rax),%esi
xorps  %xmm2,%xmm2
cvtsi2ss %esi,%xmm2
mulss  %xmm0,%xmm2
addss  (%r15,%rdi,4),%xmm2
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
movss  %xmm2,(%rcx,%rbx,4)
mulss  %xmm0,%xmm3
addss  (%r15,%rdi,4),%xmm3
movss  %xmm3,0x4(%rcx,%rbx,4)
add    $0x2,%rbx
add    $0x2,%eax
cmp    %ebx,%edx
jne    1a50 <gridabove+0x940>
jmp    17df <gridabove+0x6cf>
mov    %r9,0x58(%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  (%r15,%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    1ae0 <gridabove+0x9d0>
cmp    %r9,%r11
mov    0x40(%rsp),%rdx
mov    0x18(%rsp),%r10
mov    0x58(%rsp),%r9
jne    197e <gridabove+0x86e>
mov    0x20(%rsp),%r11
jmp    1840 <gridabove+0x730>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x249f(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%r11d
cvtsi2ss %r11d,%xmm4
mov    $0x1,%ecx
sub    %eax,%ecx
mov    %ecx,0x20(%rsp)
movslq %ebx,%r10
mov    (%r8),%rax
mov    0x140(%rsp),%ecx
add    $0xfffffffe,%ecx
mov    %ecx,0x30(%rsp)
lea    0x1(%r10),%rcx
mov    %rcx,0x50(%rsp)
movaps %xmm15,%xmm8
shufps $0x0,%xmm15,%xmm8
xor    %r15d,%r15d
movdqa 0x2471(%rip),%xmm6
movdqa 0x2479(%rip),%xmm7
mov    0x442a(%rip),%rbx
mov    %r11,0x70(%rsp)
movss  %xmm4,0x18(%rsp)
movaps %xmm8,0xb0(%rsp)
jmp    1bf1 <gridabove+0xae1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
add    $0x1,%r15
cmp    %r12d,%r10d
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rcx
movslq (%rcx,%r10,4),%rbp
lea    (%r11,%rbp,1),%r13d
mov    0x140(%rsp),%ecx
cmp    %ecx,%r13d
cmovge %ecx,%r13d
cmp    %r13d,%ebp
jle    1c20 <gridabove+0xb10>
lea    0x1(%r13),%edi
jmp    1d1c <gridabove+0xc0c>
nopl   (%rax)
mov    %r15,0x38(%rsp)
mov    0x10(%rsp),%r12
mov    0x8(%r12),%rcx
movss  (%rcx,%r10,4),%xmm0
subss  (%rax,%r10,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,0x60(%rsp)
xor    %r15d,%r15d
test   %ebp,%ebp
sete   %r15b
mov    %r13,0x58(%rsp)
lea    0x1(%r13),%r14d
mov    %r14d,0x8(%rsp)
sub    %ebp,%r14d
mov    0x40(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
divss  %xmm4,%xmm0
mulss  (%rbx),%xmm0
mov    %r10,%rbx
call   1030 <cos@plt>
movsd  0x23c0(%rip),%xmm1
mov    %rbx,%r10
mov    0x434e(%rip),%rbx
movss  0x18(%rsp),%xmm4
add    $0xffffffff,%eax
imul   0x20(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  0x60(%rsp),%xmm0
mov    (%r12),%rax
addss  (%rax,%r10,4),%xmm0
mov    0x0(%r13,%r10,8),%rcx
movss  %xmm0,(%rcx,%rbp,4)
add    $0x1,%r15d
add    $0x1,%rbp
add    $0xffffffff,%r14d
jne    1c70 <gridabove+0xb60>
movaps 0xc0(%rsp),%xmm15
mov    0x130(%rsp),%r12d
mov    0x70(%rsp),%r11
movaps 0xb0(%rsp),%xmm8
mov    0x38(%rsp),%r15
movdqa 0x2315(%rip),%xmm6
movdqa 0x231d(%rip),%xmm7
mov    0x58(%rsp),%r13
mov    0x8(%rsp),%edi
mov    0x140(%rsp),%ecx
cmp    %ecx,%edi
jge    1be0 <gridabove+0xad0>
mov    0x10(%rsp),%rcx
mov    0x8(%rcx),%rsi
lea    (%rsi,%r10,4),%rcx
mov    0x40(%rsp),%rdx
mov    (%rdx,%r10,8),%r8
movslq %edi,%r14
mov    0x30(%rsp),%edx
mov    %edx,%ebp
sub    %r13d,%ebp
xor    %edx,%edx
cmp    $0x7,%ebp
jae    1d60 <gridabove+0xc50>
mov    %r14,%r9
jmp    1e30 <gridabove+0xd20>
nopl   0x0(%rax)
mov    %r13,0x58(%rsp)
mov    %r10,%r13
mov    0x50(%rsp),%rdi
lea    (%rdi,%r15,1),%r9
lea    (%r8,%r14,4),%r10
lea    (%rsi,%r9,4),%rsi
cmp    %rsi,%r10
jae    1da6 <gridabove+0xc96>
lea    (%r14,%rbp,1),%rsi
lea    (%r8,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rcx
jae    1da6 <gridabove+0xc96>
mov    %r14,%r9
mov    0x424f(%rip),%rbx
mov    %r13,%r10
mov    0x58(%rsp),%r13
jmp    1e30 <gridabove+0xd20>
add    $0x1,%rbp
mov    %rbp,%rdx
movabs $0x1fffffff8,%rsi
and    %rsi,%rdx
lea    (%rdx,%r14,1),%r9
movss  (%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%r8,%r14,4),%rdi
add    $0x10,%rdi
xor    %esi,%esi
movdqa 0x2238(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
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    1de0 <gridabove+0xcd0>
cmp    %rdx,%rbp
mov    0x41cc(%rip),%rbx
mov    %r13,%r10
mov    0x58(%rsp),%r13
je     1be0 <gridabove+0xad0>
nopw   0x0(%rax,%rax,1)
mov    %edx,%edi
not    %edi
mov    0x140(%rsp),%esi
add    %esi,%edi
sub    %r13d,%edi
lea    (%rdx,%r13,1),%esi
test   $0x1,%dil
je     1e67 <gridabove+0xd57>
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,0x30(%rsp)
je     1be0 <gridabove+0xad0>
not    %r13d
mov    0x140(%rsp),%esi
add    %esi,%r13d
lea    (%r8,%r9,4),%rsi
add    $0x4,%rsi
cs nopw 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    %r13d,%edx
jne    1e90 <gridabove+0xd80>
jmp    1be0 <gridabove+0xad0>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x210e(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%ebp
add    $0xffffffff,%ebp
cvtsi2ss %ebp,%xmm8
mov    (%r8),%r10
mov    0x8(%r8),%r14
mov    0x18(%rsp),%r9
mov    (%r9),%r15
mov    %r12d,%ecx
mov    0x8(%r9),%r12
mov    %r13,%rax
mov    0x0(%r13),%r13
mov    0x8(%rax),%r11
movslq %ebx,%rax
movslq %ecx,%rbx
mov    %rbp,0x20(%rsp)
mov    %rbx,0x18(%rsp)
jmp    1f4d <gridabove+0xe3d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbx,%rax
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
lea    (%rcx,%rbp,1),%r8d
mov    0x140(%rsp),%edx
cmp    %edx,%r8d
cmovge %edx,%r8d
cmp    %r8d,%ecx
jle    1f80 <gridabove+0xe70>
lea    0x1(%r8),%esi
mov    0x40(%rsp),%rcx
jmp    2063 <gridabove+0xf53>
xchg   %ax,%ax
movss  (%r14,%rax,4),%xmm1
movss  (%r10,%rax,4),%xmm4
subss  %xmm4,%xmm1
divss  %xmm8,%xmm1
movss  (%r12,%rax,4),%xmm0
subss  (%r15,%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,0x10(%rsp)
mov    %rcx,%rdi
shl    $0x2,%rdi
mov    0x40(%rsp),%rdx
mov    (%rdx,%rax,8),%rbp
add    %rdi,%rbp
mov    0x30(%rsp),%rdx
mov    (%rdx,%rax,8),%rbx
add    %rdi,%rbx
mov    0x60(%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  (%r15,%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     2050 <gridabove+0xf40>
movss  (%r10,%rax,4),%xmm4
add    $0x1,%rcx
jmp    2000 <gridabove+0xef0>
xchg   %ax,%ax
mov    0x40(%rsp),%rcx
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%esi
mov    0x140(%rsp),%edx
cmp    %edx,%esi
jge    1f40 <gridabove+0xe30>
movslq %esi,%rsi
not    %r8d
mov    0x140(%rsp),%edx
add    %edx,%r8d
shl    $0x2,%rsi
mov    (%rcx,%rax,8),%rdx
add    %rsi,%rdx
mov    0x30(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
add    %rsi,%rcx
mov    0x60(%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  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
addss  (%r12,%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    20b0 <gridabove+0xfa0>
jmp    1f40 <gridabove+0xe30>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x1ee2(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%edx
mov    %rdx,%rcx
mov    %rdx,0x50(%rsp)
cvtsi2ss %edx,%xmm4
mov    $0x1,%r15d
sub    %eax,%r15d
movslq %ebx,%r14
mov    (%r8),%rax
mov    0x18(%rsp),%rcx
mov    (%rcx),%rcx
mov    0x0(%r13),%rdx
mov    %r15d,0x68(%rsp)
movss  %xmm2,0x90(%rsp)
movss  %xmm4,0x8(%rsp)
jmp    2188 <gridabove+0x1078>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r9d,%r14d
mov    0x68(%rsp),%r15d
mov    %r12,%r13
mov    %r9d,%r12d
je     30c4 <gridabove+0x1fb4>
mov    %r13,%rbp
mov    0x80(%rsp),%rsi
movslq (%rsi,%r14,4),%r13
mov    0x50(%rsp),%rsi
lea    (%rsi,%r13,1),%ebx
mov    0x140(%rsp),%esi
cmp    %esi,%ebx
cmovge %esi,%ebx
cmp    %ebx,%r13d
mov    %rbx,0x70(%rsp)
jle    21d0 <gridabove+0x10c0>
mov    %r12d,%r9d
lea    0x1(%rbx),%edi
mov    %rbp,%r12
jmp    2336 <gridabove+0x1226>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%r8),%rsi
movss  (%rsi,%r14,4),%xmm0
subss  (%rax,%r14,4),%xmm0
mov    0x18(%rsp),%rax
mov    0x8(%rax),%rax
movss  (%rax,%r14,4),%xmm1
subss  (%rcx,%r14,4),%xmm1
divss  %xmm4,%xmm0
movss  %xmm0,0x20(%rsp)
divss  %xmm4,%xmm1
movss  %xmm1,0x58(%rsp)
mov    0x8(%rbp),%rax
movss  (%rax,%r14,4),%xmm0
subss  (%rdx,%r14,4),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,0x38(%rsp)
xor    %r12d,%r12d
test   %r13d,%r13d
sete   %r12b
lea    0x1(%rbx),%ebp
mov    %ebp,0xa0(%rsp)
sub    %r13d,%ebp
mov    0x30(%rsp),%rbx
nop
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
divss  %xmm4,%xmm0
mov    0x3d95(%rip),%rax
mulss  (%rax),%xmm0
call   1030 <cos@plt>
movsd  0x1dec(%rip),%xmm1
movss  0x8(%rsp),%xmm4
add    $0xffffffff,%eax
imul   %r15d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rsp),%rax
mov    (%rax),%rax
movss  0x20(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%rax,%r14,4),%xmm1
mov    0x40(%rsp),%rcx
mov    (%rcx,%r14,8),%rcx
movss  %xmm1,(%rcx,%r13,4)
mov    0x18(%rsp),%rcx
mov    (%rcx),%rcx
movss  0x58(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%r14,4),%xmm1
mov    (%rbx,%r14,8),%rdx
movss  %xmm1,(%rdx,%r13,4)
mov    0x120(%rsp),%rdx
mov    (%rdx),%rdx
mulss  0x38(%rsp),%xmm0
addss  (%rdx,%r14,4),%xmm0
mov    0x60(%rsp),%rsi
mov    (%rsi,%r14,8),%rsi
movss  %xmm0,(%rsi,%r13,4)
add    $0x1,%r12d
add    $0x1,%r13
add    $0xffffffff,%ebp
jne    2240 <gridabove+0x1130>
movaps 0xc0(%rsp),%xmm15
movaps 0xb0(%rsp),%xmm3
mov    0x10(%rsp),%r8
mov    0x130(%rsp),%r9d
mov    0x120(%rsp),%r12
movss  0x90(%rsp),%xmm2
mov    0xa0(%rsp),%edi
mov    0x140(%rsp),%esi
cmp    %esi,%edi
mov    0x70(%rsp),%r13
jge    2170 <gridabove+0x1060>
mov    0x8(%r8),%r11
mov    0x18(%rsp),%rsi
mov    0x8(%rsi),%r15
mov    0x8(%r12),%r10
movslq %edi,%rbx
not    %r13d
mov    0x140(%rsp),%esi
add    %esi,%r13d
shl    $0x2,%rbx
mov    0x40(%rsp),%rsi
mov    (%rsi,%r14,8),%rsi
add    %rbx,%rsi
mov    0x30(%rsp),%rdi
mov    (%rdi,%r14,8),%rdi
add    %rbx,%rdi
mov    0x60(%rsp),%rbp
add    0x0(%rbp,%r14,8),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r11,%r14,4),%xmm1
movss  %xmm1,(%rsi,%rbp,4)
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
addss  (%r15,%r14,4),%xmm1
movss  %xmm1,(%rdi,%rbp,4)
mulss  %xmm3,%xmm0
addss  (%r10,%r14,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    %ebp,%r13d
jne    23a0 <gridabove+0x1290>
jmp    2170 <gridabove+0x1060>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x1bf2(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%eax
lea    -0x1(%rax),%edx
mov    %rdx,%rcx
mov    %rdx,0x70(%rsp)
cvtsi2ss %edx,%xmm10
movabs $0x1fffffff8,%rdx
mov    $0x1,%ecx
sub    %eax,%ecx
mov    %ecx,0x38(%rsp)
movslq %ebx,%rdi
mov    (%r8),%r11
mov    0x0(%r13),%r10
mov    0x140(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x68(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xe0(%rsp)
movaps %xmm15,%xmm8
shufps $0x0,%xmm15,%xmm8
movaps %xmm3,%xmm9
shufps $0x0,%xmm3,%xmm9
xor    %eax,%eax
mov    %rax,0x30(%rsp)
add    $0x4,%rdx
mov    %rdx,0xd8(%rsp)
movdqa 0x1b93(%rip),%xmm7
mov    0x3b54(%rip),%rcx
movss  %xmm10,0x58(%rsp)
movaps %xmm8,0xa0(%rsp)
movaps %xmm9,0x90(%rsp)
jmp    24dd <gridabove+0x13cd>
nop
add    $0x1,%rdi
addq   $0x1,0x30(%rsp)
mov    0x130(%rsp),%eax
cmp    %eax,%edi
mov    0x3b1e(%rip),%rcx
mov    0x10(%rsp),%r8
mov    0x120(%rsp),%r13
je     30c4 <gridabove+0x1fb4>
mov    0x80(%rsp),%rax
movslq (%rax,%rdi,4),%rbp
mov    0x70(%rsp),%rax
lea    (%rax,%rbp,1),%esi
mov    0x140(%rsp),%eax
cmp    %eax,%esi
cmovge %eax,%esi
cmp    %esi,%ebp
mov    %rsi,0x8(%rsp)
jle    2510 <gridabove+0x1400>
lea    0x1(%rsi),%ebp
jmp    2639 <gridabove+0x1529>
xchg   %ax,%ax
mov    0x8(%r8),%rdx
movss  (%rdx,%rdi,4),%xmm0
subss  (%r11,%rdi,4),%xmm0
divss  %xmm10,%xmm0
movss  %xmm0,0x18(%rsp)
mov    0x8(%r13),%rax
movss  (%rax,%rdi,4),%xmm0
subss  (%r10,%rdi,4),%xmm0
divss  %xmm10,%xmm0
movss  %xmm0,0x20(%rsp)
xor    %ebx,%ebx
test   %ebp,%ebp
sete   %bl
lea    0x1(%rsi),%r15d
mov    %r15d,0x50(%rsp)
sub    %ebp,%r15d
mov    0x40(%rsp),%r12
mov    0x60(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
divss  %xmm10,%xmm0
mulss  (%rcx),%xmm0
mov    %rdi,%r13
call   1030 <cos@plt>
movsd  0x1ac0(%rip),%xmm1
mov    %r13,%rdi
movss  0x58(%rsp),%xmm10
add    $0xffffffff,%eax
imul   0x38(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rsp),%rax
mov    (%rax),%r11
movss  0x18(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  (%r11,%r13,4),%xmm1
mov    (%r12,%r13,8),%rcx
movss  %xmm1,(%rcx,%rbp,4)
mov    0x3a0f(%rip),%rcx
mov    0x120(%rsp),%rax
mov    (%rax),%r10
mulss  0x20(%rsp),%xmm0
addss  (%r10,%r13,4),%xmm0
mov    (%r14,%r13,8),%rdx
movss  %xmm0,(%rdx,%rbp,4)
add    $0x1,%ebx
add    $0x1,%rbp
add    $0xffffffff,%r15d
jne    2570 <gridabove+0x1460>
movaps 0xc0(%rsp),%xmm15
movaps 0xb0(%rsp),%xmm3
movaps 0xa0(%rsp),%xmm8
movaps 0x90(%rsp),%xmm9
movdqa 0x19eb(%rip),%xmm7
mov    0x50(%rsp),%ebp
mov    0x140(%rsp),%eax
cmp    %eax,%ebp
mov    0x8(%rsp),%rcx
jge    24b0 <gridabove+0x13a0>
mov    0x10(%rsp),%rax
mov    0x8(%rax),%rbx
lea    (%rbx,%rdi,4),%r14
mov    0x40(%rsp),%rax
mov    (%rax,%rdi,8),%r8
mov    0x120(%rsp),%rax
mov    0x8(%rax),%rdx
lea    (%rdx,%rdi,4),%r9
mov    0x60(%rsp),%rax
mov    (%rax,%rdi,8),%rsi
movslq %ebp,%rbp
mov    0x68(%rsp),%eax
mov    %eax,%r12d
sub    %ecx,%r12d
xor    %r15d,%r15d
cmp    $0x3,%r12d
mov    %rbp,0x18(%rsp)
jae    26a1 <gridabove+0x1591>
mov    0x8(%rsp),%rcx
jmp    2803 <gridabove+0x16f3>
mov    %rdi,0x88(%rsp)
mov    0xe0(%rsp),%rcx
mov    %rsi,%rax
mov    0x30(%rsp),%rsi
lea    (%rcx,%rsi,1),%rdi
lea    (%r8,%rbp,4),%r13
lea    (%r12,%rbp,1),%rsi
mov    %r8,0x20(%rsp)
lea    0x4(%r8,%rsi,4),%rcx
lea    (%rax,%rbp,4),%rbp
mov    %rax,0x50(%rsp)
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%rbx,%rdi,4),%rbx
lea    (%rdx,%rdi,4),%rdx
cmp    %rsi,%r13
setb   0x78(%rsp)
cmp    %rcx,%rbp
setb   0x2c(%rsp)
cmp    %rbx,%r13
setb   %al
cmp    %rcx,%r14
setb   0x4c(%rsp)
cmp    %rdx,%r13
setb   %r8b
cmp    %rcx,%r9
setb   0x7(%rsp)
cmp    %rbx,%rbp
setb   %cl
cmp    %rsi,%r14
setb   0x6(%rsp)
cmp    %rdx,%rbp
setb   0x5(%rsp)
cmp    %rsi,%r9
setb   %dl
mov    0x2c(%rsp),%bl
test   %bl,0x78(%rsp)
jne    28ff <gridabove+0x17ef>
and    0x4c(%rsp),%al
mov    0x50(%rsp),%rsi
jne    27f1 <gridabove+0x16e1>
and    0x7(%rsp),%r8b
jne    27f1 <gridabove+0x16e1>
and    0x6(%rsp),%cl
jne    27f1 <gridabove+0x16e1>
mov    %edx,%ebx
and    %dl,0x5(%rsp)
mov    0x88(%rsp),%rdi
jne    27f9 <gridabove+0x16e9>
add    $0x1,%r12
mov    %r12,%r15
and    0xd8(%rsp),%r15
add    %r15,0x18(%rsp)
movss  (%r14),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  (%r9),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %ebx,%ebx
movaps 0x186a(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
cvtdq2ps %xmm2,%xmm5
movaps %xmm5,%xmm4
mulps  %xmm8,%xmm4
addps  %xmm0,%xmm4
movups %xmm4,0x0(%r13,%rbx,4)
mulps  %xmm9,%xmm5
addps  %xmm1,%xmm5
movups %xmm5,0x0(%rbp,%rbx,4)
add    $0x4,%rbx
paddd  %xmm7,%xmm2
cmp    %rbx,%r15
jne    27b0 <gridabove+0x16a0>
cmp    %r15,%r12
mov    0x8(%rsp),%rcx
mov    0x20(%rsp),%r8
je     24b0 <gridabove+0x13a0>
jmp    2803 <gridabove+0x16f3>
mov    0x88(%rsp),%rdi
mov    0x8(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    %r15d,%edx
not    %edx
mov    0x140(%rsp),%eax
add    %eax,%edx
sub    %ecx,%edx
lea    (%r15,%rcx,1),%eax
test   $0x1,%dl
je     2857 <gridabove+0x1747>
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r14),%xmm1
mov    0x18(%rsp),%rcx
movss  %xmm1,(%r8,%rcx,4)
mulss  %xmm3,%xmm0
addss  (%r9),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%r15d
add    $0x1,%rcx
mov    %rcx,0x18(%rsp)
cmp    %eax,0x68(%rsp)
mov    0x8(%rsp),%r13
je     24b0 <gridabove+0x13a0>
not    %r13d
mov    0x140(%rsp),%eax
add    %eax,%r13d
mov    0x18(%rsp),%rax
lea    (%r8,%rax,4),%rcx
add    $0x4,%rcx
lea    (%rsi,%rax,4),%rbp
add    $0x4,%rbp
mov    %r15d,%ebx
xor    %edx,%edx
xor    %esi,%esi
nop
lea    (%rbx,%rdx,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  (%r14),%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  (%r14),%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    %r13d,%eax
jne    2890 <gridabove+0x1780>
jmp    24b0 <gridabove+0x13a0>
mov    0x88(%rsp),%rdi
mov    0x8(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    0x50(%rsp),%rsi
jmp    2803 <gridabove+0x16f3>
divss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %cl
cmp    %r12d,%ebx
jge    30c4 <gridabove+0x1fb4>
cvtss2sd %xmm0,%xmm0
mov    %cl,%al
lea    0x16c0(%rip),%rcx
addsd  (%rcx,%rax,8),%xmm0
cvttsd2si %xmm0,%edx
add    $0xffffffff,%edx
mov    (%r8),%r15
mov    %r13,%rcx
mov    0x8(%r8),%r13
cvtsi2ss %edx,%xmm10
mov    (%rcx),%r14
mov    %r12d,%eax
mov    0x8(%rcx),%r12
movslq %ebx,%rbx
mov    %rdx,%r9
cltq
mov    %rax,0x18(%rsp)
mov    0x140(%rsp),%eax
add    $0xfffffffe,%eax
mov    %eax,0x58(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x20(%rsp)
movaps %xmm15,%xmm13
shufps $0x0,%xmm15,%xmm13
movaps %xmm3,%xmm14
shufps $0x0,%xmm3,%xmm14
xor    %r11d,%r11d
movdqa 0x1669(%rip),%xmm8
movdqa 0x1670(%rip),%xmm12
movss  0x169f(%rip),%xmm9
pcmpeqd %xmm11,%xmm11
mov    %r14,0x8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %r15,0x88(%rsp)
jmp    29f3 <gridabove+0x18e3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
add    $0x1,%r11
cmp    0x18(%rsp),%rbx
je     30c4 <gridabove+0x1fb4>
mov    0x20(%rsp),%rax
lea    (%rax,%r11,1),%rbp
mov    0x80(%rsp),%rax
movslq (%rax,%rbx,4),%rcx
lea    (%rcx,%r9,1),%r8d
mov    0x140(%rsp),%eax
cmp    %eax,%r8d
cmovge %eax,%r8d
cmp    %r8d,%ecx
jle    2a30 <gridabove+0x1920>
lea    0x1(%r8),%esi
jmp    2dc0 <gridabove+0x1cb0>
nopl   0x0(%rax,%rax,1)
mov    %r11,0x10(%rsp)
lea    0x1(%r8),%esi
movaps %xmm9,%xmm0
test   %ecx,%ecx
sete   %dl
je     2a47 <gridabove+0x1937>
xorps  %xmm0,%xmm0
movss  0x0(%r13,%rbx,4),%xmm7
movss  (%r15,%rbx,4),%xmm1
subss  %xmm1,%xmm7
divss  %xmm10,%xmm7
movss  (%r12,%rbx,4),%xmm3
subss  (%r14,%rbx,4),%xmm3
divss  %xmm10,%xmm3
mov    0x40(%rsp),%rax
mov    (%rax,%rbx,8),%r9
mov    0x60(%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),%rdi
cmp    %edi,%esi
jne    2ac0 <gridabove+0x19b0>
movaps 0xb0(%rsp),%xmm3
mov    0x10(%rsp),%r11
mov    0x38(%rsp),%r9
jmp    2dc0 <gridabove+0x1cb0>
xor    %eax,%eax
mov    %dl,%al
mov    %eax,%edx
mov    %ecx,%eax
not    %eax
add    %r8d,%eax
cmp    $0x3,%eax
jae    2ad9 <gridabove+0x19c9>
mov    %edx,%ecx
jmp    2ce0 <gridabove+0x1bd0>
mov    %edx,0x4c(%rsp)
mov    %rdi,0x30(%rsp)
mov    %esi,0x2c(%rsp)
lea    (%r15,%rbx,4),%rdx
mov    %rdx,0x50(%rsp)
lea    (%r15,%rbp,4),%rdi
lea    (%r14,%rbx,4),%rdx
mov    %rdx,0x70(%rsp)
mov    %rbp,0x68(%rsp)
lea    (%r14,%rbp,4),%rdx
mov    %rdx,0xa0(%rsp)
lea    (%r9,%rcx,4),%r14
add    $0x4,%r14
mov    %ecx,%ebp
not    %ebp
add    %r8d,%ebp
add    %rcx,%rbp
lea    (%r9,%rbp,4),%rsi
add    $0x8,%rsi
lea    (%r10,%rcx,4),%rdx
add    $0x4,%rdx
lea    (%r10,%rbp,4),%rbp
add    $0x8,%rbp
cmp    %rbp,%r14
setb   0x90(%rsp)
cmp    %rsi,%rdx
setb   0x78(%rsp)
cmp    %rdi,%r14
mov    %rdi,%rcx
setb   %r11b
cmp    %rsi,0x50(%rsp)
setb   0x7(%rsp)
mov    0xa0(%rsp),%rdi
cmp    %rdi,%r14
setb   0x6(%rsp)
cmp    %rsi,0x70(%rsp)
setb   0x5(%rsp)
cmp    %rcx,%rdx
setb   %sil
cmp    %rbp,0x50(%rsp)
setb   0x50(%rsp)
cmp    %rdi,%rdx
setb   %dil
cmp    %rbp,0x70(%rsp)
setb   %bpl
mov    0x78(%rsp),%cl
test   %cl,0x90(%rsp)
jne    2cc7 <gridabove+0x1bb7>
mov    %bpl,0x70(%rsp)
and    0x7(%rsp),%r11b
mov    0x68(%rsp),%rbp
jne    2cba <gridabove+0x1baa>
mov    0x5(%rsp),%cl
and    %cl,0x6(%rsp)
jne    2cba <gridabove+0x1baa>
mov    %edi,%ecx
and    0x50(%rsp),%sil
mov    0x30(%rsp),%rdi
jne    2ca9 <gridabove+0x1b99>
and    0x70(%rsp),%cl
jne    2ca9 <gridabove+0x1b99>
add    $0x1,%rax
movabs $0x1fffffff8,%rcx
mov    %rdi,%rsi
lea    0x4(%rcx),%rdi
and    %rax,%rdi
add    %rdi,%rsi
mov    %rsi,0x30(%rsp)
mov    0x4c(%rsp),%esi
movd   %esi,%xmm0
mov    %edi,%ecx
or     %esi,%ecx
pshufd $0x0,%xmm0,%xmm2
paddd  %xmm8,%xmm2
movaps %xmm7,%xmm15
shufps $0x0,%xmm7,%xmm15
movaps %xmm3,%xmm6
shufps $0x0,%xmm3,%xmm6
movss  (%r15,%rbx,4),%xmm4
shufps $0x0,%xmm4,%xmm4
mov    0x8(%rsp),%rsi
movss  (%rsi,%rbx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %ebp,%ebp
nopl   0x0(%rax)
movdqa %xmm2,%xmm5
psubd  %xmm11,%xmm5
cvtdq2ps %xmm5,%xmm5
movaps %xmm15,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm4,%xmm0
movups %xmm0,(%r14,%rbp,4)
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
movups %xmm5,(%rdx,%rbp,4)
add    $0x4,%rbp
paddd  %xmm12,%xmm2
cmp    %rbp,%rdi
jne    2c50 <gridabove+0x1b40>
cmp    %rdi,%rax
movaps 0xc0(%rsp),%xmm15
mov    0x8(%rsp),%r14
mov    0x68(%rsp),%rbp
mov    0x2c(%rsp),%esi
mov    0x30(%rsp),%rdi
jne    2ce0 <gridabove+0x1bd0>
jmp    2aa9 <gridabove+0x1999>
mov    0x4c(%rsp),%eax
mov    %eax,%ecx
mov    0x8(%rsp),%r14
mov    0x2c(%rsp),%esi
jmp    2ce0 <gridabove+0x1bd0>
mov    0x4c(%rsp),%eax
mov    %eax,%ecx
mov    0x8(%rsp),%r14
jmp    2cd7 <gridabove+0x1bc7>
mov    0x4c(%rsp),%eax
mov    %eax,%ecx
mov    0x8(%rsp),%r14
mov    0x68(%rsp),%rbp
mov    0x2c(%rsp),%esi
mov    0x30(%rsp),%rdi
mov    %r8d,%edx
sub    %edi,%edx
add    $0x1,%edx
test   $0x1,%dl
jne    2cfb <gridabove+0x1beb>
mov    %rdi,%rdx
cmp    %edi,%r8d
je     2aa9 <gridabove+0x1999>
jmp    2d38 <gridabove+0x1c28>
add    $0x1,%ecx
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%rbx,4),%xmm1
movss  %xmm1,(%r9,%rdi,4)
mulss  %xmm3,%xmm0
addss  (%r14,%rbx,4),%xmm0
movss  %xmm0,(%r10,%rdi,4)
mov    %rdi,%rdx
add    $0x1,%rdx
cmp    %edi,%r8d
je     2aa9 <gridabove+0x1999>
mov    %esi,%eax
mov    %esi,%edi
add    $0x2,%ecx
nop
lea    -0x1(%rcx),%esi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%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  (%r15,%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    2d40 <gridabove+0x1c30>
movaps 0xb0(%rsp),%xmm3
mov    0x10(%rsp),%r11
mov    0x38(%rsp),%r9
mov    %eax,%esi
nopl   0x0(%rax,%rax,1)
mov    0x140(%rsp),%eax
cmp    %eax,%esi
jge    29e0 <gridabove+0x18d0>
mov    %rbp,%rcx
mov    0x40(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
mov    0x60(%rsp),%rax
mov    (%rax,%rbx,8),%rbp
movslq %esi,%r10
mov    0x58(%rsp),%eax
mov    %eax,%r14d
sub    %r8d,%r14d
xor    %edx,%edx
cmp    $0x3,%r14d
jae    2e03 <gridabove+0x1cf3>
mov    0x8(%rsp),%r14
jmp    2fc5 <gridabove+0x1eb5>
mov    %r11,0x10(%rsp)
mov    %r10,%rsi
lea    0x0(,%rbx,4),%rax
add    %r13,%rax
mov    %rax,0x68(%rsp)
lea    0x0(%r13,%rcx,4),%r9
mov    %rdi,%r11
lea    (%r12,%rbx,4),%rdi
mov    %rdi,0x50(%rsp)
lea    (%r12,%rcx,4),%r10
mov    %r11,%rcx
lea    (%r11,%rsi,4),%rdi
lea    (%r14,%rsi,1),%r11
mov    %rcx,0xa0(%rsp)
lea    0x4(%rcx,%r11,4),%r15
mov    %rsi,0x78(%rsp)
lea    0x0(,%rsi,4),%rcx
add    %rbp,%rcx
mov    %rbp,0x90(%rsp)
lea    0x4(%rbp,%r11,4),%rbp
cmp    %rbp,%rdi
setb   0x30(%rsp)
cmp    %r15,%rcx
setb   0x70(%rsp)
cmp    %r9,%rdi
setb   %sil
cmp    %r15,%rax
setb   0x2c(%rsp)
cmp    %r10,%rdi
setb   %r11b
mov    0x50(%rsp),%rax
cmp    %r15,%rax
setb   %r15b
cmp    %r9,%rcx
setb   %r9b
cmp    %rbp,0x68(%rsp)
setb   0x68(%rsp)
cmp    %r10,%rcx
setb   %r10b
cmp    %rbp,%rax
setb   %bpl
mov    0x70(%rsp),%al
test   %al,0x30(%rsp)
jne    2f99 <gridabove+0x1e89>
mov    %r15d,%eax
and    0x2c(%rsp),%sil
mov    0x88(%rsp),%r15
jne    2f92 <gridabove+0x1e82>
and    %al,%r11b
jne    2f92 <gridabove+0x1e82>
and    0x68(%rsp),%r9b
mov    0x38(%rsp),%r9
jne    2fa6 <gridabove+0x1e96>
and    %bpl,%r10b
jne    2fa6 <gridabove+0x1e96>
add    $0x1,%r14
movabs $0x1fffffff8,%rax
lea    0x4(%rax),%rdx
and    %r14,%rdx
mov    0x78(%rsp),%r10
add    %rdx,%r10
movss  0x0(%r13,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  (%r12,%rbx,4),%xmm1
shufps $0x0,%xmm1,%xmm1
xor    %esi,%esi
movdqa %xmm8,%xmm5
mov    0x10(%rsp),%r11
mov    0x90(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    2f50 <gridabove+0x1e40>
cmp    %rdx,%r14
mov    0x8(%rsp),%r14
mov    0xa0(%rsp),%rdi
je     29e0 <gridabove+0x18d0>
jmp    2fc5 <gridabove+0x1eb5>
mov    0x38(%rsp),%r9
jmp    2fa6 <gridabove+0x1e96>
mov    0x38(%rsp),%r9
mov    0x88(%rsp),%r15
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%r11
mov    0xa0(%rsp),%rdi
mov    0x90(%rsp),%rbp
mov    0x78(%rsp),%r10
mov    %edx,%esi
not    %esi
mov    0x140(%rsp),%eax
add    %eax,%esi
sub    %r8d,%esi
lea    (%rdx,%r8,1),%ecx
test   $0x1,%sil
je     3013 <gridabove+0x1f03>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  0x0(%r13,%rbx,4),%xmm1
movss  %xmm1,(%rdi,%r10,4)
mulss  %xmm3,%xmm0
addss  (%r12,%rbx,4),%xmm0
movss  %xmm0,0x0(%rbp,%r10,4)
add    $0x1,%edx
add    $0x1,%r10
cmp    %ecx,0x58(%rsp)
je     29e0 <gridabove+0x18d0>
not    %r8d
mov    0x140(%rsp),%eax
add    %eax,%r8d
lea    (%rdi,%r10,4),%rcx
add    $0x4,%rcx
lea    0x4(,%r10,4),%rdi
add    %rbp,%rdi
mov    %edx,%edx
xor    %esi,%esi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rsi,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm15,%xmm1
addss  0x0(%r13,%rbx,4),%xmm1
movss  %xmm1,-0x4(%rcx,%rsi,4)
mulss  %xmm3,%xmm0
addss  (%r12,%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  0x0(%r13,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rsi,4)
mulss  %xmm3,%xmm1
addss  (%r12,%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    3050 <gridabove+0x1f40>
jmp    29e0 <gridabove+0x18d0>
add    $0xe8,%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 @gridabove(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 %405
47: ; preds = %17
%48 = load float**, float*** %20
%49 = icmp eq float** %48, null
br i1 %49, label %50, label %405
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 %404
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 %403
354: ; preds = %195
%355 = load i32, i32* %27
%356 = icmp eq i32 %355, 3
br i1 %356, label %357, label %402
357: ; preds = %354
%358 = load i32, i32* %25
store i32 %358, i32* %38
br label %359
359: ; preds = %398, %357
%360 = load i32, i32* %38
%361 = load i32, i32* %26
%362 = icmp slt i32 %360, %361
br i1 %362, label %363, label %401
363: ; preds = %359
store i32 0, i32* %40
store i32 0, i32* %39
br label %364
364: ; preds = %392, %363
%365 = load i32, i32* %40
%366 = load i32*, i32** %21
%367 = load i32, i32* %38
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds i32, i32* %366, i64 %368
%370 = load i32, i32* %369
%371 = icmp slt i32 %365, %370
br i1 %371, label %372, label %397
372: ; preds = %364
%373 = load float**, float*** %22
%374 = getelementptr inbounds float*, float** %373, i64 1
%375 = load float*, float** %374
%376 = load i32, i32* %38
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %375, i64 %377
%379 = load float, float* %378
%380 = load i32, i32* %39
%381 = sitofp i32 %380 to float
%382 = load float, float* %29
%383 = call float @llvm.fmuladd.f32(float %381, float %382, float %379)
%384 = load float**, float*** %18
%385 = load i32, i32* %38
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float*, float** %384, i64 %386
%388 = load float*, float** %387
%389 = load i32, i32* %40
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds float, float* %388, i64 %390
store float %383, float* %391
br label %392
392: ; preds = %372
%393 = load i32, i32* %40
%394 = add nsw i32 %393, 1
store i32 %394, i32* %40
%395 = load i32, i32* %39
%396 = add nsw i32 %395, 1
store i32 %396, i32* %39
br label %364
397: ; preds = %364
br label %398
398: ; preds = %397
%399 = load i32, i32* %38
%400 = add nsw i32 %399, 1
store i32 %400, i32* %38
br label %359
401: ; preds = %359
br label %402
402: ; preds = %401, %354
br label %403
403: ; preds = %402, %353
br label %404
404: ; preds = %403, %194
br label %1508
405: ; preds = %47, %17
%406 = load float**, float*** %19
%407 = icmp eq float** %406, null
br i1 %407, label %408, label %893
408: ; preds = %405
%409 = load i32, i32* %27
%410 = icmp eq i32 %409, 1
br i1 %410, label %411, label %609
411: ; preds = %408
%412 = load float, float* %28
%413 = load float, float* %33
%414 = fdiv float %412, %413
%415 = fpext float %414 to double
%416 = fcmp ogt double %415, 0.000000e+00
br i1 %416, label %417, label %423
417: ; preds = %411
%418 = load float, float* %28
%419 = load float, float* %33
%420 = fdiv float %418, %419
%421 = fpext float %420 to double
%422 = fadd double %421, 5.000000e-01
br label %429
423: ; preds = %411
%424 = load float, float* %28
%425 = load float, float* %33
%426 = fdiv float %424, %425
%427 = fpext float %426 to double
%428 = fsub double %427, 5.000000e-01
br label %429
429: ; preds = %423, %417
%430 = phi double [ %422, %417 ], [ %428, %423 ]
%431 = fptosi double %430 to i32
%432 = sub nsw i32 %431, 1
store i32 %432, i32* %35
%433 = load i32, i32* %25
store i32 %433, i32* %38
br label %434
434: ; preds = %605, %429
%435 = load i32, i32* %38
%436 = load i32, i32* %26
%437 = icmp slt i32 %435, %436
br i1 %437, label %438, label %608
438: ; preds = %434
%439 = load float**, float*** %22
%440 = getelementptr inbounds float*, float** %439, i64 1
%441 = load float*, float** %440
%442 = load i32, i32* %38
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds float, float* %441, i64 %443
%445 = load float, float* %444
%446 = load float**, float*** %22
%447 = getelementptr inbounds float*, float** %446, i64 0
%448 = load float*, float** %447
%449 = load i32, i32* %38
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %448, i64 %450
%452 = load float, float* %451
%453 = fsub float %445, %452
%454 = load i32, i32* %35
%455 = sitofp i32 %454 to float
%456 = fdiv float %453, %455
store float %456, float* %41
%457 = load float**, float*** %24
%458 = getelementptr inbounds float*, float** %457, i64 1
%459 = load float*, float** %458
%460 = load i32, i32* %38
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float, float* %459, i64 %461
%463 = load float, float* %462
%464 = load float**, float*** %24
%465 = getelementptr inbounds float*, float** %464, i64 0
%466 = load float*, float** %465
%467 = load i32, i32* %38
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds float, float* %466, i64 %468
%470 = load float, float* %469
%471 = fsub float %463, %470
%472 = load i32, i32* %35
%473 = sitofp i32 %472 to float
%474 = fdiv float %471, %473
store float %474, float* %43
%475 = load i32*, i32** %21
%476 = load i32, i32* %38
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i32, i32* %475, i64 %477
%479 = load i32, i32* %478
%480 = icmp eq i32 %479, 0
br i1 %480, label %481, label %482
481: ; preds = %438
store i32 1, i32* %39
br label %483
482: ; preds = %438
store i32 0, i32* %39
br label %483
483: ; preds = %482, %481
%484 = load i32*, i32** %21
%485 = load i32, i32* %38
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i32, i32* %484, i64 %486
%488 = load i32, i32* %487
%489 = load i32, i32* %35
%490 = add nsw i32 %488, %489
store i32 %490, i32* %36
%491 = load i32, i32* %36
%492 = load i32, i32* %34
%493 = icmp slt i32 %491, %492
br i1 %493, label %494, label %496
494: ; preds = %483
%495 = load i32, i32* %36
br label %498
496: ; preds = %483
%497 = load i32, i32* %34
br label %498
498: ; preds = %496, %494
%499 = phi i32 [ %495, %494 ], [ %497, %496 ]
store i32 %499, i32* %37
%500 = load i32*, i32** %21
%501 = load i32, i32* %38
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds i32, i32* %500, i64 %502
%504 = load i32, i32* %503
store i32 %504, i32* %40
br label %505
505: ; preds = %550, %498
%506 = load i32, i32* %40
%507 = load i32, i32* %37
%508 = icmp sle i32 %506, %507
br i1 %508, label %509, label %553
509: ; preds = %505
%510 = load float**, float*** %22
%511 = getelementptr inbounds float*, float** %510, i64 0
%512 = load float*, float** %511
%513 = load i32, i32* %38
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds float, float* %512, i64 %514
%516 = load float, float* %515
%517 = load float, float* %41
%518 = load i32, i32* %39
%519 = sitofp i32 %518 to float
%520 = call float @llvm.fmuladd.f32(float %517, float %519, float %516)
%521 = load float**, float*** %18
%522 = load i32, i32* %38
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float*, float** %521, i64 %523
%525 = load float*, float** %524
%526 = load i32, i32* %40
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds float, float* %525, i64 %527
store float %520, float* %528
%529 = load float**, float*** %24
%530 = getelementptr inbounds float*, float** %529, i64 0
%531 = load float*, float** %530
%532 = load i32, i32* %38
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float, float* %531, i64 %533
%535 = load float, float* %534
%536 = load float, float* %43
%537 = load i32, i32* %39
%538 = sitofp i32 %537 to float
%539 = call float @llvm.fmuladd.f32(float %536, float %538, float %535)
%540 = load float**, float*** %20
%541 = load i32, i32* %38
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds float*, float** %540, i64 %542
%544 = load float*, float** %543
%545 = load i32, i32* %40
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float, float* %544, i64 %546
store float %539, float* %547
%548 = load i32, i32* %39
%549 = add nsw i32 %548, 1
store i32 %549, i32* %39
br label %550
550: ; preds = %509
%551 = load i32, i32* %40
%552 = add nsw i32 %551, 1
store i32 %552, i32* %40
br label %505
553: ; preds = %505
%554 = load i32, i32* %37
%555 = add nsw i32 %554, 1
store i32 %555, i32* %40
store i32 0, i32* %39
br label %556
556: ; preds = %599, %553
%557 = load i32, i32* %40
%558 = load i32, i32* %34
%559 = icmp slt i32 %557, %558
br i1 %559, label %560, label %604
560: ; preds = %556
%561 = load float**, float*** %22
%562 = getelementptr inbounds float*, float** %561, i64 1
%563 = load float*, float** %562
%564 = load i32, i32* %38
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %563, i64 %565
%567 = load float, float* %566
%568 = load i32, i32* %39
%569 = sitofp i32 %568 to float
%570 = load float, float* %29
%571 = call float @llvm.fmuladd.f32(float %569, float %570, float %567)
%572 = load float**, float*** %18
%573 = load i32, i32* %38
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds float*, float** %572, i64 %574
%576 = load float*, float** %575
%577 = load i32, i32* %40
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds float, float* %576, i64 %578
store float %571, float* %579
%580 = load float**, float*** %24
%581 = getelementptr inbounds float*, float** %580, i64 1
%582 = load float*, float** %581
%583 = load i32, i32* %38
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds float, float* %582, i64 %584
%586 = load float, float* %585
%587 = load i32, i32* %39
%588 = sitofp i32 %587 to float
%589 = load float, float* %31
%590 = call float @llvm.fmuladd.f32(float %588, float %589, float %586)
%591 = load float**, float*** %20
%592 = load i32, i32* %38
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float*, float** %591, i64 %593
%595 = load float*, float** %594
%596 = load i32, i32* %40
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds float, float* %595, i64 %597
store float %590, float* %598
br label %599
599: ; preds = %560
%600 = load i32, i32* %40
%601 = add nsw i32 %600, 1
store i32 %601, i32* %40
%602 = load i32, i32* %39
%603 = add nsw i32 %602, 1
store i32 %603, i32* %39
br label %556
604: ; preds = %556
br label %605
605: ; preds = %604
%606 = load i32, i32* %38
%607 = add nsw i32 %606, 1
store i32 %607, i32* %38
br label %434
608: ; preds = %434
br label %892
609: ; preds = %408
%610 = load i32, i32* %27
%611 = icmp eq i32 %610, 2
br i1 %611, label %612, label %823
612: ; preds = %609
%613 = load float, float* %28
%614 = load float, float* %33
%615 = fdiv float %613, %614
%616 = fpext float %615 to double
%617 = fcmp ogt double %616, 0.000000e+00
br i1 %617, label %618, label %624
618: ; preds = %612
%619 = load float, float* %28
%620 = load float, float* %33
%621 = fdiv float %619, %620
%622 = fpext float %621 to double
%623 = fadd double %622, 5.000000e-01
br label %630
624: ; preds = %612
%625 = load float, float* %28
%626 = load float, float* %33
%627 = fdiv float %625, %626
%628 = fpext float %627 to double
%629 = fsub double %628, 5.000000e-01
br label %630
630: ; preds = %624, %618
%631 = phi double [ %623, %618 ], [ %629, %624 ]
%632 = fptosi double %631 to i32
%633 = sub nsw i32 %632, 1
store i32 %633, i32* %35
%634 = load i32, i32* %25
store i32 %634, i32* %38
br label %635
635: ; preds = %819, %630
%636 = load i32, i32* %38
%637 = load i32, i32* %26
%638 = icmp slt i32 %636, %637
br i1 %638, label %639, label %822
639: ; preds = %635
%640 = load float**, float*** %22
%641 = getelementptr inbounds float*, float** %640, i64 1
%642 = load float*, float** %641
%643 = load i32, i32* %38
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds float, float* %642, i64 %644
%646 = load float, float* %645
%647 = load float**, float*** %22
%648 = getelementptr inbounds float*, float** %647, i64 0
%649 = load float*, float** %648
%650 = load i32, i32* %38
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %649, i64 %651
%653 = load float, float* %652
%654 = fsub float %646, %653
%655 = load i32, i32* %35
%656 = sitofp i32 %655 to float
%657 = fdiv float %654, %656
store float %657, float* %41
%658 = load float**, float*** %24
%659 = getelementptr inbounds float*, float** %658, i64 1
%660 = load float*, float** %659
%661 = load i32, i32* %38
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %660, i64 %662
%664 = load float, float* %663
%665 = load float**, float*** %24
%666 = getelementptr inbounds float*, float** %665, i64 0
%667 = load float*, float** %666
%668 = load i32, i32* %38
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds float, float* %667, i64 %669
%671 = load float, float* %670
%672 = fsub float %664, %671
%673 = load i32, i32* %35
%674 = sitofp i32 %673 to float
%675 = fdiv float %672, %674
store float %675, float* %43
%676 = load i32*, i32** %21
%677 = load i32, i32* %38
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds i32, i32* %676, i64 %678
%680 = load i32, i32* %679
%681 = icmp eq i32 %680, 0
br i1 %681, label %682, label %683
682: ; preds = %639
store i32 1, i32* %39
br label %684
683: ; preds = %639
store i32 0, i32* %39
br label %684
684: ; preds = %683, %682
%685 = load i32*, i32** %21
%686 = load i32, i32* %38
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds i32, i32* %685, i64 %687
%689 = load i32, i32* %688
%690 = load i32, i32* %35
%691 = add nsw i32 %689, %690
store i32 %691, i32* %36
%692 = load i32, i32* %36
%693 = load i32, i32* %34
%694 = icmp slt i32 %692, %693
br i1 %694, label %695, label %697
695: ; preds = %684
%696 = load i32, i32* %36
br label %699
697: ; preds = %684
%698 = load i32, i32* %34
br label %699
699: ; preds = %697, %695
%700 = phi i32 [ %696, %695 ], [ %698, %697 ]
store i32 %700, i32* %37
%701 = load i32*, i32** %21
%702 = load i32, i32* %38
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds i32, i32* %701, i64 %703
%705 = load i32, i32* %704
store i32 %705, i32* %40
br label %706
706: ; preds = %764, %699
%707 = load i32, i32* %40
%708 = load i32, i32* %37
%709 = icmp sle i32 %707, %708
br i1 %709, label %710, label %767
710: ; preds = %706
%711 = load i32, i32* %35
%712 = sub nsw i32 0, %711
%713 = load float, float* @M_PI
%714 = load i32, i32* %39
%715 = sitofp i32 %714 to float
%716 = load i32, i32* %35
%717 = sitofp i32 %716 to float
%718 = fdiv float %715, %717
%719 = fmul float %713, %718
%720 = call i32 @cos(float %719)
%721 = sub nsw i32 %720, 1
%722 = mul nsw i32 %712, %721
%723 = sitofp i32 %722 to double
%724 = fdiv double %723, 2.000000e+00
%725 = fptrunc double %724 to float
store float %725, float* %44
%726 = load float**, float*** %22
%727 = getelementptr inbounds float*, float** %726, i64 0
%728 = load float*, float** %727
%729 = load i32, i32* %38
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds float, float* %728, i64 %730
%732 = load float, float* %731
%733 = load float, float* %41
%734 = load float, float* %44
%735 = call float @llvm.fmuladd.f32(float %733, float %734, float %732)
%736 = load float**, float*** %18
%737 = load i32, i32* %38
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds float*, float** %736, i64 %738
%740 = load float*, float** %739
%741 = load i32, i32* %40
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds float, float* %740, i64 %742
store float %735, float* %743
%744 = load float**, float*** %24
%745 = getelementptr inbounds float*, float** %744, i64 0
%746 = load float*, float** %745
%747 = load i32, i32* %38
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds float, float* %746, i64 %748
%750 = load float, float* %749
%751 = load float, float* %43
%752 = load float, float* %44
%753 = call float @llvm.fmuladd.f32(float %751, float %752, float %750)
%754 = load float**, float*** %20
%755 = load i32, i32* %38
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds float*, float** %754, i64 %756
%758 = load float*, float** %757
%759 = load i32, i32* %40
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds float, float* %758, i64 %760
store float %753, float* %761
%762 = load i32, i32* %39
%763 = add nsw i32 %762, 1
store i32 %763, i32* %39
br label %764
764: ; preds = %710
%765 = load i32, i32* %40
%766 = add nsw i32 %765, 1
store i32 %766, i32* %40
br label %706
767: ; preds = %706
%768 = load i32, i32* %37
%769 = add nsw i32 %768, 1
store i32 %769, i32* %40
store i32 0, i32* %39
br label %770
770: ; preds = %813, %767
%771 = load i32, i32* %40
%772 = load i32, i32* %34
%773 = icmp slt i32 %771, %772
br i1 %773, label %774, label %818
774: ; preds = %770
%775 = load float**, float*** %22
%776 = getelementptr inbounds float*, float** %775, i64 1
%777 = load float*, float** %776
%778 = load i32, i32* %38
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds float, float* %777, i64 %779
%781 = load float, float* %780
%782 = load i32, i32* %39
%783 = sitofp i32 %782 to float
%784 = load float, float* %29
%785 = call float @llvm.fmuladd.f32(float %783, float %784, float %781)
%786 = load float**, float*** %18
%787 = load i32, i32* %38
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds float*, float** %786, i64 %788
%790 = load float*, float** %789
%791 = load i32, i32* %40
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds float, float* %790, i64 %792
store float %785, float* %793
%794 = load float**, float*** %24
%795 = getelementptr inbounds float*, float** %794, i64 1
%796 = load float*, float** %795
%797 = load i32, i32* %38
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds float, float* %796, i64 %798
%800 = load float, float* %799
%801 = load i32, i32* %39
%802 = sitofp i32 %801 to float
%803 = load float, float* %31
%804 = call float @llvm.fmuladd.f32(float %802, float %803, float %800)
%805 = load float**, float*** %20
%806 = load i32, i32* %38
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds float*, float** %805, i64 %807
%809 = load float*, float** %808
%810 = load i32, i32* %40
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds float, float* %809, i64 %811
store float %804, float* %812
br label %813
813: ; preds = %774
%814 = load i32, i32* %40
%815 = add nsw i32 %814, 1
store i32 %815, i32* %40
%816 = load i32, i32* %39
%817 = add nsw i32 %816, 1
store i32 %817, i32* %39
br label %770
818: ; preds = %770
br label %819
819: ; preds = %818
%820 = load i32, i32* %38
%821 = add nsw i32 %820, 1
store i32 %821, i32* %38
br label %635
822: ; preds = %635
br label %891
823: ; preds = %609
%824 = load i32, i32* %27
%825 = icmp eq i32 %824, 3
br i1 %825, label %826, label %890
826: ; preds = %823
%827 = load i32, i32* %25
store i32 %827, i32* %38
br label %828
828: ; preds = %886, %826
%829 = load i32, i32* %38
%830 = load i32, i32* %26
%831 = icmp slt i32 %829, %830
br i1 %831, label %832, label %889
832: ; preds = %828
store i32 0, i32* %40
store i32 0, i32* %39
br label %833
833: ; preds = %880, %832
%834 = load i32, i32* %40
%835 = load i32*, i32** %21
%836 = load i32, i32* %38
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds i32, i32* %835, i64 %837
%839 = load i32, i32* %838
%840 = icmp slt i32 %834, %839
br i1 %840, label %841, label %885
841: ; preds = %833
%842 = load float**, float*** %22
%843 = getelementptr inbounds float*, float** %842, i64 1
%844 = load float*, float** %843
%845 = load i32, i32* %38
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds float, float* %844, i64 %846
%848 = load float, float* %847
%849 = load i32, i32* %39
%850 = sitofp i32 %849 to float
%851 = load float, float* %29
%852 = call float @llvm.fmuladd.f32(float %850, float %851, float %848)
%853 = load float**, float*** %18
%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* %40
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds float, float* %857, i64 %859
store float %852, float* %860
%861 = load float**, float*** %24
%862 = getelementptr inbounds float*, float** %861, i64 1
%863 = load float*, float** %862
%864 = load i32, i32* %38
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds float, float* %863, i64 %865
%867 = load float, float* %866
%868 = load i32, i32* %39
%869 = sitofp i32 %868 to float
%870 = load float, float* %31
%871 = call float @llvm.fmuladd.f32(float %869, float %870, float %867)
%872 = load float**, float*** %20
%873 = load i32, i32* %38
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds float*, float** %872, i64 %874
%876 = load float*, float** %875
%877 = load i32, i32* %40
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds float, float* %876, i64 %878
store float %871, float* %879
br label %880
880: ; preds = %841
%881 = load i32, i32* %40
%882 = add nsw i32 %881, 1
store i32 %882, i32* %40
%883 = load i32, i32* %39
%884 = add nsw i32 %883, 1
store i32 %884, i32* %39
br label %833
885: ; preds = %833
br label %886
886: ; preds = %885
%887 = load i32, i32* %38
%888 = add nsw i32 %887, 1
store i32 %888, i32* %38
br label %828
889: ; preds = %828
br label %890
890: ; preds = %889, %823
br label %891
891: ; preds = %890, %822
br label %892
892: ; preds = %891, %608
br label %1508
893: ; preds = %405
%894 = load i32, i32* %27
%895 = icmp eq i32 %894, 1
br i1 %895, label %896, label %1150
896: ; preds = %893
%897 = load float, float* %28
%898 = load float, float* %33
%899 = fdiv float %897, %898
%900 = fpext float %899 to double
%901 = fcmp ogt double %900, 0.000000e+00
br i1 %901, label %902, label %908
902: ; preds = %896
%903 = load float, float* %28
%904 = load float, float* %33
%905 = fdiv float %903, %904
%906 = fpext float %905 to double
%907 = fadd double %906, 5.000000e-01
br label %914
908: ; preds = %896
%909 = load float, float* %28
%910 = load float, float* %33
%911 = fdiv float %909, %910
%912 = fpext float %911 to double
%913 = fsub double %912, 5.000000e-01
br label %914
914: ; preds = %908, %902
%915 = phi double [ %907, %902 ], [ %913, %908 ]
%916 = fptosi double %915 to i32
%917 = sub nsw i32 %916, 1
store i32 %917, i32* %35
%918 = load i32, i32* %25
store i32 %918, i32* %38
br label %919
919: ; preds = %1146, %914
%920 = load i32, i32* %38
%921 = load i32, i32* %26
%922 = icmp slt i32 %920, %921
br i1 %922, label %923, label %1149
923: ; preds = %919
%924 = load float**, float*** %22
%925 = getelementptr inbounds float*, float** %924, i64 1
%926 = load float*, float** %925
%927 = load i32, i32* %38
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds float, float* %926, i64 %928
%930 = load float, float* %929
%931 = load float**, float*** %22
%932 = getelementptr inbounds float*, float** %931, i64 0
%933 = load float*, float** %932
%934 = load i32, i32* %38
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds float, float* %933, i64 %935
%937 = load float, float* %936
%938 = fsub float %930, %937
%939 = load i32, i32* %35
%940 = sitofp i32 %939 to float
%941 = fdiv float %938, %940
store float %941, float* %41
%942 = load float**, float*** %23
%943 = getelementptr inbounds float*, float** %942, i64 1
%944 = load float*, float** %943
%945 = load i32, i32* %38
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds float, float* %944, i64 %946
%948 = load float, float* %947
%949 = load float**, float*** %23
%950 = getelementptr inbounds float*, float** %949, i64 0
%951 = load float*, float** %950
%952 = load i32, i32* %38
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds float, float* %951, i64 %953
%955 = load float, float* %954
%956 = fsub float %948, %955
%957 = load i32, i32* %35
%958 = sitofp i32 %957 to float
%959 = fdiv float %956, %958
store float %959, float* %42
%960 = load float**, float*** %24
%961 = getelementptr inbounds float*, float** %960, i64 1
%962 = load float*, float** %961
%963 = load i32, i32* %38
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds float, float* %962, i64 %964
%966 = load float, float* %965
%967 = load float**, float*** %24
%968 = getelementptr inbounds float*, float** %967, i64 0
%969 = load float*, float** %968
%970 = load i32, i32* %38
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds float, float* %969, i64 %971
%973 = load float, float* %972
%974 = fsub float %966, %973
%975 = load i32, i32* %35
%976 = sitofp i32 %975 to float
%977 = fdiv float %974, %976
store float %977, float* %43
%978 = load i32*, i32** %21
%979 = load i32, i32* %38
%980 = sext i32 %979 to i64
%981 = getelementptr inbounds i32, i32* %978, i64 %980
%982 = load i32, i32* %981
%983 = icmp eq i32 %982, 0
br i1 %983, label %984, label %985
984: ; preds = %923
store i32 1, i32* %39
br label %986
985: ; preds = %923
store i32 0, i32* %39
br label %986
986: ; preds = %985, %984
%987 = load i32*, i32** %21
%988 = load i32, i32* %38
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds i32, i32* %987, i64 %989
%991 = load i32, i32* %990
%992 = load i32, i32* %35
%993 = add nsw i32 %991, %992
store i32 %993, i32* %36
%994 = load i32, i32* %36
%995 = load i32, i32* %34
%996 = icmp slt i32 %994, %995
br i1 %996, label %997, label %999
997: ; preds = %986
%998 = load i32, i32* %36
br label %1001
999: ; preds = %986
%1000 = load i32, i32* %34
br label %1001
1001: ; preds = %999, %997
%1002 = phi i32 [ %998, %997 ], [ %1000, %999 ]
store i32 %1002, i32* %37
%1003 = load i32*, i32** %21
%1004 = load i32, i32* %38
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds i32, i32* %1003, i64 %1005
%1007 = load i32, i32* %1006
store i32 %1007, i32* %40
br label %1008
1008: ; preds = %1072, %1001
%1009 = load i32, i32* %40
%1010 = load i32, i32* %37
%1011 = icmp sle i32 %1009, %1010
br i1 %1011, label %1012, label %1075
1012: ; preds = %1008
%1013 = load float**, float*** %22
%1014 = getelementptr inbounds float*, float** %1013, i64 0
%1015 = load float*, float** %1014
%1016 = load i32, i32* %38
%1017 = sext i32 %1016 to i64
%1018 = getelementptr inbounds float, float* %1015, i64 %1017
%1019 = load float, float* %1018
%1020 = load float, float* %41
%1021 = load i32, i32* %39
%1022 = sitofp i32 %1021 to float
%1023 = call float @llvm.fmuladd.f32(float %1020, float %1022, float %1019)
%1024 = load float**, float*** %18
%1025 = load i32, i32* %38
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds float*, float** %1024, i64 %1026
%1028 = load float*, float** %1027
%1029 = load i32, i32* %40
%1030 = sext i32 %1029 to i64
%1031 = getelementptr inbounds float, float* %1028, i64 %1030
store float %1023, float* %1031
%1032 = load float**, float*** %23
%1033 = getelementptr inbounds float*, float** %1032, i64 0
%1034 = load float*, float** %1033
%1035 = load i32, i32* %38
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds float, float* %1034, i64 %1036
%1038 = load float, float* %1037
%1039 = load float, float* %42
%1040 = load i32, i32* %39
%1041 = sitofp i32 %1040 to float
%1042 = call float @llvm.fmuladd.f32(float %1039, float %1041, float %1038)
%1043 = load float**, float*** %19
%1044 = load i32, i32* %38
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds float*, float** %1043, i64 %1045
%1047 = load float*, float** %1046
%1048 = load i32, i32* %40
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds float, float* %1047, i64 %1049
store float %1042, float* %1050
%1051 = load float**, float*** %24
%1052 = getelementptr inbounds float*, float** %1051, i64 0
%1053 = load float*, float** %1052
%1054 = load i32, i32* %38
%1055 = sext i32 %1054 to i64
%1056 = getelementptr inbounds float, float* %1053, i64 %1055
%1057 = load float, float* %1056
%1058 = load float, float* %43
%1059 = load i32, i32* %39
%1060 = sitofp i32 %1059 to float
%1061 = call float @llvm.fmuladd.f32(float %1058, float %1060, float %1057)
%1062 = load float**, float*** %20
%1063 = load i32, i32* %38
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds float*, float** %1062, i64 %1064
%1066 = load float*, float** %1065
%1067 = load i32, i32* %40
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds float, float* %1066, i64 %1068
store float %1061, float* %1069
%1070 = load i32, i32* %39
%1071 = add nsw i32 %1070, 1
store i32 %1071, i32* %39
br label %1072
1072: ; preds = %1012
%1073 = load i32, i32* %40
%1074 = add nsw i32 %1073, 1
store i32 %1074, i32* %40
br label %1008
1075: ; preds = %1008
%1076 = load i32, i32* %37
%1077 = add nsw i32 %1076, 1
store i32 %1077, i32* %40
store i32 0, i32* %39
br label %1078
1078: ; preds = %1140, %1075
%1079 = load i32, i32* %40
%1080 = load i32, i32* %34
%1081 = icmp slt i32 %1079, %1080
br i1 %1081, label %1082, label %1145
1082: ; preds = %1078
%1083 = load float**, float*** %22
%1084 = getelementptr inbounds float*, float** %1083, i64 1
%1085 = load float*, float** %1084
%1086 = load i32, i32* %38
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds float, float* %1085, i64 %1087
%1089 = load float, float* %1088
%1090 = load i32, i32* %39
%1091 = sitofp i32 %1090 to float
%1092 = load float, float* %29
%1093 = call float @llvm.fmuladd.f32(float %1091, float %1092, float %1089)
%1094 = load float**, float*** %18
%1095 = load i32, i32* %38
%1096 = sext i32 %1095 to i64
%1097 = getelementptr inbounds float*, float** %1094, i64 %1096
%1098 = load float*, float** %1097
%1099 = load i32, i32* %40
%1100 = sext i32 %1099 to i64
%1101 = getelementptr inbounds float, float* %1098, i64 %1100
store float %1093, float* %1101
%1102 = load float**, float*** %23
%1103 = getelementptr inbounds float*, float** %1102, i64 1
%1104 = load float*, float** %1103
%1105 = load i32, i32* %38
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds float, float* %1104, i64 %1106
%1108 = load float, float* %1107
%1109 = load i32, i32* %39
%1110 = sitofp i32 %1109 to float
%1111 = load float, float* %30
%1112 = call float @llvm.fmuladd.f32(float %1110, float %1111, float %1108)
%1113 = load float**, float*** %19
%1114 = load i32, i32* %38
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds float*, float** %1113, i64 %1115
%1117 = load float*, float** %1116
%1118 = load i32, i32* %40
%1119 = sext i32 %1118 to i64
%1120 = getelementptr inbounds float, float* %1117, i64 %1119
store float %1112, float* %1120
%1121 = load float**, float*** %24
%1122 = getelementptr inbounds float*, float** %1121, i64 1
%1123 = load float*, float** %1122
%1124 = load i32, i32* %38
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds float, float* %1123, i64 %1125
%1127 = load float, float* %1126
%1128 = load i32, i32* %39
%1129 = sitofp i32 %1128 to float
%1130 = load float, float* %31
%1131 = call float @llvm.fmuladd.f32(float %1129, float %1130, float %1127)
%1132 = load float**, float*** %20
%1133 = load i32, i32* %38
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds float*, float** %1132, i64 %1134
%1136 = load float*, float** %1135
%1137 = load i32, i32* %40
%1138 = sext i32 %1137 to i64
%1139 = getelementptr inbounds float, float* %1136, i64 %1138
store float %1131, float* %1139
br label %1140
1140: ; preds = %1082
%1141 = load i32, i32* %40
%1142 = add nsw i32 %1141, 1
store i32 %1142, i32* %40
%1143 = load i32, i32* %39
%1144 = add nsw i32 %1143, 1
store i32 %1144, i32* %39
br label %1078
1145: ; preds = %1078
br label %1146
1146: ; preds = %1145
%1147 = load i32, i32* %38
%1148 = add nsw i32 %1147, 1
store i32 %1148, i32* %38
br label %919
1149: ; preds = %919
br label %1507
1150: ; preds = %893
%1151 = load i32, i32* %27
%1152 = icmp eq i32 %1151, 2
br i1 %1152, label %1153, label %1419
1153: ; preds = %1150
%1154 = load float, float* %28
%1155 = load float, float* %33
%1156 = fdiv float %1154, %1155
%1157 = fpext float %1156 to double
%1158 = fcmp ogt double %1157, 0.000000e+00
br i1 %1158, label %1159, label %1165
1159: ; preds = %1153
%1160 = load float, float* %28
%1161 = load float, float* %33
%1162 = fdiv float %1160, %1161
%1163 = fpext float %1162 to double
%1164 = fadd double %1163, 5.000000e-01
br label %1171
1165: ; preds = %1153
%1166 = load float, float* %28
%1167 = load float, float* %33
%1168 = fdiv float %1166, %1167
%1169 = fpext float %1168 to double
%1170 = fsub double %1169, 5.000000e-01
br label %1171
1171: ; preds = %1165, %1159
%1172 = phi double [ %1164, %1159 ], [ %1170, %1165 ]
%1173 = fptosi double %1172 to i32
%1174 = sub nsw i32 %1173, 1
store i32 %1174, i32* %35
%1175 = load i32, i32* %25
store i32 %1175, i32* %38
br label %1176
1176: ; preds = %1415, %1171
%1177 = load i32, i32* %38
%1178 = load i32, i32* %26
%1179 = icmp slt i32 %1177, %1178
br i1 %1179, label %1180, label %1418
1180: ; preds = %1176
%1181 = load float**, float*** %22
%1182 = getelementptr inbounds float*, float** %1181, i64 1
%1183 = load float*, float** %1182
%1184 = load i32, i32* %38
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds float, float* %1183, i64 %1185
%1187 = load float, float* %1186
%1188 = load float**, float*** %22
%1189 = getelementptr inbounds float*, float** %1188, i64 0
%1190 = load float*, float** %1189
%1191 = load i32, i32* %38
%1192 = sext i32 %1191 to i64
%1193 = getelementptr inbounds float, float* %1190, i64 %1192
%1194 = load float, float* %1193
%1195 = fsub float %1187, %1194
%1196 = load i32, i32* %35
%1197 = sitofp i32 %1196 to float
%1198 = fdiv float %1195, %1197
store float %1198, float* %41
%1199 = load float**, float*** %23
%1200 = getelementptr inbounds float*, float** %1199, i64 1
%1201 = load float*, float** %1200
%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 float**, float*** %23
%1207 = getelementptr inbounds float*, float** %1206, i64 0
%1208 = load float*, float** %1207
%1209 = load i32, i32* %38
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds float, float* %1208, i64 %1210
%1212 = load float, float* %1211
%1213 = fsub float %1205, %1212
%1214 = load i32, i32* %35
%1215 = sitofp i32 %1214 to float
%1216 = fdiv float %1213, %1215
store float %1216, float* %42
%1217 = load float**, float*** %24
%1218 = getelementptr inbounds float*, float** %1217, i64 1
%1219 = load float*, float** %1218
%1220 = load i32, i32* %38
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds float, float* %1219, i64 %1221
%1223 = load float, float* %1222
%1224 = load float**, float*** %24
%1225 = getelementptr inbounds float*, float** %1224, i64 0
%1226 = load float*, float** %1225
%1227 = load i32, i32* %38
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds float, float* %1226, i64 %1228
%1230 = load float, float* %1229
%1231 = fsub float %1223, %1230
%1232 = load i32, i32* %35
%1233 = sitofp i32 %1232 to float
%1234 = fdiv float %1231, %1233
store float %1234, float* %43
%1235 = load i32*, i32** %21
%1236 = load i32, i32* %38
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds i32, i32* %1235, i64 %1237
%1239 = load i32, i32* %1238
%1240 = icmp eq i32 %1239, 0
br i1 %1240, label %1241, label %1242
1241: ; preds = %1180
store i32 1, i32* %39
br label %1243
1242: ; preds = %1180
store i32 0, i32* %39
br label %1243
1243: ; preds = %1242, %1241
%1244 = load i32*, i32** %21
%1245 = load i32, i32* %38
%1246 = sext i32 %1245 to i64
%1247 = getelementptr inbounds i32, i32* %1244, i64 %1246
%1248 = load i32, i32* %1247
%1249 = load i32, i32* %35
%1250 = add nsw i32 %1248, %1249
store i32 %1250, i32* %36
%1251 = load i32, i32* %36
%1252 = load i32, i32* %34
%1253 = icmp slt i32 %1251, %1252
br i1 %1253, label %1254, label %1256
1254: ; preds = %1243
%1255 = load i32, i32* %36
br label %1258
1256: ; preds = %1243
%1257 = load i32, i32* %34
br label %1258
1258: ; preds = %1256, %1254
%1259 = phi i32 [ %1255, %1254 ], [ %1257, %1256 ]
store i32 %1259, i32* %37
%1260 = load i32*, i32** %21
%1261 = load i32, i32* %38
%1262 = sext i32 %1261 to i64
%1263 = getelementptr inbounds i32, i32* %1260, i64 %1262
%1264 = load i32, i32* %1263
store i32 %1264, i32* %40
br label %1265
1265: ; preds = %1341, %1258
%1266 = load i32, i32* %40
%1267 = load i32, i32* %37
%1268 = icmp sle i32 %1266, %1267
br i1 %1268, label %1269, label %1344
1269: ; preds = %1265
%1270 = load i32, i32* %35
%1271 = sub nsw i32 0, %1270
%1272 = load float, float* @M_PI
%1273 = load i32, i32* %39
%1274 = sitofp i32 %1273 to float
%1275 = load i32, i32* %35
%1276 = sitofp i32 %1275 to float
%1277 = fdiv float %1274, %1276
%1278 = fmul float %1272, %1277
%1279 = call i32 @cos(float %1278)
%1280 = sub nsw i32 %1279, 1
%1281 = mul nsw i32 %1271, %1280
%1282 = sitofp i32 %1281 to double
%1283 = fdiv double %1282, 2.000000e+00
%1284 = fptrunc double %1283 to float
store float %1284, float* %44
%1285 = load float**, float*** %22
%1286 = getelementptr inbounds float*, float** %1285, i64 0
%1287 = load float*, float** %1286
%1288 = load i32, i32* %38
%1289 = sext i32 %1288 to i64
%1290 = getelementptr inbounds float, float* %1287, i64 %1289
%1291 = load float, float* %1290
%1292 = load float, float* %41
%1293 = load float, float* %44
%1294 = call float @llvm.fmuladd.f32(float %1292, float %1293, float %1291)
%1295 = load float**, float*** %18
%1296 = load i32, i32* %38
%1297 = sext i32 %1296 to i64
%1298 = getelementptr inbounds float*, float** %1295, i64 %1297
%1299 = load float*, float** %1298
%1300 = load i32, i32* %40
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds float, float* %1299, i64 %1301
store float %1294, float* %1302
%1303 = load float**, float*** %23
%1304 = getelementptr inbounds float*, float** %1303, i64 0
%1305 = load float*, float** %1304
%1306 = load i32, i32* %38
%1307 = sext i32 %1306 to i64
%1308 = getelementptr inbounds float, float* %1305, i64 %1307
%1309 = load float, float* %1308
%1310 = load float, float* %42
%1311 = load float, float* %44
%1312 = call float @llvm.fmuladd.f32(float %1310, float %1311, float %1309)
%1313 = load float**, float*** %19
%1314 = load i32, i32* %38
%1315 = sext i32 %1314 to i64
%1316 = getelementptr inbounds float*, float** %1313, i64 %1315
%1317 = load float*, float** %1316
%1318 = load i32, i32* %40
%1319 = sext i32 %1318 to i64
%1320 = getelementptr inbounds float, float* %1317, i64 %1319
store float %1312, float* %1320
%1321 = load float**, float*** %24
%1322 = getelementptr inbounds float*, float** %1321, i64 0
%1323 = load float*, float** %1322
%1324 = load i32, i32* %38
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds float, float* %1323, i64 %1325
%1327 = load float, float* %1326
%1328 = load float, float* %43
%1329 = load float, float* %44
%1330 = call float @llvm.fmuladd.f32(float %1328, float %1329, float %1327)
%1331 = load float**, float*** %20
%1332 = load i32, i32* %38
%1333 = sext i32 %1332 to i64
%1334 = getelementptr inbounds float*, float** %1331, i64 %1333
%1335 = load float*, float** %1334
%1336 = load i32, i32* %40
%1337 = sext i32 %1336 to i64
%1338 = getelementptr inbounds float, float* %1335, i64 %1337
store float %1330, float* %1338
%1339 = load i32, i32* %39
%1340 = add nsw i32 %1339, 1
store i32 %1340, i32* %39
br label %1341
1341: ; preds = %1269
%1342 = load i32, i32* %40
%1343 = add nsw i32 %1342, 1
store i32 %1343, i32* %40
br label %1265
1344: ; preds = %1265
%1345 = load i32, i32* %37
%1346 = add nsw i32 %1345, 1
store i32 %1346, i32* %40
store i32 0, i32* %39
br label %1347
1347: ; preds = %1409, %1344
%1348 = load i32, i32* %40
%1349 = load i32, i32* %34
%1350 = icmp slt i32 %1348, %1349
br i1 %1350, label %1351, label %1414
1351: ; preds = %1347
%1352 = load float**, float*** %22
%1353 = getelementptr inbounds float*, float** %1352, i64 1
%1354 = load float*, float** %1353
%1355 = load i32, i32* %38
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds float, float* %1354, i64 %1356
%1358 = load float, float* %1357
%1359 = load i32, i32* %39
%1360 = sitofp i32 %1359 to float
%1361 = load float, float* %29
%1362 = call float @llvm.fmuladd.f32(float %1360, float %1361, float %1358)
%1363 = load float**, float*** %18
%1364 = load i32, i32* %38
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds float*, float** %1363, i64 %1365
%1367 = load float*, float** %1366
%1368 = load i32, i32* %40
%1369 = sext i32 %1368 to i64
%1370 = getelementptr inbounds float, float* %1367, i64 %1369
store float %1362, float* %1370
%1371 = load float**, float*** %23
%1372 = getelementptr inbounds float*, float** %1371, i64 1
%1373 = load float*, float** %1372
%1374 = load i32, i32* %38
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds float, float* %1373, i64 %1375
%1377 = load float, float* %1376
%1378 = load i32, i32* %39
%1379 = sitofp i32 %1378 to float
%1380 = load float, float* %30
%1381 = call float @llvm.fmuladd.f32(float %1379, float %1380, float %1377)
%1382 = load float**, float*** %19
%1383 = load i32, i32* %38
%1384 = sext i32 %1383 to i64
%1385 = getelementptr inbounds float*, float** %1382, i64 %1384
%1386 = load float*, float** %1385
%1387 = load i32, i32* %40
%1388 = sext i32 %1387 to i64
%1389 = getelementptr inbounds float, float* %1386, i64 %1388
store float %1381, float* %1389
%1390 = load float**, float*** %24
%1391 = getelementptr inbounds float*, float** %1390, i64 1
%1392 = load float*, float** %1391
%1393 = load i32, i32* %38
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds float, float* %1392, i64 %1394
%1396 = load float, float* %1395
%1397 = load i32, i32* %39
%1398 = sitofp i32 %1397 to float
%1399 = load float, float* %31
%1400 = call float @llvm.fmuladd.f32(float %1398, float %1399, float %1396)
%1401 = load float**, float*** %20
%1402 = load i32, i32* %38
%1403 = sext i32 %1402 to i64
%1404 = getelementptr inbounds float*, float** %1401, i64 %1403
%1405 = load float*, float** %1404
%1406 = load i32, i32* %40
%1407 = sext i32 %1406 to i64
%1408 = getelementptr inbounds float, float* %1405, i64 %1407
store float %1400, float* %1408
br label %1409
1409: ; preds = %1351
%1410 = load i32, i32* %40
%1411 = add nsw i32 %1410, 1
store i32 %1411, i32* %40
%1412 = load i32, i32* %39
%1413 = add nsw i32 %1412, 1
store i32 %1413, i32* %39
br label %1347
1414: ; preds = %1347
br label %1415
1415: ; preds = %1414
%1416 = load i32, i32* %38
%1417 = add nsw i32 %1416, 1
store i32 %1417, i32* %38
br label %1176
1418: ; preds = %1176
br label %1506
1419: ; preds = %1150
%1420 = load i32, i32* %27
%1421 = icmp eq i32 %1420, 3
br i1 %1421, label %1422, label %1505
1422: ; preds = %1419
%1423 = load i32, i32* %25
store i32 %1423, i32* %38
br label %1424
1424: ; preds = %1501, %1422
%1425 = load i32, i32* %38
%1426 = load i32, i32* %26
%1427 = icmp slt i32 %1425, %1426
br i1 %1427, label %1428, label %1504
1428: ; preds = %1424
store i32 0, i32* %40
store i32 0, i32* %39
br label %1429
1429: ; preds = %1495, %1428
%1430 = load i32, i32* %40
%1431 = load i32*, i32** %21
%1432 = load i32, i32* %38
%1433 = sext i32 %1432 to i64
%1434 = getelementptr inbounds i32, i32* %1431, i64 %1433
%1435 = load i32, i32* %1434
%1436 = icmp slt i32 %1430, %1435
br i1 %1436, label %1437, label %1500
1437: ; preds = %1429
%1438 = load float**, float*** %22
%1439 = getelementptr inbounds float*, float** %1438, i64 1
%1440 = load float*, float** %1439
%1441 = load i32, i32* %38
%1442 = sext i32 %1441 to i64
%1443 = getelementptr inbounds float, float* %1440, i64 %1442
%1444 = load float, float* %1443
%1445 = load i32, i32* %39
%1446 = sitofp i32 %1445 to float
%1447 = load float, float* %29
%1448 = call float @llvm.fmuladd.f32(float %1446, float %1447, float %1444)
%1449 = load float**, float*** %18
%1450 = load i32, i32* %38
%1451 = sext i32 %1450 to i64
%1452 = getelementptr inbounds float*, float** %1449, i64 %1451
%1453 = load float*, float** %1452
%1454 = load i32, i32* %40
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds float, float* %1453, i64 %1455
store float %1448, float* %1456
%1457 = load float**, float*** %23
%1458 = getelementptr inbounds float*, float** %1457, i64 1
%1459 = load float*, float** %1458
%1460 = load i32, i32* %38
%1461 = sext i32 %1460 to i64
%1462 = getelementptr inbounds float, float* %1459, i64 %1461
%1463 = load float, float* %1462
%1464 = load i32, i32* %39
%1465 = sitofp i32 %1464 to float
%1466 = load float, float* %30
%1467 = call float @llvm.fmuladd.f32(float %1465, float %1466, float %1463)
%1468 = load float**, float*** %19
%1469 = load i32, i32* %38
%1470 = sext i32 %1469 to i64
%1471 = getelementptr inbounds float*, float** %1468, i64 %1470
%1472 = load float*, float** %1471
%1473 = load i32, i32* %40
%1474 = sext i32 %1473 to i64
%1475 = getelementptr inbounds float, float* %1472, i64 %1474
store float %1467, float* %1475
%1476 = load float**, float*** %24
%1477 = getelementptr inbounds float*, float** %1476, i64 1
%1478 = load float*, float** %1477
%1479 = load i32, i32* %38
%1480 = sext i32 %1479 to i64
%1481 = getelementptr inbounds float, float* %1478, i64 %1480
%1482 = load float, float* %1481
%1483 = load i32, i32* %39
%1484 = sitofp i32 %1483 to float
%1485 = load float, float* %31
%1486 = call float @llvm.fmuladd.f32(float %1484, float %1485, float %1482)
%1487 = load float**, float*** %20
%1488 = load i32, i32* %38
%1489 = sext i32 %1488 to i64
%1490 = getelementptr inbounds float*, float** %1487, i64 %1489
%1491 = load float*, float** %1490
%1492 = load i32, i32* %40
%1493 = sext i32 %1492 to i64
%1494 = getelementptr inbounds float, float* %1491, i64 %1493
store float %1486, float* %1494
br label %1495
1495: ; preds = %1437
%1496 = load i32, i32* %40
%1497 = add nsw i32 %1496, 1
store i32 %1497, i32* %40
%1498 = load i32, i32* %39
%1499 = add nsw i32 %1498, 1
store i32 %1499, i32* %39
br label %1429
1500: ; preds = %1429
br label %1501
1501: ; preds = %1500
%1502 = load i32, i32* %38
%1503 = add nsw i32 %1502, 1
store i32 %1503, i32* %38
br label %1424
1504: ; preds = %1424
br label %1505
1505: ; preds = %1504, %1419
br label %1506
1506: ; preds = %1505, %1418
br label %1507
1507: ; preds = %1506, %1149
br label %1508
1508: ; preds = %1507, %892, %404
ret void
}

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