#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ printf(char *, int, double);
double sqrt(double);
void jacobi_poisson(int N, int M, double *x, double *b) {
  int i, j, k, conv, maxit = 10000;
  double *t, s, tol = 1e-6;
  t = (double *)calloc(N * M, sizeof(double));
  k = 0;
  conv = 0;
  while (!conv && k < maxit) {
    i = 0;
    t[i * M + 0] =
        (b[i * M + 0] + x[(i + 1) * M + 0] + x[i * M + (0 + 1)]) / 4.0;
    for (j = 1; j < M - 1; j++) {
      t[i * M + j] = (b[i * M + j] + x[(i + 1) * M + j] + x[i * M + (j + 1)] +
                      x[i * M + (j - 1)]) /
                     4.0;
    }
    t[i * M + (M - 1)] = (b[i * M + (M - 1)] + x[(i + 1) * M + (M - 1)] +
                          x[i * M + ((M - 1) - 1)]) /
                         4.0;
    for (i = 1; i < N - 1; i++) {
      t[i * M + 0] = (b[i * M + 0] + x[(i + 1) * M + 0] + x[(i - 1) * M + 0] +
                      x[i * M + (0 + 1)]) /
                     4.0;
      for (j = 1; j < M - 1; j++) {
        t[i * M + j] = (b[i * M + j] + x[(i + 1) * M + j] + x[(i - 1) * M + j] +
                        x[i * M + (j + 1)] + x[i * M + (j - 1)]) /
                       4.0;
      }
      t[i * M + (M - 1)] =
          (b[i * M + (M - 1)] + x[(i + 1) * M + (M - 1)] +
           x[(i - 1) * M + (M - 1)] + x[i * M + ((M - 1) - 1)]) /
          4.0;
    }
    i = N - 1;
    t[i * M + 0] =
        (b[i * M + 0] + x[(i - 1) * M + 0] + x[i * M + (0 + 1)]) / 4.0;
    for (j = 1; j < M - 1; j++) {
      t[i * M + j] = (b[i * M + j] + x[(i - 1) * M + j] + x[i * M + (j + 1)] +
                      x[i * M + (j - 1)]) /
                     4.0;
    }
    t[i * M + (M - 1)] = (b[i * M + (M - 1)] + x[(i - 1) * M + (M - 1)] +
                          x[i * M + ((M - 1) - 1)]) /
                         4.0;
    s = 0.0;
    for (i = 0; i < N; i++) {
      for (j = 0; j < M; j++) {
        s += (x[i * M + j] - t[i * M + j]) * (x[i * M + j] - t[i * M + j]);
      }
    }
    conv = (sqrt(s) < tol);
    printf("Error en iteración %d: %g\n", k, sqrt(s));
    k = k + 1;
    for (i = 0; i < N; i++) {
      for (j = 0; j < M; j++) {
        x[i * M + j] = t[i * M + j];
      }
    }
  }
  free(t);
}


