int main() {
  double tol = 1E-5;
  double err = 0.0;
  double diff = 0.0;
  int max_iter = 20000;
  int iter = 0;
  double **u_old;
  double **u_new;
  const double bound_cond = 1.0;
  int i, j;
  printf("Allocating %d bytes for matrices. \n",
         sizeof(double) * (200 * 200) * 2);
  u_old = (double **)malloc(200 * sizeof(double));
  u_new = (double **)malloc(200 * sizeof(double));
  for (i = 0; i < 200; i++) {
    u_old[i] = (double *)malloc(200 * sizeof(double));
    u_new[i] = (double *)malloc(200 * sizeof(double));
  }
  for (i = 0; i < 200; i++) {
    for (j = 0; j < 200; j++) {
      u_old[i][j] = 0.0;
      u_new[i][j] = 0.0;
    }
  }
  for (j = 0; j < 200; j++) {
    u_old[0][j] = 1.0;
    u_old[200 - 1][j] = 1.0;
  }
  for (i = 1; i < 200 - 1; i++) {
    u_old[i][0] = 1.0;
    u_old[i][200 - 1] = 1.0;
  }
  printf("Starting Jacobi iterations...\n");
  do {
#pragma omp parallel for private(i)
    for (i = 1; i < 200 - 1; i++) {
#pragma omp parallel for private(j) shared(u_new, u_old)
      for (j = 1; j < 200 - 1; j++) {
        u_new[i][j] = 0.25 * (u_old[i - 1][j] + u_old[i + 1][j] +
                              u_old[i][j - 1] + u_old[i][j - 1]);
      }
    }
    err = 0.0;
#pragma omp parallel for private(i)
    for (i = 1; i < 200 - 1; i++) {
#pragma omp parallel for private(j, diff) shared(u_new, u_old) reduction(+:err)
      for (j = 1; j < 200 - 1; j++) {
        diff = u_new[i][j] - u_old[i][j];
        err += fabs(diff * diff);
      }
    }
    err = sqrtf(err);
#pragma omp parallel for private(i)
    for (i = 1; i < 200 - 1; i++) {
#pragma omp parallel for private(j) shared(u_new, u_old)
      for (j = 1; j < 200 - 1; j++) {
        u_old[i][j] = u_new[i][j];
      }
    }
    iter++;
    if (iter % 20 == 0)
      printf("Iteration %5d, Error = %12.6e\n", iter, err);
  } while ((err > tol) && (iter < max_iter));
  if (iter >= max_iter)
    printf("WARNING: Maximum iterations reached\n");
  printf("Solution reached after %6d iterations with error: %12.6e \n", err,
         iter);
  for (i = 200 - 1; i >= 0; i--) {
    free(u_new[i]);
    free(u_old[i]);
  }
  free(u_new);
  free(u_old);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movsd  0xeb1(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x4e20,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movsd  0xe7e(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
lea    0xea2(%rip),%rdi
mov    $0x9c400,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x640,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x640,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0xc8,-0x44(%rbp)
jge    120a <main+0xca>
mov    $0x640,%edi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    $0x640,%edi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11bd <main+0x7d>
movl   $0x0,-0x44(%rbp)
cmpl   $0xc8,-0x44(%rbp)
jge    1283 <main+0x143>
movl   $0x0,-0x48(%rbp)
cmpl   $0xc8,-0x48(%rbp)
jge    1270 <main+0x130>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1225 <main+0xe5>
jmp    1275 <main+0x135>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1211 <main+0xd1>
movl   $0x0,-0x48(%rbp)
cmpl   $0xc8,-0x48(%rbp)
jge    12d9 <main+0x199>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movsd  0xd56(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x638(%rax),%rax
movslq -0x48(%rbp),%rcx
movsd  0xd3a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    128a <main+0x14a>
movl   $0x1,-0x44(%rbp)
cmpl   $0xc7,-0x44(%rbp)
jge    132f <main+0x1ef>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0xcff(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0xce7(%rip),%xmm0
movsd  %xmm0,0x638(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12e0 <main+0x1a0>
lea    0xd1e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x44(%rbp)
cmpl   $0xc7,-0x44(%rbp)
jge    140f <main+0x2cf>
movl   $0x1,-0x48(%rbp)
cmpl   $0xc7,-0x48(%rbp)
jge    13fc <main+0x2bc>
mov    -0x30(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xc3b(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1358 <main+0x218>
jmp    1401 <main+0x2c1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1344 <main+0x204>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x1,-0x44(%rbp)
cmpl   $0xc7,-0x44(%rbp)
jge    14ae <main+0x36e>
movl   $0x1,-0x48(%rbp)
cmpl   $0xc7,-0x48(%rbp)
jge    149b <main+0x35b>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
movaps 0xba1(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1432 <main+0x2f2>
jmp    14a0 <main+0x360>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    141e <main+0x2de>
movsd  -0x18(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1060 <sqrtf@plt>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x1,-0x44(%rbp)
cmpl   $0xc7,-0x44(%rbp)
jge    1538 <main+0x3f8>
movl   $0x1,-0x48(%rbp)
cmpl   $0xc7,-0x48(%rbp)
jge    1525 <main+0x3e5>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14e0 <main+0x3a0>
jmp    152a <main+0x3ea>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14cc <main+0x38c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    156b <main+0x42b>
mov    -0x28(%rbp),%esi
movsd  -0x18(%rbp),%xmm0
lea    0xb0f(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
jmp    1570 <main+0x430>
movsd  -0x18(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x10(%rbp),%xmm0
mov    %al,-0x49(%rbp)
jbe    1591 <main+0x451>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    133d <main+0x1fd>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     15b6 <main+0x476>
lea    0xae3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x18(%rbp),%xmm0
mov    -0x28(%rbp),%esi
lea    0xaf2(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0xc7,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     160d <main+0x4cd>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    15d3 <main+0x493>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    0xedf(%rip),%rdi
xor    %ebx,%ebx
mov    $0x9c400,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x640,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x640,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
nopl   (%rax)
mov    $0x640,%edi
call   1060 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
mov    $0x640,%edi
call   1060 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    $0xc8,%rbx
jne    1190 <main+0x40>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    11e0 <main+0x90>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    $0xc8,%rax
je     1322 <main+0x1d2>
mov    (%r14,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
lea    0x640(%rdx),%rsi
cmp    %rsi,%rcx
jae    1280 <main+0x130>
lea    0x640(%rcx),%rsi
cmp    %rsi,%rdx
jae    1280 <main+0x130>
mov    $0x4,%esi
nopl   (%rax)
movq   $0x0,-0x20(%rcx,%rsi,8)
movq   $0x0,-0x20(%rdx,%rsi,8)
movq   $0x0,-0x18(%rcx,%rsi,8)
movq   $0x0,-0x18(%rdx,%rsi,8)
movq   $0x0,-0x10(%rcx,%rsi,8)
movq   $0x0,-0x10(%rdx,%rsi,8)
movq   $0x0,-0x8(%rcx,%rsi,8)
movq   $0x0,-0x8(%rdx,%rsi,8)
movq   $0x0,(%rcx,%rsi,8)
movq   $0x0,(%rdx,%rsi,8)
add    $0x5,%rsi
cmp    $0xcc,%rsi
jne    1210 <main+0xc0>
jmp    11d0 <main+0x80>
nopw   0x0(%rax,%rax,1)
mov    $0x12,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movupd %xmm0,-0x90(%rcx,%rsi,8)
ff ff
movupd %xmm0,-0x80(%rcx,%rsi,8)
movupd %xmm0,-0x90(%rdx,%rsi,8)
ff ff
movupd %xmm0,-0x80(%rdx,%rsi,8)
movupd %xmm0,-0x70(%rcx,%rsi,8)
movupd %xmm0,-0x60(%rcx,%rsi,8)
movupd %xmm0,-0x70(%rdx,%rsi,8)
movupd %xmm0,-0x60(%rdx,%rsi,8)
movupd %xmm0,-0x50(%rcx,%rsi,8)
movupd %xmm0,-0x40(%rcx,%rsi,8)
movupd %xmm0,-0x50(%rdx,%rsi,8)
movupd %xmm0,-0x40(%rdx,%rsi,8)
movupd %xmm0,-0x30(%rcx,%rsi,8)
movupd %xmm0,-0x20(%rcx,%rsi,8)
movupd %xmm0,-0x30(%rdx,%rsi,8)
movupd %xmm0,-0x20(%rdx,%rsi,8)
movupd %xmm0,-0x10(%rcx,%rsi,8)
movupd %xmm0,(%rcx,%rsi,8)
movupd %xmm0,-0x10(%rdx,%rsi,8)
movupd %xmm0,(%rdx,%rsi,8)
add    $0x14,%rsi
cmp    $0xda,%rsi
jne    1290 <main+0x140>
jmp    11d0 <main+0x80>
mov    (%r14),%r13
mov    0x638(%r14),%rcx
lea    0x640(%rcx),%rdx
movabs $0x3ff0000000000000,%rax
cmp    %rdx,%r13
jae    13a3 <main+0x253>
lea    0x640(%r13),%rdx
cmp    %rdx,%rcx
jae    13a3 <main+0x253>
mov    $0x4,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,-0x20(%r13,%rdx,8)
mov    %rax,-0x20(%rcx,%rdx,8)
mov    %rax,-0x18(%r13,%rdx,8)
mov    %rax,-0x18(%rcx,%rdx,8)
mov    %rax,-0x10(%r13,%rdx,8)
mov    %rax,-0x10(%rcx,%rdx,8)
mov    %rax,-0x8(%r13,%rdx,8)
mov    %rax,-0x8(%rcx,%rdx,8)
mov    %rax,0x0(%r13,%rdx,8)
mov    %rax,(%rcx,%rdx,8)
add    $0x5,%rdx
cmp    $0xcc,%rdx
jne    1360 <main+0x210>
jmp    1448 <main+0x2f8>
mov    $0x12,%edx
movapd 0xc50(%rip),%xmm0
movupd %xmm0,-0x90(%r13,%rdx,8)
ff ff ff
movupd %xmm0,-0x80(%r13,%rdx,8)
movupd %xmm0,-0x90(%rcx,%rdx,8)
ff ff
movupd %xmm0,-0x80(%rcx,%rdx,8)
movupd %xmm0,-0x70(%r13,%rdx,8)
movupd %xmm0,-0x60(%r13,%rdx,8)
movupd %xmm0,-0x70(%rcx,%rdx,8)
movupd %xmm0,-0x60(%rcx,%rdx,8)
movupd %xmm0,-0x50(%r13,%rdx,8)
movupd %xmm0,-0x40(%r13,%rdx,8)
movupd %xmm0,-0x50(%rcx,%rdx,8)
movupd %xmm0,-0x40(%rcx,%rdx,8)
movupd %xmm0,-0x30(%r13,%rdx,8)
movupd %xmm0,-0x20(%r13,%rdx,8)
movupd %xmm0,-0x30(%rcx,%rdx,8)
movupd %xmm0,-0x20(%rcx,%rdx,8)
movupd %xmm0,-0x10(%r13,%rdx,8)
movupd %xmm0,0x0(%r13,%rdx,8)
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm0,(%rcx,%rdx,8)
add    $0x14,%rdx
cmp    $0xda,%rdx
jne    13b0 <main+0x260>
mov    $0x6,%ecx
nopl   (%rax)
mov    -0x28(%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
mov    -0x20(%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
mov    -0x18(%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
mov    -0x10(%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
mov    -0x8(%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
mov    (%r14,%rcx,8),%rdx
mov    %rax,(%rdx)
mov    %rax,0x638(%rdx)
add    $0x6,%rcx
cmp    $0xcc,%rcx
jne    1450 <main+0x300>
lea    0xc05(%rip),%rdi
call   1040 <puts@plt>
mov    0x8(%r14),%rax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
movsd  0xb5a(%rip),%xmm4
movapd 0xb42(%rip),%xmm5
movapd 0xb2a(%rip),%xmm6
mov    %r14,0x30(%rsp)
mov    %r15,0x28(%rsp)
mov    %r13,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12,0x18(%rsp)
mov    $0x1,%r8d
mov    0x10(%rsp),%r9
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9,%rcx
mov    0x8(%r14,%r8,8),%r9
mov    (%r15,%r8,8),%rax
lea    0x8(%rax),%rsi
lea    0x638(%rax),%rbx
lea    0x8(%rdx),%rdi
lea    0x638(%rdx),%r10
lea    0x8(%r9),%rbp
lea    0x638(%r9),%r11
lea    0x630(%rcx),%r12
cmp    %r10,%rsi
setb   %r14b
cmp    %rbx,%rdi
setb   %r15b
cmp    %r11,%rsi
setb   %r11b
cmp    %rbx,%rbp
setb   %r13b
cmp    %r12,%rsi
setb   %r10b
cmp    %rbx,%rcx
setb   %r12b
mov    $0x1,%ebx
test   %r15b,%r14b
jne    1603 <main+0x4b3>
mov    $0x1,%ebx
and    %r13b,%r11b
jne    1603 <main+0x4b3>
mov    $0x1,%ebx
and    %r12b,%r10b
jne    1603 <main+0x4b3>
xor    %ebx,%ebx
xchg   %ax,%ax
movupd 0x8(%rdx,%rbx,8),%xmm0
movupd 0x18(%rdx,%rbx,8),%xmm1
movupd 0x8(%r9,%rbx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%r9,%rbx,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rcx,%rbx,8),%xmm1
movupd 0x10(%rcx,%rbx,8),%xmm3
addpd  %xmm1,%xmm2
addpd  %xmm3,%xmm0
addpd  %xmm1,%xmm2
addpd  %xmm3,%xmm0
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm0
movupd %xmm2,0x8(%rax,%rbx,8)
movupd %xmm0,0x18(%rax,%rbx,8)
add    $0x4,%rbx
cmp    $0xc4,%rbx
jne    15a0 <main+0x450>
mov    $0xc5,%ebx
add    $0x1,%r8
shl    $0x3,%rbx
mov    $0x638,%eax
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdi,%rbx,1),%xmm0
addsd  -0x8(%rbp,%rbx,1),%xmm0
movsd  -0x8(%rdx,%rbx,1),%xmm1
addsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,-0x8(%rsi,%rbx,1)
movsd  (%rdi,%rbx,1),%xmm0
addsd  0x0(%rbp,%rbx,1),%xmm0
movsd  (%rdx,%rbx,1),%xmm1
addsd  %xmm1,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,(%rsi,%rbx,1)
add    $0xfffffffffffffff0,%rax
add    $0x10,%rdx
add    $0x10,%rsi
add    $0x10,%rbp
add    $0x10,%rdi
cmp    %rax,%rbx
jne    1620 <main+0x4d0>
mov    %rcx,%rdx
cmp    $0xc7,%r8
mov    0x30(%rsp),%r14
mov    0x28(%rsp),%r15
jne    1520 <main+0x3d0>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%r13
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rdx
mov    $0x3,%esi
nopl   0x0(%rax)
movsd  -0x10(%rdx,%rsi,8),%xmm1
movsd  -0x8(%rdx,%rsi,8),%xmm2
subsd  -0x10(%rcx,%rsi,8),%xmm1
mulsd  %xmm1,%xmm1
andpd  %xmm5,%xmm1
subsd  -0x8(%rcx,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
andpd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
movsd  (%rdx,%rsi,8),%xmm0
subsd  (%rcx,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
andpd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
add    $0x3,%rsi
cmp    $0xc9,%rsi
jne    16c0 <main+0x570>
add    $0x1,%rax
cmp    $0xc7,%rax
je     1730 <main+0x5e0>
mov    (%r14,%rax,8),%rcx
jmp    16b0 <main+0x560>
cs nopw 0x0(%rax,%rax,1)
nop
cvtsd2ss %xmm0,%xmm0
ucomiss 0x905(%rip),%xmm0
jb     1750 <main+0x600>
sqrtss %xmm0,%xmm0
jmp    176d <main+0x61d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1070 <sqrtf@plt>
movapd 0x8b3(%rip),%xmm6
movapd 0x8bb(%rip),%xmm5
movsd  0x8c3(%rip),%xmm4
mov    $0x1,%r9d
mov    0x10(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
mov    (%r15,%r9,8),%rdx
lea    0x8(%rcx),%rsi
lea    0x638(%rcx),%r8
lea    0x8(%rdx),%rbx
lea    0x638(%rdx),%rbp
cmp    %rbp,%rsi
jae    17a9 <main+0x659>
mov    $0x1,%edi
cmp    %r8,%rbx
jb     1825 <main+0x6d5>
mov    $0xf,%edi
xchg   %ax,%ax
movupd -0x70(%rdx,%rdi,8),%xmm1
movupd -0x60(%rdx,%rdi,8),%xmm2
movupd %xmm1,-0x70(%rcx,%rdi,8)
movupd %xmm2,-0x60(%rcx,%rdi,8)
cmp    $0xcf,%rdi
je     1820 <main+0x6d0>
movups -0x50(%rdx,%rdi,8),%xmm1
movups -0x40(%rdx,%rdi,8),%xmm2
movups %xmm1,-0x50(%rcx,%rdi,8)
movups %xmm2,-0x40(%rcx,%rdi,8)
movups -0x30(%rdx,%rdi,8),%xmm1
movups -0x20(%rdx,%rdi,8),%xmm2
movups %xmm1,-0x30(%rcx,%rdi,8)
movups %xmm2,-0x20(%rcx,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm1
movupd (%rdx,%rdi,8),%xmm2
movupd %xmm1,-0x10(%rcx,%rdi,8)
movupd %xmm2,(%rcx,%rdi,8)
add    $0x10,%rdi
jmp    17b0 <main+0x660>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0xc5,%edi
cmp    %r8,%rbx
setb   %al
cmp    %rbp,%rsi
setb   %r8b
and    %al,%r8b
lea    (%rcx,%rdi,8),%rbp
lea    (%rdx,%rdi,8),%rax
add    $0x4,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdi,%rsi
movsd  (%rax,%rbx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0x1,%rdi
cmp    $0x2,%rbx
jne    1850 <main+0x700>
test   %r8b,%r8b
je     18bb <main+0x76b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rsi,8),%xmm1
movsd  %xmm1,-0x18(%rcx,%rsi,8)
movsd  -0x10(%rdx,%rsi,8),%xmm1
movsd  %xmm1,-0x10(%rcx,%rsi,8)
movsd  -0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    $0xca,%rsi
jne    1880 <main+0x730>
add    $0x1,%r9
cmp    $0xc7,%r9
je     18e0 <main+0x790>
mov    (%r14,%r9,8),%rcx
jmp    1780 <main+0x630>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtss2sd %xmm0,%xmm0
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%r12d
imul   $0xcccccccd,%r12d,%eax
ror    $0x2,%eax
cmp    $0xccccccc,%eax
ja     193e <main+0x7ee>
lea    0x763(%rip),%rdi
mov    %r12d,%esi
movsd  %xmm0,0x8(%rsp)
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
movsd  0x8(%rsp),%xmm0
mov    0x18(%rsp),%rcx
movapd 0x6e2(%rip),%xmm6
movapd 0x6ea(%rip),%xmm5
movsd  0x6f2(%rip),%xmm4
ucomisd 0x6f2(%rip),%xmm0
jbe    1954 <main+0x804>
cmp    $0x4e1f,%ecx
jb     1500 <main+0x3b0>
cmp    $0x4e1f,%ecx
jb     1974 <main+0x824>
lea    0x77d(%rip),%rdi
movsd  %xmm0,0x8(%rsp)
call   1040 <puts@plt>
movsd  0x8(%rsp),%xmm0
lea    0x70c(%rip),%rdi
mov    %r12d,%esi
mov    $0x1,%al
call   1050 <printf@plt>
mov    $0xc7,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0xffffffffffffffff,%rbx
jb     1990 <main+0x840>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [36 x i8] c"Allocating %d bytes for matrices. \0A\00"
@.str.1 = [31 x i8] c"Starting Jacobi iterations...\0A\00"
@.str.2 = [31 x i8] c"Iteration %5d, Error = %12.6e\0A\00"
@.str.3 = [37 x i8] c"WARNING: Maximum iterations reached\0A\00"
@.str.4 = [59 x i8] c"Solution reached after %6d iterations with error: %12.6e \0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca i32
%6 = alloca i32
%7 = alloca double**
%8 = alloca double**
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
store i32 0, i32* %1
store double 1.000000e-05, double* %2
store double 0.000000e+00, double* %3
store double 0.000000e+00, double* %4
store i32 20000, i32* %5
store i32 0, i32* %6
store double 1.000000e+00, double* %9
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), i64 640000)
%13 = call i8* @malloc(i64 1600)
%14 = bitcast i8* %13 to double**
store double** %14, double*** %7
%15 = call i8* @malloc(i64 1600)
%16 = bitcast i8* %15 to double**
store double** %16, double*** %8
store i32 0, i32* %10
br label %17
17: ; preds = %33, %0
%18 = load i32, i32* %10
%19 = icmp slt i32 %18, 200
br i1 %19, label %20, label %36
20: ; preds = %17
%21 = call i8* @malloc(i64 1600)
%22 = bitcast i8* %21 to double*
%23 = load double**, double*** %7
%24 = load i32, i32* %10
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double*, double** %23, i64 %25
store double* %22, double** %26
%27 = call i8* @malloc(i64 1600)
%28 = bitcast i8* %27 to double*
%29 = load double**, double*** %8
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double*, double** %29, i64 %31
store double* %28, double** %32
br label %33
33: ; preds = %20
%34 = load i32, i32* %10
%35 = add nsw i32 %34, 1
store i32 %35, i32* %10
br label %17
36: ; preds = %17
store i32 0, i32* %10
br label %37
37: ; preds = %65, %36
%38 = load i32, i32* %10
%39 = icmp slt i32 %38, 200
br i1 %39, label %40, label %68
40: ; preds = %37
store i32 0, i32* %11
br label %41
41: ; preds = %61, %40
%42 = load i32, i32* %11
%43 = icmp slt i32 %42, 200
br i1 %43, label %44, label %64
44: ; preds = %41
%45 = load double**, double*** %7
%46 = load i32, i32* %10
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double*, double** %45, i64 %47
%49 = load double*, double** %48
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double 0.000000e+00, double* %52
%53 = load double**, double*** %8
%54 = load i32, i32* %10
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double*, double** %53, i64 %55
%57 = load double*, double** %56
%58 = load i32, i32* %11
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
store double 0.000000e+00, double* %60
br label %61
61: ; preds = %44
%62 = load i32, i32* %11
%63 = add nsw i32 %62, 1
store i32 %63, i32* %11
br label %41
64: ; preds = %41
br label %65
65: ; preds = %64
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
store i32 %67, i32* %10
br label %37
68: ; preds = %37
store i32 0, i32* %11
br label %69
69: ; preds = %85, %68
%70 = load i32, i32* %11
%71 = icmp slt i32 %70, 200
br i1 %71, label %72, label %88
72: ; preds = %69
%73 = load double**, double*** %7
%74 = getelementptr inbounds double*, double** %73, i64 0
%75 = load double*, double** %74
%76 = load i32, i32* %11
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
store double 1.000000e+00, double* %78
%79 = load double**, double*** %7
%80 = getelementptr inbounds double*, double** %79, i64 199
%81 = load double*, double** %80
%82 = load i32, i32* %11
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
store double 1.000000e+00, double* %84
br label %85
85: ; preds = %72
%86 = load i32, i32* %11
%87 = add nsw i32 %86, 1
store i32 %87, i32* %11
br label %69
88: ; preds = %69
store i32 1, i32* %10
br label %89
89: ; preds = %105, %88
%90 = load i32, i32* %10
%91 = icmp slt i32 %90, 199
br i1 %91, label %92, label %108
92: ; preds = %89
%93 = load double**, double*** %7
%94 = load i32, i32* %10
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double*, double** %93, i64 %95
%97 = load double*, double** %96
%98 = getelementptr inbounds double, double* %97, i64 0
store double 1.000000e+00, double* %98
%99 = load double**, double*** %7
%100 = load i32, i32* %10
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double*, double** %99, i64 %101
%103 = load double*, double** %102
%104 = getelementptr inbounds double, double* %103, i64 199
store double 1.000000e+00, double* %104
br label %105
105: ; preds = %92
%106 = load i32, i32* %10
%107 = add nsw i32 %106, 1
store i32 %107, i32* %10
br label %89
108: ; preds = %89
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0))
br label %110
110: ; preds = %275, %108
store i32 1, i32* %10
br label %111
111: ; preds = %175, %110
%112 = load i32, i32* %10
%113 = icmp slt i32 %112, 199
br i1 %113, label %114, label %178
114: ; preds = %111
store i32 1, i32* %11
br label %115
115: ; preds = %171, %114
%116 = load i32, i32* %11
%117 = icmp slt i32 %116, 199
br i1 %117, label %118, label %174
118: ; preds = %115
%119 = load double**, double*** %7
%120 = load i32, i32* %10
%121 = sub nsw i32 %120, 1
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double*, double** %119, i64 %122
%124 = load double*, double** %123
%125 = load i32, i32* %11
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %124, i64 %126
%128 = load double, double* %127
%129 = load double**, double*** %7
%130 = load i32, i32* %10
%131 = add nsw i32 %130, 1
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double*, double** %129, i64 %132
%134 = load double*, double** %133
%135 = load i32, i32* %11
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
%138 = load double, double* %137
%139 = fadd double %128, %138
%140 = load double**, double*** %7
%141 = load i32, i32* %10
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double*, double** %140, i64 %142
%144 = load double*, double** %143
%145 = load i32, i32* %11
%146 = sub nsw i32 %145, 1
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %144, i64 %147
%149 = load double, double* %148
%150 = fadd double %139, %149
%151 = load double**, double*** %7
%152 = load i32, i32* %10
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double*, double** %151, i64 %153
%155 = load double*, double** %154
%156 = load i32, i32* %11
%157 = sub nsw i32 %156, 1
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %155, i64 %158
%160 = load double, double* %159
%161 = fadd double %150, %160
%162 = fmul double 2.500000e-01, %161
%163 = load double**, double*** %8
%164 = load i32, i32* %10
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double*, double** %163, i64 %165
%167 = load double*, double** %166
%168 = load i32, i32* %11
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
store double %162, double* %170
br label %171
171: ; preds = %118
%172 = load i32, i32* %11
%173 = add nsw i32 %172, 1
store i32 %173, i32* %11
br label %115
174: ; preds = %115
br label %175
175: ; preds = %174
%176 = load i32, i32* %10
%177 = add nsw i32 %176, 1
store i32 %177, i32* %10
br label %111
178: ; preds = %111
store double 0.000000e+00, double* %3
store i32 1, i32* %10
br label %179
179: ; preds = %216, %178
%180 = load i32, i32* %10
%181 = icmp slt i32 %180, 199
br i1 %181, label %182, label %219
182: ; preds = %179
store i32 1, i32* %11
br label %183
183: ; preds = %212, %182
%184 = load i32, i32* %11
%185 = icmp slt i32 %184, 199
br i1 %185, label %186, label %215
186: ; preds = %183
%187 = load double**, double*** %8
%188 = load i32, i32* %10
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double*, double** %187, i64 %189
%191 = load double*, double** %190
%192 = load i32, i32* %11
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double**, double*** %7
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double*, double** %196, i64 %198
%200 = load double*, double** %199
%201 = load i32, i32* %11
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
%204 = load double, double* %203
%205 = fsub double %195, %204
store double %205, double* %4
%206 = load double, double* %4
%207 = load double, double* %4
%208 = fmul double %206, %207
%209 = call double @llvm.fabs.f64(double %208)
%210 = load double, double* %3
%211 = fadd double %210, %209
store double %211, double* %3
br label %212
212: ; preds = %186
%213 = load i32, i32* %11
%214 = add nsw i32 %213, 1
store i32 %214, i32* %11
br label %183
215: ; preds = %183
br label %216
216: ; preds = %215
%217 = load i32, i32* %10
%218 = add nsw i32 %217, 1
store i32 %218, i32* %10
br label %179
219: ; preds = %179
%220 = load double, double* %3
%221 = fptrunc double %220 to float
%222 = call float @sqrtf(float %221)
%223 = fpext float %222 to double
store double %223, double* %3
store i32 1, i32* %10
br label %224
224: ; preds = %253, %219
%225 = load i32, i32* %10
%226 = icmp slt i32 %225, 199
br i1 %226, label %227, label %256
227: ; preds = %224
store i32 1, i32* %11
br label %228
228: ; preds = %249, %227
%229 = load i32, i32* %11
%230 = icmp slt i32 %229, 199
br i1 %230, label %231, label %252
231: ; preds = %228
%232 = load double**, double*** %8
%233 = load i32, i32* %10
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double*, double** %232, i64 %234
%236 = load double*, double** %235
%237 = load i32, i32* %11
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
%240 = load double, double* %239
%241 = load double**, double*** %7
%242 = load i32, i32* %10
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double*, double** %241, i64 %243
%245 = load double*, double** %244
%246 = load i32, i32* %11
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
store double %240, double* %248
br label %249
249: ; preds = %231
%250 = load i32, i32* %11
%251 = add nsw i32 %250, 1
store i32 %251, i32* %11
br label %228
252: ; preds = %228
br label %253
253: ; preds = %252
%254 = load i32, i32* %10
%255 = add nsw i32 %254, 1
store i32 %255, i32* %10
br label %224
256: ; preds = %224
%257 = load i32, i32* %6
%258 = add nsw i32 %257, 1
store i32 %258, i32* %6
%259 = load i32, i32* %6
%260 = srem i32 %259, 20
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %266
262: ; preds = %256
%263 = load i32, i32* %6
%264 = load double, double* %3
%265 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i32 %263, double %264)
br label %266
266: ; preds = %262, %256
br label %267
267: ; preds = %266
%268 = load double, double* %3
%269 = load double, double* %2
%270 = fcmp ogt double %268, %269
br i1 %270, label %271, label %275
271: ; preds = %267
%272 = load i32, i32* %6
%273 = load i32, i32* %5
%274 = icmp slt i32 %272, %273
br label %275
275: ; preds = %271, %267
%276 = phi i1 [ false, %267 ], [ %274, %271 ]
br i1 %276, label %110, label %277
277: ; preds = %275
%278 = load i32, i32* %6
%279 = load i32, i32* %5
%280 = icmp sge i32 %278, %279
br i1 %280, label %281, label %283
281: ; preds = %277
%282 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.3, i64 0, i64 0))
br label %283
283: ; preds = %281, %277
%284 = load double, double* %3
%285 = load i32, i32* %6
%286 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.4, i64 0, i64 0), double %284, i32 %285)
store i32 199, i32* %10
br label %287
287: ; preds = %303, %283
%288 = load i32, i32* %10
%289 = icmp sge i32 %288, 0
br i1 %289, label %290, label %306
290: ; preds = %287
%291 = load double**, double*** %8
%292 = load i32, i32* %10
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double*, double** %291, i64 %293
%295 = load double*, double** %294
%296 = bitcast double* %295 to i8*
%297 = load double**, double*** %7
%298 = load i32, i32* %10
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double*, double** %297, i64 %299
%301 = load double*, double** %300
%302 = bitcast double* %301 to i8*
br label %303
303: ; preds = %290
%304 = load i32, i32* %10
%305 = add nsw i32 %304, -1
store i32 %305, i32* %10
br label %287
306: ; preds = %287
%307 = load double**, double*** %8
%308 = bitcast double** %307 to i8*
%309 = load double**, double*** %7
%310 = bitcast double** %309 to i8*
ret i32 0
}

LLVM IR (-O2):
@.str = [36 x i8] c"Allocating %d bytes for matrices. \0A\00"
@.str.2 = [31 x i8] c"Iteration %5d, Error = %12.6e\0A\00"
@.str.4 = [59 x i8] c"Solution reached after %6d iterations with error: %12.6e \0A\00"
@str = [30 x i8] c"Starting Jacobi iterations...\00"
@str.5 = [36 x i8] c"WARNING: Maximum iterations reached\00"
define i32 @main() {
%1 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), i64 640000)
%2 = tail call dereferenceable_or_null(1600) i8* @malloc(i64 1600)
%3 = bitcast i8* %2 to double**
%4 = tail call dereferenceable_or_null(1600) i8* @malloc(i64 1600)
%5 = bitcast i8* %4 to double**
br label %6
6: ; preds = %0, %6
%7 = phi i64 [ 0, %0 ], [ %14, %6 ]
%8 = tail call dereferenceable_or_null(1600) i8* @malloc(i64 1600)
%9 = getelementptr inbounds double*, double** %3, i64 %7
%10 = bitcast double** %9 to i8**
store i8* %8, i8** %10
%11 = tail call dereferenceable_or_null(1600) i8* @malloc(i64 1600)
%12 = getelementptr inbounds double*, double** %5, i64 %7
%13 = bitcast double** %12 to i8**
store i8* %11, i8** %13
%14 = add nuw nsw i64 %7, 1
%15 = icmp eq i64 %14, 200
br i1 %15, label %16, label %6
16: ; preds = %6, %150
%17 = phi i64 [ %151, %150 ], [ 0, %6 ]
%18 = getelementptr inbounds double*, double** %3, i64 %17
%19 = load double*, double** %18
%20 = getelementptr inbounds double*, double** %5, i64 %17
%21 = load double*, double** %20
%22 = getelementptr double, double* %19, i64 200
%23 = getelementptr double, double* %21, i64 200
%24 = icmp ult double* %19, %23
%25 = icmp ult double* %21, %22
%26 = and i1 %24, %25
br i1 %26, label %132, label %27
27: ; preds = %16, %27
%28 = phi i64 [ %73, %27 ], [ 0, %16 ]
%29 = getelementptr inbounds double, double* %19, i64 %28
%30 = bitcast double* %29 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %30
%31 = getelementptr inbounds double, double* %29, i64 2
%32 = bitcast double* %31 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %32
%33 = getelementptr inbounds double, double* %21, i64 %28
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %34
%35 = getelementptr inbounds double, double* %33, i64 2
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %36
%37 = add nuw nsw i64 %28, 4
%38 = getelementptr inbounds double, double* %19, i64 %37
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %39
%40 = getelementptr inbounds double, double* %38, i64 2
%41 = bitcast double* %40 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %41
%42 = getelementptr inbounds double, double* %21, i64 %37
%43 = bitcast double* %42 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %43
%44 = getelementptr inbounds double, double* %42, i64 2
%45 = bitcast double* %44 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %45
%46 = add nuw nsw i64 %28, 8
%47 = getelementptr inbounds double, double* %19, i64 %46
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %48
%49 = getelementptr inbounds double, double* %47, i64 2
%50 = bitcast double* %49 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %50
%51 = getelementptr inbounds double, double* %21, i64 %46
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %52
%53 = getelementptr inbounds double, double* %51, i64 2
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %54
%55 = add nuw nsw i64 %28, 12
%56 = getelementptr inbounds double, double* %19, i64 %55
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %59
%60 = getelementptr inbounds double, double* %21, i64 %55
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %61
%62 = getelementptr inbounds double, double* %60, i64 2
%63 = bitcast double* %62 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %63
%64 = add nuw nsw i64 %28, 16
%65 = getelementptr inbounds double, double* %19, i64 %64
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %66
%67 = getelementptr inbounds double, double* %65, i64 2
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %68
%69 = getelementptr inbounds double, double* %21, i64 %64
%70 = bitcast double* %69 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %70
%71 = getelementptr inbounds double, double* %69, i64 2
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %72
%73 = add nuw nsw i64 %28, 20
%74 = icmp eq i64 %73, 200
br i1 %74, label %150, label %27
75: ; preds = %150
%76 = load double*, double** %3
%77 = getelementptr inbounds double*, double** %3, i64 199
%78 = load double*, double** %77
%79 = getelementptr double, double* %76, i64 200
%80 = getelementptr double, double* %78, i64 200
%81 = icmp ult double* %76, %80
%82 = icmp ult double* %78, %79
%83 = and i1 %81, %82
br i1 %83, label %153, label %84
84: ; preds = %75, %84
%85 = phi i64 [ %130, %84 ], [ 0, %75 ]
%86 = getelementptr inbounds double, double* %76, i64 %85
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %87
%88 = getelementptr inbounds double, double* %86, i64 2
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %89
%90 = getelementptr inbounds double, double* %78, i64 %85
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %91
%92 = getelementptr inbounds double, double* %90, i64 2
%93 = bitcast double* %92 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %93
%94 = add nuw nsw i64 %85, 4
%95 = getelementptr inbounds double, double* %76, i64 %94
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %98
%99 = getelementptr inbounds double, double* %78, i64 %94
%100 = bitcast double* %99 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %100
%101 = getelementptr inbounds double, double* %99, i64 2
%102 = bitcast double* %101 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %102
%103 = add nuw nsw i64 %85, 8
%104 = getelementptr inbounds double, double* %76, i64 %103
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %105
%106 = getelementptr inbounds double, double* %104, i64 2
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %107
%108 = getelementptr inbounds double, double* %78, i64 %103
%109 = bitcast double* %108 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %109
%110 = getelementptr inbounds double, double* %108, i64 2
%111 = bitcast double* %110 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %111
%112 = add nuw nsw i64 %85, 12
%113 = getelementptr inbounds double, double* %76, i64 %112
%114 = bitcast double* %113 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %114
%115 = getelementptr inbounds double, double* %113, i64 2
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %116
%117 = getelementptr inbounds double, double* %78, i64 %112
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %118
%119 = getelementptr inbounds double, double* %117, i64 2
%120 = bitcast double* %119 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %120
%121 = add nuw nsw i64 %85, 16
%122 = getelementptr inbounds double, double* %76, i64 %121
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %123
%124 = getelementptr inbounds double, double* %122, i64 2
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %125
%126 = getelementptr inbounds double, double* %78, i64 %121
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %127
%128 = getelementptr inbounds double, double* %126, i64 2
%129 = bitcast double* %128 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %129
%130 = add nuw nsw i64 %85, 20
%131 = icmp eq i64 %130, 200
br i1 %131, label %171, label %84
132: ; preds = %16, %132
%133 = phi i64 [ %148, %132 ], [ 0, %16 ]
%134 = getelementptr inbounds double, double* %19, i64 %133
store double 0.000000e+00, double* %134
%135 = getelementptr inbounds double, double* %21, i64 %133
store double 0.000000e+00, double* %135
%136 = add nuw nsw i64 %133, 1
%137 = getelementptr inbounds double, double* %19, i64 %136
store double 0.000000e+00, double* %137
%138 = getelementptr inbounds double, double* %21, i64 %136
store double 0.000000e+00, double* %138
%139 = add nuw nsw i64 %133, 2
%140 = getelementptr inbounds double, double* %19, i64 %139
store double 0.000000e+00, double* %140
%141 = getelementptr inbounds double, double* %21, i64 %139
store double 0.000000e+00, double* %141
%142 = add nuw nsw i64 %133, 3
%143 = getelementptr inbounds double, double* %19, i64 %142
store double 0.000000e+00, double* %143
%144 = getelementptr inbounds double, double* %21, i64 %142
store double 0.000000e+00, double* %144
%145 = add nuw nsw i64 %133, 4
%146 = getelementptr inbounds double, double* %19, i64 %145
store double 0.000000e+00, double* %146
%147 = getelementptr inbounds double, double* %21, i64 %145
store double 0.000000e+00, double* %147
%148 = add nuw nsw i64 %133, 5
%149 = icmp eq i64 %148, 200
br i1 %149, label %150, label %132
150: ; preds = %27, %132
%151 = add nuw nsw i64 %17, 1
%152 = icmp eq i64 %151, 200
br i1 %152, label %75, label %16
153: ; preds = %75, %153
%154 = phi i64 [ %169, %153 ], [ 0, %75 ]
%155 = getelementptr inbounds double, double* %76, i64 %154
store double 1.000000e+00, double* %155
%156 = getelementptr inbounds double, double* %78, i64 %154
store double 1.000000e+00, double* %156
%157 = add nuw nsw i64 %154, 1
%158 = getelementptr inbounds double, double* %76, i64 %157
store double 1.000000e+00, double* %158
%159 = getelementptr inbounds double, double* %78, i64 %157
store double 1.000000e+00, double* %159
%160 = add nuw nsw i64 %154, 2
%161 = getelementptr inbounds double, double* %76, i64 %160
store double 1.000000e+00, double* %161
%162 = getelementptr inbounds double, double* %78, i64 %160
store double 1.000000e+00, double* %162
%163 = add nuw nsw i64 %154, 3
%164 = getelementptr inbounds double, double* %76, i64 %163
store double 1.000000e+00, double* %164
%165 = getelementptr inbounds double, double* %78, i64 %163
store double 1.000000e+00, double* %165
%166 = add nuw nsw i64 %154, 4
%167 = getelementptr inbounds double, double* %76, i64 %166
store double 1.000000e+00, double* %167
%168 = getelementptr inbounds double, double* %78, i64 %166
store double 1.000000e+00, double* %168
%169 = add nuw nsw i64 %154, 5
%170 = icmp eq i64 %169, 200
br i1 %170, label %171, label %153
171: ; preds = %84, %153
br label %172
172: ; preds = %172, %171
%173 = phi i64 [ 1, %171 ], [ %197, %172 ]
%174 = getelementptr inbounds double*, double** %3, i64 %173
%175 = load double*, double** %174
store double 1.000000e+00, double* %175
%176 = getelementptr inbounds double, double* %175, i64 199
store double 1.000000e+00, double* %176
%177 = add nuw nsw i64 %173, 1
%178 = getelementptr inbounds double*, double** %3, i64 %177
%179 = load double*, double** %178
store double 1.000000e+00, double* %179
%180 = getelementptr inbounds double, double* %179, i64 199
store double 1.000000e+00, double* %180
%181 = add nuw nsw i64 %173, 2
%182 = getelementptr inbounds double*, double** %3, i64 %181
%183 = load double*, double** %182
store double 1.000000e+00, double* %183
%184 = getelementptr inbounds double, double* %183, i64 199
store double 1.000000e+00, double* %184
%185 = add nuw nsw i64 %173, 3
%186 = getelementptr inbounds double*, double** %3, i64 %185
%187 = load double*, double** %186
store double 1.000000e+00, double* %187
%188 = getelementptr inbounds double, double* %187, i64 199
store double 1.000000e+00, double* %188
%189 = add nuw nsw i64 %173, 4
%190 = getelementptr inbounds double*, double** %3, i64 %189
%191 = load double*, double** %190
store double 1.000000e+00, double* %191
%192 = getelementptr inbounds double, double* %191, i64 199
store double 1.000000e+00, double* %192
%193 = add nuw nsw i64 %173, 5
%194 = getelementptr inbounds double*, double** %3, i64 %193
%195 = load double*, double** %194
store double 1.000000e+00, double* %195
%196 = getelementptr inbounds double, double* %195, i64 199
store double 1.000000e+00, double* %196
%197 = add nuw nsw i64 %173, 6
%198 = icmp eq i64 %197, 199
br i1 %198, label %199, label %172
199: ; preds = %172
%200 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
%201 = getelementptr inbounds double*, double** %3, i64 1
%202 = load double*, double** %201
br label %203
203: ; preds = %451, %199
%204 = phi i32 [ 0, %199 ], [ %446, %451 ]
br label %205
205: ; preds = %203, %297
%206 = phi double* [ %202, %203 ], [ %211, %297 ]
%207 = phi double* [ %76, %203 ], [ %206, %297 ]
%208 = phi i64 [ 1, %203 ], [ %209, %297 ]
%209 = add nuw nsw i64 %208, 1
%210 = getelementptr inbounds double*, double** %3, i64 %209
%211 = load double*, double** %210
%212 = getelementptr inbounds double*, double** %5, i64 %208
%213 = load double*, double** %212
%214 = getelementptr double, double* %213, i64 1
%215 = getelementptr double, double* %213, i64 199
%216 = getelementptr double, double* %207, i64 1
%217 = getelementptr double, double* %207, i64 199
%218 = getelementptr double, double* %211, i64 1
%219 = getelementptr double, double* %211, i64 199
%220 = getelementptr double, double* %206, i64 198
%221 = icmp ult double* %214, %217
%222 = icmp ult double* %216, %215
%223 = and i1 %221, %222
%224 = icmp ult double* %214, %219
%225 = icmp ult double* %218, %215
%226 = and i1 %224, %225
%227 = or i1 %223, %226
%228 = icmp ult double* %214, %220
%229 = icmp ult double* %206, %215
%230 = and i1 %228, %229
%231 = or i1 %227, %230
br i1 %231, label %267, label %232
232: ; preds = %205, %232
%233 = phi i64 [ %265, %232 ], [ 0, %205 ]
%234 = or i64 %233, 1
%235 = getelementptr inbounds double, double* %207, i64 %234
%236 = bitcast double* %235 to <2 x double>*
%237 = load <2 x double>, <2 x double>* %236
%238 = getelementptr inbounds double, double* %235, i64 2
%239 = bitcast double* %238 to <2 x double>*
%240 = load <2 x double>, <2 x double>* %239
%241 = getelementptr inbounds double, double* %211, i64 %234
%242 = bitcast double* %241 to <2 x double>*
%243 = load <2 x double>, <2 x double>* %242
%244 = getelementptr inbounds double, double* %241, i64 2
%245 = bitcast double* %244 to <2 x double>*
%246 = load <2 x double>, <2 x double>* %245
%247 = fadd <2 x double> %237, %243
%248 = fadd <2 x double> %240, %246
%249 = getelementptr inbounds double, double* %206, i64 %233
%250 = bitcast double* %249 to <2 x double>*
%251 = load <2 x double>, <2 x double>* %250
%252 = getelementptr inbounds double, double* %249, i64 2
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = fadd <2 x double> %247, %251
%256 = fadd <2 x double> %248, %254
%257 = fadd <2 x double> %251, %255
%258 = fadd <2 x double> %254, %256
%259 = fmul <2 x double> %257, <double 2.500000e-01, double 2.500000e-01>
%260 = fmul <2 x double> %258, <double 2.500000e-01, double 2.500000e-01>
%261 = getelementptr inbounds double, double* %213, i64 %234
%262 = bitcast double* %261 to <2 x double>*
store <2 x double> %259, <2 x double>* %262
%263 = getelementptr inbounds double, double* %261, i64 2
%264 = bitcast double* %263 to <2 x double>*
store <2 x double> %260, <2 x double>* %264
%265 = add nuw i64 %233, 4
%266 = icmp eq i64 %265, 196
br i1 %266, label %267, label %232
267: ; preds = %232, %205
%268 = phi i64 [ 1, %205 ], [ 197, %232 ]
br label %269
269: ; preds = %269, %267
%270 = phi i64 [ %268, %267 ], [ %295, %269 ]
%271 = getelementptr inbounds double, double* %207, i64 %270
%272 = load double, double* %271
%273 = getelementptr inbounds double, double* %211, i64 %270
%274 = load double, double* %273
%275 = fadd double %272, %274
%276 = add nsw i64 %270, -1
%277 = getelementptr inbounds double, double* %206, i64 %276
%278 = load double, double* %277
%279 = fadd double %275, %278
%280 = fadd double %278, %279
%281 = fmul double %280, 2.500000e-01
%282 = getelementptr inbounds double, double* %213, i64 %270
store double %281, double* %282
%283 = add nuw nsw i64 %270, 1
%284 = getelementptr inbounds double, double* %207, i64 %283
%285 = load double, double* %284
%286 = getelementptr inbounds double, double* %211, i64 %283
%287 = load double, double* %286
%288 = fadd double %285, %287
%289 = getelementptr inbounds double, double* %206, i64 %270
%290 = load double, double* %289
%291 = fadd double %288, %290
%292 = fadd double %290, %291
%293 = fmul double %292, 2.500000e-01
%294 = getelementptr inbounds double, double* %213, i64 %283
store double %293, double* %294
%295 = add nuw nsw i64 %270, 2
%296 = icmp eq i64 %295, 199
br i1 %296, label %297, label %269
297: ; preds = %269
%298 = icmp eq i64 %209, 199
br i1 %298, label %299, label %205
299: ; preds = %297, %339
%300 = phi double* [ %341, %339 ], [ %202, %297 ]
%301 = phi i64 [ %337, %339 ], [ 1, %297 ]
%302 = phi double [ %333, %339 ], [ 0.000000e+00, %297 ]
%303 = getelementptr inbounds double*, double** %5, i64 %301
%304 = load double*, double** %303
br label %305
305: ; preds = %305, %299
%306 = phi i64 [ 1, %299 ], [ %334, %305 ]
%307 = phi double [ %302, %299 ], [ %333, %305 ]
%308 = getelementptr inbounds double, double* %304, i64 %306
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %300, i64 %306
%311 = load double, double* %310
%312 = fsub double %309, %311
%313 = fmul double %312, %312
%314 = tail call double @llvm.fabs.f64(double %313)
%315 = fadd double %307, %314
%316 = add nuw nsw i64 %306, 1
%317 = getelementptr inbounds double, double* %304, i64 %316
%318 = load double, double* %317
%319 = getelementptr inbounds double, double* %300, i64 %316
%320 = load double, double* %319
%321 = fsub double %318, %320
%322 = fmul double %321, %321
%323 = tail call double @llvm.fabs.f64(double %322)
%324 = fadd double %315, %323
%325 = add nuw nsw i64 %306, 2
%326 = getelementptr inbounds double, double* %304, i64 %325
%327 = load double, double* %326
%328 = getelementptr inbounds double, double* %300, i64 %325
%329 = load double, double* %328
%330 = fsub double %327, %329
%331 = fmul double %330, %330
%332 = tail call double @llvm.fabs.f64(double %331)
%333 = fadd double %324, %332
%334 = add nuw nsw i64 %306, 3
%335 = icmp eq i64 %334, 199
br i1 %335, label %336, label %305
336: ; preds = %305
%337 = add nuw nsw i64 %301, 1
%338 = icmp eq i64 %337, 199
br i1 %338, label %342, label %339
339: ; preds = %336
%340 = getelementptr inbounds double*, double** %3, i64 %337
%341 = load double*, double** %340
br label %299
342: ; preds = %336
%343 = fptrunc double %333 to float
%344 = tail call float @sqrtf(float %343)
br label %345
345: ; preds = %441, %342
%346 = phi double* [ %202, %342 ], [ %443, %441 ]
%347 = phi i64 [ 1, %342 ], [ %439, %441 ]
%348 = getelementptr inbounds double*, double** %5, i64 %347
%349 = load double*, double** %348
%350 = getelementptr double, double* %346, i64 1
%351 = getelementptr double, double* %346, i64 199
%352 = getelementptr double, double* %349, i64 1
%353 = getelementptr double, double* %349, i64 199
%354 = icmp ult double* %350, %353
%355 = icmp ult double* %352, %351
%356 = and i1 %354, %355
br i1 %356, label %406, label %357
357: ; preds = %345, %371
%358 = phi i64 [ %405, %371 ], [ 0, %345 ]
%359 = or i64 %358, 1
%360 = getelementptr inbounds double, double* %349, i64 %359
%361 = bitcast double* %360 to <2 x double>*
%362 = load <2 x double>, <2 x double>* %361
%363 = getelementptr inbounds double, double* %360, i64 2
%364 = bitcast double* %363 to <2 x double>*
%365 = load <2 x double>, <2 x double>* %364
%366 = getelementptr inbounds double, double* %346, i64 %359
%367 = bitcast double* %366 to <2 x double>*
store <2 x double> %362, <2 x double>* %367
%368 = getelementptr inbounds double, double* %366, i64 2
%369 = bitcast double* %368 to <2 x double>*
store <2 x double> %365, <2 x double>* %369
%370 = icmp eq i64 %358, 192
br i1 %370, label %406, label %371
371: ; preds = %357
%372 = or i64 %358, 5
%373 = getelementptr inbounds double, double* %349, i64 %372
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = getelementptr inbounds double, double* %373, i64 2
%377 = bitcast double* %376 to <2 x double>*
%378 = load <2 x double>, <2 x double>* %377
%379 = getelementptr inbounds double, double* %346, i64 %372
%380 = bitcast double* %379 to <2 x double>*
store <2 x double> %375, <2 x double>* %380
%381 = getelementptr inbounds double, double* %379, i64 2
%382 = bitcast double* %381 to <2 x double>*
store <2 x double> %378, <2 x double>* %382
%383 = or i64 %358, 9
%384 = getelementptr inbounds double, double* %349, i64 %383
%385 = bitcast double* %384 to <2 x double>*
%386 = load <2 x double>, <2 x double>* %385
%387 = getelementptr inbounds double, double* %384, i64 2
%388 = bitcast double* %387 to <2 x double>*
%389 = load <2 x double>, <2 x double>* %388
%390 = getelementptr inbounds double, double* %346, i64 %383
%391 = bitcast double* %390 to <2 x double>*
store <2 x double> %386, <2 x double>* %391
%392 = getelementptr inbounds double, double* %390, i64 2
%393 = bitcast double* %392 to <2 x double>*
store <2 x double> %389, <2 x double>* %393
%394 = or i64 %358, 13
%395 = getelementptr inbounds double, double* %349, i64 %394
%396 = bitcast double* %395 to <2 x double>*
%397 = load <2 x double>, <2 x double>* %396
%398 = getelementptr inbounds double, double* %395, i64 2
%399 = bitcast double* %398 to <2 x double>*
%400 = load <2 x double>, <2 x double>* %399
%401 = getelementptr inbounds double, double* %346, i64 %394
%402 = bitcast double* %401 to <2 x double>*
store <2 x double> %397, <2 x double>* %402
%403 = getelementptr inbounds double, double* %401, i64 2
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> %400, <2 x double>* %404
%405 = add nuw nsw i64 %358, 16
br label %357
406: ; preds = %357, %345
%407 = phi i64 [ 1, %345 ], [ 197, %357 ]
%408 = and i1 %354, %355
br label %409
409: ; preds = %409, %406
%410 = phi i64 [ %415, %409 ], [ %407, %406 ]
%411 = phi i64 [ %416, %409 ], [ 0, %406 ]
%412 = getelementptr inbounds double, double* %349, i64 %410
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %346, i64 %410
store double %413, double* %414
%415 = add nuw nsw i64 %410, 1
%416 = add i64 %411, 1
%417 = icmp eq i64 %416, 2
br i1 %417, label %418, label %409
418: ; preds = %409
br i1 %408, label %419, label %438
419: ; preds = %418, %419
%420 = phi i64 [ %436, %419 ], [ %415, %418 ]
%421 = getelementptr inbounds double, double* %349, i64 %420
%422 = load double, double* %421
%423 = getelementptr inbounds double, double* %346, i64 %420
store double %422, double* %423
%424 = add nuw nsw i64 %420, 1
%425 = getelementptr inbounds double, double* %349, i64 %424
%426 = load double, double* %425
%427 = getelementptr inbounds double, double* %346, i64 %424
store double %426, double* %427
%428 = add nuw nsw i64 %420, 2
%429 = getelementptr inbounds double, double* %349, i64 %428
%430 = load double, double* %429
%431 = getelementptr inbounds double, double* %346, i64 %428
store double %430, double* %431
%432 = add nuw nsw i64 %420, 3
%433 = getelementptr inbounds double, double* %349, i64 %432
%434 = load double, double* %433
%435 = getelementptr inbounds double, double* %346, i64 %432
store double %434, double* %435
%436 = add nuw nsw i64 %420, 4
%437 = icmp eq i64 %436, 199
br i1 %437, label %438, label %419
438: ; preds = %419, %418
%439 = add nuw nsw i64 %347, 1
%440 = icmp eq i64 %439, 199
br i1 %440, label %444, label %441
441: ; preds = %438
%442 = getelementptr inbounds double*, double** %3, i64 %439
%443 = load double*, double** %442
br label %345
444: ; preds = %438
%445 = fpext float %344 to double
%446 = add nuw nsw i32 %204, 1
%447 = urem i32 %446, 20
%448 = icmp eq i32 %447, 0
br i1 %448, label %449, label %451
449: ; preds = %444
%450 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i32 %446, double %445)
br label %451
451: ; preds = %444, %449
%452 = fcmp ogt double %445, 1.000000e-05
%453 = icmp ult i32 %204, 19999
%454 = select i1 %452, i1 %453, i1 false
br i1 %454, label %203, label %455
455: ; preds = %451
%456 = icmp ugt i32 %204, 19998
br i1 %456, label %457, label %459
457: ; preds = %455
%458 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.5, i64 0, i64 0))
br label %459
459: ; preds = %457, %455
%460 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.4, i64 0, i64 0), double %445, i32 %446)
br label %461
461: ; preds = %459, %461
%462 = phi i64 [ 199, %459 ], [ %469, %461 ]
%463 = getelementptr inbounds double*, double** %5, i64 %462
%464 = bitcast double** %463 to i8**
%465 = load i8*, i8** %464
tail call void @free(i8* %465)
%466 = getelementptr inbounds double*, double** %3, i64 %462
%467 = bitcast double** %466 to i8**
%468 = load i8*, i8** %467
tail call void @free(i8* %468)
%469 = add nsw i64 %462, -1
%470 = icmp eq i64 %462, 0
br i1 %470, label %471, label %461
471: ; preds = %461
tail call void @free(i8* %4)
tail call void @free(i8* %2)
ret i32 0
}