#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 sqrtf(float);
void eig22(float *A, int stride, float *eigre, float *eigim) {
  int N;
  float a11, a12, a21, a22, c, s, c2, s2, cs, t1, t, t2, at11, at12, at21, at22;
  N = stride;
  a11 = A[0];
  a12 = A[1];
  a21 = A[N];
  a22 = A[N + 1];
  if ((a12 + a21) == 0) {
    c = 1.0f / sqrtf(2.0f);
    s = c;
  } else {
    t1 = (a11 - a22) / (a12 + a21);
    t = t1 / (1.0f + sqrtf(1 + t1 * t1));
    c = 1.0f / sqrtf(1 + t * t);
    s = c * t;
  }
  c2 = c * c;
  s2 = s * s;
  cs = c * s;
  at11 = c2 * a11 + s2 * a22 - cs * (a12 + a21);
  at12 = c2 * a12 - s2 * a21 + cs * (a11 - a22);
  at21 = c2 * a21 - s2 * a12 + cs * (a11 - a22);
  at22 = c2 * a22 + s2 * a11 + cs * (a12 + a21);
  eigre[0] = eigre[1] = at11;
  eigim[0] = sqrtf(-at12 * at21);
  eigim[1] = -sqrtf(-at12 * at21);
  if (at12 * at21 >= 0) {
    if (at12 == 0) {
      c = 0;
      s = 1;
      c2 = 0;
      s2 = 1;
      cs = 0;
    } else {
      t = sqrtf(at21 / at12);
      t2 = t * t;
      cs = t / (1 + t2);
      c2 = (1 + t2);
      s2 = t2 / (1 + t2);
    }
    eigim[0] = eigim[1] = 0.0;
    eigre[0] = at11 - cs * (at12 + at21);
    eigre[1] = at11 + cs * (at12 + at21);
  }
}


