#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);
double sqrt(double);
int gint1_fn_dmat(double *dmat, double *density, double *points,
                  double *centers, int *shell_types, int *shell_map,
                  int *num_primitives, double *ccoeffs, double *exponents,
                  int num_dmat, 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, *dmat_element;
  double tmp;
  result = 0;
  work = malloc(10 * sizeof(double));
  if (work == NULL) {
    result = -1;
    goto EXIT;
  };
  num_dof = ((int)(sqrt(1.0 + 8.0 * num_dmat) - 1.0)) / 2;
  basis_fns = malloc(num_dof * sizeof(double));
  if (basis_fns == NULL) {
    result = -1;
    goto EXIT;
  };
  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;
    }
    *density = 0.0;
    dmat_element = dmat;
    fn1 = basis_fns;
    for (dof1 = 0; dof1 < num_dof; dof1++) {
      fn2 = basis_fns;
      tmp = 0.0;
      for (dof2 = 0; dof2 < dof1; dof2++) {
        tmp += (*fn2) * (*dmat_element);
        dmat_element++;
        fn2++;
      }
      tmp *= 2;
      tmp += (*fn1) * (*dmat_element);
      dmat_element++;
      *density += tmp * (*fn1);
      fn1++;
    }
    density++;
    points += 3;
  }
EXIT:
  free(work);
  free(basis_fns);
  return result;
}


