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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ dx_dz_fill(int, double, double, double *, double *);
int /*<<< orphan*/ dy_dz_fill(double *, double *, double *, double *);
int find_min_proj(double *);
int /*<<< orphan*/ new_xy_axis(int, double *, double *, double *, double *,
                               double *);
int /*<<< orphan*/ r3add(double *, double *);
int /*<<< orphan*/ r3mx(double *, double *, double *);
int /*<<< orphan*/ r3set(double *, double);
double A_grad_z(int l, int m1, int m2, double g[3], double z[3]) {
  r3set(g, 0.0);
  if (l == 0) {
    return 1.0;
  }
  int i_min = find_min_proj(z);
  double xx1, xx2, x[3], y[3];
  new_xy_axis(i_min, &xx1, &xx2, x, y, z);
  double A = 0, dx_dz[9], dy_dz[9];
  dx_dz_fill(i_min, xx1, xx2, z, dx_dz);
  dy_dz_fill(x, z, dx_dz, dy_dz);
  if (l == 1) {
    if (m1 == -1) {
      double dAdy[3] = {};
      if (m2 == -1)
        dAdy[0] = 0.0, dAdy[1] = 1.0, dAdy[2] = 0.0, A = y[1];
      if (m2 == 0)
        dAdy[0] = 0.0, dAdy[1] = 0.0, dAdy[2] = 1.0, A = y[2];
      if (m2 == 1)
        dAdy[0] = 1.0, dAdy[1] = 0.0, dAdy[2] = 0.0, A = y[0];
      r3mx(g, dAdy, dy_dz);
    } else if (m1 == 0) {
      if (m2 == -1)
        g[0] = 0.0, g[1] = 1.0, g[2] = 0.0, A = z[1];
      if (m2 == 0)
        g[0] = 0.0, g[1] = 0.0, g[2] = 1.0, A = z[2];
      if (m2 == 1)
        g[0] = 1.0, g[1] = 0.0, g[2] = 0.0, A = z[0];
    } else if (m1 == 1) {
      double dAdx[3] = {};
      if (m2 == -1)
        dAdx[0] = 0.0, dAdx[1] = 1.0, dAdx[2] = 0.0, A = x[1];
      if (m2 == 0)
        dAdx[0] = 0.0, dAdx[1] = 0.0, dAdx[2] = 1.0, A = x[2];
      if (m2 == 1)
        dAdx[0] = 1.0, dAdx[1] = 0.0, dAdx[2] = 0.0, A = x[0];
      r3mx(g, dAdx, dx_dz);
    }
  } else if (l == 2) {
    if (m1 == -2) {
      double dAdx[3] = {}, dAdy[3] = {}, tmp[3];
      if (m2 == -2)
        dAdx[0] = y[1], dAdx[1] = y[0], dAdx[2] = 0.0, dAdy[0] = x[1],
        dAdy[1] = x[0], dAdy[2] = 0.0, A = x[0] * y[1] + x[1] * y[0];
      if (m2 == -1)
        dAdx[0] = 0.0, dAdx[1] = y[2], dAdx[2] = y[1], dAdy[0] = 0.0,
        dAdy[1] = x[2], dAdy[2] = x[1], A = x[1] * y[2] + x[2] * y[1];
      if (m2 == 0)
        dAdx[0] = 0.0, dAdx[1] = 0.0, dAdx[2] = y[2] * 1.73205080756887729352,
        dAdy[0] = 0.0, dAdy[1] = 0.0, dAdy[2] = x[2] * 1.73205080756887729352,
        A = x[2] * y[2] * 1.73205080756887729352;
      if (m2 == 1)
        dAdx[0] = y[2], dAdx[1] = 0.0, dAdx[2] = y[0], dAdy[0] = x[2],
        dAdy[1] = 0.0, dAdy[2] = x[0], A = x[0] * y[2] + x[2] * y[0];
      if (m2 == 2)
        dAdx[0] = y[0], dAdx[1] = -y[1], dAdx[2] = 0.0, dAdy[0] = x[0],
        dAdy[1] = -x[1], dAdy[2] = 0.0, A = x[0] * y[0] - x[1] * y[1];
      r3mx(g, dAdy, dy_dz);
      r3mx(tmp, dAdx, dx_dz);
      r3add(g, tmp);
    } else if (m1 == -1) {
      double dAdy[3] = {}, tmp[3];
      if (m2 == -2)
        dAdy[0] = z[1], dAdy[1] = z[0], dAdy[2] = 0.0, g[0] = y[1], g[1] = y[0],
        g[2] = 0.0, A = y[0] * z[1] + y[1] * z[0];
      if (m2 == -1)
        dAdy[0] = 0.0, dAdy[1] = z[2], dAdy[2] = z[1], g[0] = 0.0, g[1] = y[2],
        g[2] = y[1], A = y[1] * z[2] + y[2] * z[1];
      if (m2 == 0)
        dAdy[0] = 0.0, dAdy[1] = 0.0, dAdy[2] = z[2] * 1.73205080756887729352,
        g[0] = 0.0, g[1] = 0.0, g[2] = y[2] * 1.73205080756887729352,
        A = y[2] * z[2] * 1.73205080756887729352;
      if (m2 == 1)
        dAdy[0] = z[2], dAdy[1] = 0.0, dAdy[2] = z[0], g[0] = y[2], g[1] = 0.0,
        g[2] = y[0], A = y[0] * z[2] + y[2] * z[0];
      if (m2 == 2)
        dAdy[0] = z[0], dAdy[1] = -z[1], dAdy[2] = 0.0, g[0] = y[0],
        g[1] = -y[1], g[2] = 0.0, A = y[0] * z[0] - y[1] * z[1];
      r3mx(tmp, dAdy, dy_dz);
      r3add(g, tmp);
    } else if (m1 == 0) {
      if (m2 == -2)
        g[0] = 1.73205080756887729352 * z[1],
        g[1] = 1.73205080756887729352 * z[0], g[2] = 0.0,
        A = 1.73205080756887729352 * z[0] * z[1];
      if (m2 == -1)
        g[0] = 0.0, g[1] = 1.73205080756887729352 * z[2],
        g[2] = 1.73205080756887729352 * z[1],
        A = 1.73205080756887729352 * z[1] * z[2];
      if (m2 == 0)
        g[0] = 0.0, g[1] = 0.0, g[2] = 3.0 * z[2], A = 1.5 * z[2] * z[2] - 0.5;
      if (m2 == 1)
        g[0] = 1.73205080756887729352 * z[2], g[1] = 0.0,
        g[2] = 1.73205080756887729352 * z[0],
        A = 1.73205080756887729352 * z[0] * z[2];
      if (m2 == 2)
        g[0] = 0.0, g[1] = -2.0 * 1.73205080756887729352 * z[1],
        g[2] = -1.73205080756887729352 * z[2],
        A = 1.73205080756887729352 * ((1.0 - z[2] * z[2]) * 0.5 - z[1] * z[1]);
    } else if (m1 == 1) {
      double dAdx[3] = {}, tmp[3];
      if (m2 == -2)
        dAdx[0] = z[1], dAdx[1] = z[0], dAdx[2] = 0.0, g[0] = x[1], g[1] = x[0],
        g[2] = 0.0, A = x[0] * z[1] + x[1] * z[0];
      if (m2 == -1)
        dAdx[0] = 0.0, dAdx[1] = z[2], dAdx[2] = z[1], g[0] = 0.0, g[1] = x[2],
        g[2] = x[1], A = x[1] * z[2] + x[2] * z[1];
      if (m2 == 0)
        dAdx[0] = 0.0, dAdx[1] = 0.0, dAdx[2] = z[2] * 1.73205080756887729352,
        g[0] = 0.0, g[1] = 0.0, g[2] = x[2] * 1.73205080756887729352,
        A = x[2] * z[2] * 1.73205080756887729352;
      if (m2 == 1)
        dAdx[0] = z[2], dAdx[1] = 0.0, dAdx[2] = z[0], g[0] = x[2], g[1] = 0.0,
        g[2] = x[0], A = x[0] * z[2] + x[2] * z[0];
      if (m2 == 2)
        dAdx[0] = z[0], dAdx[1] = -z[1], dAdx[2] = 0.0, g[0] = x[0],
        g[1] = -x[1], g[2] = 0.0, A = x[0] * z[0] - x[1] * z[1];
      r3mx(tmp, dAdx, dx_dz);
      r3add(g, tmp);
    } else if (m1 == 2) {
      double dAdx[3] = {}, dAdy[3] = {}, tmp[3];
      if (m2 == -2)
        dAdx[0] = x[1], dAdx[1] = x[0], dAdx[2] = 0.0, dAdy[0] = -y[1],
        dAdy[1] = -y[0], dAdy[2] = 0.0, A = x[0] * x[1] - y[0] * y[1];
      if (m2 == -1)
        dAdx[0] = 0.0, dAdx[1] = x[2], dAdx[2] = x[1], dAdy[0] = 0.0,
        dAdy[1] = -y[2], dAdy[2] = -y[1], A = x[1] * x[2] - y[1] * y[2];
      if (m2 == -0)
        dAdx[0] = 0.0, dAdx[1] = 0.0, dAdx[2] = x[2] * 1.73205080756887729352,
        dAdy[0] = 0.0, dAdy[1] = 0.0, dAdy[2] = -y[2] * 1.73205080756887729352,
        A = (x[2] * x[2] - y[2] * y[2]) * 0.5 * 1.73205080756887729352;
      if (m2 == 1)
        dAdx[0] = x[2], dAdx[1] = 0.0, dAdx[2] = x[0], dAdy[0] = -y[2],
        dAdy[1] = 0.0, dAdy[2] = -y[0], A = x[0] * x[2] - y[0] * y[2];
      if (m2 == 2)
        dAdx[0] = x[0], dAdx[1] = -x[1], dAdx[2] = 0.0, dAdy[0] = -y[0],
        dAdy[1] = y[1], dAdy[2] = 0.0,
        A = (x[0] * x[0] - x[1] * x[1] + y[1] * y[1] - y[0] * y[0]) * 0.5;
      r3mx(g, dAdy, dy_dz);
      r3mx(tmp, dAdx, dx_dz);
      r3add(g, tmp);
    }
  }
  return A;
}


