void compute_gv(double xlylzl[][3], double omega[], double omegasign,
                double wvln, double wedge, double chi, double t[3],
                double gv[][3], int n) {
  double sc, cc, sw, cw, wmat[9], cmat[9], mat[9], u[3], d[3], v[3];
  double modyz, o[3], co, so, ds, k[3];
  int i;
  sw = sin(wedge * 3.14159265358979323846 / 180.0);
  cw = cos(wedge * 3.14159265358979323846 / 180.0);
  wmat[0] = cw;
  wmat[1] = 0.0;
  wmat[2] = -sw;
  wmat[3] = 0.;
  wmat[4] = 1.0;
  wmat[5] = 0.;
  wmat[6] = sw;
  wmat[7] = 0.0;
  wmat[8] = cw;
  sc = sin(chi * 3.14159265358979323846 / 180.0);
  cc = cos(chi * 3.14159265358979323846 / 180.0);
  cmat[0] = 1.;
  cmat[1] = 0.0;
  cmat[2] = 0.;
  cmat[3] = 0.;
  cmat[4] = cc;
  cmat[5] = -sc;
  cmat[6] = 0.;
  cmat[7] = sc;
  cmat[8] = cc;
  (mat)[0] =
      (cmat)[0] * (wmat)[0] + (cmat)[3] * (wmat)[1] + (cmat)[6] * (wmat)[2];
  (mat)[1] =
      (cmat)[1] * (wmat)[0] + (cmat)[4] * (wmat)[1] + (cmat)[7] * (wmat)[2];
  (mat)[2] =
      (cmat)[2] * (wmat)[0] + (cmat)[5] * (wmat)[1] + (cmat)[8] * (wmat)[2];
  (mat)[3] =
      (cmat)[0] * (wmat)[3] + (cmat)[3] * (wmat)[4] + (cmat)[6] * (wmat)[5];
  (mat)[4] =
      (cmat)[1] * (wmat)[3] + (cmat)[4] * (wmat)[4] + (cmat)[7] * (wmat)[5];
  (mat)[5] =
      (cmat)[2] * (wmat)[3] + (cmat)[5] * (wmat)[4] + (cmat)[8] * (wmat)[5];
  (mat)[6] =
      (cmat)[0] * (wmat)[6] + (cmat)[3] * (wmat)[7] + (cmat)[6] * (wmat)[8];
  (mat)[7] =
      (cmat)[1] * (wmat)[6] + (cmat)[4] * (wmat)[7] + (cmat)[7] * (wmat)[8];
  (mat)[8] =
      (cmat)[2] * (wmat)[6] + (cmat)[5] * (wmat)[7] + (cmat)[8] * (wmat)[8];
  ;
#pragma omp parallel for private(so, co, u, o, d, modyz, ds, v, k)
  for (i = 0; i < n; i++) {
    so = sin(3.14159265358979323846 / 180.0 * omega[i] * omegasign);
    co = cos(3.14159265358979323846 / 180.0 * omega[i] * omegasign);
    u[0] = co * t[0] - so * t[1];
    u[1] = so * t[0] + co * t[1];
    u[2] = t[2];
    (o)[0] = (mat)[0] * (u)[0] + (mat)[1] * (u)[1] + (mat)[2] * (u)[2];
    (o)[1] = (mat)[3] * (u)[0] + (mat)[4] * (u)[1] + (mat)[5] * (u)[2];
    (o)[2] = (mat)[6] * (u)[0] + (mat)[7] * (u)[1] + (mat)[8] * (u)[2];
    ;
    (d)[0] = (xlylzl[i])[0] - (o)[0];
    (d)[1] = (xlylzl[i])[1] - (o)[1];
    (d)[2] = (xlylzl[i])[2] - (o)[2];
    ;
    modyz = 1. / sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
    ds = 1. / wvln;
    k[0] = ds * (d[0] * modyz - 1.);
    k[1] = ds * d[1] * modyz;
    k[2] = ds * d[2] * modyz;
    (v)[0] = (mat)[0] * (k)[0] + (mat)[3] * (k)[1] + (mat)[6] * (k)[2];
    (v)[1] = (mat)[1] * (k)[0] + (mat)[4] * (k)[1] + (mat)[7] * (k)[2];
    (v)[2] = (mat)[2] * (k)[0] + (mat)[5] * (k)[1] + (mat)[8] * (k)[2];
    ;
    gv[i][0] = co * v[0] + so * v[1];
    gv[i][1] = -so * v[0] + co * v[1];
    gv[i][2] = v[2];
  }
}


