#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 cos(double);
double **dmatrix(int, int, int, int);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sor(double **, double **, double **, double **, double **,
                       double **, double **, int, double);
int main(void) {
  int i, j, midl;
  double **a, **b, **c, **d, **e, **f, **u, rjac;
  a = dmatrix(1, 33, 1, 33);
  b = dmatrix(1, 33, 1, 33);
  c = dmatrix(1, 33, 1, 33);
  d = dmatrix(1, 33, 1, 33);
  e = dmatrix(1, 33, 1, 33);
  f = dmatrix(1, 33, 1, 33);
  u = dmatrix(1, 33, 1, 33);
  for (i = 1; i <= 33; i++)
    for (j = 1; j <= 33; j++) {
      a[i][j] = b[i][j] = c[i][j] = d[i][j] = 1.0;
      e[i][j] = (-4.0);
      f[i][j] = u[i][j] = 0.0;
    }
  midl = 33 / 2 + 1;
  f[midl][midl] = 2.0 / ((33 - 1) * (33 - 1));
  rjac = cos(3.1415926 / 33);
  sor(a, b, c, d, e, f, u, 33, rjac);
  printf("SOR solution:\n");
  for (i = 1; i <= 33; i += 4) {
    for (j = 1; j <= 33; j += 4)
      printf("%8.4f", u[i][j]);
    printf("\n");
  }
  printf("\n Test that solution satisfies difference equations:\n");
  for (i = 4 + 1; i < 33; i += 4) {
    for (j = 4 + 1; j < 33; j += 4)
      f[i][j] =
          u[i + 1][j] + u[i - 1][j] + u[i][j + 1] + u[i][j - 1] - 4.0 * u[i][j];
    printf("%7s", " ");
    for (j = 4 + 1; j < 33; j += 4)
      printf("%8.4f", f[i][j]);
    printf("\n");
  }
  free_dmatrix(u, 1, 33, 1, 33);
  free_dmatrix(f, 1, 33, 1, 33);
  free_dmatrix(e, 1, 33, 1, 33);
  free_dmatrix(d, 1, 33, 1, 33);
  free_dmatrix(c, 1, 33, 1, 33);
  free_dmatrix(b, 1, 33, 1, 33);
  free_dmatrix(a, 1, 33, 1, 33);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x18(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edx
mov    $0x21,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1040 <dmatrix@plt>
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0x21,-0x8(%rbp)
jg     1304 <main+0x1b4>
movl   $0x1,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jg     12f1 <main+0x1a1>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  0xdde(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  0xdc1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  0xda4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  0xd87(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  0xd62(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1218 <main+0xc8>
jmp    12f6 <main+0x1a6>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1207 <main+0xb7>
movl   $0x11,-0x10(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsd  0xce5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xcd0(%rip),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    -0x48(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
mov    %rax,(%rsp)
movl   $0x21,0x8(%rsp)
call   1060 <sor@plt>
lea    0xcad(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x21,-0x8(%rbp)
jg     13e9 <main+0x299>
movl   $0x1,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jg     13cd <main+0x27d>
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xc77(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
jmp    1392 <main+0x242>
lea    0xc59(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x8(%rbp)
jmp    1381 <main+0x231>
lea    0xc45(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x5,-0x8(%rbp)
cmpl   $0x21,-0x8(%rbp)
jge    153c <main+0x3ec>
movl   $0x5,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    14c9 <main+0x379>
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb72(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
jmp    140f <main+0x2bf>
lea    0xb9b(%rip),%rdi
lea    0xb98(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x5,-0xc(%rbp)
cmpl   $0x21,-0xc(%rbp)
jge    1520 <main+0x3d0>
mov    -0x40(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xb24(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
jmp    14e5 <main+0x395>
lea    0xb06(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x8(%rbp)
jmp    13fe <main+0x2ae>
mov    -0x48(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
mov    -0x18(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x21,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1070 <free_dmatrix@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,0x8(%rsp)
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x21,%esi
mov    $0x1,%edx
mov    $0x21,%ecx
call   1060 <dmatrix@plt>
mov    %rax,%r14
mov    $0x1,%r8d
movabs $0x3ff0000000000000,%rcx
movabs $0xc010000000000000,%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
mov    (%rax,%r8,8),%r10
mov    0x10(%rsp),%rax
mov    (%rax,%r8,8),%r11
mov    0x18(%rsp),%rax
mov    (%rax,%r8,8),%rbp
mov    (%r15,%r8,8),%rbx
mov    (%r12,%r8,8),%rax
mov    (%r14,%r8,8),%rdx
mov    0x0(%r13,%r8,8),%rsi
xor    %edi,%edi
xchg   %ax,%ax
mov    %rcx,0x8(%r10,%rdi,1)
mov    %rcx,0x8(%r11,%rdi,1)
mov    %rcx,0x8(%rbp,%rdi,1)
mov    %rcx,0x8(%rbx,%rdi,1)
mov    %r9,0x8(%rax,%rdi,1)
movq   $0x0,0x8(%rdx,%rdi,1)
movq   $0x0,0x8(%rsi,%rdi,1)
add    $0x8,%rdi
cmp    $0x108,%rdi
jne    1290 <main+0x130>
add    $0x1,%r8
cmp    $0x22,%r8
jne    1260 <main+0x100>
mov    0x88(%r13),%rax
movabs $0x3f60000000000000,%rcx
mov    %rcx,0x88(%rax)
movsd  0xd0e(%rip),%xmm0
mov    %r15,0x20(%rsp)
mov    %r15,%rdi
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    %r12,%r8
mov    %r13,%r9
push   $0x21
push   %r14
call   1070 <sor@plt>
add    $0x10,%rsp
lea    0xcf9(%rip),%rdi
call   1040 <puts@plt>
mov    $0xfffffffffffffffd,%rbp
lea    0xcda(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%r14,%rbp,8),%rax
movsd  0x8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0x28(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0x48(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0x68(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0x88(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0xa8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0xc8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0xe8(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x20(%r14,%rbp,8),%rax
movsd  0x108(%rax),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x4,%rbp
cmp    $0x1e,%rbp
jb     1340 <main+0x1e0>
lea    0xc08(%rip),%rdi
call   1040 <puts@plt>
mov    $0x6,%ebx
lea    0xbe3(%rip),%rbp
lea    0xbd6(%rip),%r15
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rsi
mov    -0x10(%r14,%rbx,8),%rdx
mov    -0x8(%r14,%rbx,8),%rax
movsd  0x28(%rsi),%xmm0
addsd  0x28(%rdx),%xmm0
addsd  0x30(%rax),%xmm0
addsd  0x20(%rax),%xmm0
mov    -0x8(%r13,%rbx,8),%rcx
movsd  0x28(%rax),%xmm1
movsd  0xb94(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rcx)
movsd  0x48(%rsi),%xmm0
addsd  0x48(%rdx),%xmm0
addsd  0x50(%rax),%xmm0
addsd  0x40(%rax),%xmm0
movsd  0x48(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x48(%rcx)
movsd  0x68(%rsi),%xmm0
addsd  0x68(%rdx),%xmm0
addsd  0x70(%rax),%xmm0
addsd  0x60(%rax),%xmm0
movsd  0x68(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%rcx)
movsd  0x88(%rsi),%xmm0
addsd  0x88(%rdx),%xmm0
addsd  0x90(%rax),%xmm0
addsd  0x80(%rax),%xmm0
movsd  0x88(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x88(%rcx)
movsd  0xa8(%rsi),%xmm0
addsd  0xa8(%rdx),%xmm0
addsd  0xb0(%rax),%xmm0
addsd  0xa0(%rax),%xmm0
movsd  0xa8(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xa8(%rcx)
movsd  0xc8(%rsi),%xmm0
addsd  0xc8(%rdx),%xmm0
addsd  0xd0(%rax),%xmm0
addsd  0xc0(%rax),%xmm0
movsd  0xc8(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xc8(%rcx)
movsd  0xe8(%rsi),%xmm0
addsd  0xe8(%rdx),%xmm0
addsd  0xf0(%rax),%xmm0
addsd  0xe0(%rax),%xmm0
movsd  0xe8(%rax),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0xe8(%rcx)
mov    %rbp,%rdi
lea    0xa63(%rip),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0x28(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0x48(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0x68(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0x88(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0xa8(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0xc8(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%r13,%rbx,8),%rax
movsd  0xe8(%rax),%xmm0
mov    %r15,%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x4(%rbx),%rax
add    $0xffffffffffffffff,%rbx
cmp    $0x1d,%rbx
mov    %rax,%rbx
jb     1440 <main+0x2e0>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    $0x21,%edx
mov    $0x1,%ecx
mov    $0x21,%r8d
call   1080 <free_dmatrix@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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