#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 */
float dotprod(float *, float *, int);
double fabs(float);
float norm(float *, int);
double sqrt(int);
void jacobiSVD3(float *A, float *U, float *V) {
  for (int i = 0; i < 9; i++) {
    U[i] = A[i];
    V[i] = 0;
  }
  float T[3];
  V[0] = 1;
  V[4] = 1;
  V[8] = 1;
  for (int iter = 0; iter < 4; iter++) {
    for (int j = 1; j < 3; j++) {
      for (int i = 0; i < j; i++) {
        float alpha = dotprod(U + i * 3, U + i * 3, 3);
        float beta = dotprod(U + j * 3, U + j * 3, 3);
        float gamma = dotprod(U + i * 3, U + j * 3, 3);
        float zeta = (beta - alpha) / (2.0 * gamma);
        float t =
            ((zeta > 0) ? 1.0 : -1.0) / (fabs(zeta) + sqrt(1.0 + zeta * zeta));
        float c = 1.0 / sqrt(1 + t * t);
        float s = c * t;
        T[0] = U[0 + i * 3];
        T[1] = U[1 + i * 3];
        T[2] = U[2 + i * 3];
        for (int k = 0; k < 3; k++) {
          U[k + i * 3] = c * T[k] - s * U[k + j * 3];
        }
        for (int k = 0; k < 3; k++) {
          U[k + j * 3] = s * T[k] + c * U[k + j * 3];
        }
        T[0] = V[0 + i * 3];
        T[1] = V[1 + i * 3];
        T[2] = V[2 + i * 3];
        for (int k = 0; k < 3; k++) {
          V[k + i * 3] = c * T[k] - s * V[k + j * 3];
        }
        for (int k = 0; k < 3; k++) {
          V[k + j * 3] = s * T[k] + c * V[k + j * 3];
        }
      }
    }
  }
  for (int j = 0; j < 3; j++) {
    float singval = norm(U + j * 3, 3);
    for (int i = 0; i < 3; i++) {
      U[i + j * 3] /= singval;
    }
  }
}