x86 assembly (clang, -O0):
<gint1_fn_dmat>:
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_dmat+0x6d>
movl   $0xffffffff,-0x50(%rbp)
jmp    1667 <gint1_fn_dmat+0x517>
cvtsi2sdl 0x28(%rbp),%xmm0
movsd  0xe3e(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe2a(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
movsd  0xe19(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
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    122a <gint1_fn_dmat+0xda>
movl   $0xffffffff,-0x50(%rbp)
jmp    1667 <gint1_fn_dmat+0x517>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1662 <gint1_fn_dmat+0x512>
mov    -0x88(%rbp),%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    128c <gint1_fn_dmat+0x13c>
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    1252 <gint1_fn_dmat+0x102>
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    14da <gint1_fn_dmat+0x38a>
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    1306 <gint1_fn_dmat+0x1b6>
movl   $0xfffffffe,-0x50(%rbp)
jmp    1667 <gint1_fn_dmat+0x517>
cmpl   $0xffffffff,-0x38(%rbp)
jge    1325 <gint1_fn_dmat+0x1d5>
imul   $0xfffffffe,-0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1368 <gint1_fn_dmat+0x218>
cmpl   $0xffffffff,-0x38(%rbp)
jne    133f <gint1_fn_dmat+0x1ef>
mov    $0x4,%eax
mov    %eax,-0xb8(%rbp)
jmp    135c <gint1_fn_dmat+0x20c>
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    14b1 <gint1_fn_dmat+0x361>
mov    -0x38(%rbp),%edi
mov    -0x70(%rbp),%rsi
mov    -0x80(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%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    1425 <gint1_fn_dmat+0x2d5>
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    1497 <gint1_fn_dmat+0x347>
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    143a <gint1_fn_dmat+0x2ea>
mov    -0x78(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1378 <gint1_fn_dmat+0x228>
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    12b1 <gint1_fn_dmat+0x161>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
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    163c <gint1_fn_dmat+0x4ec>
mov    -0x88(%rbp),%rax
mov    %rax,-0xa0(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    159d <gint1_fn_dmat+0x44d>
mov    -0xa0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
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    1531 <gint1_fn_dmat+0x3e1>
movsd  0xa6b(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x98(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%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    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1505 <gint1_fn_dmat+0x3b5>
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x18,%rax
mov    %rax,-0x18(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1231 <gint1_fn_dmat+0xe1>
jmp    1667 <gint1_fn_dmat+0x517>
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_dmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0x80(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rsi,%r14
mov    %rdi,0x58(%rsp)
mov    $0x50,%edi
call   1060 <malloc@plt>
cvtsi2sdl 0x108(%rsp),%xmm0
mulsd  0xe65(%rip),%xmm0
addsd  0xe65(%rip),%xmm0
mov    %rax,0x10(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     11b8 <gint1_fn_dmat+0x68>
sqrtsd %xmm0,%xmm0
jmp    11bd <gint1_fn_dmat+0x6d>
call   1070 <sqrt@plt>
addsd  0xe4b(%rip),%xmm0
cvttsd2si %xmm0,%r12d
mov    %r12d,%r13d
shr    $0x1f,%r13d
add    %r12d,%r13d
sar    %r13d
lea    0x0(,%r13,8),%edi
call   1060 <malloc@plt>
mov    %rax,%r15
test   %rax,%rax
je     16ae <gint1_fn_dmat+0x55e>
cmpl   $0x0,0x110(%rsp)
jle    16c1 <gint1_fn_dmat+0x571>
mov    0x10(%rsp),%rcx
mov    %rcx,%rax
add    $0x8,%rax
mov    %rax,0x90(%rsp)
lea    -0x1(%r13),%eax
lea    0x8(,%rax,8),%rax
mov    %rax,0x48(%rsp)
xor    %eax,%eax
mov    %r15,0x20(%rsp)
mov    %r12d,0x2c(%rsp)
mov    %r13,0x50(%rsp)
jmp    125f <gint1_fn_dmat+0x10f>
cs nopw 0x0(%rax,%rax,1)
add    $0x8,%r14
addq   $0x18,0x38(%rsp)
mov    0x60(%rsp),%rax
add    $0x1,%eax
cmp    0x110(%rsp),%eax
je     16ec <gint1_fn_dmat+0x59c>
mov    %rax,0x60(%rsp)
mov    %r14,0x68(%rsp)
cmp    $0x2,%r12d
jl     1283 <gint1_fn_dmat+0x133>
mov    %r15,%rdi
xor    %esi,%esi
mov    0x48(%rsp),%rdx
call   1050 <memset@plt>
mov    0x10(%rsp),%rcx
cmpl   $0x0,0x120(%rsp)
jle    1570 <gint1_fn_dmat+0x420>
xor    %r10d,%r10d
mov    0x20(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x100(%rsp),%r11
mov    0xf8(%rsp),%r13
jmp    12d7 <gint1_fn_dmat+0x187>
movslq 0x30(%rsp),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    %rdx,0x8(%rsp)
add    $0x1,%r10
mov    0x120(%rsp),%eax
cmp    %rax,%r10
je     1570 <gint1_fn_dmat+0x420>
mov    0x80(%rsp),%rax
mov    (%rax,%r10,4),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
cmp    $0x3,%eax
ja     16b5 <gint1_fn_dmat+0x565>
cmp    $0xfffffffe,%ebx
jg     1310 <gint1_fn_dmat+0x1c0>
mov    $0x1,%esi
sub    %ebx,%esi
sub    %ebx,%esi
jmp    1330 <gint1_fn_dmat+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0xffffffff,%ebx
je     1329 <gint1_fn_dmat+0x1d9>
lea    0x1(%rbx),%eax
lea    0x2(%rbx),%edx
imul   %eax,%edx
mov    %edx,%esi
shr    $0x1f,%esi
add    %edx,%esi
sar    %esi
jmp    1330 <gint1_fn_dmat+0x1e0>
mov    $0x4,%esi
xchg   %ax,%ax
mov    0xf0(%rsp),%rax
cmpl   $0x0,(%rax,%r10,4)
mov    %esi,0x30(%rsp)
jle    12b0 <gint1_fn_dmat+0x160>
mov    0x78(%rsp),%rax
movslq (%rax,%r10,4),%rax
lea    (%rax,%rax,2),%rax
mov    0x70(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0xa8(%rsp)
xor    %eax,%eax
cmp    $0xffffffff,%ebx
sete   %al
mov    0x8(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0x98(%rsp)
mov    %esi,%edx
sub    %eax,%edx
lea    -0x1(%rdx),%eax
mov    %rax,0xa0(%rsp)
add    $0x1,%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %rdx,0x18(%rsp)
mov    %edx,%eax
sub    %ebp,%eax
mov    %eax,0x34(%rsp)
xor    %r14d,%r14d
mov    %rbx,0xb0(%rsp)
mov    %rbp,0x40(%rsp)
jmp    13e6 <gint1_fn_dmat+0x296>
nop
add    $0x8,%r11
add    $0x8,%r13
add    $0x1,%r14d
mov    0xf0(%rsp),%rax
cmp    (%rax,%r10,4),%r14d
mov    0xb0(%rsp),%rbx
jge    12b0 <gint1_fn_dmat+0x160>
mov    %r10,%r15
mov    %r11,%rbp
movsd  (%r11),%xmm0
mov    %ebx,%edi
mov    0xa8(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    %rcx,%r12
call   1040 <gint1_fn_dispatch@plt>
cmp    $0xffffffff,%ebx
je     1420 <gint1_fn_dmat+0x2d0>
mov    %r12,%rbx
mov    0x8(%rsp),%rsi
jmp    144d <gint1_fn_dmat+0x2fd>
nopw   0x0(%rax,%rax,1)
movsd  (%r12),%xmm0
mulsd  0x0(%r13),%xmm0
mov    0x8(%rsp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
add    $0x8,%r13
mov    0x90(%rsp),%rbx
mov    0x98(%rsp),%rsi
mov    %r12,%rcx
mov    %r15,%r10
mov    %rbp,%r11
mov    0x40(%rsp),%rbp
cmpl   $0x0,0x18(%rsp)
jle    13c0 <gint1_fn_dmat+0x270>
mov    0xa0(%rsp),%rax
cmp    $0x3,%eax
jb     1520 <gint1_fn_dmat+0x3d0>
lea    (%rsi,%rax,8),%rdx
add    $0x8,%rdx
lea    (%rbx,%rax,8),%rax
add    $0x8,%rax
lea    0x8(%r13),%rdi
cmp    %rax,%rsi
setb   %r8b
cmp    %rdx,%rbx
setb   %r9b
cmp    %rdi,%rsi
setb   %al
cmp    %rdx,%r13
setb   %dl
test   %r9b,%r8b
jne    1520 <gint1_fn_dmat+0x3d0>
and    %dl,%al
jne    1520 <gint1_fn_dmat+0x3d0>
lea    (%rsi,%rbp,8),%rax
lea    (%rbx,%rbp,8),%rdx
movsd  0x0(%r13),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rbx,%rdi,8),%xmm1
movupd 0x10(%rbx,%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,%rbp
jne    14d0 <gint1_fn_dmat+0x380>
mov    0x34(%rsp),%edi
cmp    %rbp,0x88(%rsp)
je     13c0 <gint1_fn_dmat+0x270>
jmp    152d <gint1_fn_dmat+0x3dd>
xchg   %ax,%ax
mov    %rsi,%rax
mov    %rbx,%rdx
mov    0x18(%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  0x0(%r13),%xmm0
addsd  (%rax,%rsi,1),%xmm0
movsd  %xmm0,(%rax,%rsi,1)
add    $0x8,%rsi
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     1540 <gint1_fn_dmat+0x3f0>
jmp    13c0 <gint1_fn_dmat+0x270>
cs nopw 0x0(%rax,%rax,1)
mov    0x68(%rsp),%r14
movq   $0x0,(%r14)
mov    0x2c(%rsp),%r12d
cmp    $0x2,%r12d
mov    0x20(%rsp),%r15
mov    0x50(%rsp),%r13
jl     1240 <gint1_fn_dmat+0xf0>
xor    %r8d,%r8d
xorpd  %xmm0,%xmm0
mov    0x58(%rsp),%rdx
mov    %r15,%r9
xor    %eax,%eax
jmp    15ee <gint1_fn_dmat+0x49e>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
addsd  %xmm1,%xmm1
movsd  (%r9),%xmm2
movsd  (%rdx),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
add    $0x8,%rdx
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
movsd  %xmm0,(%r14)
add    $0x8,%r9
add    $0x1,%eax
add    $0x1,%r8
cmp    %r13d,%eax
je     1240 <gint1_fn_dmat+0xf0>
test   %eax,%eax
je     15b0 <gint1_fn_dmat+0x460>
lea    -0x1(%rax),%esi
xorpd  %xmm1,%xmm1
cmp    $0x3,%esi
jae    1610 <gint1_fn_dmat+0x4c0>
mov    %r15,%rdi
test   $0x3,%al
jne    167f <gint1_fn_dmat+0x52f>
jmp    15b4 <gint1_fn_dmat+0x464>
nopw   0x0(%rax,%rax,1)
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
xor    %ebp,%ebp
nop
movsd  (%r15,%rbx,8),%xmm2
mulsd  (%rdx,%rbx,8),%xmm2
movsd  0x8(%r15,%rbx,8),%xmm3
addsd  %xmm1,%xmm2
mulsd  0x8(%rdx,%rbx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  0x10(%r15,%rbx,8),%xmm2
mulsd  0x10(%rdx,%rbx,8),%xmm2
addsd  %xmm3,%xmm2
movsd  0x18(%r15,%rbx,8),%xmm1
mulsd  0x18(%rdx,%rbx,8),%xmm1
addsd  %xmm2,%xmm1
add    $0xffffffffffffffe0,%rbp
add    $0x4,%rbx
cmp    %ebx,%edi
jne    1620 <gint1_fn_dmat+0x4d0>
sub    %rbp,%rdx
mov    %r15,%rdi
sub    %rbp,%rdi
test   $0x3,%al
je     15b4 <gint1_fn_dmat+0x464>
mov    %eax,%esi
and    $0x3,%esi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rbp,1),%xmm2
mulsd  (%rdx,%rbp,1),%xmm2
addsd  %xmm2,%xmm1
add    $0x8,%rbp
cmp    %ebp,%esi
jne    1690 <gint1_fn_dmat+0x540>
add    %rbp,%rdx
jmp    15b4 <gint1_fn_dmat+0x464>
mov    $0xffffffff,%ebp
jmp    16c3 <gint1_fn_dmat+0x573>
mov    $0xfffffffe,%ebp
mov    0x20(%rsp),%r15
jmp    16c8 <gint1_fn_dmat+0x578>
xor    %ebp,%ebp
mov    0x10(%rsp),%rcx
mov    %rcx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
jmp    16c8 <gint1_fn_dmat+0x578>

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

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