#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*/ Adjoint(double **, double **);
int /*<<< orphan*/ Matrix4Equal(double **, double **);
int /*<<< orphan*/ Matrix4Mult(double **, double **, double **);
int /*<<< orphan*/ Matrix4MultValue(double **, double, double **);
int /*<<< orphan*/ MatrixExp6(double **, double **);
int /*<<< orphan*/ VecTose3(double *, double **);
void JacobianSpace(int JointNum, double *Slist, double *thetalist, double *Js) {
  int i;
  int j;
  int k;
  double T1[4][4];
  double T2[4][4];
  double se3mat[4][4];
  double V[6];
  double AdT[6][6];
  double T[4][4] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
  for (i = 0; i < 6; i++) {
    Js[i * JointNum + 0] = Slist[i * JointNum + 0];
  }
  for (i = 1; i < JointNum; i++) {
    for (j = 0; j < 6; j++) {
      V[j] = Slist[j * JointNum + i - 1];
    }
    VecTose3(V, se3mat);
    Matrix4MultValue(se3mat, thetalist[i - 1], se3mat);
    MatrixExp6(se3mat, T1);
    Matrix4Mult(T, T1, T2);
    Matrix4Equal(T2, T);
    Adjoint(T, AdT);
    for (j = 0; j < 6; j++) {
      Js[j * JointNum + i] = 0;
      for (k = 0; k < 6; k++) {
        Js[j * JointNum + i] =
            Js[j * JointNum + i] + AdT[j][k] * Slist[k * JointNum + i];
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<JacobianSpace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
lea    -0x380(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1060 <memset@plt>
movsd  0xe5b(%rip),%xmm0
movsd  %xmm0,-0x380(%rbp)
ff
movsd  0xe4b(%rip),%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  0xe3b(%rip),%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
movsd  0xe2b(%rip),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x0,-0x24(%rbp)
cmpl   $0x6,-0x24(%rbp)
jge    1228 <JacobianSpace+0xb8>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e4 <JacobianSpace+0x74>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13df <JacobianSpace+0x26f>
movl   $0x0,-0x28(%rbp)
cmpl   $0x6,-0x28(%rbp)
jge    1280 <JacobianSpace+0x110>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x28(%rbp),%rax
movsd  %xmm0,-0x1e0(%rbp,%rax,8)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1242 <JacobianSpace+0xd2>
lea    -0x1e0(%rbp),%rdi
lea    -0x1b0(%rbp),%rsi
call   1090 <VecTose3@plt>
lea    -0x1b0(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    -0x1b0(%rbp),%rsi
call   1070 <Matrix4MultValue@plt>
lea    -0x1b0(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
call   1030 <MatrixExp6@plt>
lea    -0x380(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x130(%rbp),%rdx
call   1040 <Matrix4Mult@plt>
lea    -0x130(%rbp),%rdi
lea    -0x380(%rbp),%rsi
call   1050 <Matrix4Equal@plt>
lea    -0x380(%rbp),%rdi
lea    -0x300(%rbp),%rsi
call   1080 <Adjoint@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x6,-0x28(%rbp)
jge    13cc <JacobianSpace+0x25c>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x6,-0x2c(%rbp)
jge    13b9 <JacobianSpace+0x249>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x28(%rbp),%rcx
lea    -0x300(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    133c <JacobianSpace+0x1cc>
jmp    13be <JacobianSpace+0x24e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1312 <JacobianSpace+0x1a2>
jmp    13d1 <JacobianSpace+0x261>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    122f <JacobianSpace+0xbf>
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<JacobianSpace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x398,%rsp
mov    %rcx,%r9
mov    %rdx,0x30(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x80(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x70(%rsp)
mov    %rax,0x98(%rsp)
mov    %rax,0xc0(%rsp)
mov    %rax,0xe8(%rsp)
movslq %edi,%rcx
movsd  (%rsi),%xmm0
movsd  %xmm0,(%r9)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%r9,%rcx,8)
mov    %rcx,%rax
shl    $0x4,%rax
movsd  (%rsi,%rax,1),%xmm0
movsd  %xmm0,(%r9,%rax,1)
lea    (%rcx,%rcx,2),%rax
movsd  (%rsi,%rax,8),%xmm0
mov    %rax,0x18(%rsp)
movsd  %xmm0,(%r9,%rax,8)
mov    %rcx,%rax
shl    $0x5,%rax
movsd  (%rsi,%rax,1),%xmm0
movsd  %xmm0,(%r9,%rax,1)
lea    (%rcx,%rcx,4),%rax
movsd  (%rsi,%rax,8),%xmm0
mov    %rax,0x28(%rsp)
movsd  %xmm0,(%r9,%rax,8)
mov    %rcx,(%rsp)
cmp    $0x2,%ecx
jl     1474 <JacobianSpace+0x314>
mov    %rsi,%rbx
mov    (%rsp),%rax
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x10(%rsp)
lea    0x0(,%rax,4),%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%ecx
mov    %rcx,0x20(%rsp)
add    $0x8,%r9
lea    0x0(,%rax,8),%r14
mov    $0x1,%r12d
mov    0x28(%rsp),%r13
nopl   0x0(%rax,%rax,1)
mov    %r9,0x38(%rsp)
lea    -0x1(%r12),%rax
movsd  -0x8(%rbx,%r12,8),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    (%rsp),%rcx
add    %eax,%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x50(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    0x8(%rsp),%rcx
lea    (%rcx,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x60(%rsp)
add    %r13d,%eax
cltq
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x68(%rsp)
lea    0x40(%rsp),%rdi
lea    0x210(%rsp),%rbp
mov    %rbp,%rsi
call   1080 <VecTose3@plt>
mov    0x30(%rsp),%rax
movsd  -0x8(%rax,%r12,8),%xmm0
mov    %rbp,%rdi
mov    %rbp,%rsi
call   1060 <Matrix4MultValue@plt>
mov    %rbp,%rdi
lea    0x310(%rsp),%rbp
mov    %rbp,%rsi
call   1030 <MatrixExp6@plt>
lea    0x70(%rsp),%r15
mov    %r15,%rdi
mov    %rbp,%rsi
lea    0x290(%rsp),%rbp
mov    %rbp,%rdx
call   1040 <Matrix4Mult@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
call   1050 <Matrix4Equal@plt>
mov    %r15,%rdi
lea    0xf0(%rsp),%rsi
call   1070 <Adjoint@plt>
xorpd  %xmm2,%xmm2
mov    0x38(%rsp),%r9
mov    (%rsp),%rax
lea    (%r12,%rax,1),%r8
mov    0x10(%rsp),%rax
lea    (%rax,%r12,1),%rcx
mov    0x18(%rsp),%rax
lea    (%rax,%r12,1),%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%r12,1),%rsi
lea    (%r12,%r13,1),%rdi
mov    $0x28,%ebp
mov    %r9,%rax
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rax)
movsd  0xc8(%rsp,%rbp,1),%xmm0
mulsd  (%rbx,%r12,8),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rax)
movsd  0xd0(%rsp,%rbp,1),%xmm1
mulsd  (%rbx,%r8,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
movsd  0xd8(%rsp,%rbp,1),%xmm0
mulsd  (%rbx,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  0xe0(%rsp,%rbp,1),%xmm1
mulsd  (%rbx,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
movsd  0xe8(%rsp,%rbp,1),%xmm0
mulsd  (%rbx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  0xf0(%rsp,%rbp,1),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
add    %r14,%rax
add    $0x30,%rbp
cmp    $0x148,%rbp
jne    13c0 <JacobianSpace+0x260>
add    $0x1,%r12
add    $0x8,%r9
cmp    0x20(%rsp),%r12
jne    1290 <JacobianSpace+0x130>
add    $0x398,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @JacobianSpace(i32 %0, double* nocapture %1, double* nocapture %2, double* nocapture %3) {
%5 = alloca [4 x [4 x double]]
%6 = alloca [4 x [4 x double]]
%7 = alloca [4 x [4 x double]]
%8 = alloca [6 x double]
%9 = alloca [6 x [6 x double]]
%10 = alloca [4 x [4 x double]]
%11 = bitcast [4 x [4 x double]]* %5 to i8*
%12 = bitcast [4 x [4 x double]]* %6 to i8*
%13 = bitcast [4 x [4 x double]]* %7 to i8*
%14 = bitcast [6 x double]* %8 to i8*
%15 = bitcast [6 x [6 x double]]* %9 to i8*
%16 = bitcast [4 x [4 x double]]* %10 to i8*
%17 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %10, i64 0, i64 0, i64 0
store double 1.000000e+00, double* %17
%18 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %10, i64 0, i64 1, i64 1
store double 1.000000e+00, double* %18
%19 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %10, i64 0, i64 2, i64 2
store double 1.000000e+00, double* %19
%20 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %10, i64 0, i64 3, i64 3
store double 1.000000e+00, double* %20
%21 = sext i32 %0 to i64
%22 = load double, double* %1
store double %22, double* %3
%23 = getelementptr inbounds double, double* %1, i64 %21
%24 = load double, double* %23
%25 = getelementptr inbounds double, double* %3, i64 %21
store double %24, double* %25
%26 = shl nsw i64 %21, 1
%27 = getelementptr inbounds double, double* %1, i64 %26
%28 = load double, double* %27
%29 = getelementptr inbounds double, double* %3, i64 %26
store double %28, double* %29
%30 = mul nsw i64 %21, 3
%31 = getelementptr inbounds double, double* %1, i64 %30
%32 = load double, double* %31
%33 = getelementptr inbounds double, double* %3, i64 %30
store double %32, double* %33
%34 = shl nsw i64 %21, 2
%35 = getelementptr inbounds double, double* %1, i64 %34
%36 = load double, double* %35
%37 = getelementptr inbounds double, double* %3, i64 %34
store double %36, double* %37
%38 = mul nsw i64 %21, 5
%39 = getelementptr inbounds double, double* %1, i64 %38
%40 = load double, double* %39
%41 = getelementptr inbounds double, double* %3, i64 %38
store double %40, double* %41
%42 = icmp sgt i32 %0, 1
br i1 %42, label %43, label %139
43: ; preds = %4
%44 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 0
%45 = bitcast [4 x [4 x double]]* %7 to double**
%46 = bitcast [4 x [4 x double]]* %5 to double**
%47 = bitcast [4 x [4 x double]]* %10 to double**
%48 = bitcast [4 x [4 x double]]* %6 to double**
%49 = bitcast [6 x [6 x double]]* %9 to double**
%50 = zext i32 %0 to i64
%51 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 1
%52 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 2
%53 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 3
%54 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 4
%55 = getelementptr inbounds [6 x double], [6 x double]* %8, i64 0, i64 5
br label %56
56: ; preds = %43, %136
%57 = phi i64 [ 1, %43 ], [ %137, %136 ]
%58 = add nsw i64 %57, -1
%59 = getelementptr inbounds double, double* %1, i64 %58
%60 = load double, double* %59
store double %60, double* %44
%61 = trunc i64 %58 to i32
%62 = add i32 %61, %0
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %1, i64 %63
%65 = load double, double* %64
store double %65, double* %51
%66 = add i64 %58, %26
%67 = shl i64 %66, 32
%68 = ashr exact i64 %67, 32
%69 = getelementptr inbounds double, double* %1, i64 %68
%70 = load double, double* %69
store double %70, double* %52
%71 = add i64 %58, %30
%72 = shl i64 %71, 32
%73 = ashr exact i64 %72, 32
%74 = getelementptr inbounds double, double* %1, i64 %73
%75 = load double, double* %74
store double %75, double* %53
%76 = add i64 %58, %34
%77 = shl i64 %76, 32
%78 = ashr exact i64 %77, 32
%79 = getelementptr inbounds double, double* %1, i64 %78
%80 = load double, double* %79
store double %80, double* %54
%81 = add i64 %58, %38
%82 = shl i64 %81, 32
%83 = ashr exact i64 %82, 32
%84 = getelementptr inbounds double, double* %1, i64 %83
%85 = load double, double* %84
store double %85, double* %55
%86 = call i32 @VecTose3(double* %44, double** %45)
%87 = getelementptr inbounds double, double* %2, i64 %58
%88 = load double, double* %87
%89 = call i32 @Matrix4MultValue(double** %45, double %88, double** %45)
%90 = call i32 @MatrixExp6(double** %45, double** %46)
%91 = call i32 @Matrix4Mult(double** %47, double** %46, double** %48)
%92 = call i32 @Matrix4Equal(double** %48, double** %47)
%93 = call i32 @Adjoint(double** %47, double** %49)
%94 = getelementptr inbounds double, double* %1, i64 %57
%95 = add nsw i64 %57, %21
%96 = getelementptr inbounds double, double* %1, i64 %95
%97 = add nsw i64 %26, %57
%98 = getelementptr inbounds double, double* %1, i64 %97
%99 = add nsw i64 %30, %57
%100 = getelementptr inbounds double, double* %1, i64 %99
%101 = add nsw i64 %34, %57
%102 = getelementptr inbounds double, double* %1, i64 %101
%103 = add nsw i64 %38, %57
%104 = getelementptr inbounds double, double* %1, i64 %103
br label %105
105: ; preds = %56, %105
%106 = phi i64 [ 0, %56 ], [ %134, %105 ]
%107 = mul nsw i64 %106, %21
%108 = add nsw i64 %107, %57
%109 = getelementptr inbounds double, double* %3, i64 %108
store double 0.000000e+00, double* %109
%110 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 0
%111 = load double, double* %110
%112 = load double, double* %94
%113 = call double @llvm.fmuladd.f64(double %111, double %112, double 0.000000e+00)
store double %113, double* %109
%114 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 1
%115 = load double, double* %114
%116 = load double, double* %96
%117 = call double @llvm.fmuladd.f64(double %115, double %116, double %113)
store double %117, double* %109
%118 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 2
%119 = load double, double* %118
%120 = load double, double* %98
%121 = call double @llvm.fmuladd.f64(double %119, double %120, double %117)
store double %121, double* %109
%122 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 3
%123 = load double, double* %122
%124 = load double, double* %100
%125 = call double @llvm.fmuladd.f64(double %123, double %124, double %121)
store double %125, double* %109
%126 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 4
%127 = load double, double* %126
%128 = load double, double* %102
%129 = call double @llvm.fmuladd.f64(double %127, double %128, double %125)
store double %129, double* %109
%130 = getelementptr inbounds [6 x [6 x double]], [6 x [6 x double]]* %9, i64 0, i64 %106, i64 5
%131 = load double, double* %130
%132 = load double, double* %104
%133 = call double @llvm.fmuladd.f64(double %131, double %132, double %129)
store double %133, double* %109
%134 = add nuw nsw i64 %106, 1
%135 = icmp eq i64 %134, 6
br i1 %135, label %136, label %105
136: ; preds = %105
%137 = add nuw nsw i64 %57, 1
%138 = icmp eq i64 %137, %50
br i1 %138, label %139, label %56
139: ; preds = %136, %4
ret void
}