#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(int);
void eig2t(float *A, int stride) {
  int N;
  float a11, a12, a21, a22, c, s, c2, s2, cs, t1, t, 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);
  A[0] = at11;
  A[1] = at12;
  A[N] = at21;
  A[N + 1] = at22;
}


x86 assembly (clang, -O0):
<eig2t>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11b2 <eig2t+0xa2>
jp     11b2 <eig2t+0xa2>
mov    $0x2,%edi
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xe66(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    125f <eig2t+0x14f>
movss  -0x14(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
movss  -0x18(%rbp),%xmm1
addss  -0x1c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xe11(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm2
movss  -0x50(%rbp),%xmm0
movss  0xdf4(%rip),%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xdd1(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm1
movss  0xdb9(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x14(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
addss  -0x1c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x18(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
subss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
subss  -0x20(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x20(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
addss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eig2t>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%rbx
movss  (%rdi),%xmm1
movss  0x4(%rdi),%xmm2
movslq %esi,%r14
movss  (%rdi,%r14,4),%xmm0
movss  0x4(%rdi,%r14,4),%xmm3
lea    0x1(%r14),%r15
movss  %xmm2,0x1c(%rsp)
movss  %xmm0,0x18(%rsp)
addss  %xmm0,%xmm2
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
movss  %xmm1,0xc(%rsp)
movss  %xmm3,0x8(%rsp)
movss  %xmm2,0x14(%rsp)
jne    119a <eig2t+0x8a>
jp     119a <eig2t+0x8a>
mov    $0x2,%edi
call   1030 <sqrtf@plt>
movss  0x8(%rsp),%xmm8
movss  0xc(%rsp),%xmm9
movss  0xe7b(%rip),%xmm5
divss  %xmm0,%xmm5
movaps %xmm9,%xmm11
subss  %xmm8,%xmm11
movaps %xmm5,%xmm1
jmp    1221 <eig2t+0x111>
movaps %xmm1,%xmm0
subss  %xmm3,%xmm0
movss  %xmm0,0x10(%rsp)
divss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
mulss  %xmm0,%xmm0
addss  0xe43(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1030 <sqrtf@plt>
movss  0xe32(%rip),%xmm2
addss  %xmm2,%xmm0
movss  0x4(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
cvttss2si %xmm0,%edi
call   1030 <sqrtf@plt>
movss  0x10(%rsp),%xmm11
movss  0x4(%rsp),%xmm5
movss  0xdf5(%rip),%xmm1
movss  0x8(%rsp),%xmm8
movss  0xc(%rsp),%xmm9
divss  %xmm0,%xmm1
mulss  %xmm1,%xmm5
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm5
mulss  %xmm1,%xmm1
movaps %xmm8,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm1,%xmm4
mulss  %xmm9,%xmm4
addss  %xmm2,%xmm4
movss  0x14(%rsp),%xmm10
mulss  %xmm5,%xmm10
subss  %xmm10,%xmm4
movaps %xmm1,%xmm2
movss  0x18(%rsp),%xmm7
mulss  %xmm7,%xmm2
mulss  %xmm0,%xmm7
movaps %xmm1,%xmm3
movss  0x1c(%rsp),%xmm6
mulss  %xmm6,%xmm3
subss  %xmm7,%xmm3
mulss  %xmm11,%xmm5
addss  %xmm5,%xmm3
mulss  %xmm0,%xmm6
subss  %xmm6,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm9,%xmm0
mulss  %xmm8,%xmm1
addss  %xmm0,%xmm1
addss  %xmm10,%xmm1
movss  %xmm4,(%rbx)
movss  %xmm3,0x4(%rbx)
movss  %xmm2,(%rbx,%r14,4)
movss  %xmm1,(%rbx,%r15,4)
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @eig2t(float* nocapture %0, i32 %1) {
%3 = load float, float* %0
%4 = getelementptr inbounds float, float* %0, i64 1
%5 = load float, float* %4
%6 = sext i32 %1 to i64
%7 = getelementptr inbounds float, float* %0, i64 %6
%8 = load float, float* %7
%9 = add nsw i32 %1, 1
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds float, float* %0, i64 %10
%12 = load float, float* %11
%13 = fadd float %5, %8
%14 = fcmp oeq float %13, 0.000000e+00
br i1 %14, label %15, label %19
15: ; preds = %2
%16 = tail call float @sqrtf(i32 2)
%17 = fdiv float 1.000000e+00, %16
%18 = fsub float %3, %12
br label %32
19: ; preds = %2
%20 = fsub float %3, %12
%21 = fdiv float %20, %13
%22 = tail call float @llvm.fmuladd.f32(float %21, float %21, float 1.000000e+00)
%23 = fptosi float %22 to i32
%24 = tail call float @sqrtf(i32 %23)
%25 = fadd float %24, 1.000000e+00
%26 = fdiv float %21, %25
%27 = tail call float @llvm.fmuladd.f32(float %26, float %26, float 1.000000e+00)
%28 = fptosi float %27 to i32
%29 = tail call float @sqrtf(i32 %28)
%30 = fdiv float 1.000000e+00, %29
%31 = fmul float %30, %26
br label %32
32: ; preds = %19, %15
%33 = phi float [ %20, %19 ], [ %18, %15 ]
%34 = phi float [ %31, %19 ], [ %17, %15 ]
%35 = phi float [ %30, %19 ], [ %17, %15 ]
%36 = fmul float %35, %35
%37 = fmul float %34, %34
%38 = fmul float %34, %35
%39 = fmul float %12, %37
%40 = tail call float @llvm.fmuladd.f32(float %36, float %3, float %39)
%41 = fneg float %38
%42 = tail call float @llvm.fmuladd.f32(float %41, float %13, float %40)
%43 = fneg float %37
%44 = fmul float %8, %43
%45 = tail call float @llvm.fmuladd.f32(float %36, float %5, float %44)
%46 = tail call float @llvm.fmuladd.f32(float %38, float %33, float %45)
%47 = fmul float %5, %43
%48 = tail call float @llvm.fmuladd.f32(float %36, float %8, float %47)
%49 = tail call float @llvm.fmuladd.f32(float %38, float %33, float %48)
%50 = fmul float %3, %37
%51 = tail call float @llvm.fmuladd.f32(float %36, float %12, float %50)
%52 = tail call float @llvm.fmuladd.f32(float %38, float %13, float %51)
store float %42, float* %0
store float %46, float* %4
store float %49, float* %7
store float %52, float* %11
ret void
}