#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_lu_decompose(int, double **, double **, double **);
int /*<<< orphan*/ printf(char *, ...);
void paw_test_lu_decompose() {
  int i, j, k;
  int n;
  double **a;
  double **b;
  double **c;
  double **c1;
  n = 3;
  a = paw_alloc_2d_array(n, n);
  b = paw_alloc_2d_array(n, n);
  c = paw_alloc_2d_array(n, n);
  c1 = paw_alloc_2d_array(n, n);
  c[0][0] = 1.0;
  c[0][1] = 2.0;
  c[0][2] = 3.0;
  c[1][0] = 3.0;
  c[1][1] = 2.0;
  c[1][2] = 0.0;
  c[2][0] = 1.0;
  c[2][1] = 2.0;
  c[2][2] = 8.0;
  printf("*****lu decomposition test************\n");
  paw_lu_decompose(n, c, a, b);
  printf("*****original matrix************\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f\t", c[i][j]);
    }
    printf("\n");
  }
  printf("*****u matrix************\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f\t", b[i][j]);
    }
    printf("\n");
  }
  printf("*****l matrix************\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f\t", a[i][j]);
    }
    printf("\n");
  }
  printf("*****lu product************\n");
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      c1[i][j] = 0.0;
      for (k = 0; k < n; k++) {
        c1[i][j] = c1[i][j] + a[i][k] * b[k][j];
      }
    }
    printf("\n");
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      printf("%f\t", c1[i][j]);
    }
    printf("\n");
  }
}