x86 assembly (clang, -O0):
<jacobiSVD3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    11a0 <jacobiSVD3+0x60>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    115e <jacobiSVD3+0x1e>
mov    -0x18(%rbp),%rax
movss  0xe54(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0xe44(%rip),%xmm0
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movss  0xe33(%rip),%xmm0
movss  %xmm0,0x20(%rax)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    1626 <jacobiSVD3+0x4e6>
movl   $0x1,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1613 <jacobiSVD3+0x4d3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1600 <jacobiSVD3+0x4c0>
mov    -0x10(%rbp),%rdi
imul   $0x3,-0x34(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x3,-0x34(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
imul   $0x3,-0x30(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x3,-0x30(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rdi
imul   $0x3,-0x34(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
imul   $0x3,-0x30(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xd5f(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
xorps  %xmm2,%xmm2
movsd  0xd2e(%rip),%xmm0
movsd  0xd2e(%rip),%xmm3
movsd  %xmm3,-0x80(%rbp)
ucomiss %xmm2,%xmm1
movsd  %xmm0,-0x78(%rbp)
ja     12ff <jacobiSVD3+0x1bf>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x44(%rbp),%xmm0
call   1040 <fabs@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcd4(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movsd  -0x90(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x88(%rbp),%xmm0
ff
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xc85(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc75(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x54(%rbp)
cmpl   $0x3,-0x54(%rbp)
jge    1469 <jacobiSVD3+0x329>
movss  -0x4c(%rbp),%xmm0
movslq -0x54(%rbp),%rax
movss  -0x28(%rbp,%rax,4),%xmm2
movss  -0x50(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13fe <jacobiSVD3+0x2be>
movl   $0x0,-0x58(%rbp)
cmpl   $0x3,-0x58(%rbp)
jge    14ce <jacobiSVD3+0x38e>
movss  -0x50(%rbp),%xmm0
movslq -0x58(%rbp),%rax
movss  -0x28(%rbp,%rax,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1470 <jacobiSVD3+0x330>
mov    -0x18(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x3,-0x5c(%rbp)
jge    1588 <jacobiSVD3+0x448>
movss  -0x4c(%rbp),%xmm0
movslq -0x5c(%rbp),%rax
movss  -0x28(%rbp,%rax,4),%xmm2
movss  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    151d <jacobiSVD3+0x3dd>
movl   $0x0,-0x60(%rbp)
cmpl   $0x3,-0x60(%rbp)
jge    15ed <jacobiSVD3+0x4ad>
movss  -0x50(%rbp),%xmm0
movslq -0x60(%rbp),%rax
movss  -0x28(%rbp,%rax,4),%xmm2
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   $0x3,-0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    158f <jacobiSVD3+0x44f>
jmp    15f2 <jacobiSVD3+0x4b2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11fb <jacobiSVD3+0xbb>
jmp    1605 <jacobiSVD3+0x4c5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ea <jacobiSVD3+0xaa>
jmp    1618 <jacobiSVD3+0x4d8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d9 <jacobiSVD3+0x99>
movl   $0x0,-0x64(%rbp)
cmpl   $0x3,-0x64(%rbp)
jge    16ac <jacobiSVD3+0x56c>
mov    -0x10(%rbp),%rdi
imul   $0x3,-0x64(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    $0x3,%esi
call   1050 <norm@plt>
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
cmpl   $0x3,-0x6c(%rbp)
jge    1699 <jacobiSVD3+0x559>
movss  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   $0x3,-0x64(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    165e <jacobiSVD3+0x51e>
jmp    169e <jacobiSVD3+0x55e>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    162d <jacobiSVD3+0x4ed>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobiSVD3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%rbx
mov    %rsi,%r12
movss  (%rdi),%xmm0
movss  %xmm0,(%rsi)
movl   $0x0,(%rdx)
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x4(%rsi)
movl   $0x0,0x4(%rdx)
movss  0x8(%rdi),%xmm0
movss  %xmm0,0x8(%rsi)
movl   $0x0,0x8(%rdx)
movss  0xc(%rdi),%xmm0
lea    0xc(%rsi),%rax
mov    %rax,0x18(%rsp)
movss  %xmm0,0xc(%rsi)
movl   $0x0,0xc(%rdx)
movss  0x10(%rdi),%xmm0
movss  %xmm0,0x10(%rsi)
movl   $0x0,0x10(%rdx)
movss  0x14(%rdi),%xmm0
movss  %xmm0,0x14(%rsi)
movl   $0x0,0x14(%rdx)
movss  0x18(%rdi),%xmm0
lea    0x18(%rsi),%rax
mov    %rax,0x20(%rsp)
movss  %xmm0,0x18(%rsi)
movl   $0x0,0x18(%rdx)
movss  0x1c(%rdi),%xmm0
movss  %xmm0,0x1c(%rsi)
movl   $0x0,0x1c(%rdx)
movss  0x20(%rdi),%xmm0
movss  %xmm0,0x20(%rsi)
movl   $0x3f800000,(%rdx)
movl   $0x3f800000,0x10(%rdx)
movl   $0x3f800000,0x20(%rdx)
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    %rax,0x28(%rsp)
mov    $0x1,%eax
mov    $0xc,%ecx
nop
mov    %rax,0x30(%rsp)
lea    (%rax,%rax,2),%r15
lea    (%r12,%r15,4),%rax
mov    %rax,0x38(%rsp)
xor    %r14d,%r14d
mov    %rcx,0x40(%rsp)
nopw   0x0(%rax,%rax,1)
lea    (%r12,%r14,1),%rbp
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  %xmm0,(%rsp)
mov    0x38(%rsp),%r13
mov    %r13,%rdi
mov    %r13,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  %xmm0,0x8(%rsp)
mov    %rbp,%rdi
lea    0xd82(%rip),%rbp
mov    %r13,%rsi
mov    $0x3,%edx
call   1030 <dotprod@plt>
movss  0x8(%rsp),%xmm1
subss  (%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x14(%rsp)
xor    %eax,%eax
ucomiss 0xd63(%rip),%xmm1
seta   %al
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rsp)
movaps %xmm1,%xmm0
call   1040 <fabs@plt>
movsd  %xmm0,0x8(%rsp)
movss  0x14(%rsp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xd25(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
addsd  0x8(%rsp),%xmm0
movsd  (%rsp),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rsp)
mulss  %xmm0,%xmm0
addss  0xcfd(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1060 <sqrt@plt>
mov    0x40(%rsp),%rcx
movsd  0xcdf(%rip),%xmm1
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  (%rsp),%xmm6
mulss  %xmm0,%xmm6
movss  (%r12,%r14,1),%xmm3
movss  0x4(%r12,%r14,1),%xmm2
movss  0x8(%r12,%r14,1),%xmm1
movss  (%r12,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,(%r12,%r14,1)
movss  0x4(%r12,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,0x4(%r12,%r14,1)
movss  0x8(%r12,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,0x8(%r12,%r14,1)
movss  (%r12,%r15,4),%xmm4
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%r12,%r15,4)
movss  0x4(%r12,%r15,4),%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x4(%r12,%r15,4)
movss  0x8(%r12,%r15,4),%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm6,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x8(%r12,%r15,4)
movss  (%rbx,%r14,1),%xmm3
movss  0x4(%rbx,%r14,1),%xmm2
movss  0x8(%rbx,%r14,1),%xmm1
movss  (%rbx,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,(%rbx,%r14,1)
movss  0x4(%rbx,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,0x4(%rbx,%r14,1)
movss  0x8(%rbx,%r15,4),%xmm4
mulss  %xmm6,%xmm4
movaps %xmm0,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,0x8(%rbx,%r14,1)
movss  (%rbx,%r15,4),%xmm4
mulss  %xmm0,%xmm4
movaps %xmm6,%xmm5
mulss  %xmm6,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rbx,%r15,4)
movss  0x4(%rbx,%r15,4),%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x4(%rbx,%r15,4)
mulss  0x8(%rbx,%r15,4),%xmm0
mulss  %xmm1,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x8(%rbx,%r15,4)
add    $0xc,%r14
cmp    %r14,%rcx
jne    1240 <jacobiSVD3+0x100>
mov    0x30(%rsp),%rax
add    $0x1,%rax
add    $0xc,%rcx
cmp    $0x3,%rax
jne    1220 <jacobiSVD3+0xe0>
mov    0x28(%rsp),%rax
add    $0x1,%eax
cmp    $0x4,%eax
jne    1210 <jacobiSVD3+0xd0>
mov    %r12,%rdi
mov    $0x3,%esi
call   1050 <norm@plt>
movss  (%r12),%xmm1
movss  0x4(%r12),%xmm2
divss  %xmm0,%xmm1
movss  %xmm1,(%r12)
divss  %xmm0,%xmm2
movss  %xmm2,0x4(%r12)
movss  0x8(%r12),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%r12)
mov    0x18(%rsp),%rdi
mov    $0x3,%esi
call   1050 <norm@plt>
movss  0xc(%r12),%xmm1
movss  0x10(%r12),%xmm2
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%r12)
divss  %xmm0,%xmm2
movss  %xmm2,0x10(%r12)
movss  0x14(%r12),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x14(%r12)
mov    0x20(%rsp),%rdi
mov    $0x3,%esi
call   1050 <norm@plt>
movss  0x18(%r12),%xmm1
movss  0x1c(%r12),%xmm2
divss  %xmm0,%xmm1
movss  %xmm1,0x18(%r12)
divss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r12)
movss  0x20(%r12),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x20(%r12)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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