#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void gaujor(double a[], int l, int m, int n, double eps) {
  int c, i, iw, j, k, kp1, mm1, r, s, t, u, v, *work, x;
  double api, pivot, w, wmax;
  if (l < n || m < 2 || m >= n || eps <= 0.) {
    fprintf(stderr, "Error : Illegal parameter in gaujor()\n");
    return;
  }
  work = (int *)malloc(m * sizeof(int));
  if (work == NULL) {
    fprintf(stderr, "Error : Out of memory  in gaujor()\n");
    return;
  }
  for (i = 0; i < m; i++)
    work[i] = i;
  for (k = 0; k < m; k++) {
    x = k * l;
    wmax = 0.;
    for (i = 0; i < m; i++) {
      s = i * l;
      for (j = k; j < m; j++) {
        w = fabs(a[s + j]);
        if (w > wmax) {
          wmax = w;
          r = i;
          c = j;
        }
      }
    }
    s = r * l;
    pivot = a[s + c];
    api = fabs(pivot);
    if (api < eps) {
      fprintf(stderr, "Error : api < eps  in gaujor()\n");
      free(work);
      return;
    }
    if (c != k) {
      iw = work[k];
      work[k] = work[c];
      work[c] = iw;
      for (i = 0; i < m; i++) {
        t = i * l;
        u = t + k;
        v = t + c;
        w = a[u];
        a[u] = a[v];
        a[v] = w;
      }
    }
    if (r != k) {
      for (j = k; j < n; j++) {
        t = s + j;
        u = x + j;
        w = a[t];
        a[t] = a[u];
        a[u] = w;
      }
    }
    kp1 = k + 1;
    for (i = kp1; i < n; i++)
      a[x + i] /= pivot;
    for (i = 0; i < m; i++) {
      t = i * l;
      if (i != k) {
        w = a[t + k];
        for (j = kp1; j < n; j++)
          a[t + j] -= w * a[x + j];
      }
    }
  }
  mm1 = m - 1;
  for (i = 0; i < mm1; i++) {
    for (;;) {
      k = work[i];
      if (k == i)
        break;
      iw = work[k];
      work[k] = work[i];
      work[i] = iw;
      s = k * l;
      t = i * l;
      for (j = m; j < n; j++) {
        u = s + j;
        v = t + j;
        w = a[u];
        a[u] = a[v];
        a[v] = w;
      }
    }
  }
  free(work);
  return;
}


