int add_DTD_upper(double *lhsbnd, int nk, double lam, int pord) {
  int j, k, bw = 3;
  if (lam > 0.) {
    if (pord == 0) {
      for (k = 0; k < nk; ++k)
        lhsbnd[k + 3 * nk] += lam;
    }
    if (pord == 1) {
      lhsbnd[0 + 3 * nk] += lam;
      for (k = 1; k < nk - 1; ++k)
        lhsbnd[k + 3 * nk] += 2 * lam;
      lhsbnd[k + 3 * nk] += lam;
      for (k = 1; k < nk; ++k)
        lhsbnd[k + 2 * nk] -= lam;
    }
    if (pord == 2) {
      lhsbnd[0 + 3 * nk] += lam;
      lhsbnd[1 + 3 * nk] += 5 * lam;
      for (k = 2; k < nk - 2; ++k)
        lhsbnd[k + 3 * nk] += 6 * lam;
      lhsbnd[k + 3 * nk] += 5 * lam;
      lhsbnd[++k + 3 * nk] += lam;
      lhsbnd[1 + 2 * nk] += -2 * lam;
      for (k = 2; k < nk - 1; ++k)
        lhsbnd[k + 2 * nk] += -4 * lam;
      lhsbnd[k + 2 * nk] += -2 * lam;
      for (k = 2; k < nk; ++k)
        lhsbnd[k + 1 * nk] += lam;
    }
  }
  for (j = 0; j < bw; ++j)
    for (k = bw - j; k < nk; ++k)
      lhsbnd[(k - bw + j) + (2 * bw - j) * nk] = lhsbnd[k + j * nk];
  return 0;
}


