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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
double atan2(int, double);
double cos(double);
scalar_t__ fabs(double);
int /*<<< orphan*/ memcpy(double *, double *, int);
double sin(double);
double sqrt(double);
void svd22(const double A[4], double U[4], double S[2], double V[4]) {
  double w, x, y;
  w = A[0] * A[0] + A[2] * A[2];
  x = A[0] * A[1] + A[2] * A[3];
  y = A[1] * A[1] + A[3] * A[3];
  double phi = 0.5 * atan2(2 * x, w - y);
  w = A[0] * A[0] + A[1] * A[1];
  x = A[0] * A[2] + A[1] * A[3];
  y = A[2] * A[2] + A[3] * A[3];
  double theta = 0.5 * atan2(2 * x, w - y);
  double ct = cos(theta), st = sin(theta);
  U[0] = ct;
  U[1] = -st;
  U[2] = st;
  U[3] = ct;
  double cp = cos(phi), sp = sin(phi);
  V[0] = cp;
  V[1] = -sp;
  V[2] = sp;
  V[3] = cp;
  double T[4] = {A[0] * V[0] + A[1] * V[2], A[0] * V[1] + A[1] * V[3],
                 A[2] * V[0] + A[3] * V[2], A[2] * V[1] + A[3] * V[3]};
  double WS[4] = {U[0] * T[0] + U[2] * T[2], U[0] * T[1] + U[2] * T[3],
                  U[1] * T[0] + U[3] * T[2], U[1] * T[1] + U[3] * T[3]};
  S[0] = sqrt(WS[0] * WS[0] + WS[1] * WS[1]);
  S[1] = sqrt(WS[2] * WS[2] + WS[3] * WS[3]);
  double eps = 1E-6;
  double W[4];
  if (S[0] > eps) {
    W[0] = WS[0] / S[0];
    W[2] = WS[2] / S[0];
  } else {
    W[0] = 1;
    W[2] = 0;
  }
  if (S[1] > eps) {
    W[1] = WS[1] / S[1];
    W[3] = WS[3] / S[1];
  } else {
    W[1] = 0;
    W[3] = 1;
  }
  double UW[4] = {U[0] * W[0] + U[1] * W[2], U[0] * W[1] + U[1] * W[3],
                  U[2] * W[0] + U[3] * W[2], U[2] * W[1] + U[3] * W[3]};
  memcpy(U, UW, 4 * sizeof(double));
  assert(S[0] >= 0);
  assert(S[1] >= 0);
  if (fabs(S[1]) > fabs(S[0])) {
    double t = S[0];
    S[0] = S[1];
    S[1] = t;
    double tmp[2];
    tmp[0] = U[0];
    tmp[1] = U[2];
    U[0] = U[1];
    U[2] = U[3];
    U[1] = tmp[0];
    U[3] = tmp[1];
    tmp[0] = V[0];
    tmp[1] = V[2];
    V[0] = V[1];
    V[2] = V[3];
    V[1] = tmp[0];
    V[3] = tmp[1];
  }
}