x86 assembly (clang, -O0):
<jacobi_poisson>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x2710,-0x2c(%rbp)
movsd  0xe9b(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x4(%rbp),%edi
imul   -0x8(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x28(%rbp)
mov    %al,-0x49(%rbp)
jne    11a8 <jacobi_poisson+0x68>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    11b8 <jacobi_poisson+0x78>
jmp    186e <jacobi_poisson+0x72e>
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xdfc(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12d3 <jacobi_poisson+0x193>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xd5d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    122d <jacobi_poisson+0xed>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xcd6(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1559 <jacobi_poisson+0x419>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xc39(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14af <jacobi_poisson+0x36f>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xb81(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13f0 <jacobi_poisson+0x2b0>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xadc(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1358 <jacobi_poisson+0x218>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa59(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1676 <jacobi_poisson+0x536>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x9ba(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    15d0 <jacobi_poisson+0x490>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x933(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17ad <jacobi_poisson+0x66d>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    179a <jacobi_poisson+0x65a>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1716 <jacobi_poisson+0x5d6>
jmp    179f <jacobi_poisson+0x65f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1703 <jacobi_poisson+0x5c3>
movsd  -0x40(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1060 <sqrt@plt>
mov    -0x50(%rbp),%esi
lea    0x828(%rip),%rdi
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1869 <jacobi_poisson+0x729>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1856 <jacobi_poisson+0x716>
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1810 <jacobi_poisson+0x6d0>
jmp    185b <jacobi_poisson+0x71b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17fd <jacobi_poisson+0x6bd>
jmp    118d <jacobi_poisson+0x4d>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacobi_poisson>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %rcx,%r13
mov    %rdx,%r14
mov    %esi,%r15d
mov    %edi,%ebx
mov    %esi,%edi
imul   %ebx,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%r9
movslq %r15d,%r12
lea    -0x1(%r12),%ebp
mov    %rbx,0x38(%rsp)
lea    -0x1(%rbx),%eax
mov    %rax,0x1c0(%rsp)
mov    %eax,%r11d
imul   %r15d,%r11d
lea    -0x2(%rbx),%eax
imul   %r15d,%eax
mov    %eax,0x10(%rsp)
mov    %r12d,%ebx
mov    %rbx,0x20(%rsp)
lea    0x8(%r9),%rdi
lea    (%r9,%rbp,8),%rcx
lea    0x8(%r13),%r8
lea    0x0(,%rbp,8),%rsi
add    %r13,%rsi
lea    (%r14,%rbp,8),%rax
add    $0x8,%rax
and    $0xfffffffc,%ebx
mov    %rbx,0x1a8(%rsp)
lea    -0x4(%rbx),%r10
mov    %r10,0x1a0(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
cmp    %rsi,%rdi
setb   %bl
cmp    %rcx,%r8
lea    0x8(%r14,%r12,8),%r8
setb   %dl
and    %bl,%dl
cmp    %rax,%rdi
setb   %bl
cmp    %r14,%rcx
seta   %al
and    %bl,%al
lea    (%r12,%rbp,1),%rsi
lea    (%r14,%rsi,8),%rsi
mov    %rdi,0x148(%rsp)
cmp    %rsi,%rdi
mov    %r8,%rsi
setb   %bl
cmp    %rcx,%r8
lea    -0x1(%rbp),%rdi
mov    %rdi,0x18(%rsp)
setb   %cl
and    %bl,%cl
or     %dl,%cl
or     %al,%cl
mov    %cl,0xf(%rsp)
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0xf8(%rsp)
mov    %r11,0xe8(%rsp)
movslq %r11d,%r8
lea    -0x2(%rbp),%rax
lea    (%rax,%r8,1),%ecx
cmp    %r8d,%ecx
setl   %cl
shr    $0x20,%rax
setne  %al
or     %cl,%al
mov    %al,0xe(%rsp)
lea    (%r9,%r8,8),%rdi
add    $0x8,%rdi
lea    (%r8,%rbp,1),%rax
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rdi
setb   %cl
lea    (%r9,%rax,8),%r11
lea    0x8(,%r8,8),%rbx
add    %r13,%rbx
mov    %rbx,0xd8(%rsp)
cmp    %r11,%rbx
setb   %bl
and    %cl,%bl
lea    (%r14,%rax,8),%rax
add    $0x8,%rax
cmp    %rax,%rdi
setb   %al
lea    (%r14,%r8,8),%rcx
mov    %rcx,0xd0(%rsp)
cmp    %r11,%rcx
setb   %cl
and    %al,%cl
or     %bl,%cl
mov    0x20(%rsp),%rbx
movslq 0x10(%rsp),%rdx
lea    (%rdx,%rbp,1),%rax
lea    (%r14,%rax,8),%rax
mov    %rdi,0xe0(%rsp)
cmp    %rax,%rdi
setb   0x10(%rsp)
lea    (%r14,%rdx,8),%rdi
add    $0x8,%rdi
mov    %rdi,0xc8(%rsp)
cmp    %r11,%rdi
setb   %al
and    0x10(%rsp),%al
or     %cl,%al
mov    %al,0xd(%rsp)
lea    (%r12,%r12,1),%eax
add    $0xffffffff,%eax
cltq
mov    %rax,0x178(%rsp)
lea    -0x2(%r12),%eax
cltq
mov    %rax,0x98(%rsp)
lea    0x1(%r8),%eax
cltq
mov    %rax,0x170(%rsp)
lea    -0x1(%r8,%r12,1),%eax
cltq
mov    %rax,0x168(%rsp)
mov    %rdx,0x70(%rsp)
lea    -0x1(%rdx,%r12,1),%eax
cltq
mov    %rax,0x160(%rsp)
lea    -0x2(%r8,%r12,1),%eax
cltq
mov    %rax,0x158(%rsp)
mov    0x18(%rsp),%rcx
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,%rax
or     $0x1,%rax
mov    %rax,0xb8(%rsp)
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x140(%rsp)
mov    %r10d,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%r10
mov    %r10,0x188(%rsp)
mov    %ebx,%eax
and    $0x3,%eax
mov    %rax,0x50(%rsp)
mov    %r12,%rax
shl    $0x20,%rax
mov    %rax,0x88(%rsp)
mov    %r12,%rax
shl    $0x4,%rax
add    %r14,%rax
add    $0x8,%rax
mov    %rax,0x118(%rsp)
mov    %rcx,0x198(%rsp)
mov    %rcx,%r10
shl    $0x5,%r10
movsd  0xc05(%rip),%xmm5
movapd 0xc1d(%rip),%xmm6
movapd 0xc15(%rip),%xmm7
movslq %ebp,%rax
mov    %rax,0x90(%rsp)
mov    0x38(%rsp),%eax
mov    %rax,0xa0(%rsp)
mov    0x60(%rsp),%rax
add    $0x1,%rax
mov    %rax,0xb0(%rsp)
lea    0x18(%r13),%rax
mov    %rax,0xa8(%rsp)
lea    0x0(,%r12,8),%rax
mov    %rax,0x10(%rsp)
lea    0x8(%r13,%r12,8),%rax
mov    %rax,0x110(%rsp)
lea    0x8(%r9,%r12,8),%rax
mov    %rax,0x108(%rsp)
lea    -0x8(,%rbp,8),%rax
ff
mov    %rax,0x1b0(%rsp)
lea    0x10(%r14,%r12,8),%rax
mov    %rax,0x100(%rsp)
mov    %r8,0x78(%rsp)
lea    -0x1(%r8),%eax
mov    %rax,0xf0(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x68(%rsp)
lea    0x70(%r14),%rax
mov    %rax,0x138(%rsp)
lea    0x70(%r9),%rax
mov    %rax,0x130(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x128(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x120(%rsp)
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r9,0x40(%rsp)
mov    %r15d,0x5c(%rsp)
mov    %r12,0x28(%rsp)
mov    %rbp,0x80(%rsp)
mov    %rsi,0x180(%rsp)
mov    %r10,0x190(%rsp)
mov    %r13,0x1b8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%r13),%xmm0
addsd  (%r14,%r12,8),%xmm0
addsd  0x8(%r14),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9)
cmp    $0x3,%r12d
jl     1680 <jacobi_poisson+0x540>
cmpq   $0x4,0x18(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    $0x1,%ecx
jne    15d7 <jacobi_poisson+0x497>
mov    0xa8(%rsp),%rax
mov    %r14,%rdx
xor    %ecx,%ecx
mov    0x60(%rsp),%rdi
nop
movupd -0x10(%rax),%xmm0
movupd (%rax),%xmm1
movupd 0x8(%rdx,%r12,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%rdx,%r12,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx),%xmm1
movupd 0x10(%rdx),%xmm3
movupd 0x20(%rdx),%xmm4
add    $0x20,%rdx
addpd  %xmm0,%xmm4
addpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
addpd  %xmm3,%xmm4
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm4
movupd %xmm2,0x8(%r9,%rcx,8)
movupd %xmm4,0x18(%r9,%rcx,8)
add    $0x4,%rcx
add    $0x20,%rax
cmp    %rcx,%rdi
jne    1560 <jacobi_poisson+0x420>
mov    0xb0(%rsp),%rcx
cmp    %rdi,0x18(%rsp)
je     1680 <jacobi_poisson+0x540>
mov    %rcx,%rax
test   $0x1,%bpl
jne    160d <jacobi_poisson+0x4cd>
movsd  0x0(%r13,%rcx,8),%xmm0
lea    (%rcx,%r12,1),%rax
addsd  (%r14,%rax,8),%xmm0
lea    0x1(%rcx),%rax
addsd  0x8(%r14,%rcx,8),%xmm0
addsd  -0x8(%r14,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rcx,8)
not    %rcx
cmp    0xf8(%rsp),%rcx
je     1680 <jacobi_poisson+0x540>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm0
addsd  -0x8(%rsi,%rax,8),%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
addsd  -0x8(%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
addsd  0x10(%r14,%rax,8),%xmm0
addsd  (%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x8(%r9,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%rbp
jne    1620 <jacobi_poisson+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x90(%rsp),%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
mov    0x178(%rsp),%rax
addsd  (%r14,%rax,8),%xmm0
mov    0x98(%rsp),%rax
addsd  (%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rcx,8)
cmpl   $0x3,0x38(%rsp)
jl     1830 <jacobi_poisson+0x6f0>
mov    $0x1,%r11d
mov    0x100(%rsp),%rax
mov    0x108(%rsp),%rcx
mov    0x110(%rsp),%rdx
mov    0x118(%rsp),%rsi
mov    %r14,%rdi
mov    0x88(%rsp),%r12
jmp    177c <jacobi_poisson+0x63c>
cs nopw 0x0(%rax,%rax,1)
mov    0x90(%rsp),%rbx
lea    (%r15,%rbx,1),%rbp
mov    0x1b8(%rsp),%r13
movsd  0x0(%r13,%rbp,8),%xmm0
add    %rbx,%r10
addsd  (%r8,%r10,8),%xmm0
add    %rbx,%r11
addsd  (%r8,%r11,8),%xmm0
add    0x98(%rsp),%r15
addsd  (%r8,%r15,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x40(%rsp),%r9
movsd  %xmm0,(%r9,%rbp,8)
add    0x88(%rsp),%r12
mov    0x10(%rsp),%rbp
add    %rbp,%rdi
add    %rbp,%rsi
add    %rbp,%rdx
add    %rbp,%rcx
add    %rbp,%rax
mov    0x30(%rsp),%r11
cmp    0x1c0(%rsp),%r11
mov    %r8,%r14
je     1830 <jacobi_poisson+0x6f0>
mov    %r11,%r15
mov    0x28(%rsp),%rbp
imul   %rbp,%r15
lea    0x1(%r11),%r10
mov    %r10,0x30(%rsp)
imul   %rbp,%r10
add    $0xffffffffffffffff,%r11
imul   %rbp,%r11
movsd  0x0(%r13,%r15,8),%xmm0
addsd  (%r14,%r10,8),%xmm0
addsd  (%r14,%r11,8),%xmm0
addsd  0x8(%r14,%r15,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%r15,8)
cmp    $0x3,%ebp
mov    0x1b0(%rsp),%rbx
mov    %r14,%r8
movabs $0x100000000,%r14
jl     1700 <jacobi_poisson+0x5c0>
xor    %ebp,%ebp
mov    %r12,%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rbp,1),%xmm0
addsd  (%rsi,%rbp,1),%xmm0
addsd  0x8(%rdi,%rbp,1),%xmm0
addsd  (%rax,%rbp,1),%xmm0
mov    %r13,%r9
sar    $0x1d,%r9
addsd  (%r8,%r9,1),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
add    %r14,%r13
add    $0x8,%rbp
cmp    %rbp,%rbx
jne    17f0 <jacobi_poisson+0x6b0>
jmp    1700 <jacobi_poisson+0x5c0>
nopl   0x0(%rax)
mov    0x78(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x70(%rsp),%rcx
addsd  (%r14,%rcx,8),%xmm0
mov    0x170(%rsp),%rcx
addsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rax,8)
mov    0x5c(%rsp),%r15d
cmp    $0x3,%r15d
mov    0x28(%rsp),%r12
jl     198e <jacobi_poisson+0x84e>
cmpq   $0x2,0x18(%rsp)
setb   %al
or     0xe(%rsp),%al
or     0xd(%rsp),%al
mov    $0x1,%ebp
jne    1919 <jacobi_poisson+0x7d9>
xor    %eax,%eax
mov    0xe8(%rsp),%rdx
mov    0xe0(%rsp),%rsi
mov    0xd8(%rsp),%rdi
mov    0xd0(%rsp),%rbp
mov    0xc8(%rsp),%rbx
mov    0xc0(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd 0x10(%rbp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
lea    (%rdx,%rax,1),%ecx
movslq %ecx,%rcx
movupd (%r14,%rcx,8),%xmm1
addpd  %xmm0,%xmm1
mulpd  %xmm7,%xmm1
movupd %xmm1,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    18d0 <jacobi_poisson+0x790>
mov    0xb8(%rsp),%rbp
cmp    %r8,0x18(%rsp)
je     198e <jacobi_poisson+0x84e>
mov    0xf0(%rsp),%rax
lea    (%rax,%rbp,1),%r8d
mov    0x70(%rsp),%rax
lea    (%rax,%rbp,1),%rcx
lea    (%r14,%rcx,8),%rcx
mov    0x78(%rsp),%rax
lea    (%rax,%rbp,1),%rbx
lea    0x0(,%rbx,8),%rdx
add    %r13,%rdx
lea    (%r9,%rbx,8),%rsi
mov    0x80(%rsp),%rdi
sub    %rbp,%rdi
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rbp
xor    %ebx,%ebx
movsd  (%rdx,%rbx,8),%xmm0
addsd  (%rcx,%rbx,8),%xmm0
addsd  0x0(%rbp,%rbx,8),%xmm0
lea    (%r8,%rbx,1),%eax
cltq
addsd  (%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1960 <jacobi_poisson+0x820>
mov    0x168(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x160(%rsp),%rcx
addsd  (%r14,%rcx,8),%xmm0
mov    0x158(%rsp),%rcx
addsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r9,%rax,8)
cmpl   $0x0,0x38(%rsp)
mov    0x20(%rsp),%rbx
xorpd  %xmm2,%xmm2
jle    1a80 <jacobi_poisson+0x940>
mov    0x68(%rsp),%rax
mov    0x148(%rsp),%rcx
xor    %edx,%edx
mov    0x140(%rsp),%rbp
jmp    1a09 <jacobi_poisson+0x8c9>
add    $0x1,%rdx
mov    0x10(%rsp),%rsi
add    %rsi,%rcx
add    %rsi,%rax
cmp    0xa0(%rsp),%rdx
je     1a80 <jacobi_poisson+0x940>
test   %r15d,%r15d
jle    19f0 <jacobi_poisson+0x8b0>
xor    %esi,%esi
cmp    $0x1,%r15d
je     1a53 <jacobi_poisson+0x913>
movapd %xmm2,%xmm0
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rsi,8),%xmm1
movsd  (%rax,%rsi,8),%xmm2
subsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
subsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
add    $0x2,%rsi
movapd %xmm2,%xmm0
cmp    %rsi,%rbp
jne    1a20 <jacobi_poisson+0x8e0>
test   $0x1,%bl
je     19f0 <jacobi_poisson+0x8b0>
mov    %rdx,%rdi
imul   %r12,%rdi
add    %rdi,%rsi
movsd  (%r14,%rsi,8),%xmm0
subsd  (%r9,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
jmp    19f0 <jacobi_poisson+0x8b0>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
sqrtsd %xmm2,%xmm1
ucomisd 0x581(%rip),%xmm2
movapd %xmm1,%xmm0
jae    1abc <jacobi_poisson+0x97c>
movapd %xmm2,%xmm0
movsd  %xmm2,0x30(%rsp)
movsd  %xmm1,0x150(%rsp)
call   1060 <sqrt@plt>
movsd  0x150(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  %xmm0,0x30(%rsp)
ucomisd 0x546(%rip),%xmm2
jae    1ad9 <jacobi_poisson+0x999>
movapd %xmm2,%xmm0
call   1060 <sqrt@plt>
movapd %xmm0,%xmm1
lea    0x550(%rip),%rdi
mov    0x48(%rsp),%rsi
movapd %xmm1,%xmm0
call   1040 <printf@plt>
cmpl   $0x0,0x38(%rsp)
mov    0x50(%rsp),%rcx
movsd  0x500(%rip),%xmm5
movapd 0x518(%rip),%xmm6
movapd 0x510(%rip),%xmm7
jle    1d50 <jacobi_poisson+0xc10>
mov    0x40(%rsp),%rax
mov    %r14,%r11
mov    0x120(%rsp),%r8
mov    0x128(%rsp),%rsi
mov    0x130(%rsp),%rdi
mov    0x138(%rsp),%rbp
xor    %r9d,%r9d
jmp    1b79 <jacobi_poisson+0xa39>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
mov    0x10(%rsp),%rdx
add    %rdx,%rbp
add    %rdx,%rdi
add    %rdx,%rsi
add    %rdx,%r8
add    %rdx,%r11
add    %rdx,%rax
cmp    0xa0(%rsp),%r9
je     1d50 <jacobi_poisson+0xc10>
test   %r15d,%r15d
jle    1b50 <jacobi_poisson+0xa10>
cmp    $0x4,%r15d
jae    1b90 <jacobi_poisson+0xa50>
xor    %edx,%edx
jmp    1cc0 <jacobi_poisson+0xb80>
nopl   0x0(%rax,%rax,1)
mov    %r9,%rcx
imul   %r12,%rcx
lea    (%rcx,%rbx,1),%rdx
lea    (%r14,%rcx,8),%r10
mov    0x40(%rsp),%r12
lea    (%r12,%rdx,8),%rbx
cmp    %rbx,%r10
jae    1bd0 <jacobi_poisson+0xa90>
lea    (%r14,%rdx,8),%rdx
lea    (%r12,%rcx,8),%rcx
cmp    %rdx,%rcx
jae    1bd0 <jacobi_poisson+0xa90>
xor    %edx,%edx
mov    0x28(%rsp),%r12
mov    0x20(%rsp),%rbx
mov    0x50(%rsp),%rcx
jmp    1cc0 <jacobi_poisson+0xb80>
cmpq   $0xc,0x1a0(%rsp)
mov    0x190(%rsp),%r10
jae    1bec <jacobi_poisson+0xaac>
xor    %edx,%edx
mov    0x28(%rsp),%r12
jmp    1c5d <jacobi_poisson+0xb1d>
mov    0x188(%rsp),%rbx
xor    %edx,%edx
mov    0x28(%rsp),%r12
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdi,%rdx,8),%xmm0
movups -0x60(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x70(%rbp,%rdx,8)
movups %xmm1,-0x60(%rbp,%rdx,8)
movups -0x50(%rdi,%rdx,8),%xmm0
movups -0x40(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x50(%rbp,%rdx,8)
movups %xmm1,-0x40(%rbp,%rdx,8)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdx,8)
movups %xmm1,-0x20(%rbp,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd (%rdi,%rdx,8),%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rbx
jne    1c00 <jacobi_poisson+0xac0>
cmpq   $0x0,0x198(%rsp)
je     1c9f <jacobi_poisson+0xb5f>
lea    (%rsi,%rdx,8),%rbx
lea    (%r8,%rdx,8),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rdx,%rcx,1),%xmm0
movupd (%rdx,%rcx,1),%xmm1
movupd %xmm0,-0x10(%rbx,%rcx,1)
movupd %xmm1,(%rbx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1c80 <jacobi_poisson+0xb40>
mov    0x1a8(%rsp),%rcx
mov    %rcx,%rdx
mov    0x20(%rsp),%rbx
cmp    %rbx,%rcx
mov    0x50(%rsp),%rcx
je     1b50 <jacobi_poisson+0xa10>
nopl   (%rax)
mov    %rdx,%r10
not    %r10
add    %rbx,%r10
test   %rcx,%rcx
je     1cf5 <jacobi_poisson+0xbb5>
mov    %rcx,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
jne    1ce0 <jacobi_poisson+0xba0>
cmp    $0x3,%r10
mov    0x20(%rsp),%rbx
jb     1b50 <jacobi_poisson+0xa10>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rdx,8)
movsd  0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
movsd  0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1d10 <jacobi_poisson+0xbd0>
jmp    1b50 <jacobi_poisson+0xa10>
nopl   0x0(%rax)
movsd  0x2b0(%rip),%xmm0
ucomisd 0x30(%rsp),%xmm0
mov    0x40(%rsp),%r9
mov    0x80(%rsp),%rbp
mov    0x180(%rsp),%rsi
ja     1d8e <jacobi_poisson+0xc4e>
mov    0x48(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    $0x270e,%ecx
mov    %rax,0x48(%rsp)
jbe    1510 <jacobi_poisson+0x3d0>
mov    %r9,%rdi
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
@.str = [28 x i8] c"Error en iteraci\C3\B3n %d: %g\0A\00"
define void @jacobi_poisson(i32 %0, i32 %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double*
%15 = alloca double
%16 = alloca double
store i32 %0, i32* %5
store i32 %1, i32* %6
store double* %2, double** %7
store double* %3, double** %8
store i32 10000, i32* %13
store double 0x3EB0C6F7A0B5ED8D, double* %16
%17 = load i32, i32* %5
%18 = load i32, i32* %6
%19 = mul nsw i32 %17, %18
%20 = call i64 @calloc(i32 %19, i32 8)
%21 = inttoptr i64 %20 to double*
store double* %21, double** %14
store i32 0, i32* %11
store i32 0, i32* %12
br label %22
22: ; preds = %600, %4
%23 = load i32, i32* %12
%24 = icmp ne i32 %23, 0
br i1 %24, label %29, label %25
25: ; preds = %22
%26 = load i32, i32* %11
%27 = load i32, i32* %13
%28 = icmp slt i32 %26, %27
br label %29
29: ; preds = %25, %22
%30 = phi i1 [ false, %22 ], [ %28, %25 ]
br i1 %30, label %31, label %601
31: ; preds = %29
store i32 0, i32* %9
%32 = load double*, double** %8
%33 = load i32, i32* %9
%34 = load i32, i32* %6
%35 = mul nsw i32 %33, %34
%36 = add nsw i32 %35, 0
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double, double* %32, i64 %37
%39 = load double, double* %38
%40 = load double*, double** %7
%41 = load i32, i32* %9
%42 = add nsw i32 %41, 1
%43 = load i32, i32* %6
%44 = mul nsw i32 %42, %43
%45 = add nsw i32 %44, 0
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %40, i64 %46
%48 = load double, double* %47
%49 = fadd double %39, %48
%50 = load double*, double** %7
%51 = load i32, i32* %9
%52 = load i32, i32* %6
%53 = mul nsw i32 %51, %52
%54 = add nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %50, i64 %55
%57 = load double, double* %56
%58 = fadd double %49, %57
%59 = fdiv double %58, 4.000000e+00
%60 = load double*, double** %14
%61 = load i32, i32* %9
%62 = load i32, i32* %6
%63 = mul nsw i32 %61, %62
%64 = add nsw i32 %63, 0
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %60, i64 %65
store double %59, double* %66
store i32 1, i32* %10
br label %67
67: ; preds = %124, %31
%68 = load i32, i32* %10
%69 = load i32, i32* %6
%70 = sub nsw i32 %69, 1
%71 = icmp slt i32 %68, %70
br i1 %71, label %72, label %127
72: ; preds = %67
%73 = load double*, double** %8
%74 = load i32, i32* %9
%75 = load i32, i32* %6
%76 = mul nsw i32 %74, %75
%77 = load i32, i32* %10
%78 = add nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %73, i64 %79
%81 = load double, double* %80
%82 = load double*, double** %7
%83 = load i32, i32* %9
%84 = add nsw i32 %83, 1
%85 = load i32, i32* %6
%86 = mul nsw i32 %84, %85
%87 = load i32, i32* %10
%88 = add nsw i32 %86, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %82, i64 %89
%91 = load double, double* %90
%92 = fadd double %81, %91
%93 = load double*, double** %7
%94 = load i32, i32* %9
%95 = load i32, i32* %6
%96 = mul nsw i32 %94, %95
%97 = load i32, i32* %10
%98 = add nsw i32 %97, 1
%99 = add nsw i32 %96, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %93, i64 %100
%102 = load double, double* %101
%103 = fadd double %92, %102
%104 = load double*, double** %7
%105 = load i32, i32* %9
%106 = load i32, i32* %6
%107 = mul nsw i32 %105, %106
%108 = load i32, i32* %10
%109 = sub nsw i32 %108, 1
%110 = add nsw i32 %107, %109
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %104, i64 %111
%113 = load double, double* %112
%114 = fadd double %103, %113
%115 = fdiv double %114, 4.000000e+00
%116 = load double*, double** %14
%117 = load i32, i32* %9
%118 = load i32, i32* %6
%119 = mul nsw i32 %117, %118
%120 = load i32, i32* %10
%121 = add nsw i32 %119, %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %116, i64 %122
store double %115, double* %123
br label %124
124: ; preds = %72
%125 = load i32, i32* %10
%126 = add nsw i32 %125, 1
store i32 %126, i32* %10
br label %67
127: ; preds = %67
%128 = load double*, double** %8
%129 = load i32, i32* %9
%130 = load i32, i32* %6
%131 = mul nsw i32 %129, %130
%132 = load i32, i32* %6
%133 = sub nsw i32 %132, 1
%134 = add nsw i32 %131, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %128, i64 %135
%137 = load double, double* %136
%138 = load double*, double** %7
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
%141 = load i32, i32* %6
%142 = mul nsw i32 %140, %141
%143 = load i32, i32* %6
%144 = sub nsw i32 %143, 1
%145 = add nsw i32 %142, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %138, i64 %146
%148 = load double, double* %147
%149 = fadd double %137, %148
%150 = load double*, double** %7
%151 = load i32, i32* %9
%152 = load i32, i32* %6
%153 = mul nsw i32 %151, %152
%154 = load i32, i32* %6
%155 = sub nsw i32 %154, 1
%156 = sub nsw i32 %155, 1
%157 = add nsw i32 %153, %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %150, i64 %158
%160 = load double, double* %159
%161 = fadd double %149, %160
%162 = fdiv double %161, 4.000000e+00
%163 = load double*, double** %14
%164 = load i32, i32* %9
%165 = load i32, i32* %6
%166 = mul nsw i32 %164, %165
%167 = load i32, i32* %6
%168 = sub nsw i32 %167, 1
%169 = add nsw i32 %166, %168
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %163, i64 %170
store double %162, double* %171
store i32 1, i32* %9
br label %172
172: ; preds = %351, %127
%173 = load i32, i32* %9
%174 = load i32, i32* %5
%175 = sub nsw i32 %174, 1
%176 = icmp slt i32 %173, %175
br i1 %176, label %177, label %354
177: ; preds = %172
%178 = load double*, double** %8
%179 = load i32, i32* %9
%180 = load i32, i32* %6
%181 = mul nsw i32 %179, %180
%182 = add nsw i32 %181, 0
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %178, i64 %183
%185 = load double, double* %184
%186 = load double*, double** %7
%187 = load i32, i32* %9
%188 = add nsw i32 %187, 1
%189 = load i32, i32* %6
%190 = mul nsw i32 %188, %189
%191 = add nsw i32 %190, 0
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %186, i64 %192
%194 = load double, double* %193
%195 = fadd double %185, %194
%196 = load double*, double** %7
%197 = load i32, i32* %9
%198 = sub nsw i32 %197, 1
%199 = load i32, i32* %6
%200 = mul nsw i32 %198, %199
%201 = add nsw i32 %200, 0
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %196, i64 %202
%204 = load double, double* %203
%205 = fadd double %195, %204
%206 = load double*, double** %7
%207 = load i32, i32* %9
%208 = load i32, i32* %6
%209 = mul nsw i32 %207, %208
%210 = add nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %206, i64 %211
%213 = load double, double* %212
%214 = fadd double %205, %213
%215 = fdiv double %214, 4.000000e+00
%216 = load double*, double** %14
%217 = load i32, i32* %9
%218 = load i32, i32* %6
%219 = mul nsw i32 %217, %218
%220 = add nsw i32 %219, 0
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %216, i64 %221
store double %215, double* %222
store i32 1, i32* %10
br label %223
223: ; preds = %291, %177
%224 = load i32, i32* %10
%225 = load i32, i32* %6
%226 = sub nsw i32 %225, 1
%227 = icmp slt i32 %224, %226
br i1 %227, label %228, label %294
228: ; preds = %223
%229 = load double*, double** %8
%230 = load i32, i32* %9
%231 = load i32, i32* %6
%232 = mul nsw i32 %230, %231
%233 = load i32, i32* %10
%234 = add nsw i32 %232, %233
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %229, i64 %235
%237 = load double, double* %236
%238 = load double*, double** %7
%239 = load i32, i32* %9
%240 = add nsw i32 %239, 1
%241 = load i32, i32* %6
%242 = mul nsw i32 %240, %241
%243 = load i32, i32* %10
%244 = add nsw i32 %242, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %238, i64 %245
%247 = load double, double* %246
%248 = fadd double %237, %247
%249 = load double*, double** %7
%250 = load i32, i32* %9
%251 = sub nsw i32 %250, 1
%252 = load i32, i32* %6
%253 = mul nsw i32 %251, %252
%254 = load i32, i32* %10
%255 = add nsw i32 %253, %254
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %249, i64 %256
%258 = load double, double* %257
%259 = fadd double %248, %258
%260 = load double*, double** %7
%261 = load i32, i32* %9
%262 = load i32, i32* %6
%263 = mul nsw i32 %261, %262
%264 = load i32, i32* %10
%265 = add nsw i32 %264, 1
%266 = add nsw i32 %263, %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %260, i64 %267
%269 = load double, double* %268
%270 = fadd double %259, %269
%271 = load double*, double** %7
%272 = load i32, i32* %9
%273 = load i32, i32* %6
%274 = mul nsw i32 %272, %273
%275 = load i32, i32* %10
%276 = sub nsw i32 %275, 1
%277 = add nsw i32 %274, %276
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %271, i64 %278
%280 = load double, double* %279
%281 = fadd double %270, %280
%282 = fdiv double %281, 4.000000e+00
%283 = load double*, double** %14
%284 = load i32, i32* %9
%285 = load i32, i32* %6
%286 = mul nsw i32 %284, %285
%287 = load i32, i32* %10
%288 = add nsw i32 %286, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %283, i64 %289
store double %282, double* %290
br label %291
291: ; preds = %228
%292 = load i32, i32* %10
%293 = add nsw i32 %292, 1
store i32 %293, i32* %10
br label %223
294: ; preds = %223
%295 = load double*, double** %8
%296 = load i32, i32* %9
%297 = load i32, i32* %6
%298 = mul nsw i32 %296, %297
%299 = load i32, i32* %6
%300 = sub nsw i32 %299, 1
%301 = add nsw i32 %298, %300
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %295, i64 %302
%304 = load double, double* %303
%305 = load double*, double** %7
%306 = load i32, i32* %9
%307 = add nsw i32 %306, 1
%308 = load i32, i32* %6
%309 = mul nsw i32 %307, %308
%310 = load i32, i32* %6
%311 = sub nsw i32 %310, 1
%312 = add nsw i32 %309, %311
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %305, i64 %313
%315 = load double, double* %314
%316 = fadd double %304, %315
%317 = load double*, double** %7
%318 = load i32, i32* %9
%319 = sub nsw i32 %318, 1
%320 = load i32, i32* %6
%321 = mul nsw i32 %319, %320
%322 = load i32, i32* %6
%323 = sub nsw i32 %322, 1
%324 = add nsw i32 %321, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %317, i64 %325
%327 = load double, double* %326
%328 = fadd double %316, %327
%329 = load double*, double** %7
%330 = load i32, i32* %9
%331 = load i32, i32* %6
%332 = mul nsw i32 %330, %331
%333 = load i32, i32* %6
%334 = sub nsw i32 %333, 1
%335 = sub nsw i32 %334, 1
%336 = add nsw i32 %332, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %329, i64 %337
%339 = load double, double* %338
%340 = fadd double %328, %339
%341 = fdiv double %340, 4.000000e+00
%342 = load double*, double** %14
%343 = load i32, i32* %9
%344 = load i32, i32* %6
%345 = mul nsw i32 %343, %344
%346 = load i32, i32* %6
%347 = sub nsw i32 %346, 1
%348 = add nsw i32 %345, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %342, i64 %349
store double %341, double* %350
br label %351
351: ; preds = %294
%352 = load i32, i32* %9
%353 = add nsw i32 %352, 1
store i32 %353, i32* %9
br label %172
354: ; preds = %172
%355 = load i32, i32* %5
%356 = sub nsw i32 %355, 1
store i32 %356, i32* %9
%357 = load double*, double** %8
%358 = load i32, i32* %9
%359 = load i32, i32* %6
%360 = mul nsw i32 %358, %359
%361 = add nsw i32 %360, 0
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %357, i64 %362
%364 = load double, double* %363
%365 = load double*, double** %7
%366 = load i32, i32* %9
%367 = sub nsw i32 %366, 1
%368 = load i32, i32* %6
%369 = mul nsw i32 %367, %368
%370 = add nsw i32 %369, 0
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %365, i64 %371
%373 = load double, double* %372
%374 = fadd double %364, %373
%375 = load double*, double** %7
%376 = load i32, i32* %9
%377 = load i32, i32* %6
%378 = mul nsw i32 %376, %377
%379 = add nsw i32 %378, 1
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %375, i64 %380
%382 = load double, double* %381
%383 = fadd double %374, %382
%384 = fdiv double %383, 4.000000e+00
%385 = load double*, double** %14
%386 = load i32, i32* %9
%387 = load i32, i32* %6
%388 = mul nsw i32 %386, %387
%389 = add nsw i32 %388, 0
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %385, i64 %390
store double %384, double* %391
store i32 1, i32* %10
br label %392
392: ; preds = %449, %354
%393 = load i32, i32* %10
%394 = load i32, i32* %6
%395 = sub nsw i32 %394, 1
%396 = icmp slt i32 %393, %395
br i1 %396, label %397, label %452
397: ; preds = %392
%398 = load double*, double** %8
%399 = load i32, i32* %9
%400 = load i32, i32* %6
%401 = mul nsw i32 %399, %400
%402 = load i32, i32* %10
%403 = add nsw i32 %401, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %398, i64 %404
%406 = load double, double* %405
%407 = load double*, double** %7
%408 = load i32, i32* %9
%409 = sub nsw i32 %408, 1
%410 = load i32, i32* %6
%411 = mul nsw i32 %409, %410
%412 = load i32, i32* %10
%413 = add nsw i32 %411, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %407, i64 %414
%416 = load double, double* %415
%417 = fadd double %406, %416
%418 = load double*, double** %7
%419 = load i32, i32* %9
%420 = load i32, i32* %6
%421 = mul nsw i32 %419, %420
%422 = load i32, i32* %10
%423 = add nsw i32 %422, 1
%424 = add nsw i32 %421, %423
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %418, i64 %425
%427 = load double, double* %426
%428 = fadd double %417, %427
%429 = load double*, double** %7
%430 = load i32, i32* %9
%431 = load i32, i32* %6
%432 = mul nsw i32 %430, %431
%433 = load i32, i32* %10
%434 = sub nsw i32 %433, 1
%435 = add nsw i32 %432, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %429, i64 %436
%438 = load double, double* %437
%439 = fadd double %428, %438
%440 = fdiv double %439, 4.000000e+00
%441 = load double*, double** %14
%442 = load i32, i32* %9
%443 = load i32, i32* %6
%444 = mul nsw i32 %442, %443
%445 = load i32, i32* %10
%446 = add nsw i32 %444, %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %441, i64 %447
store double %440, double* %448
br label %449
449: ; preds = %397
%450 = load i32, i32* %10
%451 = add nsw i32 %450, 1
store i32 %451, i32* %10
br label %392
452: ; preds = %392
%453 = load double*, double** %8
%454 = load i32, i32* %9
%455 = load i32, i32* %6
%456 = mul nsw i32 %454, %455
%457 = load i32, i32* %6
%458 = sub nsw i32 %457, 1
%459 = add nsw i32 %456, %458
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %453, i64 %460
%462 = load double, double* %461
%463 = load double*, double** %7
%464 = load i32, i32* %9
%465 = sub nsw i32 %464, 1
%466 = load i32, i32* %6
%467 = mul nsw i32 %465, %466
%468 = load i32, i32* %6
%469 = sub nsw i32 %468, 1
%470 = add nsw i32 %467, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %463, i64 %471
%473 = load double, double* %472
%474 = fadd double %462, %473
%475 = load double*, double** %7
%476 = load i32, i32* %9
%477 = load i32, i32* %6
%478 = mul nsw i32 %476, %477
%479 = load i32, i32* %6
%480 = sub nsw i32 %479, 1
%481 = sub nsw i32 %480, 1
%482 = add nsw i32 %478, %481
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %475, i64 %483
%485 = load double, double* %484
%486 = fadd double %474, %485
%487 = fdiv double %486, 4.000000e+00
%488 = load double*, double** %14
%489 = load i32, i32* %9
%490 = load i32, i32* %6
%491 = mul nsw i32 %489, %490
%492 = load i32, i32* %6
%493 = sub nsw i32 %492, 1
%494 = add nsw i32 %491, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds double, double* %488, i64 %495
store double %487, double* %496
store double 0.000000e+00, double* %15
store i32 0, i32* %9
br label %497
497: ; preds = %551, %452
%498 = load i32, i32* %9
%499 = load i32, i32* %5
%500 = icmp slt i32 %498, %499
br i1 %500, label %501, label %554
501: ; preds = %497
store i32 0, i32* %10
br label %502
502: ; preds = %547, %501
%503 = load i32, i32* %10
%504 = load i32, i32* %6
%505 = icmp slt i32 %503, %504
br i1 %505, label %506, label %550
506: ; preds = %502
%507 = load double*, double** %7
%508 = load i32, i32* %9
%509 = load i32, i32* %6
%510 = mul nsw i32 %508, %509
%511 = load i32, i32* %10
%512 = add nsw i32 %510, %511
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds double, double* %507, i64 %513
%515 = load double, double* %514
%516 = load double*, double** %14
%517 = load i32, i32* %9
%518 = load i32, i32* %6
%519 = mul nsw i32 %517, %518
%520 = load i32, i32* %10
%521 = add nsw i32 %519, %520
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %516, i64 %522
%524 = load double, double* %523
%525 = fsub double %515, %524
%526 = load double*, double** %7
%527 = load i32, i32* %9
%528 = load i32, i32* %6
%529 = mul nsw i32 %527, %528
%530 = load i32, i32* %10
%531 = add nsw i32 %529, %530
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds double, double* %526, i64 %532
%534 = load double, double* %533
%535 = load double*, double** %14
%536 = load i32, i32* %9
%537 = load i32, i32* %6
%538 = mul nsw i32 %536, %537
%539 = load i32, i32* %10
%540 = add nsw i32 %538, %539
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %535, i64 %541
%543 = load double, double* %542
%544 = fsub double %534, %543
%545 = load double, double* %15
%546 = call double @llvm.fmuladd.f64(double %525, double %544, double %545)
store double %546, double* %15
br label %547
547: ; preds = %506
%548 = load i32, i32* %10
%549 = add nsw i32 %548, 1
store i32 %549, i32* %10
br label %502
550: ; preds = %502
br label %551
551: ; preds = %550
%552 = load i32, i32* %9
%553 = add nsw i32 %552, 1
store i32 %553, i32* %9
br label %497
554: ; preds = %497
%555 = load double, double* %15
%556 = call double @sqrt(double %555)
%557 = load double, double* %16
%558 = fcmp olt double %556, %557
%559 = zext i1 %558 to i32
store i32 %559, i32* %12
%560 = load i32, i32* %11
%561 = load double, double* %15
%562 = call double @sqrt(double %561)
%563 = call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %560, double %562)
%564 = load i32, i32* %11
%565 = add nsw i32 %564, 1
store i32 %565, i32* %11
store i32 0, i32* %9
br label %566
566: ; preds = %597, %554
%567 = load i32, i32* %9
%568 = load i32, i32* %5
%569 = icmp slt i32 %567, %568
br i1 %569, label %570, label %600
570: ; preds = %566
store i32 0, i32* %10
br label %571
571: ; preds = %593, %570
%572 = load i32, i32* %10
%573 = load i32, i32* %6
%574 = icmp slt i32 %572, %573
br i1 %574, label %575, label %596
575: ; preds = %571
%576 = load double*, double** %14
%577 = load i32, i32* %9
%578 = load i32, i32* %6
%579 = mul nsw i32 %577, %578
%580 = load i32, i32* %10
%581 = add nsw i32 %579, %580
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %576, i64 %582
%584 = load double, double* %583
%585 = load double*, double** %7
%586 = load i32, i32* %9
%587 = load i32, i32* %6
%588 = mul nsw i32 %586, %587
%589 = load i32, i32* %10
%590 = add nsw i32 %588, %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %585, i64 %591
store double %584, double* %592
br label %593
593: ; preds = %575
%594 = load i32, i32* %10
%595 = add nsw i32 %594, 1
store i32 %595, i32* %10
br label %571
596: ; preds = %571
br label %597
597: ; preds = %596
%598 = load i32, i32* %9
%599 = add nsw i32 %598, 1
store i32 %599, i32* %9
br label %566
600: ; preds = %566
br label %22
601: ; preds = %29
%602 = load double*, double** %14
%603 = call i32 @free(double* %602)
ret void
}

LLVM IR (-O2):
@.str = [28 x i8] c"Error en iteraci\C3\B3n %d: %g\0A\00"
define void @jacobi_poisson(i32 %0, i32 %1, double* %2, double* nocapture %3) {
%5 = mul nsw i32 %1, %0
%6 = tail call i64 @calloc(i32 %5, i32 8)
%7 = inttoptr i64 %6 to double*
%8 = sext i32 %1 to i64
%9 = getelementptr inbounds double, double* %2, i64 %8
%10 = getelementptr inbounds double, double* %2, i64 1
%11 = add i32 %1, -1
%12 = icmp sgt i32 %1, 2
%13 = sext i32 %11 to i64
%14 = getelementptr inbounds double, double* %3, i64 %13
%15 = add nsw i32 %11, %1
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds double, double* %2, i64 %16
%18 = add nsw i32 %1, -2
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds double, double* %2, i64 %19
%21 = getelementptr inbounds double, double* %7, i64 %13
%22 = add i32 %0, -1
%23 = icmp sgt i32 %0, 2
%24 = mul i32 %22, %1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %3, i64 %25
%27 = add nsw i32 %0, -2
%28 = mul nsw i32 %27, %1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %2, i64 %29
%31 = add nsw i32 %24, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %2, i64 %32
%34 = getelementptr inbounds double, double* %7, i64 %25
%35 = add nsw i32 %24, %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %3, i64 %36
%38 = add nsw i32 %28, %11
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %2, i64 %39
%41 = add nsw i32 %24, %18
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %2, i64 %42
%44 = getelementptr inbounds double, double* %7, i64 %36
%45 = icmp sgt i32 %0, 0
%46 = icmp sgt i32 %1, 0
%47 = zext i32 %11 to i64
%48 = zext i32 %22 to i64
%49 = zext i32 %11 to i64
%50 = zext i32 %11 to i64
%51 = zext i32 %0 to i64
%52 = zext i32 %1 to i64
%53 = zext i32 %0 to i64
%54 = zext i32 %1 to i64
%55 = add nsw i64 %47, -2
%56 = add nsw i64 %25, 1
%57 = getelementptr double, double* %7, i64 %56
%58 = add nsw i64 %25, %47
%59 = getelementptr double, double* %7, i64 %58
%60 = getelementptr double, double* %3, i64 %56
%61 = getelementptr double, double* %3, i64 %58
%62 = getelementptr double, double* %2, i64 %25
%63 = add nsw i64 %25, %47
%64 = add nsw i64 %63, 1
%65 = getelementptr double, double* %2, i64 %64
%66 = add nsw i64 %29, 1
%67 = getelementptr double, double* %2, i64 %66
%68 = add nsw i64 %29, %47
%69 = getelementptr double, double* %2, i64 %68
%70 = add nsw i64 %47, -1
%71 = getelementptr double, double* %7, i64 1
%72 = getelementptr double, double* %7, i64 %47
%73 = getelementptr double, double* %3, i64 1
%74 = getelementptr double, double* %3, i64 %47
%75 = add nuw nsw i64 %47, 1
%76 = getelementptr double, double* %2, i64 %75
%77 = add nsw i64 %8, 1
%78 = getelementptr double, double* %2, i64 %77
%79 = add nsw i64 %8, %47
%80 = getelementptr double, double* %2, i64 %79
%81 = add nsw i64 %47, -1
%82 = and i64 %52, 4294967292
%83 = add nsw i64 %82, -4
%84 = lshr exact i64 %83, 2
%85 = add nuw nsw i64 %84, 1
%86 = icmp ult i64 %81, 4
%87 = icmp ult double* %71, %74
%88 = icmp ult double* %73, %72
%89 = and i1 %87, %88
%90 = icmp ult double* %71, %76
%91 = icmp ugt double* %72, %2
%92 = and i1 %90, %91
%93 = or i1 %89, %92
%94 = icmp ult double* %71, %80
%95 = icmp ult double* %78, %72
%96 = and i1 %94, %95
%97 = or i1 %93, %96
%98 = and i64 %81, -4
%99 = or i64 %98, 1
%100 = icmp eq i64 %81, %98
%101 = and i64 %47, 1
%102 = icmp eq i64 %101, 0
%103 = sub nsw i64 0, %47
%104 = icmp ult i64 %70, 2
%105 = trunc i64 %55 to i32
%106 = add i32 %24, %105
%107 = icmp slt i32 %106, %24
%108 = icmp ugt i64 %55, 4294967295
%109 = or i1 %107, %108
%110 = icmp ult double* %57, %61
%111 = icmp ult double* %60, %59
%112 = and i1 %110, %111
%113 = icmp ult double* %57, %65
%114 = icmp ult double* %62, %59
%115 = and i1 %113, %114
%116 = or i1 %112, %115
%117 = icmp ult double* %57, %69
%118 = icmp ult double* %67, %59
%119 = and i1 %117, %118
%120 = or i1 %116, %119
%121 = and i64 %70, -2
%122 = or i64 %70, 1
%123 = icmp eq i64 %70, %121
%124 = and i64 %52, 1
%125 = icmp eq i32 %1, 1
%126 = and i64 %52, 4294967294
%127 = icmp eq i64 %124, 0
%128 = icmp ult i32 %1, 4
%129 = and i64 %52, 4294967292
%130 = and i64 %85, 3
%131 = icmp ult i64 %83, 12
%132 = and i64 %85, 9223372036854775804
%133 = icmp eq i64 %130, 0
%134 = icmp eq i64 %129, %52
%135 = and i64 %52, 3
%136 = icmp eq i64 %135, 0
br label %140
137: ; preds = %580, %445
%138 = icmp ult i32 %141, 9999
%139 = select i1 %448, i1 %138, i1 false
br i1 %139, label %140, label %583
140: ; preds = %4, %137
%141 = phi i32 [ 0, %4 ], [ %451, %137 ]
%142 = load double, double* %3
%143 = load double, double* %9
%144 = fadd double %142, %143
%145 = load double, double* %10
%146 = fadd double %144, %145
%147 = fmul double %146, 2.500000e-01
store double %147, double* %7
br i1 %12, label %148, label %251
148: ; preds = %140
%149 = select i1 %86, i1 true, i1 %97
br i1 %149, label %194, label %150
150: ; preds = %148, %150
%151 = phi i64 [ %191, %150 ], [ 0, %148 ]
%152 = or i64 %151, 1
%153 = getelementptr inbounds double, double* %3, i64 %152
%154 = bitcast double* %153 to <2 x double>*
%155 = load <2 x double>, <2 x double>* %154
%156 = getelementptr inbounds double, double* %153, i64 2
%157 = bitcast double* %156 to <2 x double>*
%158 = load <2 x double>, <2 x double>* %157
%159 = add nsw i64 %152, %8
%160 = getelementptr inbounds double, double* %2, i64 %159
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = getelementptr inbounds double, double* %160, i64 2
%164 = bitcast double* %163 to <2 x double>*
%165 = load <2 x double>, <2 x double>* %164
%166 = fadd <2 x double> %155, %162
%167 = fadd <2 x double> %158, %165
%168 = or i64 %151, 2
%169 = getelementptr inbounds double, double* %2, i64 %168
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = getelementptr inbounds double, double* %169, i64 2
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = fadd <2 x double> %166, %171
%176 = fadd <2 x double> %167, %174
%177 = getelementptr inbounds double, double* %2, i64 %151
%178 = bitcast double* %177 to <2 x double>*
%179 = load <2 x double>, <2 x double>* %178
%180 = getelementptr inbounds double, double* %177, i64 2
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = fadd <2 x double> %175, %179
%184 = fadd <2 x double> %176, %182
%185 = fmul <2 x double> %183, <double 2.500000e-01, double 2.500000e-01>
%186 = fmul <2 x double> %184, <double 2.500000e-01, double 2.500000e-01>
%187 = getelementptr inbounds double, double* %7, i64 %152
%188 = bitcast double* %187 to <2 x double>*
store <2 x double> %185, <2 x double>* %188
%189 = getelementptr inbounds double, double* %187, i64 2
%190 = bitcast double* %189 to <2 x double>*
store <2 x double> %186, <2 x double>* %190
%191 = add nuw i64 %151, 4
%192 = icmp eq i64 %191, %98
br i1 %192, label %193, label %150
193: ; preds = %150
br i1 %100, label %251, label %194
194: ; preds = %148, %193
%195 = phi i64 [ 1, %148 ], [ %99, %193 ]
%196 = xor i64 %195, -1
br i1 %102, label %197, label %214
197: ; preds = %194
%198 = getelementptr inbounds double, double* %3, i64 %195
%199 = load double, double* %198
%200 = add nsw i64 %195, %8
%201 = getelementptr inbounds double, double* %2, i64 %200
%202 = load double, double* %201
%203 = fadd double %199, %202
%204 = add nuw nsw i64 %195, 1
%205 = getelementptr inbounds double, double* %2, i64 %204
%206 = load double, double* %205
%207 = fadd double %203, %206
%208 = add nsw i64 %195, -1
%209 = getelementptr inbounds double, double* %2, i64 %208
%210 = load double, double* %209
%211 = fadd double %207, %210
%212 = fmul double %211, 2.500000e-01
%213 = getelementptr inbounds double, double* %7, i64 %195
store double %212, double* %213
br label %214
214: ; preds = %197, %194
%215 = phi i64 [ %195, %194 ], [ %204, %197 ]
%216 = icmp eq i64 %196, %103
br i1 %216, label %251, label %217
217: ; preds = %214, %217
%218 = phi i64 [ %241, %217 ], [ %215, %214 ]
%219 = getelementptr inbounds double, double* %3, i64 %218
%220 = load double, double* %219
%221 = add nsw i64 %218, %8
%222 = getelementptr inbounds double, double* %2, i64 %221
%223 = load double, double* %222
%224 = fadd double %220, %223
%225 = add nuw nsw i64 %218, 1
%226 = getelementptr inbounds double, double* %2, i64 %225
%227 = load double, double* %226
%228 = fadd double %224, %227
%229 = add nsw i64 %218, -1
%230 = getelementptr inbounds double, double* %2, i64 %229
%231 = load double, double* %230
%232 = fadd double %228, %231
%233 = fmul double %232, 2.500000e-01
%234 = getelementptr inbounds double, double* %7, i64 %218
store double %233, double* %234
%235 = getelementptr inbounds double, double* %3, i64 %225
%236 = load double, double* %235
%237 = add nsw i64 %225, %8
%238 = getelementptr inbounds double, double* %2, i64 %237
%239 = load double, double* %238
%240 = fadd double %236, %239
%241 = add nuw nsw i64 %218, 2
%242 = getelementptr inbounds double, double* %2, i64 %241
%243 = load double, double* %242
%244 = fadd double %240, %243
%245 = getelementptr inbounds double, double* %2, i64 %218
%246 = load double, double* %245
%247 = fadd double %244, %246
%248 = fmul double %247, 2.500000e-01
%249 = getelementptr inbounds double, double* %7, i64 %225
store double %248, double* %249
%250 = icmp eq i64 %241, %47
br i1 %250, label %251, label %217
251: ; preds = %214, %217, %193, %140
%252 = load double, double* %14
%253 = load double, double* %17
%254 = fadd double %252, %253
%255 = load double, double* %20
%256 = fadd double %254, %255
%257 = fmul double %256, 2.500000e-01
store double %257, double* %21
br i1 %23, label %258, label %326
258: ; preds = %251, %307
%259 = phi i64 [ %263, %307 ], [ 1, %251 ]
%260 = mul nsw i64 %259, %8
%261 = getelementptr inbounds double, double* %3, i64 %260
%262 = load double, double* %261
%263 = add nuw nsw i64 %259, 1
%264 = mul nsw i64 %263, %8
%265 = getelementptr inbounds double, double* %2, i64 %264
%266 = load double, double* %265
%267 = fadd double %262, %266
%268 = add nsw i64 %259, -1
%269 = mul nsw i64 %268, %8
%270 = getelementptr inbounds double, double* %2, i64 %269
%271 = load double, double* %270
%272 = fadd double %267, %271
%273 = add nsw i64 %260, 1
%274 = getelementptr inbounds double, double* %2, i64 %273
%275 = load double, double* %274
%276 = fadd double %272, %275
%277 = fmul double %276, 2.500000e-01
%278 = getelementptr inbounds double, double* %7, i64 %260
store double %277, double* %278
br i1 %12, label %279, label %307
279: ; preds = %258, %279
%280 = phi i64 [ %292, %279 ], [ 1, %258 ]
%281 = add nsw i64 %280, %260
%282 = getelementptr inbounds double, double* %3, i64 %281
%283 = load double, double* %282
%284 = add nsw i64 %280, %264
%285 = getelementptr inbounds double, double* %2, i64 %284
%286 = load double, double* %285
%287 = fadd double %283, %286
%288 = add nsw i64 %280, %269
%289 = getelementptr inbounds double, double* %2, i64 %288
%290 = load double, double* %289
%291 = fadd double %287, %290
%292 = add nuw nsw i64 %280, 1
%293 = add nsw i64 %292, %260
%294 = getelementptr inbounds double, double* %2, i64 %293
%295 = load double, double* %294
%296 = fadd double %291, %295
%297 = add i64 %280, %260
%298 = shl i64 %297, 32
%299 = add i64 %298, -4294967296
%300 = ashr exact i64 %299, 32
%301 = getelementptr inbounds double, double* %2, i64 %300
%302 = load double, double* %301
%303 = fadd double %296, %302
%304 = fmul double %303, 2.500000e-01
%305 = getelementptr inbounds double, double* %7, i64 %281
store double %304, double* %305
%306 = icmp eq i64 %292, %49
br i1 %306, label %307, label %279
307: ; preds = %279, %258
%308 = add nsw i64 %260, %13
%309 = getelementptr inbounds double, double* %3, i64 %308
%310 = load double, double* %309
%311 = add nsw i64 %264, %13
%312 = getelementptr inbounds double, double* %2, i64 %311
%313 = load double, double* %312
%314 = fadd double %310, %313
%315 = add nsw i64 %269, %13
%316 = getelementptr inbounds double, double* %2, i64 %315
%317 = load double, double* %316
%318 = fadd double %314, %317
%319 = add nsw i64 %260, %19
%320 = getelementptr inbounds double, double* %2, i64 %319
%321 = load double, double* %320
%322 = fadd double %318, %321
%323 = fmul double %322, 2.500000e-01
%324 = getelementptr inbounds double, double* %7, i64 %308
store double %323, double* %324
%325 = icmp eq i64 %263, %48
br i1 %325, label %326, label %258
326: ; preds = %307, %251
%327 = load double, double* %26
%328 = load double, double* %30
%329 = fadd double %327, %328
%330 = load double, double* %33
%331 = fadd double %329, %330
%332 = fmul double %331, 2.500000e-01
store double %332, double* %34
br i1 %12, label %333, label %395
333: ; preds = %326
%334 = select i1 %104, i1 true, i1 %109
%335 = select i1 %334, i1 true, i1 %120
br i1 %335, label %369, label %336
336: ; preds = %333, %336
%337 = phi i64 [ %366, %336 ], [ 0, %333 ]
%338 = or i64 %337, 1
%339 = trunc i64 %337 to i32
%340 = or i32 %339, 1
%341 = add nsw i64 %338, %25
%342 = getelementptr inbounds double, double* %3, i64 %341
%343 = bitcast double* %342 to <2 x double>*
%344 = load <2 x double>, <2 x double>* %343
%345 = add nsw i64 %338, %29
%346 = getelementptr inbounds double, double* %2, i64 %345
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = fadd <2 x double> %344, %348
%350 = add i64 %337, 2
%351 = add nsw i64 %350, %25
%352 = getelementptr inbounds double, double* %2, i64 %351
%353 = bitcast double* %352 to <2 x double>*
%354 = load <2 x double>, <2 x double>* %353
%355 = fadd <2 x double> %349, %354
%356 = add i32 %24, %340
%357 = add i32 %356, -1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %2, i64 %358
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = fadd <2 x double> %355, %361
%363 = fmul <2 x double> %362, <double 2.500000e-01, double 2.500000e-01>
%364 = getelementptr inbounds double, double* %7, i64 %341
%365 = bitcast double* %364 to <2 x double>*
store <2 x double> %363, <2 x double>* %365
%366 = add nuw i64 %337, 2
%367 = icmp eq i64 %366, %121
br i1 %367, label %368, label %336
368: ; preds = %336
br i1 %123, label %395, label %369
369: ; preds = %333, %368
%370 = phi i64 [ 1, %333 ], [ %122, %368 ]
br label %371
371: ; preds = %369, %371
%372 = phi i64 [ %381, %371 ], [ %370, %369 ]
%373 = trunc i64 %372 to i32
%374 = add nsw i64 %372, %25
%375 = getelementptr inbounds double, double* %3, i64 %374
%376 = load double, double* %375
%377 = add nsw i64 %372, %29
%378 = getelementptr inbounds double, double* %2, i64 %377
%379 = load double, double* %378
%380 = fadd double %376, %379
%381 = add nuw nsw i64 %372, 1
%382 = add nsw i64 %381, %25
%383 = getelementptr inbounds double, double* %2, i64 %382
%384 = load double, double* %383
%385 = fadd double %380, %384
%386 = add i32 %24, %373
%387 = add i32 %386, -1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %2, i64 %388
%390 = load double, double* %389
%391 = fadd double %385, %390
%392 = fmul double %391, 2.500000e-01
%393 = getelementptr inbounds double, double* %7, i64 %374
store double %392, double* %393
%394 = icmp eq i64 %381, %50
br i1 %394, label %395, label %371
395: ; preds = %371, %368, %326
%396 = load double, double* %37
%397 = load double, double* %40
%398 = fadd double %396, %397
%399 = load double, double* %43
%400 = fadd double %398, %399
%401 = fmul double %400, 2.500000e-01
store double %401, double* %44
br i1 %45, label %402, label %445
402: ; preds = %395, %441
%403 = phi i64 [ %443, %441 ], [ 0, %395 ]
%404 = phi double [ %442, %441 ], [ 0.000000e+00, %395 ]
br i1 %46, label %405, label %441
405: ; preds = %402
%406 = mul nsw i64 %403, %8
br i1 %125, label %429, label %407
407: ; preds = %405, %407
%408 = phi i64 [ %426, %407 ], [ 0, %405 ]
%409 = phi double [ %425, %407 ], [ %404, %405 ]
%410 = phi i64 [ %427, %407 ], [ 0, %405 ]
%411 = add nsw i64 %408, %406
%412 = getelementptr inbounds double, double* %2, i64 %411
%413 = load double, double* %412
%414 = getelementptr inbounds double, double* %7, i64 %411
%415 = load double, double* %414
%416 = fsub double %413, %415
%417 = tail call double @llvm.fmuladd.f64(double %416, double %416, double %409)
%418 = or i64 %408, 1
%419 = add nsw i64 %418, %406
%420 = getelementptr inbounds double, double* %2, i64 %419
%421 = load double, double* %420
%422 = getelementptr inbounds double, double* %7, i64 %419
%423 = load double, double* %422
%424 = fsub double %421, %423
%425 = tail call double @llvm.fmuladd.f64(double %424, double %424, double %417)
%426 = add nuw nsw i64 %408, 2
%427 = add i64 %410, 2
%428 = icmp eq i64 %427, %126
br i1 %428, label %429, label %407
429: ; preds = %407, %405
%430 = phi double [ undef, %405 ], [ %425, %407 ]
%431 = phi i64 [ 0, %405 ], [ %426, %407 ]
%432 = phi double [ %404, %405 ], [ %425, %407 ]
br i1 %127, label %441, label %433
433: ; preds = %429
%434 = add nsw i64 %431, %406
%435 = getelementptr inbounds double, double* %2, i64 %434
%436 = load double, double* %435
%437 = getelementptr inbounds double, double* %7, i64 %434
%438 = load double, double* %437
%439 = fsub double %436, %438
%440 = tail call double @llvm.fmuladd.f64(double %439, double %439, double %432)
br label %441
441: ; preds = %433, %429, %402
%442 = phi double [ %404, %402 ], [ %430, %429 ], [ %440, %433 ]
%443 = add nuw nsw i64 %403, 1
%444 = icmp eq i64 %443, %51
br i1 %444, label %445, label %402
445: ; preds = %441, %395
%446 = phi double [ 0.000000e+00, %395 ], [ %442, %441 ]
%447 = tail call double @sqrt(double %446)
%448 = fcmp uge double %447, 0x3EB0C6F7A0B5ED8D
%449 = tail call double @sqrt(double %446)
%450 = tail call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %141, double %449)
%451 = add nuw nsw i32 %141, 1
br i1 %45, label %452, label %137
452: ; preds = %445, %580
%453 = phi i64 [ %581, %580 ], [ 0, %445 ]
%454 = mul i64 %453, %8
%455 = getelementptr double, double* %2, i64 %454
%456 = add i64 %454, %52
%457 = getelementptr double, double* %2, i64 %456
%458 = getelementptr double, double* %7, i64 %454
%459 = getelementptr double, double* %7, i64 %456
br i1 %46, label %460, label %580
460: ; preds = %452
%461 = mul nsw i64 %453, %8
br i1 %128, label %540, label %462
462: ; preds = %460
%463 = icmp ult double* %455, %459
%464 = icmp ult double* %458, %457
%465 = and i1 %463, %464
br i1 %465, label %540, label %466
466: ; preds = %462
br i1 %131, label %520, label %467
467: ; preds = %466, %467
%468 = phi i64 [ %517, %467 ], [ 0, %466 ]
%469 = phi i64 [ %518, %467 ], [ 0, %466 ]
%470 = add nsw i64 %468, %461
%471 = getelementptr inbounds double, double* %7, i64 %470
%472 = bitcast double* %471 to <2 x double>*
%473 = load <2 x double>, <2 x double>* %472
%474 = getelementptr inbounds double, double* %471, i64 2
%475 = bitcast double* %474 to <2 x double>*
%476 = load <2 x double>, <2 x double>* %475
%477 = getelementptr inbounds double, double* %2, i64 %470
%478 = bitcast double* %477 to <2 x double>*
store <2 x double> %473, <2 x double>* %478
%479 = getelementptr inbounds double, double* %477, i64 2
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %476, <2 x double>* %480
%481 = or i64 %468, 4
%482 = add nsw i64 %481, %461
%483 = getelementptr inbounds double, double* %7, i64 %482
%484 = bitcast double* %483 to <2 x double>*
%485 = load <2 x double>, <2 x double>* %484
%486 = getelementptr inbounds double, double* %483, i64 2
%487 = bitcast double* %486 to <2 x double>*
%488 = load <2 x double>, <2 x double>* %487
%489 = getelementptr inbounds double, double* %2, i64 %482
%490 = bitcast double* %489 to <2 x double>*
store <2 x double> %485, <2 x double>* %490
%491 = getelementptr inbounds double, double* %489, i64 2
%492 = bitcast double* %491 to <2 x double>*
store <2 x double> %488, <2 x double>* %492
%493 = or i64 %468, 8
%494 = add nsw i64 %493, %461
%495 = getelementptr inbounds double, double* %7, i64 %494
%496 = bitcast double* %495 to <2 x double>*
%497 = load <2 x double>, <2 x double>* %496
%498 = getelementptr inbounds double, double* %495, i64 2
%499 = bitcast double* %498 to <2 x double>*
%500 = load <2 x double>, <2 x double>* %499
%501 = getelementptr inbounds double, double* %2, i64 %494
%502 = bitcast double* %501 to <2 x double>*
store <2 x double> %497, <2 x double>* %502
%503 = getelementptr inbounds double, double* %501, i64 2
%504 = bitcast double* %503 to <2 x double>*
store <2 x double> %500, <2 x double>* %504
%505 = or i64 %468, 12
%506 = add nsw i64 %505, %461
%507 = getelementptr inbounds double, double* %7, i64 %506
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = getelementptr inbounds double, double* %507, i64 2
%511 = bitcast double* %510 to <2 x double>*
%512 = load <2 x double>, <2 x double>* %511
%513 = getelementptr inbounds double, double* %2, i64 %506
%514 = bitcast double* %513 to <2 x double>*
store <2 x double> %509, <2 x double>* %514
%515 = getelementptr inbounds double, double* %513, i64 2
%516 = bitcast double* %515 to <2 x double>*
store <2 x double> %512, <2 x double>* %516
%517 = add nuw i64 %468, 16
%518 = add nuw i64 %469, 4
%519 = icmp eq i64 %518, %132
br i1 %519, label %520, label %467
520: ; preds = %467, %466
%521 = phi i64 [ 0, %466 ], [ %517, %467 ]
br i1 %133, label %539, label %522
522: ; preds = %520, %522
%523 = phi i64 [ %536, %522 ], [ %521, %520 ]
%524 = phi i64 [ %537, %522 ], [ 0, %520 ]
%525 = add nsw i64 %523, %461
%526 = getelementptr inbounds double, double* %7, i64 %525
%527 = bitcast double* %526 to <2 x double>*
%528 = load <2 x double>, <2 x double>* %527
%529 = getelementptr inbounds double, double* %526, i64 2
%530 = bitcast double* %529 to <2 x double>*
%531 = load <2 x double>, <2 x double>* %530
%532 = getelementptr inbounds double, double* %2, i64 %525
%533 = bitcast double* %532 to <2 x double>*
store <2 x double> %528, <2 x double>* %533
%534 = getelementptr inbounds double, double* %532, i64 2
%535 = bitcast double* %534 to <2 x double>*
store <2 x double> %531, <2 x double>* %535
%536 = add nuw i64 %523, 4
%537 = add i64 %524, 1
%538 = icmp eq i64 %537, %130
br i1 %538, label %539, label %522
539: ; preds = %522, %520
br i1 %134, label %580, label %540
540: ; preds = %462, %460, %539
%541 = phi i64 [ 0, %462 ], [ 0, %460 ], [ %129, %539 ]
%542 = xor i64 %541, -1
%543 = add nsw i64 %542, %52
br i1 %136, label %554, label %544
544: ; preds = %540, %544
%545 = phi i64 [ %551, %544 ], [ %541, %540 ]
%546 = phi i64 [ %552, %544 ], [ 0, %540 ]
%547 = add nsw i64 %545, %461
%548 = getelementptr inbounds double, double* %7, i64 %547
%549 = load double, double* %548
%550 = getelementptr inbounds double, double* %2, i64 %547
store double %549, double* %550
%551 = add nuw nsw i64 %545, 1
%552 = add i64 %546, 1
%553 = icmp eq i64 %552, %135
br i1 %553, label %554, label %544
554: ; preds = %544, %540
%555 = phi i64 [ %541, %540 ], [ %551, %544 ]
%556 = icmp ult i64 %543, 3
br i1 %556, label %580, label %557
557: ; preds = %554, %557
%558 = phi i64 [ %578, %557 ], [ %555, %554 ]
%559 = add nsw i64 %558, %461
%560 = getelementptr inbounds double, double* %7, i64 %559
%561 = load double, double* %560
%562 = getelementptr inbounds double, double* %2, i64 %559
store double %561, double* %562
%563 = add nuw nsw i64 %558, 1
%564 = add nsw i64 %563, %461
%565 = getelementptr inbounds double, double* %7, i64 %564
%566 = load double, double* %565
%567 = getelementptr inbounds double, double* %2, i64 %564
store double %566, double* %567
%568 = add nuw nsw i64 %558, 2
%569 = add nsw i64 %568, %461
%570 = getelementptr inbounds double, double* %7, i64 %569
%571 = load double, double* %570
%572 = getelementptr inbounds double, double* %2, i64 %569
store double %571, double* %572
%573 = add nuw nsw i64 %558, 3
%574 = add nsw i64 %573, %461
%575 = getelementptr inbounds double, double* %7, i64 %574
%576 = load double, double* %575
%577 = getelementptr inbounds double, double* %2, i64 %574
store double %576, double* %577
%578 = add nuw nsw i64 %558, 4
%579 = icmp eq i64 %578, %54
br i1 %579, label %580, label %557
580: ; preds = %554, %557, %539, %452
%581 = add nuw nsw i64 %453, 1
%582 = icmp eq i64 %581, %53
br i1 %582, label %137, label %452
583: ; preds = %137
%584 = tail call i32 @free(double* %7)
ret void
}