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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int sqrtf(float);
void compute(float array0[66][66], float array1[66][66], float array2[66][66],
             float u0[66][66], float res[66][66], float n1, float n2) {
  float mu = 0.18 * 255 * 255;
  float lambda1 = 1.0;
  float lambda2 = 1.0;
  float dx = 1.0;
  float dy = 1.0;
  float dz = 1.0;
  float dx2 = 2.0;
  float dy2 = 2.0;
  float dz2 = 2.0;
  float c1 = n1, c2 = n2;
  int j, k;
  for (j = 1; j < 66 - 1; j++) {
    for (k = 1; k < 66 - 1; k++) {
      float Dx_p = (array1[j + 1][k] - array1[j][k]) / dx;
      float Dx_m = (array1[j][k] - array1[j - 1][k]) / dx;
      float Dy_p = (array2[j][k] - array1[j][k]) / dy;
      float Dy_m = (array1[j][k] - array0[j][k]) / dy;
      float Dz_p = (array1[j][k + 1] - array1[j][k]) / dz;
      float Dz_m = (array1[j][k] - array1[j][k - 1]) / dz;
      float Dx_0 = (array1[j + 1][k] - array1[j - 1][k]) / dx2;
      float Dy_0 = (array2[j][k] - array0[j][k]) / dy2;
      float Dz_0 = (array1[j][k + 1] - array1[j][k - 1]) / dz2;
      float Dxx = (Dx_p - Dx_m) / dx;
      float Dyy = (Dy_p - Dy_m) / dy;
      float Dzz = (Dz_p - Dz_m) / dz;
      float Dxy = (array2[j + 1][k] - array0[j + 1][k] - array2[j - 1][k] +
                   array0[j - 1][k]) /
                  (4 * dx * dy);
      float Dxz = (array1[j + 1][k + 1] - array1[j + 1][k - 1] -
                   array1[j - 1][k + 1] + array1[j - 1][k - 1]) /
                  (4 * dx * dz);
      float Dyz = (array2[j][k + 1] - array2[j][k - 1] - array0[j][k + 1] +
                   array0[j][k - 1]) /
                  (4 * dy * dz);
      float K =
          (Dx_0 * Dx_0 * Dyy - 2.0f * Dx_0 * Dy_0 * Dxy + Dy_0 * Dy_0 * Dxx +
           Dx_0 * Dx_0 * Dzz - 2.0f * Dx_0 * Dz_0 * Dxz + Dz_0 * Dz_0 * Dxx +
           Dy_0 * Dy_0 * Dzz - 2.0f * Dy_0 * Dz_0 * Dyz + Dz_0 * Dz_0 * Dyy) /
          (sqrtf((Dx_0 * Dx_0 + Dy_0 * Dy_0 + Dz_0 * Dz_0) *
                 (Dx_0 * Dx_0 + Dy_0 * Dy_0 + Dz_0 * Dz_0) *
                 (Dx_0 * Dx_0 + Dy_0 * Dy_0 + Dz_0 * Dz_0)) +
           10e-10);
      float Grad = sqrtf(Dx_0 * Dx_0 + Dy_0 * Dy_0 + Dz_0 * Dz_0);
      res[j][k] = Grad * (mu * K + lambda1 * (u0[j][k] - c1) * (u0[j][k] - c1) -
                          lambda2 * (u0[j][k] - c2) * (u0[j][k] - c2));
    }
  }
}