x86 assembly (clang, -O0):
<gaujor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     117d <gaujor+0x4d>
cmpl   $0x2,-0x10(%rbp)
jl     117d <gaujor+0x4d>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    117d <gaujor+0x4d>
xorps  %xmm0,%xmm0
ucomisd -0x20(%rbp),%xmm0
jb     1197 <gaujor+0x67>
mov    0x2e5c(%rip),%rax
mov    (%rax),%edi
lea    0xe83(%rip),%rsi
call   1040 <fprintf@plt>
jmp    16a4 <gaujor+0x574>
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    11cf <gaujor+0x9f>
mov    0x2e24(%rip),%rax
mov    (%rax),%edi
lea    0xe72(%rip),%rsi
call   1040 <fprintf@plt>
jmp    16a4 <gaujor+0x574>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11fe <gaujor+0xce>
mov    -0x28(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11d6 <gaujor+0xa6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    158d <gaujor+0x45d>
mov    -0x34(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12c0 <gaujor+0x190>
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12ad <gaujor+0x17d>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xd95(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    129a <gaujor+0x16a>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    129f <gaujor+0x16f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1246 <gaujor+0x116>
jmp    12b2 <gaujor+0x182>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    122a <gaujor+0xfa>
mov    -0x40(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0xd13(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    132d <gaujor+0x1fd>
mov    0x2ccf(%rip),%rax
mov    (%rax),%edi
lea    0xd41(%rip),%rsi
call   1040 <fprintf@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
jmp    16a4 <gaujor+0x574>
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     13eb <gaujor+0x2bb>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13e6 <gaujor+0x2b6>
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1372 <gaujor+0x242>
jmp    13eb <gaujor+0x2bb>
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     146c <gaujor+0x33c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1467 <gaujor+0x337>
mov    -0x44(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13fd <gaujor+0x2cd>
jmp    146c <gaujor+0x33c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14b5 <gaujor+0x385>
movsd  -0x70(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    147b <gaujor+0x34b>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    157a <gaujor+0x44a>
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     1567 <gaujor+0x437>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1562 <gaujor+0x432>
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14fb <gaujor+0x3cb>
jmp    1567 <gaujor+0x437>
jmp    156c <gaujor+0x43c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14bc <gaujor+0x38c>
jmp    157f <gaujor+0x44f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1205 <gaujor+0xd5>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    169b <gaujor+0x56b>
jmp    15ae <gaujor+0x47e>
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    15cd <gaujor+0x49d>
jmp    1688 <gaujor+0x558>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1683 <gaujor+0x553>
mov    -0x44(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1619 <gaujor+0x4e9>
jmp    15ae <gaujor+0x47e>
jmp    168d <gaujor+0x55d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    159d <gaujor+0x46d>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gaujor>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %esi,0x14(%rsp)
cmp    $0x2,%edx
jl     1198 <gaujor+0x68>
mov    %ecx,%ebx
cmp    %ecx,0x14(%rsp)
jl     1198 <gaujor+0x68>
mov    %edx,%ebp
cmp    %ebx,%edx
jge    1198 <gaujor+0x68>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    1198 <gaujor+0x68>
movsd  %xmm0,0x20(%rsp)
mov    %rdi,(%rsp)
lea    0x0(,%rbp,4),%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     11be <gaujor+0x8e>
mov    %ebp,%r10d
cmp    $0x8,%ebp
mov    %rbp,0x50(%rsp)
jae    11d0 <gaujor+0xa0>
xor    %ecx,%ecx
movsd  0x20(%rsp),%xmm8
jmp    1320 <gaujor+0x1f0>
mov    0x2e41(%rip),%rax
mov    (%rax),%edi
lea    0xf08(%rip),%rsi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fprintf@plt>
mov    0x2e1b(%rip),%rax
mov    (%rax),%edi
lea    0xf09(%rip),%rsi
jmp    11a8 <gaujor+0x78>
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    11ff <gaujor+0xcf>
movdqa 0xe08(%rip),%xmm0
xor    %edi,%edi
jmp    12c8 <gaujor+0x198>
and    $0xfffffffffffffffc,%rsi
movdqa 0xdf5(%rip),%xmm0
xor    %edi,%edi
movdqa 0xdfa(%rip),%xmm8
movdqa 0xe01(%rip),%xmm9
movdqa 0xe08(%rip),%xmm10
movdqa 0xe10(%rip),%xmm4
movdqa 0xe18(%rip),%xmm5
movdqa 0xe20(%rip),%xmm6
movdqa 0xe28(%rip),%xmm7
movdqa 0xe30(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm2,0x10(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rdi,4)
movdqu %xmm3,0x30(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rdi,4)
movdqu %xmm3,0x50(%rax,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rdi,4)
movdqu %xmm3,0x70(%rax,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1250 <gaujor+0x120>
test   %rdx,%rdx
je     1310 <gaujor+0x1e0>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd2d(%rip),%xmm1
movdqa 0xd35(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12f0 <gaujor+0x1c0>
cmp    %r10,%rcx
movsd  0x20(%rsp),%xmm8
je     132c <gaujor+0x1fc>
nopl   0x0(%rax)
mov    %ecx,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1320 <gaujor+0x1f0>
mov    %rax,0x60(%rsp)
movslq 0x14(%rsp),%rax
movslq %ebx,%rcx
mov    %rcx,0x28(%rsp)
mov    %ebx,0x9c(%rsp)
mov    %ebx,%ebx
mov    (%rsp),%rsi
lea    0x8(%rsi),%rcx
lea    0x0(,%rax,8),%rdx
mov    %rdx,0x20(%rsp)
lea    0x8(,%rax,8),%r8
lea    -0x1(%rbx),%rdx
mov    %r10d,%edi
and    $0xfffffffe,%edi
mov    %rdi,0xe0(%rsp)
mov    %rbx,%rdi
neg    %rdi
mov    %rdi,0x90(%rsp)
mov    %rax,%rdi
shl    $0x4,%rdi
mov    %rdi,0xd8(%rsp)
mov    %rax,0x38(%rsp)
lea    (%rsi,%rax,8),%rdi
lea    0x30(%rsi),%rax
mov    %rax,0xa8(%rsp)
lea    -0x4(%rbx),%rax
lea    0x10(%rsi),%rbp
mov    %rbp,0xa0(%rsp)
lea    0x18(%rsi),%r9
movapd 0xccc(%rip),%xmm0
movapd 0xcd4(%rip),%xmm1
mov    %rbx,0x18(%rsp)
lea    -0x3(%rbx),%r14
mov    $0x1,%ebx
mov    %rbx,0x8(%rsp)
xor    %r11d,%r11d
mov    %rdx,0xb8(%rsp)
mov    %rdx,%rbx
mov    %rax,%rdx
mov    %rbx,%rax
mov    %rsi,%rbx
mov    %r9,%r15
mov    %rcx,0x30(%rsp)
mov    %rcx,%rbp
mov    %rsi,%r12
mov    %r8,0xf0(%rsp)
jmp    14a8 <gaujor+0x378>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addq   $0x1,0x8(%rsp)
mov    0xc0(%rsp),%r12
add    $0x8,%r12
mov    0xc8(%rsp),%rdi
add    $0x8,%rdi
mov    0xf0(%rsp),%r8
add    %r8,0xa8(%rsp)
mov    0x130(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
addq   $0x8,0xa0(%rsp)
mov    0x20(%rsp),%rax
mov    0x58(%rsp),%rbp
add    %rax,%rbp
add    %r8,%r15
mov    0x120(%rsp),%r14
add    $0xffffffffffffffff,%r14
add    %rax,%rbx
mov    0x128(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0xd0(%rsp),%r9
add    $0x8,%r9
mov    0x78(%rsp),%r11
cmp    %r10,%r11
je     1bda <gaujor+0xaaa>
mov    %rbp,0x58(%rsp)
mov    %rdi,0xc8(%rsp)
mov    %rax,0x128(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x138(%rsp)
mov    %r14,%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x108(%rsp)
mov    %rdx,0x130(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x88(%rsp)
mov    0xb8(%rsp),%rax
sub    %r11,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x78(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0xb0(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,%rdx
sub    %r11,%rdx
lea    -0x4(%rdx),%rdi
mov    %rdi,0xf8(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,0x100(%rsp)
mov    %rdx,0x48(%rsp)
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,0x118(%rsp)
mov    %r8,%rbp
imul   %r11,%rbp
lea    (%rsi,%rbp,1),%rdx
mov    %rdx,0x110(%rsp)
mov    %r11,%rdi
imul   0x38(%rsp),%rdi
mov    %rdi,%rdx
mov    %rdi,0x68(%rsp)
lea    (%rdi,%rax,1),%rdx
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,0x70(%rsp)
mov    %r11,%rdx
not    %rdx
add    %rax,%rdx
mov    %rdx,0x40(%rsp)
add    0x30(%rsp),%rbp
mov    %rbp,0x140(%rsp)
pxor   %xmm2,%xmm2
mov    %r12,0xc0(%rsp)
mov    %r11,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12,%rdx
mov    %rax,%rsi
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm2,%xmm3
movsd  (%rdx),%xmm2
andpd  %xmm0,%xmm2
ucomisd %xmm3,%xmm2
cmova  %edi,%ecx
cmova  %esi,%r13d
maxsd  %xmm3,%xmm2
add    $0x1,%rsi
add    $0x8,%rdx
cmp    %rsi,%r10
jne    15d0 <gaujor+0x4a0>
add    $0x1,%rdi
add    0x20(%rsp),%r12
cmp    %r10,%rdi
jne    15c0 <gaujor+0x490>
mov    %ecx,%r11d
imul   0x14(%rsp),%r11d
lea    (%r11,%r13,1),%edx
movslq %edx,%rdx
mov    (%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm3,%xmm8
ja     1bbb <gaujor+0xa8b>
mov    %r11,0x80(%rsp)
mov    %r13d,%edx
cmp    %rdx,%rax
mov    0x48(%rsp),%r11
mov    %r9,0xd0(%rsp)
mov    %r14,0x120(%rsp)
je     1742 <gaujor+0x612>
mov    0x60(%rsp),%rdi
mov    (%rdi,%rax,4),%edx
movslq %r13d,%rbp
mov    (%rdi,%rbp,4),%esi
mov    %esi,(%rdi,%rax,4)
mov    %edx,(%rdi,%rbp,4)
cmpl   $0x1,0x50(%rsp)
mov    %rbp,0xe8(%rsp)
jne    1690 <gaujor+0x560>
xor    %edi,%edi
jmp    170a <gaujor+0x5da>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x38(%rsp),%rdx
add    %rbp,%rdx
mov    (%rsp),%rdi
lea    (%rdi,%rdx,8),%rsi
lea    (%rdi,%rbp,8),%rbp
xor    %edx,%edx
xor    %edi,%edi
mov    0xe0(%rsp),%r8
mov    0xd8(%rsp),%r9
mov    0xc8(%rsp),%r14
mov    0xc0(%rsp),%r12
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,1),%xmm3
movsd  0x0(%rbp,%rdx,1),%xmm4
movsd  %xmm4,(%r12,%rdx,1)
movsd  %xmm3,0x0(%rbp,%rdx,1)
movsd  (%r14,%rdx,1),%xmm3
movq   (%rsi,%rdx,1),%xmm4
movq   %xmm4,(%r14,%rdx,1)
movsd  %xmm3,(%rsi,%rdx,1)
add    $0x2,%rdi
add    %r9,%rdx
cmp    %rdi,%r8
jne    16d0 <gaujor+0x5a0>
test   $0x1,%r10b
mov    0xd0(%rsp),%r9
je     1742 <gaujor+0x612>
imul   0x38(%rsp),%rdi
lea    (%rdi,%rax,1),%rdx
add    0xe8(%rsp),%rdi
mov    (%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm3
movq   (%rsi,%rdi,8),%xmm4
movq   %xmm4,(%rsi,%rdx,8)
movsd  %xmm3,(%rsi,%rdi,8)
mov    %ecx,%edx
cmp    %rdx,%rax
mov    0x58(%rsp),%rbp
mov    0x88(%rsp),%r12
je     1927 <gaujor+0x7f7>
cmp    0x28(%rsp),%rax
jge    1927 <gaujor+0x7f7>
movslq 0x80(%rsp),%r8
mov    %rax,%rdi
cmp    $0x4,%r11
jb     1890 <gaujor+0x760>
lea    (%rax,%r8,1),%rdx
mov    (%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
cmp    0x70(%rsp),%rsi
jae    17aa <gaujor+0x67a>
mov    0x118(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rax,%rdi
cmp    %rdx,0x110(%rsp)
jb     1890 <gaujor+0x760>
cmpq   $0x4,0xf8(%rsp)
jae    17b9 <gaujor+0x689>
xor    %edx,%edx
jmp    182e <gaujor+0x6fe>
mov    0xa0(%rsp),%rdx
lea    (%rdx,%r8,8),%rsi
xor    %edx,%edx
mov    0xa8(%rsp),%rdi
nop
movups -0x10(%rsi,%rdx,8),%xmm3
movups (%rsi,%rdx,8),%xmm4
movups -0x30(%rdi,%rdx,8),%xmm5
movups -0x20(%rdi,%rdx,8),%xmm6
movups %xmm5,-0x10(%rsi,%rdx,8)
movups %xmm6,(%rsi,%rdx,8)
movups %xmm3,-0x30(%rdi,%rdx,8)
movups %xmm4,-0x20(%rdi,%rdx,8)
movupd 0x10(%rsi,%rdx,8),%xmm3
movdqu 0x20(%rsi,%rdx,8),%xmm4
movdqu -0x10(%rdi,%rdx,8),%xmm5
movdqu (%rdi,%rdx,8),%xmm6
movdqu %xmm5,0x10(%rsi,%rdx,8)
movdqu %xmm6,0x20(%rsi,%rdx,8)
movupd %xmm3,-0x10(%rdi,%rdx,8)
movdqu %xmm4,(%rdi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r12
jne    17d0 <gaujor+0x6a0>
mov    %r11,%rdi
and    $0xfffffffffffffffc,%rdi
testb  $0x1,0x100(%rsp)
01
je     1884 <gaujor+0x754>
add    %rax,%rdx
lea    (%rdx,%r8,1),%rsi
add    0x68(%rsp),%rdx
mov    (%rsp),%rbp
movupd 0x0(%rbp,%rsi,8),%xmm3
movdqu 0x10(%rbp,%rsi,8),%xmm4
movdqu 0x0(%rbp,%rdx,8),%xmm5
movdqu 0x10(%rbp,%rdx,8),%xmm6
movdqu %xmm5,0x0(%rbp,%rsi,8)
movdqu %xmm6,0x10(%rbp,%rsi,8)
movupd %xmm3,0x0(%rbp,%rdx,8)
movdqu %xmm4,0x10(%rbp,%rdx,8)
mov    0x58(%rsp),%rbp
cmp    %rdi,%r11
je     1927 <gaujor+0x7f7>
add    %rax,%rdi
mov    0x18(%rsp),%rsi
sub    %edi,%esi
mov    %rdi,%rdx
test   $0x1,%sil
je     18d1 <gaujor+0x7a1>
lea    (%rdi,%r8,1),%rdx
mov    0x68(%rsp),%rsi
add    %rdi,%rsi
mov    (%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm3
movq   0x0(%rbp,%rsi,8),%xmm4
movq   %xmm4,0x0(%rbp,%rdx,8)
movsd  %xmm3,0x0(%rbp,%rsi,8)
mov    0x58(%rsp),%rbp
lea    0x1(%rdi),%rdx
cmp    %rdi,0xb8(%rsp)
mov    0x18(%rsp),%rdi
je     1927 <gaujor+0x7f7>
mov    0x30(%rsp),%rsi
lea    (%rsi,%r8,8),%rsi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdx,8),%xmm3
movsd  -0x8(%rbp,%rdx,8),%xmm4
movsd  %xmm4,-0x8(%rsi,%rdx,8)
movsd  %xmm3,-0x8(%rbp,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm3
movq   0x0(%rbp,%rdx,8),%xmm4
movq   %xmm4,(%rsi,%rdx,8)
movsd  %xmm3,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rdi
jne    18f0 <gaujor+0x7c0>
lea    0x1(%rax),%rbp
cmp    0x28(%rsp),%rbp
mov    (%rsp),%rsi
mov    0x40(%rsp),%r11
jge    19f7 <gaujor+0x8c7>
mov    0x8(%rsp),%rdx
cmp    $0x2,%r11
jb     19db <gaujor+0x8ab>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x2,0x78(%rsp)
jae    196a <gaujor+0x83a>
xor    %edi,%edi
mov    0xb0(%rsp),%r8
jmp    19ac <gaujor+0x87c>
xor    %edi,%edi
mov    0x108(%rsp),%rdx
mov    0xb0(%rsp),%r8
nopl   0x0(%rax)
movupd -0x10(%r15,%rdi,8),%xmm4
movupd (%r15,%rdi,8),%xmm5
divpd  %xmm3,%xmm4
movupd %xmm4,-0x10(%r15,%rdi,8)
divpd  %xmm3,%xmm5
movupd %xmm5,(%r15,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1980 <gaujor+0x850>
mov    %r11,%rdx
and    $0xfffffffffffffffe,%rdx
test   $0x1,%r8b
je     19d1 <gaujor+0x8a1>
add    0x8(%rsp),%rdi
add    0x68(%rsp),%rdi
movupd (%rsi,%rdi,8),%xmm4
divpd  %xmm3,%xmm4
movupd %xmm4,(%rsi,%rdi,8)
cmp    %rdx,%r11
je     19f7 <gaujor+0x8c7>
add    0x8(%rsp),%rdx
mov    0x18(%rsp),%rdi
movsd  (%rbx,%rdx,8),%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    19e0 <gaujor+0x8b0>
mov    %rbp,0x78(%rsp)
cmp    0x28(%rsp),%rbp
setge  0x48(%rsp)
and    $0xfffffffffffffffc,%r11
mov    0x8(%rsp),%rdx
mov    %r11,0x88(%rsp)
add    %r11,%rdx
mov    %rdx,0x80(%rsp)
mov    0x30(%rsp),%r14
xor    %r8d,%r8d
jmp    1a4b <gaujor+0x91b>
nopl   0x0(%rax)
add    $0x1,%r8
mov    0x20(%rsp),%rdx
add    %rdx,%r9
add    %rdx,%r14
cmp    %r10,%r8
mov    %r11,%rax
je     1420 <gaujor+0x2f0>
mov    %rax,%r11
cmp    %rax,%r8
sete   %dl
or     0x48(%rsp),%dl
mov    0x18(%rsp),%rax
jne    1a30 <gaujor+0x900>
mov    %r8,%r12
imul   0x38(%rsp),%r12
lea    (%r12,%r11,1),%rdx
movsd  (%rsi,%rdx,8),%xmm2
xorpd  %xmm1,%xmm2
mov    0x8(%rsp),%rdi
cmpq   $0x4,0x40(%rsp)
jb     1b30 <gaujor+0xa00>
mov    0x8(%rsp),%rdx
add    %r12,%rdx
lea    (%rsi,%rdx,8),%rdx
cmp    0x70(%rsp),%rdx
jae    1ab4 <gaujor+0x984>
lea    (%r12,%rax,1),%rdx
lea    (%rsi,%rdx,8),%rdx
mov    0x8(%rsp),%rdi
cmp    %rdx,0x140(%rsp)
jb     1b30 <gaujor+0xa00>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
xor    %esi,%esi
mov    0x138(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%r15,%rsi,8),%xmm4
movupd (%r15,%rsi,8),%xmm5
movupd -0x10(%r9,%rsi,8),%xmm6
movupd (%r9,%rsi,8),%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
movupd %xmm4,-0x10(%r9,%rsi,8)
movupd %xmm5,(%r9,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1ad0 <gaujor+0x9a0>
mov    0x80(%rsp),%rdi
mov    0x88(%rsp),%rdx
cmp    %rdx,0x40(%rsp)
mov    (%rsp),%rsi
je     1a30 <gaujor+0x900>
nop
mov    %eax,%edx
sub    %edi,%edx
mov    %rdi,%rbp
test   $0x1,%dl
je     1b60 <gaujor+0xa30>
mov    0x68(%rsp),%rdx
add    %rdi,%rdx
add    %rdi,%r12
movsd  (%rsi,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rsi,%r12,8),%xmm3
movsd  %xmm3,(%rsi,%r12,8)
lea    0x1(%rdi),%rbp
not    %rdi
cmp    0x90(%rsp),%rdi
je     1a30 <gaujor+0x900>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  -0x8(%r14,%rbp,8),%xmm3
movsd  %xmm3,-0x8(%r14,%rbp,8)
movsd  0x8(%rbx,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r14,%rbp,8),%xmm3
movsd  %xmm3,(%r14,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rax
jne    1b80 <gaujor+0xa50>
jmp    1a30 <gaujor+0x900>
mov    0x241e(%rip),%rax
mov    (%rax),%edi
lea    0x530(%rip),%rsi
call   1040 <fprintf@plt>
mov    0x60(%rsp),%rdi
jmp    1e9f <gaujor+0xd6f>
cmp    $0x2,%r10d
mov    0x60(%rsp),%r15
mov    0x28(%rsp),%rbx
jl     1e9c <gaujor+0xd6c>
mov    0x50(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x50(%rsp)
mov    %rbx,%r11
sub    %r10,%r11
mov    %r10,%rcx
neg    %rcx
lea    (%rbx,%rcx,1),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
add    %r10,%rax
mov    %rax,0x40(%rsp)
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x90(%rsp)
mov    %rbx,%r13
neg    %r13
mov    (%rsp),%rcx
lea    (%rcx,%r10,8),%rsi
add    $0x30,%rsi
lea    0x30(%rcx),%rax
mov    %rax,0x70(%rsp)
xor    %r12d,%r12d
mov    0x30(%rsp),%rbp
jmp    1c8a <gaujor+0xb5a>
nopl   0x0(%rax)
add    $0x1,%r12
mov    0x20(%rsp),%rax
add    %rax,%rsi
add    %rax,%rbp
cmp    0x50(%rsp),%r12
je     1e9c <gaujor+0xd6c>
mov    (%r15,%r12,4),%r9d
cmp    %r9,%r12
je     1c70 <gaujor+0xb40>
mov    %r12,%r14
imul   0x38(%rsp),%r14
lea    (%r14,%r10,1),%rcx
mov    (%rsp),%rdx
lea    (%rdx,%rcx,8),%r8
lea    (%r14,%rbx,1),%rcx
lea    (%rdx,%rcx,8),%rax
jmp    1cc5 <gaujor+0xb95>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r9,%r12
je     1c70 <gaujor+0xb40>
movslq %r9d,%rcx
mov    %r9d,%edx
imul   0x14(%rsp),%edx
movslq %edx,%rdx
mov    (%r15,%rcx,4),%r9d
mov    %ecx,(%r15,%rcx,4)
mov    %r9d,(%r15,%r12,4)
mov    %r10,%rcx
cmp    $0x4,%r11
jb     1e00 <gaujor+0xcd0>
lea    (%r10,%rdx,1),%rcx
mov    (%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
cmp    %rax,%rcx
jae    1d15 <gaujor+0xbe5>
lea    (%rbx,%rdx,1),%rcx
mov    (%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
mov    %r10,%rcx
cmp    %rdi,%r8
jb     1e00 <gaujor+0xcd0>
cmpq   $0x4,0x18(%rsp)
jae    1d21 <gaujor+0xbf1>
xor    %edi,%edi
jmp    1d9e <gaujor+0xc6e>
lea    (%r10,%rdx,1),%rcx
mov    0x70(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
mov    0x90(%rsp),%rbx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdi,8),%xmm0
movups -0x20(%rcx,%rdi,8),%xmm1
movups -0x30(%rsi,%rdi,8),%xmm2
movups -0x20(%rsi,%rdi,8),%xmm3
movups %xmm2,-0x30(%rcx,%rdi,8)
movups %xmm3,-0x20(%rcx,%rdi,8)
movups %xmm0,-0x30(%rsi,%rdi,8)
movups %xmm1,-0x20(%rsi,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm0
movupd (%rcx,%rdi,8),%xmm1
movdqu -0x10(%rsi,%rdi,8),%xmm2
movdqu (%rsi,%rdi,8),%xmm3
movdqu %xmm2,-0x10(%rcx,%rdi,8)
movdqu %xmm3,(%rcx,%rdi,8)
movupd %xmm0,-0x10(%rsi,%rdi,8)
movupd %xmm1,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1d40 <gaujor+0xc10>
testb  $0x1,0x48(%rsp)
je     1ddf <gaujor+0xcaf>
add    %r10,%rdi
lea    (%rdi,%rdx,1),%rcx
add    %r14,%rdi
mov    (%rsp),%rbx
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movdqu (%rbx,%rdi,8),%xmm2
movdqu 0x10(%rbx,%rdi,8),%xmm3
movdqu %xmm2,(%rbx,%rcx,8)
movdqu %xmm3,0x10(%rbx,%rcx,8)
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm1,0x10(%rbx,%rdi,8)
mov    0x40(%rsp),%rcx
cmp    0x8(%rsp),%r11
mov    0x28(%rsp),%rbx
je     1cc0 <gaujor+0xb90>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x9c(%rsp),%edi
mov    %edi,%ebx
sub    %ecx,%ebx
mov    %rcx,%rdi
test   $0x1,%bl
je     1e40 <gaujor+0xd10>
lea    (%rcx,%rdx,1),%rdi
lea    (%rcx,%r14,1),%rbx
mov    (%rsp),%r15
movsd  (%r15,%rdi,8),%xmm0
movsd  (%r15,%rbx,8),%xmm1
movsd  %xmm1,(%r15,%rdi,8)
movsd  %xmm0,(%r15,%rbx,8)
mov    0x60(%rsp),%r15
lea    0x1(%rcx),%rdi
not    %rcx
cmp    %r13,%rcx
mov    0x28(%rsp),%rbx
je     1cc0 <gaujor+0xb90>
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm0
movsd  -0x8(%rbp,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rdi,8)
movsd  %xmm0,-0x8(%rbp,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
movsd  0x0(%rbp,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbx
jne    1e60 <gaujor+0xd30>
jmp    1cc0 <gaujor+0xb90>
mov    %r15,%rdi
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [39 x i8] c"Error : Illegal parameter in gaujor()\0A\00"
@.str.1 = [36 x i8] c"Error : Out of memory in gaujor()\0A\00"
@.str.2 = [32 x i8] c"Error : api < eps in gaujor()\0A\00"
define void @gaujor(double* %0, i32 %1, i32 %2, i32 %3, double %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca i32
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
store double* %0, double** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store double %4, double* %10
%29 = load i32, i32* %7
%30 = load i32, i32* %9
%31 = icmp slt i32 %29, %30
br i1 %31, label %42, label %32
32: ; preds = %5
%33 = load i32, i32* %8
%34 = icmp slt i32 %33, 2
br i1 %34, label %42, label %35
35: ; preds = %32
%36 = load i32, i32* %8
%37 = load i32, i32* %9
%38 = icmp sge i32 %36, %37
br i1 %38, label %42, label %39
39: ; preds = %35
%40 = load double, double* %10
%41 = fcmp ole double %40, 0.000000e+00
br i1 %41, label %42, label %45
42: ; preds = %39, %35, %32, %5
%43 = load i32, i32* @stderr
%44 = call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
br label %401
45: ; preds = %39
%46 = load i32, i32* %8
%47 = sext i32 %46 to i64
%48 = mul i64 %47, 4
%49 = trunc i64 %48 to i32
%50 = call i64 @malloc(i32 %49)
%51 = inttoptr i64 %50 to i32*
store i32* %51, i32** %23
%52 = load i32*, i32** %23
%53 = icmp eq i32* %52, null
br i1 %53, label %54, label %57
54: ; preds = %45
%55 = load i32, i32* @stderr
%56 = call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
br label %401
57: ; preds = %45
store i32 0, i32* %12
br label %58
58: ; preds = %68, %57
%59 = load i32, i32* %12
%60 = load i32, i32* %8
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %71
62: ; preds = %58
%63 = load i32, i32* %12
%64 = load i32*, i32** %23
%65 = load i32, i32* %12
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
store i32 %63, i32* %67
br label %68
68: ; preds = %62
%69 = load i32, i32* %12
%70 = add nsw i32 %69, 1
store i32 %70, i32* %12
br label %58
71: ; preds = %58
store i32 0, i32* %15
br label %72
72: ; preds = %312, %71
%73 = load i32, i32* %15
%74 = load i32, i32* %8
%75 = icmp slt i32 %73, %74
br i1 %75, label %76, label %315
76: ; preds = %72
%77 = load i32, i32* %15
%78 = load i32, i32* %7
%79 = mul nsw i32 %77, %78
store i32 %79, i32* %24
store double 0.000000e+00, double* %28
store i32 0, i32* %12
br label %80
80: ; preds = %114, %76
%81 = load i32, i32* %12
%82 = load i32, i32* %8
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %117
84: ; preds = %80
%85 = load i32, i32* %12
%86 = load i32, i32* %7
%87 = mul nsw i32 %85, %86
store i32 %87, i32* %19
%88 = load i32, i32* %15
store i32 %88, i32* %14
br label %89
89: ; preds = %110, %84
%90 = load i32, i32* %14
%91 = load i32, i32* %8
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %113
93: ; preds = %89
%94 = load double*, double** %6
%95 = load i32, i32* %19
%96 = load i32, i32* %14
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %94, i64 %98
%100 = load double, double* %99
%101 = call double @llvm.fabs.f64(double %100)
store double %101, double* %27
%102 = load double, double* %27
%103 = load double, double* %28
%104 = fcmp ogt double %102, %103
br i1 %104, label %105, label %109
105: ; preds = %93
%106 = load double, double* %27
store double %106, double* %28
%107 = load i32, i32* %12
store i32 %107, i32* %18
%108 = load i32, i32* %14
store i32 %108, i32* %11
br label %109
109: ; preds = %105, %93
br label %110
110: ; preds = %109
%111 = load i32, i32* %14
%112 = add nsw i32 %111, 1
store i32 %112, i32* %14
br label %89
113: ; preds = %89
br label %114
114: ; preds = %113
%115 = load i32, i32* %12
%116 = add nsw i32 %115, 1
store i32 %116, i32* %12
br label %80
117: ; preds = %80
%118 = load i32, i32* %18
%119 = load i32, i32* %7
%120 = mul nsw i32 %118, %119
store i32 %120, i32* %19
%121 = load double*, double** %6
%122 = load i32, i32* %19
%123 = load i32, i32* %11
%124 = add nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %121, i64 %125
%127 = load double, double* %126
store double %127, double* %26
%128 = load double, double* %26
%129 = call double @llvm.fabs.f64(double %128)
store double %129, double* %25
%130 = load double, double* %25
%131 = load double, double* %10
%132 = fcmp olt double %130, %131
br i1 %132, label %133, label %138
133: ; preds = %117
%134 = load i32, i32* @stderr
%135 = call i32 @fprintf(i32 %134, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.2, i64 0, i64 0))
%136 = load i32*, i32** %23
%137 = call i32 @free(i32* %136)
br label %401
138: ; preds = %117
%139 = load i32, i32* %11
%140 = load i32, i32* %15
%141 = icmp ne i32 %139, %140
br i1 %141, label %142, label %199
142: ; preds = %138
%143 = load i32*, i32** %23
%144 = load i32, i32* %15
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %143, i64 %145
%147 = load i32, i32* %146
store i32 %147, i32* %13
%148 = load i32*, i32** %23
%149 = load i32, i32* %11
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
%152 = load i32, i32* %151
%153 = load i32*, i32** %23
%154 = load i32, i32* %15
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
store i32 %152, i32* %156
%157 = load i32, i32* %13
%158 = load i32*, i32** %23
%159 = load i32, i32* %11
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %158, i64 %160
store i32 %157, i32* %161
store i32 0, i32* %12
br label %162
162: ; preds = %195, %142
%163 = load i32, i32* %12
%164 = load i32, i32* %8
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %198
166: ; preds = %162
%167 = load i32, i32* %12
%168 = load i32, i32* %7
%169 = mul nsw i32 %167, %168
store i32 %169, i32* %20
%170 = load i32, i32* %20
%171 = load i32, i32* %15
%172 = add nsw i32 %170, %171
store i32 %172, i32* %21
%173 = load i32, i32* %20
%174 = load i32, i32* %11
%175 = add nsw i32 %173, %174
store i32 %175, i32* %22
%176 = load double*, double** %6
%177 = load i32, i32* %21
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %176, i64 %178
%180 = load double, double* %179
store double %180, double* %27
%181 = load double*, double** %6
%182 = load i32, i32* %22
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
%185 = load double, double* %184
%186 = load double*, double** %6
%187 = load i32, i32* %21
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %186, i64 %188
store double %185, double* %189
%190 = load double, double* %27
%191 = load double*, double** %6
%192 = load i32, i32* %22
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
store double %190, double* %194
br label %195
195: ; preds = %166
%196 = load i32, i32* %12
%197 = add nsw i32 %196, 1
store i32 %197, i32* %12
br label %162
198: ; preds = %162
br label %199
199: ; preds = %198, %138
%200 = load i32, i32* %18
%201 = load i32, i32* %15
%202 = icmp ne i32 %200, %201
br i1 %202, label %203, label %239
203: ; preds = %199
%204 = load i32, i32* %15
store i32 %204, i32* %14
br label %205
205: ; preds = %235, %203
%206 = load i32, i32* %14
%207 = load i32, i32* %9
%208 = icmp slt i32 %206, %207
br i1 %208, label %209, label %238
209: ; preds = %205
%210 = load i32, i32* %19
%211 = load i32, i32* %14
%212 = add nsw i32 %210, %211
store i32 %212, i32* %20
%213 = load i32, i32* %24
%214 = load i32, i32* %14
%215 = add nsw i32 %213, %214
store i32 %215, i32* %21
%216 = load double*, double** %6
%217 = load i32, i32* %20
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
store double %220, double* %27
%221 = load double*, double** %6
%222 = load i32, i32* %21
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %221, i64 %223
%225 = load double, double* %224
%226 = load double*, double** %6
%227 = load i32, i32* %20
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds double, double* %226, i64 %228
store double %225, double* %229
%230 = load double, double* %27
%231 = load double*, double** %6
%232 = load i32, i32* %21
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %231, i64 %233
store double %230, double* %234
br label %235
235: ; preds = %209
%236 = load i32, i32* %14
%237 = add nsw i32 %236, 1
store i32 %237, i32* %14
br label %205
238: ; preds = %205
br label %239
239: ; preds = %238, %199
%240 = load i32, i32* %15
%241 = add nsw i32 %240, 1
store i32 %241, i32* %16
%242 = load i32, i32* %16
store i32 %242, i32* %12
br label %243
243: ; preds = %257, %239
%244 = load i32, i32* %12
%245 = load i32, i32* %9
%246 = icmp slt i32 %244, %245
br i1 %246, label %247, label %260
247: ; preds = %243
%248 = load double, double* %26
%249 = load double*, double** %6
%250 = load i32, i32* %24
%251 = load i32, i32* %12
%252 = add nsw i32 %250, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %249, i64 %253
%255 = load double, double* %254
%256 = fdiv double %255, %248
store double %256, double* %254
br label %257
257: ; preds = %247
%258 = load i32, i32* %12
%259 = add nsw i32 %258, 1
store i32 %259, i32* %12
br label %243
260: ; preds = %243
store i32 0, i32* %12
br label %261
261: ; preds = %308, %260
%262 = load i32, i32* %12
%263 = load i32, i32* %8
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %311
265: ; preds = %261
%266 = load i32, i32* %12
%267 = load i32, i32* %7
%268 = mul nsw i32 %266, %267
store i32 %268, i32* %20
%269 = load i32, i32* %12
%270 = load i32, i32* %15
%271 = icmp ne i32 %269, %270
br i1 %271, label %272, label %307
272: ; preds = %265
%273 = load double*, double** %6
%274 = load i32, i32* %20
%275 = load i32, i32* %15
%276 = add nsw i32 %274, %275
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %273, i64 %277
%279 = load double, double* %278
store double %279, double* %27
%280 = load i32, i32* %16
store i32 %280, i32* %14
br label %281
281: ; preds = %303, %272
%282 = load i32, i32* %14
%283 = load i32, i32* %9
%284 = icmp slt i32 %282, %283
br i1 %284, label %285, label %306
285: ; preds = %281
%286 = load double, double* %27
%287 = load double*, double** %6
%288 = load i32, i32* %24
%289 = load i32, i32* %14
%290 = add nsw i32 %288, %289
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double, double* %287, i64 %291
%293 = load double, double* %292
%294 = load double*, double** %6
%295 = load i32, i32* %20
%296 = load i32, i32* %14
%297 = add nsw i32 %295, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %294, i64 %298
%300 = load double, double* %299
%301 = fneg double %286
%302 = call double @llvm.fmuladd.f64(double %301, double %293, double %300)
store double %302, double* %299
br label %303
303: ; preds = %285
%304 = load i32, i32* %14
%305 = add nsw i32 %304, 1
store i32 %305, i32* %14
br label %281
306: ; preds = %281
br label %307
307: ; preds = %306, %265
br label %308
308: ; preds = %307
%309 = load i32, i32* %12
%310 = add nsw i32 %309, 1
store i32 %310, i32* %12
br label %261
311: ; preds = %261
br label %312
312: ; preds = %311
%313 = load i32, i32* %15
%314 = add nsw i32 %313, 1
store i32 %314, i32* %15
br label %72
315: ; preds = %72
%316 = load i32, i32* %8
%317 = sub nsw i32 %316, 1
store i32 %317, i32* %17
store i32 0, i32* %12
br label %318
318: ; preds = %395, %315
%319 = load i32, i32* %12
%320 = load i32, i32* %17
%321 = icmp slt i32 %319, %320
br i1 %321, label %322, label %398
322: ; preds = %318
br label %323
323: ; preds = %393, %322
%324 = load i32*, i32** %23
%325 = load i32, i32* %12
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %324, i64 %326
%328 = load i32, i32* %327
store i32 %328, i32* %15
%329 = load i32, i32* %15
%330 = load i32, i32* %12
%331 = icmp eq i32 %329, %330
br i1 %331, label %332, label %333
332: ; preds = %323
br label %394
333: ; preds = %323
%334 = load i32*, i32** %23
%335 = load i32, i32* %15
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds i32, i32* %334, i64 %336
%338 = load i32, i32* %337
store i32 %338, i32* %13
%339 = load i32*, i32** %23
%340 = load i32, i32* %12
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %339, i64 %341
%343 = load i32, i32* %342
%344 = load i32*, i32** %23
%345 = load i32, i32* %15
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %344, i64 %346
store i32 %343, i32* %347
%348 = load i32, i32* %13
%349 = load i32*, i32** %23
%350 = load i32, i32* %12
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %349, i64 %351
store i32 %348, i32* %352
%353 = load i32, i32* %15
%354 = load i32, i32* %7
%355 = mul nsw i32 %353, %354
store i32 %355, i32* %19
%356 = load i32, i32* %12
%357 = load i32, i32* %7
%358 = mul nsw i32 %356, %357
store i32 %358, i32* %20
%359 = load i32, i32* %8
store i32 %359, i32* %14
br label %360
360: ; preds = %390, %333
%361 = load i32, i32* %14
%362 = load i32, i32* %9
%363 = icmp slt i32 %361, %362
br i1 %363, label %364, label %393
364: ; preds = %360
%365 = load i32, i32* %19
%366 = load i32, i32* %14
%367 = add nsw i32 %365, %366
store i32 %367, i32* %21
%368 = load i32, i32* %20
%369 = load i32, i32* %14
%370 = add nsw i32 %368, %369
store i32 %370, i32* %22
%371 = load double*, double** %6
%372 = load i32, i32* %21
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
store double %375, double* %27
%376 = load double*, double** %6
%377 = load i32, i32* %22
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %376, i64 %378
%380 = load double, double* %379
%381 = load double*, double** %6
%382 = load i32, i32* %21
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds double, double* %381, i64 %383
store double %380, double* %384
%385 = load double, double* %27
%386 = load double*, double** %6
%387 = load i32, i32* %22
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %386, i64 %388
store double %385, double* %389
br label %390
390: ; preds = %364
%391 = load i32, i32* %14
%392 = add nsw i32 %391, 1
store i32 %392, i32* %14
br label %360
393: ; preds = %360
br label %323
394: ; preds = %332
br label %395
395: ; preds = %394
%396 = load i32, i32* %12
%397 = add nsw i32 %396, 1
store i32 %397, i32* %12
br label %318
398: ; preds = %318
%399 = load i32*, i32** %23
%400 = call i32 @free(i32* %399)
br label %401
401: ; preds = %398, %133, %54, %42
ret void
}

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