x86 assembly (clang, -O0):
<svd22>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xded(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
cvttsd2si %xmm0,%edi
movsd  -0x28(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
call   1030 <atan2@plt>
movaps %xmm0,%xmm1
movsd  0xdc2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xd29(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
cvttsd2si %xmm0,%edi
movsd  -0x28(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
call   1030 <atan2@plt>
movaps %xmm0,%xmm1
movsd  0xcfe(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x40(%rbp),%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x18(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  0xa22(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    1631 <svd22+0x4c1>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
divsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    164c <svd22+0x4dc>
movsd  0x9df(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    169a <svd22+0x52a>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    16b5 <svd22+0x545>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  0x96b(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rdi
lea    -0x100(%rbp),%rsi
mov    $0x20,%edx
call   1070 <memcpy@plt>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
call   1040 <fabs@plt>
mov    %rax,-0x128(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
call   1040 <fabs@plt>
mov    %rax,%rcx
mov    -0x128(%rbp),%rax
cmp    %rcx,%rax
jle    18fc <svd22+0x78c>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svd22>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
movsd  0x10(%rdi),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rdi),%xmm3
movsd  0x8(%rdi),%xmm4
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x18(%rdi),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm4,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm2
mulsd  %xmm4,%xmm4
addsd  %xmm2,%xmm4
subsd  %xmm4,%xmm0
addsd  %xmm3,%xmm3
cvttsd2si %xmm3,%edi
call   1030 <atan2@plt>
mulsd  0xe21(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rbx),%xmm1
movsd  0x8(%rbx),%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  0x10(%rbx),%xmm3
movsd  0x18(%rbx),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm4,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm4,%xmm3
subsd  %xmm3,%xmm0
addsd  %xmm1,%xmm1
cvttsd2si %xmm1,%edi
call   1030 <atan2@plt>
mulsd  0xdc3(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
call   1080 <cos@plt>
movsd  %xmm0,(%rsp)
movsd  0x28(%rsp),%xmm0
call   1060 <sin@plt>
movsd  (%rsp),%xmm2
movsd  %xmm2,(%r12)
movaps %xmm0,%xmm1
xorps  0xdb3(%rip),%xmm1
movlps %xmm1,0x8(%r12)
movsd  %xmm0,0x10(%r12)
movsd  %xmm2,0x18(%r12)
movsd  0x10(%rsp),%xmm0
call   1080 <cos@plt>
movaps %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <sin@plt>
movapd (%rsp),%xmm7
movsd  %xmm7,(%r14)
movapd 0xd73(%rip),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x8(%r14)
movsd  %xmm0,0x10(%r14)
movsd  %xmm7,0x18(%r14)
movsd  (%rbx),%xmm1
movsd  0x8(%rbx),%xmm6
movapd %xmm1,%xmm5
mulsd  %xmm0,%xmm1
movsd  0x10(%rbx),%xmm2
movapd %xmm0,%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm0
mulsd  %xmm7,%xmm5
addsd  %xmm0,%xmm5
mulsd  %xmm7,%xmm6
subsd  %xmm1,%xmm6
movsd  0x18(%rbx),%xmm0
mulsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm7
subsd  %xmm2,%xmm7
movupd (%r12),%xmm0
movupd 0x10(%r12),%xmm1
unpcklpd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
unpcklpd %xmm5,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
unpcklpd %xmm7,%xmm7
mulpd  %xmm1,%xmm7
unpcklpd %xmm6,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
movapd %xmm5,0x10(%rsp)
movapd %xmm6,(%rsp)
jb     1376 <svd22+0x206>
sqrtsd %xmm0,%xmm0
jmp    138a <svd22+0x21a>
call   1090 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm5
movsd  %xmm0,(%r15)
movapd %xmm6,%xmm1
mulpd  %xmm6,%xmm1
unpckhpd %xmm1,%xmm1
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jb     13b7 <svd22+0x247>
sqrtsd %xmm0,%xmm0
jmp    13c7 <svd22+0x257>
call   1090 <sqrt@plt>
movapd (%rsp),%xmm6
movapd 0x10(%rsp),%xmm5
movsd  %xmm0,0x8(%r15)
movsd  (%r15),%xmm1
ucomisd 0xc36(%rip),%xmm1
jbe    13fc <svd22+0x28c>
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm5
ucomisd 0xc24(%rip),%xmm0
ja     140e <svd22+0x29e>
xorpd  %xmm6,%xmm6
movhpd 0xc0e(%rip),%xmm6
jmp    1416 <svd22+0x2a6>
movsd  0xc04(%rip),%xmm5
ucomisd 0xc04(%rip),%xmm0
jbe    13ee <svd22+0x27e>
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm5,%xmm0
unpckhpd %xmm6,%xmm0
movsd  (%r12),%xmm1
movsd  0x8(%r12),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm0,%xmm2
unpcklpd %xmm1,%xmm1
unpcklpd %xmm6,%xmm5
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x30(%rsp)
movsd  0x10(%r12),%xmm1
movsd  0x18(%r12),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm0,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x40(%rsp)
lea    0x30(%rsp),%rsi
mov    %r12,%rdi
mov    $0x20,%edx
call   1070 <memcpy@plt>
movsd  (%r15),%xmm0
xorpd  %xmm1,%xmm1
xor    %edi,%edi
ucomisd %xmm1,%xmm0
setae  %dil
call   1050 <assert@plt>
movsd  0x8(%r15),%xmm0
xor    %edi,%edi
ucomisd 0xb6d(%rip),%xmm0
setae  %dil
call   1050 <assert@plt>
movsd  0x8(%r15),%xmm0
call   1040 <fabs@plt>
mov    %rax,%rbx
movsd  (%r15),%xmm0
call   1040 <fabs@plt>
cmp    %rax,%rbx
jle    1518 <svd22+0x3a8>
movups (%r15),%xmm0
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,(%r15)
movups (%r12),%xmm0
movups 0x10(%r12),%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,(%r12)
shufps $0x4e,%xmm1,%xmm1
movups %xmm1,0x10(%r12)
movups (%r14),%xmm0
movupd 0x10(%r14),%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm0,(%r14)
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,0x10(%r14)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @svd22(double* nocapture %0, double* %1, double* nocapture %2, double* nocapture %3) {
%5 = alloca [4 x double]
%6 = load double, double* %0
%7 = getelementptr inbounds double, double* %0, i64 2
%8 = load double, double* %7
%9 = fmul double %8, %8
%10 = tail call double @llvm.fmuladd.f64(double %6, double %6, double %9)
%11 = getelementptr inbounds double, double* %0, i64 1
%12 = load double, double* %11
%13 = getelementptr inbounds double, double* %0, i64 3
%14 = load double, double* %13
%15 = fmul double %8, %14
%16 = tail call double @llvm.fmuladd.f64(double %6, double %12, double %15)
%17 = fmul double %14, %14
%18 = tail call double @llvm.fmuladd.f64(double %12, double %12, double %17)
%19 = fmul double %16, 2.000000e+00
%20 = fptosi double %19 to i32
%21 = fsub double %10, %18
%22 = tail call double @atan2(i32 %20, double %21)
%23 = fmul double %22, 5.000000e-01
%24 = load double, double* %0
%25 = load double, double* %11
%26 = fmul double %25, %25
%27 = tail call double @llvm.fmuladd.f64(double %24, double %24, double %26)
%28 = load double, double* %7
%29 = load double, double* %13
%30 = fmul double %25, %29
%31 = tail call double @llvm.fmuladd.f64(double %24, double %28, double %30)
%32 = fmul double %29, %29
%33 = tail call double @llvm.fmuladd.f64(double %28, double %28, double %32)
%34 = fmul double %31, 2.000000e+00
%35 = fptosi double %34 to i32
%36 = fsub double %27, %33
%37 = tail call double @atan2(i32 %35, double %36)
%38 = fmul double %37, 5.000000e-01
%39 = tail call double @cos(double %38)
%40 = tail call double @sin(double %38)
store double %39, double* %1
%41 = fneg double %40
%42 = getelementptr inbounds double, double* %1, i64 1
store double %41, double* %42
%43 = getelementptr inbounds double, double* %1, i64 2
store double %40, double* %43
%44 = getelementptr inbounds double, double* %1, i64 3
store double %39, double* %44
%45 = tail call double @cos(double %23)
%46 = tail call double @sin(double %23)
store double %45, double* %3
%47 = fneg double %46
%48 = getelementptr inbounds double, double* %3, i64 1
store double %47, double* %48
%49 = getelementptr inbounds double, double* %3, i64 2
store double %46, double* %49
%50 = getelementptr inbounds double, double* %3, i64 3
store double %45, double* %50
%51 = load double, double* %0
%52 = load double, double* %11
%53 = fmul double %46, %52
%54 = tail call double @llvm.fmuladd.f64(double %51, double %45, double %53)
%55 = fmul double %45, %52
%56 = tail call double @llvm.fmuladd.f64(double %51, double %47, double %55)
%57 = load double, double* %7
%58 = load double, double* %13
%59 = fmul double %46, %58
%60 = tail call double @llvm.fmuladd.f64(double %57, double %45, double %59)
%61 = fmul double %45, %58
%62 = tail call double @llvm.fmuladd.f64(double %57, double %47, double %61)
%63 = bitcast double* %43 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = bitcast double* %1 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = insertelement <2 x double> poison, double %60, i64 0
%68 = shufflevector <2 x double> %67, <2 x double> poison, <2 x i32> zeroinitializer
%69 = fmul <2 x double> %64, %68
%70 = insertelement <2 x double> poison, double %54, i64 0
%71 = shufflevector <2 x double> %70, <2 x double> poison, <2 x i32> zeroinitializer
%72 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %71, <2 x double> %69)
%73 = insertelement <2 x double> poison, double %62, i64 0
%74 = shufflevector <2 x double> %73, <2 x double> poison, <2 x i32> zeroinitializer
%75 = fmul <2 x double> %64, %74
%76 = insertelement <2 x double> poison, double %56, i64 0
%77 = shufflevector <2 x double> %76, <2 x double> poison, <2 x i32> zeroinitializer
%78 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %66, <2 x double> %77, <2 x double> %75)
%79 = fmul <2 x double> %78, %78
%80 = extractelement <2 x double> %79, i64 0
%81 = extractelement <2 x double> %72, i64 0
%82 = tail call double @llvm.fmuladd.f64(double %81, double %81, double %80)
%83 = tail call double @sqrt(double %82)
store double %83, double* %2
%84 = fmul <2 x double> %78, %78
%85 = extractelement <2 x double> %84, i64 1
%86 = extractelement <2 x double> %72, i64 1
%87 = tail call double @llvm.fmuladd.f64(double %86, double %86, double %85)
%88 = tail call double @sqrt(double %87)
%89 = getelementptr inbounds double, double* %2, i64 1
store double %88, double* %89
%90 = load double, double* %2
%91 = fcmp ogt double %90, 0x3EB0C6F7A0B5ED8D
br i1 %91, label %92, label %96
92: ; preds = %4
%93 = insertelement <2 x double> poison, double %90, i64 0
%94 = shufflevector <2 x double> %93, <2 x double> poison, <2 x i32> zeroinitializer
%95 = fdiv <2 x double> %72, %94
br label %96
96: ; preds = %4, %92
%97 = phi <2 x double> [ %95, %92 ], [ <double 1.000000e+00, double 0.000000e+00>, %4 ]
%98 = fcmp ogt double %88, 0x3EB0C6F7A0B5ED8D
br i1 %98, label %99, label %103
99: ; preds = %96
%100 = insertelement <2 x double> poison, double %88, i64 0
%101 = shufflevector <2 x double> %100, <2 x double> poison, <2 x i32> zeroinitializer
%102 = fdiv <2 x double> %78, %101
br label %103
103: ; preds = %96, %99
%104 = phi <2 x double> [ %102, %99 ], [ <double 0.000000e+00, double 1.000000e+00>, %96 ]
%105 = bitcast [4 x double]* %5 to i8*
%106 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 0
%107 = load double, double* %1
%108 = load double, double* %42
%109 = shufflevector <2 x double> %97, <2 x double> %104, <2 x i32> <i32 1, i32 3>
%110 = insertelement <2 x double> poison, double %108, i64 0
%111 = shufflevector <2 x double> %110, <2 x double> poison, <2 x i32> zeroinitializer
%112 = fmul <2 x double> %109, %111
%113 = insertelement <2 x double> poison, double %107, i64 0
%114 = shufflevector <2 x double> %113, <2 x double> poison, <2 x i32> zeroinitializer
%115 = shufflevector <2 x double> %97, <2 x double> %104, <2 x i32> <i32 0, i32 2>
%116 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %115, <2 x double> %112)
%117 = bitcast [4 x double]* %5 to <2 x double>*
store <2 x double> %116, <2 x double>* %117
%118 = getelementptr inbounds [4 x double], [4 x double]* %5, i64 0, i64 2
%119 = load double, double* %43
%120 = load double, double* %44
%121 = insertelement <2 x double> poison, double %120, i64 0
%122 = shufflevector <2 x double> %121, <2 x double> poison, <2 x i32> zeroinitializer
%123 = fmul <2 x double> %109, %122
%124 = insertelement <2 x double> poison, double %119, i64 0
%125 = shufflevector <2 x double> %124, <2 x double> poison, <2 x i32> zeroinitializer
%126 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %125, <2 x double> %115, <2 x double> %123)
%127 = bitcast double* %118 to <2 x double>*
store <2 x double> %126, <2 x double>* %127
%128 = call i32 @memcpy(double* %1, double* %106, i32 32)
%129 = load double, double* %2
%130 = fcmp oge double %129, 0.000000e+00
%131 = zext i1 %130 to i32
%132 = call i32 @assert(i32 %131)
%133 = load double, double* %89
%134 = fcmp oge double %133, 0.000000e+00
%135 = zext i1 %134 to i32
%136 = call i32 @assert(i32 %135)
%137 = load double, double* %89
%138 = call i64 @fabs(double %137)
%139 = load double, double* %2
%140 = call i64 @fabs(double %139)
%141 = icmp sgt i64 %138, %140
br i1 %141, label %142, label %163
142: ; preds = %103
%143 = bitcast double* %2 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = shufflevector <2 x double> %144, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%146 = bitcast double* %2 to <2 x double>*
store <2 x double> %145, <2 x double>* %146
%147 = bitcast double* %1 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = bitcast double* %43 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %149
%151 = shufflevector <2 x double> %148, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%152 = bitcast double* %1 to <2 x double>*
store <2 x double> %151, <2 x double>* %152
%153 = shufflevector <2 x double> %150, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%154 = bitcast double* %43 to <2 x double>*
store <2 x double> %153, <2 x double>* %154
%155 = bitcast double* %3 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = bitcast double* %49 to <2 x double>*
%158 = load <2 x double>, <2 x double>* %157
%159 = shufflevector <2 x double> %156, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%160 = bitcast double* %3 to <2 x double>*
store <2 x double> %159, <2 x double>* %160
%161 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%162 = bitcast double* %49 to <2 x double>*
store <2 x double> %161, <2 x double>* %162
br label %163
163: ; preds = %142, %103
ret void
}