#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*/ Update_Column(double *, double, double, int, int);
int /*<<< orphan*/ Update_Row(double *, double, double, int, int);
int /*<<< orphan*/ Update_Transformation(double *, double, double, int, int);
double fabs(double);
double sqrt(double);
void Two_Eigenvalues(double *H, double *S, double eigen_real[],
                     double eigen_imag[], int n, int row, double shift) {
  double p, q, x, discriminant, r;
  double cos, sin;
  double *Hrow = H + n * row;
  double *Hnextrow = Hrow + n;
  int nextrow = row + 1;
  p = 0.5 * (Hrow[row] - Hnextrow[nextrow]);
  x = Hrow[nextrow] * Hnextrow[row];
  discriminant = p * p + x;
  Hrow[row] += shift;
  Hnextrow[nextrow] += shift;
  if (discriminant > 0.0) {
    q = sqrt(discriminant);
    if (p < 0.0)
      q = p - q;
    else
      q += p;
    eigen_real[row] = Hnextrow[nextrow] + q;
    eigen_real[nextrow] = Hnextrow[nextrow] - x / q;
    eigen_imag[row] = 0.0;
    eigen_imag[nextrow] = 0.0;
    r = sqrt(Hnextrow[row] * Hnextrow[row] + q * q);
    sin = Hnextrow[row] / r;
    cos = q / r;
    Update_Row(Hrow, cos, sin, n, row);
    Update_Column(H, cos, sin, n, row);
    Update_Transformation(S, cos, sin, n, row);
  } else {
    eigen_real[nextrow] = eigen_real[row] = Hnextrow[nextrow] + p;
    eigen_imag[row] = sqrt(fabs(discriminant));
    eigen_imag[nextrow] = -eigen_imag[row];
  }
}