x86 assembly (clang, -O0):
<compute>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movss  0xec7(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xeb6(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xea9(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xe9c(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xe8f(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xe82(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe71(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xe64(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xe57(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x1,-0x60(%rbp)
cmpl   $0x41,-0x60(%rbp)
jge    1a0c <compute+0x8fc>
movl   $0x1,-0x64(%rbp)
cmpl   $0x41,-0x64(%rbp)
jge    19f9 <compute+0x8e9>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x68(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
divss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x70(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xaed(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xa3b(%rip),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0x99d(%rip),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
movss  -0x90(%rbp),%xmm2
ff
movss  0x961(%rip),%xmm0
mulss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  -0x98(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x80(%rbp),%xmm1
mulss  -0x80(%rbp),%xmm1
movss  -0x94(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x8f5(%rip),%xmm0
mulss  -0x80(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  -0x9c(%rbp),%xmm2
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x8c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x883(%rip),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0xa0(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x80(%rbp),%xmm3
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  -0x80(%rbp),%xmm2
movss  -0x80(%rbp),%xmm3
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movsd  -0xb0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
movsd  0x76b(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x88(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  -0x34(%rbp),%xmm2
movss  -0xa4(%rbp),%xmm3
ff
movss  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
subss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
subss  -0x58(%rbp),%xmm4
mulss  %xmm4,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x3c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
subss  -0x5c(%rbp),%xmm3
mulss  %xmm3,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
subss  -0x5c(%rbp),%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x60(%rbp),%rcx
imul   $0x108,%rcx,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11da <compute+0xca>
jmp    19fe <compute+0x8ee>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11c9 <compute+0xb9>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r12
mov    %rsi,%rbx
mov    %rdi,%r13
add    $0x10c,%r14
add    $0x10c,%r15
add    $0x4,%r13
add    $0x4,%r12
add    $0x218,%rbx
mov    $0x1,%eax
movss  0xea8(%rip),%xmm11
movss  0xea3(%rip),%xmm12
movss  0xe9e(%rip),%xmm13
movss  %xmm1,0x18(%rsp)
movss  %xmm0,0x14(%rsp)
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %rax,0x20(%rsp)
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rbx,%rbp,1),%xmm3
movss  -0x10c(%rbx,%rbp,1),%xmm6
ff ff
movaps %xmm3,%xmm10
subss  %xmm6,%xmm10
movss  -0x214(%rbx,%rbp,1),%xmm4
ff ff
movss  -0x110(%rbx,%rbp,1),%xmm1
ff ff
movaps %xmm6,%xmm2
subss  %xmm4,%xmm2
subss  %xmm2,%xmm10
movss  0x108(%r12,%rbp,1),%xmm2
movss  0x10c(%r12,%rbp,1),%xmm9
movaps %xmm2,%xmm14
subss  %xmm6,%xmm14
movss  0x108(%r13,%rbp,1),%xmm7
movaps %xmm6,%xmm5
subss  %xmm7,%xmm5
subss  %xmm5,%xmm14
movss  -0x108(%rbx,%rbp,1),%xmm8
movaps %xmm8,%xmm5
subss  %xmm6,%xmm5
subss  %xmm1,%xmm6
subss  %xmm6,%xmm5
subss  %xmm4,%xmm3
mulss  %xmm11,%xmm3
subss  %xmm7,%xmm2
mulss  %xmm11,%xmm2
subss  %xmm1,%xmm8
mulss  %xmm11,%xmm8
movss  0x210(%r12,%rbp,1),%xmm4
subss  0x210(%r13,%rbp,1),%xmm4
subss  (%r12,%rbp,1),%xmm4
addss  0x0(%r13,%rbp,1),%xmm4
mulss  %xmm12,%xmm4
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm13,%xmm3
movaps %xmm3,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
movaps %xmm2,%xmm4
mulss  %xmm2,%xmm4
movaps %xmm4,%xmm0
movaps %xmm1,%xmm7
mulss  %xmm5,%xmm7
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm4
mulss  %xmm14,%xmm1
addss  %xmm6,%xmm1
movss  (%rbx,%rbp,1),%xmm6
subss  -0x8(%rbx,%rbp,1),%xmm6
subss  -0x210(%rbx,%rbp,1),%xmm6
ff ff
addss  -0x218(%rbx,%rbp,1),%xmm6
ff ff
subss  0x104(%r12,%rbp,1),%xmm9
subss  0x10c(%r13,%rbp,1),%xmm9
mulss  %xmm12,%xmm6
addss  0x104(%r13,%rbp,1),%xmm9
mulss  %xmm12,%xmm9
mulss  %xmm10,%xmm0
addss  %xmm1,%xmm0
addss  %xmm0,%xmm7
mulss  %xmm8,%xmm3
mulss  %xmm6,%xmm3
addss  %xmm7,%xmm3
mulss  %xmm13,%xmm2
mulss  %xmm8,%xmm2
mulss  %xmm8,%xmm8
mulss  %xmm8,%xmm10
addss  %xmm3,%xmm10
addss  %xmm10,%xmm5
mulss  %xmm9,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm8,%xmm14
addss  %xmm2,%xmm14
xorps  %xmm0,%xmm0
cvtss2sd %xmm14,%xmm0
movsd  %xmm0,0x8(%rsp)
addss  %xmm8,%xmm4
movss  %xmm4,0x1c(%rsp)
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm4,%xmm0
call   1030 <sqrtf@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0xcba(%rip),%xmm0
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x1c(%rsp),%xmm0
call   1030 <sqrtf@plt>
movss  0xc8c(%rip),%xmm1
movss  0xc7f(%rip),%xmm13
movss  0xc72(%rip),%xmm12
movss  0xc65(%rip),%xmm11
movss  0x14(%rsp),%xmm0
xorps  %xmm4,%xmm4
cvtsi2ss %eax,%xmm4
movss  (%r15,%rbp,1),%xmm3
movaps %xmm3,%xmm2
subss  %xmm0,%xmm2
mulss  %xmm2,%xmm2
movss  0x8(%rsp),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm2,%xmm5
movss  0x18(%rsp),%xmm1
subss  %xmm1,%xmm3
mulss  %xmm3,%xmm3
subss  %xmm3,%xmm5
mulss  %xmm4,%xmm5
movss  %xmm5,(%r14,%rbp,1)
add    $0x4,%rbp
cmp    $0x100,%rbp
jne    1190 <compute+0x80>
add    $0x108,%r14
add    $0x108,%r15
add    $0x108,%r13
add    $0x108,%r12
add    $0x108,%rbx
mov    0x20(%rsp),%rax
cmp    $0x41,%rax
jne    1180 <compute+0x70>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @compute([66 x float]* %0, [66 x float]* %1, [66 x float]* %2, [66 x float]* %3, [66 x float]* %4, float %5, float %6) {
%8 = alloca [66 x float]*
%9 = alloca [66 x float]*
%10 = alloca [66 x float]*
%11 = alloca [66 x float]*
%12 = alloca [66 x float]*
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca i32
%27 = alloca i32
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
store [66 x float]* %0, [66 x float]** %8
store [66 x float]* %1, [66 x float]** %9
store [66 x float]* %2, [66 x float]** %10
store [66 x float]* %3, [66 x float]** %11
store [66 x float]* %4, [66 x float]** %12
store float %5, float* %13
store float %6, float* %14
store float 1.170450e+04, float* %15
store float 1.000000e+00, float* %16
store float 1.000000e+00, float* %17
store float 1.000000e+00, float* %18
store float 1.000000e+00, float* %19
store float 1.000000e+00, float* %20
store float 2.000000e+00, float* %21
store float 2.000000e+00, float* %22
store float 2.000000e+00, float* %23
%45 = load float, float* %13
store float %45, float* %24
%46 = load float, float* %14
store float %46, float* %25
store i32 1, i32* %26
br label %47
47: ; preds = %545, %7
%48 = load i32, i32* %26
%49 = icmp slt i32 %48, 65
br i1 %49, label %50, label %548
50: ; preds = %47
store i32 1, i32* %27
br label %51
51: ; preds = %541, %50
%52 = load i32, i32* %27
%53 = icmp slt i32 %52, 65
br i1 %53, label %54, label %544
54: ; preds = %51
%55 = load [66 x float]*, [66 x float]** %9
%56 = load i32, i32* %26
%57 = add nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [66 x float], [66 x float]* %55, i64 %58
%60 = load i32, i32* %27
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [66 x float], [66 x float]* %59, i64 0, i64 %61
%63 = load float, float* %62
%64 = load [66 x float]*, [66 x float]** %9
%65 = load i32, i32* %26
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [66 x float], [66 x float]* %64, i64 %66
%68 = load i32, i32* %27
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [66 x float], [66 x float]* %67, i64 0, i64 %69
%71 = load float, float* %70
%72 = fsub float %63, %71
%73 = load float, float* %18
%74 = fdiv float %72, %73
store float %74, float* %28
%75 = load [66 x float]*, [66 x float]** %9
%76 = load i32, i32* %26
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [66 x float], [66 x float]* %75, i64 %77
%79 = load i32, i32* %27
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [66 x float], [66 x float]* %78, i64 0, i64 %80
%82 = load float, float* %81
%83 = load [66 x float]*, [66 x float]** %9
%84 = load i32, i32* %26
%85 = sub nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [66 x float], [66 x float]* %83, i64 %86
%88 = load i32, i32* %27
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [66 x float], [66 x float]* %87, i64 0, i64 %89
%91 = load float, float* %90
%92 = fsub float %82, %91
%93 = load float, float* %18
%94 = fdiv float %92, %93
store float %94, float* %29
%95 = load [66 x float]*, [66 x float]** %10
%96 = load i32, i32* %26
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [66 x float], [66 x float]* %95, i64 %97
%99 = load i32, i32* %27
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [66 x float], [66 x float]* %98, i64 0, i64 %100
%102 = load float, float* %101
%103 = load [66 x float]*, [66 x float]** %9
%104 = load i32, i32* %26
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [66 x float], [66 x float]* %103, i64 %105
%107 = load i32, i32* %27
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [66 x float], [66 x float]* %106, i64 0, i64 %108
%110 = load float, float* %109
%111 = fsub float %102, %110
%112 = load float, float* %19
%113 = fdiv float %111, %112
store float %113, float* %30
%114 = load [66 x float]*, [66 x float]** %9
%115 = load i32, i32* %26
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [66 x float], [66 x float]* %114, i64 %116
%118 = load i32, i32* %27
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [66 x float], [66 x float]* %117, i64 0, i64 %119
%121 = load float, float* %120
%122 = load [66 x float]*, [66 x float]** %8
%123 = load i32, i32* %26
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [66 x float], [66 x float]* %122, i64 %124
%126 = load i32, i32* %27
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [66 x float], [66 x float]* %125, i64 0, i64 %127
%129 = load float, float* %128
%130 = fsub float %121, %129
%131 = load float, float* %19
%132 = fdiv float %130, %131
store float %132, float* %31
%133 = load [66 x float]*, [66 x float]** %9
%134 = load i32, i32* %26
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [66 x float], [66 x float]* %133, i64 %135
%137 = load i32, i32* %27
%138 = add nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [66 x float], [66 x float]* %136, i64 0, i64 %139
%141 = load float, float* %140
%142 = load [66 x float]*, [66 x float]** %9
%143 = load i32, i32* %26
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [66 x float], [66 x float]* %142, i64 %144
%146 = load i32, i32* %27
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [66 x float], [66 x float]* %145, i64 0, i64 %147
%149 = load float, float* %148
%150 = fsub float %141, %149
%151 = load float, float* %20
%152 = fdiv float %150, %151
store float %152, float* %32
%153 = load [66 x float]*, [66 x float]** %9
%154 = load i32, i32* %26
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [66 x float], [66 x float]* %153, i64 %155
%157 = load i32, i32* %27
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [66 x float], [66 x float]* %156, i64 0, i64 %158
%160 = load float, float* %159
%161 = load [66 x float]*, [66 x float]** %9
%162 = load i32, i32* %26
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [66 x float], [66 x float]* %161, i64 %163
%165 = load i32, i32* %27
%166 = sub nsw i32 %165, 1
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [66 x float], [66 x float]* %164, i64 0, i64 %167
%169 = load float, float* %168
%170 = fsub float %160, %169
%171 = load float, float* %20
%172 = fdiv float %170, %171
store float %172, float* %33
%173 = load [66 x float]*, [66 x float]** %9
%174 = load i32, i32* %26
%175 = add nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [66 x float], [66 x float]* %173, i64 %176
%178 = load i32, i32* %27
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [66 x float], [66 x float]* %177, i64 0, i64 %179
%181 = load float, float* %180
%182 = load [66 x float]*, [66 x float]** %9
%183 = load i32, i32* %26
%184 = sub nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [66 x float], [66 x float]* %182, i64 %185
%187 = load i32, i32* %27
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [66 x float], [66 x float]* %186, i64 0, i64 %188
%190 = load float, float* %189
%191 = fsub float %181, %190
%192 = load float, float* %21
%193 = fdiv float %191, %192
store float %193, float* %34
%194 = load [66 x float]*, [66 x float]** %10
%195 = load i32, i32* %26
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [66 x float], [66 x float]* %194, i64 %196
%198 = load i32, i32* %27
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [66 x float], [66 x float]* %197, i64 0, i64 %199
%201 = load float, float* %200
%202 = load [66 x float]*, [66 x float]** %8
%203 = load i32, i32* %26
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [66 x float], [66 x float]* %202, i64 %204
%206 = load i32, i32* %27
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [66 x float], [66 x float]* %205, i64 0, i64 %207
%209 = load float, float* %208
%210 = fsub float %201, %209
%211 = load float, float* %22
%212 = fdiv float %210, %211
store float %212, float* %35
%213 = load [66 x float]*, [66 x float]** %9
%214 = load i32, i32* %26
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [66 x float], [66 x float]* %213, i64 %215
%217 = load i32, i32* %27
%218 = add nsw i32 %217, 1
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [66 x float], [66 x float]* %216, i64 0, i64 %219
%221 = load float, float* %220
%222 = load [66 x float]*, [66 x float]** %9
%223 = load i32, i32* %26
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [66 x float], [66 x float]* %222, i64 %224
%226 = load i32, i32* %27
%227 = sub nsw i32 %226, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [66 x float], [66 x float]* %225, i64 0, i64 %228
%230 = load float, float* %229
%231 = fsub float %221, %230
%232 = load float, float* %23
%233 = fdiv float %231, %232
store float %233, float* %36
%234 = load float, float* %28
%235 = load float, float* %29
%236 = fsub float %234, %235
%237 = load float, float* %18
%238 = fdiv float %236, %237
store float %238, float* %37
%239 = load float, float* %30
%240 = load float, float* %31
%241 = fsub float %239, %240
%242 = load float, float* %19
%243 = fdiv float %241, %242
store float %243, float* %38
%244 = load float, float* %32
%245 = load float, float* %33
%246 = fsub float %244, %245
%247 = load float, float* %20
%248 = fdiv float %246, %247
store float %248, float* %39
%249 = load [66 x float]*, [66 x float]** %10
%250 = load i32, i32* %26
%251 = add nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds [66 x float], [66 x float]* %249, i64 %252
%254 = load i32, i32* %27
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [66 x float], [66 x float]* %253, i64 0, i64 %255
%257 = load float, float* %256
%258 = load [66 x float]*, [66 x float]** %8
%259 = load i32, i32* %26
%260 = add nsw i32 %259, 1
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [66 x float], [66 x float]* %258, i64 %261
%263 = load i32, i32* %27
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [66 x float], [66 x float]* %262, i64 0, i64 %264
%266 = load float, float* %265
%267 = fsub float %257, %266
%268 = load [66 x float]*, [66 x float]** %10
%269 = load i32, i32* %26
%270 = sub nsw i32 %269, 1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds [66 x float], [66 x float]* %268, i64 %271
%273 = load i32, i32* %27
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [66 x float], [66 x float]* %272, i64 0, i64 %274
%276 = load float, float* %275
%277 = fsub float %267, %276
%278 = load [66 x float]*, [66 x float]** %8
%279 = load i32, i32* %26
%280 = sub nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [66 x float], [66 x float]* %278, i64 %281
%283 = load i32, i32* %27
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds [66 x float], [66 x float]* %282, i64 0, i64 %284
%286 = load float, float* %285
%287 = fadd float %277, %286
%288 = load float, float* %18
%289 = fmul float 4.000000e+00, %288
%290 = load float, float* %19
%291 = fmul float %289, %290
%292 = fdiv float %287, %291
store float %292, float* %40
%293 = load [66 x float]*, [66 x float]** %9
%294 = load i32, i32* %26
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [66 x float], [66 x float]* %293, i64 %296
%298 = load i32, i32* %27
%299 = add nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [66 x float], [66 x float]* %297, i64 0, i64 %300
%302 = load float, float* %301
%303 = load [66 x float]*, [66 x float]** %9
%304 = load i32, i32* %26
%305 = add nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [66 x float], [66 x float]* %303, i64 %306
%308 = load i32, i32* %27
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds [66 x float], [66 x float]* %307, i64 0, i64 %310
%312 = load float, float* %311
%313 = fsub float %302, %312
%314 = load [66 x float]*, [66 x float]** %9
%315 = load i32, i32* %26
%316 = sub nsw i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [66 x float], [66 x float]* %314, i64 %317
%319 = load i32, i32* %27
%320 = add nsw i32 %319, 1
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [66 x float], [66 x float]* %318, i64 0, i64 %321
%323 = load float, float* %322
%324 = fsub float %313, %323
%325 = load [66 x float]*, [66 x float]** %9
%326 = load i32, i32* %26
%327 = sub nsw i32 %326, 1
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds [66 x float], [66 x float]* %325, i64 %328
%330 = load i32, i32* %27
%331 = sub nsw i32 %330, 1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [66 x float], [66 x float]* %329, i64 0, i64 %332
%334 = load float, float* %333
%335 = fadd float %324, %334
%336 = load float, float* %18
%337 = fmul float 4.000000e+00, %336
%338 = load float, float* %20
%339 = fmul float %337, %338
%340 = fdiv float %335, %339
store float %340, float* %41
%341 = load [66 x float]*, [66 x float]** %10
%342 = load i32, i32* %26
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [66 x float], [66 x float]* %341, i64 %343
%345 = load i32, i32* %27
%346 = add nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [66 x float], [66 x float]* %344, i64 0, i64 %347
%349 = load float, float* %348
%350 = load [66 x float]*, [66 x float]** %10
%351 = load i32, i32* %26
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [66 x float], [66 x float]* %350, i64 %352
%354 = load i32, i32* %27
%355 = sub nsw i32 %354, 1
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [66 x float], [66 x float]* %353, i64 0, i64 %356
%358 = load float, float* %357
%359 = fsub float %349, %358
%360 = load [66 x float]*, [66 x float]** %8
%361 = load i32, i32* %26
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [66 x float], [66 x float]* %360, i64 %362
%364 = load i32, i32* %27
%365 = add nsw i32 %364, 1
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds [66 x float], [66 x float]* %363, i64 0, i64 %366
%368 = load float, float* %367
%369 = fsub float %359, %368
%370 = load [66 x float]*, [66 x float]** %8
%371 = load i32, i32* %26
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [66 x float], [66 x float]* %370, i64 %372
%374 = load i32, i32* %27
%375 = sub nsw i32 %374, 1
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [66 x float], [66 x float]* %373, i64 0, i64 %376
%378 = load float, float* %377
%379 = fadd float %369, %378
%380 = load float, float* %19
%381 = fmul float 4.000000e+00, %380
%382 = load float, float* %20
%383 = fmul float %381, %382
%384 = fdiv float %379, %383
store float %384, float* %42
%385 = load float, float* %34
%386 = load float, float* %34
%387 = fmul float %385, %386
%388 = load float, float* %38
%389 = load float, float* %34
%390 = fmul float 2.000000e+00, %389
%391 = load float, float* %35
%392 = fmul float %390, %391
%393 = load float, float* %40
%394 = fmul float %392, %393
%395 = fneg float %394
%396 = call float @llvm.fmuladd.f32(float %387, float %388, float %395)
%397 = load float, float* %35
%398 = load float, float* %35
%399 = fmul float %397, %398
%400 = load float, float* %37
%401 = call float @llvm.fmuladd.f32(float %399, float %400, float %396)
%402 = load float, float* %34
%403 = load float, float* %34
%404 = fmul float %402, %403
%405 = load float, float* %39
%406 = call float @llvm.fmuladd.f32(float %404, float %405, float %401)
%407 = load float, float* %34
%408 = fmul float 2.000000e+00, %407
%409 = load float, float* %36
%410 = fmul float %408, %409
%411 = load float, float* %41
%412 = fneg float %410
%413 = call float @llvm.fmuladd.f32(float %412, float %411, float %406)
%414 = load float, float* %36
%415 = load float, float* %36
%416 = fmul float %414, %415
%417 = load float, float* %37
%418 = call float @llvm.fmuladd.f32(float %416, float %417, float %413)
%419 = load float, float* %35
%420 = load float, float* %35
%421 = fmul float %419, %420
%422 = load float, float* %39
%423 = call float @llvm.fmuladd.f32(float %421, float %422, float %418)
%424 = load float, float* %35
%425 = fmul float 2.000000e+00, %424
%426 = load float, float* %36
%427 = fmul float %425, %426
%428 = load float, float* %42
%429 = fneg float %427
%430 = call float @llvm.fmuladd.f32(float %429, float %428, float %423)
%431 = load float, float* %36
%432 = load float, float* %36
%433 = fmul float %431, %432
%434 = load float, float* %38
%435 = call float @llvm.fmuladd.f32(float %433, float %434, float %430)
%436 = fpext float %435 to double
%437 = load float, float* %34
%438 = load float, float* %34
%439 = load float, float* %35
%440 = load float, float* %35
%441 = fmul float %439, %440
%442 = call float @llvm.fmuladd.f32(float %437, float %438, float %441)
%443 = load float, float* %36
%444 = load float, float* %36
%445 = call float @llvm.fmuladd.f32(float %443, float %444, float %442)
%446 = load float, float* %34
%447 = load float, float* %34
%448 = load float, float* %35
%449 = load float, float* %35
%450 = fmul float %448, %449
%451 = call float @llvm.fmuladd.f32(float %446, float %447, float %450)
%452 = load float, float* %36
%453 = load float, float* %36
%454 = call float @llvm.fmuladd.f32(float %452, float %453, float %451)
%455 = fmul float %445, %454
%456 = load float, float* %34
%457 = load float, float* %34
%458 = load float, float* %35
%459 = load float, float* %35
%460 = fmul float %458, %459
%461 = call float @llvm.fmuladd.f32(float %456, float %457, float %460)
%462 = load float, float* %36
%463 = load float, float* %36
%464 = call float @llvm.fmuladd.f32(float %462, float %463, float %461)
%465 = fmul float %455, %464
%466 = call i32 @sqrtf(float %465)
%467 = sitofp i32 %466 to double
%468 = fadd double %467, 1.000000e-09
%469 = fdiv double %436, %468
%470 = fptrunc double %469 to float
store float %470, float* %43
%471 = load float, float* %34
%472 = load float, float* %34
%473 = load float, float* %35
%474 = load float, float* %35
%475 = fmul float %473, %474
%476 = call float @llvm.fmuladd.f32(float %471, float %472, float %475)
%477 = load float, float* %36
%478 = load float, float* %36
%479 = call float @llvm.fmuladd.f32(float %477, float %478, float %476)
%480 = call i32 @sqrtf(float %479)
%481 = sitofp i32 %480 to float
store float %481, float* %44
%482 = load float, float* %44
%483 = load float, float* %15
%484 = load float, float* %43
%485 = load float, float* %16
%486 = load [66 x float]*, [66 x float]** %11
%487 = load i32, i32* %26
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [66 x float], [66 x float]* %486, i64 %488
%490 = load i32, i32* %27
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds [66 x float], [66 x float]* %489, i64 0, i64 %491
%493 = load float, float* %492
%494 = load float, float* %24
%495 = fsub float %493, %494
%496 = fmul float %485, %495
%497 = load [66 x float]*, [66 x float]** %11
%498 = load i32, i32* %26
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds [66 x float], [66 x float]* %497, i64 %499
%501 = load i32, i32* %27
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds [66 x float], [66 x float]* %500, i64 0, i64 %502
%504 = load float, float* %503
%505 = load float, float* %24
%506 = fsub float %504, %505
%507 = fmul float %496, %506
%508 = call float @llvm.fmuladd.f32(float %483, float %484, float %507)
%509 = load float, float* %17
%510 = load [66 x float]*, [66 x float]** %11
%511 = load i32, i32* %26
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds [66 x float], [66 x float]* %510, i64 %512
%514 = load i32, i32* %27
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds [66 x float], [66 x float]* %513, i64 0, i64 %515
%517 = load float, float* %516
%518 = load float, float* %25
%519 = fsub float %517, %518
%520 = fmul float %509, %519
%521 = load [66 x float]*, [66 x float]** %11
%522 = load i32, i32* %26
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [66 x float], [66 x float]* %521, i64 %523
%525 = load i32, i32* %27
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds [66 x float], [66 x float]* %524, i64 0, i64 %526
%528 = load float, float* %527
%529 = load float, float* %25
%530 = fsub float %528, %529
%531 = fneg float %520
%532 = call float @llvm.fmuladd.f32(float %531, float %530, float %508)
%533 = fmul float %482, %532
%534 = load [66 x float]*, [66 x float]** %12
%535 = load i32, i32* %26
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds [66 x float], [66 x float]* %534, i64 %536
%538 = load i32, i32* %27
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds [66 x float], [66 x float]* %537, i64 0, i64 %539
store float %533, float* %540
br label %541
541: ; preds = %54
%542 = load i32, i32* %27
%543 = add nsw i32 %542, 1
store i32 %543, i32* %27
br label %51
544: ; preds = %51
br label %545
545: ; preds = %544
%546 = load i32, i32* %26
%547 = add nsw i32 %546, 1
store i32 %547, i32* %26
br label %47
548: ; preds = %47
ret void
}

LLVM IR (-O2):
define void @compute([66 x float]* nocapture %0, [66 x float]* nocapture %1, [66 x float]* nocapture %2, [66 x float]* nocapture %3, [66 x float]* nocapture writeonly %4, float %5, float %6) {
br label %8
8: ; preds = %7, %121
%9 = phi i64 [ 1, %7 ], [ %10, %121 ]
%10 = add nuw nsw i64 %9, 1
%11 = add nsw i64 %9, -1
br label %12
12: ; preds = %8, %12
%13 = phi i64 [ 1, %8 ], [ %28, %12 ]
%14 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %10, i64 %13
%15 = load float, float* %14
%16 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %9, i64 %13
%17 = load float, float* %16
%18 = fsub float %15, %17
%19 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %11, i64 %13
%20 = load float, float* %19
%21 = fsub float %17, %20
%22 = getelementptr inbounds [66 x float], [66 x float]* %2, i64 %9, i64 %13
%23 = load float, float* %22
%24 = fsub float %23, %17
%25 = getelementptr inbounds [66 x float], [66 x float]* %0, i64 %9, i64 %13
%26 = load float, float* %25
%27 = fsub float %17, %26
%28 = add nuw nsw i64 %13, 1
%29 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %9, i64 %28
%30 = load float, float* %29
%31 = fsub float %30, %17
%32 = add nsw i64 %13, -1
%33 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %9, i64 %32
%34 = load float, float* %33
%35 = fsub float %17, %34
%36 = fsub float %15, %20
%37 = fmul float %36, 5.000000e-01
%38 = fsub float %23, %26
%39 = fmul float %38, 5.000000e-01
%40 = fsub float %30, %34
%41 = fmul float %40, 5.000000e-01
%42 = fsub float %18, %21
%43 = fsub float %24, %27
%44 = fsub float %31, %35
%45 = getelementptr inbounds [66 x float], [66 x float]* %2, i64 %10, i64 %13
%46 = load float, float* %45
%47 = getelementptr inbounds [66 x float], [66 x float]* %0, i64 %10, i64 %13
%48 = load float, float* %47
%49 = fsub float %46, %48
%50 = getelementptr inbounds [66 x float], [66 x float]* %2, i64 %11, i64 %13
%51 = load float, float* %50
%52 = fsub float %49, %51
%53 = getelementptr inbounds [66 x float], [66 x float]* %0, i64 %11, i64 %13
%54 = load float, float* %53
%55 = fadd float %52, %54
%56 = fmul float %55, 2.500000e-01
%57 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %10, i64 %28
%58 = load float, float* %57
%59 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %10, i64 %32
%60 = load float, float* %59
%61 = fsub float %58, %60
%62 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %11, i64 %28
%63 = load float, float* %62
%64 = fsub float %61, %63
%65 = getelementptr inbounds [66 x float], [66 x float]* %1, i64 %11, i64 %32
%66 = load float, float* %65
%67 = fadd float %64, %66
%68 = fmul float %67, 2.500000e-01
%69 = getelementptr inbounds [66 x float], [66 x float]* %2, i64 %9, i64 %28
%70 = load float, float* %69
%71 = getelementptr inbounds [66 x float], [66 x float]* %2, i64 %9, i64 %32
%72 = load float, float* %71
%73 = fsub float %70, %72
%74 = getelementptr inbounds [66 x float], [66 x float]* %0, i64 %9, i64 %28
%75 = load float, float* %74
%76 = fsub float %73, %75
%77 = getelementptr inbounds [66 x float], [66 x float]* %0, i64 %9, i64 %32
%78 = load float, float* %77
%79 = fadd float %76, %78
%80 = fmul float %79, 2.500000e-01
%81 = fmul float %37, %37
%82 = fmul float %37, -2.000000e+00
%83 = fmul float %82, %39
%84 = fmul float %83, %56
%85 = tail call float @llvm.fmuladd.f32(float %81, float %43, float %84)
%86 = fmul float %39, %39
%87 = tail call float @llvm.fmuladd.f32(float %86, float %42, float %85)
%88 = tail call float @llvm.fmuladd.f32(float %81, float %44, float %87)
%89 = fmul float %82, %41
%90 = tail call float @llvm.fmuladd.f32(float %89, float %68, float %88)
%91 = fmul float %41, %41
%92 = tail call float @llvm.fmuladd.f32(float %91, float %42, float %90)
%93 = tail call float @llvm.fmuladd.f32(float %86, float %44, float %92)
%94 = fmul float %39, -2.000000e+00
%95 = fmul float %94, %41
%96 = tail call float @llvm.fmuladd.f32(float %95, float %80, float %93)
%97 = tail call float @llvm.fmuladd.f32(float %91, float %43, float %96)
%98 = fpext float %97 to double
%99 = tail call float @llvm.fmuladd.f32(float %37, float %37, float %86)
%100 = tail call float @llvm.fmuladd.f32(float %41, float %41, float %99)
%101 = fmul float %100, %100
%102 = fmul float %100, %101
%103 = tail call i32 @sqrtf(float %102)
%104 = sitofp i32 %103 to double
%105 = fadd double %104, 1.000000e-09
%106 = fdiv double %98, %105
%107 = fptrunc double %106 to float
%108 = tail call i32 @sqrtf(float %100)
%109 = sitofp i32 %108 to float
%110 = getelementptr inbounds [66 x float], [66 x float]* %3, i64 %9, i64 %13
%111 = load float, float* %110
%112 = fsub float %111, %5
%113 = fmul float %112, %112
%114 = tail call float @llvm.fmuladd.f32(float %107, float 1.170450e+04, float %113)
%115 = fsub float %111, %6
%116 = fneg float %115
%117 = tail call float @llvm.fmuladd.f32(float %116, float %115, float %114)
%118 = fmul float %117, %109
%119 = getelementptr inbounds [66 x float], [66 x float]* %4, i64 %9, i64 %13
store float %118, float* %119
%120 = icmp eq i64 %28, 65
br i1 %120, label %121, label %12
121: ; preds = %12
%122 = icmp eq i64 %10, 65
br i1 %122, label %123, label %8
123: ; preds = %121
ret void
}