#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 maxit, double tol) {
  int i, j, k, conv;
  double *t, s;
  t = (double *)calloc(N * M, sizeof(double));
  k = 0;
  conv = 0;
  while (!conv && k < maxit) {
    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;
    }
    s = 0.0;
    for (i = 1; i < N - 1; i++) {
      for (j = 1; j < M - 1; 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 = 1; i < N - 1; i++) {
      for (j = 1; j < M - 1; 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)
mov    %r8d,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x4(%rbp),%edi
imul   -0x8(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x49(%rbp)
jne    119d <jacobi_poisson+0x5d>
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    11ad <jacobi_poisson+0x6d>
jmp    1543 <jacobi_poisson+0x403>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13b5 <jacobi_poisson+0x275>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%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    -0x2c(%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    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xdd5(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    130b <jacobi_poisson+0x1cb>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xd1d(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    124c <jacobi_poisson+0x10c>
mov    -0x18(%rbp),%rax
mov    -0x2c(%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    -0x2c(%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    -0x2c(%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    -0x2c(%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  0xc78(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%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    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b4 <jacobi_poisson+0x74>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1478 <jacobi_poisson+0x338>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1465 <jacobi_poisson+0x325>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13dc <jacobi_poisson+0x29c>
jmp    146a <jacobi_poisson+0x32a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13c4 <jacobi_poisson+0x284>
movsd  -0x48(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
call   1060 <sqrt@plt>
mov    -0x50(%rbp),%esi
lea    0xb55(%rip),%rdi
call   1040 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    153e <jacobi_poisson+0x3fe>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    152b <jacobi_poisson+0x3eb>
mov    -0x40(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14e0 <jacobi_poisson+0x3a0>
jmp    1530 <jacobi_poisson+0x3f0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c8 <jacobi_poisson+0x388>
jmp    1182 <jacobi_poisson+0x42>
mov    -0x40(%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    $0x118,%rsp
movsd  %xmm0,0xc8(%rsp)
mov    %r8d,%r15d
mov    %rcx,%r12
mov    %rdx,%r14
mov    %esi,%ebx
mov    %edi,%eax
mov    %esi,%edi
mov    %rax,0x20(%rsp)
imul   %eax,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%r9
test   %r15d,%r15d
jle    180c <jacobi_poisson+0x6cc>
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x50(%rsp)
lea    -0x1(%rbx),%ebp
lea    -0x2(%rbx),%eax
movslq %ebx,%rcx
movslq %ebp,%rdx
mov    %rdx,0x108(%rsp)
cltq
mov    %rax,0x100(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0xf8(%rsp)
lea    (%rcx,%rbp,1),%rax
mov    %rax,0xf0(%rsp)
lea    -0x1(%rbp),%rdx
lea    -0x5(%rbp),%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rsi,%rax
mov    %rsi,0xe0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xc0(%rsp)
mov    %rcx,%rax
shl    $0x20,%rax
mov    %rax,0x68(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
add    %r14,%rax
add    $0x8,%rax
mov    %rax,0xb0(%rsp)
mov    %rdx,%rax
mov    %rdx,0x40(%rsp)
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    %rdx,0xa8(%rsp)
movsd  0xdbc(%rip),%xmm2
mov    %rdi,0xd8(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xd0(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x48(%rsp)
lea    0x8(%r12,%rcx,8),%rax
mov    %rax,0xa0(%rsp)
lea    0x8(%r9,%rcx,8),%rax
mov    %rax,0x60(%rsp)
lea    -0x8(,%rbp,8),%r13
ff
lea    0x10(%r14,%rcx,8),%rax
mov    %rax,0x98(%rsp)
lea    0x8(%r14,%rcx,8),%rax
mov    %rax,0x70(%rsp)
lea    0x38(%r14,%rcx,8),%rax
mov    %rax,0x90(%rsp)
lea    0x38(%r9,%rcx,8),%rax
mov    %rax,0x88(%rsp)
lea    (%r14,%rcx,8),%rax
mov    %rax,0x80(%rsp)
mov    %rcx,0x28(%rsp)
lea    (%r9,%rcx,8),%rax
mov    %rax,0x78(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    %rbx,0x38(%rsp)
mov    %r9,0x10(%rsp)
mov    %r15d,0x5c(%rsp)
mov    %r12,0x110(%rsp)
mov    %rbp,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm3,%xmm3
cmpl   $0x3,0x20(%rsp)
jl     1550 <jacobi_poisson+0x410>
mov    $0x1,%r11d
mov    0x98(%rsp),%rax
mov    0x60(%rsp),%rcx
mov    0xa0(%rsp),%rdx
mov    0xb0(%rsp),%rsi
mov    %r14,%rdi
mov    0x68(%rsp),%r15
jmp    13b2 <jacobi_poisson+0x272>
nopl   0x0(%rax)
mov    0x108(%rsp),%rbp
lea    (%r8,%rbp,1),%rbx
mov    0x110(%rsp),%r12
movsd  (%r12,%rbx,8),%xmm0
add    %rbp,%r10
addsd  (%r14,%r10,8),%xmm0
add    %rbp,%r11
addsd  (%r14,%r11,8),%xmm0
add    0x100(%rsp),%r8
addsd  (%r14,%r8,8),%xmm0
mulsd  %xmm2,%xmm0
mov    0x10(%rsp),%r9
movsd  %xmm0,(%r9,%rbx,8)
add    0x68(%rsp),%r15
mov    0x48(%rsp),%rbp
add    %rbp,%rdi
add    %rbp,%rsi
add    %rbp,%rdx
add    %rbp,%rcx
add    %rbp,%rax
mov    0x18(%rsp),%r11
cmp    0x50(%rsp),%r11
je     1450 <jacobi_poisson+0x310>
mov    %r11,%r8
mov    0x28(%rsp),%rbx
imul   %rbx,%r8
lea    0x1(%r11),%r10
mov    %r10,0x18(%rsp)
imul   %rbx,%r10
add    $0xffffffffffffffff,%r11
imul   %rbx,%r11
movsd  (%r12,%r8,8),%xmm0
addsd  (%r14,%r10,8),%xmm0
addsd  (%r14,%r11,8),%xmm0
addsd  0x8(%r14,%r8,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r9,%r8,8)
cmp    $0x3,%ebx
movabs $0x100000000,%rbp
jl     1340 <jacobi_poisson+0x200>
xor    %ebx,%ebx
mov    %r15,%r12
xchg   %ax,%ax
movsd  (%rdx,%rbx,1),%xmm0
addsd  (%rsi,%rbx,1),%xmm0
addsd  0x8(%rdi,%rbx,1),%xmm0
addsd  (%rax,%rbx,1),%xmm0
mov    %r12,%r9
sar    $0x1d,%r9
addsd  (%r14,%r9,1),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
add    %rbp,%r12
add    $0x8,%rbx
cmp    %rbx,%r13
jne    1410 <jacobi_poisson+0x2d0>
jmp    1340 <jacobi_poisson+0x200>
nopl   0x0(%rax)
xorpd  %xmm3,%xmm3
cmpl   $0x3,0x20(%rsp)
mov    0x5c(%rsp),%r15d
mov    0x38(%rsp),%rbp
mov    0xa8(%rsp),%rbx
jl     1550 <jacobi_poisson+0x410>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
mov    0x60(%rsp),%rcx
mov    0x70(%rsp),%rdx
jmp    14aa <jacobi_poisson+0x36a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
mov    0x48(%rsp),%rsi
add    %rsi,%rdx
add    %rsi,%rcx
cmp    0x50(%rsp),%rax
je     1550 <jacobi_poisson+0x410>
cmp    $0x3,%ebp
jl     1490 <jacobi_poisson+0x350>
mov    $0x1,%esi
cmpl   $0x2,0x8(%rsp)
jne    14d0 <jacobi_poisson+0x390>
movapd %xmm3,%xmm0
jmp    151c <jacobi_poisson+0x3dc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdx,%rsi,8),%xmm1
movsd  (%rdx,%rsi,8),%xmm0
subsd  -0x8(%rcx,%rsi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
subsd  (%rcx,%rsi,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
lea    (%rbx,%rsi,1),%rdi
add    $0x2,%rdi
add    $0x2,%rsi
movapd %xmm0,%xmm3
cmp    $0x1,%rdi
jne    14e0 <jacobi_poisson+0x3a0>
movapd %xmm0,%xmm3
testb  $0x1,0x40(%rsp)
je     1490 <jacobi_poisson+0x350>
mov    %rax,%rdi
imul   0x28(%rsp),%rdi
add    %rdi,%rsi
movsd  (%r14,%rsi,8),%xmm3
subsd  (%r9,%rsi,8),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
jmp    1490 <jacobi_poisson+0x350>
xorps  %xmm1,%xmm1
sqrtsd %xmm3,%xmm1
ucomisd 0xaa9(%rip),%xmm3
movapd %xmm1,%xmm0
jae    158c <jacobi_poisson+0x44c>
movapd %xmm3,%xmm0
movsd  %xmm3,0x18(%rsp)
movsd  %xmm1,0xb8(%rsp)
call   1060 <sqrt@plt>
movsd  0xb8(%rsp),%xmm1
movsd  0x18(%rsp),%xmm3
movsd  %xmm0,0x18(%rsp)
ucomisd 0xa6e(%rip),%xmm3
jae    15a9 <jacobi_poisson+0x469>
movapd %xmm3,%xmm0
call   1060 <sqrt@plt>
movapd %xmm0,%xmm1
lea    0xa60(%rip),%rdi
mov    0x30(%rsp),%rsi
movapd %xmm1,%xmm0
call   1040 <printf@plt>
cmpl   $0x3,0x20(%rsp)
mov    0x38(%rsp),%r10
mov    0x8(%rsp),%rbp
movsd  0xa2b(%rip),%xmm2
jl     17e0 <jacobi_poisson+0x6a0>
mov    $0x1,%r9d
mov    0x78(%rsp),%rcx
mov    0x80(%rsp),%rdx
mov    0x88(%rsp),%rsi
mov    0x90(%rsp),%rdi
xor    %r8d,%r8d
jmp    1634 <jacobi_poisson+0x4f4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    $0x1,%r8
mov    0x48(%rsp),%rax
add    %rax,%rdi
add    %rax,%rsi
add    %rax,%rdx
add    %rax,%rcx
cmp    0x50(%rsp),%r9
je     17e0 <jacobi_poisson+0x6a0>
cmp    $0x3,%r10d
jl     1610 <jacobi_poisson+0x4d0>
mov    $0x1,%ebx
cmpq   $0x4,0x40(%rsp)
jb     1750 <jacobi_poisson+0x610>
mov    %r8,%rax
imul   0x28(%rsp),%rax
mov    0xf8(%rsp),%rbp
lea    (%rax,%rbp,1),%r11
add    0xf0(%rsp),%rax
lea    (%r14,%r11,8),%r10
mov    0x10(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%rbp
cmp    %rbp,%r10
mov    0x38(%rsp),%r10
jae    169c <jacobi_poisson+0x55c>
lea    (%r14,%rax,8),%rax
mov    0x10(%rsp),%rbp
lea    0x0(%rbp,%r11,8),%rbp
cmp    %rax,%rbp
mov    0x8(%rsp),%rbp
jb     1750 <jacobi_poisson+0x610>
cmpq   $0x4,0xe8(%rsp)
jae    16ab <jacobi_poisson+0x56b>
xor    %ebp,%ebp
jmp    16f4 <jacobi_poisson+0x5b4>
mov    0xc0(%rsp),%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rsi,%rbp,8),%xmm0
movups -0x20(%rsi,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdi,%rbp,8)
movups %xmm1,-0x20(%rdi,%rbp,8)
movupd -0x10(%rsi,%rbp,8),%xmm0
movupd (%rsi,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rdi,%rbp,8)
movupd %xmm1,(%rdi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    16c0 <jacobi_poisson+0x580>
testb  $0x1,0xe0(%rsp)
01
je     172b <jacobi_poisson+0x5eb>
mov    %r9,%rax
imul   0x28(%rsp),%rax
or     $0x1,%rbp
add    %rax,%rbp
mov    0x10(%rsp),%rax
movupd (%rax,%rbp,8),%xmm0
movupd 0x10(%rax,%rbp,8),%xmm1
movupd %xmm0,(%r14,%rbp,8)
movupd %xmm1,0x10(%r14,%rbp,8)
mov    0xd0(%rsp),%rbx
mov    0xd8(%rsp),%rax
cmp    %rax,0x40(%rsp)
mov    0x8(%rsp),%rbp
je     1610 <jacobi_poisson+0x4d0>
nopl   0x0(%rax,%rax,1)
mov    %ebp,%eax
sub    %ebx,%eax
mov    %rbp,%r11
mov    %rbx,%rbp
not    %rbp
add    %r11,%rbp
and    $0x3,%rax
je     1784 <jacobi_poisson+0x644>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1770 <jacobi_poisson+0x630>
cmp    $0x3,%rbp
mov    0x8(%rsp),%rbp
jb     1610 <jacobi_poisson+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
movsd  0x8(%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rbx,8)
movsd  0x10(%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rbx,8)
movsd  0x18(%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    17a0 <jacobi_poisson+0x660>
jmp    1610 <jacobi_poisson+0x4d0>
nopl   0x0(%rax)
movsd  0xc8(%rsp),%xmm0
ucomisd 0x18(%rsp),%xmm0
mov    0x10(%rsp),%r9
ja     180c <jacobi_poisson+0x6cc>
mov    0x30(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x30(%rsp)
cmp    %r15d,%eax
jl     1300 <jacobi_poisson+0x1c0>
mov    %r9,%rdi
add    $0x118,%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, i32 %4, double %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca double
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double*
%18 = alloca double
store i32 %0, i32* %7
store i32 %1, i32* %8
store double* %2, double** %9
store double* %3, double** %10
store i32 %4, i32* %11
store double %5, double* %12
%19 = load i32, i32* %7
%20 = load i32, i32* %8
%21 = mul nsw i32 %19, %20
%22 = call i64 @calloc(i32 %21, i32 8)
%23 = inttoptr i64 %22 to double*
store double* %23, double** %17
store i32 0, i32* %15
store i32 0, i32* %16
br label %24
24: ; preds = %324, %6
%25 = load i32, i32* %16
%26 = icmp ne i32 %25, 0
br i1 %26, label %31, label %27
27: ; preds = %24
%28 = load i32, i32* %15
%29 = load i32, i32* %11
%30 = icmp slt i32 %28, %29
br label %31
31: ; preds = %27, %24
%32 = phi i1 [ false, %24 ], [ %30, %27 ]
br i1 %32, label %33, label %325
33: ; preds = %31
store i32 1, i32* %13
br label %34
34: ; preds = %213, %33
%35 = load i32, i32* %13
%36 = load i32, i32* %7
%37 = sub nsw i32 %36, 1
%38 = icmp slt i32 %35, %37
br i1 %38, label %39, label %216
39: ; preds = %34
%40 = load double*, double** %10
%41 = load i32, i32* %13
%42 = load i32, i32* %8
%43 = mul nsw i32 %41, %42
%44 = add nsw i32 %43, 0
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %40, i64 %45
%47 = load double, double* %46
%48 = load double*, double** %9
%49 = load i32, i32* %13
%50 = add nsw i32 %49, 1
%51 = load i32, i32* %8
%52 = mul nsw i32 %50, %51
%53 = add nsw i32 %52, 0
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %48, i64 %54
%56 = load double, double* %55
%57 = fadd double %47, %56
%58 = load double*, double** %9
%59 = load i32, i32* %13
%60 = sub nsw i32 %59, 1
%61 = load i32, i32* %8
%62 = mul nsw i32 %60, %61
%63 = add nsw i32 %62, 0
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %58, i64 %64
%66 = load double, double* %65
%67 = fadd double %57, %66
%68 = load double*, double** %9
%69 = load i32, i32* %13
%70 = load i32, i32* %8
%71 = mul nsw i32 %69, %70
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %68, i64 %73
%75 = load double, double* %74
%76 = fadd double %67, %75
%77 = fdiv double %76, 4.000000e+00
%78 = load double*, double** %17
%79 = load i32, i32* %13
%80 = load i32, i32* %8
%81 = mul nsw i32 %79, %80
%82 = add nsw i32 %81, 0
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %78, i64 %83
store double %77, double* %84
store i32 1, i32* %14
br label %85
85: ; preds = %153, %39
%86 = load i32, i32* %14
%87 = load i32, i32* %8
%88 = sub nsw i32 %87, 1
%89 = icmp slt i32 %86, %88
br i1 %89, label %90, label %156
90: ; preds = %85
%91 = load double*, double** %10
%92 = load i32, i32* %13
%93 = load i32, i32* %8
%94 = mul nsw i32 %92, %93
%95 = load i32, i32* %14
%96 = add nsw i32 %94, %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %91, i64 %97
%99 = load double, double* %98
%100 = load double*, double** %9
%101 = load i32, i32* %13
%102 = add nsw i32 %101, 1
%103 = load i32, i32* %8
%104 = mul nsw i32 %102, %103
%105 = load i32, i32* %14
%106 = add nsw i32 %104, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %100, i64 %107
%109 = load double, double* %108
%110 = fadd double %99, %109
%111 = load double*, double** %9
%112 = load i32, i32* %13
%113 = sub nsw i32 %112, 1
%114 = load i32, i32* %8
%115 = mul nsw i32 %113, %114
%116 = load i32, i32* %14
%117 = add nsw i32 %115, %116
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %111, i64 %118
%120 = load double, double* %119
%121 = fadd double %110, %120
%122 = load double*, double** %9
%123 = load i32, i32* %13
%124 = load i32, i32* %8
%125 = mul nsw i32 %123, %124
%126 = load i32, i32* %14
%127 = add nsw i32 %126, 1
%128 = add nsw i32 %125, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %122, i64 %129
%131 = load double, double* %130
%132 = fadd double %121, %131
%133 = load double*, double** %9
%134 = load i32, i32* %13
%135 = load i32, i32* %8
%136 = mul nsw i32 %134, %135
%137 = load i32, i32* %14
%138 = sub nsw i32 %137, 1
%139 = add nsw i32 %136, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %133, i64 %140
%142 = load double, double* %141
%143 = fadd double %132, %142
%144 = fdiv double %143, 4.000000e+00
%145 = load double*, double** %17
%146 = load i32, i32* %13
%147 = load i32, i32* %8
%148 = mul nsw i32 %146, %147
%149 = load i32, i32* %14
%150 = add nsw i32 %148, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %145, i64 %151
store double %144, double* %152
br label %153
153: ; preds = %90
%154 = load i32, i32* %14
%155 = add nsw i32 %154, 1
store i32 %155, i32* %14
br label %85
156: ; preds = %85
%157 = load double*, double** %10
%158 = load i32, i32* %13
%159 = load i32, i32* %8
%160 = mul nsw i32 %158, %159
%161 = load i32, i32* %8
%162 = sub nsw i32 %161, 1
%163 = add nsw i32 %160, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %157, i64 %164
%166 = load double, double* %165
%167 = load double*, double** %9
%168 = load i32, i32* %13
%169 = add nsw i32 %168, 1
%170 = load i32, i32* %8
%171 = mul nsw i32 %169, %170
%172 = load i32, i32* %8
%173 = sub nsw i32 %172, 1
%174 = add nsw i32 %171, %173
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %167, i64 %175
%177 = load double, double* %176
%178 = fadd double %166, %177
%179 = load double*, double** %9
%180 = load i32, i32* %13
%181 = sub nsw i32 %180, 1
%182 = load i32, i32* %8
%183 = mul nsw i32 %181, %182
%184 = load i32, i32* %8
%185 = sub nsw i32 %184, 1
%186 = add nsw i32 %183, %185
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %179, i64 %187
%189 = load double, double* %188
%190 = fadd double %178, %189
%191 = load double*, double** %9
%192 = load i32, i32* %13
%193 = load i32, i32* %8
%194 = mul nsw i32 %192, %193
%195 = load i32, i32* %8
%196 = sub nsw i32 %195, 1
%197 = sub nsw i32 %196, 1
%198 = add nsw i32 %194, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %191, i64 %199
%201 = load double, double* %200
%202 = fadd double %190, %201
%203 = fdiv double %202, 4.000000e+00
%204 = load double*, double** %17
%205 = load i32, i32* %13
%206 = load i32, i32* %8
%207 = mul nsw i32 %205, %206
%208 = load i32, i32* %8
%209 = sub nsw i32 %208, 1
%210 = add nsw i32 %207, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %204, i64 %211
store double %203, double* %212
br label %213
213: ; preds = %156
%214 = load i32, i32* %13
%215 = add nsw i32 %214, 1
store i32 %215, i32* %13
br label %34
216: ; preds = %34
store double 0.000000e+00, double* %18
store i32 1, i32* %13
br label %217
217: ; preds = %273, %216
%218 = load i32, i32* %13
%219 = load i32, i32* %7
%220 = sub nsw i32 %219, 1
%221 = icmp slt i32 %218, %220
br i1 %221, label %222, label %276
222: ; preds = %217
store i32 1, i32* %14
br label %223
223: ; preds = %269, %222
%224 = load i32, i32* %14
%225 = load i32, i32* %8
%226 = sub nsw i32 %225, 1
%227 = icmp slt i32 %224, %226
br i1 %227, label %228, label %272
228: ; preds = %223
%229 = load double*, double** %9
%230 = load i32, i32* %13
%231 = load i32, i32* %8
%232 = mul nsw i32 %230, %231
%233 = load i32, i32* %14
%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** %17
%239 = load i32, i32* %13
%240 = load i32, i32* %8
%241 = mul nsw i32 %239, %240
%242 = load i32, i32* %14
%243 = add nsw i32 %241, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double, double* %238, i64 %244
%246 = load double, double* %245
%247 = fsub double %237, %246
%248 = load double*, double** %9
%249 = load i32, i32* %13
%250 = load i32, i32* %8
%251 = mul nsw i32 %249, %250
%252 = load i32, i32* %14
%253 = add nsw i32 %251, %252
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %248, i64 %254
%256 = load double, double* %255
%257 = load double*, double** %17
%258 = load i32, i32* %13
%259 = load i32, i32* %8
%260 = mul nsw i32 %258, %259
%261 = load i32, i32* %14
%262 = add nsw i32 %260, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %257, i64 %263
%265 = load double, double* %264
%266 = fsub double %256, %265
%267 = load double, double* %18
%268 = call double @llvm.fmuladd.f64(double %247, double %266, double %267)
store double %268, double* %18
br label %269
269: ; preds = %228
%270 = load i32, i32* %14
%271 = add nsw i32 %270, 1
store i32 %271, i32* %14
br label %223
272: ; preds = %223
br label %273
273: ; preds = %272
%274 = load i32, i32* %13
%275 = add nsw i32 %274, 1
store i32 %275, i32* %13
br label %217
276: ; preds = %217
%277 = load double, double* %18
%278 = call double @sqrt(double %277)
%279 = load double, double* %12
%280 = fcmp olt double %278, %279
%281 = zext i1 %280 to i32
store i32 %281, i32* %16
%282 = load i32, i32* %15
%283 = load double, double* %18
%284 = call double @sqrt(double %283)
%285 = call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %282, double %284)
%286 = load i32, i32* %15
%287 = add nsw i32 %286, 1
store i32 %287, i32* %15
store i32 1, i32* %13
br label %288
288: ; preds = %321, %276
%289 = load i32, i32* %13
%290 = load i32, i32* %7
%291 = sub nsw i32 %290, 1
%292 = icmp slt i32 %289, %291
br i1 %292, label %293, label %324
293: ; preds = %288
store i32 1, i32* %14
br label %294
294: ; preds = %317, %293
%295 = load i32, i32* %14
%296 = load i32, i32* %8
%297 = sub nsw i32 %296, 1
%298 = icmp slt i32 %295, %297
br i1 %298, label %299, label %320
299: ; preds = %294
%300 = load double*, double** %17
%301 = load i32, i32* %13
%302 = load i32, i32* %8
%303 = mul nsw i32 %301, %302
%304 = load i32, i32* %14
%305 = add nsw i32 %303, %304
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %300, i64 %306
%308 = load double, double* %307
%309 = load double*, double** %9
%310 = load i32, i32* %13
%311 = load i32, i32* %8
%312 = mul nsw i32 %310, %311
%313 = load i32, i32* %14
%314 = add nsw i32 %312, %313
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %309, i64 %315
store double %308, double* %316
br label %317
317: ; preds = %299
%318 = load i32, i32* %14
%319 = add nsw i32 %318, 1
store i32 %319, i32* %14
br label %294
320: ; preds = %294
br label %321
321: ; preds = %320
%322 = load i32, i32* %13
%323 = add nsw i32 %322, 1
store i32 %323, i32* %13
br label %288
324: ; preds = %288
br label %24
325: ; preds = %31
%326 = load double*, double** %17
%327 = call i32 @free(double* %326)
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* nocapture %2, double* nocapture %3, i32 %4, double %5) {
%7 = mul nsw i32 %1, %0
%8 = tail call i64 @calloc(i32 %7, i32 8)
%9 = inttoptr i64 %8 to double*
%10 = icmp sgt i32 %4, 0
br i1 %10, label %11, label %278
11: ; preds = %6
%12 = add i32 %0, -1
%13 = icmp sgt i32 %0, 2
%14 = add i32 %1, -1
%15 = icmp sgt i32 %1, 2
%16 = add nsw i32 %1, -2
%17 = sext i32 %1 to i64
%18 = sext i32 %14 to i64
%19 = sext i32 %16 to i64
%20 = zext i32 %12 to i64
%21 = zext i32 %14 to i64
%22 = zext i32 %12 to i64
%23 = zext i32 %12 to i64
%24 = zext i32 %14 to i64
%25 = add nsw i64 %17, 1
%26 = add nsw i64 %17, %21
%27 = add nsw i64 %21, -1
%28 = add nsw i64 %21, -1
%29 = add nsw i64 %21, -5
%30 = lshr i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %28, 1
%33 = icmp eq i32 %14, 2
%34 = and i64 %28, -2
%35 = icmp eq i64 %32, 0
%36 = icmp ult i64 %27, 4
%37 = and i64 %27, -4
%38 = or i64 %37, 1
%39 = and i64 %31, 1
%40 = icmp ult i64 %29, 4
%41 = and i64 %31, 9223372036854775806
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %27, %37
br label %47
44: ; preds = %274, %161
%45 = icmp slt i32 %167, %4
%46 = select i1 %164, i1 %45, i1 false
br i1 %46, label %47, label %278
47: ; preds = %11, %44
%48 = phi i32 [ 0, %11 ], [ %167, %44 ]
br i1 %13, label %50, label %161
49: ; preds = %99
br i1 %13, label %118, label %161
50: ; preds = %47, %99
%51 = phi i64 [ %55, %99 ], [ 1, %47 ]
%52 = mul nsw i64 %51, %17
%53 = getelementptr inbounds double, double* %3, i64 %52
%54 = load double, double* %53
%55 = add nuw nsw i64 %51, 1
%56 = mul nsw i64 %55, %17
%57 = getelementptr inbounds double, double* %2, i64 %56
%58 = load double, double* %57
%59 = fadd double %54, %58
%60 = add nsw i64 %51, -1
%61 = mul nsw i64 %60, %17
%62 = getelementptr inbounds double, double* %2, i64 %61
%63 = load double, double* %62
%64 = fadd double %59, %63
%65 = add nsw i64 %52, 1
%66 = getelementptr inbounds double, double* %2, i64 %65
%67 = load double, double* %66
%68 = fadd double %64, %67
%69 = fmul double %68, 2.500000e-01
%70 = getelementptr inbounds double, double* %9, i64 %52
store double %69, double* %70
br i1 %15, label %71, label %99
71: ; preds = %50, %71
%72 = phi i64 [ %84, %71 ], [ 1, %50 ]
%73 = add nsw i64 %72, %52
%74 = getelementptr inbounds double, double* %3, i64 %73
%75 = load double, double* %74
%76 = add nsw i64 %72, %56
%77 = getelementptr inbounds double, double* %2, i64 %76
%78 = load double, double* %77
%79 = fadd double %75, %78
%80 = add nsw i64 %72, %61
%81 = getelementptr inbounds double, double* %2, i64 %80
%82 = load double, double* %81
%83 = fadd double %79, %82
%84 = add nuw nsw i64 %72, 1
%85 = add nsw i64 %84, %52
%86 = getelementptr inbounds double, double* %2, i64 %85
%87 = load double, double* %86
%88 = fadd double %83, %87
%89 = add i64 %72, %52
%90 = shl i64 %89, 32
%91 = add i64 %90, -4294967296
%92 = ashr exact i64 %91, 32
%93 = getelementptr inbounds double, double* %2, i64 %92
%94 = load double, double* %93
%95 = fadd double %88, %94
%96 = fmul double %95, 2.500000e-01
%97 = getelementptr inbounds double, double* %9, i64 %73
store double %96, double* %97
%98 = icmp eq i64 %84, %21
br i1 %98, label %99, label %71
99: ; preds = %71, %50
%100 = add nsw i64 %52, %18
%101 = getelementptr inbounds double, double* %3, i64 %100
%102 = load double, double* %101
%103 = add nsw i64 %56, %18
%104 = getelementptr inbounds double, double* %2, i64 %103
%105 = load double, double* %104
%106 = fadd double %102, %105
%107 = add nsw i64 %61, %18
%108 = getelementptr inbounds double, double* %2, i64 %107
%109 = load double, double* %108
%110 = fadd double %106, %109
%111 = add nsw i64 %52, %19
%112 = getelementptr inbounds double, double* %2, i64 %111
%113 = load double, double* %112
%114 = fadd double %110, %113
%115 = fmul double %114, 2.500000e-01
%116 = getelementptr inbounds double, double* %9, i64 %100
store double %115, double* %116
%117 = icmp eq i64 %55, %20
br i1 %117, label %49, label %50
118: ; preds = %49, %157
%119 = phi i64 [ %159, %157 ], [ 1, %49 ]
%120 = phi double [ %158, %157 ], [ 0.000000e+00, %49 ]
br i1 %15, label %121, label %157
121: ; preds = %118
%122 = mul nsw i64 %119, %17
br i1 %33, label %145, label %123
123: ; preds = %121, %123
%124 = phi i64 [ %142, %123 ], [ 1, %121 ]
%125 = phi double [ %141, %123 ], [ %120, %121 ]
%126 = phi i64 [ %143, %123 ], [ 0, %121 ]
%127 = add nsw i64 %124, %122
%128 = getelementptr inbounds double, double* %2, i64 %127
%129 = load double, double* %128
%130 = getelementptr inbounds double, double* %9, i64 %127
%131 = load double, double* %130
%132 = fsub double %129, %131
%133 = tail call double @llvm.fmuladd.f64(double %132, double %132, double %125)
%134 = add nuw nsw i64 %124, 1
%135 = add nsw i64 %134, %122
%136 = getelementptr inbounds double, double* %2, i64 %135
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %9, i64 %135
%139 = load double, double* %138
%140 = fsub double %137, %139
%141 = tail call double @llvm.fmuladd.f64(double %140, double %140, double %133)
%142 = add nuw nsw i64 %124, 2
%143 = add i64 %126, 2
%144 = icmp eq i64 %143, %34
br i1 %144, label %145, label %123
145: ; preds = %123, %121
%146 = phi double [ undef, %121 ], [ %141, %123 ]
%147 = phi i64 [ 1, %121 ], [ %142, %123 ]
%148 = phi double [ %120, %121 ], [ %141, %123 ]
br i1 %35, label %157, label %149
149: ; preds = %145
%150 = add nsw i64 %147, %122
%151 = getelementptr inbounds double, double* %2, i64 %150
%152 = load double, double* %151
%153 = getelementptr inbounds double, double* %9, i64 %150
%154 = load double, double* %153
%155 = fsub double %152, %154
%156 = tail call double @llvm.fmuladd.f64(double %155, double %155, double %148)
br label %157
157: ; preds = %149, %145, %118
%158 = phi double [ %120, %118 ], [ %146, %145 ], [ %156, %149 ]
%159 = add nuw nsw i64 %119, 1
%160 = icmp eq i64 %159, %22
br i1 %160, label %161, label %118
161: ; preds = %157, %47, %49
%162 = phi double [ 0.000000e+00, %49 ], [ 0.000000e+00, %47 ], [ %158, %157 ]
%163 = tail call double @sqrt(double %162)
%164 = fcmp uge double %163, %5
%165 = tail call double @sqrt(double %162)
%166 = tail call i32 @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i32 %48, double %165)
%167 = add nuw nsw i32 %48, 1
br i1 %13, label %168, label %44
168: ; preds = %161, %274
%169 = phi i64 [ %277, %274 ], [ 0, %161 ]
%170 = phi i64 [ %275, %274 ], [ 1, %161 ]
%171 = mul i64 %169, %17
%172 = add i64 %25, %171
%173 = getelementptr double, double* %2, i64 %172
%174 = add i64 %26, %171
%175 = getelementptr double, double* %2, i64 %174
%176 = getelementptr double, double* %9, i64 %172
%177 = getelementptr double, double* %9, i64 %174
br i1 %15, label %178, label %274
178: ; preds = %168
%179 = mul nsw i64 %170, %17
br i1 %36, label %231, label %180
180: ; preds = %178
%181 = icmp ult double* %173, %177
%182 = icmp ult double* %176, %175
%183 = and i1 %181, %182
br i1 %183, label %231, label %184
184: ; preds = %180
br i1 %40, label %215, label %185
185: ; preds = %184, %185
%186 = phi i64 [ %212, %185 ], [ 0, %184 ]
%187 = phi i64 [ %213, %185 ], [ 0, %184 ]
%188 = or i64 %186, 1
%189 = add nsw i64 %188, %179
%190 = getelementptr inbounds double, double* %9, i64 %189
%191 = bitcast double* %190 to <2 x double>*
%192 = load <2 x double>, <2 x double>* %191
%193 = getelementptr inbounds double, double* %190, i64 2
%194 = bitcast double* %193 to <2 x double>*
%195 = load <2 x double>, <2 x double>* %194
%196 = getelementptr inbounds double, double* %2, i64 %189
%197 = bitcast double* %196 to <2 x double>*
store <2 x double> %192, <2 x double>* %197
%198 = getelementptr inbounds double, double* %196, i64 2
%199 = bitcast double* %198 to <2 x double>*
store <2 x double> %195, <2 x double>* %199
%200 = or i64 %186, 5
%201 = add nsw i64 %200, %179
%202 = getelementptr inbounds double, double* %9, i64 %201
%203 = bitcast double* %202 to <2 x double>*
%204 = load <2 x double>, <2 x double>* %203
%205 = getelementptr inbounds double, double* %202, i64 2
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %2, i64 %201
%209 = bitcast double* %208 to <2 x double>*
store <2 x double> %204, <2 x double>* %209
%210 = getelementptr inbounds double, double* %208, i64 2
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> %207, <2 x double>* %211
%212 = add nuw i64 %186, 8
%213 = add i64 %187, 2
%214 = icmp eq i64 %213, %41
br i1 %214, label %215, label %185
215: ; preds = %185, %184
%216 = phi i64 [ 0, %184 ], [ %212, %185 ]
br i1 %42, label %230, label %217
217: ; preds = %215
%218 = or i64 %216, 1
%219 = add nsw i64 %218, %179
%220 = getelementptr inbounds double, double* %9, i64 %219
%221 = bitcast double* %220 to <2 x double>*
%222 = load <2 x double>, <2 x double>* %221
%223 = getelementptr inbounds double, double* %220, i64 2
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = getelementptr inbounds double, double* %2, i64 %219
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> %222, <2 x double>* %227
%228 = getelementptr inbounds double, double* %226, i64 2
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> %225, <2 x double>* %229
br label %230
230: ; preds = %215, %217
br i1 %43, label %274, label %231
231: ; preds = %180, %178, %230
%232 = phi i64 [ 1, %180 ], [ 1, %178 ], [ %38, %230 ]
%233 = sub nsw i64 %21, %232
%234 = xor i64 %232, -1
%235 = add nsw i64 %234, %21
%236 = and i64 %233, 3
%237 = icmp eq i64 %236, 0
br i1 %237, label %248, label %238
238: ; preds = %231, %238
%239 = phi i64 [ %245, %238 ], [ %232, %231 ]
%240 = phi i64 [ %246, %238 ], [ 0, %231 ]
%241 = add nsw i64 %239, %179
%242 = getelementptr inbounds double, double* %9, i64 %241
%243 = load double, double* %242
%244 = getelementptr inbounds double, double* %2, i64 %241
store double %243, double* %244
%245 = add nuw nsw i64 %239, 1
%246 = add i64 %240, 1
%247 = icmp eq i64 %246, %236
br i1 %247, label %248, label %238
248: ; preds = %238, %231
%249 = phi i64 [ %232, %231 ], [ %245, %238 ]
%250 = icmp ult i64 %235, 3
br i1 %250, label %274, label %251
251: ; preds = %248, %251
%252 = phi i64 [ %272, %251 ], [ %249, %248 ]
%253 = add nsw i64 %252, %179
%254 = getelementptr inbounds double, double* %9, i64 %253
%255 = load double, double* %254
%256 = getelementptr inbounds double, double* %2, i64 %253
store double %255, double* %256
%257 = add nuw nsw i64 %252, 1
%258 = add nsw i64 %257, %179
%259 = getelementptr inbounds double, double* %9, i64 %258
%260 = load double, double* %259
%261 = getelementptr inbounds double, double* %2, i64 %258
store double %260, double* %261
%262 = add nuw nsw i64 %252, 2
%263 = add nsw i64 %262, %179
%264 = getelementptr inbounds double, double* %9, i64 %263
%265 = load double, double* %264
%266 = getelementptr inbounds double, double* %2, i64 %263
store double %265, double* %266
%267 = add nuw nsw i64 %252, 3
%268 = add nsw i64 %267, %179
%269 = getelementptr inbounds double, double* %9, i64 %268
%270 = load double, double* %269
%271 = getelementptr inbounds double, double* %2, i64 %268
store double %270, double* %271
%272 = add nuw nsw i64 %252, 4
%273 = icmp eq i64 %272, %24
br i1 %273, label %274, label %251
274: ; preds = %248, %251, %230, %168
%275 = add nuw nsw i64 %170, 1
%276 = icmp eq i64 %275, %23
%277 = add i64 %169, 1
br i1 %276, label %44, label %168
278: ; preds = %44, %6
%279 = tail call i32 @free(double* %9)
ret void
}