x86 assembly (clang, -O0):
<Two_Eigenvalues>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xe41(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1396 <Two_Eigenvalues+0x256>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1274 <Two_Eigenvalues+0x134>
movsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    1283 <Two_Eigenvalues+0x143>
movsd  -0x38(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm1
divsd  -0x40(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x70(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <Update_Row@plt>
mov    -0x8(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1050 <Update_Column@plt>
mov    -0x10(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1030 <Update_Transformation@plt>
jmp    1415 <Two_Eigenvalues+0x2d5>
mov    -0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movaps 0xc42(%rip),%xmm1
pand   %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Two_Eigenvalues>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%r14
movslq %r9d,%rbx
imul   %r8d,%r9d
movslq %r9d,%rax
lea    (%rdi,%rax,8),%rbp
movslq %r8d,%rax
lea    0x0(,%rax,8),%r12
add    %rbp,%r12
lea    0x1(%rbx),%r15
movsd  0x0(%rbp,%rbx,8),%xmm2
movsd  0x8(%rbp,%rbx,8),%xmm4
movapd %xmm2,%xmm5
subsd  0x8(%r12,%rbx,8),%xmm5
mulsd  0xe70(%rip),%xmm5
mulsd  (%r12,%rbx,8),%xmm4
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
addsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
addsd  0x8(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jbe    11dc <Two_Eigenvalues+0x9c>
mov    %r8d,%r13d
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
jb     120a <Two_Eigenvalues+0xca>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1235 <Two_Eigenvalues+0xf5>
addsd  %xmm0,%xmm5
movsd  %xmm5,(%r14,%rbx,8)
movsd  %xmm5,(%r14,%r15,8)
andpd  0xe1c(%rip),%xmm1
ucomisd %xmm2,%xmm1
jb     12b3 <Two_Eigenvalues+0x173>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    12c2 <Two_Eigenvalues+0x182>
movapd %xmm1,%xmm0
mov    %rcx,0x10(%rsp)
movsd  %xmm4,0x8(%rsp)
movsd  %xmm5,0x20(%rsp)
call   1060 <sqrt@plt>
movsd  0x20(%rsp),%xmm5
movsd  0x8(%rsp),%xmm4
mov    0x10(%rsp),%rcx
movapd 0xde3(%rip),%xmm1
xorpd  %xmm0,%xmm1
xorpd  %xmm2,%xmm2
movapd %xmm5,%xmm3
cmpltsd %xmm2,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm0,%xmm3
orpd   %xmm1,%xmm3
addsd  %xmm5,%xmm3
movsd  (%r12,%r15,8),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
movsd  (%r12,%r15,8),%xmm0
divsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,(%r14,%r15,8)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rcx,%rbx,8)
movsd  (%r12,%rbx,8),%xmm0
movapd %xmm3,0x10(%rsp)
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jb     12e4 <Two_Eigenvalues+0x1a4>
sqrtsd %xmm0,%xmm0
jmp    12e9 <Two_Eigenvalues+0x1a9>
movapd %xmm1,%xmm0
mov    %rcx,%rbp
call   1060 <sqrt@plt>
mov    %rbp,%rcx
movsd  %xmm0,(%rcx,%rbx,8)
xorpd  0xd51(%rip),%xmm0
movlpd %xmm0,(%rcx,%r15,8)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
call   1060 <sqrt@plt>
movsd  (%r12,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movapd 0x10(%rsp),%xmm2
divsd  %xmm0,%xmm2
movapd %xmm2,0x10(%rsp)
mov    %rbp,%rdi
movapd %xmm2,%xmm0
mov    %r13d,%esi
mov    %ebx,%edx
call   1040 <Update_Row@plt>
mov    0x28(%rsp),%rdi
movaps 0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    %r13d,%esi
mov    %ebx,%edx
call   1050 <Update_Column@plt>
mov    0x30(%rsp),%rdi
movaps 0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    %r13d,%esi
mov    %ebx,%edx
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <Update_Transformation@plt>

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

LLVM IR (-O2):
define void @Two_Eigenvalues(double* %0, double* %1, double* nocapture writeonly %2, double* nocapture writeonly %3, i32 %4, i32 %5, double %6) {
%8 = mul nsw i32 %5, %4
%9 = sext i32 %8 to i64
%10 = getelementptr inbounds double, double* %0, i64 %9
%11 = sext i32 %4 to i64
%12 = getelementptr inbounds double, double* %10, i64 %11
%13 = add nsw i32 %5, 1
%14 = sext i32 %5 to i64
%15 = getelementptr inbounds double, double* %10, i64 %14
%16 = load double, double* %15
%17 = sext i32 %13 to i64
%18 = getelementptr inbounds double, double* %12, i64 %17
%19 = load double, double* %18
%20 = fsub double %16, %19
%21 = fmul double %20, 5.000000e-01
%22 = getelementptr inbounds double, double* %10, i64 %17
%23 = load double, double* %22
%24 = getelementptr inbounds double, double* %12, i64 %14
%25 = load double, double* %24
%26 = fmul double %23, %25
%27 = tail call double @llvm.fmuladd.f64(double %21, double %21, double %26)
%28 = fadd double %16, %6
store double %28, double* %15
%29 = load double, double* %18
%30 = fadd double %29, %6
store double %30, double* %18
%31 = fcmp ogt double %27, 0.000000e+00
br i1 %31, label %32, label %57
32: ; preds = %7
%33 = tail call double @sqrt(double %27)
%34 = fcmp olt double %21, 0.000000e+00
%35 = fneg double %33
%36 = select i1 %34, double %35, double %33
%37 = fadd double %21, %36
%38 = load double, double* %18
%39 = fadd double %38, %37
%40 = getelementptr inbounds double, double* %2, i64 %14
store double %39, double* %40
%41 = load double, double* %18
%42 = fdiv double %26, %37
%43 = fsub double %41, %42
%44 = getelementptr inbounds double, double* %2, i64 %17
store double %43, double* %44
%45 = getelementptr inbounds double, double* %3, i64 %14
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %46
%47 = load double, double* %24
%48 = fmul double %37, %37
%49 = tail call double @llvm.fmuladd.f64(double %47, double %47, double %48)
%50 = tail call double @sqrt(double %49)
%51 = load double, double* %24
%52 = fdiv double %51, %50
%53 = fdiv double %37, %50
%54 = tail call i32 @Update_Row(double* %10, double %53, double %52, i32 %4, i32 %5)
%55 = tail call i32 @Update_Column(double* %0, double %53, double %52, i32 %4, i32 %5)
%56 = tail call i32 @Update_Transformation(double* %1, double %53, double %52, i32 %4, i32 %5)
br label %66
57: ; preds = %7
%58 = fadd double %21, %30
%59 = getelementptr inbounds double, double* %2, i64 %14
store double %58, double* %59
%60 = getelementptr inbounds double, double* %2, i64 %17
store double %58, double* %60
%61 = tail call double @llvm.fabs.f64(double %27)
%62 = tail call double @sqrt(double %61)
%63 = getelementptr inbounds double, double* %3, i64 %14
store double %62, double* %63
%64 = fneg double %62
%65 = getelementptr inbounds double, double* %3, i64 %17
store double %64, double* %65
br label %66
66: ; preds = %57, %32
ret void
}