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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ ChebyDivRem(double *, double const, double *, int);
int /*<<< orphan*/ OURpermute(double *, double *, int);
double *get_mods(int);
int /*<<< orphan*/ memcpy(double *, double *, int);
int /*<<< orphan*/ reverse_it(double *, double *, int);
void ExpIFCT(double *data, double *result, double *workspace, int n, int k,
             int permflag) {
  int j, loopcntr;
  int levelsize, divsize;
  double *dividend, *remres;
  const double *modptr;
  double *divptr, *remptr;
  double divptr0, divptr1, divptr2, divptr3;
  double tmpmod, tmpmod2;
  remres = workspace;
  dividend = workspace + n;
  reverse_it(data, dividend, k);
  levelsize = 2 * (n / k);
  divsize = k;
  modptr = get_mods(levelsize);
  divptr = dividend;
  remptr = remres;
  loopcntr = 0;
  for (j = 0; j < levelsize; j += 2) {
    ChebyDivRem(divptr, modptr[j], remptr, divsize);
    remptr += (divsize >> 1);
    ChebyDivRem(divptr, modptr[j + 1], remptr, divsize);
    remptr += (divsize >> 1);
  }
  divptr = remres;
  remptr = dividend;
  loopcntr++;
  divsize /= 2;
  levelsize *= 2;
  modptr = get_mods(levelsize);
  while (divsize > 4) {
    for (j = 0; j < levelsize; j += 2) {
      ChebyDivRem(divptr, modptr[j], remptr, divsize);
      remptr += (divsize >> 1);
      ChebyDivRem(divptr, modptr[j + 1], remptr, divsize);
      remptr += (divsize >> 1);
      divptr += divsize;
    }
    if ((loopcntr % 2) == 0) {
      divptr = remres;
      remptr = dividend;
    } else {
      divptr = dividend;
      remptr = remres;
    }
    loopcntr++;
    divsize /= 2;
    levelsize *= 2;
    modptr = get_mods(levelsize);
  }
  if (divsize == 4) {
    for (j = 0; j < levelsize; j += 2) {
      divptr0 = divptr[0];
      divptr1 = divptr[1];
      divptr2 = divptr[2];
      divptr3 = divptr[3];
      tmpmod = modptr[j];
      tmpmod2 = 2.0 * modptr[j];
      remptr[0] = divptr2 - divptr0 - (tmpmod2 * divptr0);
      remptr[1] = (divptr3 - (tmpmod * divptr1));
      remptr[2] = divptr2 - divptr0 + (tmpmod2 * divptr0);
      remptr[3] = (divptr3 + (tmpmod * divptr1));
      remptr += 4;
      divptr += 4;
    }
    if ((loopcntr % 2) == 0) {
      divptr = remres;
      remptr = dividend;
    } else {
      divptr = dividend;
      remptr = remres;
    }
    loopcntr++;
    divsize /= 2;
    levelsize *= 2;
    modptr = get_mods(levelsize);
  }
  if (divsize == 2) {
    for (j = 0; j < levelsize; j += 2) {
      divptr0 = divptr[0];
      divptr1 = divptr[1];
      remptr[0] = divptr1 - (modptr[j] * divptr0);
      remptr[1] = divptr1 + (modptr[j] * divptr0);
      remptr += 2;
      divptr += divsize;
    }
    if ((loopcntr % 2) == 0) {
      divptr = remres;
      remptr = dividend;
    } else {
      divptr = dividend;
      remptr = remres;
    }
  }
  if (permflag == 0) {
    memcpy(result, divptr, sizeof(double) * n);
  } else
    OURpermute(divptr, result, n);
}


