#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 **paw_alloc_2d_array(int, int);
int /*<<< orphan*/ paw_triang_matrix_inverse(char *, int, double **, double **);
int /*<<< orphan*/ printf(char *, ...);
void paw_test_triang_matrix_inverse() {
  int i, j, k;
  int n;
  double **a;
  double **b;
  double **c;
  n = 3;
  a = paw_alloc_2d_array(n, n);
  b = paw_alloc_2d_array(n, n);
  c = paw_alloc_2d_array(n, n);
  a[0][0] = 1.0;
  a[0][1] = 2.0;
  a[0][2] = 3.0;
  a[1][0] = 0.0;
  a[1][1] = 3.0;
  a[1][2] = 6.3;
  a[2][0] = 0.0;
  a[2][1] = 0.0;
  a[2][2] = 4.0;
  paw_triang_matrix_inverse("u", n, a, b);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      c[i][j] = 0.0;
      for (k = 0; k < n; k++) {
        c[i][j] = c[i][j] + a[i][k] * b[k][j];
      }
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f\t", c[i][j]);
    }
    printf("\n");
  }
}


x86 assembly (clang, -O0):
<paw_test_triang_matrix_inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x3,-0x10(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1040 <paw_alloc_2d_array@plt>
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1040 <paw_alloc_2d_array@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1040 <paw_alloc_2d_array@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movsd  0xe8a(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movsd  0xe6e(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0xe4a(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0xe2d(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movsd  0xdf1(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
lea    0xe02(%rip),%rdi
call   1050 <paw_triang_matrix_inverse@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    130c <paw_test_triang_matrix_inverse+0x1dc>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12f9 <paw_test_triang_matrix_inverse+0x1c9>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12e6 <paw_test_triang_matrix_inverse+0x1b6>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1270 <paw_test_triang_matrix_inverse+0x140>
jmp    12eb <paw_test_triang_matrix_inverse+0x1bb>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1245 <paw_test_triang_matrix_inverse+0x115>
jmp    12fe <paw_test_triang_matrix_inverse+0x1ce>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1232 <paw_test_triang_matrix_inverse+0x102>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    137f <paw_test_triang_matrix_inverse+0x24f>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1363 <paw_test_triang_matrix_inverse+0x233>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xcdc(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1326 <paw_test_triang_matrix_inverse+0x1f6>
lea    0xcc4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1313 <paw_test_triang_matrix_inverse+0x1e3>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_test_triang_matrix_inverse>:
push   %r15
push   %r14
push   %rbx
mov    $0x3,%edi
mov    $0x3,%esi
call   1050 <paw_alloc_2d_array@plt>
mov    %rax,%r15
mov    $0x3,%edi
mov    $0x3,%esi
call   1050 <paw_alloc_2d_array@plt>
mov    %rax,%rbx
mov    $0x3,%edi
mov    $0x3,%esi
call   1050 <paw_alloc_2d_array@plt>
mov    %rax,%r14
mov    (%r15),%rax
movapd 0xe7a(%rip),%xmm0
movupd %xmm0,(%rax)
movabs $0x4008000000000000,%rcx
mov    %rcx,0x10(%rax)
mov    0x8(%r15),%rax
xorpd  %xmm0,%xmm0
movhpd 0xe68(%rip),%xmm0
xorps  %xmm1,%xmm1
movupd %xmm0,(%rax)
movabs $0x4019333333333333,%rcx
33 19 40
mov    %rcx,0x10(%rax)
mov    0x10(%r15),%rax
movups %xmm1,(%rax)
movabs $0x4010000000000000,%rcx
mov    %rcx,0x10(%rax)
lea    0xe3f(%rip),%rdi
mov    $0x3,%esi
mov    %r15,%rdx
mov    %rbx,%rcx
call   1060 <paw_triang_matrix_inverse@plt>
mov    (%rbx),%rdx
mov    0x8(%rbx),%rcx
mov    0x10(%rbx),%rax
mov    (%r14),%rsi
mov    (%r15),%rdi
movq   $0x0,(%rsi)
movsd  (%rdi),%xmm1
mulsd  (%rdx),%xmm1
xorpd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  (%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  (%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi)
movq   $0x0,0x8(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x8(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  0x8(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x8(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsi)
movq   $0x0,0x10(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x10(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  0x10(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x10(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rsi)
mov    0x8(%r14),%rsi
mov    0x8(%r15),%rdi
movq   $0x0,(%rsi)
movsd  (%rdi),%xmm1
mulsd  (%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  (%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  (%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi)
movq   $0x0,0x8(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x8(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  0x8(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x8(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsi)
movq   $0x0,0x10(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x10(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  0x10(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x10(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rsi)
mov    0x10(%r14),%rsi
mov    0x10(%r15),%rdi
movq   $0x0,(%rsi)
movsd  (%rdi),%xmm1
mulsd  (%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  (%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  (%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi)
movq   $0x0,0x8(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x8(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi)
movsd  0x8(%rdi),%xmm2
mulsd  0x8(%rcx),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x8(%rax),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rsi)
movq   $0x0,0x10(%rsi)
movsd  (%rdi),%xmm1
mulsd  0x10(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi)
movsd  0x8(%rdi),%xmm0
mulsd  0x10(%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  0x10(%rax),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi)
mov    (%r14),%rax
movsd  (%rax),%xmm0
lea    0xbd3(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    (%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    (%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%r14),%rax
movsd  (%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x8(%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x8(%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%r14),%rax
movsd  (%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x10(%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    0x10(%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    $0xa,%edi
pop    %rbx
pop    %r14
pop    %r15
jmp    1030 <putchar@plt>

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

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