void cl_invert(double v[], double r[]) {
  int a, i, b, j, ax, ix;
  for (a = 0; a < 3; a++)
    for (i = 0; i < 2; i++) {
      for (b = 0; b < 3; b++)
        for (j = 0; j < 2; j++) {
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] =
              ((b == a) && (i == j)) ? 1.0 : 0.0;
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] = 0;
        }
    }
  for (a = 0; a < 3; a++)
    for (i = 0; i < 2; i++) {
      double x = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((i) + 2 * (a))))]))[0];
      double y = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((i) + 2 * (a))))]))[1];
      double d = x * x + y * y;
      int am = a;
      int im = i;
      for (ax = a, ix = i + 1; ix < 2; ix++) {
        double xx = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((ix) + 2 * (ax))))]))[0];
        double yy = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((ix) + 2 * (ax))))]))[1];
        double dd = xx * xx + yy * yy;
        if (dd > d)
          d = dd, am = ax, im = ix;
      }
      for (ax = a + 1; ax < 3; ax++) {
        for (ix = 0; ix < 2; ix++) {
          double xx =
              (&((r)[2 * ((i) + 2 * ((a) + 3 * ((ix) + 2 * (ax))))]))[0];
          double yy =
              (&((r)[2 * ((i) + 2 * ((a) + 3 * ((ix) + 2 * (ax))))]))[1];
          double dd = xx * xx + yy * yy;
          if (dd > d)
            d = dd, am = ax, im = ix;
        }
      }
      if ((am != a) || (im != i)) {
        for (b = a, j = i; j < 2; j++) {
          double x = (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0];
          double y = (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1];
          (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] =
              (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0];
          (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] =
              (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1];
          (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0] = x;
          (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1] = y;
        }
        for (b = a + 1; b < 3; b++) {
          for (j = 0; j < 2; j++) {
            double x = (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0];
            double y = (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1];
            (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] =
                (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0];
            (&((r)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] =
                (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1];
            (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0] = x;
            (&((r)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1] = y;
          }
        }
        for (b = 0; b < 3; b++)
          for (j = 0; j < 2; j++) {
            double x = (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0];
            double y = (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1];
            (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] =
                (&((v)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0];
            (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] =
                (&((v)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1];
            (&((v)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[0] = x;
            (&((v)[2 * ((j) + 2 * ((b) + 3 * ((im) + 2 * (am))))]))[1] = y;
          }
      }
      for (b = a, j = i + 1; j < 2; j++) {
        project_r(a, i, b, j, r);
        project_v(a, i, b, j, r, v);
      }
      for (b = a + 1; b < 3; b++) {
        for (j = 0; j < 2; j++) {
          project_r(a, i, b, j, r);
          project_v(a, i, b, j, r, v);
        }
      }
    }
  for (a = 3; a--;) {
    for (i = 2; i--;) {
      double x = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((i) + 2 * (a))))]))[0];
      double y = (&((r)[2 * ((i) + 2 * ((a) + 3 * ((i) + 2 * (a))))]))[1];
      double dd = 1 / (x * x + y * y);
      x = x * dd;
      y = -y * dd;
      for (b = 0; b < 3; b++)
        for (j = 0; j < 2; j++) {
          double z = (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0];
          double t = (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1];
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] =
              x * z - y * t;
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] =
              x * t + y * z;
        }
      for (b = 0; b < a; b++) {
        for (j = 0; j < 2; j++) {
          scale(a, i, b, j, r, v);
        }
      }
      for (b = a, j = 0; j < i; j++) {
        scale(a, i, b, j, r, v);
      }
    }
  }
}


