int erd__int2d_to_e000(int shella, int shellp, int ngqp, int nexq, int ngqexq,
                       int nxyzet, int nxyzp, double *int2dx, double *int2dy,
                       double *int2dz, double *temp1, double *temp2,
                       double *scale, double *batch) {
  int i, k, m, n, se, xe, ye, ze, xep;
  double sum;
  int xye, xyep, seend, yeend, xemax, nxyze;
  xep = nxyzet + 2;
  for (xe = 0; xe <= shellp; ++xe) {
    xep = xep + xe - 2;
    xemax = xe * shellp;
    yeend = shellp - xe;
    for (m = 0; m < ngqexq; ++m) {
      temp1[m] = scale[m] * int2dx[m + xe * ngqexq];
    }
    xyep = xep - xemax;
    for (ye = 0; ye <= yeend; ++ye) {
      xye = xe + ye;
      --xyep;
      seend = ((shella) < (xye) ? (xye) : (shella));
      if (ye == 0) {
        for (n = 0; n < ngqexq; ++n) {
          temp2[n] = temp1[n];
        }
      } else {
        for (n = 0; n < ngqexq; ++n) {
          temp2[n] = temp1[n] * int2dy[n + ye * ngqexq];
        }
      }
      i = xyep;
      nxyze = nxyzp;
      for (se = shellp; se >= seend; --se) {
        ze = se - xye;
        batch[i] = 0.0;
        if (ze == 0) {
          k = 0;
          for (m = 0; m < nexq; ++m) {
            sum = 0.;
            for (n = 0; n < ngqp; ++n) {
              sum += temp2[k + n];
            }
            k += ngqp;
            batch[i] += sum;
          }
        } else {
          k = 0;
          for (m = 0; m < nexq; ++m) {
            sum = 0.;
            for (n = 0; n < ngqp; ++n) {
              sum += temp2[k + n] * int2dz[k + n + ze * ngqexq];
            }
            k += ngqp;
            batch[i] += sum;
          }
        }
        i = i - nxyze + xe;
        nxyze = nxyze - se - 1;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
push   %rbp
mov    %rsp,%rbp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     148c <erd__int2d_to_e000+0x38c>
mov    -0x3c(%rbp),%eax
add    -0x30(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c5 <erd__int2d_to_e000+0xc5>
mov    0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1179 <erd__int2d_to_e000+0x79>
mov    -0x3c(%rbp),%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     1479 <erd__int2d_to_e000+0x379>
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    120a <erd__int2d_to_e000+0x10a>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1210 <erd__int2d_to_e000+0x110>
mov    -0x4(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1260 <erd__int2d_to_e000+0x160>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    125b <erd__int2d_to_e000+0x15b>
mov    0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1227 <erd__int2d_to_e000+0x127>
jmp    12b8 <erd__int2d_to_e000+0x1b8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b3 <erd__int2d_to_e000+0x1b3>
mov    0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1267 <erd__int2d_to_e000+0x167>
jmp    12b8 <erd__int2d_to_e000+0x1b8>
mov    -0x50(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jl     1466 <erd__int2d_to_e000+0x366>
mov    -0x2c(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x38(%rbp)
jne    138b <erd__int2d_to_e000+0x28b>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1386 <erd__int2d_to_e000+0x286>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1358 <erd__int2d_to_e000+0x258>
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1322 <erd__int2d_to_e000+0x222>
mov    -0xc(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1307 <erd__int2d_to_e000+0x207>
jmp    1440 <erd__int2d_to_e000+0x340>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    143b <erd__int2d_to_e000+0x33b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    140d <erd__int2d_to_e000+0x30d>
mov    0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13b4 <erd__int2d_to_e000+0x2b4>
mov    -0xc(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1399 <erd__int2d_to_e000+0x299>
jmp    1440 <erd__int2d_to_e000+0x340>
mov    -0x1c(%rbp),%eax
sub    -0x60(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x60(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ca <erd__int2d_to_e000+0x1ca>
jmp    146b <erd__int2d_to_e000+0x36b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11d5 <erd__int2d_to_e000+0xd5>
jmp    147e <erd__int2d_to_e000+0x37e>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1147 <erd__int2d_to_e000+0x47>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,-0x68(%rsp)
mov    %r8d,-0x78(%rsp)
mov    %rsi,-0x40(%rsp)
test   %esi,%esi
js     1bb8 <erd__int2d_to_e000+0xab8>
mov    %ecx,%ebx
mov    0x160(%rsp),%r8
mov    0x158(%rsp),%rbp
mov    0x150(%rsp),%rsi
mov    -0x68(%rsp),%rax
add    $0x2,%eax
mov    %rax,-0x68(%rsp)
movslq -0x78(%rsp),%r10
movslq %edi,%rax
mov    %rax,0xa0(%rsp)
mov    %r10d,%r12d
lea    (%r8,%r12,8),%rax
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,-0x48(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x50(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %rsi,%rax
seta   %r9b
lea    (%rsi,%r12,8),%r11
cmp    %r8,%r11
seta   %al
and    %r9b,%al
mov    %al,-0x71(%rsp)
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
and    %rcx,%rax
mov    %rax,-0x10(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x8(%rsp)
mov    %r11,0x38(%rsp)
cmp    %rbp,%r11
seta   %r9b
lea    0x0(,%r12,8),%rax
add    %rbp,%rax
mov    %rax,0x88(%rsp)
cmp    %rsi,%rax
seta   %al
and    %r9b,%al
mov    %al,-0x79(%rsp)
mov    %ecx,%r14d
and    $0x3,%r14d
mov    %rcx,%rax
mov    %rcx,(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x50(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x80(%rsp)
movslq %edx,%r15
mov    %r15d,%ecx
mov    %ecx,%r9d
and    $0xfffffffe,%r9d
mov    %ecx,%r11d
and    $0x3,%r11d
mov    %ecx,%r13d
and    $0xfffffffc,%r13d
mov    %r14,0x70(%rsp)
shl    $0x5,%r14
mov    %r14,0x90(%rsp)
mov    -0x40(%rsp),%r14
mov    %r14d,%edi
mov    %r10,%rax
mov    %rdi,0x10(%rsp)
imul   %rdi,%rax
mov    0x148(%rsp),%rdi
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rsp)
mov    %r10,-0x30(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,0x18(%rsp)
neg    %rax
mov    %rax,-0x28(%rsp)
mov    0x140(%rsp),%r10
mov    0x138(%rsp),%rdi
lea    0x1(%r14),%eax
mov    %rcx,0xe8(%rsp)
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x30(%rsp)
lea    0x30(%rdi),%rcx
lea    0x8(%rdi),%r14
mov    %rcx,%rdi
lea    0x30(%r10),%rcx
mov    %rcx,0x48(%rsp)
lea    0x8(%r10),%rcx
mov    %rcx,0x40(%rsp)
lea    0x10(%rbp),%rcx
mov    %rcx,0x68(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0x60(%rsp)
mov    %r15,0xf0(%rsp)
lea    0x0(,%r15,8),%r10
mov    %r14,%r15
lea    0x8(%rbp),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x18(%rbp),%rcx
mov    %rcx,0xc0(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x70(%rsp)
mov    %rax,0x58(%rsp)
mov    %eax,-0x5c(%rsp)
mov    %edx,-0x54(%rsp)
mov    %r12,0x98(%rsp)
jmp    135b <erd__int2d_to_e000+0x25b>
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rcx
add    $0x1,%rcx
addl   $0xffffffff,-0x5c(%rsp)
mov    0x18(%rsp),%rax
mov    0x78(%rsp),%rdi
add    %rax,%rdi
add    %rax,%r15
mov    -0x28(%rsp),%rax
add    %rax,-0x8(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x70(%rsp)
cmp    0x58(%rsp),%rcx
je     1bb8 <erd__int2d_to_e000+0xab8>
cmpl   $0x0,-0x78(%rsp)
jle    14ee <erd__int2d_to_e000+0x3ee>
mov    -0x70(%rsp),%rax
imul   -0x30(%rsp),%rax
cmpl   $0x4,-0x78(%rsp)
jae    1380 <erd__int2d_to_e000+0x280>
xor    %edx,%edx
jmp    1480 <erd__int2d_to_e000+0x380>
nop
mov    %rdi,%r14
lea    (%rax,%r12,1),%rcx
mov    0x138(%rsp),%rdi
lea    (%rdi,%rax,8),%rdx
lea    (%rdi,%rcx,8),%rcx
cmp    %rsi,%rcx
seta   %cl
cmp    0x38(%rsp),%rdx
setb   %dl
and    %cl,%dl
or     -0x71(%rsp),%dl
je     13b7 <erd__int2d_to_e000+0x2b7>
xor    %edx,%edx
mov    %r14,%rdi
jmp    1480 <erd__int2d_to_e000+0x380>
cmpq   $0x0,-0x50(%rsp)
je     1ba4 <erd__int2d_to_e000+0xaa4>
mov    -0x10(%rsp),%rcx
xor    %edx,%edx
mov    %r14,%rdi
nopl   (%rax)
movupd (%r8,%rdx,8),%xmm0
movupd 0x10(%r8,%rdx,8),%xmm1
movupd -0x30(%rdi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rdi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rsi,%rdx,8)
movupd %xmm0,0x10(%rsi,%rdx,8)
movupd 0x20(%r8,%rdx,8),%xmm0
movupd 0x30(%r8,%rdx,8),%xmm1
movupd -0x10(%rdi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rdi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rsi,%rdx,8)
movupd %xmm0,0x30(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    13d0 <erd__int2d_to_e000+0x2d0>
testb  $0x1,(%rsp)
je     1473 <erd__int2d_to_e000+0x373>
movupd (%r8,%rdx,8),%xmm0
movupd 0x10(%r8,%rdx,8),%xmm1
lea    (%rdx,%rax,1),%rcx
mov    0x138(%rsp),%rdi
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mov    %r14,%rdi
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rsi,%rdx,8)
movupd %xmm0,0x10(%rsi,%rdx,8)
mov    -0x48(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r12,%rcx
je     14ee <erd__int2d_to_e000+0x3ee>
mov    %rdx,%rcx
test   $0x1,%r12b
je     14ab <erd__int2d_to_e000+0x3ab>
movsd  (%r8,%rdx,8),%xmm0
add    %rdx,%rax
mov    0x138(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x8(%rsp),%rdx
je     14ee <erd__int2d_to_e000+0x3ee>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rcx,8),%xmm0
mulsd  -0x8(%r15,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
movsd  0x8(%r8,%rcx,8),%xmm0
mulsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    14c0 <erd__int2d_to_e000+0x3c0>
mov    %rdi,0x78(%rsp)
mov    -0x68(%rsp),%rax
mov    -0x70(%rsp),%rcx
add    %ecx,%eax
add    $0xfffffffe,%eax
mov    %rax,-0x68(%rsp)
cmp    0x10(%rsp),%rcx
ja     1320 <erd__int2d_to_e000+0x220>
mov    -0x70(%rsp),%rax
imul   -0x40(%rsp),%eax
mov    -0x68(%rsp),%rcx
sub    %eax,%ecx
mov    %ecx,-0x58(%rsp)
mov    -0x5c(%rsp),%eax
mov    %rax,0xa8(%rsp)
mov    -0x8(%rsp),%rax
mov    %rax,-0x38(%rsp)
mov    0x40(%rsp),%r14
mov    0x48(%rsp),%rcx
xor    %edi,%edi
mov    %r15,0xb0(%rsp)
jmp    15c6 <erd__int2d_to_e000+0x4c6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rdi
add    $0x1,%rdi
mov    0x18(%rsp),%rax
mov    0x20(%rsp),%rcx
add    %rax,%rcx
mov    0xb8(%rsp),%r14
add    %rax,%r14
mov    -0x38(%rsp),%rax
add    -0x28(%rsp),%rax
mov    %rax,-0x38(%rsp)
cmp    0xa8(%rsp),%rdi
mov    0x160(%rsp),%r8
mov    0x158(%rsp),%rbp
mov    0x150(%rsp),%rsi
mov    0x98(%rsp),%r12
mov    0xb0(%rsp),%r15
je     1320 <erd__int2d_to_e000+0x220>
mov    %rcx,0x20(%rsp)
mov    -0x70(%rsp),%rax
lea    (%rdi,%rax,1),%rcx
mov    0xa0(%rsp),%rax
cmp    %rax,%rcx
mov    %eax,%r8d
mov    %rcx,0xd8(%rsp)
cmovg  %ecx,%r8d
mov    %rdi,0x28(%rsp)
test   %rdi,%rdi
mov    0x90(%rsp),%rdi
je     16d0 <erd__int2d_to_e000+0x5d0>
cmpl   $0x0,-0x78(%rsp)
jle    1910 <erd__int2d_to_e000+0x810>
mov    0x28(%rsp),%rax
imul   -0x30(%rsp),%rax
cmpl   $0x4,-0x78(%rsp)
jb     1652 <erd__int2d_to_e000+0x552>
mov    0x140(%rsp),%rdi
lea    (%rdi,%rax,8),%rcx
lea    (%rax,%r12,1),%rdx
lea    (%rdi,%rdx,8),%rdx
cmp    %rbp,%rdx
seta   %dl
cmp    0x88(%rsp),%rcx
setb   %cl
and    %dl,%cl
or     -0x79(%rsp),%cl
je     1703 <erd__int2d_to_e000+0x603>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r12b
je     167f <erd__int2d_to_e000+0x57f>
movsd  (%rsi,%rdx,8),%xmm0
add    %rdx,%rax
mov    0x140(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x8(%rsp),%rdx
je     1910 <erd__int2d_to_e000+0x810>
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm0
mulsd  -0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm0
mulsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    1690 <erd__int2d_to_e000+0x590>
jmp    1910 <erd__int2d_to_e000+0x810>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x0,-0x78(%rsp)
jle    1910 <erd__int2d_to_e000+0x810>
cmpl   $0x4,-0x78(%rsp)
setb   %al
or     -0x79(%rsp),%al
je     16f0 <erd__int2d_to_e000+0x5f0>
xor    %eax,%eax
jmp    1890 <erd__int2d_to_e000+0x790>
cmpq   $0xc,-0x50(%rsp)
jae    17d2 <erd__int2d_to_e000+0x6d2>
xor    %eax,%eax
jmp    183d <erd__int2d_to_e000+0x73d>
cmpq   $0x0,-0x50(%rsp)
mov    0x20(%rsp),%rdi
je     1b93 <erd__int2d_to_e000+0xa93>
mov    -0x10(%rsp),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
movupd -0x30(%rdi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rdi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rdx,8)
movupd %xmm0,0x10(%rbp,%rdx,8)
movupd 0x20(%rsi,%rdx,8),%xmm0
movupd 0x30(%rsi,%rdx,8),%xmm1
movupd -0x10(%rdi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rdi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbp,%rdx,8)
movupd %xmm0,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1720 <erd__int2d_to_e000+0x620>
testb  $0x1,(%rsp)
je     17bc <erd__int2d_to_e000+0x6bc>
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
lea    (%rdx,%rax,1),%rcx
mov    0x140(%rsp),%rdi
movupd (%rdi,%rcx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x0(%rbp,%rdx,8)
movupd %xmm0,0x10(%rbp,%rdx,8)
mov    -0x48(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r12,%rcx
je     1910 <erd__int2d_to_e000+0x810>
jmp    1654 <erd__int2d_to_e000+0x554>
mov    0x50(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rsi,%rax,8),%xmm0
movups 0x10(%rsi,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movups 0x20(%rsi,%rax,8),%xmm0
movups 0x30(%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rbp,%rax,8)
movups %xmm1,0x30(%rbp,%rax,8)
movups 0x40(%rsi,%rax,8),%xmm0
movups 0x50(%rsi,%rax,8),%xmm1
movups %xmm0,0x40(%rbp,%rax,8)
movups %xmm1,0x50(%rbp,%rax,8)
movupd 0x60(%rsi,%rax,8),%xmm0
movupd 0x70(%rsi,%rax,8),%xmm1
movupd %xmm0,0x60(%rbp,%rax,8)
movupd %xmm1,0x70(%rbp,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    17e0 <erd__int2d_to_e000+0x6e0>
cmpq   $0x0,0x70(%rsp)
je     187f <erd__int2d_to_e000+0x77f>
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1860 <erd__int2d_to_e000+0x760>
mov    -0x48(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     1910 <erd__int2d_to_e000+0x810>
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
mov    0x80(%rsp),%rdx
test   %rdx,%rdx
je     18c5 <erd__int2d_to_e000+0x7c5>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18b0 <erd__int2d_to_e000+0x7b0>
cmp    $0x3,%rcx
jb     1910 <erd__int2d_to_e000+0x810>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    18d0 <erd__int2d_to_e000+0x7d0>
nopl   0x0(%rax,%rax,1)
mov    %r14,0xb8(%rsp)
addl   $0xffffffff,-0x58(%rsp)
cmp    -0x40(%rsp),%r8d
mov    -0x54(%rsp),%edx
jg     1560 <erd__int2d_to_e000+0x460>
movslq %r8d,%rax
mov    %rax,0xd0(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x20(%rsp)
mov    0x10(%rsp),%rcx
mov    0x130(%rsp),%esi
mov    -0x58(%rsp),%ebp
jmp    19a0 <erd__int2d_to_e000+0x8a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x18(%rsp),%ebp
add    -0x70(%rsp),%ebp
mov    -0x14(%rsp),%esi
sub    %esi,%ebp
mov    0xe0(%rsp),%rdi
mov    %edi,%eax
not    %eax
add    %eax,%esi
lea    -0x1(%rdi),%rax
mov    -0x20(%rsp),%rcx
add    -0x28(%rsp),%rcx
mov    %rcx,-0x20(%rsp)
cmp    0xd0(%rsp),%rdi
mov    %rax,%rcx
jle    1560 <erd__int2d_to_e000+0x460>
mov    %rcx,%r14
sub    0xd8(%rsp),%r14
movslq %ebp,%r15
mov    0x168(%rsp),%rax
movq   $0x0,(%rax,%r15,8)
test   %r14d,%r14d
mov    %esi,-0x14(%rsp)
mov    %rcx,0xe0(%rsp)
mov    %ebp,-0x18(%rsp)
je     1ad0 <erd__int2d_to_e000+0x9d0>
test   %ebx,%ebx
jle    1960 <erd__int2d_to_e000+0x860>
imul   -0x30(%rsp),%r14
xor    %r8d,%r8d
xorpd  %xmm0,%xmm0
mov    0xc8(%rsp),%rsi
mov    -0x20(%rsp),%r12
xor    %eax,%eax
jmp    1a2b <erd__int2d_to_e000+0x92b>
nopl   0x0(%rax)
addsd  %xmm1,%xmm0
add    0xf0(%rsp),%r8
mov    0x168(%rsp),%rcx
movsd  %xmm0,(%rcx,%r15,8)
add    $0x1,%eax
add    %r10,%r12
add    %r10,%rsi
cmp    %ebx,%eax
je     1960 <erd__int2d_to_e000+0x860>
xorpd  %xmm1,%xmm1
test   %edx,%edx
jle    1a00 <erd__int2d_to_e000+0x900>
cmpq   $0x0,0x30(%rsp)
je     1a90 <erd__int2d_to_e000+0x990>
xorpd  %xmm2,%xmm2
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdi,8),%xmm3
movsd  (%rsi,%rdi,8),%xmm1
mulsd  -0x8(%r12,%rdi,8),%xmm3
mulsd  (%r12,%rdi,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x2,%rdi
movapd %xmm1,%xmm2
cmp    %rdi,%r9
jne    1a50 <erd__int2d_to_e000+0x950>
testb  $0x1,0xe8(%rsp)
01
je     1a00 <erd__int2d_to_e000+0x900>
jmp    1aa4 <erd__int2d_to_e000+0x9a4>
nopl   (%rax)
xorpd  %xmm1,%xmm1
xor    %edi,%edi
testb  $0x1,0xe8(%rsp)
01
je     1a00 <erd__int2d_to_e000+0x900>
add    %r8,%rdi
mov    0x158(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm2
add    %r14,%rdi
mov    0x148(%rsp),%rcx
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
jmp    1a00 <erd__int2d_to_e000+0x900>
nopl   (%rax)
test   %ebx,%ebx
jle    1960 <erd__int2d_to_e000+0x860>
xor    %esi,%esi
xorpd  %xmm0,%xmm0
mov    0x158(%rsp),%rdi
mov    0xc0(%rsp),%rbp
jmp    1b19 <erd__int2d_to_e000+0xa19>
addsd  %xmm1,%xmm0
mov    0x168(%rsp),%rcx
movsd  %xmm0,(%rcx,%r15,8)
add    $0x1,%esi
add    %r10,%rbp
add    %r10,%rdi
mov    %eax,%ebx
cmp    %eax,%esi
mov    -0x54(%rsp),%edx
je     1960 <erd__int2d_to_e000+0x860>
mov    %ebx,%eax
xorpd  %xmm1,%xmm1
test   %edx,%edx
jle    1af0 <erd__int2d_to_e000+0x9f0>
cmpq   $0x3,0x30(%rsp)
jae    1b40 <erd__int2d_to_e000+0xa40>
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
jmp    1b71 <erd__int2d_to_e000+0xa71>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
addsd  -0x18(%rbp,%rbx,8),%xmm1
addsd  -0x10(%rbp,%rbx,8),%xmm1
addsd  -0x8(%rbp,%rbx,8),%xmm1
addsd  0x0(%rbp,%rbx,8),%xmm1
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1b50 <erd__int2d_to_e000+0xa50>
test   %r11,%r11
je     1af0 <erd__int2d_to_e000+0x9f0>
lea    (%rdi,%rbx,8),%rbx
xor    %ecx,%ecx
addsd  (%rbx,%rcx,8),%xmm1
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1b80 <erd__int2d_to_e000+0xa80>
jmp    1af0 <erd__int2d_to_e000+0x9f0>
xor    %edx,%edx
testb  $0x1,(%rsp)
jne    1786 <erd__int2d_to_e000+0x686>
jmp    17bc <erd__int2d_to_e000+0x6bc>
xor    %edx,%edx
mov    %r14,%rdi
testb  $0x1,(%rsp)
jne    1439 <erd__int2d_to_e000+0x339>
jmp    1473 <erd__int2d_to_e000+0x373>
xor    %eax,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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