#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 */
int abs(int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ gint1_fn_dispatch(int, double *, double, double *, double *);
double *malloc(int);
scalar_t__ sqrt(int);
int gint1_fn_overlap(double *overlap, double *points, double *weights,
                     double *centers, int *shell_types, int *shell_map,
                     int *num_primitives, double *ccoeffs, double *exponents,
                     int num_overlap, int num_points, int num_centers,
                     int num_shells, int num_ccoeffs, int num_exponents) {
  int shell, shell_type, primitive, dof1, dof2, num_dof, num_shell_dof, result,
      i_point;
  double *work, *out, *center, *ccoeff, *exponent, *basis_fns, *shell_fns, *fn1,
      *fn2, *overlap_element;
  double tmp;
  result = 0;
  work = malloc(10 * sizeof(double));
  if (work == NULL) {
    result = -1;
    goto EXIT;
  };
  num_dof = (int)(sqrt(num_overlap));
  basis_fns = malloc(num_dof * sizeof(double));
  if (basis_fns == NULL) {
    result = -1;
    goto EXIT;
  };
  out = overlap;
  for (dof1 = 0; dof1 < num_overlap; dof1++) {
    *out = 0.0;
    out++;
  }
  for (i_point = 0; i_point < num_points; i_point++) {
    fn1 = basis_fns;
    for (dof1 = 0; dof1 < num_dof; dof1++) {
      *fn1 = 0.0;
      fn1++;
    }
    ccoeff = ccoeffs;
    exponent = exponents;
    shell_fns = basis_fns;
    for (shell = 0; shell < num_shells; shell++) {
      center = centers + (3 * shell_map[shell]);
      shell_type = shell_types[shell];
      if (abs(shell_type) > 3) {
        result = -2;
        goto EXIT;
      };
      num_shell_dof =
          ((shell_type < -1)
               ? (-2 * shell_type + 1)
               : ((shell_type == -1)
                      ? (4)
                      : (((shell_type + 1) * (shell_type + 2)) / 2)));
      for (primitive = 0; primitive < num_primitives[shell]; primitive++) {
        gint1_fn_dispatch(shell_type, center, *exponent, points, work);
        out = work;
        exponent++;
        fn1 = shell_fns;
        if (shell_type == -1) {
          *fn1 += (*out) * (*ccoeff);
          fn1++;
          out++;
          ccoeff++;
        }
        for (dof1 = num_shell_dof - (shell_type == -1); dof1 > 0; dof1--) {
          *fn1 += (*out) * (*ccoeff);
          fn1++;
          out++;
        }
        ccoeff++;
      }
      shell_fns += num_shell_dof;
    }
    overlap_element = overlap;
    fn1 = basis_fns;
    for (dof1 = 0; dof1 < num_dof; dof1++) {
      fn2 = basis_fns;
      tmp = (*weights) * (*fn1);
      for (dof2 = 0; dof2 < num_dof; dof2++) {
        *overlap_element += tmp * (*fn2);
        overlap_element++;
        fn2++;
      }
      fn1++;
    }
    points += 3;
    weights++;
  }
EXIT:
  free(work);
  free(basis_fns);
  return result;
}


x86 assembly (clang, -O0):
<gint1_fn_overlap>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x50(%rbp)
mov    $0x50,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    11bd <gint1_fn_overlap+0x6d>
movl   $0xffffffff,-0x50(%rbp)
jmp    15f7 <gint1_fn_overlap+0x4a7>
mov    0x28(%rbp),%edi
call   1070 <sqrt@plt>
mov    %eax,-0x48(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
jne    11f8 <gint1_fn_overlap+0xa8>
movl   $0xffffffff,-0x50(%rbp)
jmp    15f7 <gint1_fn_overlap+0x4a7>
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1238 <gint1_fn_overlap+0xe8>
mov    -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1207 <gint1_fn_overlap+0xb7>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    15f2 <gint1_fn_overlap+0x4a2>
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    129a <gint1_fn_overlap+0x14a>
mov    -0x98(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x98(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1260 <gint1_fn_overlap+0x110>
mov    0x18(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    14e8 <gint1_fn_overlap+0x398>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
imul   $0x3,(%rcx,%rdx,4),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edi
call   1050 <abs@plt>
cmp    $0x3,%eax
jle    1314 <gint1_fn_overlap+0x1c4>
movl   $0xfffffffe,-0x50(%rbp)
jmp    15f7 <gint1_fn_overlap+0x4a7>
cmpl   $0xffffffff,-0x38(%rbp)
jge    1333 <gint1_fn_overlap+0x1e3>
imul   $0xfffffffe,-0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1376 <gint1_fn_overlap+0x226>
cmpl   $0xffffffff,-0x38(%rbp)
jne    134d <gint1_fn_overlap+0x1fd>
mov    $0x4,%eax
mov    %eax,-0xb8(%rbp)
jmp    136a <gint1_fn_overlap+0x21a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    14bf <gint1_fn_overlap+0x36f>
mov    -0x38(%rbp),%edi
mov    -0x70(%rbp),%rsi
mov    -0x80(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rdx
mov    -0x60(%rbp),%rcx
call   1040 <gint1_fn_dispatch@plt>
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x80(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x98(%rbp)
cmpl   $0xffffffff,-0x38(%rbp)
jne    1433 <gint1_fn_overlap+0x2e3>
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x98(%rbp)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x78(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
cmpl   $0xffffffff,-0x38(%rbp)
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    14a5 <gint1_fn_overlap+0x355>
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x78(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x98(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x98(%rbp)
mov    -0x68(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1448 <gint1_fn_overlap+0x2f8>
mov    -0x78(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1386 <gint1_fn_overlap+0x236>
mov    -0x4c(%rbp),%ecx
mov    -0x90(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12bf <gint1_fn_overlap+0x16f>
mov    -0x8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15cc <gint1_fn_overlap+0x47c>
mov    -0x88(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x98(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15ac <gint1_fn_overlap+0x45c>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xa0(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1544 <gint1_fn_overlap+0x3f4>
mov    -0x98(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x98(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1508 <gint1_fn_overlap+0x3b8>
mov    -0x10(%rbp),%rax
add    $0x18,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    123f <gint1_fn_overlap+0xef>
jmp    15f7 <gint1_fn_overlap+0x4a7>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gint1_fn_overlap>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x88(%rsp)
mov    %r8,0xa8(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rdx,%r14
mov    %rsi,0x30(%rsp)
mov    %rdi,0x20(%rsp)
mov    0x138(%rsp),%r15d
mov    $0x50,%edi
call   1060 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r15d,%edi
call   1070 <sqrt@plt>
mov    %rax,%r13
lea    0x0(,%rax,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r12
test   %rax,%rax
je     17e8 <gint1_fn_overlap+0x698>
test   %r15d,%r15d
jle    11d8 <gint1_fn_overlap+0x88>
mov    %r15d,%edx
shl    $0x3,%rdx
mov    0x20(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
cmpl   $0x0,0x140(%rsp)
jle    17f6 <gint1_fn_overlap+0x6a6>
mov    0x8(%rsp),%r15
mov    %r15,%rax
add    $0x8,%rax
mov    %rax,0xc0(%rsp)
mov    %r13d,%eax
shl    $0x3,%rax
mov    %rax,0x40(%rsp)
lea    -0x1(%r13),%eax
lea    (%r12,%rax,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x90(%rsp)
mov    %rax,0xb0(%rsp)
lea    0x1(%rax),%rdx
mov    %rdx,%rax
mov    %rdx,0x28(%rsp)
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,0x70(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x68(%rsp)
mov    %rsi,%r10
and    $0xfffffffffffffffe,%r10
mov    %rdx,0x78(%rsp)
lea    (%r12,%rdx,8),%rax
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %r12,0xa0(%rsp)
mov    %r13,0x98(%rsp)
mov    %r10,0x48(%rsp)
jmp    129f <gint1_fn_overlap+0x14f>
nopl   0x0(%rax)
addq   $0x18,0x30(%rsp)
add    $0x8,%r14
mov    0x50(%rsp),%rax
add    $0x1,%eax
cmp    0x140(%rsp),%eax
je     1821 <gint1_fn_overlap+0x6d1>
mov    %rax,0x50(%rsp)
mov    %r14,0x58(%rsp)
test   %r13d,%r13d
jle    12c2 <gint1_fn_overlap+0x172>
mov    %r12,%rdi
xor    %esi,%esi
mov    0x40(%rsp),%rdx
call   1050 <memset@plt>
mov    0x8(%rsp),%r15
cmpl   $0x0,0x150(%rsp)
jle    15d0 <gint1_fn_overlap+0x480>
xor    %r10d,%r10d
mov    %r12,(%rsp)
mov    0x130(%rsp),%r11
mov    0x128(%rsp),%rbx
jmp    1325 <gint1_fn_overlap+0x1d5>
nopl   0x0(%rax)
movslq 0x18(%rsp),%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    %rdx,(%rsp)
add    $0x1,%r10
mov    0x150(%rsp),%eax
cmp    %rax,%r10
mov    0xa0(%rsp),%r12
mov    0x98(%rsp),%r13
je     15d0 <gint1_fn_overlap+0x480>
mov    0xa8(%rsp),%rax
mov    (%rax,%r10,4),%ebp
mov    %ebp,%eax
neg    %eax
cmovs  %ebp,%eax
cmp    $0x3,%eax
ja     17ef <gint1_fn_overlap+0x69f>
cmp    $0xfffffffe,%ebp
jg     1360 <gint1_fn_overlap+0x210>
mov    $0x1,%esi
sub    %ebp,%esi
sub    %ebp,%esi
jmp    1380 <gint1_fn_overlap+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0xffffffff,%ebp
je     1379 <gint1_fn_overlap+0x229>
lea    0x1(%rbp),%eax
lea    0x2(%rbp),%edx
imul   %eax,%edx
mov    %edx,%esi
shr    $0x1f,%esi
add    %edx,%esi
sar    %esi
jmp    1380 <gint1_fn_overlap+0x230>
mov    $0x4,%esi
xchg   %ax,%ax
mov    0x120(%rsp),%rax
cmpl   $0x0,(%rax,%r10,4)
mov    %esi,0x18(%rsp)
jle    12f0 <gint1_fn_overlap+0x1a0>
mov    0x88(%rsp),%rax
movslq (%rax,%r10,4),%rax
lea    (%rax,%rax,2),%rax
mov    0x80(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
cmp    $0xffffffff,%ebp
sete   %al
mov    (%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0xc8(%rsp)
mov    %esi,%edx
sub    %eax,%edx
lea    -0x1(%rdx),%eax
mov    %rax,0xd0(%rsp)
add    $0x1,%rax
mov    %rax,0xb8(%rsp)
mov    %rax,%r14
movabs $0x1fffffffc,%rax
and    %rax,%r14
mov    %rdx,0x10(%rsp)
mov    %edx,%eax
sub    %r14d,%eax
mov    %eax,0x1c(%rsp)
xor    %r12d,%r12d
mov    %rbp,0xe0(%rsp)
mov    %r14,0x38(%rsp)
jmp    1446 <gint1_fn_overlap+0x2f6>
xchg   %ax,%ax
add    $0x8,%r11
add    $0x8,%rbx
add    $0x1,%r12d
mov    0x120(%rsp),%rax
cmp    (%rax,%r10,4),%r12d
mov    0xe0(%rsp),%rbp
jge    12f0 <gint1_fn_overlap+0x1a0>
mov    %r10,%r14
mov    %r11,%r13
movsd  (%r11),%xmm0
mov    %ebp,%edi
mov    0xd8(%rsp),%rsi
mov    0x30(%rsp),%rdx
mov    %r15,%rcx
call   1040 <gint1_fn_dispatch@plt>
cmp    $0xffffffff,%ebp
je     1480 <gint1_fn_overlap+0x330>
mov    %r15,%rbp
mov    (%rsp),%rsi
jmp    14a9 <gint1_fn_overlap+0x359>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15),%xmm0
mulsd  (%rbx),%xmm0
mov    (%rsp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
add    $0x8,%rbx
mov    0xc0(%rsp),%rbp
mov    0xc8(%rsp),%rsi
mov    %r14,%r10
mov    %r13,%r11
mov    0x38(%rsp),%r14
cmpl   $0x0,0x10(%rsp)
jle    1420 <gint1_fn_overlap+0x2d0>
mov    0xd0(%rsp),%rax
cmp    $0x3,%eax
jb     1580 <gint1_fn_overlap+0x430>
lea    (%rsi,%rax,8),%rdx
add    $0x8,%rdx
lea    0x8(,%rax,8),%rax
add    %rbp,%rax
lea    0x8(%rbx),%rdi
cmp    %rax,%rsi
setb   %r8b
cmp    %rdx,%rbp
setb   %r9b
cmp    %rdi,%rsi
setb   %al
cmp    %rdx,%rbx
setb   %dl
test   %r9b,%r8b
jne    1580 <gint1_fn_overlap+0x430>
and    %dl,%al
jne    1580 <gint1_fn_overlap+0x430>
lea    (%rsi,%r14,8),%rax
lea    0x0(,%r14,8),%rdx
add    %rbp,%rdx
movsd  (%rbx),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%rbp,%rdi,8),%xmm1
movupd 0x10(%rbp,%rdi,8),%xmm2
movupd (%rsi,%rdi,8),%xmm3
movupd 0x10(%rsi,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rsi,%rdi,8)
movupd %xmm2,0x10(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r14
jne    1530 <gint1_fn_overlap+0x3e0>
mov    0x1c(%rsp),%edi
cmp    %r14,0xb8(%rsp)
je     1420 <gint1_fn_overlap+0x2d0>
jmp    158d <gint1_fn_overlap+0x43d>
nop
mov    %rsi,%rax
mov    %rbp,%rdx
mov    0x10(%rsp),%rsi
mov    %esi,%edi
add    $0x1,%edi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rsi,1),%xmm0
mulsd  (%rbx),%xmm0
addsd  (%rax,%rsi,1),%xmm0
movsd  %xmm0,(%rax,%rsi,1)
add    $0x8,%rsi
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     15a0 <gint1_fn_overlap+0x450>
jmp    1420 <gint1_fn_overlap+0x2d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r13d,%r13d
mov    0x58(%rsp),%r14
mov    0x48(%rsp),%r10
jle    1280 <gint1_fn_overlap+0x130>
xor    %r8d,%r8d
mov    0x20(%rsp),%rdx
mov    %r12,%r9
jmp    1601 <gint1_fn_overlap+0x4b1>
add    $0x8,%r9
add    $0x1,%r8d
cmp    %r13d,%r8d
je     1280 <gint1_fn_overlap+0x130>
movsd  (%r14),%xmm0
mulsd  (%r9),%xmm0
cmpl   $0x3,0xb0(%rsp)
03
jb     1635 <gint1_fn_overlap+0x4e5>
cmp    0x90(%rsp),%rdx
jae    16f0 <gint1_fn_overlap+0x5a0>
mov    0x28(%rsp),%rax
lea    (%rdx,%rax,8),%rax
cmp    %rax,%r12
jae    16f0 <gint1_fn_overlap+0x5a0>
mov    %r12,%rsi
xor    %ebp,%ebp
mov    %r13d,%ebx
sub    %ebp,%ebx
mov    %ebp,%edi
not    %edi
add    %r13d,%edi
and    $0x3,%ebx
je     1671 <gint1_fn_overlap+0x521>
neg    %ebx
xor    %eax,%eax
nop
movsd  (%rsi),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
add    $0x8,%rdx
add    $0x8,%rsi
add    $0xffffffff,%eax
cmp    %eax,%ebx
jne    1650 <gint1_fn_overlap+0x500>
sub    %eax,%ebp
cmp    $0x3,%edi
jb     15f0 <gint1_fn_overlap+0x4a0>
mov    %r13d,%edi
sub    %ebp,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
movsd  0x8(%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx),%xmm1
movsd  %xmm1,0x8(%rdx)
movsd  0x10(%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx),%xmm1
movsd  %xmm1,0x10(%rdx)
movsd  0x18(%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdx),%xmm1
movsd  %xmm1,0x18(%rdx)
add    $0x20,%rdx
add    $0x4,%rbp
cmp    %ebp,%edi
jne    1690 <gint1_fn_overlap+0x540>
jmp    15f0 <gint1_fn_overlap+0x4a0>
xchg   %ax,%ax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x70(%rsp)
je     17dd <gint1_fn_overlap+0x68d>
mov    %r10,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rdx,%rsi,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rdx,%rsi,8),%xmm2
movupd 0x20(%rdx,%rsi,8),%xmm5
movupd 0x30(%rdx,%rsi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rdx,%rsi,8)
movupd %xmm3,0x10(%rdx,%rsi,8)
movupd 0x20(%r12,%rsi,8),%xmm2
movupd 0x30(%r12,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rdx,%rsi,8)
movupd %xmm3,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1710 <gint1_fn_overlap+0x5c0>
testb  $0x1,0x68(%rsp)
je     17bd <gint1_fn_overlap+0x66d>
movupd (%r12,%rsi,8),%xmm2
movupd 0x10(%r12,%rsi,8),%xmm3
movupd (%rdx,%rsi,8),%xmm4
movupd 0x10(%rdx,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rsi,8)
movupd %xmm3,0x10(%rdx,%rsi,8)
mov    0x78(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
mov    0x60(%rsp),%rsi
mov    %eax,%ebp
cmp    %rax,0x28(%rsp)
je     15f0 <gint1_fn_overlap+0x4a0>
jmp    163a <gint1_fn_overlap+0x4ea>
xor    %esi,%esi
testb  $0x1,0x68(%rsp)
jne    178a <gint1_fn_overlap+0x63a>
jmp    17bd <gint1_fn_overlap+0x66d>
mov    $0xffffffff,%ebp
jmp    17f8 <gint1_fn_overlap+0x6a8>
mov    $0xfffffffe,%ebp
jmp    17fd <gint1_fn_overlap+0x6ad>
xor    %ebp,%ebp
mov    0x8(%rsp),%r15
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
jmp    17fd <gint1_fn_overlap+0x6ad>

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

LLVM IR (-O2):
define i32 @gint1_fn_overlap(double* nocapture %0, double* %1, double* nocapture %2, double* %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture %6, double* nocapture %7, double* nocapture %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13, i32 %14) {
%16 = bitcast double* %0 to i8*
%17 = tail call double* @malloc(i32 80)
%18 = icmp ne double* %17, null
tail call void @llvm.assume(i1 %18)
%19 = tail call i64 @sqrt(i32 %9)
%20 = trunc i64 %19 to i32
%21 = shl i32 %20, 3
%22 = tail call double* @malloc(i32 %21)
%23 = bitcast double* %22 to i8*
%24 = icmp eq double* %22, null
br i1 %24, label %341, label %25
25: ; preds = %15
%26 = icmp sgt i32 %9, 0
br i1 %26, label %27, label %30
27: ; preds = %25
%28 = zext i32 %9 to i64
%29 = shl nuw nsw i64 %28, 3
br label %30
30: ; preds = %27, %25
%31 = icmp sgt i32 %10, 0
br i1 %31, label %32, label %341
32: ; preds = %30
%33 = icmp sgt i32 %20, 0
%34 = icmp sgt i32 %12, 0
%35 = getelementptr inbounds double, double* %17, i64 1
%36 = shl i64 %19, 3
%37 = and i64 %36, 34359738360
%38 = zext i32 %12 to i64
%39 = add i32 %20, -1
%40 = zext i32 %39 to i64
%41 = add nuw nsw i64 %40, 1
%42 = getelementptr double, double* %22, i64 %41
%43 = zext i32 %39 to i64
%44 = add nuw nsw i64 %43, 1
%45 = and i64 %44, 8589934588
%46 = add nsw i64 %45, -4
%47 = lshr exact i64 %46, 2
%48 = add nuw nsw i64 %47, 1
%49 = icmp ult i32 %39, 3
%50 = and i64 %44, 8589934588
%51 = getelementptr double, double* %22, i64 %50
%52 = trunc i64 %50 to i32
%53 = and i64 %48, 1
%54 = icmp eq i64 %46, 0
%55 = and i64 %48, 9223372036854775806
%56 = icmp eq i64 %53, 0
%57 = icmp eq i64 %44, %50
br label %58
58: ; preds = %32, %336
%59 = phi double* [ %1, %32 ], [ %337, %336 ]
%60 = phi double* [ %2, %32 ], [ %338, %336 ]
%61 = phi i32 [ 0, %32 ], [ %339, %336 ]
br i1 %33, label %62, label %63
62: ; preds = %58
br label %63
63: ; preds = %62, %58
br i1 %34, label %65, label %64
64: ; preds = %193, %63
br i1 %33, label %200, label %336
65: ; preds = %63, %193
%66 = phi i64 [ %198, %193 ], [ 0, %63 ]
%67 = phi double* [ %197, %193 ], [ %22, %63 ]
%68 = phi double* [ %195, %193 ], [ %8, %63 ]
%69 = phi double* [ %194, %193 ], [ %7, %63 ]
%70 = getelementptr inbounds i32, i32* %5, i64 %66
%71 = load i32, i32* %70
%72 = mul nsw i32 %71, 3
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %3, i64 %73
%75 = getelementptr inbounds i32, i32* %4, i64 %66
%76 = load i32, i32* %75
%77 = tail call i32 @llvm.abs.i32(i32 %76, i1 true)
%78 = icmp ugt i32 %77, 3
br i1 %78, label %341, label %79
79: ; preds = %65
%80 = icmp slt i32 %76, -1
br i1 %80, label %81, label %84
81: ; preds = %79
%82 = mul nsw i32 %76, -2
%83 = or i32 %82, 1
br label %91
84: ; preds = %79
%85 = icmp eq i32 %76, -1
br i1 %85, label %91, label %86
86: ; preds = %84
%87 = add nuw nsw i32 %76, 1
%88 = add nuw nsw i32 %76, 2
%89 = mul nsw i32 %87, %88
%90 = sdiv i32 %89, 2
br label %91
91: ; preds = %86, %84, %81
%92 = phi i32 [ %83, %81 ], [ %90, %86 ], [ 4, %84 ]
%93 = getelementptr inbounds i32, i32* %6, i64 %66
%94 = load i32, i32* %93
%95 = icmp sgt i32 %94, 0
br i1 %95, label %96, label %193
96: ; preds = %91
%97 = icmp eq i32 %76, -1
%98 = getelementptr inbounds double, double* %67, i64 1
%99 = sext i1 %97 to i32
%100 = add i32 %92, %99
%101 = icmp sgt i32 %100, 0
%102 = add i32 %92, -1
%103 = add i32 %102, %99
%104 = zext i32 %103 to i64
%105 = zext i32 %103 to i64
%106 = add nuw nsw i64 %105, 1
%107 = icmp ult i32 %103, 3
%108 = and i64 %106, 8589934588
%109 = trunc i64 %108 to i32
%110 = sub i32 %100, %109
%111 = icmp eq i64 %106, %108
br label %112
112: ; preds = %96, %188
%113 = phi double* [ %68, %96 ], [ %118, %188 ]
%114 = phi double* [ %69, %96 ], [ %189, %188 ]
%115 = phi i32 [ 0, %96 ], [ %190, %188 ]
%116 = load double, double* %113
%117 = tail call i32 @gint1_fn_dispatch(i32 %76, double* %74, double %116, double* %59, double* %17)
%118 = getelementptr inbounds double, double* %113, i64 1
br i1 %97, label %119, label %125
119: ; preds = %112
%120 = load double, double* %17
%121 = load double, double* %114
%122 = load double, double* %67
%123 = tail call double @llvm.fmuladd.f64(double %120, double %121, double %122)
store double %123, double* %67
%124 = getelementptr inbounds double, double* %114, i64 1
br label %125
125: ; preds = %119, %112
%126 = phi double* [ %35, %119 ], [ %17, %112 ]
%127 = phi double* [ %124, %119 ], [ %114, %112 ]
%128 = phi double* [ %98, %119 ], [ %67, %112 ]
br i1 %101, label %129, label %188
129: ; preds = %125
br i1 %107, label %172, label %130
130: ; preds = %129
%131 = getelementptr double, double* %128, i64 1
%132 = getelementptr double, double* %131, i64 %104
%133 = getelementptr double, double* %126, i64 1
%134 = getelementptr double, double* %133, i64 %104
%135 = getelementptr double, double* %127, i64 1
%136 = icmp ult double* %128, %134
%137 = icmp ult double* %126, %132
%138 = and i1 %136, %137
%139 = icmp ult double* %128, %135
%140 = icmp ult double* %127, %132
%141 = and i1 %139, %140
%142 = or i1 %138, %141
br i1 %142, label %172, label %143
143: ; preds = %130
%144 = getelementptr double, double* %128, i64 %108
%145 = getelementptr double, double* %126, i64 %108
%146 = load double, double* %127
%147 = insertelement <2 x double> poison, double %146, i64 0
%148 = shufflevector <2 x double> %147, <2 x double> poison, <2 x i32> zeroinitializer
%149 = insertelement <2 x double> poison, double %146, i64 0
%150 = shufflevector <2 x double> %149, <2 x double> poison, <2 x i32> zeroinitializer
br label %151
151: ; preds = %151, %143
%152 = phi i64 [ 0, %143 ], [ %169, %151 ]
%153 = getelementptr double, double* %128, i64 %152
%154 = getelementptr double, double* %126, i64 %152
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = getelementptr double, double* %154, i64 2
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = bitcast double* %153 to <2 x double>*
%161 = load <2 x double>, <2 x double>* %160
%162 = getelementptr double, double* %153, i64 2
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %156, <2 x double> %148, <2 x double> %161)
%166 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %150, <2 x double> %164)
%167 = bitcast double* %153 to <2 x double>*
store <2 x double> %165, <2 x double>* %167
%168 = bitcast double* %162 to <2 x double>*
store <2 x double> %166, <2 x double>* %168
%169 = add nuw i64 %152, 4
%170 = icmp eq i64 %169, %108
br i1 %170, label %171, label %151
171: ; preds = %151
br i1 %111, label %188, label %172
172: ; preds = %130, %129, %171
%173 = phi double* [ %128, %130 ], [ %128, %129 ], [ %144, %171 ]
%174 = phi double* [ %126, %130 ], [ %126, %129 ], [ %145, %171 ]
%175 = phi i32 [ %100, %130 ], [ %100, %129 ], [ %110, %171 ]
br label %176
176: ; preds = %172, %176
%177 = phi double* [ %184, %176 ], [ %173, %172 ]
%178 = phi double* [ %185, %176 ], [ %174, %172 ]
%179 = phi i32 [ %186, %176 ], [ %175, %172 ]
%180 = load double, double* %178
%181 = load double, double* %127
%182 = load double, double* %177
%183 = tail call double @llvm.fmuladd.f64(double %180, double %181, double %182)
store double %183, double* %177
%184 = getelementptr inbounds double, double* %177, i64 1
%185 = getelementptr inbounds double, double* %178, i64 1
%186 = add nsw i32 %179, -1
%187 = icmp ugt i32 %179, 1
br i1 %187, label %176, label %188
188: ; preds = %176, %171, %125
%189 = getelementptr inbounds double, double* %127, i64 1
%190 = add nuw nsw i32 %115, 1
%191 = load i32, i32* %93
%192 = icmp slt i32 %190, %191
br i1 %192, label %112, label %193
193: ; preds = %188, %91
%194 = phi double* [ %69, %91 ], [ %189, %188 ]
%195 = phi double* [ %68, %91 ], [ %118, %188 ]
%196 = sext i32 %92 to i64
%197 = getelementptr inbounds double, double* %67, i64 %196
%198 = add nuw nsw i64 %66, 1
%199 = icmp eq i64 %198, %38
br i1 %199, label %64, label %65
200: ; preds = %64, %331
%201 = phi double* [ %332, %331 ], [ %0, %64 ]
%202 = phi double* [ %333, %331 ], [ %22, %64 ]
%203 = phi i32 [ %334, %331 ], [ 0, %64 ]
%204 = load double, double* %60
%205 = load double, double* %202
%206 = fmul double %204, %205
br i1 %49, label %277, label %207
207: ; preds = %200
%208 = getelementptr double, double* %201, i64 %41
%209 = icmp ult double* %201, %42
%210 = icmp ult double* %22, %208
%211 = and i1 %209, %210
br i1 %211, label %277, label %212
212: ; preds = %207
%213 = getelementptr double, double* %201, i64 %50
%214 = insertelement <2 x double> poison, double %206, i64 0
%215 = shufflevector <2 x double> %214, <2 x double> poison, <2 x i32> zeroinitializer
%216 = insertelement <2 x double> poison, double %206, i64 0
%217 = shufflevector <2 x double> %216, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %54, label %257, label %218
218: ; preds = %212, %218
%219 = phi i64 [ %254, %218 ], [ 0, %212 ]
%220 = phi i64 [ %255, %218 ], [ 0, %212 ]
%221 = getelementptr double, double* %201, i64 %219
%222 = getelementptr double, double* %22, i64 %219
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = getelementptr double, double* %222, i64 2
%226 = bitcast double* %225 to <2 x double>*
%227 = load <2 x double>, <2 x double>* %226
%228 = bitcast double* %221 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = getelementptr double, double* %221, i64 2
%231 = bitcast double* %230 to <2 x double>*
%232 = load <2 x double>, <2 x double>* %231
%233 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %215, <2 x double> %224, <2 x double> %229)
%234 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %217, <2 x double> %227, <2 x double> %232)
%235 = bitcast double* %221 to <2 x double>*
store <2 x double> %233, <2 x double>* %235
%236 = bitcast double* %230 to <2 x double>*
store <2 x double> %234, <2 x double>* %236
%237 = or i64 %219, 4
%238 = getelementptr double, double* %201, i64 %237
%239 = getelementptr double, double* %22, i64 %237
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr double, double* %239, i64 2
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = bitcast double* %238 to <2 x double>*
%246 = load <2 x double>, <2 x double>* %245
%247 = getelementptr double, double* %238, i64 2
%248 = bitcast double* %247 to <2 x double>*
%249 = load <2 x double>, <2 x double>* %248
%250 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %215, <2 x double> %241, <2 x double> %246)
%251 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %217, <2 x double> %244, <2 x double> %249)
%252 = bitcast double* %238 to <2 x double>*
store <2 x double> %250, <2 x double>* %252
%253 = bitcast double* %247 to <2 x double>*
store <2 x double> %251, <2 x double>* %253
%254 = add nuw i64 %219, 8
%255 = add i64 %220, 2
%256 = icmp eq i64 %255, %55
br i1 %256, label %257, label %218
257: ; preds = %218, %212
%258 = phi i64 [ 0, %212 ], [ %254, %218 ]
br i1 %56, label %276, label %259
259: ; preds = %257
%260 = getelementptr double, double* %201, i64 %258
%261 = getelementptr double, double* %22, i64 %258
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = getelementptr double, double* %261, i64 2
%265 = bitcast double* %264 to <2 x double>*
%266 = load <2 x double>, <2 x double>* %265
%267 = bitcast double* %260 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = getelementptr double, double* %260, i64 2
%270 = bitcast double* %269 to <2 x double>*
%271 = load <2 x double>, <2 x double>* %270
%272 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %215, <2 x double> %263, <2 x double> %268)
%273 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %217, <2 x double> %266, <2 x double> %271)
%274 = bitcast double* %260 to <2 x double>*
store <2 x double> %272, <2 x double>* %274
%275 = bitcast double* %269 to <2 x double>*
store <2 x double> %273, <2 x double>* %275
br label %276
276: ; preds = %257, %259
br i1 %57, label %331, label %277
277: ; preds = %207, %200, %276
%278 = phi double* [ %201, %207 ], [ %201, %200 ], [ %213, %276 ]
%279 = phi double* [ %22, %207 ], [ %22, %200 ], [ %51, %276 ]
%280 = phi i32 [ 0, %207 ], [ 0, %200 ], [ %52, %276 ]
%281 = sub i32 %20, %280
%282 = xor i32 %280, -1
%283 = add i32 %282, %20
%284 = and i32 %281, 3
%285 = icmp eq i32 %284, 0
br i1 %285, label %299, label %286
286: ; preds = %277, %286
%287 = phi double* [ %294, %286 ], [ %278, %277 ]
%288 = phi double* [ %295, %286 ], [ %279, %277 ]
%289 = phi i32 [ %296, %286 ], [ %280, %277 ]
%290 = phi i32 [ %297, %286 ], [ 0, %277 ]
%291 = load double, double* %288
%292 = load double, double* %287
%293 = tail call double @llvm.fmuladd.f64(double %206, double %291, double %292)
store double %293, double* %287
%294 = getelementptr inbounds double, double* %287, i64 1
%295 = getelementptr inbounds double, double* %288, i64 1
%296 = add nuw nsw i32 %289, 1
%297 = add i32 %290, 1
%298 = icmp eq i32 %297, %284
br i1 %298, label %299, label %286
299: ; preds = %286, %277
%300 = phi double* [ undef, %277 ], [ %294, %286 ]
%301 = phi double* [ %278, %277 ], [ %294, %286 ]
%302 = phi double* [ %279, %277 ], [ %295, %286 ]
%303 = phi i32 [ %280, %277 ], [ %296, %286 ]
%304 = icmp ult i32 %283, 3
br i1 %304, label %331, label %305
305: ; preds = %299, %305
%306 = phi double* [ %327, %305 ], [ %301, %299 ]
%307 = phi double* [ %328, %305 ], [ %302, %299 ]
%308 = phi i32 [ %329, %305 ], [ %303, %299 ]
%309 = load double, double* %307
%310 = load double, double* %306
%311 = tail call double @llvm.fmuladd.f64(double %206, double %309, double %310)
store double %311, double* %306
%312 = getelementptr inbounds double, double* %306, i64 1
%313 = getelementptr inbounds double, double* %307, i64 1
%314 = load double, double* %313
%315 = load double, double* %312
%316 = tail call double @llvm.fmuladd.f64(double %206, double %314, double %315)
store double %316, double* %312
%317 = getelementptr inbounds double, double* %306, i64 2
%318 = getelementptr inbounds double, double* %307, i64 2
%319 = load double, double* %318
%320 = load double, double* %317
%321 = tail call double @llvm.fmuladd.f64(double %206, double %319, double %320)
store double %321, double* %317
%322 = getelementptr inbounds double, double* %306, i64 3
%323 = getelementptr inbounds double, double* %307, i64 3
%324 = load double, double* %323
%325 = load double, double* %322
%326 = tail call double @llvm.fmuladd.f64(double %206, double %324, double %325)
store double %326, double* %322
%327 = getelementptr inbounds double, double* %306, i64 4
%328 = getelementptr inbounds double, double* %307, i64 4
%329 = add nuw nsw i32 %308, 4
%330 = icmp eq i32 %329, %20
br i1 %330, label %331, label %305
331: ; preds = %299, %305, %276
%332 = phi double* [ %213, %276 ], [ %300, %299 ], [ %327, %305 ]
%333 = getelementptr inbounds double, double* %202, i64 1
%334 = add nuw nsw i32 %203, 1
%335 = icmp eq i32 %334, %20
br i1 %335, label %336, label %200
336: ; preds = %331, %64
%337 = getelementptr inbounds double, double* %59, i64 3
%338 = getelementptr inbounds double, double* %60, i64 1
%339 = add nuw nsw i32 %61, 1
%340 = icmp eq i32 %339, %10
br i1 %340, label %341, label %58
341: ; preds = %336, %65, %30, %15
%342 = phi i32 [ -1, %15 ], [ 0, %30 ], [ -2, %65 ], [ 0, %336 ]
%343 = tail call i32 @free(double* %17)
%344 = tail call i32 @free(double* %22)
ret i32 %342
}