x86 assembly (clang, -O0):
<add_DTD_upper>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movl   $0x3,-0x28(%rbp)
movsd  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1449 <add_DTD_upper+0x349>
cmpl   $0x0,-0x1c(%rbp)
jne    117b <add_DTD_upper+0x7b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1176 <add_DTD_upper+0x76>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113d <add_DTD_upper+0x3d>
jmp    117b <add_DTD_upper+0x7b>
cmpl   $0x1,-0x1c(%rbp)
jne    1259 <add_DTD_upper+0x159>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11ef <add_DTD_upper+0xef>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a9 <add_DTD_upper+0xa9>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1254 <add_DTD_upper+0x154>
movsd  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1215 <add_DTD_upper+0x115>
jmp    1259 <add_DTD_upper+0x159>
cmpl   $0x2,-0x1c(%rbp)
jne    1444 <add_DTD_upper+0x344>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xd60(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1302 <add_DTD_upper+0x202>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xd29(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b4 <add_DTD_upper+0x1b4>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xcdc(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp)
imul   $0x3,-0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13d4 <add_DTD_upper+0x2d4>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xc4f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1384 <add_DTD_upper+0x284>
movsd  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    143f <add_DTD_upper+0x33f>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%edx
shl    $0x0,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1404 <add_DTD_upper+0x304>
jmp    1444 <add_DTD_upper+0x344>
jmp    1449 <add_DTD_upper+0x349>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14ce <add_DTD_upper+0x3ce>
mov    -0x28(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14bb <add_DTD_upper+0x3bb>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x1,%edx
sub    -0x20(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1465 <add_DTD_upper+0x365>
jmp    14c0 <add_DTD_upper+0x3c0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1450 <add_DTD_upper+0x350>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<add_DTD_upper>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1867 <add_DTD_upper+0x767>
cmp    $0x2,%edx
je     1480 <add_DTD_upper+0x380>
cmp    $0x1,%edx
je     114d <add_DTD_upper+0x4d>
test   %edx,%edx
jne    1867 <add_DTD_upper+0x767>
test   %esi,%esi
jle    180a <add_DTD_upper+0x70a>
lea    (%rsi,%rsi,2),%eax
movslq %eax,%r8
mov    %esi,%r10d
cmp    $0x4,%esi
jae    121d <add_DTD_upper+0x11d>
xor    %ecx,%ecx
jmp    12cc <add_DTD_upper+0x1cc>
lea    (%rsi,%rsi,2),%r8d
movslq %r8d,%r9
movsd  (%rdi,%r9,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%r9,8)
mov    $0x1,%r10d
cmp    $0x3,%esi
jl     1357 <add_DTD_upper+0x257>
lea    -0x1(%rsi),%r10d
mov    %r10d,%r15d
lea    -0x1(%r15),%r11
mov    $0x1,%ecx
cmp    $0x4,%r11
jb     1326 <add_DTD_upper+0x226>
mov    %r11,%rcx
and    $0xfffffffffffffffc,%rcx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     12ec <add_DTD_upper+0x1ec>
mov    %r14,%r12
and    $0xfffffffffffffffe,%r12
lea    (%rdi,%r9,8),%rax
add    $0x38,%rax
xor    %ebx,%ebx
movapd %xmm1,%xmm2
addpd  %xmm1,%xmm2
nopl   (%rax)
movupd -0x30(%rax,%rbx,8),%xmm3
movupd -0x20(%rax,%rbx,8),%xmm4
movupd -0x10(%rax,%rbx,8),%xmm5
movupd (%rax,%rbx,8),%xmm6
addpd  %xmm2,%xmm3
addpd  %xmm2,%xmm4
movupd %xmm3,-0x30(%rax,%rbx,8)
movupd %xmm4,-0x20(%rax,%rbx,8)
addpd  %xmm2,%xmm5
addpd  %xmm2,%xmm6
movupd %xmm5,-0x10(%rax,%rbx,8)
movupd %xmm6,(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r12
jne    11d0 <add_DTD_upper+0xd0>
jmp    12ee <add_DTD_upper+0x1ee>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     129a <add_DTD_upper+0x19a>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdi,%r8,8),%rax
add    $0x30,%rax
xor    %ebx,%ebx
movupd -0x30(%rax,%rbx,8),%xmm2
movupd -0x20(%rax,%rbx,8),%xmm3
movupd -0x10(%rax,%rbx,8),%xmm4
movupd (%rax,%rbx,8),%xmm5
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rax,%rbx,8)
movupd %xmm3,-0x20(%rax,%rbx,8)
addpd  %xmm1,%xmm4
addpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rax,%rbx,8)
movupd %xmm5,(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1250 <add_DTD_upper+0x150>
jmp    129c <add_DTD_upper+0x19c>
xor    %ebx,%ebx
test   $0x1,%r9b
je     12c3 <add_DTD_upper+0x1c3>
add    %r8,%rbx
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm3,0x10(%rdi,%rbx,8)
cmp    %r10,%rcx
je     1867 <add_DTD_upper+0x767>
lea    (%rdi,%r8,8),%rax
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    12d0 <add_DTD_upper+0x1d0>
jmp    1867 <add_DTD_upper+0x767>
xor    %ebx,%ebx
test   $0x1,%r14b
je     131d <add_DTD_upper+0x21d>
or     $0x1,%rbx
add    %r9,%rbx
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
addpd  %xmm1,%xmm1
addpd  %xmm1,%xmm2
addpd  %xmm3,%xmm1
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm1,0x10(%rdi,%rbx,8)
cmp    %rcx,%r11
je     1357 <add_DTD_upper+0x257>
or     $0x1,%rcx
lea    (%rdi,%r9,8),%rax
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1340 <add_DTD_upper+0x240>
add    %r8d,%r10d
movslq %r10d,%rax
movsd  (%rdi,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
cmp    $0x2,%esi
jl     1477 <add_DTD_upper+0x377>
lea    (%rsi,%rsi,1),%eax
movslq %eax,%r8
mov    %esi,%r11d
lea    -0x1(%r11),%r9
mov    $0x1,%ecx
cmp    $0x4,%r9
jb     1450 <add_DTD_upper+0x350>
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     141a <add_DTD_upper+0x31a>
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
lea    (%rdi,%r8,8),%rax
add    $0x38,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rax,%rbx,8),%xmm2
movupd -0x20(%rax,%rbx,8),%xmm3
movupd -0x10(%rax,%rbx,8),%xmm4
movupd (%rax,%rbx,8),%xmm5
subpd  %xmm1,%xmm2
subpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rax,%rbx,8)
movupd %xmm3,-0x20(%rax,%rbx,8)
subpd  %xmm1,%xmm4
subpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rax,%rbx,8)
movupd %xmm5,(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r14
jne    13d0 <add_DTD_upper+0x2d0>
jmp    141c <add_DTD_upper+0x31c>
xor    %ebx,%ebx
test   $0x1,%r10b
je     1447 <add_DTD_upper+0x347>
or     $0x1,%rbx
add    %r8,%rbx
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
subpd  %xmm1,%xmm2
subpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm3,0x10(%rdi,%rbx,8)
cmp    %rcx,%r9
je     1477 <add_DTD_upper+0x377>
or     $0x1,%rcx
lea    (%rdi,%r8,8),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1460 <add_DTD_upper+0x360>
cmp    $0x2,%edx
jne    1867 <add_DTD_upper+0x767>
lea    (%rsi,%rsi,2),%r9d
movslq %r9d,%r15
movsd  (%rdi,%r15,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%r15,8)
movsd  0xb61(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x8(%rdi,%r15,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rdi,%r15,8)
mov    $0x2,%r8d
mov    $0x2,%r10d
cmp    $0x5,%esi
jl     15e7 <add_DTD_upper+0x4e7>
lea    -0x2(%rsi),%r10d
mov    %r10d,%r12d
lea    -0x2(%r12),%r11
mov    $0x2,%edx
cmp    $0x4,%r11
jb     15b8 <add_DTD_upper+0x4b8>
mov    %r11,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
lea    -0x4(%rdx),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     157a <add_DTD_upper+0x47a>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%r15,8),%rcx
add    $0x40,%rcx
xor    %ebx,%ebx
movapd 0xaff(%rip),%xmm3
mulpd  %xmm2,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rcx,%rbx,8),%xmm4
movupd -0x20(%rcx,%rbx,8),%xmm5
movupd -0x10(%rcx,%rbx,8),%xmm6
movupd (%rcx,%rbx,8),%xmm7
addpd  %xmm3,%xmm4
addpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rcx,%rbx,8)
movupd %xmm5,-0x20(%rcx,%rbx,8)
addpd  %xmm3,%xmm6
addpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%rcx,%rbx,8)
movupd %xmm7,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1530 <add_DTD_upper+0x430>
jmp    157c <add_DTD_upper+0x47c>
xor    %ebx,%ebx
test   $0x1,%r14b
je     15af <add_DTD_upper+0x4af>
or     $0x2,%rbx
add    %r15,%rbx
movupd (%rdi,%rbx,8),%xmm3
movupd 0x10(%rdi,%rbx,8),%xmm4
mulpd  0xa84(%rip),%xmm2
addpd  %xmm2,%xmm3
addpd  %xmm4,%xmm2
movupd %xmm3,(%rdi,%rbx,8)
movupd %xmm2,0x10(%rdi,%rbx,8)
cmp    %rdx,%r11
je     15e7 <add_DTD_upper+0x4e7>
or     $0x2,%rdx
lea    (%rdi,%r15,8),%rax
movsd  0xa44(%rip),%xmm2
mulsd  %xmm0,%xmm2
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    15d0 <add_DTD_upper+0x4d0>
lea    (%r10,%r9,1),%eax
cltq
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
lea    (%r10,%r9,1),%eax
add    $0x1,%eax
cltq
movsd  (%rdi,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
lea    (%rsi,%rsi,1),%r11d
lea    0x1(%rsi,%rsi,1),%eax
cltq
movsd  (%rdi,%rax,8),%xmm2
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
cmp    $0x4,%esi
jl     1757 <add_DTD_upper+0x657>
lea    -0x1(%rsi),%r8d
movslq %r11d,%r9
mov    %r8d,%r15d
lea    -0x2(%r15),%r10
mov    $0x2,%edx
cmp    $0x4,%r10
jb     1728 <add_DTD_upper+0x628>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
lea    -0x4(%rdx),%rax
mov    %rax,%r14
shr    $0x2,%r14
add    $0x1,%r14
test   %rax,%rax
je     16ea <add_DTD_upper+0x5ea>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rdi,%r9,8),%rax
add    $0x40,%rax
xor    %ebx,%ebx
movapd 0x9a0(%rip),%xmm3
mulpd  %xmm2,%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rax,%rbx,8),%xmm4
movupd -0x20(%rax,%rbx,8),%xmm5
movupd -0x10(%rax,%rbx,8),%xmm6
movupd (%rax,%rbx,8),%xmm7
addpd  %xmm3,%xmm4
addpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rax,%rbx,8)
movupd %xmm5,-0x20(%rax,%rbx,8)
addpd  %xmm3,%xmm6
addpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%rax,%rbx,8)
movupd %xmm7,(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    16a0 <add_DTD_upper+0x5a0>
jmp    16ec <add_DTD_upper+0x5ec>
xor    %ebx,%ebx
test   $0x1,%r14b
je     171f <add_DTD_upper+0x61f>
or     $0x2,%rbx
add    %r9,%rbx
movupd (%rdi,%rbx,8),%xmm3
movupd 0x10(%rdi,%rbx,8),%xmm4
mulpd  0x924(%rip),%xmm2
addpd  %xmm2,%xmm3
addpd  %xmm4,%xmm2
movupd %xmm3,(%rdi,%rbx,8)
movupd %xmm2,0x10(%rdi,%rbx,8)
cmp    %rdx,%r10
je     1757 <add_DTD_upper+0x657>
or     $0x2,%rdx
lea    (%rdi,%r9,8),%rax
movsd  0x8dc(%rip),%xmm2
mulsd  %xmm0,%xmm2
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1740 <add_DTD_upper+0x640>
add    %r11d,%r8d
movslq %r8d,%rax
movsd  (%rdi,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  %xmm2,(%rdi,%rax,8)
cmp    $0x3,%esi
jl     180a <add_DTD_upper+0x70a>
mov    %esi,%r10d
lea    -0x2(%r10),%r8
mov    $0x2,%ecx
cmp    $0x4,%r8
jb     1848 <add_DTD_upper+0x748>
mov    %r8,%rcx
and    $0xfffffffffffffffc,%rcx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     1812 <add_DTD_upper+0x712>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdi,%r10,8),%rax
add    $0x40,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movupd -0x30(%rax,%rbx,8),%xmm2
movupd -0x20(%rax,%rbx,8),%xmm3
movupd -0x10(%rax,%rbx,8),%xmm4
movupd (%rax,%rbx,8),%xmm5
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rax,%rbx,8)
movupd %xmm3,-0x20(%rax,%rbx,8)
addpd  %xmm1,%xmm4
addpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rax,%rbx,8)
movupd %xmm5,(%rax,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    17c0 <add_DTD_upper+0x6c0>
jmp    1814 <add_DTD_upper+0x714>
movslq %esi,%r14
jmp    19e3 <add_DTD_upper+0x8e3>
xor    %ebx,%ebx
test   $0x1,%r9b
je     183f <add_DTD_upper+0x73f>
or     $0x2,%rbx
add    %r10,%rbx
movupd (%rdi,%rbx,8),%xmm2
movupd 0x10(%rdi,%rbx,8),%xmm3
addpd  %xmm1,%xmm2
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rbx,8)
movupd %xmm3,0x10(%rdi,%rbx,8)
cmp    %rcx,%r8
je     1867 <add_DTD_upper+0x767>
or     $0x2,%rcx
lea    (%rdi,%r10,8),%rax
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1850 <add_DTD_upper+0x750>
cmp    $0x4,%esi
jl     193d <add_DTD_upper+0x83d>
lea    (%rsi,%rsi,1),%r9d
lea    (%r9,%r9,2),%r14d
mov    %esi,%r11d
lea    -0x3(%r11),%r8
mov    $0x3,%edx
cmp    $0x4,%r8
jae    1b94 <add_DTD_upper+0xa94>
lea    0x1(%r11),%ecx
mov    %rdx,%rax
not    %rax
add    %r11,%rax
and    $0x3,%rcx
je     18ca <add_DTD_upper+0x7ca>
lea    -0x4(%r14),%ebx
add    $0x1,%rbx
nopl   0x0(%rax)
movsd  (%rdi,%rdx,8),%xmm0
lea    (%rbx,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    18b0 <add_DTD_upper+0x7b0>
cmp    $0x3,%rax
jb     193d <add_DTD_upper+0x83d>
mov    %r14d,%ebx
lea    -0x2(%r14),%ecx
lea    0x1(%rcx),%rax
add    $0xfffffffc,%r14d
add    $0x1,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rdx,8),%xmm0
lea    (%r14,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
movsd  0x8(%rdi,%rdx,8),%xmm0
lea    (%rcx,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
movsd  0x10(%rdi,%rdx,8),%xmm0
lea    (%rax,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
movsd  0x18(%rdi,%rdx,8),%xmm0
lea    (%rbx,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    18f0 <add_DTD_upper+0x7f0>
movslq %esi,%r14
cmp    $0x3,%esi
jl     19e3 <add_DTD_upper+0x8e3>
lea    (%rsi,%rsi,4),%r8d
lea    (%rsi,%rsi,4),%r9d
add    $0xfffffffe,%r9d
mov    %esi,%r12d
lea    -0x2(%r12),%r10
mov    $0x2,%r15d
cmp    $0x4,%r10
jae    1c9b <add_DTD_upper+0xb9b>
mov    %r12d,%ecx
sub    %r15d,%ecx
mov    %r15,%rax
not    %rax
test   $0x1,%cl
je     1996 <add_DTD_upper+0x896>
lea    (%r15,%r14,1),%rcx
movsd  (%rdi,%rcx,8),%xmm0
add    %r15d,%r9d
movslq %r9d,%rcx
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%r15
neg    %r12
cmp    %r12,%rax
je     19e3 <add_DTD_upper+0x8e3>
lea    0x1(%r15),%rax
lea    (%r8,%r15,1),%ecx
add    $0xffffffff,%ecx
lea    (%rdi,%r14,8),%rdx
nopl   (%rax)
movsd  -0x8(%rdx,%rax,8),%xmm0
lea    -0x1(%rcx),%ebp
movslq %ebp,%rbp
movsd  %xmm0,(%rdi,%rbp,8)
movsd  (%rdx,%rax,8),%xmm0
movslq %ecx,%rcx
movsd  %xmm0,(%rdi,%rcx,8)
lea    (%r12,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
add    $0x2,%ecx
cmp    $0x1,%rbp
jne    19b0 <add_DTD_upper+0x8b0>
cmp    $0x2,%esi
jl     1a79 <add_DTD_upper+0x979>
add    %r14,%r14
lea    0x0(,%rsi,4),%ecx
lea    -0x1(,%rsi,4),%r8d
ff
mov    %esi,%edx
lea    -0x1(%rdx),%r9
mov    $0x1,%r11d
cmp    $0x4,%r9
jae    1a84 <add_DTD_upper+0x984>
mov    %r11,%rax
not    %rax
test   $0x1,%dl
jne    1a33 <add_DTD_upper+0x933>
lea    (%r11,%r14,1),%rsi
movsd  (%rdi,%rsi,8),%xmm0
add    %r11d,%r8d
movslq %r8d,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%r11
add    %rdx,%rax
je     1a79 <add_DTD_upper+0x979>
sub    %r11,%rdx
add    %r11d,%ecx
add    %r11,%r14
lea    (%rdi,%r14,8),%rax
add    $0x8,%rax
nopl   0x0(%rax)
movsd  -0x8(%rax),%xmm0
lea    -0x1(%rcx),%esi
movslq %esi,%rsi
movsd  %xmm0,(%rdi,%rsi,8)
movsd  (%rax),%xmm0
movslq %ecx,%rcx
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x2,%ecx
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    1a50 <add_DTD_upper+0x950>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x2(%rdx),%rax
lea    (%rcx,%rax,1),%esi
cmp    %ecx,%esi
jl     1a10 <add_DTD_upper+0x910>
shr    $0x20,%rax
jne    1a10 <add_DTD_upper+0x910>
movslq %ecx,%rax
lea    (%rdi,%rax,8),%rsi
lea    (%r14,%rdx,1),%rbp
lea    (%rdi,%rbp,8),%rbp
cmp    %rbp,%rsi
jae    1ad4 <add_DTD_upper+0x9d4>
add    %rdx,%rax
lea    (%rdi,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
lea    0x0(,%r14,8),%rsi
or     $0x8,%rsi
add    %rdi,%rsi
cmp    %rax,%rsi
jb     1a10 <add_DTD_upper+0x910>
mov    %r9,%r11
and    $0xfffffffffffffffc,%r11
lea    -0x4(%r11),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1da0 <add_DTD_upper+0xca0>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%r14,8),%r15
add    $0x38,%r15
xor    %ebx,%ebx
mov    %ecx,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r15,%rbx,8),%xmm0
movups -0x20(%r15,%rbx,8),%xmm1
movslq %esi,%rsi
movups %xmm0,(%rdi,%rsi,8)
movups %xmm1,0x10(%rdi,%rsi,8)
movupd -0x10(%r15,%rbx,8),%xmm0
movupd (%r15,%rbx,8),%xmm1
lea    0x4(%rsi),%ebp
movslq %ebp,%rbp
movupd %xmm0,(%rdi,%rbp,8)
movupd %xmm1,0x10(%rdi,%rbp,8)
add    $0x8,%rbx
add    $0x8,%esi
add    $0xfffffffffffffffe,%rax
jne    1b10 <add_DTD_upper+0xa10>
test   $0x1,%r10b
je     1b82 <add_DTD_upper+0xa82>
mov    %rbx,%rax
or     $0x1,%rax
or     $0x1,%ebx
add    %r14,%rax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
add    %r8d,%ebx
movslq %ebx,%rax
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
cmp    %r11,%r9
je     1a79 <add_DTD_upper+0x979>
or     $0x1,%r11
jmp    1a10 <add_DTD_upper+0x910>
lea    -0x4(%r11),%rax
lea    (%r14,%rax,1),%ecx
cmp    %r14d,%ecx
jl     188e <add_DTD_upper+0x78e>
shr    $0x20,%rax
jne    188e <add_DTD_upper+0x78e>
movslq %r14d,%rax
lea    (%rdi,%rax,8),%rcx
lea    (%rdi,%r11,8),%rbx
cmp    %rbx,%rcx
jae    1bd7 <add_DTD_upper+0xad7>
add    %r11,%rax
lea    (%rdi,%rax,8),%rax
add    $0xffffffffffffffe8,%rax
lea    0x18(%rdi),%rcx
cmp    %rax,%rcx
jb     188e <add_DTD_upper+0x78e>
mov    %r8,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     1db1 <add_DTD_upper+0xcb1>
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
mov    %r14d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x18(%rdi,%rbx,8),%xmm0
movups 0x28(%rdi,%rbx,8),%xmm1
movslq %ecx,%rcx
movups %xmm0,(%rdi,%rcx,8)
movups %xmm1,0x10(%rdi,%rcx,8)
movupd 0x38(%rdi,%rbx,8),%xmm0
movupd 0x48(%rdi,%rbx,8),%xmm1
lea    0x4(%rcx),%ebp
movslq %ebp,%rbp
movupd %xmm0,(%rdi,%rbp,8)
movupd %xmm1,0x10(%rdi,%rbp,8)
add    $0x8,%rbx
add    $0x8,%ecx
add    $0xfffffffffffffffe,%rax
jne    1c10 <add_DTD_upper+0xb10>
test   $0x1,%dl
je     1c86 <add_DTD_upper+0xb86>
lea    (%r9,%r9,2),%eax
add    $0xfffffffd,%eax
lea    0x0(,%rbx,8),%rcx
or     $0x3,%ebx
add    %eax,%ebx
or     $0x18,%rcx
movupd (%rdi,%rcx,1),%xmm0
movupd 0x10(%rdi,%rcx,1),%xmm1
movslq %ebx,%rax
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
cmp    %r10,%r8
je     193d <add_DTD_upper+0x83d>
or     $0x3,%r8
mov    %r8,%rdx
jmp    188e <add_DTD_upper+0x78e>
lea    -0x3(%r12),%rax
lea    (%r8,%rax,1),%ecx
cmp    %r8d,%ecx
jl     196d <add_DTD_upper+0x86d>
shr    $0x20,%rax
jne    196d <add_DTD_upper+0x86d>
movslq %r8d,%rax
lea    (%rdi,%rax,8),%rcx
lea    (%r14,%r12,1),%rdx
lea    (%rdi,%rdx,8),%rdx
cmp    %rdx,%rcx
jae    1ce7 <add_DTD_upper+0xbe7>
add    %r12,%rax
lea    (%rdi,%rax,8),%rax
add    $0xfffffffffffffff0,%rax
lea    (%rdi,%r14,8),%rcx
add    $0x10,%rcx
cmp    %rax,%rcx
jb     196d <add_DTD_upper+0x86d>
mov    %r10,%r15
and    $0xfffffffffffffffc,%r15
lea    -0x4(%r15),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     1dc1 <add_DTD_upper+0xcc1>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%r14,8),%rdx
add    $0x40,%rdx
xor    %ebx,%ebx
mov    %r8d,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rbx,8),%xmm0
movups -0x20(%rdx,%rbx,8),%xmm1
movslq %ecx,%rcx
movups %xmm0,(%rdi,%rcx,8)
movups %xmm1,0x10(%rdi,%rcx,8)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
lea    0x4(%rcx),%ebp
movslq %ebp,%rbp
movupd %xmm0,(%rdi,%rbp,8)
movupd %xmm1,0x10(%rdi,%rbp,8)
add    $0x8,%rbx
add    $0x8,%ecx
add    $0xfffffffffffffffe,%rax
jne    1d20 <add_DTD_upper+0xc20>
test   $0x1,%r11b
je     1d8e <add_DTD_upper+0xc8e>
mov    %rbx,%rax
or     $0x2,%rax
or     $0x2,%ebx
add    %r14,%rax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
add    %r9d,%ebx
movslq %ebx,%rax
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
cmp    %r15,%r10
je     19e3 <add_DTD_upper+0x8e3>
or     $0x2,%r15
jmp    196d <add_DTD_upper+0x86d>
xor    %ebx,%ebx
test   $0x1,%r10b
jne    1b59 <add_DTD_upper+0xa59>
jmp    1b82 <add_DTD_upper+0xa82>
xor    %ebx,%ebx
test   $0x1,%dl
jne    1c55 <add_DTD_upper+0xb55>
jmp    1c86 <add_DTD_upper+0xb86>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    1d65 <add_DTD_upper+0xc65>
jmp    1d8e <add_DTD_upper+0xc8e>

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

LLVM IR (-O2):
define i32 @add_DTD_upper(double* nocapture %0, i32 %1, double %2, i32 %3) {
%5 = fcmp ogt double %2, 0.000000e+00
br i1 %5, label %6, label %528
6: ; preds = %4
switch i32 %3, label %528 [
i32 0, label %7
i32 1, label %83
i32 2, label %255
]
7: ; preds = %6
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %526
9: ; preds = %7
%10 = mul nsw i32 %1, 3
%11 = sext i32 %10 to i64
%12 = zext i32 %1 to i64
%13 = icmp ult i32 %1, 4
br i1 %13, label %73, label %14
14: ; preds = %9
%15 = and i64 %12, 4294967292
%16 = insertelement <2 x double> poison, double %2, i64 0
%17 = shufflevector <2 x double> %16, <2 x double> poison, <2 x i32> zeroinitializer
%18 = insertelement <2 x double> poison, double %2, i64 0
%19 = shufflevector <2 x double> %18, <2 x double> poison, <2 x i32> zeroinitializer
%20 = add nsw i64 %15, -4
%21 = lshr exact i64 %20, 2
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 1
%24 = icmp eq i64 %20, 0
br i1 %24, label %56, label %25
25: ; preds = %14
%26 = and i64 %22, 9223372036854775806
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %53, %27 ]
%29 = phi i64 [ 0, %25 ], [ %54, %27 ]
%30 = add nsw i64 %28, %11
%31 = getelementptr inbounds double, double* %0, i64 %30
%32 = bitcast double* %31 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = getelementptr inbounds double, double* %31, i64 2
%35 = bitcast double* %34 to <2 x double>*
%36 = load <2 x double>, <2 x double>* %35
%37 = fadd <2 x double> %33, %17
%38 = fadd <2 x double> %36, %19
%39 = bitcast double* %31 to <2 x double>*
store <2 x double> %37, <2 x double>* %39
%40 = bitcast double* %34 to <2 x double>*
store <2 x double> %38, <2 x double>* %40
%41 = or i64 %28, 4
%42 = add nsw i64 %41, %11
%43 = getelementptr inbounds double, double* %0, i64 %42
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = getelementptr inbounds double, double* %43, i64 2
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = fadd <2 x double> %45, %17
%50 = fadd <2 x double> %48, %19
%51 = bitcast double* %43 to <2 x double>*
store <2 x double> %49, <2 x double>* %51
%52 = bitcast double* %46 to <2 x double>*
store <2 x double> %50, <2 x double>* %52
%53 = add nuw i64 %28, 8
%54 = add i64 %29, 2
%55 = icmp eq i64 %54, %26
br i1 %55, label %56, label %27
56: ; preds = %27, %14
%57 = phi i64 [ 0, %14 ], [ %53, %27 ]
%58 = icmp eq i64 %23, 0
br i1 %58, label %71, label %59
59: ; preds = %56
%60 = add nsw i64 %57, %11
%61 = getelementptr inbounds double, double* %0, i64 %60
%62 = bitcast double* %61 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = getelementptr inbounds double, double* %61, i64 2
%65 = bitcast double* %64 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = fadd <2 x double> %63, %17
%68 = fadd <2 x double> %66, %19
%69 = bitcast double* %61 to <2 x double>*
store <2 x double> %67, <2 x double>* %69
%70 = bitcast double* %64 to <2 x double>*
store <2 x double> %68, <2 x double>* %70
br label %71
71: ; preds = %56, %59
%72 = icmp eq i64 %15, %12
br i1 %72, label %528, label %73
73: ; preds = %9, %71
%74 = phi i64 [ 0, %9 ], [ %15, %71 ]
br label %75
75: ; preds = %73, %75
%76 = phi i64 [ %81, %75 ], [ %74, %73 ]
%77 = add nsw i64 %76, %11
%78 = getelementptr inbounds double, double* %0, i64 %77
%79 = load double, double* %78
%80 = fadd double %79, %2
store double %80, double* %78
%81 = add nuw nsw i64 %76, 1
%82 = icmp eq i64 %81, %12
br i1 %82, label %528, label %75
83: ; preds = %6
%84 = mul nsw i32 %1, 3
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = load double, double* %86
%88 = fadd double %87, %2
store double %88, double* %86
%89 = add i32 %1, -1
%90 = icmp sgt i32 %1, 2
br i1 %90, label %91, label %167
91: ; preds = %83
%92 = zext i32 %89 to i64
%93 = add nsw i64 %92, -1
%94 = icmp ult i64 %93, 4
br i1 %94, label %157, label %95
95: ; preds = %91
%96 = and i64 %93, -4
%97 = or i64 %96, 1
%98 = insertelement <2 x double> poison, double %2, i64 0
%99 = shufflevector <2 x double> %98, <2 x double> poison, <2 x i32> zeroinitializer
%100 = insertelement <2 x double> poison, double %2, i64 0
%101 = shufflevector <2 x double> %100, <2 x double> poison, <2 x i32> zeroinitializer
%102 = add nsw i64 %96, -4
%103 = lshr exact i64 %102, 2
%104 = add nuw nsw i64 %103, 1
%105 = and i64 %104, 1
%106 = icmp eq i64 %102, 0
br i1 %106, label %139, label %107
107: ; preds = %95
%108 = and i64 %104, 9223372036854775806
br label %109
109: ; preds = %109, %107
%110 = phi i64 [ 0, %107 ], [ %136, %109 ]
%111 = phi i64 [ 0, %107 ], [ %137, %109 ]
%112 = or i64 %110, 1
%113 = add nsw i64 %112, %85
%114 = getelementptr inbounds double, double* %0, i64 %113
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = getelementptr inbounds double, double* %114, i64 2
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %116)
%121 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %119)
%122 = bitcast double* %114 to <2 x double>*
store <2 x double> %120, <2 x double>* %122
%123 = bitcast double* %117 to <2 x double>*
store <2 x double> %121, <2 x double>* %123
%124 = or i64 %110, 5
%125 = add nsw i64 %124, %85
%126 = getelementptr inbounds double, double* %0, i64 %125
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = getelementptr inbounds double, double* %126, i64 2
%130 = bitcast double* %129 to <2 x double>*
%131 = load <2 x double>, <2 x double>* %130
%132 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %128)
%133 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %131)
%134 = bitcast double* %126 to <2 x double>*
store <2 x double> %132, <2 x double>* %134
%135 = bitcast double* %129 to <2 x double>*
store <2 x double> %133, <2 x double>* %135
%136 = add nuw i64 %110, 8
%137 = add i64 %111, 2
%138 = icmp eq i64 %137, %108
br i1 %138, label %139, label %109
139: ; preds = %109, %95
%140 = phi i64 [ 0, %95 ], [ %136, %109 ]
%141 = icmp eq i64 %105, 0
br i1 %141, label %155, label %142
142: ; preds = %139
%143 = or i64 %140, 1
%144 = add nsw i64 %143, %85
%145 = getelementptr inbounds double, double* %0, i64 %144
%146 = bitcast double* %145 to <2 x double>*
%147 = load <2 x double>, <2 x double>* %146
%148 = getelementptr inbounds double, double* %145, i64 2
%149 = bitcast double* %148 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %149
%151 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %99, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %147)
%152 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %101, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %150)
%153 = bitcast double* %145 to <2 x double>*
store <2 x double> %151, <2 x double>* %153
%154 = bitcast double* %148 to <2 x double>*
store <2 x double> %152, <2 x double>* %154
br label %155
155: ; preds = %139, %142
%156 = icmp eq i64 %93, %96
br i1 %156, label %167, label %157
157: ; preds = %91, %155
%158 = phi i64 [ 1, %91 ], [ %97, %155 ]
br label %159
159: ; preds = %157, %159
%160 = phi i64 [ %165, %159 ], [ %158, %157 ]
%161 = add nsw i64 %160, %85
%162 = getelementptr inbounds double, double* %0, i64 %161
%163 = load double, double* %162
%164 = tail call double @llvm.fmuladd.f64(double %2, double 2.000000e+00, double %163)
store double %164, double* %162
%165 = add nuw nsw i64 %160, 1
%166 = icmp eq i64 %165, %92
br i1 %166, label %167, label %159
167: ; preds = %159, %155, %83
%168 = phi i32 [ 1, %83 ], [ %89, %155 ], [ %89, %159 ]
%169 = add nsw i32 %168, %84
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %0, i64 %170
%172 = load double, double* %171
%173 = fadd double %172, %2
store double %173, double* %171
%174 = icmp sgt i32 %1, 1
br i1 %174, label %175, label %253
175: ; preds = %167
%176 = shl nuw nsw i32 %1, 1
%177 = sext i32 %176 to i64
%178 = zext i32 %1 to i64
%179 = add nsw i64 %178, -1
%180 = icmp ult i64 %179, 4
br i1 %180, label %243, label %181
181: ; preds = %175
%182 = and i64 %179, -4
%183 = or i64 %182, 1
%184 = insertelement <2 x double> poison, double %2, i64 0
%185 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> zeroinitializer
%186 = insertelement <2 x double> poison, double %2, i64 0
%187 = shufflevector <2 x double> %186, <2 x double> poison, <2 x i32> zeroinitializer
%188 = add nsw i64 %182, -4
%189 = lshr exact i64 %188, 2
%190 = add nuw nsw i64 %189, 1
%191 = and i64 %190, 1
%192 = icmp eq i64 %188, 0
br i1 %192, label %225, label %193
193: ; preds = %181
%194 = and i64 %190, 9223372036854775806
br label %195
195: ; preds = %195, %193
%196 = phi i64 [ 0, %193 ], [ %222, %195 ]
%197 = phi i64 [ 0, %193 ], [ %223, %195 ]
%198 = or i64 %196, 1
%199 = add nsw i64 %198, %177
%200 = getelementptr inbounds double, double* %0, i64 %199
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = getelementptr inbounds double, double* %200, i64 2
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = fsub <2 x double> %202, %185
%207 = fsub <2 x double> %205, %187
%208 = bitcast double* %200 to <2 x double>*
store <2 x double> %206, <2 x double>* %208
%209 = bitcast double* %203 to <2 x double>*
store <2 x double> %207, <2 x double>* %209
%210 = or i64 %196, 5
%211 = add nsw i64 %210, %177
%212 = getelementptr inbounds double, double* %0, i64 %211
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = getelementptr inbounds double, double* %212, i64 2
%216 = bitcast double* %215 to <2 x double>*
%217 = load <2 x double>, <2 x double>* %216
%218 = fsub <2 x double> %214, %185
%219 = fsub <2 x double> %217, %187
%220 = bitcast double* %212 to <2 x double>*
store <2 x double> %218, <2 x double>* %220
%221 = bitcast double* %215 to <2 x double>*
store <2 x double> %219, <2 x double>* %221
%222 = add nuw i64 %196, 8
%223 = add i64 %197, 2
%224 = icmp eq i64 %223, %194
br i1 %224, label %225, label %195
225: ; preds = %195, %181
%226 = phi i64 [ 0, %181 ], [ %222, %195 ]
%227 = icmp eq i64 %191, 0
br i1 %227, label %241, label %228
228: ; preds = %225
%229 = or i64 %226, 1
%230 = add nsw i64 %229, %177
%231 = getelementptr inbounds double, double* %0, i64 %230
%232 = bitcast double* %231 to <2 x double>*
%233 = load <2 x double>, <2 x double>* %232
%234 = getelementptr inbounds double, double* %231, i64 2
%235 = bitcast double* %234 to <2 x double>*
%236 = load <2 x double>, <2 x double>* %235
%237 = fsub <2 x double> %233, %185
%238 = fsub <2 x double> %236, %187
%239 = bitcast double* %231 to <2 x double>*
store <2 x double> %237, <2 x double>* %239
%240 = bitcast double* %234 to <2 x double>*
store <2 x double> %238, <2 x double>* %240
br label %241
241: ; preds = %225, %228
%242 = icmp eq i64 %179, %182
br i1 %242, label %253, label %243
243: ; preds = %175, %241
%244 = phi i64 [ 1, %175 ], [ %183, %241 ]
br label %245
245: ; preds = %243, %245
%246 = phi i64 [ %251, %245 ], [ %244, %243 ]
%247 = add nsw i64 %246, %177
%248 = getelementptr inbounds double, double* %0, i64 %247
%249 = load double, double* %248
%250 = fsub double %249, %2
store double %250, double* %248
%251 = add nuw nsw i64 %246, 1
%252 = icmp eq i64 %251, %178
br i1 %252, label %253, label %245
253: ; preds = %245, %241, %167
%254 = icmp eq i32 %3, 2
br i1 %254, label %255, label %528
255: ; preds = %6, %253
%256 = mul nsw i32 %1, 3
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %0, i64 %257
%259 = load double, double* %258
%260 = fadd double %259, %2
store double %260, double* %258
%261 = add nsw i32 %256, 1
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %0, i64 %262
%264 = load double, double* %263
%265 = tail call double @llvm.fmuladd.f64(double %2, double 5.000000e+00, double %264)
store double %265, double* %263
%266 = add i32 %1, -2
%267 = icmp sgt i32 %1, 4
br i1 %267, label %268, label %344
268: ; preds = %255
%269 = zext i32 %266 to i64
%270 = add nsw i64 %269, -2
%271 = icmp ult i64 %270, 4
br i1 %271, label %334, label %272
272: ; preds = %268
%273 = and i64 %270, -4
%274 = or i64 %273, 2
%275 = insertelement <2 x double> poison, double %2, i64 0
%276 = shufflevector <2 x double> %275, <2 x double> poison, <2 x i32> zeroinitializer
%277 = insertelement <2 x double> poison, double %2, i64 0
%278 = shufflevector <2 x double> %277, <2 x double> poison, <2 x i32> zeroinitializer
%279 = add nsw i64 %273, -4
%280 = lshr exact i64 %279, 2
%281 = add nuw nsw i64 %280, 1
%282 = and i64 %281, 1
%283 = icmp eq i64 %279, 0
br i1 %283, label %316, label %284
284: ; preds = %272
%285 = and i64 %281, 9223372036854775806
br label %286
286: ; preds = %286, %284
%287 = phi i64 [ 0, %284 ], [ %313, %286 ]
%288 = phi i64 [ 0, %284 ], [ %314, %286 ]
%289 = or i64 %287, 2
%290 = add nsw i64 %289, %257
%291 = getelementptr inbounds double, double* %0, i64 %290
%292 = bitcast double* %291 to <2 x double>*
%293 = load <2 x double>, <2 x double>* %292
%294 = getelementptr inbounds double, double* %291, i64 2
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %276, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %293)
%298 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %278, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %296)
%299 = bitcast double* %291 to <2 x double>*
store <2 x double> %297, <2 x double>* %299
%300 = bitcast double* %294 to <2 x double>*
store <2 x double> %298, <2 x double>* %300
%301 = or i64 %287, 6
%302 = add nsw i64 %301, %257
%303 = getelementptr inbounds double, double* %0, i64 %302
%304 = bitcast double* %303 to <2 x double>*
%305 = load <2 x double>, <2 x double>* %304
%306 = getelementptr inbounds double, double* %303, i64 2
%307 = bitcast double* %306 to <2 x double>*
%308 = load <2 x double>, <2 x double>* %307
%309 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %276, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %305)
%310 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %278, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %308)
%311 = bitcast double* %303 to <2 x double>*
store <2 x double> %309, <2 x double>* %311
%312 = bitcast double* %306 to <2 x double>*
store <2 x double> %310, <2 x double>* %312
%313 = add nuw i64 %287, 8
%314 = add i64 %288, 2
%315 = icmp eq i64 %314, %285
br i1 %315, label %316, label %286
316: ; preds = %286, %272
%317 = phi i64 [ 0, %272 ], [ %313, %286 ]
%318 = icmp eq i64 %282, 0
br i1 %318, label %332, label %319
319: ; preds = %316
%320 = or i64 %317, 2
%321 = add nsw i64 %320, %257
%322 = getelementptr inbounds double, double* %0, i64 %321
%323 = bitcast double* %322 to <2 x double>*
%324 = load <2 x double>, <2 x double>* %323
%325 = getelementptr inbounds double, double* %322, i64 2
%326 = bitcast double* %325 to <2 x double>*
%327 = load <2 x double>, <2 x double>* %326
%328 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %276, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %324)
%329 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %278, <2 x double> <double 6.000000e+00, double 6.000000e+00>, <2 x double> %327)
%330 = bitcast double* %322 to <2 x double>*
store <2 x double> %328, <2 x double>* %330
%331 = bitcast double* %325 to <2 x double>*
store <2 x double> %329, <2 x double>* %331
br label %332
332: ; preds = %316, %319
%333 = icmp eq i64 %270, %273
br i1 %333, label %344, label %334
334: ; preds = %268, %332
%335 = phi i64 [ 2, %268 ], [ %274, %332 ]
br label %336
336: ; preds = %334, %336
%337 = phi i64 [ %342, %336 ], [ %335, %334 ]
%338 = add nsw i64 %337, %257
%339 = getelementptr inbounds double, double* %0, i64 %338
%340 = load double, double* %339
%341 = tail call double @llvm.fmuladd.f64(double %2, double 6.000000e+00, double %340)
store double %341, double* %339
%342 = add nuw nsw i64 %337, 1
%343 = icmp eq i64 %342, %269
br i1 %343, label %344, label %336
344: ; preds = %336, %332, %255
%345 = phi i32 [ 2, %255 ], [ %266, %332 ], [ %266, %336 ]
%346 = add i32 %345, %256
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %0, i64 %347
%349 = load double, double* %348
%350 = tail call double @llvm.fmuladd.f64(double %2, double 5.000000e+00, double %349)
store double %350, double* %348
%351 = add i32 %346, 1
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %0, i64 %352
%354 = load double, double* %353
%355 = fadd double %354, %2
store double %355, double* %353
%356 = shl nsw i32 %1, 1
%357 = or i32 %356, 1
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %0, i64 %358
%360 = load double, double* %359
%361 = tail call double @llvm.fmuladd.f64(double %2, double -2.000000e+00, double %360)
store double %361, double* %359
%362 = add i32 %1, -1
%363 = icmp sgt i32 %1, 3
br i1 %363, label %364, label %441
364: ; preds = %344
%365 = sext i32 %356 to i64
%366 = zext i32 %362 to i64
%367 = add nsw i64 %366, -2
%368 = icmp ult i64 %367, 4
br i1 %368, label %431, label %369
369: ; preds = %364
%370 = and i64 %367, -4
%371 = or i64 %370, 2
%372 = insertelement <2 x double> poison, double %2, i64 0
%373 = shufflevector <2 x double> %372, <2 x double> poison, <2 x i32> zeroinitializer
%374 = insertelement <2 x double> poison, double %2, i64 0
%375 = shufflevector <2 x double> %374, <2 x double> poison, <2 x i32> zeroinitializer
%376 = add nsw i64 %370, -4
%377 = lshr exact i64 %376, 2
%378 = add nuw nsw i64 %377, 1
%379 = and i64 %378, 1
%380 = icmp eq i64 %376, 0
br i1 %380, label %413, label %381
381: ; preds = %369
%382 = and i64 %378, 9223372036854775806
br label %383
383: ; preds = %383, %381
%384 = phi i64 [ 0, %381 ], [ %410, %383 ]
%385 = phi i64 [ 0, %381 ], [ %411, %383 ]
%386 = or i64 %384, 2
%387 = add nsw i64 %386, %365
%388 = getelementptr inbounds double, double* %0, i64 %387
%389 = bitcast double* %388 to <2 x double>*
%390 = load <2 x double>, <2 x double>* %389
%391 = getelementptr inbounds double, double* %388, i64 2
%392 = bitcast double* %391 to <2 x double>*
%393 = load <2 x double>, <2 x double>* %392
%394 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %373, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %390)
%395 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %393)
%396 = bitcast double* %388 to <2 x double>*
store <2 x double> %394, <2 x double>* %396
%397 = bitcast double* %391 to <2 x double>*
store <2 x double> %395, <2 x double>* %397
%398 = or i64 %384, 6
%399 = add nsw i64 %398, %365
%400 = getelementptr inbounds double, double* %0, i64 %399
%401 = bitcast double* %400 to <2 x double>*
%402 = load <2 x double>, <2 x double>* %401
%403 = getelementptr inbounds double, double* %400, i64 2
%404 = bitcast double* %403 to <2 x double>*
%405 = load <2 x double>, <2 x double>* %404
%406 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %373, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %402)
%407 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %405)
%408 = bitcast double* %400 to <2 x double>*
store <2 x double> %406, <2 x double>* %408
%409 = bitcast double* %403 to <2 x double>*
store <2 x double> %407, <2 x double>* %409
%410 = add nuw i64 %384, 8
%411 = add i64 %385, 2
%412 = icmp eq i64 %411, %382
br i1 %412, label %413, label %383
413: ; preds = %383, %369
%414 = phi i64 [ 0, %369 ], [ %410, %383 ]
%415 = icmp eq i64 %379, 0
br i1 %415, label %429, label %416
416: ; preds = %413
%417 = or i64 %414, 2
%418 = add nsw i64 %417, %365
%419 = getelementptr inbounds double, double* %0, i64 %418
%420 = bitcast double* %419 to <2 x double>*
%421 = load <2 x double>, <2 x double>* %420
%422 = getelementptr inbounds double, double* %419, i64 2
%423 = bitcast double* %422 to <2 x double>*
%424 = load <2 x double>, <2 x double>* %423
%425 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %373, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %421)
%426 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %375, <2 x double> <double -4.000000e+00, double -4.000000e+00>, <2 x double> %424)
%427 = bitcast double* %419 to <2 x double>*
store <2 x double> %425, <2 x double>* %427
%428 = bitcast double* %422 to <2 x double>*
store <2 x double> %426, <2 x double>* %428
br label %429
429: ; preds = %413, %416
%430 = icmp eq i64 %367, %370
br i1 %430, label %441, label %431
431: ; preds = %364, %429
%432 = phi i64 [ 2, %364 ], [ %371, %429 ]
br label %433
433: ; preds = %431, %433
%434 = phi i64 [ %439, %433 ], [ %432, %431 ]
%435 = add nsw i64 %434, %365
%436 = getelementptr inbounds double, double* %0, i64 %435
%437 = load double, double* %436
%438 = tail call double @llvm.fmuladd.f64(double %2, double -4.000000e+00, double %437)
store double %438, double* %436
%439 = add nuw nsw i64 %434, 1
%440 = icmp eq i64 %439, %366
br i1 %440, label %441, label %433
441: ; preds = %433, %429, %344
%442 = phi i32 [ 2, %344 ], [ %362, %429 ], [ %362, %433 ]
%443 = add nsw i32 %442, %356
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %0, i64 %444
%446 = load double, double* %445
%447 = tail call double @llvm.fmuladd.f64(double %2, double -2.000000e+00, double %446)
store double %447, double* %445
%448 = icmp sgt i32 %1, 2
br i1 %448, label %449, label %526
449: ; preds = %441
%450 = zext i32 %1 to i64
%451 = zext i32 %1 to i64
%452 = add nsw i64 %451, -2
%453 = icmp ult i64 %452, 4
br i1 %453, label %516, label %454
454: ; preds = %449
%455 = and i64 %452, -4
%456 = or i64 %455, 2
%457 = insertelement <2 x double> poison, double %2, i64 0
%458 = shufflevector <2 x double> %457, <2 x double> poison, <2 x i32> zeroinitializer
%459 = insertelement <2 x double> poison, double %2, i64 0
%460 = shufflevector <2 x double> %459, <2 x double> poison, <2 x i32> zeroinitializer
%461 = add nsw i64 %455, -4
%462 = lshr exact i64 %461, 2
%463 = add nuw nsw i64 %462, 1
%464 = and i64 %463, 1
%465 = icmp eq i64 %461, 0
br i1 %465, label %498, label %466
466: ; preds = %454
%467 = and i64 %463, 9223372036854775806
br label %468
468: ; preds = %468, %466
%469 = phi i64 [ 0, %466 ], [ %495, %468 ]
%470 = phi i64 [ 0, %466 ], [ %496, %468 ]
%471 = or i64 %469, 2
%472 = add nuw nsw i64 %471, %450
%473 = getelementptr inbounds double, double* %0, i64 %472
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = getelementptr inbounds double, double* %473, i64 2
%477 = bitcast double* %476 to <2 x double>*
%478 = load <2 x double>, <2 x double>* %477
%479 = fadd <2 x double> %475, %458
%480 = fadd <2 x double> %478, %460
%481 = bitcast double* %473 to <2 x double>*
store <2 x double> %479, <2 x double>* %481
%482 = bitcast double* %476 to <2 x double>*
store <2 x double> %480, <2 x double>* %482
%483 = or i64 %469, 6
%484 = add nuw nsw i64 %483, %450
%485 = getelementptr inbounds double, double* %0, i64 %484
%486 = bitcast double* %485 to <2 x double>*
%487 = load <2 x double>, <2 x double>* %486
%488 = getelementptr inbounds double, double* %485, i64 2
%489 = bitcast double* %488 to <2 x double>*
%490 = load <2 x double>, <2 x double>* %489
%491 = fadd <2 x double> %487, %458
%492 = fadd <2 x double> %490, %460
%493 = bitcast double* %485 to <2 x double>*
store <2 x double> %491, <2 x double>* %493
%494 = bitcast double* %488 to <2 x double>*
store <2 x double> %492, <2 x double>* %494
%495 = add nuw i64 %469, 8
%496 = add i64 %470, 2
%497 = icmp eq i64 %496, %467
br i1 %497, label %498, label %468
498: ; preds = %468, %454
%499 = phi i64 [ 0, %454 ], [ %495, %468 ]
%500 = icmp eq i64 %464, 0
br i1 %500, label %514, label %501
501: ; preds = %498
%502 = or i64 %499, 2
%503 = add nuw nsw i64 %502, %450
%504 = getelementptr inbounds double, double* %0, i64 %503
%505 = bitcast double* %504 to <2 x double>*
%506 = load <2 x double>, <2 x double>* %505
%507 = getelementptr inbounds double, double* %504, i64 2
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = fadd <2 x double> %506, %458
%511 = fadd <2 x double> %509, %460
%512 = bitcast double* %504 to <2 x double>*
store <2 x double> %510, <2 x double>* %512
%513 = bitcast double* %507 to <2 x double>*
store <2 x double> %511, <2 x double>* %513
br label %514
514: ; preds = %498, %501
%515 = icmp eq i64 %452, %455
br i1 %515, label %528, label %516
516: ; preds = %449, %514
%517 = phi i64 [ 2, %449 ], [ %456, %514 ]
br label %518
518: ; preds = %516, %518
%519 = phi i64 [ %524, %518 ], [ %517, %516 ]
%520 = add nuw nsw i64 %519, %450
%521 = getelementptr inbounds double, double* %0, i64 %520
%522 = load double, double* %521
%523 = fadd double %522, %2
store double %523, double* %521
%524 = add nuw nsw i64 %519, 1
%525 = icmp eq i64 %524, %451
br i1 %525, label %528, label %518
526: ; preds = %441, %7
%527 = sext i32 %1 to i64
br label %811
528: ; preds = %518, %75, %514, %71, %6, %253, %4
%529 = sext i32 %1 to i64
%530 = icmp sgt i32 %1, 3
br i1 %530, label %531, label %675
531: ; preds = %528
%532 = mul nsw i32 %1, 6
%533 = add i32 %532, -3
%534 = zext i32 %1 to i64
%535 = add nsw i64 %534, -3
%536 = icmp ult i64 %535, 4
br i1 %536, label %622, label %537
537: ; preds = %531
%538 = add nsw i64 %534, -4
%539 = trunc i64 %538 to i32
%540 = add i32 %532, %539
%541 = icmp slt i32 %540, %532
%542 = icmp ugt i64 %538, 4294967295
%543 = or i1 %541, %542
br i1 %543, label %622, label %544
544: ; preds = %537
%545 = sext i32 %532 to i64
%546 = getelementptr double, double* %0, i64 %545
%547 = add nsw i64 %545, %534
%548 = add nsw i64 %547, -3
%549 = getelementptr double, double* %0, i64 %548
%550 = getelementptr double, double* %0, i64 3
%551 = getelementptr double, double* %0, i64 %534
%552 = icmp ult double* %546, %551
%553 = icmp ult double* %550, %549
%554 = and i1 %552, %553
br i1 %554, label %622, label %555
555: ; preds = %544
%556 = and i64 %535, -4
%557 = or i64 %535, 3
%558 = add nsw i64 %556, -4
%559 = lshr exact i64 %558, 2
%560 = add nuw nsw i64 %559, 1
%561 = and i64 %560, 1
%562 = icmp eq i64 %558, 0
br i1 %562, label %601, label %563
563: ; preds = %555
%564 = and i64 %560, 9223372036854775806
br label %565
565: ; preds = %565, %563
%566 = phi i64 [ 0, %563 ], [ %598, %565 ]
%567 = phi i64 [ 0, %563 ], [ %599, %565 ]
%568 = or i64 %566, 3
%569 = trunc i64 %566 to i32
%570 = or i32 %569, 3
%571 = getelementptr inbounds double, double* %0, i64 %568
%572 = bitcast double* %571 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = getelementptr inbounds double, double* %571, i64 2
%575 = bitcast double* %574 to <2 x double>*
%576 = load <2 x double>, <2 x double>* %575
%577 = add i32 %533, %570
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double, double* %0, i64 %578
%580 = bitcast double* %579 to <2 x double>*
store <2 x double> %573, <2 x double>* %580
%581 = getelementptr inbounds double, double* %579, i64 2
%582 = bitcast double* %581 to <2 x double>*
store <2 x double> %576, <2 x double>* %582
%583 = or i64 %566, 7
%584 = trunc i64 %566 to i32
%585 = or i32 %584, 7
%586 = getelementptr inbounds double, double* %0, i64 %583
%587 = bitcast double* %586 to <2 x double>*
%588 = load <2 x double>, <2 x double>* %587
%589 = getelementptr inbounds double, double* %586, i64 2
%590 = bitcast double* %589 to <2 x double>*
%591 = load <2 x double>, <2 x double>* %590
%592 = add i32 %533, %585
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %0, i64 %593
%595 = bitcast double* %594 to <2 x double>*
store <2 x double> %588, <2 x double>* %595
%596 = getelementptr inbounds double, double* %594, i64 2
%597 = bitcast double* %596 to <2 x double>*
store <2 x double> %591, <2 x double>* %597
%598 = add nuw i64 %566, 8
%599 = add i64 %567, 2
%600 = icmp eq i64 %599, %564
br i1 %600, label %601, label %565
601: ; preds = %565, %555
%602 = phi i64 [ 0, %555 ], [ %598, %565 ]
%603 = icmp eq i64 %561, 0
br i1 %603, label %620, label %604
604: ; preds = %601
%605 = or i64 %602, 3
%606 = trunc i64 %602 to i32
%607 = or i32 %606, 3
%608 = getelementptr inbounds double, double* %0, i64 %605
%609 = bitcast double* %608 to <2 x double>*
%610 = load <2 x double>, <2 x double>* %609
%611 = getelementptr inbounds double, double* %608, i64 2
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = add i32 %533, %607
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds double, double* %0, i64 %615
%617 = bitcast double* %616 to <2 x double>*
store <2 x double> %610, <2 x double>* %617
%618 = getelementptr inbounds double, double* %616, i64 2
%619 = bitcast double* %618 to <2 x double>*
store <2 x double> %613, <2 x double>* %619
br label %620
620: ; preds = %601, %604
%621 = icmp eq i64 %535, %556
br i1 %621, label %675, label %622
622: ; preds = %544, %537, %531, %620
%623 = phi i64 [ 3, %544 ], [ 3, %537 ], [ 3, %531 ], [ %557, %620 ]
%624 = add nuw nsw i64 %534, 1
%625 = xor i64 %623, -1
%626 = add nsw i64 %625, %534
%627 = and i64 %624, 3
%628 = icmp eq i64 %627, 0
br i1 %628, label %641, label %629
629: ; preds = %622, %629
%630 = phi i64 [ %638, %629 ], [ %623, %622 ]
%631 = phi i64 [ %639, %629 ], [ 0, %622 ]
%632 = getelementptr inbounds double, double* %0, i64 %630
%633 = load double, double* %632
%634 = trunc i64 %630 to i32
%635 = add i32 %533, %634
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds double, double* %0, i64 %636
store double %633, double* %637
%638 = add nuw nsw i64 %630, 1
%639 = add i64 %631, 1
%640 = icmp eq i64 %639, %627
br i1 %640, label %641, label %629
641: ; preds = %629, %622
%642 = phi i64 [ %623, %622 ], [ %638, %629 ]
%643 = icmp ult i64 %626, 3
br i1 %643, label %675, label %644
644: ; preds = %641, %644
%645 = phi i64 [ %673, %644 ], [ %642, %641 ]
%646 = getelementptr inbounds double, double* %0, i64 %645
%647 = load double, double* %646
%648 = trunc i64 %645 to i32
%649 = add i32 %533, %648
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds double, double* %0, i64 %650
store double %647, double* %651
%652 = add nuw nsw i64 %645, 1
%653 = getelementptr inbounds double, double* %0, i64 %652
%654 = load double, double* %653
%655 = trunc i64 %652 to i32
%656 = add i32 %533, %655
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double, double* %0, i64 %657
store double %654, double* %658
%659 = add nuw nsw i64 %645, 2
%660 = getelementptr inbounds double, double* %0, i64 %659
%661 = load double, double* %660
%662 = trunc i64 %659 to i32
%663 = add i32 %533, %662
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds double, double* %0, i64 %664
store double %661, double* %665
%666 = add nuw nsw i64 %645, 3
%667 = getelementptr inbounds double, double* %0, i64 %666
%668 = load double, double* %667
%669 = trunc i64 %666 to i32
%670 = add i32 %533, %669
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %0, i64 %671
store double %668, double* %672
%673 = add nuw nsw i64 %645, 4
%674 = icmp eq i64 %673, %534
br i1 %674, label %675, label %644
675: ; preds = %641, %644, %620, %528
%676 = icmp sgt i32 %1, 2
br i1 %676, label %677, label %811
677: ; preds = %675
%678 = mul nsw i32 %1, 5
%679 = add i32 %678, -2
%680 = zext i32 %1 to i64
%681 = add nsw i64 %680, -2
%682 = icmp ult i64 %681, 4
br i1 %682, label %773, label %683
683: ; preds = %677
%684 = add nsw i64 %680, -3
%685 = trunc i64 %684 to i32
%686 = add i32 %678, %685
%687 = icmp slt i32 %686, %678
%688 = icmp ugt i64 %684, 4294967295
%689 = or i1 %687, %688
br i1 %689, label %773, label %690
690: ; preds = %683
%691 = sext i32 %678 to i64
%692 = getelementptr double, double* %0, i64 %691
%693 = add nsw i64 %691, %680
%694 = add nsw i64 %693, -2
%695 = getelementptr double, double* %0, i64 %694
%696 = add nsw i64 %529, 2
%697 = getelementptr double, double* %0, i64 %696
%698 = add nsw i64 %529, %680
%699 = getelementptr double, double* %0, i64 %698
%700 = icmp ult double* %692, %699
%701 = icmp ult double* %697, %695
%702 = and i1 %700, %701
br i1 %702, label %773, label %703
703: ; preds = %690
%704 = and i64 %681, -4
%705 = or i64 %704, 2
%706 = add nsw i64 %704, -4
%707 = lshr exact i64 %706, 2
%708 = add nuw nsw i64 %707, 1
%709 = and i64 %708, 1
%710 = icmp eq i64 %706, 0
br i1 %710, label %751, label %711
711: ; preds = %703
%712 = and i64 %708, 9223372036854775806
br label %713
713: ; preds = %713, %711
%714 = phi i64 [ 0, %711 ], [ %748, %713 ]
%715 = phi i64 [ 0, %711 ], [ %749, %713 ]
%716 = or i64 %714, 2
%717 = trunc i64 %714 to i32
%718 = or i32 %717, 2
%719 = add nsw i64 %716, %529
%720 = getelementptr inbounds double, double* %0, i64 %719
%721 = bitcast double* %720 to <2 x double>*
%722 = load <2 x double>, <2 x double>* %721
%723 = getelementptr inbounds double, double* %720, i64 2
%724 = bitcast double* %723 to <2 x double>*
%725 = load <2 x double>, <2 x double>* %724
%726 = add i32 %679, %718
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds double, double* %0, i64 %727
%729 = bitcast double* %728 to <2 x double>*
store <2 x double> %722, <2 x double>* %729
%730 = getelementptr inbounds double, double* %728, i64 2
%731 = bitcast double* %730 to <2 x double>*
store <2 x double> %725, <2 x double>* %731
%732 = or i64 %714, 6
%733 = trunc i64 %714 to i32
%734 = or i32 %733, 6
%735 = add nsw i64 %732, %529
%736 = getelementptr inbounds double, double* %0, i64 %735
%737 = bitcast double* %736 to <2 x double>*
%738 = load <2 x double>, <2 x double>* %737
%739 = getelementptr inbounds double, double* %736, i64 2
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = add i32 %679, %734
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds double, double* %0, i64 %743
%745 = bitcast double* %744 to <2 x double>*
store <2 x double> %738, <2 x double>* %745
%746 = getelementptr inbounds double, double* %744, i64 2
%747 = bitcast double* %746 to <2 x double>*
store <2 x double> %741, <2 x double>* %747
%748 = add nuw i64 %714, 8
%749 = add i64 %715, 2
%750 = icmp eq i64 %749, %712
br i1 %750, label %751, label %713
751: ; preds = %713, %703
%752 = phi i64 [ 0, %703 ], [ %748, %713 ]
%753 = icmp eq i64 %709, 0
br i1 %753, label %771, label %754
754: ; preds = %751
%755 = or i64 %752, 2
%756 = trunc i64 %752 to i32
%757 = or i32 %756, 2
%758 = add nsw i64 %755, %529
%759 = getelementptr inbounds double, double* %0, i64 %758
%760 = bitcast double* %759 to <2 x double>*
%761 = load <2 x double>, <2 x double>* %760
%762 = getelementptr inbounds double, double* %759, i64 2
%763 = bitcast double* %762 to <2 x double>*
%764 = load <2 x double>, <2 x double>* %763
%765 = add i32 %679, %757
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds double, double* %0, i64 %766
%768 = bitcast double* %767 to <2 x double>*
store <2 x double> %761, <2 x double>* %768
%769 = getelementptr inbounds double, double* %767, i64 2
%770 = bitcast double* %769 to <2 x double>*
store <2 x double> %764, <2 x double>* %770
br label %771
771: ; preds = %751, %754
%772 = icmp eq i64 %681, %704
br i1 %772, label %811, label %773
773: ; preds = %690, %683, %677, %771
%774 = phi i64 [ 2, %690 ], [ 2, %683 ], [ 2, %677 ], [ %705, %771 ]
%775 = sub nsw i64 %680, %774
%776 = xor i64 %774, -1
%777 = and i64 %775, 1
%778 = icmp eq i64 %777, 0
br i1 %778, label %788, label %779
779: ; preds = %773
%780 = add nsw i64 %774, %529
%781 = getelementptr inbounds double, double* %0, i64 %780
%782 = load double, double* %781
%783 = trunc i64 %774 to i32
%784 = add i32 %679, %783
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %0, i64 %785
store double %782, double* %786
%787 = add nuw nsw i64 %774, 1
br label %788
788: ; preds = %779, %773
%789 = phi i64 [ %774, %773 ], [ %787, %779 ]
%790 = sub nsw i64 0, %680
%791 = icmp eq i64 %776, %790
br i1 %791, label %811, label %792
792: ; preds = %788, %792
%793 = phi i64 [ %809, %792 ], [ %789, %788 ]
%794 = add nsw i64 %793, %529
%795 = getelementptr inbounds double, double* %0, i64 %794
%796 = load double, double* %795
%797 = trunc i64 %793 to i32
%798 = add i32 %679, %797
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %0, i64 %799
store double %796, double* %800
%801 = add nuw nsw i64 %793, 1
%802 = add nsw i64 %801, %529
%803 = getelementptr inbounds double, double* %0, i64 %802
%804 = load double, double* %803
%805 = trunc i64 %801 to i32
%806 = add i32 %679, %805
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %0, i64 %807
store double %804, double* %808
%809 = add nuw nsw i64 %793, 2
%810 = icmp eq i64 %809, %680
br i1 %810, label %811, label %792
811: ; preds = %788, %792, %771, %526, %675
%812 = phi i64 [ %529, %675 ], [ %527, %526 ], [ %529, %771 ], [ %529, %792 ], [ %529, %788 ]
%813 = icmp sgt i32 %1, 1
br i1 %813, label %814, label %948
814: ; preds = %811
%815 = shl nsw i64 %812, 1
%816 = shl nsw i32 %1, 2
%817 = add i32 %816, -1
%818 = zext i32 %1 to i64
%819 = add nsw i64 %818, -1
%820 = icmp ult i64 %819, 4
br i1 %820, label %911, label %821
821: ; preds = %814
%822 = add nsw i64 %818, -2
%823 = trunc i64 %822 to i32
%824 = add i32 %816, %823
%825 = icmp slt i32 %824, %816
%826 = icmp ugt i64 %822, 4294967295
%827 = or i1 %825, %826
br i1 %827, label %911, label %828
828: ; preds = %821
%829 = sext i32 %816 to i64
%830 = getelementptr double, double* %0, i64 %829
%831 = add nsw i64 %829, %818
%832 = add nsw i64 %831, -1
%833 = getelementptr double, double* %0, i64 %832
%834 = or i64 %815, 1
%835 = getelementptr double, double* %0, i64 %834
%836 = add nsw i64 %815, %818
%837 = getelementptr double, double* %0, i64 %836
%838 = icmp ult double* %830, %837
%839 = icmp ult double* %835, %833
%840 = and i1 %838, %839
br i1 %840, label %911, label %841
841: ; preds = %828
%842 = and i64 %819, -4
%843 = or i64 %842, 1
%844 = add nsw i64 %842, -4
%845 = lshr exact i64 %844, 2
%846 = add nuw nsw i64 %845, 1
%847 = and i64 %846, 1
%848 = icmp eq i64 %844, 0
br i1 %848, label %889, label %849
849: ; preds = %841
%850 = and i64 %846, 9223372036854775806
br label %851
851: ; preds = %851, %849
%852 = phi i64 [ 0, %849 ], [ %886, %851 ]
%853 = phi i64 [ 0, %849 ], [ %887, %851 ]
%854 = or i64 %852, 1
%855 = trunc i64 %852 to i32
%856 = or i32 %855, 1
%857 = add nsw i64 %854, %815
%858 = getelementptr inbounds double, double* %0, i64 %857
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = getelementptr inbounds double, double* %858, i64 2
%862 = bitcast double* %861 to <2 x double>*
%863 = load <2 x double>, <2 x double>* %862
%864 = add i32 %817, %856
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds double, double* %0, i64 %865
%867 = bitcast double* %866 to <2 x double>*
store <2 x double> %860, <2 x double>* %867
%868 = getelementptr inbounds double, double* %866, i64 2
%869 = bitcast double* %868 to <2 x double>*
store <2 x double> %863, <2 x double>* %869
%870 = or i64 %852, 5
%871 = trunc i64 %852 to i32
%872 = or i32 %871, 5
%873 = add nsw i64 %870, %815
%874 = getelementptr inbounds double, double* %0, i64 %873
%875 = bitcast double* %874 to <2 x double>*
%876 = load <2 x double>, <2 x double>* %875
%877 = getelementptr inbounds double, double* %874, i64 2
%878 = bitcast double* %877 to <2 x double>*
%879 = load <2 x double>, <2 x double>* %878
%880 = add i32 %817, %872
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds double, double* %0, i64 %881
%883 = bitcast double* %882 to <2 x double>*
store <2 x double> %876, <2 x double>* %883
%884 = getelementptr inbounds double, double* %882, i64 2
%885 = bitcast double* %884 to <2 x double>*
store <2 x double> %879, <2 x double>* %885
%886 = add nuw i64 %852, 8
%887 = add i64 %853, 2
%888 = icmp eq i64 %887, %850
br i1 %888, label %889, label %851
889: ; preds = %851, %841
%890 = phi i64 [ 0, %841 ], [ %886, %851 ]
%891 = icmp eq i64 %847, 0
br i1 %891, label %909, label %892
892: ; preds = %889
%893 = or i64 %890, 1
%894 = trunc i64 %890 to i32
%895 = or i32 %894, 1
%896 = add nsw i64 %893, %815
%897 = getelementptr inbounds double, double* %0, i64 %896
%898 = bitcast double* %897 to <2 x double>*
%899 = load <2 x double>, <2 x double>* %898
%900 = getelementptr inbounds double, double* %897, i64 2
%901 = bitcast double* %900 to <2 x double>*
%902 = load <2 x double>, <2 x double>* %901
%903 = add i32 %817, %895
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %0, i64 %904
%906 = bitcast double* %905 to <2 x double>*
store <2 x double> %899, <2 x double>* %906
%907 = getelementptr inbounds double, double* %905, i64 2
%908 = bitcast double* %907 to <2 x double>*
store <2 x double> %902, <2 x double>* %908
br label %909
909: ; preds = %889, %892
%910 = icmp eq i64 %819, %842
br i1 %910, label %948, label %911
911: ; preds = %828, %821, %814, %909
%912 = phi i64 [ 1, %828 ], [ 1, %821 ], [ 1, %814 ], [ %843, %909 ]
%913 = xor i64 %912, -1
%914 = and i64 %818, 1
%915 = icmp eq i64 %914, 0
br i1 %915, label %916, label %925
916: ; preds = %911
%917 = add nsw i64 %912, %815
%918 = getelementptr inbounds double, double* %0, i64 %917
%919 = load double, double* %918
%920 = trunc i64 %912 to i32
%921 = add i32 %817, %920
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds double, double* %0, i64 %922
store double %919, double* %923
%924 = add nuw nsw i64 %912, 1
br label %925
925: ; preds = %916, %911
%926 = phi i64 [ %912, %911 ], [ %924, %916 ]
%927 = sub nsw i64 0, %818
%928 = icmp eq i64 %913, %927
br i1 %928, label %948, label %929
929: ; preds = %925, %929
%930 = phi i64 [ %946, %929 ], [ %926, %925 ]
%931 = add nsw i64 %930, %815
%932 = getelementptr inbounds double, double* %0, i64 %931
%933 = load double, double* %932
%934 = trunc i64 %930 to i32
%935 = add i32 %817, %934
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %0, i64 %936
store double %933, double* %937
%938 = add nuw nsw i64 %930, 1
%939 = add nsw i64 %938, %815
%940 = getelementptr inbounds double, double* %0, i64 %939
%941 = load double, double* %940
%942 = trunc i64 %938 to i32
%943 = add i32 %817, %942
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %0, i64 %944
store double %941, double* %945
%946 = add nuw nsw i64 %930, 2
%947 = icmp eq i64 %946, %818
br i1 %947, label %948, label %929
948: ; preds = %925, %929, %909, %811
ret i32 0
}