x86 assembly (clang, -O0):
<A_grad_z>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
xorps  %xmm0,%xmm0
call   1070 <r3set@plt>
cmpl   $0x0,-0xc(%rbp)
jne    11c4 <A_grad_z+0x44>
movsd  0x1e6e(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    25c0 <A_grad_z+0x1440>
mov    -0x28(%rbp),%rdi
call   1050 <find_min_proj@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edi
lea    -0x60(%rbp),%rcx
lea    -0x80(%rbp),%r8
mov    -0x28(%rbp),%r9
lea    -0x38(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1090 <new_xy_axis@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x2c(%rbp),%edi
movsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
mov    -0x28(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   10a0 <dx_dz_fill@plt>
lea    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0x120(%rbp),%rcx
call   1060 <dy_dz_fill@plt>
cmpl   $0x1,-0xc(%rbp)
jne    14fa <A_grad_z+0x37a>
cmpl   $0xffffffff,-0x10(%rbp)
jne    1329 <A_grad_z+0x1a9>
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xffffffff,-0x14(%rbp)
jne    1293 <A_grad_z+0x113>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x1db5(%rip),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    12d0 <A_grad_z+0x150>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0x1d6d(%rip),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    130d <A_grad_z+0x18d>
movsd  0x1d46(%rip),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0x140(%rbp),%rsi
lea    -0x120(%rbp),%rdx
call   1080 <r3mx@plt>
jmp    14f5 <A_grad_z+0x375>
cmpl   $0x0,-0x10(%rbp)
jne    1400 <A_grad_z+0x280>
cmpl   $0xffffffff,-0x14(%rbp)
jne    1376 <A_grad_z+0x1f6>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1cd4(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    13b9 <A_grad_z+0x239>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  0x1c85(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    13fb <A_grad_z+0x27b>
mov    -0x20(%rbp),%rax
movsd  0x1c59(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    14f0 <A_grad_z+0x370>
cmpl   $0x1,-0x10(%rbp)
jne    14eb <A_grad_z+0x36b>
lea    -0x160(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xffffffff,-0x14(%rbp)
jne    145a <A_grad_z+0x2da>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x1bee(%rip),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    1497 <A_grad_z+0x317>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x1ba6(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    14d4 <A_grad_z+0x354>
movsd  0x1b7f(%rip),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0x160(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   1080 <r3mx@plt>
jmp    14f0 <A_grad_z+0x370>
jmp    14f5 <A_grad_z+0x375>
jmp    25b3 <A_grad_z+0x1433>
cmpl   $0x2,-0xc(%rbp)
jne    25ae <A_grad_z+0x142e>
cmpl   $0xfffffffe,-0x10(%rbp)
jne    181d <A_grad_z+0x69d>
lea    -0x180(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x1a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xfffffffe,-0x14(%rbp)
jne    15ac <A_grad_z+0x42c>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x14(%rbp)
jne    1624 <A_grad_z+0x4a4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    16a2 <A_grad_z+0x522>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x19b4(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0x1989(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  0x196a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    171a <A_grad_z+0x59a>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x2,-0x14(%rbp)
jne    17d7 <A_grad_z+0x657>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
lea    -0x120(%rbp),%rdx
call   1080 <r3mx@plt>
lea    -0x1c0(%rbp),%rdi
lea    -0x180(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   1080 <r3mx@plt>
mov    -0x20(%rbp),%rdi
lea    -0x1c0(%rbp),%rsi
call   1040 <r3add@plt>
jmp    25a9 <A_grad_z+0x1429>
cmpl   $0xffffffff,-0x10(%rbp)
jne    1b58 <A_grad_z+0x9d8>
lea    -0x1e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xfffffffe,-0x14(%rbp)
jne    18c2 <A_grad_z+0x742>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x14(%rbp)
jne    194c <A_grad_z+0x7cc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    19d4 <A_grad_z+0x854>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x1688(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x165c(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  0x1638(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    1a5c <A_grad_z+0x8dc>
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x2,-0x14(%rbp)
jne    1b29 <A_grad_z+0x9a9>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
lea    -0x200(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
lea    -0x120(%rbp),%rdx
call   1080 <r3mx@plt>
mov    -0x20(%rbp),%rdi
lea    -0x200(%rbp),%rsi
call   1040 <r3add@plt>
jmp    25a4 <A_grad_z+0x1424>
cmpl   $0x0,-0x10(%rbp)
jne    1de0 <A_grad_z+0xc60>
cmpl   $0xfffffffe,-0x14(%rbp)
jne    1bcb <A_grad_z+0xa4b>
mov    -0x28(%rbp),%rax
movsd  0x1488(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0x146f(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x144a(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x14(%rbp)
jne    1c36 <A_grad_z+0xab6>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0x1414(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x13fa(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x13e0(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    1ca3 <A_grad_z+0xb23>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x13bd(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x139b(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1379(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    1d0c <A_grad_z+0xb8c>
mov    -0x28(%rbp),%rax
movsd  0x1347(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x1322(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x1309(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x2,-0x14(%rbp)
jne    1ddb <A_grad_z+0xc5b>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0x130b(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movsd  0x12e9(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x129e(%rip),%xmm0
addsd  %xmm0,%xmm1
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1249(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1231(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    259f <A_grad_z+0x141f>
cmpl   $0x1,-0x10(%rbp)
jne    211b <A_grad_z+0xf9b>
lea    -0x220(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xfffffffe,-0x14(%rbp)
jne    1e85 <A_grad_z+0xd05>
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x14(%rbp)
jne    1f0f <A_grad_z+0xd8f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    1f97 <A_grad_z+0xe17>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x10c5(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x1099(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  0x1075(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    201f <A_grad_z+0xe9f>
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x2,-0x14(%rbp)
jne    20ec <A_grad_z+0xf6c>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
lea    -0x240(%rbp),%rdi
lea    -0x220(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   1080 <r3mx@plt>
mov    -0x20(%rbp),%rdi
lea    -0x240(%rbp),%rsi
call   1040 <r3add@plt>
jmp    259a <A_grad_z+0x141a>
cmpl   $0x2,-0x10(%rbp)
jne    2595 <A_grad_z+0x1415>
lea    -0x260(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x280(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
cmpl   $0xfffffffe,-0x14(%rbp)
jne    2208 <A_grad_z+0x1088>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x14(%rbp)
jne    22c5 <A_grad_z+0x1145>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
jne    2393 <A_grad_z+0x1213>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  0xd13(%rip),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xccc(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc8d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc79(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x14(%rbp)
jne    2450 <A_grad_z+0x12d0>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x2,-0x14(%rbp)
jne    2554 <A_grad_z+0x13d4>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xac0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rdi
lea    -0x280(%rbp),%rsi
lea    -0x120(%rbp),%rdx
call   1080 <r3mx@plt>
lea    -0x2a0(%rbp),%rdi
lea    -0x260(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   1080 <r3mx@plt>
mov    -0x20(%rbp),%rdi
lea    -0x2a0(%rbp),%rsi
call   1040 <r3add@plt>
jmp    259a <A_grad_z+0x141a>
jmp    259f <A_grad_z+0x141f>
jmp    25a4 <A_grad_z+0x1424>
jmp    25a9 <A_grad_z+0x1429>
jmp    25ae <A_grad_z+0x142e>
jmp    25b3 <A_grad_z+0x1433>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<A_grad_z>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r8,%rbp
mov    %rcx,%rbx
mov    %edx,%r14d
mov    %esi,%r13d
mov    %edi,%r12d
xorps  %xmm0,%xmm0
mov    %rcx,%rdi
call   1060 <r3set@plt>
test   %r12d,%r12d
je     12b1 <A_grad_z+0x141>
mov    %r14,0x8(%rsp)
mov    %rbx,0x88(%rsp)
mov    %rbp,%rdi
call   1040 <find_min_proj@plt>
mov    %eax,%r14d
lea    0x98(%rsp),%rsi
lea    0x90(%rsp),%rdx
mov    %rbp,%rbx
lea    0x50(%rsp),%rbp
lea    0x70(%rsp),%r8
mov    %eax,%edi
mov    %rbp,%rcx
mov    %rbx,%r9
call   1080 <new_xy_axis@plt>
movsd  0x98(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
lea    0x110(%rsp),%r15
mov    %r14d,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1090 <dx_dz_fill@plt>
lea    0xc0(%rsp),%rcx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1050 <dy_dz_fill@plt>
cmp    $0x2,%r12d
je     12be <A_grad_z+0x14e>
cmp    $0x1,%r12d
xorpd  %xmm0,%xmm0
jne    1e12 <A_grad_z+0xca2>
cmp    $0x1,%r13d
je     1372 <A_grad_z+0x202>
test   %r13d,%r13d
mov    0x88(%rsp),%rdi
mov    0x8(%rsp),%rax
je     13ca <A_grad_z+0x25a>
cmp    $0xffffffff,%r13d
jne    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
cmp    $0x1,%eax
je     15f8 <A_grad_z+0x488>
test   %eax,%eax
je     1615 <A_grad_z+0x4a5>
xorpd  %xmm0,%xmm0
cmp    $0xffffffff,%eax
jne    1637 <A_grad_z+0x4c7>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
jmp    1637 <A_grad_z+0x4c7>
movsd  0xd47(%rip),%xmm0
jmp    1e12 <A_grad_z+0xca2>
add    $0x2,%r13d
cmp    $0x4,%r13d
xorpd  %xmm0,%xmm0
ja     1e12 <A_grad_z+0xca2>
lea    0xd79(%rip),%rax
movslq (%rax,%r13,4),%rcx
add    %rax,%rcx
jmp    *%rcx
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movq   $0x0,0x40(%rsp)
mov    0x8(%rsp),%rcx
add    $0x2,%ecx
cmp    $0x4,%ecx
mov    0x88(%rsp),%rbp
ja     16ec <A_grad_z+0x57c>
lea    0xd92(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movsd  0x70(%rsp),%xmm0
movsd  0x78(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  %xmm0,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x50(%rsp),%xmm3
movsd  0x58(%rsp),%xmm2
movsd  %xmm2,0x30(%rsp)
movsd  %xmm3,0x38(%rsp)
movq   $0x0,0x40(%rsp)
jmp    17cc <A_grad_z+0x65c>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
mov    0x8(%rsp),%rax
cmp    $0x1,%eax
mov    0x88(%rsp),%rdi
je     1654 <A_grad_z+0x4e4>
test   %eax,%eax
je     1671 <A_grad_z+0x501>
xorpd  %xmm0,%xmm0
cmp    $0xffffffff,%eax
jne    1690 <A_grad_z+0x520>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x18(%rsp)
movsd  0x58(%rsp),%xmm0
jmp    1690 <A_grad_z+0x520>
cmp    $0x1,%eax
je     16ad <A_grad_z+0x53d>
test   %eax,%eax
je     16cc <A_grad_z+0x55c>
cmp    $0xffffffff,%eax
jne    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movhpd 0xc10(%rip),%xmm0
movupd %xmm0,(%rdi)
movq   $0x0,0x10(%rdi)
movsd  0x8(%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
mov    0x8(%rsp),%rcx
add    $0x2,%ecx
cmp    $0x4,%ecx
mov    0x88(%rsp),%rbp
ja     184a <A_grad_z+0x6da>
lea    0xc67(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movups (%rbx),%xmm0
shufps $0x4e,%xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x70(%rsp),%xmm1
movsd  %xmm1,0x8(%rbp)
movq   $0x0,0x10(%rbp)
mulsd  (%rbx),%xmm0
mulsd  0x8(%rbx),%xmm1
jmp    192c <A_grad_z+0x7bc>
mov    0x8(%rsp),%rcx
add    $0x2,%ecx
cmp    $0x4,%ecx
mov    0x88(%rsp),%rdx
ja     1e12 <A_grad_z+0xca2>
lea    0xbe9(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movsd  0xb5c(%rip),%xmm0
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx)
movsd  (%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdx)
movq   $0x0,0x10(%rdx)
mulsd  (%rbx),%xmm0
mulsd  0x8(%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
mov    0x8(%rsp),%rcx
add    $0x2,%ecx
cmp    $0x4,%ecx
mov    0x88(%rsp),%rbp
ja     1abe <A_grad_z+0x94e>
lea    0xb61(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movups (%rbx),%xmm0
shufps $0x4e,%xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  0x50(%rsp),%xmm1
movsd  %xmm1,0x8(%rbp)
movq   $0x0,0x10(%rbp)
mulsd  (%rbx),%xmm0
mulsd  0x8(%rbx),%xmm1
jmp    1b9c <A_grad_z+0xa2c>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movq   $0x0,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movq   $0x0,0x40(%rsp)
mov    0x8(%rsp),%rcx
add    $0x2,%ecx
cmp    $0x4,%ecx
mov    0x88(%rsp),%rbp
ja     16ec <A_grad_z+0x57c>
lea    0xac1(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movsd  0x50(%rsp),%xmm4
movsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  %xmm4,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movdqa 0x70(%rsp),%xmm1
movdqa 0xa65(%rip),%xmm2
pxor   %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm3
movdqa %xmm3,0x30(%rsp)
movq   $0x0,0x40(%rsp)
jmp    1c60 <A_grad_z+0xaf0>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%rsp)
movupd %xmm0,0x18(%rsp)
movsd  0x70(%rsp),%xmm0
jmp    1637 <A_grad_z+0x4c7>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x20(%rsp)
movsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x10(%rsp),%rsi
lea    0xc0(%rsp),%rdx
call   1070 <r3mx@plt>
jmp    1e0c <A_grad_z+0xc9c>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%rsp)
movupd %xmm0,0x18(%rsp)
movsd  0x50(%rsp),%xmm0
jmp    1690 <A_grad_z+0x520>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x10(%rsp),%rsi
lea    0x110(%rsp),%rdx
call   1070 <r3mx@plt>
jmp    1e0c <A_grad_z+0xc9c>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rdi)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x8(%rdi)
movsd  (%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdi)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x10(%rdi)
movsd  0x10(%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    1dcf <A_grad_z+0xc5f>
movq   $0x0,0x10(%rsp)
movsd  0x78(%rsp),%xmm0
movsd  0x80(%rsp),%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  %xmm0,0x20(%rsp)
movq   $0x0,0x30(%rsp)
movsd  0x58(%rsp),%xmm3
movsd  0x60(%rsp),%xmm2
movsd  %xmm2,0x38(%rsp)
jmp    17c6 <A_grad_z+0x656>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x80(%rsp),%xmm3
movsd  0x8b6(%rip),%xmm1
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movsd  0x60(%rsp),%xmm0
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x40(%rsp)
jmp    1cd0 <A_grad_z+0xb60>
movsd  0x70(%rsp),%xmm0
movsd  0x80(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movq   $0x0,0x18(%rsp)
movsd  %xmm0,0x20(%rsp)
movsd  0x50(%rsp),%xmm3
movsd  0x60(%rsp),%xmm2
movsd  %xmm2,0x30(%rsp)
movq   $0x0,0x38(%rsp)
movsd  %xmm3,0x40(%rsp)
mulsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,0x8(%rsp)
jmp    1dcf <A_grad_z+0xc5f>
movsd  0x70(%rsp),%xmm0
movsd  0x78(%rsp),%xmm1
movsd  %xmm0,0x10(%rsp)
movapd 0x843(%rip),%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x50(%rsp),%xmm4
movsd  0x58(%rsp),%xmm3
movsd  %xmm4,0x30(%rsp)
xorpd  %xmm3,%xmm2
movlpd %xmm2,0x38(%rsp)
movq   $0x0,0x40(%rsp)
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm4
subsd  %xmm1,%xmm4
jmp    1dc9 <A_grad_z+0xc59>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    1997 <A_grad_z+0x827>
movq   $0x0,0x10(%rsp)
movups 0x8(%rbx),%xmm0
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,0x18(%rsp)
movq   $0x0,0x0(%rbp)
movsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x78(%rsp),%xmm1
movsd  %xmm1,0x10(%rbp)
mulsd  0x8(%rbx),%xmm0
jmp    1927 <A_grad_z+0x7b7>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x764(%rip),%xmm1
movsd  0x10(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp)
movupd %xmm0,0x0(%rbp)
movsd  0x80(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rbp)
mulsd  0x10(%rbx),%xmm2
mulsd  %xmm1,%xmm2
jmp    1991 <A_grad_z+0x821>
movsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movq   $0x0,0x18(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movq   $0x0,0x8(%rbp)
movsd  0x70(%rsp),%xmm1
movsd  %xmm1,0x10(%rbp)
mulsd  (%rbx),%xmm0
mulsd  0x10(%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
jmp    1997 <A_grad_z+0x827>
movsd  (%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rbx),%xmm0
movapd 0x6f1(%rip),%xmm1
xorpd  %xmm1,%xmm0
movlpd %xmm0,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x70(%rsp),%xmm2
movsd  %xmm2,0x0(%rbp)
movsd  0x78(%rsp),%xmm0
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%rbp)
movq   $0x0,0x10(%rbp)
mulsd  0x8(%rbx),%xmm0
mulsd  (%rbx),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsp)
lea    0x30(%rsp),%rbx
lea    0x10(%rsp),%rsi
lea    0xc0(%rsp),%rdx
jmp    1df9 <A_grad_z+0xc89>
movq   $0x0,(%rdx)
movsd  0x653(%rip),%xmm0
movsd  0x10(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdx)
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rdx)
mulsd  0x8(%rbx),%xmm0
mulsd  0x10(%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdx)
movsd  0x10(%rbx),%xmm0
mulsd  0x62b(%rip),%xmm0
movsd  %xmm0,0x10(%rdx)
movsd  0x10(%rbx),%xmm1
movsd  0x621(%rip),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  0x619(%rip),%xmm0
jmp    1e12 <A_grad_z+0xca2>
movsd  0x5e4(%rip),%xmm0
movsd  0x10(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx)
movq   $0x0,0x8(%rdx)
movsd  (%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rdx)
mulsd  (%rbx),%xmm0
mulsd  0x10(%rbx),%xmm0
jmp    1e12 <A_grad_z+0xca2>
movq   $0x0,(%rdx)
movsd  0x8(%rbx),%xmm0
mulsd  0x5b0(%rip),%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%rbx),%xmm0
mulsd  0x596(%rip),%xmm0
movsd  %xmm0,0x10(%rdx)
movsd  0x8(%rbx),%xmm2
movsd  0x10(%rbx),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x563(%rip),%xmm0
subsd  %xmm1,%xmm0
mulsd  0x55f(%rip),%xmm0
mulsd  %xmm2,%xmm2
subsd  %xmm2,%xmm0
mulsd  0x557(%rip),%xmm0
jmp    1e12 <A_grad_z+0xca2>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x30(%rsp),%rbx
jmp    1dec <A_grad_z+0xc7c>
movq   $0x0,0x10(%rsp)
movups 0x8(%rbx),%xmm0
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,0x18(%rsp)
movq   $0x0,0x0(%rbp)
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  0x58(%rsp),%xmm1
movsd  %xmm1,0x10(%rbp)
mulsd  0x8(%rbx),%xmm0
jmp    1b97 <A_grad_z+0xa27>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x4ee(%rip),%xmm1
movsd  0x10(%rbx),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp)
movupd %xmm0,0x0(%rbp)
movsd  0x60(%rsp),%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rbp)
mulsd  0x10(%rbx),%xmm2
mulsd  %xmm1,%xmm2
jmp    1c09 <A_grad_z+0xa99>
movsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movq   $0x0,0x18(%rsp)
movsd  (%rbx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movq   $0x0,0x8(%rbp)
movsd  0x50(%rsp),%xmm1
movsd  %xmm1,0x10(%rbp)
mulsd  (%rbx),%xmm0
mulsd  0x10(%rbx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
lea    0x30(%rsp),%rbx
jmp    1dec <A_grad_z+0xc7c>
movsd  (%rbx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rbx),%xmm0
movapd 0x479(%rip),%xmm1
xorpd  %xmm1,%xmm0
movlpd %xmm0,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x50(%rsp),%xmm2
movsd  %xmm2,0x0(%rbp)
movsd  0x58(%rsp),%xmm0
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%rbp)
movq   $0x0,0x10(%rbp)
mulsd  0x8(%rbx),%xmm0
mulsd  (%rbx),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsp)
lea    0x30(%rsp),%rbx
jmp    1dec <A_grad_z+0xc7c>
movq   $0x0,0x10(%rsp)
movsd  0x58(%rsp),%xmm4
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  %xmm4,0x20(%rsp)
movq   $0x0,0x30(%rsp)
movdqu 0x78(%rsp),%xmm1
movdqa 0x3ef(%rip),%xmm2
pxor   %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm3
movdqu %xmm3,0x38(%rsp)
punpckhqdq %xmm1,%xmm1
mulsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
jmp    1dc9 <A_grad_z+0xc59>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0x60(%rsp),%xmm3
movsd  0x383(%rip),%xmm1
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movsd  0x80(%rsp),%xmm0
movsd  0x366(%rip),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x40(%rsp)
mulsd  %xmm0,%xmm0
mulsd  %xmm3,%xmm3
subsd  %xmm0,%xmm3
mulsd  0x338(%rip),%xmm3
mulsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rsp)
jmp    1dcf <A_grad_z+0xc5f>
movsd  0x50(%rsp),%xmm5
movsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movq   $0x0,0x18(%rsp)
movsd  %xmm5,0x20(%rsp)
movsd  0x70(%rsp),%xmm1
movsd  0x80(%rsp),%xmm2
movapd 0x329(%rip),%xmm3
movapd %xmm2,%xmm4
xorpd  %xmm3,%xmm4
movlpd %xmm4,0x30(%rsp)
movq   $0x0,0x38(%rsp)
xorpd  %xmm1,%xmm3
movlpd %xmm3,0x40(%rsp)
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm5
subsd  %xmm2,%xmm5
movsd  %xmm5,0x8(%rsp)
jmp    1dcf <A_grad_z+0xc5f>
movsd  0x50(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
movsd  %xmm0,0x10(%rsp)
movapd 0x2d7(%rip),%xmm2
movapd %xmm1,%xmm3
xorpd  %xmm2,%xmm3
movlpd %xmm3,0x18(%rsp)
movq   $0x0,0x20(%rsp)
movsd  0x70(%rsp),%xmm3
movsd  0x78(%rsp),%xmm4
xorpd  %xmm3,%xmm2
movlpd %xmm2,0x30(%rsp)
movsd  %xmm4,0x38(%rsp)
movq   $0x0,0x40(%rsp)
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm4
addsd  %xmm0,%xmm4
mulsd  %xmm3,%xmm3
subsd  %xmm3,%xmm4
mulsd  0x23f(%rip),%xmm4
movsd  %xmm4,0x8(%rsp)
lea    0x30(%rsp),%rsi
lea    0xc0(%rsp),%rdx
mov    %rbp,%rdi
call   1070 <r3mx@plt>
lea    0xa0(%rsp),%rbx
lea    0x10(%rsp),%rsi
lea    0x110(%rsp),%rdx
mov    %rbx,%rdi
call   1070 <r3mx@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1030 <r3add@plt>
movsd  0x8(%rsp),%xmm0
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @A_grad_z(i32 %0, i32 %1, i32 %2, double* %3, double* %4) {
%6 = alloca double
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca double
%14 = alloca double
%15 = alloca [3 x double]
%16 = alloca [3 x double]
%17 = alloca double
%18 = alloca [9 x double]
%19 = alloca [9 x double]
%20 = alloca [3 x double]
%21 = alloca [3 x double]
%22 = alloca [3 x double]
%23 = alloca [3 x double]
%24 = alloca [3 x double]
%25 = alloca [3 x double]
%26 = alloca [3 x double]
%27 = alloca [3 x double]
%28 = alloca [3 x double]
%29 = alloca [3 x double]
%30 = alloca [3 x double]
%31 = alloca [3 x double]
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store double* %3, double** %10
store double* %4, double** %11
%32 = load double*, double** %10
%33 = call i32 @r3set(double* %32, double 0.000000e+00)
%34 = load i32, i32* %7
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %37
36: ; preds = %5
store double 1.000000e+00, double* %6
br label %1028
37: ; preds = %5
%38 = load double*, double** %11
%39 = call i32 @find_min_proj(double* %38)
store i32 %39, i32* %12
%40 = load i32, i32* %12
%41 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%42 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%43 = load double*, double** %11
%44 = call i32 @new_xy_axis(i32 %40, double* %13, double* %14, double* %41, double* %42, double* %43)
store double 0.000000e+00, double* %17
%45 = load i32, i32* %12
%46 = load double, double* %13
%47 = load double, double* %14
%48 = load double*, double** %11
%49 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%50 = call i32 @dx_dz_fill(i32 %45, double %46, double %47, double* %48, double* %49)
%51 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%52 = load double*, double** %11
%53 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%54 = getelementptr inbounds [9 x double], [9 x double]* %19, i64 0, i64 0
%55 = call i32 @dy_dz_fill(double* %51, double* %52, double* %53, double* %54)
%56 = load i32, i32* %7
%57 = icmp eq i32 %56, 1
br i1 %57, label %58, label %176
58: ; preds = %37
%59 = load i32, i32* %8
%60 = icmp eq i32 %59, -1
br i1 %60, label %61, label %94
61: ; preds = %58
%62 = bitcast [3 x double]* %20 to i8*
%63 = load i32, i32* %9
%64 = icmp eq i32 %63, -1
br i1 %64, label %65, label %71
65: ; preds = %61
%66 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 0
store double 0.000000e+00, double* %66
%67 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 1
store double 1.000000e+00, double* %67
%68 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 2
store double 0.000000e+00, double* %68
%69 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%70 = load double, double* %69
store double %70, double* %17
br label %71
71: ; preds = %65, %61
%72 = load i32, i32* %9
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %80
74: ; preds = %71
%75 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 0
store double 0.000000e+00, double* %75
%76 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 1
store double 0.000000e+00, double* %76
%77 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 2
store double 1.000000e+00, double* %77
%78 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%79 = load double, double* %78
store double %79, double* %17
br label %80
80: ; preds = %74, %71
%81 = load i32, i32* %9
%82 = icmp eq i32 %81, 1
br i1 %82, label %83, label %89
83: ; preds = %80
%84 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 0
store double 1.000000e+00, double* %84
%85 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 1
store double 0.000000e+00, double* %85
%86 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 2
store double 0.000000e+00, double* %86
%87 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%88 = load double, double* %87
store double %88, double* %17
br label %89
89: ; preds = %83, %80
%90 = load double*, double** %10
%91 = getelementptr inbounds [3 x double], [3 x double]* %20, i64 0, i64 0
%92 = getelementptr inbounds [9 x double], [9 x double]* %19, i64 0, i64 0
%93 = call i32 @r3mx(double* %90, double* %91, double* %92)
br label %175
94: ; preds = %58
%95 = load i32, i32* %8
%96 = icmp eq i32 %95, 0
br i1 %96, label %97, label %137
97: ; preds = %94
%98 = load i32, i32* %9
%99 = icmp eq i32 %98, -1
br i1 %99, label %100, label %110
100: ; preds = %97
%101 = load double*, double** %10
%102 = getelementptr inbounds double, double* %101, i64 0
store double 0.000000e+00, double* %102
%103 = load double*, double** %10
%104 = getelementptr inbounds double, double* %103, i64 1
store double 1.000000e+00, double* %104
%105 = load double*, double** %10
%106 = getelementptr inbounds double, double* %105, i64 2
store double 0.000000e+00, double* %106
%107 = load double*, double** %11
%108 = getelementptr inbounds double, double* %107, i64 1
%109 = load double, double* %108
store double %109, double* %17
br label %110
110: ; preds = %100, %97
%111 = load i32, i32* %9
%112 = icmp eq i32 %111, 0
br i1 %112, label %113, label %123
113: ; preds = %110
%114 = load double*, double** %10
%115 = getelementptr inbounds double, double* %114, i64 0
store double 0.000000e+00, double* %115
%116 = load double*, double** %10
%117 = getelementptr inbounds double, double* %116, i64 1
store double 0.000000e+00, double* %117
%118 = load double*, double** %10
%119 = getelementptr inbounds double, double* %118, i64 2
store double 1.000000e+00, double* %119
%120 = load double*, double** %11
%121 = getelementptr inbounds double, double* %120, i64 2
%122 = load double, double* %121
store double %122, double* %17
br label %123
123: ; preds = %113, %110
%124 = load i32, i32* %9
%125 = icmp eq i32 %124, 1
br i1 %125, label %126, label %136
126: ; preds = %123
%127 = load double*, double** %10
%128 = getelementptr inbounds double, double* %127, i64 0
store double 1.000000e+00, double* %128
%129 = load double*, double** %10
%130 = getelementptr inbounds double, double* %129, i64 1
store double 0.000000e+00, double* %130
%131 = load double*, double** %10
%132 = getelementptr inbounds double, double* %131, i64 2
store double 0.000000e+00, double* %132
%133 = load double*, double** %11
%134 = getelementptr inbounds double, double* %133, i64 0
%135 = load double, double* %134
store double %135, double* %17
br label %136
136: ; preds = %126, %123
br label %174
137: ; preds = %94
%138 = load i32, i32* %8
%139 = icmp eq i32 %138, 1
br i1 %139, label %140, label %173
140: ; preds = %137
%141 = bitcast [3 x double]* %21 to i8*
%142 = load i32, i32* %9
%143 = icmp eq i32 %142, -1
br i1 %143, label %144, label %150
144: ; preds = %140
%145 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
store double 0.000000e+00, double* %145
%146 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 1
store double 1.000000e+00, double* %146
%147 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 2
store double 0.000000e+00, double* %147
%148 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%149 = load double, double* %148
store double %149, double* %17
br label %150
150: ; preds = %144, %140
%151 = load i32, i32* %9
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %159
153: ; preds = %150
%154 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
store double 0.000000e+00, double* %154
%155 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 1
store double 0.000000e+00, double* %155
%156 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 2
store double 1.000000e+00, double* %156
%157 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%158 = load double, double* %157
store double %158, double* %17
br label %159
159: ; preds = %153, %150
%160 = load i32, i32* %9
%161 = icmp eq i32 %160, 1
br i1 %161, label %162, label %168
162: ; preds = %159
%163 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
store double 1.000000e+00, double* %163
%164 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 1
store double 0.000000e+00, double* %164
%165 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 2
store double 0.000000e+00, double* %165
%166 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%167 = load double, double* %166
store double %167, double* %17
br label %168
168: ; preds = %162, %159
%169 = load double*, double** %10
%170 = getelementptr inbounds [3 x double], [3 x double]* %21, i64 0, i64 0
%171 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%172 = call i32 @r3mx(double* %169, double* %170, double* %171)
br label %173
173: ; preds = %168, %137
br label %174
174: ; preds = %173, %136
br label %175
175: ; preds = %174, %89
br label %1026
176: ; preds = %37
%177 = load i32, i32* %7
%178 = icmp eq i32 %177, 2
br i1 %178, label %179, label %1025
179: ; preds = %176
%180 = load i32, i32* %8
%181 = icmp eq i32 %180, -2
br i1 %181, label %182, label %333
182: ; preds = %179
%183 = bitcast [3 x double]* %22 to i8*
%184 = bitcast [3 x double]* %23 to i8*
%185 = load i32, i32* %9
%186 = icmp eq i32 %185, -2
br i1 %186, label %187, label %212
187: ; preds = %182
%188 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%189 = load double, double* %188
%190 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %189, double* %190
%191 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%192 = load double, double* %191
%193 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %192, double* %193
%194 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double 0.000000e+00, double* %194
%195 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%196 = load double, double* %195
%197 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
store double %196, double* %197
%198 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%199 = load double, double* %198
%200 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 1
store double %199, double* %200
%201 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 2
store double 0.000000e+00, double* %201
%202 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%203 = load double, double* %202
%204 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%205 = load double, double* %204
%206 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%207 = load double, double* %206
%208 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%209 = load double, double* %208
%210 = fmul double %207, %209
%211 = call double @llvm.fmuladd.f64(double %203, double %205, double %210)
store double %211, double* %17
br label %212
212: ; preds = %187, %182
%213 = load i32, i32* %9
%214 = icmp eq i32 %213, -1
br i1 %214, label %215, label %240
215: ; preds = %212
%216 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double 0.000000e+00, double* %216
%217 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%218 = load double, double* %217
%219 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %218, double* %219
%220 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%221 = load double, double* %220
%222 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %221, double* %222
%223 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
store double 0.000000e+00, double* %223
%224 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%225 = load double, double* %224
%226 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 1
store double %225, double* %226
%227 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%228 = load double, double* %227
%229 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 2
store double %228, double* %229
%230 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%231 = load double, double* %230
%232 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%233 = load double, double* %232
%234 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%235 = load double, double* %234
%236 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%237 = load double, double* %236
%238 = fmul double %235, %237
%239 = call double @llvm.fmuladd.f64(double %231, double %233, double %238)
store double %239, double* %17
br label %240
240: ; preds = %215, %212
%241 = load i32, i32* %9
%242 = icmp eq i32 %241, 0
br i1 %242, label %243, label %262
243: ; preds = %240
%244 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double 0.000000e+00, double* %244
%245 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double 0.000000e+00, double* %245
%246 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%247 = load double, double* %246
%248 = fmul double %247, 0x3FFBB67AE8584CAA
%249 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %248, double* %249
%250 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
store double 0.000000e+00, double* %250
%251 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 1
store double 0.000000e+00, double* %251
%252 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%253 = load double, double* %252
%254 = fmul double %253, 0x3FFBB67AE8584CAA
%255 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 2
store double %254, double* %255
%256 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%257 = load double, double* %256
%258 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%259 = load double, double* %258
%260 = fmul double %257, %259
%261 = fmul double %260, 0x3FFBB67AE8584CAA
store double %261, double* %17
br label %262
262: ; preds = %243, %240
%263 = load i32, i32* %9
%264 = icmp eq i32 %263, 1
br i1 %264, label %265, label %290
265: ; preds = %262
%266 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%267 = load double, double* %266
%268 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %267, double* %268
%269 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double 0.000000e+00, double* %269
%270 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%271 = load double, double* %270
%272 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double %271, double* %272
%273 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%274 = load double, double* %273
%275 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
store double %274, double* %275
%276 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 1
store double 0.000000e+00, double* %276
%277 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%278 = load double, double* %277
%279 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 2
store double %278, double* %279
%280 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%281 = load double, double* %280
%282 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%283 = load double, double* %282
%284 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%285 = load double, double* %284
%286 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%287 = load double, double* %286
%288 = fmul double %285, %287
%289 = call double @llvm.fmuladd.f64(double %281, double %283, double %288)
store double %289, double* %17
br label %290
290: ; preds = %265, %262
%291 = load i32, i32* %9
%292 = icmp eq i32 %291, 2
br i1 %292, label %293, label %321
293: ; preds = %290
%294 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%295 = load double, double* %294
%296 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
store double %295, double* %296
%297 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%298 = load double, double* %297
%299 = fneg double %298
%300 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 1
store double %299, double* %300
%301 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 2
store double 0.000000e+00, double* %301
%302 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%303 = load double, double* %302
%304 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
store double %303, double* %304
%305 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%306 = load double, double* %305
%307 = fneg double %306
%308 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 1
store double %307, double* %308
%309 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 2
store double 0.000000e+00, double* %309
%310 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%311 = load double, double* %310
%312 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%313 = load double, double* %312
%314 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%315 = load double, double* %314
%316 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%317 = load double, double* %316
%318 = fmul double %315, %317
%319 = fneg double %318
%320 = call double @llvm.fmuladd.f64(double %311, double %313, double %319)
store double %320, double* %17
br label %321
321: ; preds = %293, %290
%322 = load double*, double** %10
%323 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 0, i64 0
%324 = getelementptr inbounds [9 x double], [9 x double]* %19, i64 0, i64 0
%325 = call i32 @r3mx(double* %322, double* %323, double* %324)
%326 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 0
%327 = getelementptr inbounds [3 x double], [3 x double]* %22, i64 0, i64 0
%328 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%329 = call i32 @r3mx(double* %326, double* %327, double* %328)
%330 = load double*, double** %10
%331 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 0
%332 = call i32 @r3add(double* %330, double* %331)
br label %1024
333: ; preds = %179
%334 = load i32, i32* %8
%335 = icmp eq i32 %334, -1
br i1 %335, label %336, label %515
336: ; preds = %333
%337 = bitcast [3 x double]* %25 to i8*
%338 = load i32, i32* %9
%339 = icmp eq i32 %338, -2
br i1 %339, label %340, label %372
340: ; preds = %336
%341 = load double*, double** %11
%342 = getelementptr inbounds double, double* %341, i64 1
%343 = load double, double* %342
%344 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
store double %343, double* %344
%345 = load double*, double** %11
%346 = getelementptr inbounds double, double* %345, i64 0
%347 = load double, double* %346
%348 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
store double %347, double* %348
%349 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 2
store double 0.000000e+00, double* %349
%350 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%351 = load double, double* %350
%352 = load double*, double** %10
%353 = getelementptr inbounds double, double* %352, i64 0
store double %351, double* %353
%354 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%355 = load double, double* %354
%356 = load double*, double** %10
%357 = getelementptr inbounds double, double* %356, i64 1
store double %355, double* %357
%358 = load double*, double** %10
%359 = getelementptr inbounds double, double* %358, i64 2
store double 0.000000e+00, double* %359
%360 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%361 = load double, double* %360
%362 = load double*, double** %11
%363 = getelementptr inbounds double, double* %362, i64 1
%364 = load double, double* %363
%365 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%366 = load double, double* %365
%367 = load double*, double** %11
%368 = getelementptr inbounds double, double* %367, i64 0
%369 = load double, double* %368
%370 = fmul double %366, %369
%371 = call double @llvm.fmuladd.f64(double %361, double %364, double %370)
store double %371, double* %17
br label %372
372: ; preds = %340, %336
%373 = load i32, i32* %9
%374 = icmp eq i32 %373, -1
br i1 %374, label %375, label %407
375: ; preds = %372
%376 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
store double 0.000000e+00, double* %376
%377 = load double*, double** %11
%378 = getelementptr inbounds double, double* %377, i64 2
%379 = load double, double* %378
%380 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
store double %379, double* %380
%381 = load double*, double** %11
%382 = getelementptr inbounds double, double* %381, i64 1
%383 = load double, double* %382
%384 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 2
store double %383, double* %384
%385 = load double*, double** %10
%386 = getelementptr inbounds double, double* %385, i64 0
store double 0.000000e+00, double* %386
%387 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%388 = load double, double* %387
%389 = load double*, double** %10
%390 = getelementptr inbounds double, double* %389, i64 1
store double %388, double* %390
%391 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%392 = load double, double* %391
%393 = load double*, double** %10
%394 = getelementptr inbounds double, double* %393, i64 2
store double %392, double* %394
%395 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%396 = load double, double* %395
%397 = load double*, double** %11
%398 = getelementptr inbounds double, double* %397, i64 2
%399 = load double, double* %398
%400 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%401 = load double, double* %400
%402 = load double*, double** %11
%403 = getelementptr inbounds double, double* %402, i64 1
%404 = load double, double* %403
%405 = fmul double %401, %404
%406 = call double @llvm.fmuladd.f64(double %396, double %399, double %405)
store double %406, double* %17
br label %407
407: ; preds = %375, %372
%408 = load i32, i32* %9
%409 = icmp eq i32 %408, 0
br i1 %409, label %410, label %434
410: ; preds = %407
%411 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
store double 0.000000e+00, double* %411
%412 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
store double 0.000000e+00, double* %412
%413 = load double*, double** %11
%414 = getelementptr inbounds double, double* %413, i64 2
%415 = load double, double* %414
%416 = fmul double %415, 0x3FFBB67AE8584CAA
%417 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 2
store double %416, double* %417
%418 = load double*, double** %10
%419 = getelementptr inbounds double, double* %418, i64 0
store double 0.000000e+00, double* %419
%420 = load double*, double** %10
%421 = getelementptr inbounds double, double* %420, i64 1
store double 0.000000e+00, double* %421
%422 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%423 = load double, double* %422
%424 = fmul double %423, 0x3FFBB67AE8584CAA
%425 = load double*, double** %10
%426 = getelementptr inbounds double, double* %425, i64 2
store double %424, double* %426
%427 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%428 = load double, double* %427
%429 = load double*, double** %11
%430 = getelementptr inbounds double, double* %429, i64 2
%431 = load double, double* %430
%432 = fmul double %428, %431
%433 = fmul double %432, 0x3FFBB67AE8584CAA
store double %433, double* %17
br label %434
434: ; preds = %410, %407
%435 = load i32, i32* %9
%436 = icmp eq i32 %435, 1
br i1 %436, label %437, label %469
437: ; preds = %434
%438 = load double*, double** %11
%439 = getelementptr inbounds double, double* %438, i64 2
%440 = load double, double* %439
%441 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
store double %440, double* %441
%442 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
store double 0.000000e+00, double* %442
%443 = load double*, double** %11
%444 = getelementptr inbounds double, double* %443, i64 0
%445 = load double, double* %444
%446 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 2
store double %445, double* %446
%447 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%448 = load double, double* %447
%449 = load double*, double** %10
%450 = getelementptr inbounds double, double* %449, i64 0
store double %448, double* %450
%451 = load double*, double** %10
%452 = getelementptr inbounds double, double* %451, i64 1
store double 0.000000e+00, double* %452
%453 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%454 = load double, double* %453
%455 = load double*, double** %10
%456 = getelementptr inbounds double, double* %455, i64 2
store double %454, double* %456
%457 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%458 = load double, double* %457
%459 = load double*, double** %11
%460 = getelementptr inbounds double, double* %459, i64 2
%461 = load double, double* %460
%462 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%463 = load double, double* %462
%464 = load double*, double** %11
%465 = getelementptr inbounds double, double* %464, i64 0
%466 = load double, double* %465
%467 = fmul double %463, %466
%468 = call double @llvm.fmuladd.f64(double %458, double %461, double %467)
store double %468, double* %17
br label %469
469: ; preds = %437, %434
%470 = load i32, i32* %9
%471 = icmp eq i32 %470, 2
br i1 %471, label %472, label %507
472: ; preds = %469
%473 = load double*, double** %11
%474 = getelementptr inbounds double, double* %473, i64 0
%475 = load double, double* %474
%476 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
store double %475, double* %476
%477 = load double*, double** %11
%478 = getelementptr inbounds double, double* %477, i64 1
%479 = load double, double* %478
%480 = fneg double %479
%481 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
store double %480, double* %481
%482 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 2
store double 0.000000e+00, double* %482
%483 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%484 = load double, double* %483
%485 = load double*, double** %10
%486 = getelementptr inbounds double, double* %485, i64 0
store double %484, double* %486
%487 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%488 = load double, double* %487
%489 = fneg double %488
%490 = load double*, double** %10
%491 = getelementptr inbounds double, double* %490, i64 1
store double %489, double* %491
%492 = load double*, double** %10
%493 = getelementptr inbounds double, double* %492, i64 2
store double 0.000000e+00, double* %493
%494 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%495 = load double, double* %494
%496 = load double*, double** %11
%497 = getelementptr inbounds double, double* %496, i64 0
%498 = load double, double* %497
%499 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%500 = load double, double* %499
%501 = load double*, double** %11
%502 = getelementptr inbounds double, double* %501, i64 1
%503 = load double, double* %502
%504 = fmul double %500, %503
%505 = fneg double %504
%506 = call double @llvm.fmuladd.f64(double %495, double %498, double %505)
store double %506, double* %17
br label %507
507: ; preds = %472, %469
%508 = getelementptr inbounds [3 x double], [3 x double]* %26, i64 0, i64 0
%509 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 0
%510 = getelementptr inbounds [9 x double], [9 x double]* %19, i64 0, i64 0
%511 = call i32 @r3mx(double* %508, double* %509, double* %510)
%512 = load double*, double** %10
%513 = getelementptr inbounds [3 x double], [3 x double]* %26, i64 0, i64 0
%514 = call i32 @r3add(double* %512, double* %513)
br label %1023
515: ; preds = %333
%516 = load i32, i32* %8
%517 = icmp eq i32 %516, 0
br i1 %517, label %518, label %655
518: ; preds = %515
%519 = load i32, i32* %9
%520 = icmp eq i32 %519, -2
br i1 %520, label %521, label %544
521: ; preds = %518
%522 = load double*, double** %11
%523 = getelementptr inbounds double, double* %522, i64 1
%524 = load double, double* %523
%525 = fmul double 0x3FFBB67AE8584CAA, %524
%526 = load double*, double** %10
%527 = getelementptr inbounds double, double* %526, i64 0
store double %525, double* %527
%528 = load double*, double** %11
%529 = getelementptr inbounds double, double* %528, i64 0
%530 = load double, double* %529
%531 = fmul double 0x3FFBB67AE8584CAA, %530
%532 = load double*, double** %10
%533 = getelementptr inbounds double, double* %532, i64 1
store double %531, double* %533
%534 = load double*, double** %10
%535 = getelementptr inbounds double, double* %534, i64 2
store double 0.000000e+00, double* %535
%536 = load double*, double** %11
%537 = getelementptr inbounds double, double* %536, i64 0
%538 = load double, double* %537
%539 = fmul double 0x3FFBB67AE8584CAA, %538
%540 = load double*, double** %11
%541 = getelementptr inbounds double, double* %540, i64 1
%542 = load double, double* %541
%543 = fmul double %539, %542
store double %543, double* %17
br label %544
544: ; preds = %521, %518
%545 = load i32, i32* %9
%546 = icmp eq i32 %545, -1
br i1 %546, label %547, label %570
547: ; preds = %544
%548 = load double*, double** %10
%549 = getelementptr inbounds double, double* %548, i64 0
store double 0.000000e+00, double* %549
%550 = load double*, double** %11
%551 = getelementptr inbounds double, double* %550, i64 2
%552 = load double, double* %551
%553 = fmul double 0x3FFBB67AE8584CAA, %552
%554 = load double*, double** %10
%555 = getelementptr inbounds double, double* %554, i64 1
store double %553, double* %555
%556 = load double*, double** %11
%557 = getelementptr inbounds double, double* %556, i64 1
%558 = load double, double* %557
%559 = fmul double 0x3FFBB67AE8584CAA, %558
%560 = load double*, double** %10
%561 = getelementptr inbounds double, double* %560, i64 2
store double %559, double* %561
%562 = load double*, double** %11
%563 = getelementptr inbounds double, double* %562, i64 1
%564 = load double, double* %563
%565 = fmul double 0x3FFBB67AE8584CAA, %564
%566 = load double*, double** %11
%567 = getelementptr inbounds double, double* %566, i64 2
%568 = load double, double* %567
%569 = fmul double %565, %568
store double %569, double* %17
br label %570
570: ; preds = %547, %544
%571 = load i32, i32* %9
%572 = icmp eq i32 %571, 0
br i1 %572, label %573, label %592
573: ; preds = %570
%574 = load double*, double** %10
%575 = getelementptr inbounds double, double* %574, i64 0
store double 0.000000e+00, double* %575
%576 = load double*, double** %10
%577 = getelementptr inbounds double, double* %576, i64 1
store double 0.000000e+00, double* %577
%578 = load double*, double** %11
%579 = getelementptr inbounds double, double* %578, i64 2
%580 = load double, double* %579
%581 = fmul double 3.000000e+00, %580
%582 = load double*, double** %10
%583 = getelementptr inbounds double, double* %582, i64 2
store double %581, double* %583
%584 = load double*, double** %11
%585 = getelementptr inbounds double, double* %584, i64 2
%586 = load double, double* %585
%587 = fmul double 1.500000e+00, %586
%588 = load double*, double** %11
%589 = getelementptr inbounds double, double* %588, i64 2
%590 = load double, double* %589
%591 = call double @llvm.fmuladd.f64(double %587, double %590, double -5.000000e-01)
store double %591, double* %17
br label %592
592: ; preds = %573, %570
%593 = load i32, i32* %9
%594 = icmp eq i32 %593, 1
br i1 %594, label %595, label %618
595: ; preds = %592
%596 = load double*, double** %11
%597 = getelementptr inbounds double, double* %596, i64 2
%598 = load double, double* %597
%599 = fmul double 0x3FFBB67AE8584CAA, %598
%600 = load double*, double** %10
%601 = getelementptr inbounds double, double* %600, i64 0
store double %599, double* %601
%602 = load double*, double** %10
%603 = getelementptr inbounds double, double* %602, i64 1
store double 0.000000e+00, double* %603
%604 = load double*, double** %11
%605 = getelementptr inbounds double, double* %604, i64 0
%606 = load double, double* %605
%607 = fmul double 0x3FFBB67AE8584CAA, %606
%608 = load double*, double** %10
%609 = getelementptr inbounds double, double* %608, i64 2
store double %607, double* %609
%610 = load double*, double** %11
%611 = getelementptr inbounds double, double* %610, i64 0
%612 = load double, double* %611
%613 = fmul double 0x3FFBB67AE8584CAA, %612
%614 = load double*, double** %11
%615 = getelementptr inbounds double, double* %614, i64 2
%616 = load double, double* %615
%617 = fmul double %613, %616
store double %617, double* %17
br label %618
618: ; preds = %595, %592
%619 = load i32, i32* %9
%620 = icmp eq i32 %619, 2
br i1 %620, label %621, label %654
621: ; preds = %618
%622 = load double*, double** %10
%623 = getelementptr inbounds double, double* %622, i64 0
store double 0.000000e+00, double* %623
%624 = load double*, double** %11
%625 = getelementptr inbounds double, double* %624, i64 1
%626 = load double, double* %625
%627 = fmul double 0xC00BB67AE8584CAA, %626
%628 = load double*, double** %10
%629 = getelementptr inbounds double, double* %628, i64 1
store double %627, double* %629
%630 = load double*, double** %11
%631 = getelementptr inbounds double, double* %630, i64 2
%632 = load double, double* %631
%633 = fmul double 0xBFFBB67AE8584CAA, %632
%634 = load double*, double** %10
%635 = getelementptr inbounds double, double* %634, i64 2
store double %633, double* %635
%636 = load double*, double** %11
%637 = getelementptr inbounds double, double* %636, i64 2
%638 = load double, double* %637
%639 = load double*, double** %11
%640 = getelementptr inbounds double, double* %639, i64 2
%641 = load double, double* %640
%642 = fneg double %638
%643 = call double @llvm.fmuladd.f64(double %642, double %641, double 1.000000e+00)
%644 = load double*, double** %11
%645 = getelementptr inbounds double, double* %644, i64 1
%646 = load double, double* %645
%647 = load double*, double** %11
%648 = getelementptr inbounds double, double* %647, i64 1
%649 = load double, double* %648
%650 = fmul double %646, %649
%651 = fneg double %650
%652 = call double @llvm.fmuladd.f64(double %643, double 5.000000e-01, double %651)
%653 = fmul double 0x3FFBB67AE8584CAA, %652
store double %653, double* %17
br label %654
654: ; preds = %621, %618
br label %1022
655: ; preds = %515
%656 = load i32, i32* %8
%657 = icmp eq i32 %656, 1
br i1 %657, label %658, label %837
658: ; preds = %655
%659 = bitcast [3 x double]* %27 to i8*
%660 = load i32, i32* %9
%661 = icmp eq i32 %660, -2
br i1 %661, label %662, label %694
662: ; preds = %658
%663 = load double*, double** %11
%664 = getelementptr inbounds double, double* %663, i64 1
%665 = load double, double* %664
%666 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
store double %665, double* %666
%667 = load double*, double** %11
%668 = getelementptr inbounds double, double* %667, i64 0
%669 = load double, double* %668
%670 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 1
store double %669, double* %670
%671 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 2
store double 0.000000e+00, double* %671
%672 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%673 = load double, double* %672
%674 = load double*, double** %10
%675 = getelementptr inbounds double, double* %674, i64 0
store double %673, double* %675
%676 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%677 = load double, double* %676
%678 = load double*, double** %10
%679 = getelementptr inbounds double, double* %678, i64 1
store double %677, double* %679
%680 = load double*, double** %10
%681 = getelementptr inbounds double, double* %680, i64 2
store double 0.000000e+00, double* %681
%682 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%683 = load double, double* %682
%684 = load double*, double** %11
%685 = getelementptr inbounds double, double* %684, i64 1
%686 = load double, double* %685
%687 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%688 = load double, double* %687
%689 = load double*, double** %11
%690 = getelementptr inbounds double, double* %689, i64 0
%691 = load double, double* %690
%692 = fmul double %688, %691
%693 = call double @llvm.fmuladd.f64(double %683, double %686, double %692)
store double %693, double* %17
br label %694
694: ; preds = %662, %658
%695 = load i32, i32* %9
%696 = icmp eq i32 %695, -1
br i1 %696, label %697, label %729
697: ; preds = %694
%698 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
store double 0.000000e+00, double* %698
%699 = load double*, double** %11
%700 = getelementptr inbounds double, double* %699, i64 2
%701 = load double, double* %700
%702 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 1
store double %701, double* %702
%703 = load double*, double** %11
%704 = getelementptr inbounds double, double* %703, i64 1
%705 = load double, double* %704
%706 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 2
store double %705, double* %706
%707 = load double*, double** %10
%708 = getelementptr inbounds double, double* %707, i64 0
store double 0.000000e+00, double* %708
%709 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%710 = load double, double* %709
%711 = load double*, double** %10
%712 = getelementptr inbounds double, double* %711, i64 1
store double %710, double* %712
%713 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%714 = load double, double* %713
%715 = load double*, double** %10
%716 = getelementptr inbounds double, double* %715, i64 2
store double %714, double* %716
%717 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%718 = load double, double* %717
%719 = load double*, double** %11
%720 = getelementptr inbounds double, double* %719, i64 2
%721 = load double, double* %720
%722 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%723 = load double, double* %722
%724 = load double*, double** %11
%725 = getelementptr inbounds double, double* %724, i64 1
%726 = load double, double* %725
%727 = fmul double %723, %726
%728 = call double @llvm.fmuladd.f64(double %718, double %721, double %727)
store double %728, double* %17
br label %729
729: ; preds = %697, %694
%730 = load i32, i32* %9
%731 = icmp eq i32 %730, 0
br i1 %731, label %732, label %756
732: ; preds = %729
%733 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
store double 0.000000e+00, double* %733
%734 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 1
store double 0.000000e+00, double* %734
%735 = load double*, double** %11
%736 = getelementptr inbounds double, double* %735, i64 2
%737 = load double, double* %736
%738 = fmul double %737, 0x3FFBB67AE8584CAA
%739 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 2
store double %738, double* %739
%740 = load double*, double** %10
%741 = getelementptr inbounds double, double* %740, i64 0
store double 0.000000e+00, double* %741
%742 = load double*, double** %10
%743 = getelementptr inbounds double, double* %742, i64 1
store double 0.000000e+00, double* %743
%744 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%745 = load double, double* %744
%746 = fmul double %745, 0x3FFBB67AE8584CAA
%747 = load double*, double** %10
%748 = getelementptr inbounds double, double* %747, i64 2
store double %746, double* %748
%749 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%750 = load double, double* %749
%751 = load double*, double** %11
%752 = getelementptr inbounds double, double* %751, i64 2
%753 = load double, double* %752
%754 = fmul double %750, %753
%755 = fmul double %754, 0x3FFBB67AE8584CAA
store double %755, double* %17
br label %756
756: ; preds = %732, %729
%757 = load i32, i32* %9
%758 = icmp eq i32 %757, 1
br i1 %758, label %759, label %791
759: ; preds = %756
%760 = load double*, double** %11
%761 = getelementptr inbounds double, double* %760, i64 2
%762 = load double, double* %761
%763 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
store double %762, double* %763
%764 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 1
store double 0.000000e+00, double* %764
%765 = load double*, double** %11
%766 = getelementptr inbounds double, double* %765, i64 0
%767 = load double, double* %766
%768 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 2
store double %767, double* %768
%769 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%770 = load double, double* %769
%771 = load double*, double** %10
%772 = getelementptr inbounds double, double* %771, i64 0
store double %770, double* %772
%773 = load double*, double** %10
%774 = getelementptr inbounds double, double* %773, i64 1
store double 0.000000e+00, double* %774
%775 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%776 = load double, double* %775
%777 = load double*, double** %10
%778 = getelementptr inbounds double, double* %777, i64 2
store double %776, double* %778
%779 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%780 = load double, double* %779
%781 = load double*, double** %11
%782 = getelementptr inbounds double, double* %781, i64 2
%783 = load double, double* %782
%784 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%785 = load double, double* %784
%786 = load double*, double** %11
%787 = getelementptr inbounds double, double* %786, i64 0
%788 = load double, double* %787
%789 = fmul double %785, %788
%790 = call double @llvm.fmuladd.f64(double %780, double %783, double %789)
store double %790, double* %17
br label %791
791: ; preds = %759, %756
%792 = load i32, i32* %9
%793 = icmp eq i32 %792, 2
br i1 %793, label %794, label %829
794: ; preds = %791
%795 = load double*, double** %11
%796 = getelementptr inbounds double, double* %795, i64 0
%797 = load double, double* %796
%798 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
store double %797, double* %798
%799 = load double*, double** %11
%800 = getelementptr inbounds double, double* %799, i64 1
%801 = load double, double* %800
%802 = fneg double %801
%803 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 1
store double %802, double* %803
%804 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 2
store double 0.000000e+00, double* %804
%805 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%806 = load double, double* %805
%807 = load double*, double** %10
%808 = getelementptr inbounds double, double* %807, i64 0
store double %806, double* %808
%809 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%810 = load double, double* %809
%811 = fneg double %810
%812 = load double*, double** %10
%813 = getelementptr inbounds double, double* %812, i64 1
store double %811, double* %813
%814 = load double*, double** %10
%815 = getelementptr inbounds double, double* %814, i64 2
store double 0.000000e+00, double* %815
%816 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%817 = load double, double* %816
%818 = load double*, double** %11
%819 = getelementptr inbounds double, double* %818, i64 0
%820 = load double, double* %819
%821 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%822 = load double, double* %821
%823 = load double*, double** %11
%824 = getelementptr inbounds double, double* %823, i64 1
%825 = load double, double* %824
%826 = fmul double %822, %825
%827 = fneg double %826
%828 = call double @llvm.fmuladd.f64(double %817, double %820, double %827)
store double %828, double* %17
br label %829
829: ; preds = %794, %791
%830 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0, i64 0
%831 = getelementptr inbounds [3 x double], [3 x double]* %27, i64 0, i64 0
%832 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%833 = call i32 @r3mx(double* %830, double* %831, double* %832)
%834 = load double*, double** %10
%835 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0, i64 0
%836 = call i32 @r3add(double* %834, double* %835)
br label %1021
837: ; preds = %655
%838 = load i32, i32* %8
%839 = icmp eq i32 %838, 2
br i1 %839, label %840, label %1020
840: ; preds = %837
%841 = bitcast [3 x double]* %29 to i8*
%842 = bitcast [3 x double]* %30 to i8*
%843 = load i32, i32* %9
%844 = icmp eq i32 %843, -2
br i1 %844, label %845, label %873
845: ; preds = %840
%846 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%847 = load double, double* %846
%848 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
store double %847, double* %848
%849 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%850 = load double, double* %849
%851 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
store double %850, double* %851
%852 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 2
store double 0.000000e+00, double* %852
%853 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%854 = load double, double* %853
%855 = fneg double %854
%856 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
store double %855, double* %856
%857 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%858 = load double, double* %857
%859 = fneg double %858
%860 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 1
store double %859, double* %860
%861 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 2
store double 0.000000e+00, double* %861
%862 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%863 = load double, double* %862
%864 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%865 = load double, double* %864
%866 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%867 = load double, double* %866
%868 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%869 = load double, double* %868
%870 = fmul double %867, %869
%871 = fneg double %870
%872 = call double @llvm.fmuladd.f64(double %863, double %865, double %871)
store double %872, double* %17
br label %873
873: ; preds = %845, %840
%874 = load i32, i32* %9
%875 = icmp eq i32 %874, -1
br i1 %875, label %876, label %904
876: ; preds = %873
%877 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
store double 0.000000e+00, double* %877
%878 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%879 = load double, double* %878
%880 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
store double %879, double* %880
%881 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%882 = load double, double* %881
%883 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 2
store double %882, double* %883
%884 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
store double 0.000000e+00, double* %884
%885 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%886 = load double, double* %885
%887 = fneg double %886
%888 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 1
store double %887, double* %888
%889 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%890 = load double, double* %889
%891 = fneg double %890
%892 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 2
store double %891, double* %892
%893 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%894 = load double, double* %893
%895 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%896 = load double, double* %895
%897 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%898 = load double, double* %897
%899 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%900 = load double, double* %899
%901 = fmul double %898, %900
%902 = fneg double %901
%903 = call double @llvm.fmuladd.f64(double %894, double %896, double %902)
store double %903, double* %17
br label %904
904: ; preds = %876, %873
%905 = load i32, i32* %9
%906 = icmp eq i32 %905, 0
br i1 %906, label %907, label %934
907: ; preds = %904
%908 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
store double 0.000000e+00, double* %908
%909 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
store double 0.000000e+00, double* %909
%910 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%911 = load double, double* %910
%912 = fmul double %911, 0x3FFBB67AE8584CAA
%913 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 2
store double %912, double* %913
%914 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
store double 0.000000e+00, double* %914
%915 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 1
store double 0.000000e+00, double* %915
%916 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%917 = load double, double* %916
%918 = fneg double %917
%919 = fmul double %918, 0x3FFBB67AE8584CAA
%920 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 2
store double %919, double* %920
%921 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%922 = load double, double* %921
%923 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%924 = load double, double* %923
%925 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%926 = load double, double* %925
%927 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%928 = load double, double* %927
%929 = fmul double %926, %928
%930 = fneg double %929
%931 = call double @llvm.fmuladd.f64(double %922, double %924, double %930)
%932 = fmul double %931, 5.000000e-01
%933 = fmul double %932, 0x3FFBB67AE8584CAA
store double %933, double* %17
br label %934
934: ; preds = %907, %904
%935 = load i32, i32* %9
%936 = icmp eq i32 %935, 1
br i1 %936, label %937, label %965
937: ; preds = %934
%938 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%939 = load double, double* %938
%940 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
store double %939, double* %940
%941 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
store double 0.000000e+00, double* %941
%942 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%943 = load double, double* %942
%944 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 2
store double %943, double* %944
%945 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%946 = load double, double* %945
%947 = fneg double %946
%948 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
store double %947, double* %948
%949 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 1
store double 0.000000e+00, double* %949
%950 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%951 = load double, double* %950
%952 = fneg double %951
%953 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 2
store double %952, double* %953
%954 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%955 = load double, double* %954
%956 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 2
%957 = load double, double* %956
%958 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%959 = load double, double* %958
%960 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%961 = load double, double* %960
%962 = fmul double %959, %961
%963 = fneg double %962
%964 = call double @llvm.fmuladd.f64(double %955, double %957, double %963)
store double %964, double* %17
br label %965
965: ; preds = %937, %934
%966 = load i32, i32* %9
%967 = icmp eq i32 %966, 2
br i1 %967, label %968, label %1008
968: ; preds = %965
%969 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%970 = load double, double* %969
%971 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
store double %970, double* %971
%972 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%973 = load double, double* %972
%974 = fneg double %973
%975 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
store double %974, double* %975
%976 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 2
store double 0.000000e+00, double* %976
%977 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%978 = load double, double* %977
%979 = fneg double %978
%980 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
store double %979, double* %980
%981 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%982 = load double, double* %981
%983 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 1
store double %982, double* %983
%984 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 2
store double 0.000000e+00, double* %984
%985 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%986 = load double, double* %985
%987 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 0
%988 = load double, double* %987
%989 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%990 = load double, double* %989
%991 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0, i64 1
%992 = load double, double* %991
%993 = fmul double %990, %992
%994 = fneg double %993
%995 = call double @llvm.fmuladd.f64(double %986, double %988, double %994)
%996 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%997 = load double, double* %996
%998 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%999 = load double, double* %998
%1000 = call double @llvm.fmuladd.f64(double %997, double %999, double %995)
%1001 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%1002 = load double, double* %1001
%1003 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%1004 = load double, double* %1003
%1005 = fneg double %1002
%1006 = call double @llvm.fmuladd.f64(double %1005, double %1004, double %1000)
%1007 = fmul double %1006, 5.000000e-01
store double %1007, double* %17
br label %1008
1008: ; preds = %968, %965
%1009 = load double*, double** %10
%1010 = getelementptr inbounds [3 x double], [3 x double]* %30, i64 0, i64 0
%1011 = getelementptr inbounds [9 x double], [9 x double]* %19, i64 0, i64 0
%1012 = call i32 @r3mx(double* %1009, double* %1010, double* %1011)
%1013 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 0, i64 0
%1014 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 0
%1015 = getelementptr inbounds [9 x double], [9 x double]* %18, i64 0, i64 0
%1016 = call i32 @r3mx(double* %1013, double* %1014, double* %1015)
%1017 = load double*, double** %10
%1018 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 0, i64 0
%1019 = call i32 @r3add(double* %1017, double* %1018)
br label %1020
1020: ; preds = %1008, %837
br label %1021
1021: ; preds = %1020, %829
br label %1022
1022: ; preds = %1021, %654
br label %1023
1023: ; preds = %1022, %507
br label %1024
1024: ; preds = %1023, %321
br label %1025
1025: ; preds = %1024, %176
br label %1026
1026: ; preds = %1025, %175
%1027 = load double, double* %17
store double %1027, double* %6
br label %1028
1028: ; preds = %1026, %36
%1029 = load double, double* %6
ret double %1029
}

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