#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 */
typedef int ic;
typedef int i;

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ fpsconv(double *, int, double *, double *, int, double *,
                           double *);
int /*<<< orphan*/ free(double *);
void MDWT(double *x, int m, int n, double *h, int lh, int L, double *y) {
  double *h0, *h1, *ydummyl, *ydummyh, *xdummy;
  long i, j;
  int actual_L, actual_m, actual_n, r_o_a, c_o_a, ir, ic, lhm1;
  xdummy = (double *)calloc((m > n ? m : n) + lh - 1, sizeof(double));
  ydummyl = (double *)calloc((m > n ? m : n), sizeof(double));
  ydummyh = (double *)calloc((m > n ? m : n), sizeof(double));
  h0 = (double *)calloc(lh, sizeof(double));
  h1 = (double *)calloc(lh, sizeof(double));
  if (n == 1) {
    n = m;
    m = 1;
  }
  for (i = 0; i < lh; i++) {
    h0[i] = h[lh - i - 1];
    h1[i] = h[i];
  }
  for (i = 0; i < lh; i += 2)
    h1[i] = -h1[i];
  lhm1 = lh - 1;
  actual_m = 2 * m;
  actual_n = 2 * n;
  for (actual_L = 1; actual_L <= L; actual_L++) {
    if (m == 1)
      actual_m = 1;
    else {
      actual_m = actual_m / 2;
      r_o_a = actual_m / 2;
    }
    actual_n = actual_n / 2;
    c_o_a = actual_n / 2;
    for (ir = 0; ir < actual_m; ir++) {
      for (i = 0; i < actual_n; i++)
        if (actual_L == 1)
          xdummy[i] = (*(x + (m * (i) + ir)));
        else
          xdummy[i] = (*(y + (m * (i) + ir)));
      fpsconv(xdummy, actual_n, h0, h1, lhm1, ydummyl, ydummyh);
      ic = c_o_a;
      for (i = 0; i < c_o_a; i++) {
        (*(y + (m * (i) + ir))) = ydummyl[i];
        (*(y + (m * (ic++) + ir))) = ydummyh[i];
      }
    }
    if (m > 1) {
      for (ic = 0; ic < actual_n; ic++) {
        for (i = 0; i < actual_m; i++)
          xdummy[i] = (*(y + (m * (ic) + i)));
        fpsconv(xdummy, actual_m, h0, h1, lhm1, ydummyl, ydummyh);
        ir = r_o_a;
        for (i = 0; i < r_o_a; i++) {
          (*(y + (m * (ic) + i))) = ydummyl[i];
          (*(y + (m * (ic) + ir++))) = ydummyh[i];
        }
      }
    }
  }
  free(xdummy);
  free(ydummyl);
  free(ydummyh);
  free(h0);
  free(h1);
}


