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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double glmgen_factorial(int);
void tf_dtx(double *x, int n, int k, double *a, double *b) {
  int i;
  int j;
  double fact;
  for (i = 0; i < n - k; i++)
    b[i] = a[i];
  if (k < 1 || k >= n)
    return;
  for (i = k; i > 0; --i) {
    b[n - i] = b[n - i - 1];
    for (j = n - i - 1; j > 0; --j) {
      b[j] = b[j - 1] - b[j];
    }
    b[0] = -b[0];
    if (i != 1) {
      for (j = 0; j <= n - i; ++j) {
        b[j] = b[j] / (x[j + i - 1] - x[j]);
      }
    }
  }
  fact = glmgen_factorial(k - 1);
  for (i = 0; i < n; ++i) {
    b[i] *= fact;
  }
}


x86 assembly (clang, -O0):
<tf_dtx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    116a <tf_dtx+0x5a>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1131 <tf_dtx+0x21>
cmpl   $0x1,-0x10(%rbp)
jl     1180 <tf_dtx+0x70>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1185 <tf_dtx+0x75>
jmp    1303 <tf_dtx+0x1f3>
mov    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    12bb <tf_dtx+0x1ab>
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    120c <tf_dtx+0xfc>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11c8 <tf_dtx+0xb8>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x1,-0x24(%rbp)
je     12a8 <tf_dtx+0x198>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jg     12a3 <tf_dtx+0x193>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1244 <tf_dtx+0x134>
jmp    12a8 <tf_dtx+0x198>
jmp    12ad <tf_dtx+0x19d>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    118b <tf_dtx+0x7b>
mov    -0x10(%rbp),%edi
sub    $0x1,%edi
call   1030 <glmgen_factorial@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1303 <tf_dtx+0x1f3>
movsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d2 <tf_dtx+0x1c2>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tf_dtx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,%r15
mov    %esi,%eax
sub    %edx,%eax
test   %eax,%eax
jle    129a <tf_dtx+0x18a>
mov    %eax,%r9d
cmp    $0x4,%eax
jb     114b <tf_dtx+0x3b>
lea    (%rcx,%r9,8),%rax
cmp    %r15,%rax
jbe    11c0 <tf_dtx+0xb0>
lea    (%r15,%r9,8),%rax
cmp    %rcx,%rax
jbe    11c0 <tf_dtx+0xb0>
xor    %ebp,%ebp
mov    %rbp,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1175 <tf_dtx+0x65>
nop
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rax
jne    1160 <tf_dtx+0x50>
cmp    $0x3,%r8
jb     129a <tf_dtx+0x18a>
nop
movsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
movsd  0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r15,%rbp,8)
movsd  0x10(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r15,%rbp,8)
movsd  0x18(%rcx,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r15,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r9
jne    1180 <tf_dtx+0x70>
jmp    129a <tf_dtx+0x18a>
mov    %r9d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%r10
mov    %r10,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0xc,%r10
jae    11e6 <tf_dtx+0xd6>
xor    %eax,%eax
jmp    1254 <tf_dtx+0x144>
and    $0xfffffffffffffffc,%r11
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
movups 0x20(%rcx,%rax,8),%xmm0
movups 0x30(%rcx,%rax,8),%xmm1
movups %xmm0,0x20(%r15,%rax,8)
movups %xmm1,0x30(%r15,%rax,8)
movups 0x40(%rcx,%rax,8),%xmm0
movups 0x50(%rcx,%rax,8),%xmm1
movups %xmm0,0x40(%r15,%rax,8)
movups %xmm1,0x50(%r15,%rax,8)
movupd 0x60(%rcx,%rax,8),%xmm0
movupd 0x70(%rcx,%rax,8),%xmm1
movupd %xmm0,0x60(%r15,%rax,8)
movupd %xmm1,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%r11
jne    11f0 <tf_dtx+0xe0>
test   %r8,%r8
je     1291 <tf_dtx+0x181>
lea    (%r15,%rax,8),%r10
add    $0x10,%r10
lea    (%rcx,%rax,8),%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %ebx,%ebx
nop
movupd -0x10(%rax,%rbx,1),%xmm0
movupd (%rax,%rbx,1),%xmm1
movupd %xmm0,-0x10(%r10,%rbx,1)
movupd %xmm1,(%r10,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1270 <tf_dtx+0x160>
cmp    %r9,%rbp
jne    114d <tf_dtx+0x3d>
test   %edx,%edx
jle    1849 <tf_dtx+0x739>
mov    %esi,%ecx
sub    %edx,%ecx
jle    1849 <tf_dtx+0x739>
mov    %edx,%r13d
not    %r13d
add    %esi,%r13d
lea    0x1(%rcx),%r8d
mov    %edx,%r14d
mov    %esi,0x1c(%rsp)
movslq %esi,%rax
mov    %rax,0x70(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x20(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0x58(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,0x50(%rsp)
add    $0xfffffffe,%ecx
mov    %rcx,0x68(%rsp)
lea    -0x8(%r15),%rax
mov    %rax,0x38(%rsp)
mov    %r14,%rax
shl    $0x20,%rax
mov    %rax,0x28(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,0x30(%rsp)
xor    %r11d,%r11d
movapd 0xcec(%rip),%xmm0
mov    %r8,0x60(%rsp)
mov    %edx,0xc(%rsp)
jmp    134b <tf_dtx+0x23b>
nop
add    $0x1,%r13d
add    $0x1,%r8d
add    $0x1,%r11d
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x28(%rsp)
addq   $0xffffffffffffffff,0x30(%rsp)
cmp    $0x1,%r10
jle    1748 <tf_dtx+0x638>
mov    %r14,%r9
test   %r13d,%r13d
mov    $0x1,%eax
cmovle %r13d,%eax
mov    0x70(%rsp),%r12
sub    %r14,%r12
movsd  -0x8(%r15,%r12,8),%xmm1
movsd  %xmm1,(%r15,%r12,8)
cmp    $0x2,%r12
jl     13bb <tf_dtx+0x2ab>
mov    %r13d,%edx
mov    %r13d,%r14d
sub    %eax,%r14d
cmp    $0x3,%r14d
jae    1520 <tf_dtx+0x410>
lea    0x1(%rdx),%ebx
lea    (%r15,%rdx,8),%rsi
lea    -0x1(%rdx),%ecx
lea    (%r15,%rcx,8),%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbp,8),%xmm1
subsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
add    $0xffffffffffffffff,%rbp
lea    (%rbx,%rbp,1),%eax
cmp    $0x1,%eax
jg     13a0 <tf_dtx+0x290>
mov    %r8d,%r8d
movsd  (%r15),%xmm1
xorpd  %xmm0,%xmm1
movlpd %xmm1,(%r15)
lea    -0x1(%r9),%r14
mov    %r9,%r10
cmp    $0x1,%r9
mov    $0xffffffff,%ebx
je     1320 <tf_dtx+0x210>
test   %r12,%r12
js     1320 <tf_dtx+0x210>
movslq %r14d,%rax
movsd  (%rdi,%rax,8),%xmm2
subsd  (%rdi),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%r15)
cmp    $0x1,%r8d
je     1320 <tf_dtx+0x210>
mov    0x60(%rsp),%rax
lea    (%rax,%r11,1),%esi
lea    -0x1(%rsi),%r9
mov    $0x1,%eax
cmp    $0x2,%r9
jb     16ec <tf_dtx+0x5dc>
mov    0xc(%rsp),%ecx
sub    %r11d,%ecx
lea    -0x2(%rsi),%rbx
lea    (%rbx,%rcx,1),%ebp
cmp    %ecx,%ebp
jl     16e7 <tf_dtx+0x5d7>
shr    $0x20,%rbx
jne    16e7 <tf_dtx+0x5d7>
movslq %ecx,%rcx
lea    (%rcx,%rsi,1),%rdx
lea    (%r15,%rsi,8),%rbp
lea    (%rdi,%rsi,8),%rsi
lea    (%rdi,%rcx,8),%rcx
mov    %rcx,0x10(%rsp)
mov    0x50(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    0x20(%rsp),%rbx
cmp    %rsi,%rbx
setb   %r12b
cmp    %rbp,0x58(%rsp)
setb   %dl
cmp    %rcx,%rbx
setb   %cl
cmp    %rbp,0x10(%rsp)
setb   %sil
test   %dl,%r12b
jne    16e7 <tf_dtx+0x5d7>
and    %sil,%cl
mov    $0xffffffff,%ebx
jne    16ec <tf_dtx+0x5dc>
lea    -0x1(%r8),%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
mov    %r9,%rax
or     $0x1,%rax
mov    0x28(%rsp),%rcx
xor    %ebx,%ebx
movabs $0x1fffffffc,%r12
nopl   0x0(%rax,%rax,1)
movupd 0x8(%r15,%rbx,8),%xmm1
lea    (%r12,%rcx,1),%rbp
add    $0x4,%rbp
sar    $0x1d,%rcx
movupd (%rdi,%rcx,1),%xmm2
movupd 0x8(%rdi,%rbx,8),%xmm3
subpd  %xmm3,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x8(%r15,%rbx,8)
add    $0x2,%rbx
mov    %rbp,%rcx
cmp    %rbx,%rsi
jne    14d0 <tf_dtx+0x3c0>
cmp    %rdx,%r9
mov    $0xffffffff,%ebx
je     1320 <tf_dtx+0x210>
jmp    16ec <tf_dtx+0x5dc>
nopl   0x0(%rax)
mov    0x68(%rsp),%rax
add    %r11d,%eax
cmp    %eax,%r14d
ja     1388 <tf_dtx+0x278>
lea    (%r15,%rdx,8),%rcx
mov    %r14d,%esi
shl    $0x3,%rsi
mov    %rcx,%rbp
sub    %rsi,%rbp
cmp    %rcx,%rbp
ja     1388 <tf_dtx+0x278>
lea    (%r15,%rax,8),%rbp
mov    %rbp,%rcx
sub    %rsi,%rcx
cmp    %rbp,%rcx
ja     1388 <tf_dtx+0x278>
mov    %rdx,%rcx
sub    %r14,%rcx
lea    (%r15,%rcx,8),%rcx
mov    0x20(%rsp),%rbp
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
cmp    %rsi,%rcx
jae    1598 <tf_dtx+0x488>
lea    0x0(,%rdx,8),%rcx
add    %rbp,%rcx
sub    %r14,%rax
lea    (%r15,%rax,8),%rax
cmp    %rcx,%rax
jb     1388 <tf_dtx+0x278>
add    $0x1,%r14
mov    %r14,%rbp
movabs $0x1fffffffc,%rax
and    %rax,%rbp
lea    -0x4(%rbp),%rcx
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     1737 <tf_dtx+0x627>
mov    %rax,0x40(%rsp)
mov    %rbp,0x48(%rsp)
mov    %r9,0x10(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%r10
mov    $0xffffffff,%ebx
lea    (%rdx,%rbx,1),%rax
add    $0xfffffffffffffffc,%rax
mov    %rdx,%rbp
add    %rbx,%rdx
mov    %r14,%r9
and    $0xfffffffffffffffc,%r9
add    $0xfffffffffffffffc,%r9
shr    $0x2,%r9
add    $0x1,%r9
and    $0xfffffffffffffffe,%r9
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rsi,1),%ecx
movupd -0x18(%r15,%rcx,8),%xmm1
movupd -0x8(%r15,%rcx,8),%xmm2
movupd -0x30(%r10,%rsi,8),%xmm3
movupd -0x20(%r10,%rsi,8),%xmm4
movupd -0x10(%r10,%rsi,8),%xmm5
subpd  %xmm5,%xmm1
movupd (%r10,%rsi,8),%xmm5
subpd  %xmm5,%xmm2
movupd %xmm2,(%r10,%rsi,8)
movupd %xmm1,-0x10(%r10,%rsi,8)
lea    (%rax,%rsi,1),%ecx
movupd -0x18(%r15,%rcx,8),%xmm1
subpd  %xmm3,%xmm1
movupd -0x8(%r15,%rcx,8),%xmm2
subpd  %xmm4,%xmm2
movupd %xmm2,-0x20(%r10,%rsi,8)
movupd %xmm1,-0x30(%r10,%rsi,8)
add    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffffe,%r9
jne    1610 <tf_dtx+0x500>
neg    %rsi
mov    0x10(%rsp),%r9
mov    %rbp,%rdx
mov    0x48(%rsp),%rbp
mov    0x40(%rsp),%rax
test   $0x1,%al
je     16d6 <tf_dtx+0x5c6>
mov    %rdx,%rcx
sub    %rsi,%rcx
lea    (%rbx,%rcx,1),%eax
movupd -0x18(%r15,%rax,8),%xmm1
movupd -0x8(%r15,%rax,8),%xmm2
movupd -0x18(%r15,%rcx,8),%xmm3
subpd  %xmm3,%xmm1
movupd -0x8(%r15,%rcx,8),%xmm3
subpd  %xmm3,%xmm2
movupd %xmm2,-0x8(%r15,%rcx,8)
movupd %xmm1,-0x18(%r15,%rcx,8)
cmp    %rbp,%r14
je     13bb <tf_dtx+0x2ab>
sub    %rbp,%rdx
jmp    1388 <tf_dtx+0x278>
mov    $0xffffffff,%ebx
mov    0x30(%rsp),%rcx
add    %eax,%ecx
shl    $0x20,%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
lea    (%rbx,%rcx,1),%rsi
add    $0x1,%rsi
sar    $0x1d,%rcx
movsd  (%rdi,%rcx,1),%xmm2
subsd  (%rdi,%rax,8),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
mov    %rsi,%rcx
cmp    %rax,%r8
jne    1700 <tf_dtx+0x5f0>
jmp    1320 <tf_dtx+0x210>
xor    %esi,%esi
mov    $0xffffffff,%ebx
test   $0x1,%al
jne    169b <tf_dtx+0x58b>
jmp    16d6 <tf_dtx+0x5c6>
mov    0xc(%rsp),%edi
add    $0xffffffff,%edi
call   1030 <glmgen_factorial@plt>
mov    0x1c(%rsp),%ecx
test   %ecx,%ecx
jle    1849 <tf_dtx+0x739>
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    176e <tf_dtx+0x65e>
xor    %ecx,%ecx
jmp    1830 <tf_dtx+0x720>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1858 <tf_dtx+0x748>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %rdx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
movupd 0x20(%r15,%rsi,8),%xmm4
movupd 0x30(%r15,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm3,0x10(%r15,%rsi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x20(%r15,%rsi,8)
movupd %xmm5,0x30(%r15,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    17b0 <tf_dtx+0x6a0>
test   $0x1,%dl
je     1827 <tf_dtx+0x717>
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rsi,8)
movupd %xmm3,0x10(%r15,%rsi,8)
cmp    %rax,%rcx
je     1849 <tf_dtx+0x739>
nopl   0x0(%rax)
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1830 <tf_dtx+0x720>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%dl
jne    1805 <tf_dtx+0x6f5>
jmp    1827 <tf_dtx+0x717>

LLVM IR (-O0):
define void @tf_dtx(double* %0, i32 %1, i32 %2, double* %3, double* %4) {
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca double
store double* %0, double** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store double* %3, double** %9
store double* %4, double** %10
store i32 0, i32* %11
br label %14
14: ; preds = %30, %5
%15 = load i32, i32* %11
%16 = load i32, i32* %7
%17 = load i32, i32* %8
%18 = sub nsw i32 %16, %17
%19 = icmp slt i32 %15, %18
br i1 %19, label %20, label %33
20: ; preds = %14
%21 = load double*, double** %9
%22 = load i32, i32* %11
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds double, double* %21, i64 %23
%25 = load double, double* %24
%26 = load double*, double** %10
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %26, i64 %28
store double %25, double* %29
br label %30
30: ; preds = %20
%31 = load i32, i32* %11
%32 = add nsw i32 %31, 1
store i32 %32, i32* %11
br label %14
33: ; preds = %14
%34 = load i32, i32* %8
%35 = icmp slt i32 %34, 1
br i1 %35, label %40, label %36
36: ; preds = %33
%37 = load i32, i32* %8
%38 = load i32, i32* %7
%39 = icmp sge i32 %37, %38
br i1 %39, label %40, label %41
40: ; preds = %36, %33
br label %156
41: ; preds = %36
%42 = load i32, i32* %8
store i32 %42, i32* %11
br label %43
43: ; preds = %134, %41
%44 = load i32, i32* %11
%45 = icmp sgt i32 %44, 0
br i1 %45, label %46, label %137
46: ; preds = %43
%47 = load double*, double** %10
%48 = load i32, i32* %7
%49 = load i32, i32* %11
%50 = sub nsw i32 %48, %49
%51 = sub nsw i32 %50, 1
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %47, i64 %52
%54 = load double, double* %53
%55 = load double*, double** %10
%56 = load i32, i32* %7
%57 = load i32, i32* %11
%58 = sub nsw i32 %56, %57
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %55, i64 %59
store double %54, double* %60
%61 = load i32, i32* %7
%62 = load i32, i32* %11
%63 = sub nsw i32 %61, %62
%64 = sub nsw i32 %63, 1
store i32 %64, i32* %12
br label %65
65: ; preds = %85, %46
%66 = load i32, i32* %12
%67 = icmp sgt i32 %66, 0
br i1 %67, label %68, label %88
68: ; preds = %65
%69 = load double*, double** %10
%70 = load i32, i32* %12
%71 = sub nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %69, i64 %72
%74 = load double, double* %73
%75 = load double*, double** %10
%76 = load i32, i32* %12
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
%79 = load double, double* %78
%80 = fsub double %74, %79
%81 = load double*, double** %10
%82 = load i32, i32* %12
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %81, i64 %83
store double %80, double* %84
br label %85
85: ; preds = %68
%86 = load i32, i32* %12
%87 = add nsw i32 %86, -1
store i32 %87, i32* %12
br label %65
88: ; preds = %65
%89 = load double*, double** %10
%90 = getelementptr inbounds double, double* %89, i64 0
%91 = load double, double* %90
%92 = fneg double %91
%93 = load double*, double** %10
%94 = getelementptr inbounds double, double* %93, i64 0
store double %92, double* %94
%95 = load i32, i32* %11
%96 = icmp ne i32 %95, 1
br i1 %96, label %97, label %133
97: ; preds = %88
store i32 0, i32* %12
br label %98
98: ; preds = %129, %97
%99 = load i32, i32* %12
%100 = load i32, i32* %7
%101 = load i32, i32* %11
%102 = sub nsw i32 %100, %101
%103 = icmp sle i32 %99, %102
br i1 %103, label %104, label %132
104: ; preds = %98
%105 = load double*, double** %10
%106 = load i32, i32* %12
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = load double*, double** %6
%111 = load i32, i32* %12
%112 = load i32, i32* %11
%113 = add nsw i32 %111, %112
%114 = sub nsw i32 %113, 1
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %110, i64 %115
%117 = load double, double* %116
%118 = load double*, double** %6
%119 = load i32, i32* %12
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = fsub double %117, %122
%124 = fdiv double %109, %123
%125 = load double*, double** %10
%126 = load i32, i32* %12
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
store double %124, double* %128
br label %129
129: ; preds = %104
%130 = load i32, i32* %12
%131 = add nsw i32 %130, 1
store i32 %131, i32* %12
br label %98
132: ; preds = %98
br label %133
133: ; preds = %132, %88
br label %134
134: ; preds = %133
%135 = load i32, i32* %11
%136 = add nsw i32 %135, -1
store i32 %136, i32* %11
br label %43
137: ; preds = %43
%138 = load i32, i32* %8
%139 = sub nsw i32 %138, 1
%140 = call double @glmgen_factorial(i32 %139)
store double %140, double* %13
store i32 0, i32* %11
br label %141
141: ; preds = %153, %137
%142 = load i32, i32* %11
%143 = load i32, i32* %7
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %156
145: ; preds = %141
%146 = load double, double* %13
%147 = load double*, double** %10
%148 = load i32, i32* %11
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %147, i64 %149
%151 = load double, double* %150
%152 = fmul double %151, %146
store double %152, double* %150
br label %153
153: ; preds = %145
%154 = load i32, i32* %11
%155 = add nsw i32 %154, 1
store i32 %155, i32* %11
br label %141
156: ; preds = %40, %141
ret void
}

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