#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 cos(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int sin(int);
int /*<<< orphan*/ stderr;
void m1ftrw(double *a, int n, int nn, int dir, int off, int max, int r, int rep,
            int rstr, double *w) {
  int i, j, k, ind;
  double b[2 * 2000];
  double cr, ci, c0r, c0i, c1r, c1i, tmp;
  off *= 2;
  max *= 2;
  nn *= 2;
  rstr *= 2;
  if (n * rep > 2000) {
    fprintf(stderr, "Increase BIG in m1ftr\n");
    exit(1);
  }
  c0r = cos(2 * (r % n) * 3.14159265358979 / n);
  c0i = dir * sin(2 * (r % n) * 3.14159265358979 / n);
  c1r = 1.0;
  c1i = 0.0;
  for (i = 0; i < 2 * n * rep; i += 2 * rep) {
    for (j = 0; j < 2 * rep; j++)
      b[i + j] = 0.0;
    cr = 1.0;
    ci = 0.0;
    ind = off;
    for (k = 0; k < rep; k++) {
      b[i + 2 * k] = 0.0;
      b[i + 2 * k + 1] = 0.0;
    }
    for (j = 0; j < n; j++) {
      for (k = 0; k < rep; k++) {
        b[i + 2 * k] += a[ind + k * rstr] * cr - a[ind + k * rstr + 1] * ci;
        b[i + 2 * k + 1] += a[ind + k * rstr] * ci + a[ind + k * rstr + 1] * cr;
      }
      tmp = cr;
      cr = cr * c1r - ci * c1i;
      ci = tmp * c1i + ci * c1r;
      ind += nn;
      if (ind > max)
        ind = ind - max;
    }
    tmp = c1r;
    c1r = c1r * c0r - c1i * c0i;
    c1i = tmp * c0i + c1i * c0r;
  }
  cr = 1.0;
  ci = 0.0;
  ind = off;
  for (i = 0; i < 2 * n * rep; i += 2 * rep) {
    for (k = 0; k < rep; k++) {
      a[ind + k * rstr] = b[i + 2 * k] * cr - b[i + 2 * k + 1] * ci;
      a[ind + k * rstr + 1] = b[i + 2 * k] * ci + b[i + 2 * k + 1] * cr;
    }
    tmp = cr;
    cr = cr * w[0] - ci * w[1];
    ci = tmp * w[1] + ci * w[0];
    ind += nn;
    if (ind > max)
      ind = ind - max;
  }
}


