#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 */
double **dmatrix(int, int, int, int);
double *dvector(int, int);
int /*<<< orphan*/ eigsrt(double *, double **);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int /*<<< orphan*/ free_dvector(double *, int, int);
int /*<<< orphan*/ jacobi(double **, double *, double **);
int DerivePrincipalStresses(double stressTensor[3][3], double sp[3],
                            double cn[3][3]) {
  double **a, **v, *d;
  int i, j;
  a = dmatrix(1, 3, 1, 3);
  v = dmatrix(1, 3, 1, 3);
  d = dvector(1, 3);
  a[1][1] = stressTensor[0][0];
  a[2][2] = stressTensor[1][1];
  a[3][3] = stressTensor[2][2];
  a[1][2] = stressTensor[0][1];
  a[1][3] = stressTensor[0][2];
  a[2][3] = stressTensor[1][2];
  a[2][1] = a[1][2];
  a[3][1] = a[1][3];
  a[3][2] = a[2][3];
  jacobi(a, d, v);
  d[1] *= -1.0f;
  d[2] *= -1.0f;
  d[3] *= -1.0f;
  eigsrt(d, v);
  d[1] *= -1.0f;
  d[2] *= -1.0f;
  d[3] *= -1.0f;
  for (i = 0; i < 3; i++) {
    sp[i] = d[i + 1];
    for (j = 0; j < 3; j++) {
      cn[i][j] = v[j + 1][i + 1];
    }
  }
  free_dmatrix(a, 1, 3, 1, 3);
  free_dmatrix(v, 1, 3, 1, 3);
  free_dvector(d, 1, 3);
  return (1);
}