x86 assembly (clang, -O0):
<ExpIFCT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1060 <reverse_it@plt>
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x20(%rbp)
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%edi
call   1070 <get_mods@plt>
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1263 <ExpIFCT+0x113>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <ChebyDivRem@plt>
mov    -0x34(%rbp),%ecx
sar    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <ChebyDivRem@plt>
mov    -0x34(%rbp),%ecx
sar    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    11da <ExpIFCT+0x8a>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
call   1070 <get_mods@plt>
mov    %rax,-0x50(%rbp)
cmpl   $0x4,-0x34(%rbp)
jle    13b8 <ExpIFCT+0x268>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    134e <ExpIFCT+0x1fe>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <ChebyDivRem@plt>
mov    -0x34(%rbp),%ecx
sar    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <ChebyDivRem@plt>
mov    -0x34(%rbp),%ecx
sar    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    12b0 <ExpIFCT+0x160>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1377 <ExpIFCT+0x227>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1387 <ExpIFCT+0x237>
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
call   1070 <get_mods@plt>
mov    %rax,-0x50(%rbp)
jmp    129f <ExpIFCT+0x14f>
cmpl   $0x4,-0x34(%rbp)
jne    158c <ExpIFCT+0x43c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1527 <ExpIFCT+0x3d7>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x58(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x58(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  0xbcf(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x78(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x60(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    13c9 <ExpIFCT+0x279>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1550 <ExpIFCT+0x400>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1560 <ExpIFCT+0x410>
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edi
call   1070 <get_mods@plt>
mov    %rax,-0x50(%rbp)
cmpl   $0x2,-0x34(%rbp)
jne    1697 <ExpIFCT+0x547>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1659 <ExpIFCT+0x509>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x58(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x60(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x60(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    159d <ExpIFCT+0x44d>
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1682 <ExpIFCT+0x532>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1692 <ExpIFCT+0x542>
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1697 <ExpIFCT+0x547>
cmpl   $0x0,-0x24(%rbp)
jne    16bd <ExpIFCT+0x56d>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1050 <memcpy@plt>
jmp    16cd <ExpIFCT+0x57d>
mov    -0x58(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <OURpermute@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ExpIFCT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9d,0x4c(%rsp)
mov    %r8d,%r14d
mov    %rsi,0x50(%rsp)
mov    %ecx,0x3c(%rsp)
movslq %ecx,%rbx
mov    %rdx,0x20(%rsp)
lea    (%rdx,%rbx,8),%r15
mov    %r15,%rsi
mov    %r8d,%edx
call   1060 <reverse_it@plt>
mov    %ebx,%eax
cltd
idiv   %r14d
mov    %eax,%ebx
lea    (%rbx,%rbx,1),%ebp
mov    %ebp,%edi
call   1070 <get_mods@plt>
mov    %rbx,0x28(%rsp)
test   %ebx,%ebx
jle    120e <ExpIFCT+0xbe>
mov    %rax,%r13
mov    %r14d,%eax
sar    %eax
cltq
movslq %ebp,%rcx
mov    %rcx,0x30(%rsp)
mov    %rax,%r12
shl    $0x4,%r12
shl    $0x3,%rax
mov    %rax,0x18(%rsp)
xor    %ebx,%ebx
mov    0x20(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14d,%edx
call   1030 <ChebyDivRem@plt>
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,1),%rsi
movsd  0x8(%r13,%rbx,8),%xmm0
mov    %r15,%rdi
mov    %r14d,%edx
call   1030 <ChebyDivRem@plt>
add    $0x2,%rbx
add    %r12,%rbp
cmp    0x30(%rsp),%rbx
jl     11d0 <ExpIFCT+0x80>
mov    %r15,0x8(%rsp)
mov    0x28(%rsp),%rbp
shl    $0x2,%ebp
mov    %ebp,%edi
call   1070 <get_mods@plt>
mov    %r14d,%ecx
shr    $0x1f,%ecx
add    %r14d,%ecx
sar    %ecx
mov    $0x1,%r12d
cmp    $0xa,%r14d
jl     1327 <ExpIFCT+0x1d7>
mov    $0x1,%r12d
mov    0x8(%rsp),%r13
mov    0x20(%rsp),%rbx
jmp    1295 <ExpIFCT+0x145>
nop
mov    0x14(%rsp),%r12d
test   $0x1,%r12b
mov    0x8(%rsp),%r15
mov    %r15,%rbx
mov    0x20(%rsp),%r13
cmove  %r13,%rbx
cmove  %r15,%r13
add    $0x1,%r12d
mov    0x28(%rsp),%rbp
add    %ebp,%ebp
mov    %ebp,%edi
call   1070 <get_mods@plt>
mov    %r14d,%ecx
shr    $0x1f,%ecx
add    %r14d,%ecx
sar    %ecx
cmp    $0x9,%r14d
jle    1334 <ExpIFCT+0x1e4>
mov    %r12d,0x14(%rsp)
mov    %ecx,%r14d
mov    %rbp,0x28(%rsp)
test   %ebp,%ebp
jle    1250 <ExpIFCT+0x100>
mov    %rax,%r12
mov    %r14d,%eax
sar    %eax
movslq %r14d,%rbp
mov    0x28(%rsp),%ecx
mov    %rcx,0x30(%rsp)
mov    %rax,%rcx
shl    $0x4,%rcx
mov    %rcx,0x40(%rsp)
shl    $0x3,%rax
mov    %rax,0x18(%rsp)
shl    $0x3,%rbp
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r15,8),%xmm0
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r14d,%edx
call   1030 <ChebyDivRem@plt>
mov    0x18(%rsp),%rax
lea    (%rax,%r13,1),%rsi
movsd  0x8(%r12,%r15,8),%xmm0
mov    %rbx,%rdi
mov    %r14d,%edx
call   1030 <ChebyDivRem@plt>
add    $0x2,%r15
add    0x40(%rsp),%r13
add    %rbp,%rbx
cmp    0x30(%rsp),%r15
jb     12e0 <ExpIFCT+0x190>
jmp    1250 <ExpIFCT+0x100>
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%r15
mov    %r15,%r13
and    $0xfffffffe,%r14d
cmp    $0x8,%r14d
jne    13c4 <ExpIFCT+0x274>
test   %ebp,%ebp
jle    13a1 <ExpIFCT+0x251>
mov    %ebp,%esi
xor    %ecx,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movupd (%rbx,%rcx,2),%xmm0
movsd  0x10(%rbx,%rcx,2),%xmm1
movsd  (%rax,%rcx,1),%xmm2
movapd %xmm2,%xmm3
addsd  %xmm2,%xmm3
subsd  %xmm0,%xmm1
unpcklpd %xmm2,%xmm3
movhpd 0x18(%rbx,%rcx,2),%xmm1
mulpd  %xmm0,%xmm3
movapd %xmm1,%xmm0
subpd  %xmm3,%xmm0
movupd %xmm0,0x0(%r13,%rcx,2)
addpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r13,%rcx,2)
add    $0x2,%rdx
add    $0x10,%rcx
cmp    %rsi,%rdx
jb     1350 <ExpIFCT+0x200>
test   $0x1,%r12b
mov    %r15,%rbx
mov    0x20(%rsp),%r13
cmove  %r13,%rbx
cmove  %r15,%r13
add    $0x1,%r12d
add    %ebp,%ebp
mov    %ebp,%edi
call   1070 <get_mods@plt>
jmp    13cd <ExpIFCT+0x27d>
cmp    $0x2,%ecx
jne    15e1 <ExpIFCT+0x491>
test   %ebp,%ebp
jle    15d4 <ExpIFCT+0x484>
mov    %ebp,%r10d
lea    -0x1(%r10),%rdx
cmp    $0x4,%rdx
jae    13ea <ExpIFCT+0x29a>
xor    %r14d,%r14d
jmp    157f <ExpIFCT+0x42f>
mov    %r12d,0x14(%rsp)
lea    -0x8(,%r10,8),%rcx
ff
or     $0x8,%rcx
lea    (%rcx,%r13,1),%r11
lea    0x8(%r13),%rsi
lea    0x1(%r10),%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x0(,%rbp,8),%rdi
add    %r13,%rdi
lea    (%rbx,%rcx,1),%r12
lea    0x8(%rbx),%r15
lea    (%rbx,%rbp,8),%rbp
add    %rax,%rcx
cmp    %rdi,%r13
setb   0x18(%rsp)
cmp    %r11,%rsi
setb   0x30(%rsp)
cmp    %r12,%r13
setb   %r8b
cmp    %r11,%rbx
setb   0x40(%rsp)
cmp    %rbp,%r13
setb   %r9b
cmp    %r11,%r15
setb   0x28(%rsp)
cmp    %rcx,%r13
setb   0x7(%rsp)
cmp    %r11,%rax
setb   0x6(%rsp)
cmp    %r12,%rsi
setb   %r11b
cmp    %rdi,%rbx
setb   %r12b
cmp    %rbp,%rsi
setb   %bpl
cmp    %rdi,%r15
setb   %r15b
cmp    %rcx,%rsi
setb   %sil
cmp    %rdi,%rax
setb   %dil
xor    %r14d,%r14d
mov    0x30(%rsp),%cl
test   %cl,0x18(%rsp)
jne    1629 <ExpIFCT+0x4d9>
mov    %dil,0x18(%rsp)
mov    %r15d,%edi
mov    %r12d,%r15d
and    0x40(%rsp),%r8b
mov    0x14(%rsp),%r12d
jne    157a <ExpIFCT+0x42a>
and    0x28(%rsp),%r9b
jne    157a <ExpIFCT+0x42a>
mov    0x6(%rsp),%cl
and    %cl,0x7(%rsp)
jne    157a <ExpIFCT+0x42a>
and    %r15b,%r11b
jne    157a <ExpIFCT+0x42a>
and    %dil,%bpl
jne    157a <ExpIFCT+0x42a>
and    0x18(%rsp),%sil
jne    157a <ExpIFCT+0x42a>
shr    %rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x1,%ecx
test   %rcx,%rcx
mov    $0x2,%esi
cmovne %rcx,%rsi
sub    %rsi,%rdx
lea    (%rdx,%rdx,1),%r14
mov    %rdx,%rsi
shl    $0x4,%rsi
lea    (%rsi,%r13,1),%rdi
add    %rbx,%rsi
xor    %ebp,%ebp
xchg   %ax,%ax
movupd (%rbx,%rbp,1),%xmm0
movupd 0x10(%rbx,%rbp,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movsd  (%rax,%rbp,1),%xmm1
movhpd 0x10(%rax,%rbp,1),%xmm1
mulpd  %xmm2,%xmm1
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm2,%xmm0
unpcklpd %xmm1,%xmm0
movhlps %xmm2,%xmm1
movups %xmm1,0x10(%r13,%rbp,1)
movupd %xmm0,0x0(%r13,%rbp,1)
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1520 <ExpIFCT+0x3d0>
mov    %rdi,%r13
mov    %rsi,%rbx
mov    0x8(%rsp),%r15
lea    (%rax,%r14,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rsi,8),%xmm0
movsd  0x8(%rbx,%rsi,8),%xmm1
movsd  (%rdx,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rsi,8)
mulsd  (%rdx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r13,%rsi,8)
lea    (%r14,%rsi,1),%rdi
add    $0x2,%rdi
add    $0x2,%rsi
cmp    %r10,%rdi
jb     1590 <ExpIFCT+0x440>
test   $0x1,%r12b
cmove  0x20(%rsp),%r15
mov    %r15,%rbx
cmpl   $0x0,0x4c(%rsp)
je     1607 <ExpIFCT+0x4b7>
mov    %rbx,%rdi
mov    0x50(%rsp),%rsi
mov    0x3c(%rsp),%edx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <OURpermute@plt>
mov    0x3c(%rsp),%edx
shl    $0x3,%edx
mov    0x50(%rsp),%rdi
mov    %rbx,%rsi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <memcpy@plt>
mov    0x8(%rsp),%r15
mov    0x14(%rsp),%r12d
jmp    157f <ExpIFCT+0x42f>

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

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