#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*/ Matrix3Mult(double **, double **, double **);
int /*<<< orphan*/ Matrix3MultVec(double **, double *, double *);
int /*<<< orphan*/ MatrixLog3(double **, double **);
int /*<<< orphan*/ TransToRp(double **, double **, double *);
double acos(double);
double fabs(double);
double tan(double);
void MatrixLog6(double T[4][4], double se3Mat[4][4]) {
  int i;
  int j;
  double R[3][3];
  double so3mat[3][3];
  double p[3];
  TransToRp(T, R, p);
  MatrixLog3(R, so3mat);
  int flag = 0;
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
      if (fabs(so3mat[i][j]) < 1.0E-6) {
        continue;
      } else {
        flag = 1;
        break;
      }
    }
  }
  if (!flag) {
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        se3Mat[i][j] = 0.0;
      }
    }
    se3Mat[0][3] = T[0][3];
    se3Mat[1][3] = T[1][3];
    se3Mat[2][3] = T[2][3];
    se3Mat[3][0] = 0.0;
    se3Mat[3][1] = 0.0;
    se3Mat[3][2] = 0.0;
    se3Mat[3][3] = 0.0;
  } else {
    double MatI3[3][3] = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0};
    double v[3];
    double temp[3][3];
    double InvGtheta[3][3];
    double theta = acos((R[0][0] + R[1][1] + R[2][2] - 1.0) / 2.0);
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        se3Mat[i][j] = so3mat[i][j];
      }
    }
    Matrix3Mult(so3mat, so3mat, temp);
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        InvGtheta[i][j] =
            MatI3[i][j] - 0.5 * so3mat[i][j] +
            (1.0 / theta - 0.5 * 1.0 / tan(0.5 * theta)) * temp[i][j] / theta;
      }
    }
    Matrix3MultVec(InvGtheta, p, v);
    se3Mat[0][3] = v[0];
    se3Mat[1][3] = v[1];
    se3Mat[2][3] = v[2];
    se3Mat[3][0] = 0.0;
    se3Mat[3][1] = 0.0;
    se3Mat[3][2] = 0.0;
    se3Mat[3][3] = 0.0;
  }
  return;
}