x86 assembly (clang, -O0):
<cl_invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    128a <cl_invert+0x15a>
movl   $0x0,-0x18(%rbp)
cmpl   $0x2,-0x18(%rbp)
jge    1277 <cl_invert+0x147>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1264 <cl_invert+0x134>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1251 <cl_invert+0x121>
mov    -0x1c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0xd1(%rbp)
jne    11aa <cl_invert+0x7a>
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
sete   %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
movsd  0xe48(%rip),%xmm0
xorps  %xmm1,%xmm1
movsd  %xmm1,-0xe8(%rbp)
ff
test   $0x1,%al
movsd  %xmm0,-0xe0(%rbp)
ff
jne    11e3 <cl_invert+0xb3>
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    117d <cl_invert+0x4d>
jmp    1256 <cl_invert+0x126>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    116c <cl_invert+0x3c>
jmp    1269 <cl_invert+0x139>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    115b <cl_invert+0x2b>
jmp    127c <cl_invert+0x14c>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114a <cl_invert+0x1a>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1b0f <cl_invert+0x9df>
movl   $0x0,-0x18(%rbp)
cmpl   $0x2,-0x18(%rbp)
jge    1afc <cl_invert+0x9cc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    140a <cl_invert+0x2da>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x28(%rbp),%esi
mov    -0x24(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x28(%rbp),%esi
mov    -0x24(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    13f7 <cl_invert+0x2c7>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    13fc <cl_invert+0x2cc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1347 <cl_invert+0x217>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    14fa <cl_invert+0x3ca>
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    14e7 <cl_invert+0x3b7>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x28(%rbp),%esi
mov    -0x24(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x28(%rbp),%esi
mov    -0x24(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    14d4 <cl_invert+0x3a4>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    14d9 <cl_invert+0x3a9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1424 <cl_invert+0x2f4>
jmp    14ec <cl_invert+0x3bc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1413 <cl_invert+0x2e3>
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1512 <cl_invert+0x3e2>
mov    -0x48(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1a19 <cl_invert+0x8e9>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    16a4 <cl_invert+0x574>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    151e <cl_invert+0x3ee>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    185d <cl_invert+0x72d>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    184a <cl_invert+0x71a>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    16be <cl_invert+0x58e>
jmp    184f <cl_invert+0x71f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ad <cl_invert+0x57d>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1a14 <cl_invert+0x8e4>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1a01 <cl_invert+0x8d1>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1875 <cl_invert+0x745>
jmp    1a06 <cl_invert+0x8d6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1864 <cl_invert+0x734>
jmp    1a19 <cl_invert+0x8e9>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1a72 <cl_invert+0x942>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    $0x0,%al
call   1030 <project_r@plt>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    -0x8(%rbp),%r9
mov    $0x0,%al
call   1040 <project_v@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1a28 <cl_invert+0x8f8>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1ae9 <cl_invert+0x9b9>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1ad6 <cl_invert+0x9a6>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    $0x0,%al
call   1030 <project_r@plt>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    -0x8(%rbp),%r9
mov    $0x0,%al
call   1040 <project_v@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1a8c <cl_invert+0x95c>
jmp    1adb <cl_invert+0x9ab>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1a7b <cl_invert+0x94b>
jmp    1aee <cl_invert+0x9be>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12a2 <cl_invert+0x172>
jmp    1b01 <cl_invert+0x9d1>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1291 <cl_invert+0x161>
movl   $0x3,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     1e3d <cl_invert+0xd0d>
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     1e38 <cl_invert+0xd08>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x426(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1d91 <cl_invert+0xc61>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1d7e <cl_invert+0xc4e>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1c45 <cl_invert+0xb15>
jmp    1d83 <cl_invert+0xc53>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1c34 <cl_invert+0xb04>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1df1 <cl_invert+0xcc1>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    1dde <cl_invert+0xcae>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    -0x8(%rbp),%r9
mov    $0x0,%al
call   1050 <scale@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1dab <cl_invert+0xc7b>
jmp    1de3 <cl_invert+0xcb3>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1d98 <cl_invert+0xc68>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1e33 <cl_invert+0xd03>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x10(%rbp),%r8
mov    -0x8(%rbp),%r9
mov    $0x0,%al
call   1050 <scale@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1dfe <cl_invert+0xcce>
jmp    1b31 <cl_invert+0xa01>
jmp    1b16 <cl_invert+0x9e6>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cl_invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,%r13
mov    %rdi,%r14
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rdi)
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rdi)
movups %xmm0,0x18(%rdi)
movups %xmm0,0x28(%rdi)
movups %xmm0,0x38(%rdi)
movups %xmm0,0x48(%rdi)
movups %xmm0,0x58(%rdi)
movq   $0x0,0x68(%rdi)
mov    %rax,0x70(%rdi)
movups %xmm0,0x78(%rdi)
movups %xmm0,0x88(%rdi)
movups %xmm0,0x98(%rdi)
movups %xmm0,0xa8(%rdi)
movups %xmm0,0xb8(%rdi)
movups %xmm0,0xc8(%rdi)
movq   $0x0,0xd8(%rdi)
mov    %rax,0xe0(%rdi)
movups %xmm0,0xe8(%rdi)
movups %xmm0,0xf8(%rdi)
movups %xmm0,0x108(%rdi)
movups %xmm0,0x118(%rdi)
movups %xmm0,0x128(%rdi)
movups %xmm0,0x138(%rdi)
movq   $0x0,0x148(%rdi)
mov    %rax,0x150(%rdi)
movups %xmm0,0x158(%rdi)
movups %xmm0,0x168(%rdi)
movups %xmm0,0x178(%rdi)
movups %xmm0,0x188(%rdi)
movups %xmm0,0x198(%rdi)
movups %xmm0,0x1a8(%rdi)
movq   $0x0,0x1b8(%rdi)
mov    %rax,0x1c0(%rdi)
movups %xmm0,0x1c8(%rdi)
movups %xmm0,0x1d8(%rdi)
movups %xmm0,0x1e8(%rdi)
movups %xmm0,0x1f8(%rdi)
movups %xmm0,0x208(%rdi)
movups %xmm0,0x218(%rdi)
movq   $0x0,0x228(%rdi)
movsd  0xd9a(%rip),%xmm0
movupd %xmm0,0x230(%rdi)
mov    $0x18,%eax
mov    %rax,0x18(%rsp)
movq   $0xfffffffffffffffe,0x10(%rsp)
ff ff
mov    $0x4,%eax
mov    %rax,0x8(%rsp)
mov    $0x2,%eax
mov    %rax,(%rsp)
xor    %r9d,%r9d
mov    $0x1,%r10d
xor    %r15d,%r15d
jmp    12d9 <cl_invert+0x1a9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addq   $0x1c,0x18(%rsp)
addq   $0x1,0x10(%rsp)
addq   $0x4,0x8(%rsp)
addq   $0xffffffffffffffff,(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,%r15
cmp    $0x3,%rax
je     1719 <cl_invert+0x5e9>
lea    (%r15,%r15,1),%rax
mov    %rax,0x30(%rsp)
lea    0x1(%r15),%rax
mov    %rax,0x20(%rsp)
lea    (%r15,%r15,1),%eax
add    $0x1,%eax
lea    (%rax,%rax,2),%eax
cltq
add    %r15,%rax
shl    $0x2,%rax
mov    %rax,0x28(%rsp)
mov    $0x1,%r11b
xor    %r12d,%r12d
jmp    132d <cl_invert+0x1fd>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r12d
test   $0x1,%bl
mov    $0x0,%r11d
mov    $0x0,%r9d
mov    $0x1,%r10d
je     12b0 <cl_invert+0x180>
mov    %r12,%r8
or     0x30(%rsp),%r8
lea    (%r8,%r8,2),%eax
add    %r15d,%eax
add    %eax,%eax
cltq
or     %r12,%rax
shl    $0x4,%rax
movsd  0x0(%r13,%rax,1),%xmm0
movsd  0x8(%r13,%rax,1),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
test   $0x1,%r11b
je     13b0 <cl_invert+0x280>
mov    0x28(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
movsd  0x8(%r13,%rax,8),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
xor    %eax,%eax
ucomisd %xmm0,%xmm1
seta   %al
maxsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
cmp    $0x1,%r15
jbe    13b9 <cl_invert+0x289>
mov    %r15d,%ecx
jmp    143b <cl_invert+0x30b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%eax
cmp    $0x1,%r15
ja     139d <cl_invert+0x26d>
lea    (%r12,%r12,1),%rsi
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rdx
mov    %r15d,%ecx
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rbp
or     %rsi,%rbp
movsd  0x0(%r13,%rbp,8),%xmm1
movsd  0x8(%r13,%rbp,8),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
lea    0xc(%rdx),%rbp
or     %rsi,%rbp
ucomisd %xmm0,%xmm1
cmova  %r9d,%eax
lea    0x3(%rdi),%ebx
maxsd  %xmm0,%xmm1
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  0x8(%r13,%rbp,8),%xmm2
mulsd  %xmm2,%xmm2
cmova  %ebx,%ecx
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
cmova  %r10d,%eax
cmova  %ebx,%ecx
maxsd  %xmm1,%xmm0
add    $0x18,%rdx
inc    %rdi
jne    13d0 <cl_invert+0x2a0>
mov    %ecx,%edx
cmp    %rdx,%r15
jne    144d <cl_invert+0x31d>
mov    %eax,%edx
cmp    %rdx,%r12
je     1657 <cl_invert+0x527>
lea    (%r8,%r8,2),%r8
lea    (%r8,%r15,1),%rsi
lea    (%rax,%rcx,2),%edx
lea    (%rdx,%rdx,2),%edx
add    %r15d,%edx
lea    0x0(,%rsi,4),%rdi
mov    %r12,%rbp
add    %r12,%rbp
or     %rdi,%rbp
movupd 0x0(%r13,%rbp,8),%xmm0
lea    0x0(,%rdx,4),%edi
lea    (%r12,%r12,1),%ebx
or     %edi,%ebx
movslq %ebx,%rdi
movupd 0x0(%r13,%rdi,8),%xmm1
movupd %xmm1,0x0(%r13,%rbp,8)
movupd %xmm0,0x0(%r13,%rdi,8)
test   $0x1,%r11b
je     14cb <cl_invert+0x39b>
shl    $0x5,%rsi
lea    0x2(,%rdx,4),%edx
movslq %edx,%rdx
movupd 0x10(%r13,%rsi,1),%xmm0
movupd 0x0(%r13,%rdx,8),%xmm1
movupd %xmm1,0x10(%r13,%rsi,1)
movupd %xmm0,0x0(%r13,%rdx,8)
cmp    $0x1,%r15
ja     1542 <cl_invert+0x412>
lea    (%rcx,%rcx,2),%edx
lea    (%rax,%rax,2),%esi
shl    $0x2,%esi
lea    (%rsi,%rdx,8),%esi
mov    %r8,%rdi
shl    $0x5,%rdi
add    %r13,%rdi
mov    (%rsp),%rbp
mov    0x8(%rsp),%rdx
movups (%rdi,%rdx,8),%xmm0
lea    (%rsi,%rdx,1),%rbx
movslq %ebx,%rbx
movups 0x0(%r13,%rbx,8),%xmm1
movups %xmm1,(%rdi,%rdx,8)
movups %xmm0,0x0(%r13,%rbx,8)
movupd 0x10(%rdi,%rdx,8),%xmm0
add    $0x2,%ebx
movslq %ebx,%rbx
movsd  0x0(%r13,%rbx,8),%xmm1
movsd  %xmm1,0x10(%rdi,%rdx,8)
movsd  0x8(%r13,%rbx,8),%xmm1
movsd  %xmm1,0x18(%rdi,%rdx,8)
movupd %xmm0,0x0(%r13,%rbx,8)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rbp
jne    14f0 <cl_invert+0x3c0>
lea    (%rax,%rcx,2),%eax
shl    $0x2,%eax
lea    (%rax,%rax,2),%ecx
shl    $0x5,%r8
movups (%r14,%r8,1),%xmm0
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%r8,1)
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r14,%r8,1)
movups %xmm0,(%r14,%rcx,8)
movups 0x10(%r14,%r8,1),%xmm0
or     $0x2,%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,0x10(%r14,%r8,1)
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,0x18(%r14,%r8,1)
movups %xmm0,(%r14,%rcx,8)
movups 0x20(%r14,%r8,1),%xmm0
lea    0x4(%rax,%rax,2),%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,0x20(%r14,%r8,1)
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,0x28(%r14,%r8,1)
movups %xmm0,(%r14,%rcx,8)
movups 0x30(%r14,%r8,1),%xmm0
lea    0x6(%rax,%rax,2),%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,0x30(%r14,%r8,1)
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,0x38(%r14,%r8,1)
movups %xmm0,(%r14,%rcx,8)
movups 0x40(%r14,%r8,1),%xmm0
lea    0x8(%rax,%rax,2),%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,0x40(%r14,%r8,1)
movsd  0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,0x48(%r14,%r8,1)
movups %xmm0,(%r14,%rcx,8)
movupd 0x50(%r14,%r8,1),%xmm0
lea    0xa(%rax,%rax,2),%eax
cltq
movsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,0x50(%r14,%r8,1)
movsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x58(%r14,%r8,1)
movupd %xmm0,(%r14,%rax,8)
mov    %r11d,%ebx
test   $0x1,%r11b
je     1691 <cl_invert+0x561>
mov    %r15d,%edi
xor    %esi,%esi
mov    %r15d,%edx
mov    $0x1,%ecx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <project_r@plt>
mov    %r15d,%edi
xor    %esi,%esi
mov    %r15d,%edx
mov    $0x1,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1040 <project_v@plt>
mov    0x20(%rsp),%rax
mov    %eax,%ebp
cmp    $0x1,%r15
ja     1310 <cl_invert+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <project_r@plt>
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1040 <project_v@plt>
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <project_r@plt>
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1040 <project_v@plt>
add    $0x1,%ebp
cmp    $0x3,%ebp
jne    16b0 <cl_invert+0x580>
jmp    1310 <cl_invert+0x1e0>
mov    $0x2,%r15d
lea    (%r15,%r15,1),%rbx
mov    $0x1,%r12d
jmp    1755 <cl_invert+0x625>
nopl   0x0(%rax,%rax,1)
test   %r12,%r12
je     18ec <cl_invert+0x7bc>
mov    %r15d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
xor    %ecx,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1050 <scale@plt>
add    $0xffffffffffffffff,%r12
lea    (%r12,%rbx,1),%rax
lea    (%r12,%rbx,1),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %r15d,%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
add    %r12,%rcx
shl    $0x4,%rcx
lea    (%rax,%rax,2),%rax
shl    $0x5,%rax
movsd  0x0(%r13,%rcx,1),%xmm0
movsd  0x8(%r13,%rcx,1),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  0x85f(%rip),%xmm2
divsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
movapd 0x85f(%rip),%xmm3
xorpd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm3,%xmm2
unpcklpd %xmm2,%xmm1
movupd (%r14,%rax,1),%xmm3
movupd 0x10(%r14,%rax,1),%xmm4
movupd 0x20(%r14,%rax,1),%xmm5
movupd 0x30(%r14,%rax,1),%xmm2
movapd %xmm3,%xmm6
mulpd  %xmm1,%xmm6
shufpd $0x1,%xmm6,%xmm6
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm3,(%r14,%rax,1)
movapd %xmm0,%xmm3
mulpd  %xmm4,%xmm3
mulpd  %xmm1,%xmm4
shufpd $0x1,%xmm4,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,0x10(%r14,%rax,1)
movapd %xmm0,%xmm3
mulpd  %xmm5,%xmm3
mulpd  %xmm1,%xmm5
shufpd $0x1,%xmm5,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,0x20(%r14,%rax,1)
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm2,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x30(%r14,%rax,1)
movupd 0x40(%r14,%rax,1),%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
shufpd $0x1,%xmm3,%xmm3
mulpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,0x40(%r14,%rax,1)
movupd 0x50(%r14,%rax,1),%xmm2
mulpd  %xmm2,%xmm1
shufpd $0x1,%xmm1,%xmm1
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,0x50(%r14,%rax,1)
test   %r15,%r15
je     1730 <cl_invert+0x600>
xor    %ebp,%ebp
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1050 <scale@plt>
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    $0x1,%ecx
mov    %r13,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1050 <scale@plt>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    18a0 <cl_invert+0x770>
test   %r12,%r12
jne    1739 <cl_invert+0x609>
add    $0xffffffffffffffff,%r15
jmp    171f <cl_invert+0x5ef>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @cl_invert(double* %0, double* %1) {
store double 1.000000e+00, double* %0
%3 = getelementptr inbounds double, double* %0, i64 1
%4 = getelementptr inbounds double, double* %0, i64 14
%5 = bitcast double* %3 to i8*
store double 1.000000e+00, double* %4
%6 = getelementptr inbounds double, double* %0, i64 15
%7 = getelementptr inbounds double, double* %0, i64 28
%8 = bitcast double* %6 to i8*
store double 1.000000e+00, double* %7
%9 = getelementptr inbounds double, double* %0, i64 29
%10 = getelementptr inbounds double, double* %0, i64 42
%11 = bitcast double* %9 to i8*
store double 1.000000e+00, double* %10
%12 = getelementptr inbounds double, double* %0, i64 43
%13 = getelementptr inbounds double, double* %0, i64 56
%14 = bitcast double* %12 to i8*
store double 1.000000e+00, double* %13
%15 = getelementptr inbounds double, double* %0, i64 57
%16 = getelementptr inbounds double, double* %0, i64 70
%17 = bitcast double* %15 to i8*
%18 = bitcast double* %16 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 0.000000e+00>, <2 x double>* %18
br label %19
19: ; preds = %2, %284
%20 = phi i64 [ 0, %2 ], [ %25, %284 ]
%21 = phi i64 [ 1, %2 ], [ %285, %284 ]
%22 = trunc i64 %20 to i32
%23 = shl nuw nsw i64 %20, 1
%24 = shl nuw nsw i32 %22, 1
%25 = add nuw nsw i64 %20, 1
%26 = icmp ult i64 %20, 2
%27 = or i32 %24, 1
%28 = mul nuw nsw i32 %27, 3
%29 = sext i32 %28 to i64
%30 = add nuw nsw i64 %20, %29
%31 = shl i64 %30, 2
%32 = trunc i64 %25 to i32
%33 = getelementptr inbounds double, double* %1, i64 %31
%34 = getelementptr inbounds double, double* %33, i64 1
br label %36
35: ; preds = %276, %272
br i1 %37, label %36, label %284
36: ; preds = %19, %35
%37 = phi i1 [ true, %19 ], [ false, %35 ]
%38 = phi i64 [ 0, %19 ], [ 1, %35 ]
%39 = trunc i64 %38 to i32
%40 = or i64 %38, %23
%41 = or i64 %38, %23
%42 = trunc i64 %41 to i32
%43 = mul nuw nsw i64 %40, 3
%44 = mul nuw nsw i32 %42, 3
%45 = add nuw nsw i64 %43, %20
%46 = add nuw nsw i32 %44, %22
%47 = shl nuw nsw i32 %46, 1
%48 = sext i32 %47 to i64
%49 = or i64 %38, %48
%50 = shl nsw i64 %49, 1
%51 = getelementptr inbounds double, double* %1, i64 %50
%52 = load double, double* %51
%53 = getelementptr inbounds double, double* %51, i64 1
%54 = load double, double* %53
%55 = fmul double %54, %54
%56 = tail call double @llvm.fmuladd.f64(double %52, double %52, double %55)
br i1 %37, label %57, label %65
57: ; preds = %36
%58 = load double, double* %33
%59 = load double, double* %34
%60 = fmul double %59, %59
%61 = tail call double @llvm.fmuladd.f64(double %58, double %58, double %60)
%62 = fcmp ogt double %61, %56
%63 = zext i1 %62 to i32
%64 = select i1 %62, double %61, double %56
br label %65
65: ; preds = %57, %36
%66 = phi i32 [ %63, %57 ], [ %39, %36 ]
%67 = phi double [ %64, %57 ], [ %56, %36 ]
br i1 %26, label %68, label %109
68: ; preds = %65
%69 = shl nuw nsw i64 %38, 1
%70 = shl nuw nsw i64 %38, 1
br label %71
71: ; preds = %68, %71
%72 = phi i64 [ %107, %71 ], [ %21, %68 ]
%73 = phi double [ %106, %71 ], [ %67, %68 ]
%74 = phi i32 [ %105, %71 ], [ %22, %68 ]
%75 = phi i32 [ %103, %71 ], [ %66, %68 ]
%76 = shl nuw nsw i64 %72, 1
%77 = mul nuw nsw i64 %72, 6
%78 = add nuw nsw i64 %77, %20
%79 = shl i64 %78, 2
%80 = or i64 %79, %69
%81 = getelementptr inbounds double, double* %1, i64 %80
%82 = load double, double* %81
%83 = getelementptr inbounds double, double* %81, i64 1
%84 = load double, double* %83
%85 = fmul double %84, %84
%86 = tail call double @llvm.fmuladd.f64(double %82, double %82, double %85)
%87 = fcmp ogt double %86, %73
%88 = select i1 %87, i32 0, i32 %75
%89 = trunc i64 %72 to i32
%90 = select i1 %87, double %86, double %73
%91 = or i64 %76, 1
%92 = mul nuw nsw i64 %91, 3
%93 = add nuw nsw i64 %92, %20
%94 = shl i64 %93, 2
%95 = or i64 %94, %70
%96 = getelementptr inbounds double, double* %1, i64 %95
%97 = load double, double* %96
%98 = getelementptr inbounds double, double* %96, i64 1
%99 = load double, double* %98
%100 = fmul double %99, %99
%101 = tail call double @llvm.fmuladd.f64(double %97, double %97, double %100)
%102 = fcmp ogt double %101, %90
%103 = select i1 %102, i32 1, i32 %88
%104 = or i1 %102, %87
%105 = select i1 %104, i32 %89, i32 %74
%106 = select i1 %102, double %101, double %90
%107 = add nuw nsw i64 %72, 1
%108 = icmp eq i64 %107, 3
br i1 %108, label %109, label %71
109: ; preds = %71, %65
%110 = phi i32 [ %66, %65 ], [ %103, %71 ]
%111 = phi i32 [ %22, %65 ], [ %105, %71 ]
%112 = zext i32 %111 to i64
%113 = icmp eq i64 %20, %112
%114 = zext i32 %110 to i64
%115 = icmp eq i64 %38, %114
%116 = select i1 %113, i1 %115, i1 false
br i1 %116, label %271, label %117
117: ; preds = %109
%118 = shl nsw i32 %111, 1
%119 = add nsw i32 %118, %110
%120 = mul nsw i32 %119, 3
%121 = add nsw i32 %120, %22
%122 = trunc i64 %38 to i32
%123 = shl i64 %45, 2
%124 = shl nuw nsw i64 %38, 1
%125 = or i64 %123, %124
%126 = getelementptr inbounds double, double* %1, i64 %125
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = shl i32 %121, 2
%130 = shl nuw nsw i32 %122, 1
%131 = or i32 %129, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %1, i64 %132
%134 = bitcast double* %133 to <2 x double>*
%135 = load <2 x double>, <2 x double>* %134
%136 = bitcast double* %126 to <2 x double>*
store <2 x double> %135, <2 x double>* %136
%137 = bitcast double* %133 to <2 x double>*
store <2 x double> %128, <2 x double>* %137
br i1 %37, label %138, label %152
138: ; preds = %117
%139 = shl i64 %45, 2
%140 = or i64 %139, 2
%141 = getelementptr inbounds double, double* %1, i64 %140
%142 = bitcast double* %141 to <2 x double>*
%143 = shl i32 %121, 2
%144 = or i32 %143, 2
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds double, double* %1, i64 %145
%147 = bitcast double* %146 to <2 x double>*
%148 = bitcast double* %141 to <2 x double>*
%149 = bitcast double* %146 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %142
%151 = load <2 x double>, <2 x double>* %147
store <2 x double> %151, <2 x double>* %148
store <2 x double> %150, <2 x double>* %149
br label %152
152: ; preds = %138, %117
%153 = shl nsw i32 %111, 1
%154 = add nsw i32 %153, %110
%155 = mul nsw i32 %154, 3
br i1 %26, label %239, label %156
156: ; preds = %239, %152
%157 = mul i32 %154, 12
%158 = mul i64 %40, 12
%159 = getelementptr inbounds double, double* %0, i64 %158
%160 = getelementptr inbounds double, double* %159, i64 1
%161 = bitcast double* %159 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = mul i32 %154, 12
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %0, i64 %164
%166 = load double, double* %165
store double %166, double* %159
%167 = getelementptr inbounds double, double* %165, i64 1
%168 = load double, double* %167
store double %168, double* %160
%169 = bitcast double* %165 to <2 x double>*
store <2 x double> %162, <2 x double>* %169
%170 = mul i64 %40, 12
%171 = or i64 %170, 2
%172 = getelementptr inbounds double, double* %0, i64 %171
%173 = getelementptr inbounds double, double* %172, i64 1
%174 = bitcast double* %172 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = or i32 %157, 2
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %0, i64 %177
%179 = load double, double* %178
store double %179, double* %172
%180 = getelementptr inbounds double, double* %178, i64 1
%181 = load double, double* %180
store double %181, double* %173
%182 = bitcast double* %178 to <2 x double>*
store <2 x double> %175, <2 x double>* %182
%183 = mul i32 %154, 12
%184 = mul i64 %40, 12
%185 = add i64 %184, 4
%186 = getelementptr inbounds double, double* %0, i64 %185
%187 = getelementptr inbounds double, double* %186, i64 1
%188 = bitcast double* %186 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = add i32 %183, 4
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %0, i64 %191
%193 = load double, double* %192
store double %193, double* %186
%194 = getelementptr inbounds double, double* %192, i64 1
%195 = load double, double* %194
store double %195, double* %187
%196 = bitcast double* %192 to <2 x double>*
store <2 x double> %189, <2 x double>* %196
%197 = mul i64 %40, 12
%198 = add i64 %197, 6
%199 = getelementptr inbounds double, double* %0, i64 %198
%200 = getelementptr inbounds double, double* %199, i64 1
%201 = bitcast double* %199 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = mul i32 %154, 12
%204 = add i32 %203, 6
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds double, double* %0, i64 %205
%207 = load double, double* %206
store double %207, double* %199
%208 = getelementptr inbounds double, double* %206, i64 1
%209 = load double, double* %208
store double %209, double* %200
%210 = bitcast double* %206 to <2 x double>*
store <2 x double> %202, <2 x double>* %210
%211 = mul i32 %154, 12
%212 = mul i64 %40, 12
%213 = add i64 %212, 8
%214 = getelementptr inbounds double, double* %0, i64 %213
%215 = getelementptr inbounds double, double* %214, i64 1
%216 = bitcast double* %214 to <2 x double>*
%217 = load <2 x double>, <2 x double>* %216
%218 = add i32 %211, 8
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %0, i64 %219
%221 = load double, double* %220
store double %221, double* %214
%222 = getelementptr inbounds double, double* %220, i64 1
%223 = load double, double* %222
store double %223, double* %215
%224 = bitcast double* %220 to <2 x double>*
store <2 x double> %217, <2 x double>* %224
%225 = mul i64 %40, 12
%226 = add i64 %225, 10
%227 = getelementptr inbounds double, double* %0, i64 %226
%228 = getelementptr inbounds double, double* %227, i64 1
%229 = bitcast double* %227 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = mul i32 %154, 12
%232 = add i32 %231, 10
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %0, i64 %233
%235 = load double, double* %234
store double %235, double* %227
%236 = getelementptr inbounds double, double* %234, i64 1
%237 = load double, double* %236
store double %237, double* %228
%238 = bitcast double* %234 to <2 x double>*
store <2 x double> %230, <2 x double>* %238
br label %271
239: ; preds = %152, %239
%240 = phi i64 [ %269, %239 ], [ %21, %152 ]
%241 = add nuw nsw i64 %240, %43
%242 = shl i64 %241, 2
%243 = trunc i64 %240 to i32
%244 = add i32 %155, %243
%245 = shl i32 %244, 2
%246 = shl nsw i64 %241, 2
%247 = getelementptr inbounds double, double* %1, i64 %246
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = shl nsw i32 %244, 2
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds double, double* %1, i64 %251
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = bitcast double* %247 to <2 x double>*
store <2 x double> %254, <2 x double>* %255
%256 = bitcast double* %252 to <2 x double>*
store <2 x double> %249, <2 x double>* %256
%257 = or i64 %242, 2
%258 = getelementptr inbounds double, double* %1, i64 %257
%259 = getelementptr inbounds double, double* %258, i64 1
%260 = bitcast double* %258 to <2 x double>*
%261 = load <2 x double>, <2 x double>* %260
%262 = or i32 %245, 2
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %1, i64 %263
%265 = load double, double* %264
store double %265, double* %258
%266 = getelementptr inbounds double, double* %264, i64 1
%267 = load double, double* %266
store double %267, double* %259
%268 = bitcast double* %264 to <2 x double>*
store <2 x double> %261, <2 x double>* %268
%269 = add nuw nsw i64 %240, 1
%270 = icmp eq i64 %269, 3
br i1 %270, label %156, label %239
271: ; preds = %156, %109
br i1 %37, label %273, label %272
272: ; preds = %273, %271
br i1 %26, label %276, label %35
273: ; preds = %271
%274 = tail call i32 (i32, i32, i32, i32, double*, ...) bitcast (i32 (...)* @project_r to i32 (i32, i32, i32, i32, double*, ...)*)(i32 %22, i32 0, i32 %22, i32 1, double* %1)
%275 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @project_v to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %22, i32 0, i32 %22, i32 1, double* %1, double* %0)
br label %272
276: ; preds = %272, %276
%277 = phi i32 [ %282, %276 ], [ %32, %272 ]
%278 = tail call i32 (i32, i32, i32, i32, double*, ...) bitcast (i32 (...)* @project_r to i32 (i32, i32, i32, i32, double*, ...)*)(i32 %22, i32 %39, i32 %277, i32 0, double* %1)
%279 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @project_v to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %22, i32 %39, i32 %277, i32 0, double* %1, double* %0)
%280 = tail call i32 (i32, i32, i32, i32, double*, ...) bitcast (i32 (...)* @project_r to i32 (i32, i32, i32, i32, double*, ...)*)(i32 %22, i32 %39, i32 %277, i32 1, double* %1)
%281 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @project_v to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %22, i32 %39, i32 %277, i32 1, double* %1, double* %0)
%282 = add nuw nsw i32 %277, 1
%283 = icmp eq i32 %282, 3
br i1 %283, label %35, label %276
284: ; preds = %35
%285 = add nuw nsw i64 %21, 1
%286 = icmp eq i64 %25, 3
br i1 %286, label %289, label %19
287: ; preds = %377
%288 = add nsw i64 %290, -1
br label %289
289: ; preds = %284, %287
%290 = phi i64 [ %288, %287 ], [ 2, %284 ]
%291 = shl nsw i64 %290, 1
%292 = icmp eq i64 %290, 0
%293 = trunc i64 %291 to i32
%294 = trunc i64 %290 to i32
br label %298
295: ; preds = %379, %377
%296 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @scale to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %294, i32 %300, i32 %294, i32 0, double* %1, double* %0)
%297 = add nsw i64 %299, -1
br label %298
298: ; preds = %295, %289
%299 = phi i64 [ 1, %289 ], [ %297, %295 ]
%300 = trunc i64 %299 to i32
%301 = add nuw nsw i64 %299, %291
%302 = add nuw nsw i32 %300, %293
%303 = mul nuw nsw i32 %302, 3
%304 = add nuw nsw i32 %303, %294
%305 = shl nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = add nuw nsw i64 %299, %306
%308 = shl nsw i64 %307, 1
%309 = getelementptr inbounds double, double* %1, i64 %308
%310 = load double, double* %309
%311 = getelementptr inbounds double, double* %309, i64 1
%312 = load double, double* %311
%313 = fmul double %312, %312
%314 = tail call double @llvm.fmuladd.f64(double %310, double %310, double %313)
%315 = fdiv double 1.000000e+00, %314
%316 = fmul double %310, %315
%317 = fneg double %312
%318 = fmul double %315, %317
%319 = fneg double %318
%320 = mul i64 %301, 12
%321 = getelementptr inbounds double, double* %0, i64 %320
%322 = bitcast double* %321 to <2 x double>*
%323 = load <2 x double>, <2 x double>* %322
%324 = insertelement <2 x double> poison, double %318, i64 0
%325 = insertelement <2 x double> %324, double %319, i64 1
%326 = fmul <2 x double> %323, %325
%327 = shufflevector <2 x double> %326, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%328 = insertelement <2 x double> poison, double %316, i64 0
%329 = shufflevector <2 x double> %328, <2 x double> poison, <2 x i32> zeroinitializer
%330 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %323, <2 x double> %327)
%331 = bitcast double* %321 to <2 x double>*
store <2 x double> %330, <2 x double>* %331
%332 = mul i64 %301, 12
%333 = or i64 %332, 2
%334 = getelementptr inbounds double, double* %0, i64 %333
%335 = bitcast double* %334 to <2 x double>*
%336 = load <2 x double>, <2 x double>* %335
%337 = fmul <2 x double> %336, %325
%338 = shufflevector <2 x double> %337, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%339 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %336, <2 x double> %338)
%340 = bitcast double* %334 to <2 x double>*
store <2 x double> %339, <2 x double>* %340
%341 = mul i64 %301, 12
%342 = add i64 %341, 4
%343 = getelementptr inbounds double, double* %0, i64 %342
%344 = bitcast double* %343 to <2 x double>*
%345 = load <2 x double>, <2 x double>* %344
%346 = fmul <2 x double> %345, %325
%347 = shufflevector <2 x double> %346, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%348 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %345, <2 x double> %347)
%349 = bitcast double* %343 to <2 x double>*
store <2 x double> %348, <2 x double>* %349
%350 = mul i64 %301, 12
%351 = add i64 %350, 6
%352 = getelementptr inbounds double, double* %0, i64 %351
%353 = bitcast double* %352 to <2 x double>*
%354 = load <2 x double>, <2 x double>* %353
%355 = fmul <2 x double> %354, %325
%356 = shufflevector <2 x double> %355, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%357 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %354, <2 x double> %356)
%358 = bitcast double* %352 to <2 x double>*
store <2 x double> %357, <2 x double>* %358
%359 = mul i64 %301, 12
%360 = add i64 %359, 8
%361 = getelementptr inbounds double, double* %0, i64 %360
%362 = bitcast double* %361 to <2 x double>*
%363 = load <2 x double>, <2 x double>* %362
%364 = fmul <2 x double> %363, %325
%365 = shufflevector <2 x double> %364, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%366 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %363, <2 x double> %365)
%367 = bitcast double* %361 to <2 x double>*
store <2 x double> %366, <2 x double>* %367
%368 = mul i64 %301, 12
%369 = add i64 %368, 10
%370 = getelementptr inbounds double, double* %0, i64 %369
%371 = bitcast double* %370 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = fmul <2 x double> %372, %325
%374 = shufflevector <2 x double> %373, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%375 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %372, <2 x double> %374)
%376 = bitcast double* %370 to <2 x double>*
store <2 x double> %375, <2 x double>* %376
br i1 %292, label %379, label %381
377: ; preds = %381
%378 = icmp eq i64 %299, 0
br i1 %378, label %287, label %295
379: ; preds = %298
%380 = icmp eq i64 %299, 0
br i1 %380, label %388, label %295
381: ; preds = %298, %381
%382 = phi i32 [ %385, %381 ], [ 0, %298 ]
%383 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @scale to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %294, i32 %300, i32 %382, i32 0, double* %1, double* %0)
%384 = tail call i32 (i32, i32, i32, i32, double*, double*, ...) bitcast (i32 (...)* @scale to i32 (i32, i32, i32, i32, double*, double*, ...)*)(i32 %294, i32 %300, i32 %382, i32 1, double* %1, double* %0)
%385 = add nuw nsw i32 %382, 1
%386 = zext i32 %385 to i64
%387 = icmp eq i64 %290, %386
br i1 %387, label %377, label %381
388: ; preds = %379
ret void
}