x86 assembly (clang, -O0):
<paw_test_lu_decompose>:
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    -0x10(%rbp),%edi
mov    -0x10(%rbp),%esi
call   1040 <paw_alloc_2d_array@plt>
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  0xe86(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  0xe6b(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  0xe67(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0xe52(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movsd  0xe2e(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movsd  0xe11(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movsd  0xdf5(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
movsd  0xdd8(%rip),%xmm0
movsd  %xmm0,0x10(%rax)
lea    0xdec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1050 <paw_lu_decompose@plt>
lea    0xdf2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12d0 <paw_test_lu_decompose+0x1a0>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12b4 <paw_test_lu_decompose+0x184>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xdcb(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1277 <paw_test_lu_decompose+0x147>
lea    0xe04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1264 <paw_test_lu_decompose+0x134>
lea    0xd97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1351 <paw_test_lu_decompose+0x221>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1335 <paw_test_lu_decompose+0x205>
mov    -0x20(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xd4a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12f8 <paw_test_lu_decompose+0x1c8>
lea    0xd83(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    12e5 <paw_test_lu_decompose+0x1b5>
lea    0xd31(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13d2 <paw_test_lu_decompose+0x2a2>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13b6 <paw_test_lu_decompose+0x286>
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xcc9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1379 <paw_test_lu_decompose+0x249>
lea    0xd02(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1366 <paw_test_lu_decompose+0x236>
lea    0xccb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14ca <paw_test_lu_decompose+0x39a>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14ae <paw_test_lu_decompose+0x37e>
mov    -0x30(%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    149b <paw_test_lu_decompose+0x36b>
mov    -0x30(%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    -0x30(%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    1425 <paw_test_lu_decompose+0x2f5>
jmp    14a0 <paw_test_lu_decompose+0x370>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13fa <paw_test_lu_decompose+0x2ca>
lea    0xc0a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    13e7 <paw_test_lu_decompose+0x2b7>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    153d <paw_test_lu_decompose+0x40d>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1521 <paw_test_lu_decompose+0x3f1>
mov    -0x30(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xb5e(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    14e4 <paw_test_lu_decompose+0x3b4>
lea    0xb97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    14d1 <paw_test_lu_decompose+0x3a1>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<paw_test_lu_decompose>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    $0x3,%edi
mov    $0x3,%esi
call   1060 <paw_alloc_2d_array@plt>
mov    %rax,%r15
mov    $0x3,%edi
mov    $0x3,%esi
call   1060 <paw_alloc_2d_array@plt>
mov    %rax,%rbp
mov    $0x3,%edi
mov    $0x3,%esi
call   1060 <paw_alloc_2d_array@plt>
mov    %rax,%r13
mov    $0x3,%edi
mov    $0x3,%esi
call   1060 <paw_alloc_2d_array@plt>
mov    %rax,%r14
mov    0x0(%r13),%rax
movaps 0xe52(%rip),%xmm0
movups %xmm0,(%rax)
movabs $0x4008000000000000,%rcx
mov    %rcx,0x10(%rax)
mov    0x8(%r13),%rax
movapd 0xe45(%rip),%xmm1
movupd %xmm1,(%rax)
movq   $0x0,0x10(%rax)
mov    0x10(%r13),%rax
movups %xmm0,(%rax)
movabs $0x4020000000000000,%rcx
mov    %rcx,0x10(%rax)
lea    0xe31(%rip),%rdi
call   1040 <puts@plt>
mov    $0x3,%edi
mov    %r13,%rsi
mov    %r15,%rdx
mov    %rbp,%rcx
call   1070 <paw_lu_decompose@plt>
lea    0xe39(%rip),%rdi
call   1040 <puts@plt>
mov    0x0(%r13),%rax
movsd  (%rax),%xmm0
lea    0xdfa(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x0(%r13),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x0(%r13),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%r13),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r13),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r13),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%r13),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r13),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r13),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xd81(%rip),%rdi
call   1040 <puts@plt>
mov    0x0(%rbp),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x0(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x0(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xcc9(%rip),%rdi
call   1040 <puts@plt>
mov    (%r15),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    (%r15),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    (%r15),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%r15),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r15),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r15),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%r15),%rax
movsd  (%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r15),%rax
movsd  0x8(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r15),%rax
movsd  0x10(%rax),%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc14(%rip),%rdi
call   1040 <puts@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14,%rbx,8),%rax
mov    (%r15,%rbx,8),%rcx
movq   $0x0,(%rax)
movsd  (%rcx),%xmm0
mov    0x0(%rbp),%rdx
mulsd  (%rdx),%xmm0
xorpd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rax)
movsd  0x8(%rcx),%xmm1
mov    0x8(%rbp),%rsi
mulsd  (%rsi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
movsd  0x10(%rcx),%xmm0
mov    0x10(%rbp),%rdi
mulsd  (%rdi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movq   $0x0,0x8(%rax)
movsd  (%rcx),%xmm0
mulsd  0x8(%rdx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x8(%rcx),%xmm1
mulsd  0x8(%rsi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rax)
movsd  0x10(%rcx),%xmm0
mulsd  0x8(%rdi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
movq   $0x0,0x10(%rax)
movsd  (%rcx),%xmm0
mulsd  0x10(%rdx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%rax)
movsd  0x8(%rcx),%xmm1
mulsd  0x10(%rsi),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rax)
movsd  0x10(%rcx),%xmm0
mulsd  0x10(%rdi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    $0x3,%rbx
jne    14a0 <paw_test_lu_decompose+0x350>
mov    (%r14),%rax
movsd  (%rax),%xmm0
lea    0xa89(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    (%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    (%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x8(%r14),%rax
movsd  (%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%r14),%rax
movsd  (%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r14),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x10(%r14),%rax
movsd  0x10(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <putchar@plt>

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

LLVM IR (-O2):
@.str.2 = [4 x i8] c"%f\09\00"
@str = [39 x i8] c"*****lu decomposition test************\00"
@str.7 = [33 x i8] c"*****original matrix************\00"
@str.8 = [26 x i8] c"*****u matrix************\00"
@str.9 = [26 x i8] c"*****l matrix************\00"
@str.10 = [28 x i8] c"*****lu product************\00"
define void @paw_test_lu_decompose() {
%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 = tail call double** @paw_alloc_2d_array(i32 3, i32 3)
%5 = load double*, double** %3
%6 = bitcast double* %5 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 2.000000e+00>, <2 x double>* %6
%7 = getelementptr inbounds double, double* %5, i64 2
store double 3.000000e+00, double* %7
%8 = getelementptr inbounds double*, double** %3, i64 1
%9 = load double*, double** %8
%10 = bitcast double* %9 to <2 x double>*
store <2 x double> <double 3.000000e+00, double 2.000000e+00>, <2 x double>* %10
%11 = getelementptr inbounds double, double* %9, i64 2
store double 0.000000e+00, double* %11
%12 = getelementptr inbounds double*, double** %3, i64 2
%13 = load double*, double** %12
%14 = bitcast double* %13 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 2.000000e+00>, <2 x double>* %14
%15 = getelementptr inbounds double, double* %13, i64 2
store double 8.000000e+00, double* %15
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str, i64 0, i64 0))
%17 = tail call i32 @paw_lu_decompose(i32 3, double** %3, double** %1, double** %2)
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.7, i64 0, i64 0))
%19 = load double*, double** %3
%20 = load double, double* %19
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %20)
%22 = load double*, double** %3
%23 = getelementptr inbounds double, double* %22, i64 1
%24 = load double, double* %23
%25 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %24)
%26 = load double*, double** %3
%27 = getelementptr inbounds double, double* %26, i64 2
%28 = load double, double* %27
%29 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %28)
%30 = tail call i32 @putchar(i32 10)
%31 = load double*, double** %8
%32 = load double, double* %31
%33 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %32)
%34 = load double*, double** %8
%35 = getelementptr inbounds double, double* %34, i64 1
%36 = load double, double* %35
%37 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %36)
%38 = load double*, double** %8
%39 = getelementptr inbounds double, double* %38, i64 2
%40 = load double, double* %39
%41 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %40)
%42 = tail call i32 @putchar(i32 10)
%43 = load double*, double** %12
%44 = load double, double* %43
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %44)
%46 = load double*, double** %12
%47 = getelementptr inbounds double, double* %46, i64 1
%48 = load double, double* %47
%49 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %48)
%50 = load double*, double** %12
%51 = getelementptr inbounds double, double* %50, i64 2
%52 = load double, double* %51
%53 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %52)
%54 = tail call i32 @putchar(i32 10)
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.8, i64 0, i64 0))
%56 = load double*, double** %2
%57 = load double, double* %56
%58 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %57)
%59 = load double*, double** %2
%60 = getelementptr inbounds double, double* %59, i64 1
%61 = load double, double* %60
%62 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %61)
%63 = load double*, double** %2
%64 = getelementptr inbounds double, double* %63, i64 2
%65 = load double, double* %64
%66 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %65)
%67 = tail call i32 @putchar(i32 10)
%68 = getelementptr inbounds double*, double** %2, i64 1
%69 = load double*, double** %68
%70 = load double, double* %69
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %70)
%72 = load double*, double** %68
%73 = getelementptr inbounds double, double* %72, i64 1
%74 = load double, double* %73
%75 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %74)
%76 = load double*, double** %68
%77 = getelementptr inbounds double, double* %76, i64 2
%78 = load double, double* %77
%79 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %78)
%80 = tail call i32 @putchar(i32 10)
%81 = getelementptr inbounds double*, double** %2, i64 2
%82 = load double*, double** %81
%83 = load double, double* %82
%84 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %83)
%85 = load double*, double** %81
%86 = getelementptr inbounds double, double* %85, i64 1
%87 = load double, double* %86
%88 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %87)
%89 = load double*, double** %81
%90 = getelementptr inbounds double, double* %89, i64 2
%91 = load double, double* %90
%92 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %91)
%93 = tail call i32 @putchar(i32 10)
%94 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.9, i64 0, i64 0))
%95 = load double*, double** %1
%96 = load double, double* %95
%97 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %96)
%98 = load double*, double** %1
%99 = getelementptr inbounds double, double* %98, i64 1
%100 = load double, double* %99
%101 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %100)
%102 = load double*, double** %1
%103 = getelementptr inbounds double, double* %102, i64 2
%104 = load double, double* %103
%105 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %104)
%106 = tail call i32 @putchar(i32 10)
%107 = getelementptr inbounds double*, double** %1, i64 1
%108 = load double*, double** %107
%109 = load double, double* %108
%110 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %109)
%111 = load double*, double** %107
%112 = getelementptr inbounds double, double* %111, i64 1
%113 = load double, double* %112
%114 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %113)
%115 = load double*, double** %107
%116 = getelementptr inbounds double, double* %115, i64 2
%117 = load double, double* %116
%118 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %117)
%119 = tail call i32 @putchar(i32 10)
%120 = getelementptr inbounds double*, double** %1, i64 2
%121 = load double*, double** %120
%122 = load double, double* %121
%123 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %122)
%124 = load double*, double** %120
%125 = getelementptr inbounds double, double* %124, i64 1
%126 = load double, double* %125
%127 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %126)
%128 = load double*, double** %120
%129 = getelementptr inbounds double, double* %128, i64 2
%130 = load double, double* %129
%131 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %130)
%132 = tail call i32 @putchar(i32 10)
%133 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.10, i64 0, i64 0))
br label %134
134: ; preds = %0, %134
%135 = phi i64 [ 0, %0 ], [ %181, %134 ]
%136 = getelementptr inbounds double*, double** %4, i64 %135
%137 = load double*, double** %136
%138 = getelementptr inbounds double*, double** %1, i64 %135
%139 = load double*, double** %138
store double 0.000000e+00, double* %137
%140 = load double, double* %139
%141 = load double*, double** %2
%142 = load double, double* %141
%143 = tail call double @llvm.fmuladd.f64(double %140, double %142, double 0.000000e+00)
store double %143, double* %137
%144 = getelementptr inbounds double, double* %139, i64 1
%145 = load double, double* %144
%146 = load double*, double** %68
%147 = load double, double* %146
%148 = tail call double @llvm.fmuladd.f64(double %145, double %147, double %143)
store double %148, double* %137
%149 = getelementptr inbounds double, double* %139, i64 2
%150 = load double, double* %149
%151 = load double*, double** %81
%152 = load double, double* %151
%153 = tail call double @llvm.fmuladd.f64(double %150, double %152, double %148)
store double %153, double* %137
%154 = getelementptr inbounds double, double* %137, i64 1
store double 0.000000e+00, double* %154
%155 = load double, double* %139
%156 = getelementptr inbounds double, double* %141, i64 1
%157 = load double, double* %156
%158 = tail call double @llvm.fmuladd.f64(double %155, double %157, double 0.000000e+00)
store double %158, double* %154
%159 = load double, double* %144
%160 = getelementptr inbounds double, double* %146, i64 1
%161 = load double, double* %160
%162 = tail call double @llvm.fmuladd.f64(double %159, double %161, double %158)
store double %162, double* %154
%163 = load double, double* %149
%164 = getelementptr inbounds double, double* %151, i64 1
%165 = load double, double* %164
%166 = tail call double @llvm.fmuladd.f64(double %163, double %165, double %162)
store double %166, double* %154
%167 = getelementptr inbounds double, double* %137, i64 2
store double 0.000000e+00, double* %167
%168 = load double, double* %139
%169 = getelementptr inbounds double, double* %141, i64 2
%170 = load double, double* %169
%171 = tail call double @llvm.fmuladd.f64(double %168, double %170, double 0.000000e+00)
store double %171, double* %167
%172 = load double, double* %144
%173 = getelementptr inbounds double, double* %146, i64 2
%174 = load double, double* %173
%175 = tail call double @llvm.fmuladd.f64(double %172, double %174, double %171)
store double %175, double* %167
%176 = load double, double* %149
%177 = getelementptr inbounds double, double* %151, i64 2
%178 = load double, double* %177
%179 = tail call double @llvm.fmuladd.f64(double %176, double %178, double %175)
store double %179, double* %167
%180 = tail call i32 @putchar(i32 10)
%181 = add nuw nsw i64 %135, 1
%182 = icmp eq i64 %181, 3
br i1 %182, label %183, label %134
183: ; preds = %134
%184 = load double*, double** %4
%185 = load double, double* %184
%186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %185)
%187 = load double*, double** %4
%188 = getelementptr inbounds double, double* %187, i64 1
%189 = load double, double* %188
%190 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %189)
%191 = load double*, double** %4
%192 = getelementptr inbounds double, double* %191, i64 2
%193 = load double, double* %192
%194 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %193)
%195 = tail call i32 @putchar(i32 10)
%196 = getelementptr inbounds double*, double** %4, i64 1
%197 = load double*, double** %196
%198 = load double, double* %197
%199 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %198)
%200 = load double*, double** %196
%201 = getelementptr inbounds double, double* %200, i64 1
%202 = load double, double* %201
%203 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %202)
%204 = load double*, double** %196
%205 = getelementptr inbounds double, double* %204, i64 2
%206 = load double, double* %205
%207 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %206)
%208 = tail call i32 @putchar(i32 10)
%209 = getelementptr inbounds double*, double** %4, i64 2
%210 = load double*, double** %209
%211 = load double, double* %210
%212 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %211)
%213 = load double*, double** %209
%214 = getelementptr inbounds double, double* %213, i64 1
%215 = load double, double* %214
%216 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %215)
%217 = load double*, double** %209
%218 = getelementptr inbounds double, double* %217, i64 2
%219 = load double, double* %218
%220 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double %219)
%221 = tail call i32 @putchar(i32 10)
ret void
}