x86 assembly (clang, -O0):
<m1ftrw>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7d70,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    0x20(%rbp),%eax
shl    $0x1,%eax
mov    %eax,0x20(%rbp)
mov    -0xc(%rbp),%eax
imul   0x18(%rbp),%eax
cmp    $0x7d0,%eax
jle    11c2 <m1ftrw+0x82>
mov    0x2e36(%rip),%rax
mov    (%rax),%edi
lea    0xe5d(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    0x10(%rbp),%eax
cltd
idivl  -0xc(%rbp)
shl    $0x1,%edx
cvtsi2sd %edx,%xmm0
movsd  0xe30(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <cos@plt>
movsd  %xmm0,-0x7d48(%rbp)
ff
mov    -0x14(%rbp),%eax
mov    %eax,-0x7d6c(%rbp)
mov    0x10(%rbp),%eax
cltd
idivl  -0xc(%rbp)
shl    $0x1,%edx
cvtsi2sd %edx,%xmm0
movsd  0xdf3(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <sin@plt>
mov    %eax,%ecx
mov    -0x7d6c(%rbp),%eax
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x7d50(%rbp)
ff
movsd  0xdb6(%rip),%xmm0
movsd  %xmm0,-0x7d58(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d60(%rbp)
ff
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    159c <m1ftrw+0x45c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    0x18(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    12b3 <m1ftrw+0x173>
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
cltq
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d30(%rbp,%rax,8)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1280 <m1ftrw+0x140>
movsd  0xd45(%rip),%xmm0
movsd  %xmm0,-0x7d38(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d40(%rbp)
ff
mov    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    132a <m1ftrw+0x1ea>
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cltq
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d30(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d30(%rbp,%rax,8)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12db <m1ftrw+0x19b>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1504 <m1ftrw+0x3c4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    144c <m1ftrw+0x30c>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x7d38(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x7d40(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cltq
addsd  -0x7d30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x7d30(%rbp,%rax,8)
ff ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x7d40(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  -0x7d38(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
addsd  -0x7d30(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x7d30(%rbp,%rax,8)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1344 <m1ftrw+0x204>
movsd  -0x7d38(%rbp),%xmm0
ff
movsd  %xmm0,-0x7d68(%rbp)
ff
movsd  -0x7d38(%rbp),%xmm0
ff
movsd  -0x7d58(%rbp),%xmm2
ff
movsd  -0x7d40(%rbp),%xmm1
ff
mulsd  -0x7d60(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d38(%rbp)
ff
movsd  -0x7d68(%rbp),%xmm0
ff
movsd  -0x7d60(%rbp),%xmm2
ff
movsd  -0x7d40(%rbp),%xmm1
ff
mulsd  -0x7d58(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d40(%rbp)
ff
mov    -0x10(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    14f1 <m1ftrw+0x3b1>
mov    -0x2c(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    14f6 <m1ftrw+0x3b6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1331 <m1ftrw+0x1f1>
movsd  -0x7d58(%rbp),%xmm0
ff
movsd  %xmm0,-0x7d68(%rbp)
ff
movsd  -0x7d58(%rbp),%xmm0
ff
movsd  -0x7d48(%rbp),%xmm2
ff
movsd  -0x7d60(%rbp),%xmm1
ff
mulsd  -0x7d50(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d58(%rbp)
ff
movsd  -0x7d68(%rbp),%xmm0
ff
movsd  -0x7d50(%rbp),%xmm2
ff
movsd  -0x7d60(%rbp),%xmm1
ff
mulsd  -0x7d48(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d60(%rbp)
ff
mov    0x18(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1264 <m1ftrw+0x124>
movsd  0xa5c(%rip),%xmm0
movsd  %xmm0,-0x7d38(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7d40(%rbp)
ff
mov    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    178f <m1ftrw+0x64f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    16d2 <m1ftrw+0x592>
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cltq
movsd  -0x7d30(%rbp,%rax,8),%xmm0
movsd  -0x7d38(%rbp),%xmm2
ff
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
movsd  -0x7d30(%rbp,%rax,8),%xmm1
ff ff
mulsd  -0x7d40(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
cltq
movsd  -0x7d30(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x7d40(%rbp),%xmm2
ff
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
add    $0x1,%eax
cltq
movsd  -0x7d30(%rbp,%rax,8),%xmm1
ff ff
mulsd  -0x7d38(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15e0 <m1ftrw+0x4a0>
movsd  -0x7d38(%rbp),%xmm0
ff
movsd  %xmm0,-0x7d68(%rbp)
ff
movsd  -0x7d38(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x7d40(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d38(%rbp)
ff
movsd  -0x7d68(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0x7d40(%rbp),%xmm1
ff
mov    0x28(%rbp),%rax
mulsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x7d40(%rbp)
ff
mov    -0x10(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1779 <m1ftrw+0x639>
mov    -0x2c(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    177e <m1ftrw+0x63e>
mov    0x18(%rbp),%eax
shl    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    15c4 <m1ftrw+0x484>
add    $0x7d70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m1ftrw>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7d98,%rsp
mov    %ecx,0x8(%rsp)
mov    %rdi,0x18(%rsp)
mov    0x7dd8(%rsp),%eax
mov    %eax,%r15d
imul   %esi,%r15d
cmp    $0x7d1,%r15d
jge    150e <m1ftrw+0x3be>
mov    %r9d,%ebx
mov    %r8d,%r14d
mov    %edx,%r12d
mov    %esi,%ebp
mov    0x7dd0(%rsp),%eax
cltd
idiv   %esi
add    %edx,%edx
cvtsi2sd %edx,%xmm0
mulsd  0xe58(%rip),%xmm0
cvtsi2sd %esi,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%r13d
mov    %r13d,%edi
call   1060 <cos@plt>
movapd %xmm0,0x20(%rsp)
mov    %r13d,%edi
call   1050 <sin@plt>
add    %r15d,%r15d
test   %r15d,%r15d
mov    0x18(%rsp),%rsi
mov    0x7dd8(%rsp),%r10d
jle    14fc <m1ftrw+0x3ac>
mov    %r12d,%r8d
mov    %r15d,%edx
mov    0x7de0(%rsp),%ecx
add    %r14d,%r14d
mov    %r14d,0x4(%rsp)
add    %ebx,%ebx
add    %r12d,%r8d
add    %ecx,%ecx
imul   0x8(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    (%r10,%r10,1),%eax
movslq %eax,%rdi
cmp    $0x2,%edi
mov    $0x1,%eax
cmovge %edi,%eax
shl    $0x3,%rax
mov    %rax,0x40(%rsp)
mov    %r10d,%r15d
mov    %r15,0x38(%rsp)
shl    $0x4,%r15
movslq %ecx,%r14
cmp    %edi,%edx
mov    %edi,%eax
mov    %edx,0x10(%rsp)
cmovg  %edx,%eax
add    $0xffffffff,%eax
xor    %r9d,%r9d
xor    %edx,%edx
div    %edi
add    $0x1,%eax
mov    %rax,0x48(%rsp)
movapd 0x20(%rsp),%xmm2
movapd %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm1,0x60(%rsp)
unpcklpd %xmm2,%xmm0
movapd %xmm0,0x70(%rsp)
lea    0x8(%rsi),%r13
shl    $0x3,%r14
mov    %rdi,0x20(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %rax,0x8(%rsp)
movsd  0xd75(%rip),%xmm7
lea    0x90(%rsp),%r12
movapd 0xd6d(%rip),%xmm6
mov    %r8d,0x14(%rsp)
jmp    12e9 <m1ftrw+0x199>
nopw   0x0(%rax,%rax,1)
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
xorpd  %xmm6,%xmm0
shufpd $0x2,%xmm7,%xmm0
mulpd  0x70(%rsp),%xmm0
unpcklpd %xmm7,%xmm7
mulpd  0x60(%rsp),%xmm7
addpd  %xmm0,%xmm7
add    $0x1,%r9
add    0x8(%rsp),%r12
cmp    0x48(%rsp),%r9
je     1422 <m1ftrw+0x2d2>
test   %r10d,%r10d
jle    1353 <m1ftrw+0x203>
mov    %r9,%rax
imul   0x20(%rsp),%rax
lea    (%rsp,%rax,8),%rdi
add    $0x90,%rdi
mov    %rdi,0x50(%rsp)
xor    %esi,%esi
mov    0x40(%rsp),%rdx
mov    %r9,0x58(%rsp)
movapd %xmm7,0x80(%rsp)
call   1030 <memset@plt>
mov    0x50(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
movapd 0x80(%rsp),%xmm7
mov    0x58(%rsp),%r9
movapd 0xcca(%rip),%xmm6
mov    0x7dd8(%rsp),%r10d
mov    0x14(%rsp),%r8d
test   %ebp,%ebp
jle    12b0 <m1ftrw+0x160>
movapd %xmm7,%xmm0
shufpd $0x1,%xmm7,%xmm0
xor    %eax,%eax
mov    0x4(%rsp),%ecx
movsd  0xc96(%rip),%xmm1
jmp    13bb <m1ftrw+0x26b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
xorpd  %xmm6,%xmm2
shufpd $0x2,%xmm1,%xmm2
mulpd  %xmm0,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm7,%xmm1
add    %r8d,%ecx
cmp    %ebx,%ecx
mov    $0x0,%edx
cmovg  %ebx,%edx
addpd  %xmm2,%xmm1
sub    %edx,%ecx
add    $0x1,%eax
cmp    %ebp,%eax
je     12b0 <m1ftrw+0x160>
test   %r10d,%r10d
jle    1380 <m1ftrw+0x230>
movslq %ecx,%rdx
movapd %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm2
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  -0x8(%rdx),%xmm3
movsd  (%rdx),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm6,%xmm5
unpcklpd %xmm4,%xmm5
mulpd  %xmm2,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
addpd  (%r12,%rsi,1),%xmm3
movapd %xmm3,(%r12,%rsi,1)
add    %r14,%rdx
add    $0x10,%rsi
cmp    %rsi,%r15
jne    13e0 <m1ftrw+0x290>
jmp    1380 <m1ftrw+0x230>
mov    0x10(%rsp),%ecx
test   %ecx,%ecx
mov    0x4(%rsp),%ebp
mov    0x18(%rsp),%r9
mov    0x7de8(%rsp),%r11
mov    0x38(%rsp),%rax
jle    14fc <m1ftrw+0x3ac>
mov    %ecx,%r15d
lea    0x98(%rsp),%rcx
shl    $0x4,%rax
movsd  0xbad(%rip),%xmm0
xor    %edx,%edx
jmp    14a9 <m1ftrw+0x359>
nop
movupd (%r11),%xmm1
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
xorpd  %xmm6,%xmm2
shufpd $0x2,%xmm0,%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm1,%xmm0
shufpd $0x1,%xmm1,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm1,%xmm0
add    %r8d,%ebp
cmp    %ebx,%ebp
mov    $0x0,%esi
cmovg  %ebx,%esi
sub    %esi,%ebp
add    0x20(%rsp),%rdx
add    0x8(%rsp),%rcx
cmp    %r15,%rdx
jge    14fc <m1ftrw+0x3ac>
test   %r10d,%r10d
jle    1460 <m1ftrw+0x310>
movslq %ebp,%rsi
movapd %xmm0,%xmm1
shufpd $0x1,%xmm0,%xmm1
lea    (%r9,%rsi,8),%rsi
xor    %edi,%edi
movsd  -0x8(%rcx,%rdi,1),%xmm2
movsd  (%rcx,%rdi,1),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm6,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm1,%xmm4
unpcklpd %xmm2,%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rsi)
add    %r14,%rsi
add    $0x10,%rdi
cmp    %rdi,%rax
jne    14c0 <m1ftrw+0x370>
jmp    1460 <m1ftrw+0x310>
add    $0x7d98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2acb(%rip),%rax
mov    (%rax),%edi
lea    0xb02(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x1,%edi
call   1070 <exit@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [23 x i8] c"Increase BIG in m1ftr\0A\00"
define void @m1ftrw(double* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, double* nocapture %9) {
%11 = alloca [4000 x double]
%12 = bitcast [4000 x double]* %11 to i8*
%13 = shl nsw i32 %4, 1
%14 = shl nsw i32 %5, 1
%15 = shl nsw i32 %2, 1
%16 = shl nsw i32 %8, 1
%17 = mul nsw i32 %7, %1
%18 = icmp sgt i32 %17, 2000
br i1 %18, label %19, label %23
19: ; preds = %10
%20 = load i32, i32* @stderr
%21 = tail call i32 @fprintf(i32 %20, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
%22 = tail call i32 @exit(i32 1)
unreachable
23: ; preds = %10
%24 = srem i32 %6, %1
%25 = shl nsw i32 %24, 1
%26 = sitofp i32 %25 to double
%27 = fmul double %26, 0x400921FB54442D11
%28 = sitofp i32 %1 to double
%29 = fdiv double %27, %28
%30 = fptosi double %29 to i32
%31 = tail call double @cos(i32 %30)
%32 = tail call i32 @sin(i32 %30)
%33 = mul nsw i32 %32, %3
%34 = sitofp i32 %33 to double
%35 = shl nsw i32 %1, 1
%36 = mul i32 %35, %7
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %178
38: ; preds = %23
%39 = shl i32 %7, 1
%40 = icmp sgt i32 %7, 0
%41 = icmp sgt i32 %1, 0
%42 = sext i32 %39 to i64
%43 = call i32 @llvm.smax.i32(i32 %39, i32 1)
%44 = zext i32 %43 to i64
%45 = shl nuw nsw i64 %44, 3
%46 = zext i32 %7 to i64
%47 = shl nuw nsw i64 %46, 4
%48 = sext i32 %16 to i64
%49 = call i32 @llvm.smax.i32(i32 %36, i32 %39)
%50 = add nsw i32 %49, -1
%51 = udiv i32 %50, %39
%52 = add i32 %51, 1
%53 = zext i32 %52 to i64
%54 = insertelement <2 x double> poison, double %31, i64 0
%55 = insertelement <2 x double> %54, double %34, i64 1
%56 = insertelement <2 x double> poison, double %34, i64 0
%57 = insertelement <2 x double> %56, double %31, i64 1
br label %58
58: ; preds = %38, %123
%59 = phi i64 [ 0, %38 ], [ %130, %123 ]
%60 = phi i64 [ 0, %38 ], [ %131, %123 ]
%61 = phi <2 x double> [ <double 1.000000e+00, double 0.000000e+00>, %38 ], [ %129, %123 ]
%62 = mul nsw i64 %60, %42
%63 = getelementptr [4000 x double], [4000 x double]* %11, i64 0, i64 %62
%64 = bitcast double* %63 to i8*
br i1 %40, label %74, label %75
65: ; preds = %123
br i1 %37, label %66, label %178
66: ; preds = %65
%67 = icmp sgt i32 %7, 0
%68 = shl i32 %7, 1
%69 = sext i32 %16 to i64
%70 = sext i32 %68 to i64
%71 = zext i32 %36 to i64
%72 = zext i32 %7 to i64
%73 = bitcast double* %9 to <2 x double>*
br label %133
74: ; preds = %58
br label %75
75: ; preds = %58, %74
br i1 %41, label %76, label %123
76: ; preds = %75
%77 = shufflevector <2 x double> %61, <2 x double> undef, <2 x i32> <i32 1, i32 0>
br label %78
78: ; preds = %76, %110
%79 = phi i32 [ %120, %110 ], [ %13, %76 ]
%80 = phi i32 [ %121, %110 ], [ 0, %76 ]
%81 = phi <2 x double> [ %116, %110 ], [ <double 1.000000e+00, double 0.000000e+00>, %76 ]
br i1 %40, label %82, label %110
82: ; preds = %78
%83 = sext i32 %79 to i64
%84 = shufflevector <2 x double> %81, <2 x double> undef, <2 x i32> <i32 1, i32 0>
br label %85
85: ; preds = %82, %85
%86 = phi i64 [ 0, %82 ], [ %108, %85 ]
%87 = mul nsw i64 %86, %48
%88 = add nsw i64 %87, %83
%89 = getelementptr inbounds double, double* %0, i64 %88
%90 = load double, double* %89
%91 = add nsw i64 %88, 1
%92 = getelementptr inbounds double, double* %0, i64 %91
%93 = load double, double* %92
%94 = fneg double %93
%95 = shl nuw nsw i64 %86, 1
%96 = add nsw i64 %95, %59
%97 = getelementptr inbounds [4000 x double], [4000 x double]* %11, i64 0, i64 %96
%98 = insertelement <2 x double> poison, double %94, i64 0
%99 = insertelement <2 x double> %98, double %93, i64 1
%100 = fmul <2 x double> %84, %99
%101 = insertelement <2 x double> poison, double %90, i64 0
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> zeroinitializer
%103 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %102, <2 x double> %81, <2 x double> %100)
%104 = bitcast double* %97 to <2 x double>*
%105 = load <2 x double>, <2 x double>* %104
%106 = fadd <2 x double> %105, %103
%107 = bitcast double* %97 to <2 x double>*
store <2 x double> %106, <2 x double>* %107
%108 = add nuw nsw i64 %86, 1
%109 = icmp eq i64 %108, %46
br i1 %109, label %110, label %85
110: ; preds = %85, %78
%111 = extractelement <2 x double> %81, i64 1
%112 = fneg double %111
%113 = insertelement <2 x double> %81, double %112, i64 0
%114 = fmul <2 x double> %77, %113
%115 = shufflevector <2 x double> %81, <2 x double> undef, <2 x i32> zeroinitializer
%116 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %61, <2 x double> %114)
%117 = add nsw i32 %79, %15
%118 = icmp sgt i32 %117, %14
%119 = select i1 %118, i32 %14, i32 0
%120 = sub nsw i32 %117, %119
%121 = add nuw nsw i32 %80, 1
%122 = icmp eq i32 %121, %1
br i1 %122, label %123, label %78
123: ; preds = %110, %75
%124 = extractelement <2 x double> %61, i64 1
%125 = fneg double %124
%126 = insertelement <2 x double> %61, double %125, i64 0
%127 = fmul <2 x double> %57, %126
%128 = shufflevector <2 x double> %61, <2 x double> undef, <2 x i32> zeroinitializer
%129 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %55, <2 x double> %127)
%130 = add nsw i64 %59, %42
%131 = add nuw nsw i64 %60, 1
%132 = icmp eq i64 %131, %53
br i1 %132, label %65, label %58
133: ; preds = %66, %162
%134 = phi i64 [ 0, %66 ], [ %176, %162 ]
%135 = phi i32 [ %13, %66 ], [ %175, %162 ]
%136 = phi <2 x double> [ <double 1.000000e+00, double 0.000000e+00>, %66 ], [ %171, %162 ]
br i1 %67, label %137, label %162
137: ; preds = %133
%138 = sext i32 %135 to i64
%139 = shufflevector <2 x double> %136, <2 x double> undef, <2 x i32> <i32 1, i32 0>
br label %140
140: ; preds = %137, %140
%141 = phi i64 [ 0, %137 ], [ %160, %140 ]
%142 = shl nuw nsw i64 %141, 1
%143 = add nsw i64 %142, %134
%144 = getelementptr inbounds [4000 x double], [4000 x double]* %11, i64 0, i64 %143
%145 = load double, double* %144
%146 = or i64 %143, 1
%147 = getelementptr inbounds [4000 x double], [4000 x double]* %11, i64 0, i64 %146
%148 = load double, double* %147
%149 = fneg double %148
%150 = mul nsw i64 %141, %69
%151 = add nsw i64 %150, %138
%152 = getelementptr inbounds double, double* %0, i64 %151
%153 = insertelement <2 x double> poison, double %149, i64 0
%154 = insertelement <2 x double> %153, double %148, i64 1
%155 = fmul <2 x double> %139, %154
%156 = insertelement <2 x double> poison, double %145, i64 0
%157 = shufflevector <2 x double> %156, <2 x double> poison, <2 x i32> zeroinitializer
%158 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %157, <2 x double> %136, <2 x double> %155)
%159 = bitcast double* %152 to <2 x double>*
store <2 x double> %158, <2 x double>* %159
%160 = add nuw nsw i64 %141, 1
%161 = icmp eq i64 %160, %72
br i1 %161, label %162, label %140
162: ; preds = %140, %133
%163 = load <2 x double>, <2 x double>* %73
%164 = extractelement <2 x double> %136, i64 1
%165 = fneg double %164
%166 = insertelement <2 x double> poison, double %164, i64 0
%167 = insertelement <2 x double> %166, double %165, i64 1
%168 = fmul <2 x double> %163, %167
%169 = shufflevector <2 x double> %168, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%170 = shufflevector <2 x double> %136, <2 x double> undef, <2 x i32> zeroinitializer
%171 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %163, <2 x double> %169)
%172 = add nsw i32 %135, %15
%173 = icmp sgt i32 %172, %14
%174 = select i1 %173, i32 %14, i32 0
%175 = sub nsw i32 %172, %174
%176 = add nsw i64 %134, %70
%177 = icmp slt i64 %176, %71
br i1 %177, label %133, label %178
178: ; preds = %162, %23, %65
ret void
}