x86 assembly (clang, -O0):
<DerivePrincipalStresses>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x3,%esi
call   1060 <dvector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0x18(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
mov    0x10(%rax),%rax
movsd  0x18(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1030 <jacobi@plt>
mov    -0x30(%rbp),%rax
movsd  0xd5d(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x30(%rbp),%rax
movsd  0xd47(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x30(%rbp),%rax
movsd  0xd31(%rip),%xmm0
mulsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x30(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1050 <eigsrt@plt>
mov    -0x30(%rbp),%rax
movsd  0xd0e(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x30(%rbp),%rax
movsd  0xcf8(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x30(%rbp),%rax
movsd  0xce2(%rip),%xmm0
mulsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rax)
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    13c1 <DerivePrincipalStresses+0x261>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x38(%rbp)
cmpl   $0x3,-0x38(%rbp)
jge    13ae <DerivePrincipalStresses+0x24e>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    135f <DerivePrincipalStresses+0x1ff>
jmp    13b3 <DerivePrincipalStresses+0x253>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    132f <DerivePrincipalStresses+0x1cf>
mov    -0x20(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1080 <free_dmatrix@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1080 <free_dmatrix@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1070 <free_dvector@plt>
mov    $0x1,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DerivePrincipalStresses>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbp
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   1040 <dmatrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   1040 <dmatrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x3,%esi
call   1060 <dvector@plt>
mov    %rax,%rbx
movsd  0x0(%rbp),%xmm0
mov    0x8(%r12),%rax
movsd  %xmm0,0x8(%rax)
movsd  0x20(%rbp),%xmm0
mov    0x10(%r12),%rcx
movsd  %xmm0,0x10(%rcx)
movsd  0x40(%rbp),%xmm0
mov    0x18(%r12),%rdx
movsd  %xmm0,0x18(%rdx)
movsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x18(%rax)
movsd  0x28(%rbp),%xmm0
movsd  %xmm0,0x18(%rcx)
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x8(%rcx)
movsd  0x18(%rax),%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x10(%rdx)
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
call   1030 <jacobi@plt>
movups 0x8(%rbx),%xmm0
movaps 0xdc0(%rip),%xmm1
xorps  %xmm1,%xmm0
movups %xmm0,0x8(%rbx)
movsd  0x18(%rbx),%xmm0
xorps  %xmm1,%xmm0
movlps %xmm0,0x18(%rbx)
mov    %rbx,%rdi
mov    %r13,%rsi
call   1050 <eigsrt@plt>
movups 0x8(%rbx),%xmm0
movaps 0xd97(%rip),%xmm2
xorps  %xmm2,%xmm0
movups %xmm0,0x8(%rbx)
movsd  0x18(%rbx),%xmm1
xorps  %xmm2,%xmm1
movlps %xmm1,0x18(%rbx)
movlps %xmm0,(%r14)
mov    0x8(%r13),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,(%r15)
mov    0x10(%r13),%rcx
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x8(%r15)
mov    0x18(%r13),%rdx
movsd  0x8(%rdx),%xmm0
movsd  %xmm0,0x10(%r15)
movsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x8(%r14)
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x18(%r15)
movsd  0x10(%rcx),%xmm0
movsd  %xmm0,0x20(%r15)
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,0x28(%r15)
movsd  0x18(%rbx),%xmm0
movsd  %xmm0,0x10(%r14)
movsd  0x18(%rax),%xmm0
movsd  %xmm0,0x30(%r15)
movsd  0x18(%rcx),%xmm0
movsd  %xmm0,0x38(%r15)
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,0x40(%r15)
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   1080 <free_dmatrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   1080 <free_dmatrix@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1070 <free_dvector@plt>
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @DerivePrincipalStresses([3 x double]* %0, double* %1, [3 x double]* %2) {
%4 = alloca [3 x double]*
%5 = alloca double*
%6 = alloca [3 x double]*
%7 = alloca double**
%8 = alloca double**
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
store [3 x double]* %0, [3 x double]** %4
store double* %1, double** %5
store [3 x double]* %2, [3 x double]** %6
%12 = call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
store double** %12, double*** %7
%13 = call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
store double** %13, double*** %8
%14 = call double* @dvector(i32 1, i32 3)
store double* %14, double** %9
%15 = load [3 x double]*, [3 x double]** %4
%16 = getelementptr inbounds [3 x double], [3 x double]* %15, i64 0
%17 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%18 = load double, double* %17
%19 = load double**, double*** %7
%20 = getelementptr inbounds double*, double** %19, i64 1
%21 = load double*, double** %20
%22 = getelementptr inbounds double, double* %21, i64 1
store double %18, double* %22
%23 = load [3 x double]*, [3 x double]** %4
%24 = getelementptr inbounds [3 x double], [3 x double]* %23, i64 1
%25 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 0, i64 1
%26 = load double, double* %25
%27 = load double**, double*** %7
%28 = getelementptr inbounds double*, double** %27, i64 2
%29 = load double*, double** %28
%30 = getelementptr inbounds double, double* %29, i64 2
store double %26, double* %30
%31 = load [3 x double]*, [3 x double]** %4
%32 = getelementptr inbounds [3 x double], [3 x double]* %31, i64 2
%33 = getelementptr inbounds [3 x double], [3 x double]* %32, i64 0, i64 2
%34 = load double, double* %33
%35 = load double**, double*** %7
%36 = getelementptr inbounds double*, double** %35, i64 3
%37 = load double*, double** %36
%38 = getelementptr inbounds double, double* %37, i64 3
store double %34, double* %38
%39 = load [3 x double]*, [3 x double]** %4
%40 = getelementptr inbounds [3 x double], [3 x double]* %39, i64 0
%41 = getelementptr inbounds [3 x double], [3 x double]* %40, i64 0, i64 1
%42 = load double, double* %41
%43 = load double**, double*** %7
%44 = getelementptr inbounds double*, double** %43, i64 1
%45 = load double*, double** %44
%46 = getelementptr inbounds double, double* %45, i64 2
store double %42, double* %46
%47 = load [3 x double]*, [3 x double]** %4
%48 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0
%49 = getelementptr inbounds [3 x double], [3 x double]* %48, i64 0, i64 2
%50 = load double, double* %49
%51 = load double**, double*** %7
%52 = getelementptr inbounds double*, double** %51, i64 1
%53 = load double*, double** %52
%54 = getelementptr inbounds double, double* %53, i64 3
store double %50, double* %54
%55 = load [3 x double]*, [3 x double]** %4
%56 = getelementptr inbounds [3 x double], [3 x double]* %55, i64 1
%57 = getelementptr inbounds [3 x double], [3 x double]* %56, i64 0, i64 2
%58 = load double, double* %57
%59 = load double**, double*** %7
%60 = getelementptr inbounds double*, double** %59, i64 2
%61 = load double*, double** %60
%62 = getelementptr inbounds double, double* %61, i64 3
store double %58, double* %62
%63 = load double**, double*** %7
%64 = getelementptr inbounds double*, double** %63, i64 1
%65 = load double*, double** %64
%66 = getelementptr inbounds double, double* %65, i64 2
%67 = load double, double* %66
%68 = load double**, double*** %7
%69 = getelementptr inbounds double*, double** %68, i64 2
%70 = load double*, double** %69
%71 = getelementptr inbounds double, double* %70, i64 1
store double %67, double* %71
%72 = load double**, double*** %7
%73 = getelementptr inbounds double*, double** %72, i64 1
%74 = load double*, double** %73
%75 = getelementptr inbounds double, double* %74, i64 3
%76 = load double, double* %75
%77 = load double**, double*** %7
%78 = getelementptr inbounds double*, double** %77, i64 3
%79 = load double*, double** %78
%80 = getelementptr inbounds double, double* %79, i64 1
store double %76, double* %80
%81 = load double**, double*** %7
%82 = getelementptr inbounds double*, double** %81, i64 2
%83 = load double*, double** %82
%84 = getelementptr inbounds double, double* %83, i64 3
%85 = load double, double* %84
%86 = load double**, double*** %7
%87 = getelementptr inbounds double*, double** %86, i64 3
%88 = load double*, double** %87
%89 = getelementptr inbounds double, double* %88, i64 2
store double %85, double* %89
%90 = load double**, double*** %7
%91 = load double*, double** %9
%92 = load double**, double*** %8
%93 = call i32 @jacobi(double** %90, double* %91, double** %92)
%94 = load double*, double** %9
%95 = getelementptr inbounds double, double* %94, i64 1
%96 = load double, double* %95
%97 = fmul double %96, -1.000000e+00
store double %97, double* %95
%98 = load double*, double** %9
%99 = getelementptr inbounds double, double* %98, i64 2
%100 = load double, double* %99
%101 = fmul double %100, -1.000000e+00
store double %101, double* %99
%102 = load double*, double** %9
%103 = getelementptr inbounds double, double* %102, i64 3
%104 = load double, double* %103
%105 = fmul double %104, -1.000000e+00
store double %105, double* %103
%106 = load double*, double** %9
%107 = load double**, double*** %8
%108 = call i32 @eigsrt(double* %106, double** %107)
%109 = load double*, double** %9
%110 = getelementptr inbounds double, double* %109, i64 1
%111 = load double, double* %110
%112 = fmul double %111, -1.000000e+00
store double %112, double* %110
%113 = load double*, double** %9
%114 = getelementptr inbounds double, double* %113, i64 2
%115 = load double, double* %114
%116 = fmul double %115, -1.000000e+00
store double %116, double* %114
%117 = load double*, double** %9
%118 = getelementptr inbounds double, double* %117, i64 3
%119 = load double, double* %118
%120 = fmul double %119, -1.000000e+00
store double %120, double* %118
store i32 0, i32* %10
br label %121
121: ; preds = %161, %3
%122 = load i32, i32* %10
%123 = icmp slt i32 %122, 3
br i1 %123, label %124, label %164
124: ; preds = %121
%125 = load double*, double** %9
%126 = load i32, i32* %10
%127 = add nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %125, i64 %128
%130 = load double, double* %129
%131 = load double*, double** %5
%132 = load i32, i32* %10
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
store double %130, double* %134
store i32 0, i32* %11
br label %135
135: ; preds = %157, %124
%136 = load i32, i32* %11
%137 = icmp slt i32 %136, 3
br i1 %137, label %138, label %160
138: ; preds = %135
%139 = load double**, double*** %8
%140 = load i32, i32* %11
%141 = add nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double*, double** %139, i64 %142
%144 = load double*, double** %143
%145 = load i32, i32* %10
%146 = add nsw i32 %145, 1
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %144, i64 %147
%149 = load double, double* %148
%150 = load [3 x double]*, [3 x double]** %6
%151 = load i32, i32* %10
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [3 x double], [3 x double]* %150, i64 %152
%154 = load i32, i32* %11
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [3 x double], [3 x double]* %153, i64 0, i64 %155
store double %149, double* %156
br label %157
157: ; preds = %138
%158 = load i32, i32* %11
%159 = add nsw i32 %158, 1
store i32 %159, i32* %11
br label %135
160: ; preds = %135
br label %161
161: ; preds = %160
%162 = load i32, i32* %10
%163 = add nsw i32 %162, 1
store i32 %163, i32* %10
br label %121
164: ; preds = %121
%165 = load double**, double*** %7
%166 = call i32 @free_dmatrix(double** %165, i32 1, i32 3, i32 1, i32 3)
%167 = load double**, double*** %8
%168 = call i32 @free_dmatrix(double** %167, i32 1, i32 3, i32 1, i32 3)
%169 = load double*, double** %9
%170 = call i32 @free_dvector(double* %169, i32 1, i32 3)
ret i32 1
}

LLVM IR (-O2):
define i32 @DerivePrincipalStresses([3 x double]* nocapture %0, double* nocapture writeonly %1, [3 x double]* nocapture writeonly %2) {
%4 = tail call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
%5 = tail call double** @dmatrix(i32 1, i32 3, i32 1, i32 3)
%6 = tail call double* @dvector(i32 1, i32 3)
%7 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%8 = load double, double* %7
%9 = getelementptr inbounds double*, double** %4, i64 1
%10 = load double*, double** %9
%11 = getelementptr inbounds double, double* %10, i64 1
store double %8, double* %11
%12 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%13 = load double, double* %12
%14 = getelementptr inbounds double*, double** %4, i64 2
%15 = load double*, double** %14
%16 = getelementptr inbounds double, double* %15, i64 2
store double %13, double* %16
%17 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 2
%18 = load double, double* %17
%19 = getelementptr inbounds double*, double** %4, i64 3
%20 = load double*, double** %19
%21 = getelementptr inbounds double, double* %20, i64 3
store double %18, double* %21
%22 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%23 = load double, double* %22
%24 = getelementptr inbounds double, double* %10, i64 2
store double %23, double* %24
%25 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%26 = load double, double* %25
%27 = getelementptr inbounds double, double* %10, i64 3
store double %26, double* %27
%28 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%29 = load double, double* %28
%30 = getelementptr inbounds double, double* %15, i64 3
store double %29, double* %30
%31 = load double, double* %24
%32 = getelementptr inbounds double, double* %15, i64 1
store double %31, double* %32
%33 = load double, double* %27
%34 = getelementptr inbounds double, double* %20, i64 1
store double %33, double* %34
%35 = load double, double* %30
%36 = getelementptr inbounds double, double* %20, i64 2
store double %35, double* %36
%37 = tail call i32 @jacobi(double** %4, double* %6, double** %5)
%38 = getelementptr inbounds double, double* %6, i64 1
%39 = getelementptr inbounds double, double* %6, i64 2
%40 = bitcast double* %38 to <2 x double>*
%41 = load <2 x double>, <2 x double>* %40
%42 = fneg <2 x double> %41
%43 = bitcast double* %38 to <2 x double>*
store <2 x double> %42, <2 x double>* %43
%44 = getelementptr inbounds double, double* %6, i64 3
%45 = load double, double* %44
%46 = fneg double %45
store double %46, double* %44
%47 = tail call i32 @eigsrt(double* %6, double** %5)
%48 = bitcast double* %38 to <2 x double>*
%49 = load <2 x double>, <2 x double>* %48
%50 = fneg <2 x double> %49
%51 = bitcast double* %38 to <2 x double>*
store <2 x double> %50, <2 x double>* %51
%52 = load double, double* %44
%53 = fneg double %52
store double %53, double* %44
%54 = getelementptr inbounds double*, double** %5, i64 1
%55 = extractelement <2 x double> %50, i64 0
store double %55, double* %1
%56 = load double*, double** %54
%57 = getelementptr inbounds double, double* %56, i64 1
%58 = load double, double* %57
%59 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 0
store double %58, double* %59
%60 = getelementptr inbounds double*, double** %5, i64 2
%61 = load double*, double** %60
%62 = getelementptr inbounds double, double* %61, i64 1
%63 = load double, double* %62
%64 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 1
store double %63, double* %64
%65 = getelementptr inbounds double*, double** %5, i64 3
%66 = load double*, double** %65
%67 = getelementptr inbounds double, double* %66, i64 1
%68 = load double, double* %67
%69 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 0, i64 2
store double %68, double* %69
%70 = load double, double* %39
%71 = getelementptr inbounds double, double* %1, i64 1
store double %70, double* %71
%72 = getelementptr inbounds double, double* %56, i64 2
%73 = load double, double* %72
%74 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 1, i64 0
store double %73, double* %74
%75 = getelementptr inbounds double, double* %61, i64 2
%76 = load double, double* %75
%77 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 1, i64 1
store double %76, double* %77
%78 = getelementptr inbounds double, double* %66, i64 2
%79 = load double, double* %78
%80 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 1, i64 2
store double %79, double* %80
%81 = load double, double* %44
%82 = getelementptr inbounds double, double* %1, i64 2
store double %81, double* %82
%83 = getelementptr inbounds double, double* %56, i64 3
%84 = load double, double* %83
%85 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 2, i64 0
store double %84, double* %85
%86 = getelementptr inbounds double, double* %61, i64 3
%87 = load double, double* %86
%88 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 2, i64 1
store double %87, double* %88
%89 = getelementptr inbounds double, double* %66, i64 3
%90 = load double, double* %89
%91 = getelementptr inbounds [3 x double], [3 x double]* %2, i64 2, i64 2
store double %90, double* %91
%92 = tail call i32 @free_dmatrix(double** %4, i32 1, i32 3, i32 1, i32 3)
%93 = tail call i32 @free_dmatrix(double** %5, i32 1, i32 3, i32 1, i32 3)
%94 = tail call i32 @free_dvector(double* %6, i32 1, i32 3)
ret i32 1
}