x86 assembly (clang, -O0):
<MatrixLog6>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
call   1030 <TransToRp@plt>
lea    -0x60(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
call   1070 <MatrixLog3@plt>
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1240 <MatrixLog6+0xd0>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    122d <MatrixLog6+0xbd>
movslq -0x14(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe3b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xe1f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1210 <MatrixLog6+0xa0>
jmp    121f <MatrixLog6+0xaf>
movl   $0x1,-0xd4(%rbp)
jmp    122d <MatrixLog6+0xbd>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11c9 <MatrixLog6+0x59>
jmp    1232 <MatrixLog6+0xc2>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b8 <MatrixLog6+0x48>
cmpl   $0x0,-0xd4(%rbp)
jne    1316 <MatrixLog6+0x1a6>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    12ab <MatrixLog6+0x13b>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    1298 <MatrixLog6+0x128>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1265 <MatrixLog6+0xf5>
jmp    129d <MatrixLog6+0x12d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1254 <MatrixLog6+0xe4>
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movsd  0x58(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x60(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x70(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x78(%rax)
jmp    15bd <MatrixLog6+0x44d>
lea    -0x120(%rbp),%rdi
xor    %esi,%esi
mov    $0x48,%edx
call   1060 <memset@plt>
movsd  0xcd7(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  0xcc7(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xcb7(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
addsd  -0x40(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  0xc98(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0xc84(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1050 <acos@plt>
movsd  %xmm0,-0x1e8(%rbp)
ff
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1403 <MatrixLog6+0x293>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    13f0 <MatrixLog6+0x280>
movslq -0x14(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13a5 <MatrixLog6+0x235>
jmp    13f5 <MatrixLog6+0x285>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1394 <MatrixLog6+0x224>
lea    -0xb0(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0x190(%rbp),%rdx
call   1080 <Matrix3Mult@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1540 <MatrixLog6+0x3d0>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    152d <MatrixLog6+0x3bd>
movslq -0x14(%rbp),%rcx
lea    -0x120(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x14(%rbp),%rcx
lea    -0xb0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb9b(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  0xb73(%rip),%xmm0
divsd  -0x1e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  0xb63(%rip),%xmm0
mulsd  -0x1e8(%rbp),%xmm0
ff
call   1090 <tan@plt>
movsd  -0x1f8(%rbp),%xmm1
ff
movaps %xmm0,%xmm3
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0xb3b(%rip),%xmm2
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
movslq -0x14(%rbp),%rcx
lea    -0x190(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x1e8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movslq -0x14(%rbp),%rcx
lea    -0x1e0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1435 <MatrixLog6+0x2c5>
jmp    1532 <MatrixLog6+0x3c2>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1424 <MatrixLog6+0x2b4>
lea    -0x1e0(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x140(%rbp),%rdx
call   1040 <Matrix3MultVec@plt>
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x60(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x70(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x78(%rax)
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixLog6>:
push   %r15
push   %r14
push   %rbx
sub    $0x1f0,%rsp
mov    %rsi,%r15
mov    %rdi,%r14
lea    0x1a0(%rsp),%rbx
lea    0xe0(%rsp),%rdx
mov    %rbx,%rsi
call   1030 <TransToRp@plt>
lea    0x20(%rsp),%rsi
mov    %rbx,%rdi
call   1060 <MatrixLog3@plt>
movsd  0x20(%rsp),%xmm1
andpd  0xe5b(%rip),%xmm1
mov    $0x1,%eax
movsd  0xe5e(%rip),%xmm0
ucomisd %xmm1,%xmm0
mov    $0x1,%ecx
jbe    11f1 <MatrixLog6+0x91>
movsd  0x28(%rsp),%xmm1
andpd  0xe35(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    $0x1,%ecx
jbe    11f1 <MatrixLog6+0x91>
movsd  0x30(%rsp),%xmm1
andpd  0xe1c(%rip),%xmm1
ucomisd %xmm1,%xmm0
mov    $0x1,%ecx
jbe    11f1 <MatrixLog6+0x91>
xor    %ecx,%ecx
movsd  0x38(%rsp),%xmm1
andpd  0xe01(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    122f <MatrixLog6+0xcf>
movsd  0x40(%rsp),%xmm1
andpd  0xded(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    122f <MatrixLog6+0xcf>
movsd  0x48(%rsp),%xmm1
andpd  0xdd9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    122f <MatrixLog6+0xcf>
mov    %ecx,%eax
movsd  0x50(%rsp),%xmm1
andpd  0xdc3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12d5 <MatrixLog6+0x175>
movsd  0x58(%rsp),%xmm1
andpd  0xdab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12d5 <MatrixLog6+0x175>
movsd  0x60(%rsp),%xmm1
andpd  0xd97(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12d5 <MatrixLog6+0x175>
test   %eax,%eax
jne    12d5 <MatrixLog6+0x175>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r15)
movq   $0x0,0x10(%r15)
movupd %xmm0,0x20(%r15)
movq   $0x0,0x30(%r15)
movupd %xmm0,0x40(%r15)
movq   $0x0,0x50(%r15)
movsd  0x18(%r14),%xmm1
movsd  %xmm1,0x18(%r15)
movsd  0x38(%r14),%xmm1
movsd  %xmm1,0x38(%r15)
movsd  0x58(%r14),%xmm1
movsd  %xmm1,0x58(%r15)
movupd %xmm0,0x60(%r15)
movupd %xmm0,0x70(%r15)
jmp    154a <MatrixLog6+0x3ea>
lea    0x38(%rsp),%rbx
xorpd  %xmm0,%xmm0
movapd %xmm0,0x90(%rsp)
movapd %xmm0,0xb0(%rsp)
movapd %xmm0,0xc0(%rsp)
movapd %xmm0,0xa0(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x90(%rsp)
mov    %rax,0xb0(%rsp)
mov    %rax,0xd0(%rsp)
movsd  0x1a0(%rsp),%xmm0
addsd  0x1c0(%rsp),%xmm0
addsd  0x1e0(%rsp),%xmm0
addsd  0xcd1(%rip),%xmm0
movsd  0xcd1(%rip),%xmm1
movsd  %xmm1,0x8(%rsp)
mulsd  %xmm1,%xmm0
call   1050 <acos@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x30(%rsp),%rax
mov    %rax,0x10(%r15)
movaps 0x20(%rsp),%xmm0
movups %xmm0,(%r15)
movups (%rbx),%xmm0
movups %xmm0,0x20(%r15)
mov    0x10(%rbx),%rax
mov    %rax,0x30(%r15)
mov    0x28(%rbx),%rax
mov    %rax,0x50(%r15)
movups 0x18(%rbx),%xmm0
movups %xmm0,0x40(%r15)
lea    0x20(%rsp),%rdi
lea    0x150(%rsp),%rdx
mov    %rdi,%rsi
call   1070 <Matrix3Mult@plt>
movsd  0xc74(%rip),%xmm0
movapd %xmm0,%xmm1
movsd  0x10(%rsp),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x8(%rsp),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsp)
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  0x20(%rsp,%rbx,1),%xmm2
movsd  0xc42(%rip),%xmm1
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1080 <tan@plt>
movsd  0xc22(%rip),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
addsd  0x18(%rsp),%xmm1
mulsd  0x150(%rsp,%rbx,1),%xmm1
divsd  0x10(%rsp),%xmm1
addsd  (%rsp),%xmm1
movsd  %xmm1,0x100(%rsp,%rbx,1)
movsd  0x28(%rsp,%rbx,1),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x98(%rsp,%rbx,1),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1080 <tan@plt>
movsd  0xbcc(%rip),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
addsd  0x18(%rsp),%xmm1
mulsd  0x158(%rsp,%rbx,1),%xmm1
divsd  0x10(%rsp),%xmm1
addsd  (%rsp),%xmm1
movsd  %xmm1,0x108(%rsp,%rbx,1)
movsd  0x30(%rsp,%rbx,1),%xmm0
mulsd  %xmm2,%xmm0
addsd  0xa0(%rsp,%rbx,1),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rsp),%xmm0
call   1080 <tan@plt>
movsd  0xb76(%rip),%xmm1
divsd  %xmm0,%xmm1
addsd  0x18(%rsp),%xmm1
mulsd  0x160(%rsp,%rbx,1),%xmm1
divsd  0x10(%rsp),%xmm1
addsd  (%rsp),%xmm1
movsd  %xmm1,0x110(%rsp,%rbx,1)
cmp    $0x30,%rbx
je     14f9 <MatrixLog6+0x399>
movsd  0xa8(%rsp,%rbx,1),%xmm0
add    $0x18,%rbx
jmp    13e0 <MatrixLog6+0x280>
lea    0x100(%rsp),%rdi
lea    0xe0(%rsp),%rsi
lea    0x70(%rsp),%rdx
call   1040 <Matrix3MultVec@plt>
movsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x18(%r15)
movsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x38(%r15)
movsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x58(%r15)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x70(%r15)
movupd %xmm0,0x60(%r15)
add    $0x1f0,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @MatrixLog6([4 x double]* %0, [4 x double]* %1) {
%3 = alloca [4 x double]*
%4 = alloca [4 x double]*
%5 = alloca i32
%6 = alloca i32
%7 = alloca [3 x [3 x double]]
%8 = alloca [3 x [3 x double]]
%9 = alloca [3 x double]
%10 = alloca i32
%11 = alloca [3 x [3 x double]]
%12 = alloca [3 x double]
%13 = alloca [3 x [3 x double]]
%14 = alloca [3 x [3 x double]]
%15 = alloca double
store [4 x double]* %0, [4 x double]** %3
store [4 x double]* %1, [4 x double]** %4
%16 = load [4 x double]*, [4 x double]** %3
%17 = bitcast [4 x double]* %16 to double**
%18 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %7, i64 0, i64 0
%19 = bitcast [3 x double]* %18 to double**
%20 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%21 = call i32 @TransToRp(double** %17, double** %19, double* %20)
%22 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %7, i64 0, i64 0
%23 = bitcast [3 x double]* %22 to double**
%24 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 0
%25 = bitcast [3 x double]* %24 to double**
%26 = call i32 @MatrixLog3(double** %23, double** %25)
store i32 0, i32* %10
store i32 0, i32* %5
br label %27
27: ; preds = %50, %2
%28 = load i32, i32* %5
%29 = icmp slt i32 %28, 3
br i1 %29, label %30, label %53
30: ; preds = %27
store i32 0, i32* %6
br label %31
31: ; preds = %46, %30
%32 = load i32, i32* %6
%33 = icmp slt i32 %32, 3
br i1 %33, label %34, label %49
34: ; preds = %31
%35 = load i32, i32* %5
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 %36
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [3 x double], [3 x double]* %37, i64 0, i64 %39
%41 = load double, double* %40
%42 = call double @llvm.fabs.f64(double %41)
%43 = fcmp olt double %42, 0x3EB0C6F7A0B5ED8D
br i1 %43, label %44, label %45
44: ; preds = %34
br label %46
45: ; preds = %34
store i32 1, i32* %10
br label %49
46: ; preds = %44
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
br label %31
49: ; preds = %45, %31
br label %50
50: ; preds = %49
%51 = load i32, i32* %5
%52 = add nsw i32 %51, 1
store i32 %52, i32* %5
br label %27
53: ; preds = %27
%54 = load i32, i32* %10
%55 = icmp ne i32 %54, 0
br i1 %55, label %113, label %56
56: ; preds = %53
store i32 0, i32* %5
br label %57
57: ; preds = %76, %56
%58 = load i32, i32* %5
%59 = icmp slt i32 %58, 3
br i1 %59, label %60, label %79
60: ; preds = %57
store i32 0, i32* %6
br label %61
61: ; preds = %72, %60
%62 = load i32, i32* %6
%63 = icmp slt i32 %62, 3
br i1 %63, label %64, label %75
64: ; preds = %61
%65 = load [4 x double]*, [4 x double]** %4
%66 = load i32, i32* %5
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [4 x double], [4 x double]* %65, i64 %67
%69 = load i32, i32* %6
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [4 x double], [4 x double]* %68, i64 0, i64 %70
store double 0.000000e+00, double* %71
br label %72
72: ; preds = %64
%73 = load i32, i32* %6
%74 = add nsw i32 %73, 1
store i32 %74, i32* %6
br label %61
75: ; preds = %61
br label %76
76: ; preds = %75
%77 = load i32, i32* %5
%78 = add nsw i32 %77, 1
store i32 %78, i32* %5
br label %57
79: ; preds = %57
%80 = load [4 x double]*, [4 x double]** %3
%81 = getelementptr inbounds [4 x double], [4 x double]* %80, i64 0
%82 = getelementptr inbounds [4 x double], [4 x double]* %81, i64 0, i64 3
%83 = load double, double* %82
%84 = load [4 x double]*, [4 x double]** %4
%85 = getelementptr inbounds [4 x double], [4 x double]* %84, i64 0
%86 = getelementptr inbounds [4 x double], [4 x double]* %85, i64 0, i64 3
store double %83, double* %86
%87 = load [4 x double]*, [4 x double]** %3
%88 = getelementptr inbounds [4 x double], [4 x double]* %87, i64 1
%89 = getelementptr inbounds [4 x double], [4 x double]* %88, i64 0, i64 3
%90 = load double, double* %89
%91 = load [4 x double]*, [4 x double]** %4
%92 = getelementptr inbounds [4 x double], [4 x double]* %91, i64 1
%93 = getelementptr inbounds [4 x double], [4 x double]* %92, i64 0, i64 3
store double %90, double* %93
%94 = load [4 x double]*, [4 x double]** %3
%95 = getelementptr inbounds [4 x double], [4 x double]* %94, i64 2
%96 = getelementptr inbounds [4 x double], [4 x double]* %95, i64 0, i64 3
%97 = load double, double* %96
%98 = load [4 x double]*, [4 x double]** %4
%99 = getelementptr inbounds [4 x double], [4 x double]* %98, i64 2
%100 = getelementptr inbounds [4 x double], [4 x double]* %99, i64 0, i64 3
store double %97, double* %100
%101 = load [4 x double]*, [4 x double]** %4
%102 = getelementptr inbounds [4 x double], [4 x double]* %101, i64 3
%103 = getelementptr inbounds [4 x double], [4 x double]* %102, i64 0, i64 0
store double 0.000000e+00, double* %103
%104 = load [4 x double]*, [4 x double]** %4
%105 = getelementptr inbounds [4 x double], [4 x double]* %104, i64 3
%106 = getelementptr inbounds [4 x double], [4 x double]* %105, i64 0, i64 1
store double 0.000000e+00, double* %106
%107 = load [4 x double]*, [4 x double]** %4
%108 = getelementptr inbounds [4 x double], [4 x double]* %107, i64 3
%109 = getelementptr inbounds [4 x double], [4 x double]* %108, i64 0, i64 2
store double 0.000000e+00, double* %109
%110 = load [4 x double]*, [4 x double]** %4
%111 = getelementptr inbounds [4 x double], [4 x double]* %110, i64 3
%112 = getelementptr inbounds [4 x double], [4 x double]* %111, i64 0, i64 3
store double 0.000000e+00, double* %112
br label %260
113: ; preds = %53
%114 = bitcast [3 x [3 x double]]* %11 to i8*
%115 = bitcast i8* %114 to [3 x [3 x double]]*
%116 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %115, i32 0, i32 0
%117 = getelementptr inbounds [3 x double], [3 x double]* %116, i32 0, i32 0
store double 1.000000e+00, double* %117
%118 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %115, i32 0, i32 1
%119 = getelementptr inbounds [3 x double], [3 x double]* %118, i32 0, i32 1
store double 1.000000e+00, double* %119
%120 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %115, i32 0, i32 2
%121 = getelementptr inbounds [3 x double], [3 x double]* %120, i32 0, i32 2
store double 1.000000e+00, double* %121
%122 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %7, i64 0, i64 0
%123 = getelementptr inbounds [3 x double], [3 x double]* %122, i64 0, i64 0
%124 = load double, double* %123
%125 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %7, i64 0, i64 1
%126 = getelementptr inbounds [3 x double], [3 x double]* %125, i64 0, i64 1
%127 = load double, double* %126
%128 = fadd double %124, %127
%129 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %7, i64 0, i64 2
%130 = getelementptr inbounds [3 x double], [3 x double]* %129, i64 0, i64 2
%131 = load double, double* %130
%132 = fadd double %128, %131
%133 = fsub double %132, 1.000000e+00
%134 = fdiv double %133, 2.000000e+00
%135 = call double @acos(double %134)
store double %135, double* %15
store i32 0, i32* %5
br label %136
136: ; preds = %162, %113
%137 = load i32, i32* %5
%138 = icmp slt i32 %137, 3
br i1 %138, label %139, label %165
139: ; preds = %136
store i32 0, i32* %6
br label %140
140: ; preds = %158, %139
%141 = load i32, i32* %6
%142 = icmp slt i32 %141, 3
br i1 %142, label %143, label %161
143: ; preds = %140
%144 = load i32, i32* %5
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 %145
%147 = load i32, i32* %6
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [3 x double], [3 x double]* %146, i64 0, i64 %148
%150 = load double, double* %149
%151 = load [4 x double]*, [4 x double]** %4
%152 = load i32, i32* %5
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [4 x double], [4 x double]* %151, i64 %153
%155 = load i32, i32* %6
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [4 x double], [4 x double]* %154, i64 0, i64 %156
store double %150, double* %157
br label %158
158: ; preds = %143
%159 = load i32, i32* %6
%160 = add nsw i32 %159, 1
store i32 %160, i32* %6
br label %140
161: ; preds = %140
br label %162
162: ; preds = %161
%163 = load i32, i32* %5
%164 = add nsw i32 %163, 1
store i32 %164, i32* %5
br label %136
165: ; preds = %136
%166 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 0
%167 = bitcast [3 x double]* %166 to double**
%168 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 0
%169 = bitcast [3 x double]* %168 to double**
%170 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %13, i64 0, i64 0
%171 = bitcast [3 x double]* %170 to double**
%172 = call i32 @Matrix3Mult(double** %167, double** %169, double** %171)
store i32 0, i32* %5
br label %173
173: ; preds = %224, %165
%174 = load i32, i32* %5
%175 = icmp slt i32 %174, 3
br i1 %175, label %176, label %227
176: ; preds = %173
store i32 0, i32* %6
br label %177
177: ; preds = %220, %176
%178 = load i32, i32* %6
%179 = icmp slt i32 %178, 3
br i1 %179, label %180, label %223
180: ; preds = %177
%181 = load i32, i32* %5
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %11, i64 0, i64 %182
%184 = load i32, i32* %6
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [3 x double], [3 x double]* %183, i64 0, i64 %185
%187 = load double, double* %186
%188 = load i32, i32* %5
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %8, i64 0, i64 %189
%191 = load i32, i32* %6
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [3 x double], [3 x double]* %190, i64 0, i64 %192
%194 = load double, double* %193
%195 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %194, double %187)
%196 = load double, double* %15
%197 = fdiv double 1.000000e+00, %196
%198 = load double, double* %15
%199 = fmul double 5.000000e-01, %198
%200 = call double @tan(double %199)
%201 = fdiv double 5.000000e-01, %200
%202 = fsub double %197, %201
%203 = load i32, i32* %5
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %13, i64 0, i64 %204
%206 = load i32, i32* %6
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [3 x double], [3 x double]* %205, i64 0, i64 %207
%209 = load double, double* %208
%210 = fmul double %202, %209
%211 = load double, double* %15
%212 = fdiv double %210, %211
%213 = fadd double %195, %212
%214 = load i32, i32* %5
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %14, i64 0, i64 %215
%217 = load i32, i32* %6
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [3 x double], [3 x double]* %216, i64 0, i64 %218
store double %213, double* %219
br label %220
220: ; preds = %180
%221 = load i32, i32* %6
%222 = add nsw i32 %221, 1
store i32 %222, i32* %6
br label %177
223: ; preds = %177
br label %224
224: ; preds = %223
%225 = load i32, i32* %5
%226 = add nsw i32 %225, 1
store i32 %226, i32* %5
br label %173
227: ; preds = %173
%228 = getelementptr inbounds [3 x [3 x double]], [3 x [3 x double]]* %14, i64 0, i64 0
%229 = bitcast [3 x double]* %228 to double**
%230 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%231 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%232 = call i32 @Matrix3MultVec(double** %229, double* %230, double* %231)
%233 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%234 = load double, double* %233
%235 = load [4 x double]*, [4 x double]** %4
%236 = getelementptr inbounds [4 x double], [4 x double]* %235, i64 0
%237 = getelementptr inbounds [4 x double], [4 x double]* %236, i64 0, i64 3
store double %234, double* %237
%238 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%239 = load double, double* %238
%240 = load [4 x double]*, [4 x double]** %4
%241 = getelementptr inbounds [4 x double], [4 x double]* %240, i64 1
%242 = getelementptr inbounds [4 x double], [4 x double]* %241, i64 0, i64 3
store double %239, double* %242
%243 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%244 = load double, double* %243
%245 = load [4 x double]*, [4 x double]** %4
%246 = getelementptr inbounds [4 x double], [4 x double]* %245, i64 2
%247 = getelementptr inbounds [4 x double], [4 x double]* %246, i64 0, i64 3
store double %244, double* %247
%248 = load [4 x double]*, [4 x double]** %4
%249 = getelementptr inbounds [4 x double], [4 x double]* %248, i64 3
%250 = getelementptr inbounds [4 x double], [4 x double]* %249, i64 0, i64 0
store double 0.000000e+00, double* %250
%251 = load [4 x double]*, [4 x double]** %4
%252 = getelementptr inbounds [4 x double], [4 x double]* %251, i64 3
%253 = getelementptr inbounds [4 x double], [4 x double]* %252, i64 0, i64 1
store double 0.000000e+00, double* %253
%254 = load [4 x double]*, [4 x double]** %4
%255 = getelementptr inbounds [4 x double], [4 x double]* %254, i64 3
%256 = getelementptr inbounds [4 x double], [4 x double]* %255, i64 0, i64 2
store double 0.000000e+00, double* %256
%257 = load [4 x double]*, [4 x double]** %4
%258 = getelementptr inbounds [4 x double], [4 x double]* %257, i64 3
%259 = getelementptr inbounds [4 x double], [4 x double]* %258, i64 0, i64 3
store double 0.000000e+00, double* %259
br label %260
260: ; preds = %227, %79
ret void
}

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