x86 assembly (clang, -O0):
<eig22>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11bd <eig22+0xad>
jp     11bd <eig22+0xad>
movss  0xe6f(%rip),%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xe5b(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1262 <eig22+0x152>
movss  -0x28(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
addss  -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xe06(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm2
movss  -0x68(%rbp),%xmm0
movss  0xded(%rip),%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xdca(%rip),%xmm1
addss  %xmm1,%xmm0
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xdb6(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
addss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
subss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
subss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
addss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x60(%rbp),%xmm0
call   1030 <sqrtf@plt>
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x60(%rbp),%xmm0
call   1030 <sqrtf@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x5c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     153e <eig22+0x42e>
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1466 <eig22+0x356>
jp     1466 <eig22+0x356>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xbc1(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xbac(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    14d1 <eig22+0x3c1>
movss  -0x60(%rbp),%xmm0
divss  -0x5c(%rbp),%xmm0
call   1030 <sqrtf@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm0
movss  0xb6a(%rip),%xmm1
addss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xb54(%rip),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x54(%rbp),%xmm0
movss  0xb3d(%rip),%xmm1
addss  -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
addss  -0x60(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
addss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eig22>:
push   %r14
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r14
mov    %rdx,%rbx
movss  (%rdi),%xmm2
movss  0x4(%rdi),%xmm5
movslq %esi,%rax
movss  (%rdi,%rax,4),%xmm9
movss  0x4(%rdi,%rax,4),%xmm4
movaps %xmm5,%xmm1
addss  %xmm9,%xmm1
xorps  %xmm8,%xmm8
ucomiss %xmm8,%xmm1
movaps %xmm2,%xmm7
subss  %xmm4,%xmm7
jne    1160 <eig22+0x50>
jp     1160 <eig22+0x50>
movss  0xea8(%rip),%xmm3
movaps %xmm3,%xmm6
jmp    1221 <eig22+0x111>
movaps %xmm7,%xmm3
divss  %xmm1,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
addss  0xe8e(%rip),%xmm0
ucomiss %xmm8,%xmm0
movss  %xmm2,0x8(%rsp)
movaps %xmm5,0x20(%rsp)
movaps %xmm9,0x40(%rsp)
movss  %xmm7,0x30(%rsp)
movaps %xmm1,0x50(%rsp)
movss  %xmm4,0xc(%rsp)
jb     11a4 <eig22+0x94>
sqrtss %xmm0,%xmm0
jmp    11b3 <eig22+0xa3>
movaps %xmm3,0x10(%rsp)
call   1030 <sqrtf@plt>
movaps 0x10(%rsp),%xmm3
movss  0xe49(%rip),%xmm6
addss  %xmm6,%xmm0
divss  %xmm0,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm6,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     11dc <eig22+0xcc>
sqrtss %xmm0,%xmm0
jmp    11f3 <eig22+0xe3>
movaps %xmm3,0x10(%rsp)
call   1030 <sqrtf@plt>
movss  0xe16(%rip),%xmm6
movaps 0x10(%rsp),%xmm3
movss  0x8(%rsp),%xmm2
xorps  %xmm8,%xmm8
movaps 0x20(%rsp),%xmm5
movaps 0x40(%rsp),%xmm9
movss  0x30(%rsp),%xmm7
movaps 0x50(%rsp),%xmm1
movss  0xc(%rsp),%xmm4
divss  %xmm0,%xmm6
mulss  %xmm6,%xmm3
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm6,%xmm3
mulss  %xmm6,%xmm6
mulss  %xmm0,%xmm4
mulss  %xmm6,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm2
movaps %xmm9,%xmm1
unpcklps %xmm5,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
shufps $0x0,%xmm6,%xmm6
unpcklps %xmm9,%xmm5
mulps  %xmm6,%xmm5
subps  %xmm0,%xmm5
mulss  %xmm7,%xmm3
shufps $0x0,%xmm3,%xmm3
addps  %xmm5,%xmm3
movss  %xmm2,0x4(%rbx)
movss  %xmm2,(%rbx)
movaps 0xd95(%rip),%xmm1
xorps  %xmm3,%xmm1
movaps %xmm3,%xmm5
shufps $0x55,%xmm3,%xmm5
mulss  %xmm5,%xmm1
xorps  %xmm4,%xmm4
sqrtss %xmm1,%xmm4
ucomiss %xmm8,%xmm1
movaps %xmm4,%xmm0
movss  %xmm2,0x8(%rsp)
movaps %xmm3,0x10(%rsp)
movaps %xmm5,0x20(%rsp)
jae    12d5 <eig22+0x1c5>
movaps %xmm1,%xmm0
movaps %xmm1,0x40(%rsp)
movaps %xmm4,0x30(%rsp)
call   1030 <sqrtf@plt>
movaps 0x30(%rsp),%xmm4
movaps 0x40(%rsp),%xmm1
movaps 0x20(%rsp),%xmm5
movaps 0x10(%rsp),%xmm3
movss  0x8(%rsp),%xmm2
movss  %xmm0,(%r14)
xorps  %xmm6,%xmm6
ucomiss %xmm6,%xmm1
jae    1300 <eig22+0x1f0>
movaps %xmm1,%xmm0
call   1030 <sqrtf@plt>
xorps  %xmm6,%xmm6
movaps 0x20(%rsp),%xmm5
movaps 0x10(%rsp),%xmm3
movss  0x8(%rsp),%xmm2
movaps %xmm0,%xmm4
xorps  0xd09(%rip),%xmm4
movss  %xmm4,0x4(%r14)
movaps %xmm3,%xmm0
mulss  %xmm5,%xmm0
ucomiss %xmm6,%xmm0
jb     1383 <eig22+0x273>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
jne    1323 <eig22+0x213>
jnp    1360 <eig22+0x250>
movaps %xmm5,%xmm0
divss  %xmm3,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1338 <eig22+0x228>
sqrtss %xmm0,%xmm0
jmp    134d <eig22+0x23d>
call   1030 <sqrtf@plt>
movaps 0x20(%rsp),%xmm5
movaps 0x10(%rsp),%xmm3
movss  0x8(%rsp),%xmm2
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
addss  0xca8(%rip),%xmm1
divss  %xmm1,%xmm0
movq   $0x0,(%r14)
addss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm2,%xmm0
subss  %xmm3,%xmm0
movss  %xmm0,(%rbx)
addss  %xmm2,%xmm3
movss  %xmm3,0x4(%rbx)
add    $0x68,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @eig22(float* %0, i32 %1, float* %2, float* %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
store float* %0, float** %5
store i32 %1, i32* %6
store float* %2, float** %7
store float* %3, float** %8
%26 = load i32, i32* %6
store i32 %26, i32* %9
%27 = load float*, float** %5
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
store float %29, float* %10
%30 = load float*, float** %5
%31 = getelementptr inbounds float, float* %30, i64 1
%32 = load float, float* %31
store float %32, float* %11
%33 = load float*, float** %5
%34 = load i32, i32* %9
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %33, i64 %35
%37 = load float, float* %36
store float %37, float* %12
%38 = load float*, float** %5
%39 = load i32, i32* %9
%40 = add nsw i32 %39, 1
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %38, i64 %41
%43 = load float, float* %42
store float %43, float* %13
%44 = load float, float* %11
%45 = load float, float* %12
%46 = fadd float %44, %45
%47 = fcmp oeq float %46, 0.000000e+00
br i1 %47, label %48, label %52
48: ; preds = %4
%49 = call float @sqrtf(float 2.000000e+00)
%50 = fdiv float 1.000000e+00, %49
store float %50, float* %14
%51 = load float, float* %14
store float %51, float* %15
br label %75
52: ; preds = %4
%53 = load float, float* %10
%54 = load float, float* %13
%55 = fsub float %53, %54
%56 = load float, float* %11
%57 = load float, float* %12
%58 = fadd float %56, %57
%59 = fdiv float %55, %58
store float %59, float* %19
%60 = load float, float* %19
%61 = load float, float* %19
%62 = load float, float* %19
%63 = call float @llvm.fmuladd.f32(float %61, float %62, float 1.000000e+00)
%64 = call float @sqrtf(float %63)
%65 = fadd float 1.000000e+00, %64
%66 = fdiv float %60, %65
store float %66, float* %20
%67 = load float, float* %20
%68 = load float, float* %20
%69 = call float @llvm.fmuladd.f32(float %67, float %68, float 1.000000e+00)
%70 = call float @sqrtf(float %69)
%71 = fdiv float 1.000000e+00, %70
store float %71, float* %14
%72 = load float, float* %14
%73 = load float, float* %20
%74 = fmul float %72, %73
store float %74, float* %15
br label %75
75: ; preds = %52, %48
%76 = load float, float* %14
%77 = load float, float* %14
%78 = fmul float %76, %77
store float %78, float* %16
%79 = load float, float* %15
%80 = load float, float* %15
%81 = fmul float %79, %80
store float %81, float* %17
%82 = load float, float* %14
%83 = load float, float* %15
%84 = fmul float %82, %83
store float %84, float* %18
%85 = load float, float* %16
%86 = load float, float* %10
%87 = load float, float* %17
%88 = load float, float* %13
%89 = fmul float %87, %88
%90 = call float @llvm.fmuladd.f32(float %85, float %86, float %89)
%91 = load float, float* %18
%92 = load float, float* %11
%93 = load float, float* %12
%94 = fadd float %92, %93
%95 = fneg float %91
%96 = call float @llvm.fmuladd.f32(float %95, float %94, float %90)
store float %96, float* %22
%97 = load float, float* %16
%98 = load float, float* %11
%99 = load float, float* %17
%100 = load float, float* %12
%101 = fmul float %99, %100
%102 = fneg float %101
%103 = call float @llvm.fmuladd.f32(float %97, float %98, float %102)
%104 = load float, float* %18
%105 = load float, float* %10
%106 = load float, float* %13
%107 = fsub float %105, %106
%108 = call float @llvm.fmuladd.f32(float %104, float %107, float %103)
store float %108, float* %23
%109 = load float, float* %16
%110 = load float, float* %12
%111 = load float, float* %17
%112 = load float, float* %11
%113 = fmul float %111, %112
%114 = fneg float %113
%115 = call float @llvm.fmuladd.f32(float %109, float %110, float %114)
%116 = load float, float* %18
%117 = load float, float* %10
%118 = load float, float* %13
%119 = fsub float %117, %118
%120 = call float @llvm.fmuladd.f32(float %116, float %119, float %115)
store float %120, float* %24
%121 = load float, float* %16
%122 = load float, float* %13
%123 = load float, float* %17
%124 = load float, float* %10
%125 = fmul float %123, %124
%126 = call float @llvm.fmuladd.f32(float %121, float %122, float %125)
%127 = load float, float* %18
%128 = load float, float* %11
%129 = load float, float* %12
%130 = fadd float %128, %129
%131 = call float @llvm.fmuladd.f32(float %127, float %130, float %126)
store float %131, float* %25
%132 = load float, float* %22
%133 = load float*, float** %7
%134 = getelementptr inbounds float, float* %133, i64 1
store float %132, float* %134
%135 = load float*, float** %7
%136 = getelementptr inbounds float, float* %135, i64 0
store float %132, float* %136
%137 = load float, float* %23
%138 = fneg float %137
%139 = load float, float* %24
%140 = fmul float %138, %139
%141 = call float @sqrtf(float %140)
%142 = load float*, float** %8
%143 = getelementptr inbounds float, float* %142, i64 0
store float %141, float* %143
%144 = load float, float* %23
%145 = fneg float %144
%146 = load float, float* %24
%147 = fmul float %145, %146
%148 = call float @sqrtf(float %147)
%149 = fneg float %148
%150 = load float*, float** %8
%151 = getelementptr inbounds float, float* %150, i64 1
store float %149, float* %151
%152 = load float, float* %23
%153 = load float, float* %24
%154 = fmul float %152, %153
%155 = fcmp oge float %154, 0.000000e+00
br i1 %155, label %156, label %200
156: ; preds = %75
%157 = load float, float* %23
%158 = fcmp oeq float %157, 0.000000e+00
br i1 %158, label %159, label %160
159: ; preds = %156
store float 0.000000e+00, float* %14
store float 1.000000e+00, float* %15
store float 0.000000e+00, float* %16
store float 1.000000e+00, float* %17
store float 0.000000e+00, float* %18
br label %178
160: ; preds = %156
%161 = load float, float* %24
%162 = load float, float* %23
%163 = fdiv float %161, %162
%164 = call float @sqrtf(float %163)
store float %164, float* %20
%165 = load float, float* %20
%166 = load float, float* %20
%167 = fmul float %165, %166
store float %167, float* %21
%168 = load float, float* %20
%169 = load float, float* %21
%170 = fadd float 1.000000e+00, %169
%171 = fdiv float %168, %170
store float %171, float* %18
%172 = load float, float* %21
%173 = fadd float 1.000000e+00, %172
store float %173, float* %16
%174 = load float, float* %21
%175 = load float, float* %21
%176 = fadd float 1.000000e+00, %175
%177 = fdiv float %174, %176
store float %177, float* %17
br label %178
178: ; preds = %160, %159
%179 = load float*, float** %8
%180 = getelementptr inbounds float, float* %179, i64 1
store float 0.000000e+00, float* %180
%181 = load float*, float** %8
%182 = getelementptr inbounds float, float* %181, i64 0
store float 0.000000e+00, float* %182
%183 = load float, float* %22
%184 = load float, float* %18
%185 = load float, float* %23
%186 = load float, float* %24
%187 = fadd float %185, %186
%188 = fneg float %184
%189 = call float @llvm.fmuladd.f32(float %188, float %187, float %183)
%190 = load float*, float** %7
%191 = getelementptr inbounds float, float* %190, i64 0
store float %189, float* %191
%192 = load float, float* %22
%193 = load float, float* %18
%194 = load float, float* %23
%195 = load float, float* %24
%196 = fadd float %194, %195
%197 = call float @llvm.fmuladd.f32(float %193, float %196, float %192)
%198 = load float*, float** %7
%199 = getelementptr inbounds float, float* %198, i64 1
store float %197, float* %199
br label %200
200: ; preds = %178, %75
ret void
}

LLVM IR (-O2):
define void @eig22(float* nocapture %0, i32 %1, float* nocapture writeonly %2, float* nocapture writeonly %3) {
%5 = load float, float* %0
%6 = getelementptr inbounds float, float* %0, i64 1
%7 = load float, float* %6
%8 = sext i32 %1 to i64
%9 = getelementptr inbounds float, float* %0, i64 %8
%10 = load float, float* %9
%11 = add nsw i32 %1, 1
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds float, float* %0, i64 %12
%14 = load float, float* %13
%15 = fadd float %7, %10
%16 = fcmp oeq float %15, 0.000000e+00
%17 = fsub float %5, %14
br i1 %16, label %28, label %18
18: ; preds = %4
%19 = fdiv float %17, %15
%20 = tail call float @llvm.fmuladd.f32(float %19, float %19, float 1.000000e+00)
%21 = tail call float @sqrtf(float %20)
%22 = fadd float %21, 1.000000e+00
%23 = fdiv float %19, %22
%24 = tail call float @llvm.fmuladd.f32(float %23, float %23, float 1.000000e+00)
%25 = tail call float @sqrtf(float %24)
%26 = fdiv float 1.000000e+00, %25
%27 = fmul float %26, %23
br label %28
28: ; preds = %4, %18
%29 = phi float [ %27, %18 ], [ 0x3FE6A09E60000000, %4 ]
%30 = phi float [ %26, %18 ], [ 0x3FE6A09E60000000, %4 ]
%31 = fmul float %30, %30
%32 = fmul float %29, %29
%33 = fmul float %29, %30
%34 = fmul float %14, %32
%35 = tail call float @llvm.fmuladd.f32(float %31, float %5, float %34)
%36 = fneg float %33
%37 = tail call float @llvm.fmuladd.f32(float %36, float %15, float %35)
%38 = fneg float %32
%39 = insertelement <2 x float> poison, float %10, i64 0
%40 = insertelement <2 x float> %39, float %7, i64 1
%41 = insertelement <2 x float> poison, float %38, i64 0
%42 = shufflevector <2 x float> %41, <2 x float> poison, <2 x i32> zeroinitializer
%43 = fmul <2 x float> %40, %42
%44 = insertelement <2 x float> poison, float %31, i64 0
%45 = shufflevector <2 x float> %44, <2 x float> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x float> poison, float %7, i64 0
%47 = insertelement <2 x float> %46, float %10, i64 1
%48 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %45, <2 x float> %47, <2 x float> %43)
%49 = insertelement <2 x float> poison, float %33, i64 0
%50 = shufflevector <2 x float> %49, <2 x float> poison, <2 x i32> zeroinitializer
%51 = insertelement <2 x float> poison, float %17, i64 0
%52 = shufflevector <2 x float> %51, <2 x float> poison, <2 x i32> zeroinitializer
%53 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %50, <2 x float> %52, <2 x float> %48)
%54 = getelementptr inbounds float, float* %2, i64 1
store float %37, float* %54
store float %37, float* %2
%55 = extractelement <2 x float> %53, i64 0
%56 = fneg float %55
%57 = extractelement <2 x float> %53, i64 1
%58 = fmul float %57, %56
%59 = tail call float @sqrtf(float %58)
store float %59, float* %3
%60 = tail call float @sqrtf(float %58)
%61 = fneg float %60
%62 = getelementptr inbounds float, float* %3, i64 1
store float %61, float* %62
%63 = fmul float %55, %57
%64 = fcmp ult float %63, 0.000000e+00
br i1 %64, label %79, label %65
65: ; preds = %28
%66 = fcmp oeq float %55, 0.000000e+00
br i1 %66, label %73, label %67
67: ; preds = %65
%68 = fdiv float %57, %55
%69 = tail call float @sqrtf(float %68)
%70 = fmul float %69, %69
%71 = fadd float %70, 1.000000e+00
%72 = fdiv float %69, %71
br label %73
73: ; preds = %65, %67
%74 = phi float [ %72, %67 ], [ 0.000000e+00, %65 ]
store float 0.000000e+00, float* %62
store float 0.000000e+00, float* %3
%75 = fadd float %55, %57
%76 = fneg float %74
%77 = tail call float @llvm.fmuladd.f32(float %76, float %75, float %37)
store float %77, float* %2
%78 = tail call float @llvm.fmuladd.f32(float %74, float %75, float %37)
store float %78, float* %54
br label %79
79: ; preds = %73, %28
ret void
}