x86 assembly (clang, -O0):
<MDWT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    116c <MDWT+0x3c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    1172 <MDWT+0x42>
mov    -0x10(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%edi
add    -0x1c(%rbp),%edi
sub    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11a0 <MDWT+0x70>
mov    -0xc(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    11a6 <MDWT+0x76>
mov    -0x10(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    11d1 <MDWT+0xa1>
mov    -0xc(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    11da <MDWT+0xaa>
mov    -0x10(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x1c(%rbp),%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
cmpl   $0x1,-0x10(%rbp)
jne    1227 <MDWT+0xf7>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
movl   $0x1,-0xc(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jge    128d <MDWT+0x15d>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
sub    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    122f <MDWT+0xff>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jge    12e8 <MDWT+0x1b8>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
jmp    1295 <MDWT+0x165>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     15f6 <MDWT+0x4c6>
cmpl   $0x1,-0xc(%rbp)
jne    132c <MDWT+0x1fc>
movl   $0x1,-0x60(%rbp)
jmp    1348 <MDWT+0x218>
mov    -0x60(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    14bb <MDWT+0x38b>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmp    %rcx,%rax
jge    1401 <MDWT+0x2d1>
cmpl   $0x1,-0x5c(%rbp)
jne    13c5 <MDWT+0x295>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   -0x50(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13eb <MDWT+0x2bb>
mov    0x10(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   -0x50(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13f0 <MDWT+0x2c0>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    137f <MDWT+0x24f>
mov    -0x48(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x78(%rbp),%r8d
mov    -0x38(%rbp),%r9
mov    -0x40(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <fpsconv@plt>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmp    %rcx,%rax
jge    14a8 <MDWT+0x378>
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   -0x50(%rbp),%rcx
movslq -0x70(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x74(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x74(%rbp)
imul   %edx,%ecx
add    -0x70(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1433 <MDWT+0x303>
jmp    14ad <MDWT+0x37d>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    136b <MDWT+0x23b>
cmpl   $0x1,-0xc(%rbp)
jle    15e3 <MDWT+0x4b3>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    15de <MDWT+0x4ae>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmp    %rcx,%rax
jge    1526 <MDWT+0x3f6>
mov    0x10(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    14e0 <MDWT+0x3b0>
mov    -0x48(%rbp),%rdi
mov    -0x60(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x78(%rbp),%r8d
mov    -0x38(%rbp),%r9
mov    -0x40(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <fpsconv@plt>
mov    -0x68(%rbp),%eax
mov    %eax,-0x70(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmp    %rcx,%rax
jge    15cb <MDWT+0x49b>
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
add    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    -0x70(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x70(%rbp)
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1558 <MDWT+0x428>
jmp    15d0 <MDWT+0x4a0>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14cc <MDWT+0x39c>
jmp    15e3 <MDWT+0x4b3>
jmp    15e8 <MDWT+0x4b8>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    130a <MDWT+0x1da>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MDWT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9d,0x74(%rsp)
mov    %r8d,%r14d
mov    %rcx,0x38(%rsp)
mov    %edx,%r13d
mov    %esi,%r12d
mov    %rdi,0x128(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0x18(%rsp)
cmp    %edx,%esi
mov    %edx,%ebp
cmovg  %esi,%ebp
lea    (%r14,%rbp,1),%edi
add    $0xffffffff,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebp,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%rbx
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rbx,%r8
mov    %r13d,%ecx
cmp    $0x1,%r13d
cmove  %r12d,%r13d
mov    %rax,%rbp
cmove  %ecx,%r12d
mov    %r12,0x78(%rsp)
mov    %r14,0x58(%rsp)
test   %r14d,%r14d
jle    1485 <MDWT+0x355>
mov    0x58(%rsp),%rcx
movslq %ecx,%r14
cmp    $0x4,%ecx
jae    1204 <MDWT+0xd4>
xor    %ecx,%ecx
mov    0x38(%rsp),%rax
jmp    135b <MDWT+0x22b>
lea    (%r8,%r14,8),%rcx
lea    0x0(,%r14,8),%rdi
add    %rbp,%rdi
mov    0x38(%rsp),%rax
lea    (%rax,%r14,8),%rbx
cmp    %rdi,%r8
mov    %r8,%rdx
setb   %r8b
cmp    %rcx,%rbp
setb   %r9b
mov    %rdx,%r11
cmp    %rbx,%rdx
setb   %dl
cmp    %rax,%rcx
seta   %sil
cmp    %rbx,%rbp
setb   %r10b
cmp    %rax,%rdi
seta   %dil
xor    %ecx,%ecx
test   %r9b,%r8b
jne    1358 <MDWT+0x228>
and    %sil,%dl
jne    1358 <MDWT+0x228>
and    %dil,%r10b
mov    %r11,%r8
jne    135b <MDWT+0x22b>
mov    %r14,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2112 <MDWT+0xfe2>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x8(%r14),%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x20(%rax,%rbx,8),%xmm0
movups 0x30(%rax,%rbx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r8,%rdx,8)
movups %xmm0,0x10(%r8,%rdx,8)
movups (%rax,%rdx,8),%xmm0
movups 0x10(%rax,%rdx,8),%xmm1
movups %xmm0,0x0(%rbp,%rdx,8)
movups %xmm1,0x10(%rbp,%rdx,8)
movups (%rax,%rbx,8),%xmm0
movups 0x10(%rax,%rbx,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,0x20(%r8,%rdx,8)
movups %xmm0,0x30(%r8,%rdx,8)
movups 0x20(%rax,%rdx,8),%xmm0
movups 0x30(%rax,%rdx,8),%xmm1
movups %xmm0,0x20(%rbp,%rdx,8)
movups %xmm1,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    12a0 <MDWT+0x170>
test   $0x1,%sil
je     134e <MDWT+0x21e>
mov    %rdx,%rsi
not    %rsi
add    %r14,%rsi
movups -0x18(%rax,%rsi,8),%xmm0
movups -0x8(%rax,%rsi,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r8,%rdx,8)
movups %xmm0,0x10(%r8,%rdx,8)
movups (%rax,%rdx,8),%xmm0
movups 0x10(%rax,%rdx,8),%xmm1
movups %xmm0,0x0(%rbp,%rdx,8)
movups %xmm1,0x10(%rbp,%rdx,8)
cmp    %r14,%rcx
jne    135b <MDWT+0x22b>
jmp    13da <MDWT+0x2aa>
mov    %r11,%r8
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r14b
je     1385 <MDWT+0x255>
lea    (%rdx,%r14,1),%rsi
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
or     $0x1,%rcx
add    %r14,%rdx
je     13da <MDWT+0x2aa>
mov    %r14,%rdx
sub    %rcx,%rdx
lea    (%rax,%rdx,8),%rdx
add    $0xfffffffffffffff8,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  -0x8(%rdx),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
add    $0xfffffffffffffff0,%rdx
cmp    %rcx,%r14
jne    13a0 <MDWT+0x270>
cmpl   $0x0,0x58(%rsp)
jle    1485 <MDWT+0x355>
add    $0xffffffffffffffff,%r14
mov    %r14,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x6,%r14
jae    1402 <MDWT+0x2d2>
xor    %eax,%eax
jmp    1452 <MDWT+0x322>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
movaps 0x1bf1(%rip),%xmm0
nop
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x10(%rbp,%rax,8),%xmm2
movsd  0x20(%rbp,%rax,8),%xmm3
movsd  0x30(%rbp,%rax,8),%xmm4
xorps  %xmm0,%xmm1
movlps %xmm1,0x0(%rbp,%rax,8)
xorps  %xmm0,%xmm2
movlps %xmm2,0x10(%rbp,%rax,8)
xorps  %xmm0,%xmm3
movlps %xmm3,0x20(%rbp,%rax,8)
xorps  %xmm0,%xmm4
movlps %xmm4,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffc,%rdx
jne    1410 <MDWT+0x2e0>
test   %rcx,%rcx
je     1485 <MDWT+0x355>
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
shl    $0x4,%rcx
xor    %edx,%edx
movaps 0x1b91(%rip),%xmm0
nop
movsd  (%rax,%rdx,1),%xmm1
xorps  %xmm0,%xmm1
movlps %xmm1,(%rax,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    1470 <MDWT+0x340>
cmpl   $0x0,0x74(%rsp)
mov    0x40(%rsp),%r9
mov    0x20(%rsp),%r11
jle    20d0 <MDWT+0xfa0>
mov    0x58(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x58(%rsp)
add    %r13d,%r13d
mov    0x78(%rsp),%rax
lea    (%rax,%rax,1),%ecx
mov    %rcx,0x68(%rsp)
movslq %eax,%rcx
mov    %rcx,0x50(%rsp)
mov    %rcx,%r10
shl    $0x4,%r10
mov    0x18(%rsp),%rax
lea    0x10(%rax),%rdx
mov    %rdx,0xf8(%rsp)
mov    %rcx,%rdx
shl    $0x5,%rdx
mov    %rdx,0x180(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0xf0(%rsp)
lea    0x70(%rax),%rcx
mov    %rcx,0x120(%rsp)
lea    0x10(%r15),%rcx
mov    %rcx,0x130(%rsp)
add    $0x30,%rax
mov    %rax,0x118(%rsp)
lea    0x8(%r9),%rax
mov    %rax,0x190(%rsp)
lea    0x8(%r11),%rax
mov    %rax,0x188(%rsp)
mov    $0x1,%esi
mov    %r8,0x110(%rsp)
mov    %rbp,0x108(%rsp)
mov    %r10,0x38(%rsp)
jmp    156c <MDWT+0x43c>
xchg   %ax,%ax
mov    0x148(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x74(%rsp),%ecx
mov    %eax,%esi
mov    0x2c(%rsp),%r13d
je     20d0 <MDWT+0xfa0>
mov    %r13d,%ebx
cmpl   $0x1,0x78(%rsp)
mov    %rsi,0x148(%rsp)
jne    1590 <MDWT+0x460>
mov    %ebx,%edx
shr    $0x1f,%edx
add    %ebx,%edx
sar    %edx
mov    $0x1,%eax
jmp    15bf <MDWT+0x48f>
xchg   %ax,%ax
mov    0x68(%rsp),%rcx
mov    %ecx,%eax
shr    $0x1f,%eax
add    %ecx,%eax
sar    %eax
lea    0x3(%rcx),%edx
test   %ecx,%ecx
cmovns %ecx,%edx
sar    $0x2,%edx
mov    %edx,0x4c(%rsp)
mov    %ebx,%edx
shr    $0x1f,%edx
add    %ebx,%edx
sar    %edx
cmp    $0x2,%ecx
jl     1a10 <MDWT+0x8e0>
cmpl   $0x1,0x78(%rsp)
sete   %r14b
lea    0x3(%rbx),%ecx
test   %ebx,%ebx
cmovns %ebx,%ecx
sar    $0x2,%ecx
mov    %edx,0x2c(%rsp)
movslq %edx,%rdx
movslq %ecx,%rdi
lea    (%rdi,%rdi,1),%rcx
mov    %rcx,0xd8(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x80(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xd0(%rsp)
cmp    $0x1,%esi
mov    %rax,0x68(%rsp)
mov    %eax,%eax
mov    %rax,0x88(%rsp)
lea    (%r9,%rdi,8),%rax
mov    %rax,0xc8(%rsp)
lea    (%r11,%rdi,8),%rax
mov    %rax,0xc0(%rsp)
mov    0x18(%rsp),%r12
cmove  0x128(%rsp),%r12
cmp    $0x4,%edi
setae  %al
and    %r14b,%al
mov    %al,0xe8(%rsp)
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xb0(%rsp)
add    %rdi,%rax
mov    %rax,0xa8(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x60(%rsp)
mov    0x50(%rsp),%rax
lea    (%r12,%rax,8),%r14
mov    0xf0(%rsp),%rax
mov    %rdi,0x30(%rsp)
imul   %rdi,%rax
mov    %rax,0xa0(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0xf8(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    %r12,0xb8(%rsp)
xor    %r13d,%r13d
mov    %rbx,0x90(%rsp)
jmp    1701 <MDWT+0x5d1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x8,%r14
add    $0x8,%r12
addq   $0x8,0x98(%rsp)
addq   $0x8,0x10(%rsp)
cmp    0x88(%rsp),%r13
mov    0x110(%rsp),%r8
mov    0x108(%rsp),%rbp
mov    0x90(%rsp),%rbx
je     19f0 <MDWT+0x8c0>
cmp    $0x2,%ebx
jl     177e <MDWT+0x64e>
cmpl   $0x1,0x2c(%rsp)
jne    1720 <MDWT+0x5f0>
xor    %eax,%eax
jmp    1755 <MDWT+0x625>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
xor    %eax,%eax
mov    0xd0(%rsp),%rdx
nopl   0x0(%rax)
movsd  (%r12,%rcx,1),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  (%r14,%rcx,1),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
add    %r10,%rcx
cmp    %rax,%rdx
jne    1730 <MDWT+0x600>
testb  $0x1,0x80(%rsp)
01
je     177e <MDWT+0x64e>
mov    %rax,%rcx
imul   0x50(%rsp),%rcx
add    %r13,%rcx
mov    0xb8(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
mov    %r11,(%rsp)
mov    %r15,%rdi
mov    0x2c(%rsp),%esi
mov    %r8,%rdx
mov    %rbp,%rcx
mov    0x58(%rsp),%r8
call   1050 <fpsconv@plt>
mov    0x38(%rsp),%r10
mov    0x20(%rsp),%r11
mov    0x40(%rsp),%r9
cmp    $0x4,%ebx
mov    0x30(%rsp),%rbp
jl     16c0 <MDWT+0x590>
cmpb   $0x0,0xe8(%rsp)
je     18e0 <MDWT+0x7b0>
mov    %r13,%rax
add    %rbp,%rax
mov    0xd8(%rsp),%rcx
add    %r13,%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
lea    (%rdx,%rcx,8),%rcx
lea    (%rdx,%r13,8),%rdi
mov    0xc8(%rsp),%rdx
cmp    %rdx,%rsi
setb   0xe0(%rsp)
cmp    %rcx,%r9
setb   %bl
mov    0xc0(%rsp),%r10
cmp    %r10,%rsi
setb   %al
cmp    %rcx,%r11
setb   %r8b
cmp    %rdx,%rdi
setb   %dl
cmp    %rsi,%r9
mov    %r11,%rbp
setb   %r11b
cmp    %r10,%rdi
setb   %cl
cmp    %rsi,%rbp
setb   %sil
test   %bl,0xe0(%rsp)
jne    19bf <MDWT+0x88f>
and    %r8b,%al
jne    19bf <MDWT+0x88f>
and    %r11b,%dl
mov    0x38(%rsp),%r10
jne    19d8 <MDWT+0x8a8>
mov    0x30(%rsp),%rbp
mov    %rbp,%rax
mov    $0x0,%edx
and    %sil,%cl
mov    0x20(%rsp),%r11
jne    18e5 <MDWT+0x7b5>
mov    0x98(%rsp),%rax
xor    %ecx,%ecx
mov    0x180(%rsp),%rdx
mov    0xb0(%rsp),%rsi
mov    0xa0(%rsp),%rdi
xchg   %ax,%ax
movups (%r9,%rcx,8),%xmm0
movups 0x10(%r9,%rcx,8),%xmm1
movups %xmm0,-0x10(%rax)
movups %xmm1,(%rax)
movups (%r11,%rcx,8),%xmm0
movups 0x10(%r11,%rcx,8),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x4,%rcx
add    %rdx,%rax
cmp    %rcx,%rsi
jne    1890 <MDWT+0x760>
mov    0xa8(%rsp),%rax
mov    %rsi,%rdx
cmp    %rbp,%rsi
je     16c0 <MDWT+0x590>
jmp    18e5 <MDWT+0x7b5>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
xor    %edx,%edx
test   $0x1,%bpl
jne    18f0 <MDWT+0x7c0>
mov    %rdx,%rcx
jmp    192f <MDWT+0x7ff>
movsd  (%r9,%rdx,8),%xmm0
mov    %rdx,%rcx
mov    0x50(%rsp),%rbx
imul   %rbx,%rcx
add    %r13,%rcx
mov    0x18(%rsp),%rdi
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%r11,%rdx,8),%xmm0
lea    0x1(%rax),%rsi
imul   %rbx,%rax
add    %r13,%rax
movsd  %xmm0,(%rdi,%rax,8)
mov    %rdx,%rcx
or     $0x1,%rcx
mov    %rsi,%rax
not    %rdx
cmp    0x60(%rsp),%rdx
je     16c0 <MDWT+0x590>
mov    0x50(%rsp),%r8
mov    %r8,%rdx
imul   %rax,%rdx
add    %r13,%rdx
add    $0x1,%rax
mov    0xf0(%rsp),%rbx
imul   %rbx,%rax
mov    0x10(%rsp),%rdi
add    %rdi,%rax
lea    0x1(%rcx),%rsi
imul   %rbx,%rsi
add    %rdi,%rsi
mov    %r8,%rdi
imul   %rcx,%rdi
add    %r13,%rdi
mov    0x18(%rsp),%rbx
xchg   %ax,%ax
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
movsd  (%r11,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%r9,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,1)
movsd  0x8(%r11,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rax,1)
add    $0x2,%rcx
add    %r10,%rbx
cmp    %rcx,%rbp
jne    1980 <MDWT+0x850>
jmp    16c0 <MDWT+0x590>
mov    0x30(%rsp),%rbp
mov    %rbp,%rax
xor    %edx,%edx
mov    0x20(%rsp),%r11
mov    0x38(%rsp),%r10
jmp    18e5 <MDWT+0x7b5>
mov    0x30(%rsp),%rbp
mov    %rbp,%rax
xor    %edx,%edx
mov    0x20(%rsp),%r11
jmp    18e5 <MDWT+0x7b5>
nopl   0x0(%rax)
mov    $0x1,%al
mov    %eax,0x80(%rsp)
cmpl   $0x2,0x78(%rsp)
jge    1a2f <MDWT+0x8ff>
jmp    1550 <MDWT+0x420>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,0x2c(%rsp)
movl   $0x0,0x80(%rsp)
mov    %rax,0x68(%rsp)
cmpl   $0x2,0x78(%rsp)
jl     1550 <MDWT+0x420>
cmp    $0x2,%ebx
jl     1550 <MDWT+0x420>
mov    %r8,%rbx
mov    0x68(%rsp),%r8
movslq %r8d,%rdi
movslq 0x4c(%rsp),%rsi
mov    0x2c(%rsp),%eax
mov    %rax,0xe0(%rsp)
lea    (%rsi,%rsi,1),%rax
mov    %rax,0xc0(%rsp)
lea    -0x4(%rdi),%rax
mov    %rax,0x160(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
lea    -0x4(%rsi),%rcx
mov    %rcx,0xa0(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdi,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x158(%rsp)
movabs $0x7ffffffffffffffe,%r10
ff ff 7f
lea    -0x2(%r10),%rcx
and    %rax,%rcx
mov    %rcx,0x138(%rsp)
mov    %eax,%r14d
and    $0x3,%r14d
and    $0x3,%r8d
mov    %r8,0xc8(%rsp)
mov    %rbx,%r8
mov    %rsi,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rdx,%rax
mov    %rdx,0x178(%rsp)
and    %r10,%rdx
mov    %rdx,0x140(%rsp)
mov    0x50(%rsp),%rax
mov    %rsi,%rdx
neg    %rdx
mov    %rdx,0xd0(%rsp)
mov    %r14,0x150(%rsp)
shl    $0x5,%r14
mov    %r14,0x100(%rsp)
lea    (%r9,%rsi,8),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%r11,%rsi,8),%rdx
mov    %rdx,0xb0(%rsp)
lea    (%r15,%rdi,8),%rdx
mov    %rdx,0xa8(%rsp)
mov    %rcx,0x170(%rsp)
add    %rsi,%rcx
mov    %rcx,0x168(%rsp)
mov    0x118(%rsp),%rcx
mov    %rsi,0x10(%rsp)
lea    (%rcx,%rsi,8),%rcx
mov    $0x1,%edx
mov    %rdx,0x88(%rsp)
mov    0x18(%rsp),%r14
mov    0xf8(%rsp),%r12
mov    0x120(%rsp),%r13
xor    %edx,%edx
mov    %rdi,0xe8(%rsp)
jmp    1bf2 <MDWT+0xac2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x98(%rsp),%rdx
add    $0x1,%rdx
mov    0xf0(%rsp),%rax
add    %rax,%r13
add    %rax,%r12
add    %rax,%r14
mov    0x30(%rsp),%rcx
add    %rax,%rcx
mov    0x50(%rsp),%rax
add    %rax,0x88(%rsp)
cmp    0xe0(%rsp),%rdx
mov    0x40(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x110(%rsp),%r8
mov    0x108(%rsp),%rbp
mov    0xe8(%rsp),%rdi
je     1550 <MDWT+0x420>
mov    %rcx,0x30(%rsp)
mov    %rdx,0x98(%rsp)
mov    %rdx,%rbx
imul   %rax,%rbx
mov    0x18(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rax,0x90(%rsp)
cmpb   $0x0,0x80(%rsp)
mov    0x68(%rsp),%rsi
je     1de0 <MDWT+0xcb0>
cmp    $0x4,%esi
jb     1c5b <MDWT+0xb2b>
lea    (%rbx,%rdi,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
cmp    %rax,%r15
jae    1ce4 <MDWT+0xbb4>
mov    0x90(%rsp),%rax
cmp    0xa8(%rsp),%rax
jae    1ce4 <MDWT+0xbb4>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    0xc8(%rsp),%rdx
test   %rdx,%rdx
je     1c96 <MDWT+0xb66>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1c80 <MDWT+0xb50>
cmp    $0x3,%rcx
jb     1de0 <MDWT+0xcb0>
movsd  -0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1ca0 <MDWT+0xb70>
jmp    1de0 <MDWT+0xcb0>
mov    %rbx,%r10
cmpq   $0xc,0x160(%rsp)
jae    1cfe <MDWT+0xbce>
xor    %eax,%eax
mov    0x100(%rsp),%rbx
jmp    1d79 <MDWT+0xc49>
mov    0x138(%rsp),%rcx
xor    %eax,%eax
mov    0x100(%rsp),%rbx
movups -0x70(%r13,%rax,8),%xmm0
movups -0x60(%r13,%rax,8),%xmm1
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
movups -0x50(%r13,%rax,8),%xmm0
movups -0x40(%r13,%rax,8),%xmm1
movups %xmm0,0x20(%r15,%rax,8)
movups %xmm1,0x30(%r15,%rax,8)
movups -0x30(%r13,%rax,8),%xmm0
movups -0x20(%r13,%rax,8),%xmm1
movups %xmm0,0x40(%r15,%rax,8)
movups %xmm1,0x50(%r15,%rax,8)
movups -0x10(%r13,%rax,8),%xmm0
movups 0x0(%r13,%rax,8),%xmm1
movups %xmm0,0x60(%r15,%rax,8)
movups %xmm1,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1d10 <MDWT+0xbe0>
cmpq   $0x0,0x150(%rsp)
je     1dbb <MDWT+0xc8b>
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%r12,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbx
jne    1da0 <MDWT+0xc70>
mov    0x158(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
mov    %r10,%rbx
jne    1c5d <MDWT+0xb2d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,(%rsp)
mov    %r15,%rdi
mov    %r8,%rdx
mov    %rbp,%rcx
mov    0x58(%rsp),%r8
call   1050 <fpsconv@plt>
mov    0x38(%rsp),%r10
cmpl   $0x0,0x4c(%rsp)
jle    1b90 <MDWT+0xa60>
cmpl   $0x4,0x4c(%rsp)
jae    1e30 <MDWT+0xd00>
mov    0x10(%rsp),%rax
xor    %ecx,%ecx
testb  $0x1,0x10(%rsp)
jne    1f10 <MDWT+0xde0>
mov    %rcx,%rsi
jmp    1f48 <MDWT+0xe18>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
add    %rbx,%rax
mov    0xc0(%rsp),%rcx
mov    %rbx,0x60(%rsp)
add    %rbx,%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
lea    (%rdx,%rcx,8),%rcx
mov    0xb8(%rsp),%rdi
cmp    %rdi,%rsi
setb   0xd8(%rsp)
mov    0x40(%rsp),%rdx
cmp    %rcx,%rdx
setb   %r11b
mov    0xb0(%rsp),%rbx
cmp    %rbx,%rsi
setb   %al
mov    0x20(%rsp),%rbp
cmp    %rcx,%rbp
setb   %r8b
mov    0x90(%rsp),%r9
cmp    %rdi,%r9
setb   %cl
cmp    %rsi,%rdx
setb   %dil
cmp    %rbx,%r9
setb   %dl
cmp    %rsi,%rbp
setb   %sil
test   %r11b,0xd8(%rsp)
jne    20bf <MDWT+0xf8f>
and    %r8b,%al
jne    20bf <MDWT+0xf8f>
and    %dil,%cl
mov    0x60(%rsp),%rbx
jne    1e0e <MDWT+0xcde>
mov    0x10(%rsp),%rax
mov    $0x0,%ecx
and    %sil,%dl
jne    1e15 <MDWT+0xce5>
cmpq   $0x4,0xa0(%rsp)
jae    1fda <MDWT+0xeaa>
xor    %eax,%eax
mov    0x40(%rsp),%rdx
mov    0x20(%rsp),%rdi
jmp    205a <MDWT+0xf2a>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
lea    (%rcx,%rbx,1),%rdx
mov    0x18(%rsp),%rsi
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x20(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
lea    0x1(%rax),%rdx
add    %rbx,%rax
movsd  %xmm0,(%rsi,%rax,8)
mov    %rcx,%rsi
or     $0x1,%rsi
mov    %rdx,%rax
not    %rcx
cmp    0xd0(%rsp),%rcx
je     1b90 <MDWT+0xa60>
mov    0x190(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    0x88(%rsp),%rbp
add    %rbp,%rax
mov    0x18(%rsp),%rbx
lea    (%rbx,%rax,8),%rax
mov    0x10(%rsp),%rdx
sub    %rsi,%rdx
mov    0x188(%rsp),%rdi
lea    (%rdi,%rsi,8),%rdi
add    %rbp,%rsi
lea    (%rbx,%rsi,8),%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rbx,8)
movsd  -0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdx
jne    1fa0 <MDWT+0xe70>
jmp    1b90 <MDWT+0xa60>
mov    0x140(%rsp),%rcx
xor    %eax,%eax
mov    0x40(%rsp),%rdx
mov    0x20(%rsp),%rdi
mov    0x30(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
movups %xmm0,(%r14,%rax,8)
movups %xmm1,0x10(%r14,%rax,8)
movups (%rdi,%rax,8),%xmm0
movups 0x10(%rdi,%rax,8),%xmm1
movups %xmm0,-0x30(%rsi,%rax,8)
movups %xmm1,-0x20(%rsi,%rax,8)
movups 0x20(%rdx,%rax,8),%xmm0
movups 0x30(%rdx,%rax,8),%xmm1
movups %xmm0,0x20(%r14,%rax,8)
movups %xmm1,0x30(%r14,%rax,8)
movups 0x20(%rdi,%rax,8),%xmm0
movups 0x30(%rdi,%rax,8),%xmm1
movups %xmm0,-0x10(%rsi,%rax,8)
movups %xmm1,(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2000 <MDWT+0xed0>
testb  $0x1,0x178(%rsp)
01
je     209c <MDWT+0xf6c>
mov    0x10(%rsp),%rcx
add    %rax,%rcx
movups (%rdx,%rax,8),%xmm0
movups 0x10(%rdx,%rax,8),%xmm1
lea    (%rax,%rbx,1),%rdx
mov    0x18(%rsp),%rsi
movups %xmm0,(%rsi,%rdx,8)
movups %xmm1,0x10(%rsi,%rdx,8)
movups (%rdi,%rax,8),%xmm0
movups 0x10(%rdi,%rax,8),%xmm1
add    %rbx,%rcx
movups %xmm0,(%rsi,%rcx,8)
movups %xmm1,0x10(%rsi,%rcx,8)
mov    0x168(%rsp),%rax
mov    0x170(%rsp),%rdx
mov    %rdx,%rcx
cmp    0x10(%rsp),%rdx
je     1b90 <MDWT+0xa60>
jmp    1e15 <MDWT+0xce5>
mov    0x10(%rsp),%rax
xor    %ecx,%ecx
mov    0x60(%rsp),%rbx
jmp    1e15 <MDWT+0xce5>
mov    %r15,%rdi
mov    %r9,%r14
mov    %r11,%rbx
mov    %r8,%r15
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %edx,%edx
test   $0x1,%sil
jne    1315 <MDWT+0x1e5>
jmp    134e <MDWT+0x21e>

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

LLVM IR (-O2):
define void @MDWT(double* nocapture %0, i32 %1, i32 %2, double* nocapture %3, i32 %4, i32 %5, double* nocapture %6) {
%8 = icmp sgt i32 %1, %2
%9 = select i1 %8, i32 %1, i32 %2
%10 = add i32 %4, -1
%11 = add i32 %10, %9
%12 = tail call i64 @calloc(i32 %11, i32 8)
%13 = inttoptr i64 %12 to double*
%14 = inttoptr i64 %12 to i8*
%15 = tail call i64 @calloc(i32 %9, i32 8)
%16 = inttoptr i64 %15 to double*
%17 = inttoptr i64 %15 to i8*
%18 = tail call i64 @calloc(i32 %9, i32 8)
%19 = inttoptr i64 %18 to double*
%20 = inttoptr i64 %18 to i8*
%21 = tail call i64 @calloc(i32 %4, i32 8)
%22 = inttoptr i64 %21 to double*
%23 = inttoptr i64 %21 to i8*
%24 = tail call i64 @calloc(i32 %4, i32 8)
%25 = inttoptr i64 %24 to double*
%26 = inttoptr i64 %24 to i8*
%27 = icmp eq i32 %2, 1
%28 = select i1 %27, i32 %1, i32 %2
%29 = select i1 %27, i32 1, i32 %1
%30 = sext i32 %4 to i64
%31 = icmp sgt i32 %4, 0
br i1 %31, label %32, label %234
32: ; preds = %7
%33 = icmp ult i32 %4, 4
br i1 %33, label %152, label %34
34: ; preds = %32
%35 = getelementptr double, double* %22, i64 %30
%36 = bitcast double* %35 to i8*
%37 = getelementptr double, double* %25, i64 %30
%38 = bitcast double* %37 to i8*
%39 = getelementptr double, double* %3, i64 %30
%40 = bitcast double* %39 to i8*
%41 = icmp ult i8* %23, %38
%42 = icmp ult i8* %26, %36
%43 = and i1 %41, %42
%44 = icmp ult i8* %23, %40
%45 = icmp ugt double* %35, %3
%46 = and i1 %44, %45
%47 = or i1 %43, %46
%48 = icmp ult i8* %26, %40
%49 = icmp ugt double* %37, %3
%50 = and i1 %48, %49
%51 = or i1 %47, %50
br i1 %51, label %152, label %52
52: ; preds = %34
%53 = and i64 %30, -4
%54 = add nsw i64 %53, -4
%55 = lshr exact i64 %54, 2
%56 = add nuw nsw i64 %55, 1
%57 = and i64 %56, 1
%58 = icmp eq i64 %54, 0
br i1 %58, label %120, label %59
59: ; preds = %52
%60 = and i64 %56, 9223372036854775806
br label %61
61: ; preds = %61, %59
%62 = phi i64 [ 0, %59 ], [ %117, %61 ]
%63 = phi i64 [ 0, %59 ], [ %118, %61 ]
%64 = xor i64 %62, -1
%65 = add nsw i64 %64, %30
%66 = getelementptr inbounds double, double* %3, i64 %65
%67 = getelementptr inbounds double, double* %66, i64 -1
%68 = bitcast double* %67 to <2 x double>*
%69 = load <2 x double>, <2 x double>* %68
%70 = shufflevector <2 x double> %69, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%71 = getelementptr inbounds double, double* %66, i64 -2
%72 = getelementptr inbounds double, double* %71, i64 -1
%73 = bitcast double* %72 to <2 x double>*
%74 = load <2 x double>, <2 x double>* %73
%75 = shufflevector <2 x double> %74, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%76 = getelementptr inbounds double, double* %22, i64 %62
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %70, <2 x double>* %77
%78 = getelementptr inbounds double, double* %76, i64 2
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %75, <2 x double>* %79
%80 = getelementptr inbounds double, double* %3, i64 %62
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = getelementptr inbounds double, double* %80, i64 2
%84 = bitcast double* %83 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = getelementptr inbounds double, double* %25, i64 %62
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %82, <2 x double>* %87
%88 = getelementptr inbounds double, double* %86, i64 2
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %85, <2 x double>* %89
%90 = or i64 %62, 4
%91 = sub nuw nsw i64 -5, %62
%92 = add nsw i64 %91, %30
%93 = getelementptr inbounds double, double* %3, i64 %92
%94 = getelementptr inbounds double, double* %93, i64 -1
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = shufflevector <2 x double> %96, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%98 = getelementptr inbounds double, double* %93, i64 -2
%99 = getelementptr inbounds double, double* %98, i64 -1
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%103 = getelementptr inbounds double, double* %22, i64 %90
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> %97, <2 x double>* %104
%105 = getelementptr inbounds double, double* %103, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %102, <2 x double>* %106
%107 = getelementptr inbounds double, double* %3, i64 %90
%108 = bitcast double* %107 to <2 x double>*
%109 = load <2 x double>, <2 x double>* %108
%110 = getelementptr inbounds double, double* %107, i64 2
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = getelementptr inbounds double, double* %25, i64 %90
%114 = bitcast double* %113 to <2 x double>*
store <2 x double> %109, <2 x double>* %114
%115 = getelementptr inbounds double, double* %113, i64 2
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %112, <2 x double>* %116
%117 = add nuw i64 %62, 8
%118 = add i64 %63, 2
%119 = icmp eq i64 %118, %60
br i1 %119, label %120, label %61
120: ; preds = %61, %52
%121 = phi i64 [ 0, %52 ], [ %117, %61 ]
%122 = icmp eq i64 %57, 0
br i1 %122, label %150, label %123
123: ; preds = %120
%124 = xor i64 %121, -1
%125 = add nsw i64 %124, %30
%126 = getelementptr inbounds double, double* %3, i64 %125
%127 = getelementptr inbounds double, double* %126, i64 -1
%128 = bitcast double* %127 to <2 x double>*
%129 = load <2 x double>, <2 x double>* %128
%130 = shufflevector <2 x double> %129, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%131 = getelementptr inbounds double, double* %126, i64 -2
%132 = getelementptr inbounds double, double* %131, i64 -1
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = shufflevector <2 x double> %134, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%136 = getelementptr inbounds double, double* %22, i64 %121
%137 = bitcast double* %136 to <2 x double>*
store <2 x double> %130, <2 x double>* %137
%138 = getelementptr inbounds double, double* %136, i64 2
%139 = bitcast double* %138 to <2 x double>*
store <2 x double> %135, <2 x double>* %139
%140 = getelementptr inbounds double, double* %3, i64 %121
%141 = bitcast double* %140 to <2 x double>*
%142 = load <2 x double>, <2 x double>* %141
%143 = getelementptr inbounds double, double* %140, i64 2
%144 = bitcast double* %143 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr inbounds double, double* %25, i64 %121
%147 = bitcast double* %146 to <2 x double>*
store <2 x double> %142, <2 x double>* %147
%148 = getelementptr inbounds double, double* %146, i64 2
%149 = bitcast double* %148 to <2 x double>*
store <2 x double> %145, <2 x double>* %149
br label %150
150: ; preds = %120, %123
%151 = icmp eq i64 %53, %30
br i1 %151, label %171, label %152
152: ; preds = %34, %32, %150
%153 = phi i64 [ 0, %34 ], [ 0, %32 ], [ %53, %150 ]
%154 = xor i64 %153, -1
%155 = and i64 %30, 1
%156 = icmp eq i64 %155, 0
br i1 %156, label %167, label %157
157: ; preds = %152
%158 = xor i64 %153, -1
%159 = add nsw i64 %158, %30
%160 = getelementptr inbounds double, double* %3, i64 %159
%161 = load double, double* %160
%162 = getelementptr inbounds double, double* %22, i64 %153
store double %161, double* %162
%163 = getelementptr inbounds double, double* %3, i64 %153
%164 = load double, double* %163
%165 = getelementptr inbounds double, double* %25, i64 %153
store double %164, double* %165
%166 = or i64 %153, 1
br label %167
167: ; preds = %157, %152
%168 = phi i64 [ %153, %152 ], [ %166, %157 ]
%169 = sub nsw i64 0, %30
%170 = icmp eq i64 %154, %169
br i1 %170, label %171, label %180
171: ; preds = %167, %180, %150
br i1 %31, label %172, label %234
172: ; preds = %171
%173 = add nsw i64 %30, -1
%174 = lshr i64 %173, 1
%175 = add nuw i64 %174, 1
%176 = and i64 %175, 3
%177 = icmp ult i64 %173, 6
br i1 %177, label %222, label %178
178: ; preds = %172
%179 = and i64 %175, -4
br label %201
180: ; preds = %167, %180
%181 = phi i64 [ %199, %180 ], [ %168, %167 ]
%182 = xor i64 %181, -1
%183 = add nsw i64 %182, %30
%184 = getelementptr inbounds double, double* %3, i64 %183
%185 = load double, double* %184
%186 = getelementptr inbounds double, double* %22, i64 %181
store double %185, double* %186
%187 = getelementptr inbounds double, double* %3, i64 %181
%188 = load double, double* %187
%189 = getelementptr inbounds double, double* %25, i64 %181
store double %188, double* %189
%190 = add nuw nsw i64 %181, 1
%191 = sub i64 -2, %181
%192 = add nsw i64 %191, %30
%193 = getelementptr inbounds double, double* %3, i64 %192
%194 = load double, double* %193
%195 = getelementptr inbounds double, double* %22, i64 %190
store double %194, double* %195
%196 = getelementptr inbounds double, double* %3, i64 %190
%197 = load double, double* %196
%198 = getelementptr inbounds double, double* %25, i64 %190
store double %197, double* %198
%199 = add nuw nsw i64 %181, 2
%200 = icmp eq i64 %199, %30
br i1 %200, label %171, label %180
201: ; preds = %201, %178
%202 = phi i64 [ 0, %178 ], [ %219, %201 ]
%203 = phi i64 [ 0, %178 ], [ %220, %201 ]
%204 = getelementptr inbounds double, double* %25, i64 %202
%205 = load double, double* %204
%206 = fneg double %205
store double %206, double* %204
%207 = or i64 %202, 2
%208 = getelementptr inbounds double, double* %25, i64 %207
%209 = load double, double* %208
%210 = fneg double %209
store double %210, double* %208
%211 = or i64 %202, 4
%212 = getelementptr inbounds double, double* %25, i64 %211
%213 = load double, double* %212
%214 = fneg double %213
store double %214, double* %212
%215 = or i64 %202, 6
%216 = getelementptr inbounds double, double* %25, i64 %215
%217 = load double, double* %216
%218 = fneg double %217
store double %218, double* %216
%219 = add nuw nsw i64 %202, 8
%220 = add i64 %203, 4
%221 = icmp eq i64 %220, %179
br i1 %221, label %222, label %201
222: ; preds = %201, %172
%223 = phi i64 [ 0, %172 ], [ %219, %201 ]
%224 = icmp eq i64 %176, 0
br i1 %224, label %234, label %225
225: ; preds = %222, %225
%226 = phi i64 [ %231, %225 ], [ %223, %222 ]
%227 = phi i64 [ %232, %225 ], [ 0, %222 ]
%228 = getelementptr inbounds double, double* %25, i64 %226
%229 = load double, double* %228
%230 = fneg double %229
store double %230, double* %228
%231 = add nuw nsw i64 %226, 2
%232 = add i64 %227, 1
%233 = icmp eq i64 %232, %176
br i1 %233, label %234, label %225
234: ; preds = %222, %225, %7, %171
%235 = icmp slt i32 %5, 1
br i1 %235, label %747, label %236
236: ; preds = %234
%237 = shl nsw i32 %28, 1
%238 = shl nsw i32 %29, 1
%239 = icmp eq i32 %29, 1
%240 = sext i32 %29 to i64
%241 = icmp sgt i32 %29, 1
%242 = icmp eq i32 %29, 1
br label %243
243: ; preds = %236, %744
%244 = phi i32 [ undef, %236 ], [ %423, %744 ]
%245 = phi i32 [ %237, %236 ], [ %422, %744 ]
%246 = phi i32 [ %238, %236 ], [ %424, %744 ]
%247 = phi i32 [ 1, %236 ], [ %745, %744 ]
br i1 %239, label %248, label %250
248: ; preds = %243
%249 = sdiv i32 %245, 2
br label %255
250: ; preds = %243
%251 = sdiv i32 %246, 2
%252 = sdiv i32 %246, 4
%253 = sdiv i32 %245, 2
%254 = icmp sgt i32 %246, 1
br i1 %254, label %255, label %420
255: ; preds = %248, %250
%256 = phi i32 [ %249, %248 ], [ %253, %250 ]
%257 = phi i32 [ %244, %248 ], [ %252, %250 ]
%258 = phi i32 [ 1, %248 ], [ %251, %250 ]
%259 = sdiv i32 %245, 4
%260 = sext i32 %256 to i64
%261 = icmp sgt i32 %245, 1
%262 = icmp eq i32 %247, 1
%263 = sext i32 %259 to i64
%264 = icmp sgt i32 %245, 3
%265 = zext i32 %258 to i64
%266 = shl nsw i64 %263, 1
%267 = getelementptr double, double* %16, i64 %263
%268 = getelementptr double, double* %19, i64 %263
%269 = and i64 %260, 1
%270 = icmp eq i32 %256, 1
%271 = and i64 %260, -2
%272 = select i1 %262, double* %0, double* %6
%273 = select i1 %262, double* %0, double* %6
%274 = icmp eq i64 %269, 0
%275 = select i1 %262, double* %0, double* %6
%276 = icmp ugt i32 %259, 3
%277 = and i1 %276, %242
%278 = and i64 %263, -4
%279 = add nsw i64 %278, %263
%280 = icmp eq i64 %278, %263
%281 = and i64 %263, 1
%282 = icmp eq i64 %281, 0
%283 = sub nsw i64 0, %263
br label %284
284: ; preds = %255, %417
%285 = phi i64 [ 0, %255 ], [ %418, %417 ]
%286 = add i64 %285, %263
%287 = getelementptr double, double* %6, i64 %286
%288 = bitcast double* %287 to i8*
%289 = add i64 %266, %285
%290 = getelementptr double, double* %6, i64 %289
%291 = bitcast double* %290 to i8*
%292 = getelementptr double, double* %6, i64 %285
br i1 %261, label %293, label %319
293: ; preds = %284
br i1 %270, label %311, label %294
294: ; preds = %293, %294
%295 = phi i64 [ %308, %294 ], [ 0, %293 ]
%296 = phi i64 [ %309, %294 ], [ 0, %293 ]
%297 = mul nsw i64 %295, %240
%298 = add nsw i64 %297, %285
%299 = getelementptr inbounds double, double* %272, i64 %298
%300 = load double, double* %299
%301 = getelementptr inbounds double, double* %13, i64 %295
store double %300, double* %301
%302 = or i64 %295, 1
%303 = mul nsw i64 %302, %240
%304 = add nsw i64 %303, %285
%305 = getelementptr inbounds double, double* %273, i64 %304
%306 = load double, double* %305
%307 = getelementptr inbounds double, double* %13, i64 %302
store double %306, double* %307
%308 = add nuw nsw i64 %295, 2
%309 = add i64 %296, 2
%310 = icmp eq i64 %309, %271
br i1 %310, label %311, label %294
311: ; preds = %294, %293
%312 = phi i64 [ 0, %293 ], [ %308, %294 ]
br i1 %274, label %319, label %313
313: ; preds = %311
%314 = mul nsw i64 %312, %240
%315 = add nsw i64 %314, %285
%316 = getelementptr inbounds double, double* %275, i64 %315
%317 = load double, double* %316
%318 = getelementptr inbounds double, double* %13, i64 %312
store double %317, double* %318
br label %319
319: ; preds = %313, %311, %284
%320 = tail call i32 @fpsconv(double* %13, i32 %256, double* %22, double* %25, i32 %10, double* %16, double* %19)
br i1 %264, label %321, label %417
321: ; preds = %319
br i1 %277, label %322, label %368
322: ; preds = %321
%323 = icmp ult double* %287, %267
%324 = icmp ult i8* %17, %291
%325 = and i1 %323, %324
%326 = icmp ult double* %287, %268
%327 = icmp ult i8* %20, %291
%328 = and i1 %326, %327
%329 = or i1 %325, %328
%330 = icmp ult double* %292, %267
%331 = icmp ult i8* %17, %288
%332 = and i1 %330, %331
%333 = or i1 %329, %332
%334 = icmp ult double* %292, %268
%335 = icmp ult i8* %20, %288
%336 = and i1 %334, %335
%337 = or i1 %333, %336
br i1 %337, label %368, label %338
338: ; preds = %322, %338
%339 = phi i64 [ %365, %338 ], [ 0, %322 ]
%340 = add i64 %339, %263
%341 = getelementptr inbounds double, double* %16, i64 %339
%342 = bitcast double* %341 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = getelementptr inbounds double, double* %341, i64 2
%345 = bitcast double* %344 to <2 x double>*
%346 = load <2 x double>, <2 x double>* %345
%347 = mul nsw i64 %339, %240
%348 = add nsw i64 %347, %285
%349 = getelementptr inbounds double, double* %6, i64 %348
%350 = bitcast double* %349 to <2 x double>*
store <2 x double> %343, <2 x double>* %350
%351 = getelementptr inbounds double, double* %349, i64 2
%352 = bitcast double* %351 to <2 x double>*
store <2 x double> %346, <2 x double>* %352
%353 = getelementptr inbounds double, double* %19, i64 %339
%354 = bitcast double* %353 to <2 x double>*
%355 = load <2 x double>, <2 x double>* %354
%356 = getelementptr inbounds double, double* %353, i64 2
%357 = bitcast double* %356 to <2 x double>*
%358 = load <2 x double>, <2 x double>* %357
%359 = mul nsw i64 %340, %240
%360 = add nsw i64 %359, %285
%361 = getelementptr inbounds double, double* %6, i64 %360
%362 = bitcast double* %361 to <2 x double>*
store <2 x double> %355, <2 x double>* %362
%363 = getelementptr inbounds double, double* %361, i64 2
%364 = bitcast double* %363 to <2 x double>*
store <2 x double> %358, <2 x double>* %364
%365 = add nuw i64 %339, 4
%366 = icmp eq i64 %365, %278
br i1 %366, label %367, label %338
367: ; preds = %338
br i1 %280, label %417, label %368
368: ; preds = %322, %321, %367
%369 = phi i64 [ %263, %322 ], [ %263, %321 ], [ %279, %367 ]
%370 = phi i64 [ 0, %322 ], [ 0, %321 ], [ %278, %367 ]
%371 = xor i64 %370, -1
br i1 %282, label %385, label %372
372: ; preds = %368
%373 = getelementptr inbounds double, double* %16, i64 %370
%374 = load double, double* %373
%375 = mul nsw i64 %370, %240
%376 = add nsw i64 %375, %285
%377 = getelementptr inbounds double, double* %6, i64 %376
store double %374, double* %377
%378 = getelementptr inbounds double, double* %19, i64 %370
%379 = load double, double* %378
%380 = add nsw i64 %369, 1
%381 = mul nsw i64 %369, %240
%382 = add nsw i64 %381, %285
%383 = getelementptr inbounds double, double* %6, i64 %382
store double %379, double* %383
%384 = or i64 %370, 1
br label %385
385: ; preds = %372, %368
%386 = phi i64 [ %369, %368 ], [ %380, %372 ]
%387 = phi i64 [ %370, %368 ], [ %384, %372 ]
%388 = icmp eq i64 %371, %283
br i1 %388, label %417, label %389
389: ; preds = %385, %389
%390 = phi i64 [ %411, %389 ], [ %386, %385 ]
%391 = phi i64 [ %415, %389 ], [ %387, %385 ]
%392 = getelementptr inbounds double, double* %16, i64 %391
%393 = load double, double* %392
%394 = mul nsw i64 %391, %240
%395 = add nsw i64 %394, %285
%396 = getelementptr inbounds double, double* %6, i64 %395
store double %393, double* %396
%397 = getelementptr inbounds double, double* %19, i64 %391
%398 = load double, double* %397
%399 = add nsw i64 %390, 1
%400 = mul nsw i64 %390, %240
%401 = add nsw i64 %400, %285
%402 = getelementptr inbounds double, double* %6, i64 %401
store double %398, double* %402
%403 = add nuw nsw i64 %391, 1
%404 = getelementptr inbounds double, double* %16, i64 %403
%405 = load double, double* %404
%406 = mul nsw i64 %403, %240
%407 = add nsw i64 %406, %285
%408 = getelementptr inbounds double, double* %6, i64 %407
store double %405, double* %408
%409 = getelementptr inbounds double, double* %19, i64 %403
%410 = load double, double* %409
%411 = add nsw i64 %390, 2
%412 = mul nsw i64 %399, %240
%413 = add nsw i64 %412, %285
%414 = getelementptr inbounds double, double* %6, i64 %413
store double %410, double* %414
%415 = add nuw nsw i64 %391, 2
%416 = icmp eq i64 %415, %263
br i1 %416, label %417, label %389
417: ; preds = %385, %389, %367, %319
%418 = add nuw nsw i64 %285, 1
%419 = icmp eq i64 %418, %265
br i1 %419, label %420, label %284
420: ; preds = %417, %250
%421 = phi i1 [ false, %250 ], [ true, %417 ]
%422 = phi i32 [ %253, %250 ], [ %256, %417 ]
%423 = phi i32 [ %252, %250 ], [ %257, %417 ]
%424 = phi i32 [ %251, %250 ], [ %258, %417 ]
%425 = icmp sgt i32 %245, 1
%426 = select i1 %241, i1 %425, i1 false
br i1 %426, label %427, label %744
427: ; preds = %420
%428 = sext i32 %424 to i64
%429 = sext i32 %423 to i64
%430 = icmp sgt i32 %423, 0
%431 = zext i32 %422 to i64
%432 = shl nsw i64 %429, 1
%433 = getelementptr double, double* %16, i64 %429
%434 = getelementptr double, double* %19, i64 %429
%435 = getelementptr double, double* %13, i64 %428
%436 = add nsw i64 %428, -4
%437 = lshr i64 %436, 2
%438 = add nuw nsw i64 %437, 1
%439 = add nsw i64 %429, -4
%440 = lshr i64 %439, 2
%441 = add nuw nsw i64 %440, 1
%442 = icmp ult i32 %424, 4
%443 = and i64 %428, -4
%444 = and i64 %438, 3
%445 = icmp ult i64 %436, 12
%446 = and i64 %438, 9223372036854775804
%447 = icmp eq i64 %444, 0
%448 = icmp eq i64 %443, %428
%449 = and i64 %428, 3
%450 = icmp eq i64 %449, 0
%451 = icmp ult i32 %423, 4
%452 = and i64 %429, -4
%453 = add nsw i64 %452, %429
%454 = and i64 %441, 1
%455 = icmp ult i64 %439, 4
%456 = and i64 %441, 9223372036854775806
%457 = icmp eq i64 %454, 0
%458 = icmp eq i64 %452, %429
%459 = and i64 %429, 1
%460 = icmp eq i64 %459, 0
%461 = sub nsw i64 0, %429
br label %462
462: ; preds = %427, %741
%463 = phi i64 [ 0, %427 ], [ %742, %741 ]
%464 = mul i64 %463, %240
%465 = getelementptr double, double* %6, i64 %464
%466 = add i64 %464, %428
%467 = getelementptr double, double* %6, i64 %466
%468 = bitcast double* %467 to i8*
%469 = mul i64 %463, %240
%470 = add i64 %469, %429
%471 = getelementptr double, double* %6, i64 %470
%472 = bitcast double* %471 to i8*
%473 = add i64 %432, %469
%474 = getelementptr double, double* %6, i64 %473
%475 = bitcast double* %474 to i8*
%476 = getelementptr double, double* %6, i64 %469
br i1 %421, label %477, label %597
477: ; preds = %462
%478 = mul nsw i64 %463, %240
br i1 %442, label %557, label %479
479: ; preds = %477
%480 = icmp ult i8* %14, %468
%481 = icmp ult double* %465, %435
%482 = and i1 %480, %481
br i1 %482, label %557, label %483
483: ; preds = %479
br i1 %445, label %537, label %484
484: ; preds = %483, %484
%485 = phi i64 [ %534, %484 ], [ 0, %483 ]
%486 = phi i64 [ %535, %484 ], [ 0, %483 ]
%487 = add nsw i64 %485, %478
%488 = getelementptr inbounds double, double* %6, i64 %487
%489 = bitcast double* %488 to <2 x double>*
%490 = load <2 x double>, <2 x double>* %489
%491 = getelementptr inbounds double, double* %488, i64 2
%492 = bitcast double* %491 to <2 x double>*
%493 = load <2 x double>, <2 x double>* %492
%494 = getelementptr inbounds double, double* %13, i64 %485
%495 = bitcast double* %494 to <2 x double>*
store <2 x double> %490, <2 x double>* %495
%496 = getelementptr inbounds double, double* %494, i64 2
%497 = bitcast double* %496 to <2 x double>*
store <2 x double> %493, <2 x double>* %497
%498 = or i64 %485, 4
%499 = add nsw i64 %498, %478
%500 = getelementptr inbounds double, double* %6, i64 %499
%501 = bitcast double* %500 to <2 x double>*
%502 = load <2 x double>, <2 x double>* %501
%503 = getelementptr inbounds double, double* %500, i64 2
%504 = bitcast double* %503 to <2 x double>*
%505 = load <2 x double>, <2 x double>* %504
%506 = getelementptr inbounds double, double* %13, i64 %498
%507 = bitcast double* %506 to <2 x double>*
store <2 x double> %502, <2 x double>* %507
%508 = getelementptr inbounds double, double* %506, i64 2
%509 = bitcast double* %508 to <2 x double>*
store <2 x double> %505, <2 x double>* %509
%510 = or i64 %485, 8
%511 = add nsw i64 %510, %478
%512 = getelementptr inbounds double, double* %6, i64 %511
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = getelementptr inbounds double, double* %512, i64 2
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = getelementptr inbounds double, double* %13, i64 %510
%519 = bitcast double* %518 to <2 x double>*
store <2 x double> %514, <2 x double>* %519
%520 = getelementptr inbounds double, double* %518, i64 2
%521 = bitcast double* %520 to <2 x double>*
store <2 x double> %517, <2 x double>* %521
%522 = or i64 %485, 12
%523 = add nsw i64 %522, %478
%524 = getelementptr inbounds double, double* %6, i64 %523
%525 = bitcast double* %524 to <2 x double>*
%526 = load <2 x double>, <2 x double>* %525
%527 = getelementptr inbounds double, double* %524, i64 2
%528 = bitcast double* %527 to <2 x double>*
%529 = load <2 x double>, <2 x double>* %528
%530 = getelementptr inbounds double, double* %13, i64 %522
%531 = bitcast double* %530 to <2 x double>*
store <2 x double> %526, <2 x double>* %531
%532 = getelementptr inbounds double, double* %530, i64 2
%533 = bitcast double* %532 to <2 x double>*
store <2 x double> %529, <2 x double>* %533
%534 = add nuw i64 %485, 16
%535 = add nuw i64 %486, 4
%536 = icmp eq i64 %535, %446
br i1 %536, label %537, label %484
537: ; preds = %484, %483
%538 = phi i64 [ 0, %483 ], [ %534, %484 ]
br i1 %447, label %556, label %539
539: ; preds = %537, %539
%540 = phi i64 [ %553, %539 ], [ %538, %537 ]
%541 = phi i64 [ %554, %539 ], [ 0, %537 ]
%542 = add nsw i64 %540, %478
%543 = getelementptr inbounds double, double* %6, i64 %542
%544 = bitcast double* %543 to <2 x double>*
%545 = load <2 x double>, <2 x double>* %544
%546 = getelementptr inbounds double, double* %543, i64 2
%547 = bitcast double* %546 to <2 x double>*
%548 = load <2 x double>, <2 x double>* %547
%549 = getelementptr inbounds double, double* %13, i64 %540
%550 = bitcast double* %549 to <2 x double>*
store <2 x double> %545, <2 x double>* %550
%551 = getelementptr inbounds double, double* %549, i64 2
%552 = bitcast double* %551 to <2 x double>*
store <2 x double> %548, <2 x double>* %552
%553 = add nuw i64 %540, 4
%554 = add i64 %541, 1
%555 = icmp eq i64 %554, %444
br i1 %555, label %556, label %539
556: ; preds = %539, %537
br i1 %448, label %597, label %557
557: ; preds = %479, %477, %556
%558 = phi i64 [ 0, %479 ], [ 0, %477 ], [ %443, %556 ]
%559 = xor i64 %558, -1
%560 = add nsw i64 %559, %428
br i1 %450, label %571, label %561
561: ; preds = %557, %561
%562 = phi i64 [ %568, %561 ], [ %558, %557 ]
%563 = phi i64 [ %569, %561 ], [ 0, %557 ]
%564 = add nsw i64 %562, %478
%565 = getelementptr inbounds double, double* %6, i64 %564
%566 = load double, double* %565
%567 = getelementptr inbounds double, double* %13, i64 %562
store double %566, double* %567
%568 = add nuw nsw i64 %562, 1
%569 = add i64 %563, 1
%570 = icmp eq i64 %569, %449
br i1 %570, label %571, label %561
571: ; preds = %561, %557
%572 = phi i64 [ %558, %557 ], [ %568, %561 ]
%573 = icmp ult i64 %560, 3
br i1 %573, label %597, label %574
574: ; preds = %571, %574
%575 = phi i64 [ %595, %574 ], [ %572, %571 ]
%576 = add nsw i64 %575, %478
%577 = getelementptr inbounds double, double* %6, i64 %576
%578 = load double, double* %577
%579 = getelementptr inbounds double, double* %13, i64 %575
store double %578, double* %579
%580 = add nuw nsw i64 %575, 1
%581 = add nsw i64 %580, %478
%582 = getelementptr inbounds double, double* %6, i64 %581
%583 = load double, double* %582
%584 = getelementptr inbounds double, double* %13, i64 %580
store double %583, double* %584
%585 = add nuw nsw i64 %575, 2
%586 = add nsw i64 %585, %478
%587 = getelementptr inbounds double, double* %6, i64 %586
%588 = load double, double* %587
%589 = getelementptr inbounds double, double* %13, i64 %585
store double %588, double* %589
%590 = add nuw nsw i64 %575, 3
%591 = add nsw i64 %590, %478
%592 = getelementptr inbounds double, double* %6, i64 %591
%593 = load double, double* %592
%594 = getelementptr inbounds double, double* %13, i64 %590
store double %593, double* %594
%595 = add nuw nsw i64 %575, 4
%596 = icmp eq i64 %595, %428
br i1 %596, label %597, label %574
597: ; preds = %571, %574, %556, %462
%598 = tail call i32 @fpsconv(double* %13, i32 %424, double* %22, double* %25, i32 %10, double* %16, double* %19)
br i1 %430, label %599, label %741
599: ; preds = %597
%600 = mul nsw i64 %463, %240
br i1 %451, label %698, label %601
601: ; preds = %599
%602 = icmp ult double* %471, %433
%603 = icmp ult i8* %17, %475
%604 = and i1 %602, %603
%605 = icmp ult double* %471, %434
%606 = icmp ult i8* %20, %475
%607 = and i1 %605, %606
%608 = or i1 %604, %607
%609 = icmp ult double* %476, %433
%610 = icmp ult i8* %17, %472
%611 = and i1 %609, %610
%612 = or i1 %608, %611
%613 = icmp ult double* %476, %434
%614 = icmp ult i8* %20, %472
%615 = and i1 %613, %614
%616 = or i1 %612, %615
br i1 %616, label %698, label %617
617: ; preds = %601
br i1 %455, label %671, label %618
618: ; preds = %617, %618
%619 = phi i64 [ %668, %618 ], [ 0, %617 ]
%620 = phi i64 [ %669, %618 ], [ 0, %617 ]
%621 = add i64 %619, %429
%622 = getelementptr inbounds double, double* %16, i64 %619
%623 = bitcast double* %622 to <2 x double>*
%624 = load <2 x double>, <2 x double>* %623
%625 = getelementptr inbounds double, double* %622, i64 2
%626 = bitcast double* %625 to <2 x double>*
%627 = load <2 x double>, <2 x double>* %626
%628 = add nsw i64 %619, %600
%629 = getelementptr inbounds double, double* %6, i64 %628
%630 = bitcast double* %629 to <2 x double>*
store <2 x double> %624, <2 x double>* %630
%631 = getelementptr inbounds double, double* %629, i64 2
%632 = bitcast double* %631 to <2 x double>*
store <2 x double> %627, <2 x double>* %632
%633 = getelementptr inbounds double, double* %19, i64 %619
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %633, i64 2
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = add nsw i64 %621, %600
%640 = getelementptr inbounds double, double* %6, i64 %639
%641 = bitcast double* %640 to <2 x double>*
store <2 x double> %635, <2 x double>* %641
%642 = getelementptr inbounds double, double* %640, i64 2
%643 = bitcast double* %642 to <2 x double>*
store <2 x double> %638, <2 x double>* %643
%644 = or i64 %619, 4
%645 = add i64 %644, %429
%646 = getelementptr inbounds double, double* %16, i64 %644
%647 = bitcast double* %646 to <2 x double>*
%648 = load <2 x double>, <2 x double>* %647
%649 = getelementptr inbounds double, double* %646, i64 2
%650 = bitcast double* %649 to <2 x double>*
%651 = load <2 x double>, <2 x double>* %650
%652 = add nsw i64 %644, %600
%653 = getelementptr inbounds double, double* %6, i64 %652
%654 = bitcast double* %653 to <2 x double>*
store <2 x double> %648, <2 x double>* %654
%655 = getelementptr inbounds double, double* %653, i64 2
%656 = bitcast double* %655 to <2 x double>*
store <2 x double> %651, <2 x double>* %656
%657 = getelementptr inbounds double, double* %19, i64 %644
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %657, i64 2
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = add nsw i64 %645, %600
%664 = getelementptr inbounds double, double* %6, i64 %663
%665 = bitcast double* %664 to <2 x double>*
store <2 x double> %659, <2 x double>* %665
%666 = getelementptr inbounds double, double* %664, i64 2
%667 = bitcast double* %666 to <2 x double>*
store <2 x double> %662, <2 x double>* %667
%668 = add nuw i64 %619, 8
%669 = add i64 %620, 2
%670 = icmp eq i64 %669, %456
br i1 %670, label %671, label %618
671: ; preds = %618, %617
%672 = phi i64 [ 0, %617 ], [ %668, %618 ]
br i1 %457, label %697, label %673
673: ; preds = %671
%674 = add i64 %672, %429
%675 = getelementptr inbounds double, double* %16, i64 %672
%676 = bitcast double* %675 to <2 x double>*
%677 = load <2 x double>, <2 x double>* %676
%678 = getelementptr inbounds double, double* %675, i64 2
%679 = bitcast double* %678 to <2 x double>*
%680 = load <2 x double>, <2 x double>* %679
%681 = add nsw i64 %672, %600
%682 = getelementptr inbounds double, double* %6, i64 %681
%683 = bitcast double* %682 to <2 x double>*
store <2 x double> %677, <2 x double>* %683
%684 = getelementptr inbounds double, double* %682, i64 2
%685 = bitcast double* %684 to <2 x double>*
store <2 x double> %680, <2 x double>* %685
%686 = getelementptr inbounds double, double* %19, i64 %672
%687 = bitcast double* %686 to <2 x double>*
%688 = load <2 x double>, <2 x double>* %687
%689 = getelementptr inbounds double, double* %686, i64 2
%690 = bitcast double* %689 to <2 x double>*
%691 = load <2 x double>, <2 x double>* %690
%692 = add nsw i64 %674, %600
%693 = getelementptr inbounds double, double* %6, i64 %692
%694 = bitcast double* %693 to <2 x double>*
store <2 x double> %688, <2 x double>* %694
%695 = getelementptr inbounds double, double* %693, i64 2
%696 = bitcast double* %695 to <2 x double>*
store <2 x double> %691, <2 x double>* %696
br label %697
697: ; preds = %671, %673
br i1 %458, label %741, label %698
698: ; preds = %601, %599, %697
%699 = phi i64 [ %429, %601 ], [ %429, %599 ], [ %453, %697 ]
%700 = phi i64 [ 0, %601 ], [ 0, %599 ], [ %452, %697 ]
%701 = xor i64 %700, -1
br i1 %460, label %713, label %702
702: ; preds = %698
%703 = getelementptr inbounds double, double* %16, i64 %700
%704 = load double, double* %703
%705 = add nsw i64 %700, %600
%706 = getelementptr inbounds double, double* %6, i64 %705
store double %704, double* %706
%707 = getelementptr inbounds double, double* %19, i64 %700
%708 = load double, double* %707
%709 = add nsw i64 %699, 1
%710 = add nsw i64 %699, %600
%711 = getelementptr inbounds double, double* %6, i64 %710
store double %708, double* %711
%712 = or i64 %700, 1
br label %713
713: ; preds = %702, %698
%714 = phi i64 [ %699, %698 ], [ %709, %702 ]
%715 = phi i64 [ %700, %698 ], [ %712, %702 ]
%716 = icmp eq i64 %701, %461
br i1 %716, label %741, label %717
717: ; preds = %713, %717
%718 = phi i64 [ %736, %717 ], [ %714, %713 ]
%719 = phi i64 [ %739, %717 ], [ %715, %713 ]
%720 = getelementptr inbounds double, double* %16, i64 %719
%721 = load double, double* %720
%722 = add nsw i64 %719, %600
%723 = getelementptr inbounds double, double* %6, i64 %722
store double %721, double* %723
%724 = getelementptr inbounds double, double* %19, i64 %719
%725 = load double, double* %724
%726 = add nsw i64 %718, 1
%727 = add nsw i64 %718, %600
%728 = getelementptr inbounds double, double* %6, i64 %727
store double %725, double* %728
%729 = add nuw nsw i64 %719, 1
%730 = getelementptr inbounds double, double* %16, i64 %729
%731 = load double, double* %730
%732 = add nsw i64 %729, %600
%733 = getelementptr inbounds double, double* %6, i64 %732
store double %731, double* %733
%734 = getelementptr inbounds double, double* %19, i64 %729
%735 = load double, double* %734
%736 = add nsw i64 %718, 2
%737 = add nsw i64 %726, %600
%738 = getelementptr inbounds double, double* %6, i64 %737
store double %735, double* %738
%739 = add nuw nsw i64 %719, 2
%740 = icmp eq i64 %739, %429
br i1 %740, label %741, label %717
741: ; preds = %713, %717, %697, %597
%742 = add nuw nsw i64 %463, 1
%743 = icmp eq i64 %742, %431
br i1 %743, label %744, label %462
744: ; preds = %741, %420
%745 = add nuw i32 %247, 1
%746 = icmp eq i32 %247, %5
br i1 %746, label %747, label %243
747: ; preds = %744, %234
%748 = tail call i32 @free(double* %13)
%749 = tail call i32 @free(double* %16)
%750 = tail call i32 @free(double* %19)
%751 = tail call i32 @free(double* %22)
%752 = tail call i32 @free(double* %25)
ret void
}