x86 assembly (clang, -O0):
<compute_gv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
movsd  %xmm2,-0x28(%rbp)
movsd  %xmm3,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8d,-0x44(%rbp)
movsd  0xea5(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  0xe90(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  0xe82(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  0xe6d(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xe08(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xde1(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  0xdcc(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  0xdbe(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  0xda9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  0xd8b(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x204(%rbp)
mov    -0x204(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a28 <compute_gv+0x8f8>
mov    -0x10(%rbp),%rax
movslq -0x204(%rbp),%rcx
movsd  0xa93(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x18(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x204(%rbp),%rcx
movsd  0xa69(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x18(%rbp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x1e0(%rbp),%xmm1
ff
mov    -0x38(%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,-0x170(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x1d8(%rbp),%xmm1
ff
mov    -0x38(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm2
ff
movsd  -0x148(%rbp),%xmm0
ff
mulsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x140(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x138(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm2
ff
movsd  -0x118(%rbp),%xmm0
ff
mulsd  -0x168(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
subsd  -0x1d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
subsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
subsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x190(%rbp),%xmm2
ff
movsd  -0x188(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x180(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x80c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  0x7f8(%rip),%xmm0
divsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm1
ff
movsd  -0x1b8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  0x7df(%rip),%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  -0x188(%rbp),%xmm0
ff
mulsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
mulsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm0
ff
mulsd  -0x1f8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x148(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x1f8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm0
ff
mulsd  -0x1f8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1e0(%rbp),%xmm1
ff
mulsd  -0x1a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  -0x1e0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1d8(%rbp),%xmm1
ff
mulsd  -0x1a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x1a0(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movslq -0x204(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    156b <compute_gv+0x43b>
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_gv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r8d,%ebp
mov    %rcx,%r14
mov    %rdx,%r15
movsd  %xmm3,0x20(%rsp)
movsd  %xmm1,0x60(%rsp)
movsd  %xmm0,0x58(%rsp)
mov    %rsi,%rbx
mov    %rdi,%r12
movapd %xmm2,%xmm0
mulsd  0xe92(%rip),%xmm0
divsd  0xe92(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <cos@plt>
movsd  %xmm0,(%rsp)
movsd  0x20(%rsp),%xmm0
mulsd  0xe5b(%rip),%xmm0
divsd  0xe5b(%rip),%xmm0
movsd  %xmm0,0x20(%rsp)
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x20(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x8(%rsp),%xmm10
movsd  0x10(%rsp),%xmm9
test   %ebp,%ebp
jle    15cc <compute_gv+0x49c>
movapd %xmm0,%xmm15
xorpd  %xmm6,%xmm6
movsd  (%rsp),%xmm5
movapd %xmm5,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm6,%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movapd %xmm15,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm6,%xmm2
movapd %xmm10,%xmm3
mulsd  %xmm9,%xmm3
movapd %xmm2,%xmm11
movapd %xmm15,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm6,%xmm9
addsd  %xmm2,%xmm9
movapd %xmm2,%xmm12
addsd  %xmm1,%xmm12
subsd  %xmm3,%xmm12
movsd  0xdbd(%rip),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm2,%xmm11
subsd  %xmm4,%xmm11
movapd %xmm15,%xmm3
addsd  %xmm6,%xmm3
movapd %xmm10,%xmm13
mulsd  %xmm6,%xmm13
addsd  %xmm3,%xmm13
xorpd  %xmm14,%xmm14
subsd  %xmm10,%xmm14
addsd  %xmm1,%xmm14
addsd  %xmm0,%xmm1
mulsd  %xmm5,%xmm10
addsd  %xmm1,%xmm10
addsd  %xmm0,%xmm2
mulsd  %xmm5,%xmm15
addsd  %xmm2,%xmm15
movsd  0xd6b(%rip),%xmm0
divsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x88(%rsp)
mov    %ebp,%eax
shl    $0x3,%rax
lea    (%rax,%rax,2),%r13
xor    %ebp,%ebp
movsd  %xmm9,0x10(%rsp)
movsd  %xmm10,0x8(%rsp)
movsd  %xmm15,(%rsp)
movsd  %xmm11,0x50(%rsp)
movsd  %xmm12,0x48(%rsp)
movsd  %xmm13,0x40(%rsp)
movsd  %xmm14,0x38(%rsp)
jmp    144f <compute_gv+0x31f>
nopl   (%rax)
movapd %xmm7,0x90(%rsp)
movsd  %xmm4,0x80(%rsp)
movsd  %xmm5,0x78(%rsp)
movsd  %xmm2,0x70(%rsp)
call   1050 <sqrt@plt>
movsd  0x70(%rsp),%xmm2
movsd  0x78(%rsp),%xmm5
movsd  0x80(%rsp),%xmm4
movapd 0x90(%rsp),%xmm7
movapd 0x20(%rsp),%xmm3
movsd  0x38(%rsp),%xmm14
movsd  0x40(%rsp),%xmm13
movsd  0x48(%rsp),%xmm12
movsd  0x50(%rsp),%xmm11
xorpd  %xmm8,%xmm8
movsd  (%rsp),%xmm15
movsd  0x8(%rsp),%xmm10
movsd  0x10(%rsp),%xmm9
movsd  0xc94(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm5
addsd  0xc94(%rip),%xmm5
movsd  0x88(%rsp),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm2,%xmm0
mulsd  %xmm8,%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm13,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm2,%xmm6
movapd %xmm12,%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm10,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm14,%xmm6
mulsd  %xmm11,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm15,%xmm4
addsd  %xmm5,%xmm4
unpcklpd %xmm7,%xmm3
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
unpcklpd 0x60(%rsp),%xmm7
unpcklpd %xmm0,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rbp,1)
movsd  %xmm4,0x10(%r14,%rbp,1)
add    $0x8,%rbx
add    $0x18,%rbp
cmp    %rbp,%r13
je     15cc <compute_gv+0x49c>
movsd  (%rbx),%xmm0
movsd  0xbc5(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  0x58(%rsp),%xmm0
call   1030 <sin@plt>
movapd %xmm0,0x20(%rsp)
movsd  (%rbx),%xmm0
mulsd  0xba4(%rip),%xmm0
mulsd  0x58(%rsp),%xmm0
call   1040 <cos@plt>
movsd  0x38(%rsp),%xmm14
movsd  0x40(%rsp),%xmm13
movsd  0x48(%rsp),%xmm12
movsd  0x50(%rsp),%xmm11
xorpd  %xmm8,%xmm8
movsd  0x8(%rsp),%xmm6
movsd  0x10(%rsp),%xmm5
movapd %xmm0,%xmm7
movsd  (%r15),%xmm0
movsd  0x8(%r15),%xmm1
movapd %xmm7,%xmm2
mulsd  %xmm1,%xmm2
movapd 0x20(%rsp),%xmm4
mulsd  %xmm4,%xmm1
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm3
movapd %xmm4,%xmm1
movapd %xmm4,%xmm10
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  0x10(%r15),%xmm0
movapd %xmm12,%xmm2
mulsd  %xmm1,%xmm2
movsd  0x18(%rsp),%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm11,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm4,%xmm2
movapd %xmm13,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm5,%xmm9
mulsd  %xmm3,%xmm5
mulsd  %xmm8,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm14,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm10,%xmm3
mulsd  %xmm6,%xmm1
addsd  %xmm5,%xmm1
movsd  (%rsp),%xmm15
mulsd  %xmm15,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r12,%rbp,1),%xmm5
subsd  %xmm2,%xmm5
movsd  0x8(%r12,%rbp,1),%xmm2
subsd  %xmm4,%xmm2
movsd  0x10(%r12,%rbp,1),%xmm4
subsd  %xmm0,%xmm4
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm10,%xmm1
xorpd  0xa83(%rip),%xmm1
ucomisd %xmm8,%xmm0
movapd %xmm1,0x60(%rsp)
jb     1300 <compute_gv+0x1d0>
movapd %xmm6,%xmm10
sqrtsd %xmm0,%xmm0
jmp    137c <compute_gv+0x24c>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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